Psychodynamic Personality Matching API Service

Core Frameworks

Key Principle: CCRT + IPC Integration

Luborsky's CCRT provides the content of relational patterns (what people want, expect, and do). The IPC provides the geometric structure (where these patterns live in interpersonal space). By mapping CCRT components onto IPC coordinates, we achieve both clinical depth and mathematical tractability for cosine similarity computation.

3.1 Archetype Dictionary (10 Families)

Each archetype family represents a primary personality organization pattern from Millon's taxonomy, mapped to clinical names and game-universe display names.

3.2 Severity / Intensity Levels (Gacha Rarity Mapping)

4.1 CCRT Components

The Core Conflictual Relationship Theme (Luborsky, 1977) consists of three components extracted from Relationship Episodes (REs) in free text:

4.2 CCRT Standard Categories (Luborsky & Crits-Christoph, 1998)

4.3 Archetype-to-CCRT Mapping

Each archetype has a primary CCRT profile derived from Millon's theoretical descriptions and validated against clinical observation:

5.1 IPC Octant Definitions

The Interpersonal Circumplex (Leary, 1957; Wiggins, 1979) arranges interpersonal behavior along two orthogonal axes: Dominance (vertical: assertive to submissive) and Affiliation (horizontal: hostile to friendly). Eight octants divide the circle:

5.2 Archetype IPC Positions

5.3 IPC Coordinate Conversion

Convert angular position to Cartesian coordinates for vector operations:

function ipcToCartesian(angleDeg, radius = 1.0) {
  const rad = (angleDeg - 90) * (Math.PI / 180);
  return {
    x: Math.cos(rad) * radius,  // Affiliation axis
    y: -Math.sin(rad) * radius  // Dominance axis (inverted for screen)
  };
}

6.1 Complete Subtype Registry (31 Subtypes)

Each Millon subtype modifies the base archetype's CCRT profile with specific shifts in Wish, RO, and RS, along with IPC position adjustments and ideal/worst match pairings at the subtype level.

Schizoid Family (Character: Elias Thorne)

Histrionic Family (Character: Vivienne Lark)

Antisocial/Sadistic Family (Character: Captain Draven)

Compulsive Family (Character: Nyra Solace)

Avoidant Family (Character: Lady Elowen)

Antisocial/Entropic Family (Character: The Void)

7.1 McClelland/Winter Motive System

Three implicit motives (McClelland, 1987; Winter, 1994) are scored from text content and map onto the IPC as angular coordinates:

7.2 Motive-to-IPC Angular Mapping

function motiveToIpcAngle(nAch, nAff, nPow) {
  // Normalize motive scores to unit vectors
  const total = nAch + nAff + nPow || 1;
  const achNorm = nAch / total;
  const affNorm = nAff / total;
  const powNorm = nPow / total;

  // IPC angular centroids for each motive
  const achAngle = 35;   // PA-NO boundary
  const affAngle = 90;   // LM center
  const powAngle = 337;  // PA-BC boundary

  // Weighted angular combination (circular mean)
  const sinSum = achNorm * Math.sin(achAngle * Math.PI/180) +
                affNorm * Math.sin(affAngle * Math.PI/180) +
                powNorm * Math.sin(powAngle * Math.PI/180);
  const cosSum = achNorm * Math.cos(achAngle * Math.PI/180) +
                affNorm * Math.cos(affAngle * Math.PI/180) +
                powNorm * Math.cos(powAngle * Math.PI/180);

  let angle = Math.atan2(sinSum, cosSum) * 180 / Math.PI;
  if (angle < 0) angle += 360;
  const intensity = Math.sqrt(sinSum**2 + cosSum**2);

  return { angle, intensity };
}

12 manipulation patterns scored from text with severity weightings. Used both for safety monitoring and personality profiling (high-severity pattern usage correlates with specific archetype profiles).

9.1 Free Text Analysis Pipeline

The system processes unstructured text through multiple coding passes to extract a personality profile vector:

// Pipeline: Text -> CCRT Extraction -> Motive Scoring -> IPC Positioning -> Vector Construction

function analyzeText(text) {
  const ccrt = extractCCRT(text);           // W, RO, RS category scores
  const motives = scoreMotives(text);        // nAch, nAff, nPow
  const manipulation = detectManipulation(text); // 12-pattern scores
  const traits = scoreMillon(text);          // 10 archetype affinity scores
  const ipc = computeIpcPosition(ccrt, motives, traits);
  const vector = buildPersonalityVector(ccrt, motives, manipulation, traits, ipc);
  return { ccrt, motives, manipulation, traits, ipc, vector };
}

9.2 CCRT Extraction from Free Text

function extractCCRT(text) {
  const lower = text.toLowerCase();
  const scores = { W: {}, RO: {}, RS: {} };

  // Score each CCRT category by dictionary marker frequency
  for (const [code, markers] of Object.entries(CCRT_DICTIONARY.W)) {
    scores.W[code] = markers.reduce((sum, m) => {
      const regex = new RegExp(m, 'gi');
      return sum + (lower.match(regex) || []).length;
    }, 0);
  }
  // ... same for RO and RS

  // Normalize to probability distribution
  const normalize = (obj) => {
    const total = Object.values(obj).reduce((s, v) => s + v, 0) || 1;
    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v / total]));
  };

  return {
    W: normalize(scores.W),
    RO: normalize(scores.RO),
    RS: normalize(scores.RS),
    primaryW: argmax(scores.W),
    primaryRO: argmax(scores.RO),
    primaryRS: argmax(scores.RS)
  };
}

9.3 Millon Archetype Affinity Scoring

const MILLON_DICTIONARY = {
  NARCISSISTIC: {
    markers: ["special", "superior", "admire", "entitled", "grandiose",
              "beneath me", "deserve", "best", "unique", "exceptional",
              "envy", "mirror", "display", "recognition", "status"],
    weight: 1.0,
    ipcAngle: 350
  },
  DEPENDENT: {
    markers: ["need you", "can't without", "please don't leave", "take care of",
              "helpless", "cling", "approval", "abandoned", "reassure",
              "support me", "guide me", "protect", "rely on", "lost without"],
    weight: 1.0,
    ipcAngle: 200
  },
  BORDERLINE: {
    markers: ["love you hate you", "don't leave", "you're perfect", "you're terrible",
              "splitting", "empty", "abandon", "rage", "unstable",
              "intense", "self-harm", "all or nothing", "idealize", "devalue"],
    weight: 1.0,
    ipcAngle: null
  },
  HISTRIONIC: {
    markers: ["attention", "notice me", "dramatic", "exciting", "theatrical",
              "performance", "center", "spotlight", "charming", "seductive",
              "vivacious", "expressive", "flamboyant", "impression"],
    weight: 1.0,
    ipcAngle: 70
  },
  AVOIDANT: {
    markers: ["reject", "humiliate", "withdraw", "shy", "afraid",
              "inadequate", "avoid", "sensitive", "exposed", "criticize",
              "self-conscious", "judged", "inferior", "retreat"],
    weight: 1.0,
    ipcAngle: 230
  },
  SCHIZOID: {
    markers: ["alone", "solitude", "detach", "flat", "indifferent",
              "cold", "emotionless", "withdrawn", "inner world", "numb",
              "unmoved", "mechanical", "dispassionate", "void"],
    weight: 1.0,
    ipcAngle: 250
  },
  ANTISOCIAL: {
    markers: ["exploit", "manipulate", "dominate", "predator", "ruthless",
              "no remorse", "use", "discard", "con", "deceive",
              "rules don't apply", "victim", "prey", "entitled"],
    weight: 1.0,
    ipcAngle: 315
  },
  PARANOID: {
    markers: ["trust", "betray", "suspicious", "watching", "plot",
              "conspiracy", "deceive", "hidden agenda", "vigilant", "threat",
              "hostile", "guarded", "secret", "spying"],
    weight: 1.0,
    ipcAngle: 330
  },
  OBSESSIVE_COMPULSIVE: {
    markers: ["perfect", "order", "control", "rules", "correct",
              "precise", "clean", "organize", "standard", "rigid",
              "proper", "discipline", "systematic", "duty"],
    weight: 1.0,
    ipcAngle: 20
  },
  PASSIVE_AGGRESSIVE: {
    markers: ["fine", "whatever", "I guess", "if you say so", "sure",
              "forget it", "not my problem", "sabotage", "procrastinate",
              "backhanded", "comply then undermine", "sarcastic", "resentful"],
    weight: 1.0,
    ipcAngle: 210
  }
};

function scoreMillon(text) {
  const lower = text.toLowerCase();
  const scores = {};
  for (const [archetype, config] of Object.entries(MILLON_DICTIONARY)) {
    scores[archetype] = config.markers.reduce((sum, m) => {
      return sum + (lower.includes(m.toLowerCase()) ? config.weight : 0);
    }, 0);
  }
  // Normalize
  const total = Object.values(scores).reduce((s, v) => s + v, 0) || 1;
  return Object.fromEntries(Object.entries(scores).map(([k, v]) => [k, v / total]));
}

10.1 Personality Vector Construction

Each person's personality is represented as a high-dimensional vector in a unified space combining CCRT, motive, manipulation, and archetype scores. The a priori factor selection uses dimensions that map onto the IPC's geometric structure.

Vector Dimensions (49 total)

Total: 49-dimensional personality vector

10.2 Prototype Vectors (Ideal & Worst Match)

For each archetype, we construct an Ideal Match Prototype Vector and a Worst Match Prototype Vector by aggregating the CCRT, IPC, and motive profiles of their ideal/worst match archetypes:

function buildPrototypeVector(archetypeId, matchType) {
  const ccrt = ARCHETYPE_CCRT[archetypeId];
  const matches = matchType === 'ideal' ? ccrt.idealMatch : ccrt.worstMatch;

  // Average the IPC positions of all ideal/worst matches
  const vectors = matches.map(m => buildArchetypeVector(m));
  return averageVectors(vectors);
}

function buildArchetypeVector(archetypeId) {
  const ccrt = ARCHETYPE_CCRT[archetypeId];
  const ipc = IPC_POSITIONS[archetypeId];
  const vec = new Array(49).fill(0);

  // Map CCRT W to primary wish dimension
  const wishMap = mapWishToCategory(ccrt.wish);
  vec[wishMap.index] = 1.0;

  // Map RO and RS
  const roMap = mapROToCategory(ccrt.responseOfOther);
  vec[14 + roMap.index] = 1.0;
  const rsMap = mapRSToCategory(ccrt.responseOfSelf);
  vec[24 + rsMap.index] = 1.0;

  // IPC coordinates normalized to [-1, 1]
  vec[37] = (ipc?.dominance || 0) / 3;
  vec[38] = (ipc?.affiliation || 0) / 3;

  // Archetype affinity (one-hot for pure archetype)
  const archetypeIndex = ARCHETYPE_ORDER.indexOf(archetypeId);
  vec[39 + archetypeIndex] = 1.0;

  return vec;
}

10.3 Cosine Similarity

function cosineSimilarity(vecA, vecB) {
  let dotProduct = 0, normA = 0, normB = 0;
  for (let i = 0; i < vecA.length; i++) {
    dotProduct += vecA[i] * vecB[i];
    normA += vecA[i] ** 2;
    normB += vecB[i] ** 2;
  }
  if (normA === 0 || normB === 0) return 0;
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

function cosineDissimilarity(vecA, vecB) {
  return 1 - cosineSimilarity(vecA, vecB);
}

11.1 The Core Matching Formula

The match percentage between two users A and B is computed bidirectionally, combining similarity to ideal match with dissimilarity from worst match:

const profileA = analyzeText(textA);  // 49-dim vector
const profileB = analyzeText(textB);  // 49-dim vector

const primaryA = argmax(profileA.traits);  // e.g., 'NARCISSISTIC'
const primaryB = argmax(profileB.traits);  // e.g., 'DEPENDENT'

const idealA = buildPrototypeVector(primaryA, 'ideal');
const worstA = buildPrototypeVector(primaryA, 'worst');
const idealB = buildPrototypeVector(primaryB, 'ideal');
const worstB = buildPrototypeVector(primaryB, 'worst');

// How well does B match A's ideal? (A's perspective)
const simToIdealA = cosineSimilarity(profileB.vector, idealA);
const simToWorstA = cosineSimilarity(profileB.vector, worstA);

// Directional score A->B: similarity to ideal minus similarity to worst
// Rescaled to 0-100
const dirScoreAB = ((simToIdealA - simToWorstA + 1) / 2) * 100;

// How well does A match B's ideal? (B's perspective)
const simToIdealB = cosineSimilarity(profileA.vector, idealB);
const simToWorstB = cosineSimilarity(profileA.vector, worstB);

const dirScoreBA = ((simToIdealB - simToWorstB + 1) / 2) * 100;

// Geometric mean preserves the "both must match" requirement
// If A loves B but B hates A, geometric mean penalizes more than arithmetic
const matchPercent = Math.sqrt(dirScoreAB * dirScoreBA);

// Alternative: weighted arithmetic mean (adjustable alpha)
// const alpha = 0.5;
// const matchPercent = alpha * dirScoreAB + (1 - alpha) * dirScoreBA;

11.2 Complete Match Function

function computeMatch(textA, textB) {
  // 1. Extract profiles
  const profileA = analyzeText(textA);
  const profileB = analyzeText(textB);

  // 2. Primary archetypes
  const primaryA = argmax(profileA.traits);
  const primaryB = argmax(profileB.traits);

  // 3. Build prototypes
  const idealA = buildPrototypeVector(primaryA, 'ideal');
  const worstA = buildPrototypeVector(primaryA, 'worst');
  const idealB = buildPrototypeVector(primaryB, 'ideal');
  const worstB = buildPrototypeVector(primaryB, 'worst');

  // 4. Directional scores
  const simIdealA = cosineSimilarity(profileB.vector, idealA);
  const simWorstA = cosineSimilarity(profileB.vector, worstA);
  const dirAB = ((simIdealA - simWorstA + 1) / 2) * 100;

  const simIdealB = cosineSimilarity(profileA.vector, idealB);
  const simWorstB = cosineSimilarity(profileA.vector, worstB);
  const dirBA = ((simIdealB - simWorstB + 1) / 2) * 100;

  // 5. Bidirectional geometric mean
  const matchPercent = Math.round(Math.sqrt(Math.max(0, dirAB) * Math.max(0, dirBA)));

  // 6. IPC angular distance for additional context
  const ipcA = IPC_POSITIONS[primaryA];
  const ipcB = IPC_POSITIONS[primaryB];
  let angularDist = null;
  if (ipcA?.angle != null && ipcB?.angle != null) {
    angularDist = Math.abs(ipcA.angle - ipcB.angle);
    if (angularDist > 180) angularDist = 360 - angularDist;
  }

  // 7. Check for collusive bond
  const collusiveBond = COLLUSIVE_BONDS.find(b =>
    (b.pair[0] === primaryA && b.pair[1] === primaryB) ||
    (b.pair[0] === primaryB && b.pair[1] === primaryA)
  );

  return {
    matchPercent,
    dirScoreAB: Math.round(dirAB),
    dirScoreBA: Math.round(dirBA),
    profileA: { primary: primaryA, ccrt: profileA.ccrt, motives: profileA.motives },
    profileB: { primary: primaryB, ccrt: profileB.ccrt, motives: profileB.motives },
    angularDistance: angularDist,
    collusiveBond: collusiveBond || null,
    manipulationRiskA: profileA.manipulation.severityScore,
    manipulationRiskB: profileB.manipulation.severityScore,
    compatibility: getCompatibility(primaryA, primaryB)
  };
}

11.3 Collusive Bond Detection

12.1 Automated Clinical Progress Note from CCRT Analysis

function writeCCRTProgressNote(profile, sessionNumber) {
  const { ccrt, traits, motives, manipulation, ipc } = profile;
  const primary = argmax(traits);
  const archCcrt = ARCHETYPE_CCRT[primary];

  const note = {
    header: {
      date: new Date().toISOString().split('T')[0],
      session: sessionNumber,
      format: 'CCRT Progress Note (Luborsky Method)'
    },
    presenting: {
      primaryArchetype: primary,
      displayName: ARCHETYPE_DISPLAY_NAMES[primary],
      ipcPosition: `${ipc.octant} (${ipc.angle}°)`,
      dominance: ipc.dominance,
      affiliation: ipc.affiliation
    },
    ccrtFormulation: {
      primaryWish: `W: ${ccrt.primaryW} — ${archCcrt.wish}`,
      responseOfOther: `RO: ${ccrt.primaryRO} — ${archCcrt.responseOfOther}`,
      responseOfSelf: `RS: ${ccrt.primaryRS} — ${archCcrt.responseOfSelf}`,
      ccrtNarrative: generateCCRTNarrative(primary, ccrt)
    },
    motiveProfile: {
      achievement: (motives.nAch * 100).toFixed(1) + '%',
      affiliation: (motives.nAff * 100).toFixed(1) + '%',
      power: (motives.nPow * 100).toFixed(1) + '%'
    },
    manipulationFlags: {
      totalScore: manipulation.severityScore,
      criticalPatterns: manipulation.criticalPatterns.map(p => p.pattern),
      highPatterns: manipulation.highPatterns.map(p => p.pattern)
    },
    relationalPrognosis: {
      idealMatch: archCcrt.idealMatch.join(', '),
      idealReason: archCcrt.idealReason,
      riskMatch: archCcrt.worstMatch.join(', '),
      riskReason: archCcrt.worstReason
    },
    clinicalImpressions: generateClinicalImpressions(primary, ccrt, motives)
  };

  return note;
}

function generateCCRTNarrative(archetype, ccrt) {
  const a = ARCHETYPE_CCRT[archetype];
  return `The subject's predominant relational theme reflects a ${archetype.toLowerCase()} ` +
    `personality organization. Core wish centers on: "${a.wish}". ` +
    `Anticipated response from others: "${a.responseOfOther}". ` +
    `Characteristic self-response pattern: "${a.responseOfSelf}". ` +
    `This CCRT formulation suggests a relational cycle where the wish ` +
    `organizes both perception of others and defensive self-responses, ` +
    `creating a self-reinforcing interpersonal pattern consistent with ` +
    `the ${archetype.toLowerCase()} prototype.`;
}

function generateClinicalImpressions(archetype, ccrt, motives) {
  const impressions = [];

  // Motive balance assessment
  if (motives.nPow > 0.5) {
    impressions.push('Elevated power motivation suggests dominance-seeking behavior patterns.');
  }
  if (motives.nAff > 0.5) {
    impressions.push('Strong affiliative motivation; relational needs may drive decision-making.');
  }
  if (motives.nAch > 0.5) {
    impressions.push('Achievement orientation prominent; standards and performance are central.');
  }

  // IPC position assessment
  const ipc = IPC_POSITIONS[archetype];
  if (ipc?.dominance >= 2) {
    impressions.push('IPC positioning indicates high interpersonal dominance.');
  } else if (ipc?.dominance <= -2) {
    impressions.push('IPC positioning indicates pronounced submissiveness.');
  }
  if (ipc?.affiliation <= -2) {
    impressions.push('Low affiliation score suggests interpersonal coldness or hostility.');
  }

  return impressions;
}

12.2 Progress Note Output Format

CCRT PROGRESS NOTE
==================
Date: 2026-02-28
Session: 1
Format: CCRT Progress Note (Luborsky Method)

PRESENTING PROFILE
  Primary Archetype: NARCISSISTIC (The Emperor)
  IPC Position: PA (350°) | Dominance: +3 | Affiliation: -1

CCRT FORMULATION
  W:  To be admired, to be special, to be superior
  RO: Others admire OR humiliate
  RS: Grandiose inflation OR narcissistic rage

  Narrative: The subject's predominant relational theme reflects a
  narcissistic personality organization. Core wish centers on: "To
  be admired, to be special, to be superior". Anticipated response
  from others: "Others admire OR humiliate". This CCRT formulation
  suggests a relational cycle where the wish organizes both perception
  of others and defensive self-responses.

MOTIVE PROFILE
  Achievement: 15.2%
  Affiliation: 8.3%
  Power: 76.5%

MANIPULATION FLAGS
  Total Score: 7
  Critical: [gaslighting]
  High: [loveBombing]

RELATIONAL PROGNOSIS
  Ideal Match: DEPENDENT, HISTRIONIC
  Reason: Dependent provides narcissistic supply without competition.
  Risk Match: NARCISSISTIC, PARANOID
  Reason: Two narcissists create a mirrorless void.

CLINICAL IMPRESSIONS
  - Elevated power motivation suggests dominance-seeking behavior.
  - IPC positioning indicates high interpersonal dominance.
    

13.1 Approach: Dictionary-Based Semantic Scoring

The semantic similarity engine operates at two levels: (1) dictionary-based keyword matching for CCRT/motive/archetype scoring, and (2) embedding-based similarity for nuanced free-text comparison when an embedding API is available.

13.2 Dictionary-Based Semantic Vector

function buildSemanticVector(text) {
  const ccrt = extractCCRT(text);
  const motives = scoreMotives(text);
  const traits = scoreMillon(text);
  const manipulation = detectManipulation(text);

  // Construct 49-dimensional vector
  const vec = [];

  // CCRT Wish (14 dims, normalized probabilities)
  for (let i = 1; i <= 14; i++) vec.push(ccrt.W[`W${i}`] || 0);

  // CCRT RO (10 dims)
  for (let i = 1; i <= 10; i++) vec.push(ccrt.RO[`RO${i}`] || 0);

  // CCRT RS (10 dims)
  for (let i = 1; i <= 10; i++) vec.push(ccrt.RS[`RS${i}`] || 0);

  // Motives (3 dims)
  vec.push(motives.nAch, motives.nAff, motives.nPow);

  // IPC position (2 dims) — derived from weighted archetype positions
  let domSum = 0, affSum = 0, totalWeight = 0;
  for (const [arch, score] of Object.entries(traits)) {
    const pos = IPC_POSITIONS[arch];
    if (pos && pos.angle !== null) {
      domSum += pos.dominance * score;
      affSum += pos.affiliation * score;
      totalWeight += score;
    }
  }
  vec.push(totalWeight ? domSum / totalWeight / 3 : 0);
  vec.push(totalWeight ? affSum / totalWeight / 3 : 0);

  // Archetype affinity (10 dims)
  const archetypeOrder = ['NARCISSISTIC', 'DEPENDENT', 'BORDERLINE', 'HISTRIONIC',
    'AVOIDANT', 'SCHIZOID', 'ANTISOCIAL', 'PARANOID',
    'OBSESSIVE_COMPULSIVE', 'PASSIVE_AGGRESSIVE'];
  for (const arch of archetypeOrder) {
    vec.push(traits[arch] || 0);
  }

  return vec;
}

13.3 Embedding-Enhanced Similarity (Optional)

// When an embedding API is available (e.g., OpenAI, Anthropic),
// use it to compute a dense semantic embedding of the full text,
// then combine with the dictionary-based vector

async function hybridSimilarity(textA, textB, embeddingApi) {
  // Dictionary-based vectors
  const dictVecA = buildSemanticVector(textA);
  const dictVecB = buildSemanticVector(textB);
  const dictSim = cosineSimilarity(dictVecA, dictVecB);

  // Embedding-based similarity (if API available)
  let embSim = 0;
  if (embeddingApi) {
    const embA = await embeddingApi.embed(textA);
    const embB = await embeddingApi.embed(textB);
    embSim = cosineSimilarity(embA, embB);
  }

  // Weighted combination (dictionary is primary, embedding is secondary)
  const alpha = embeddingApi ? 0.6 : 1.0;
  return alpha * dictSim + (1 - alpha) * embSim;
}

16.1 A Priori Factor Selection Rationale

The 49-dimensional personality vector uses a priori selected factors based on established psychometric instruments. Each block maps to validated constructs:

16.2 Confirmatory Factor Analysis Protocol

// Recommended CFA model specification for empirical validation
// Use lavaan (R) or Mplus syntax

// Model 1: CCRT 3-factor structure
//   Wish =~ W1 + W2 + ... + W14
//   RO =~ RO1 + RO2 + ... + RO10
//   RS =~ RS1 + RS2 + ... + RS10
// Expected fit: CFI >= 0.90, RMSEA <= 0.08, SRMR <= 0.08

// Model 2: IPC circumplex structure
//   Dominance =~ PA + BC + NO - HI - JK - FG
//   Affiliation =~ LM + NO + JK - BC - DE - FG
// Test circularity: equal spacing, equal communalities

// Model 3: Archetype discrimination
//   10 archetype factors should show discriminant validity
//   Average Variance Extracted (AVE) >= 0.50 for each
//   Heterotrait-Monotrait ratio (HTMT) < 0.85 between pairs

16.3 Daubert Defensibility