ei-tui 1.7.0 → 1.8.0

package/src/cli/install.ts

@@ -140,6 +140,22 @@ export async function installMcpClients(): Promise<void> {
     console.log(`ℹ️  OMP not detected — skipping OMP extension install.`);
   }
 
+  // Shared, spec-standard skill discovery directory that Cursor, Codex, and
+  // base Pi (non-OMP) each independently walk up looking for
+  // (~/.agents/skills/<name>/SKILL.md) — unconditional because, unlike the
+  // harness-specific steps above, it needs no per-tool detection: every tool
+  // that reads it does so regardless of what else is installed on the machine.
+  // Claude Code, OMP, and OpenCode do NOT read this path — they keep their own
+  // installSkillsTo() calls inside installClaudeCode()/installOmp()/
+  // installOpenCodePlugin() untouched.
+  if (
+    !(await runInstallStep("Shared skills directory (~/.agents/skills)", () =>
+      installSkillsTo(join(home, ".agents", "skills"))
+    ))
+  ) {
+    failures.push("Shared skills directory");
+  }
+
   if (failures.length > 0) {
     throw new Error(
       `${failures.length} integration(s) failed to install: ${failures.join(", ")}. See warnings above for details.`,
@@ -172,29 +188,49 @@ function hookEntryHasCommand(entry: unknown, command: string): boolean {
   });
 }
 
-async function installCodex(): Promise<void> {
-  const dataPath = process.env.EI_DATA_PATH ?? join(resolveHome(), ".local", "share", "ei");
-  const proc = Bun.spawn(
-    ["codex", "mcp", "add", "ei", "--env", `EI_DATA_PATH=${dataPath}`, "--", "bunx", "ei-tui", "mcp"],
-    {
+export async function installCodex(): Promise<void> {
+  const home = resolveHome();
+  const configPath = join(home, ".codex", "config.toml");
+
+  // `codex mcp remove <name>` verified as a real subcommand (`codex mcp
+  // --help`, `codex mcp remove --help`) against codex-cli 0.142.3 —
+  // symmetric with the `codex mcp add` call this replaces. It rewrites
+  // ~/.codex/config.toml itself, so we don't hand-roll a TOML writer here;
+  // we only pre-check the file (via Bun's built-in TOML parser) to decide
+  // whether there's anything to remove, so a no-op run never touches —
+  // or lets the codex CLI reformat — the file at all.
+  let hasEiEntry = false;
+  try {
+    const text = await Bun.file(configPath).text();
+    const parsed = Bun.TOML.parse(text) as { mcp_servers?: Record<string, unknown> };
+    hasEiEntry = Boolean(parsed?.mcp_servers?.ei);
+  } catch {
+    // File doesn't exist, or isn't valid TOML — nothing to remove.
+  }
+
+  if (!hasEiEntry) {
+    console.log(`ℹ️  Ei MCP already absent from ${configPath} — nothing to remove.`);
+  } else {
+    const proc = Bun.spawn(["codex", "mcp", "remove", "ei"], {
       stdout: "pipe",
       stderr: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+
+    if (exitCode !== 0) {
+      console.warn(`⚠️  Codex MCP removal failed.`);
+      const detail = (stderr || stdout).trim();
+      if (detail) console.warn(`   ${detail}`);
+    } else {
+      console.log(
+        `✓ Removed Ei MCP server registration from ${configPath} (skills now cover this capability; MCP remains available via manual setup — see README).`
+      );
     }
-  );
-
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-
-  if (exitCode !== 0) {
-    console.warn(`⚠️  Codex MCP install failed.`);
-    const detail = (stderr || stdout).trim();
-    if (detail) console.warn(`   ${detail}`);
-  } else {
-    console.log(`✓ Installed Ei MCP server to Codex config (~/.codex/config.toml)`);
-    console.log(`  Restart Codex to activate MCP.`);
   }
 
   await installCodexHooks();
@@ -315,36 +351,34 @@ export async function installClaudeCode(): Promise<void> {
   const home = resolveHome();
   const claudeJsonPath = join(home, ".claude.json");
 
-  // Claude Code supports ${VAR} substitution in env values, resolved from its
-  // own environment at spawn time — so the value stays fresh if EI_DATA_PATH changes.
-  const mcpEntry: Record<string, unknown> = {
-    type: "stdio",
-    command: "bunx",
-    args: ["ei-tui", "mcp"],
-    env: { EI_DATA_PATH: "${EI_DATA_PATH}" },
-  };
-
-  // Direct atomic write — we need full control over the config structure to
-  // write the env field. `claude mcp add` doesn't support env vars.
+  // Direct config edit — matches the atomic-write pattern the original
+  // registration used, but inverted: remove the "ei" entry instead of
+  // adding one. Every other key/entry in the file is left untouched.
   let config: Record<string, unknown> = {};
   try {
     const text = await Bun.file(claudeJsonPath).text();
     config = JSON.parse(text) as Record<string, unknown>;
   } catch {
-    // File doesn't exist or isn't valid JSON — start fresh
+    // File doesn't exist or isn't valid JSON — nothing to remove.
   }
 
-  const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
-  mcpServers["ei"] = mcpEntry;
-  config.mcpServers = mcpServers;
+  const mcpServers = config.mcpServers;
+  const hasEiEntry = typeof mcpServers === "object" && mcpServers !== null && "ei" in mcpServers;
 
-  // Atomic write: write to temp file then rename to avoid partial writes
-  const tmpPath = `${claudeJsonPath}.ei-install.tmp`;
-  await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
-  await rename(tmpPath, claudeJsonPath);
+  if (!hasEiEntry) {
+    console.log(`ℹ️  Ei MCP already absent from ${claudeJsonPath} — nothing to remove.`);
+  } else {
+    delete (mcpServers as Record<string, unknown>)["ei"];
 
-  console.log(`✓ Installed Ei MCP server to ${claudeJsonPath}`);
-  console.log(`  Restart Claude Code to activate.`);
+    // Atomic write: write to temp file then rename to avoid partial writes
+    const tmpPath = `${claudeJsonPath}.ei-install.tmp`;
+    await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
+    await rename(tmpPath, claudeJsonPath);
+
+    console.log(
+      `✓ Removed Ei MCP server registration from ${claudeJsonPath} (skills now cover this capability; MCP remains available via manual setup — see README).`
+    );
+  }
 
   await installClaudeCodeHooks();
 
@@ -435,37 +469,37 @@ The following items MAY be relevant to your current task — use \\\`ei_search\\
   console.log(`✓ Installed Ei context hook to ~/.claude/hooks/ei-inject.ts`);
 }
 
-async function installCursor(): Promise<void> {
+export async function installCursor(): Promise<void> {
   const home = resolveHome();
   const cursorJsonPath = join(home, ".cursor", "mcp.json");
 
-  // Cursor does not support ${VAR} substitution in mcp.json — literal values only.
-  const mcpEntry: Record<string, unknown> = {
-    type: "stdio",
-    command: "bunx",
-    args: ["ei-tui", "mcp"],
-    env: { EI_DATA_PATH: process.env.EI_DATA_PATH ?? "" },
-  };
-
+  // Direct config edit — matches the atomic-write pattern the original
+  // registration used, but inverted: remove the "ei" entry instead of
+  // adding one. Every other key/entry in the file is left untouched.
   let config: Record<string, unknown> = {};
   try {
     const text = await Bun.file(cursorJsonPath).text();
     config = JSON.parse(text) as Record<string, unknown>;
   } catch {
-    // File doesn't exist or isn't valid JSON — start fresh
+    // File doesn't exist or isn't valid JSON — nothing to remove.
   }
 
-  const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
-  mcpServers["ei"] = mcpEntry;
-  config.mcpServers = mcpServers;
+  const mcpServers = config.mcpServers;
+  const hasEiEntry = typeof mcpServers === "object" && mcpServers !== null && "ei" in mcpServers;
+
+  if (!hasEiEntry) {
+    console.log(`ℹ️  Ei MCP already absent from ${cursorJsonPath} — nothing to remove.`);
+  } else {
+    delete (mcpServers as Record<string, unknown>)["ei"];
 
-  await Bun.$`mkdir -p ${join(home, ".cursor")}`;
-  const tmpPath = `${cursorJsonPath}.ei-install.tmp`;
-  await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
-  await rename(tmpPath, cursorJsonPath);
+    const tmpPath = `${cursorJsonPath}.ei-install.tmp`;
+    await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
+    await rename(tmpPath, cursorJsonPath);
 
-  console.log(`✓ Installed Ei MCP server to ${cursorJsonPath}`);
-  console.log(`  Restart Cursor to activate.`);
+    console.log(
+      `✓ Removed Ei MCP server registration from ${cursorJsonPath} (skills now cover this capability; MCP remains available via manual setup — see README).`
+    );
+  }
 
   await installCursorHooks();
 }

package/src/cli/mcp.ts

@@ -20,14 +20,14 @@ export function createMcpServer(): McpServer {
     "ei_search",
     {
       description:
-        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Use at session start to load user context, and mid-session whenever the user references past work, preferences, or people. Returns facts, people, topics of interest, quotes, and personas. TYPE GUIDANCE: 'facts' are ONLY user demographics (name, age, job title, location, family structure, physical traits). For interests, opinions, hobbies, or anything the human cares about, use 'topics'. For named individuals, use 'people'. For verbatim things said, use 'quotes'. For AI agent identities with traits and working style, use 'personas'. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Persona results include traits and topics — use type='personas' with the persona's name OR a natural-language description of their role to load a persona's character sheet. Results include entity IDs that can be passed to ei_lookup for full detail. Omit query with recent=true to browse the most recently discussed items.",
+        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Use at session start to load user context, and mid-session whenever the user references past work, preferences, or people. Balanced search (no type filter) returns facts, people, topics of interest, and quotes — personas are excluded unless you pass type: \"personas\" explicitly. TYPE GUIDANCE: 'facts' are ONLY user demographics (name, age, job title, location, family structure, physical traits). For interests, opinions, hobbies, or anything the human cares about, use 'topics'. For named individuals, use 'people'. For verbatim things said, use 'quotes'. For AI agent identities with traits and working style, use 'personas'. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Persona results include traits and topics — use type='personas' with the persona's name OR a natural-language description of their role to load a persona's character sheet. Results include entity IDs that can be passed to ei_lookup for full detail. Omit query with recent=true to browse the most recently discussed items.",
       inputSchema: {
         query: z.string().optional().describe("Search text. Supports natural language. Omit to browse without semantic filtering — useful with recent=true or persona filter."),
         type: z
           .enum(["facts", "people", "topics", "quotes", "personas"])
           .optional()
           .describe(
-            "Filter to a specific data type. Omit to search all types (balanced across all 5). For 'personas': matches by display name first, then falls back to semantic search of persona descriptions — use the persona's name (e.g. 'Sisyphus') or a description of their role (e.g. 'primary coding agent'). For 'people': semantic search on person descriptions. Note: 'personas' and 'people' are distinct — personas are AI agent identity records with traits/topics; people are human contacts."
+            "Filter to a specific data type. Omit to search a balanced set across facts, people, topics, and quotes — personas are excluded from that balanced set and require passing type: \"personas\" explicitly. For 'personas': matches by display name first, then falls back to semantic search of persona descriptions — use the persona's name (e.g. 'Sisyphus') or a description of their role (e.g. 'primary coding agent'). For 'people': semantic search on person descriptions. Note: 'personas' and 'people' are distinct — personas are AI agent identity records with traits/topics; people are human contacts."
           ),
         persona: z
           .string()

package/src/cli/persona-corrections.ts

@@ -97,7 +97,7 @@ const personaTopicSchema = z.strictObject({
 });
 
 // No minimum trait/topic count is enforced here on purpose — that floor
-// (coding-harness-reflect's "3 traits minimum") exists only as skill-level
+// (ei-reflect's "3 traits minimum") exists only as skill-level
 // AGENT guidance today, not a server-side gate, so a single "add one trait"
 // edit is never blocked.
 const personaEntitySchema = z.strictObject({

package/src/cli/retrieval.ts

@@ -628,3 +628,30 @@ export async function lookupById(id: string): Promise<({ type: string } & Record
   }
   return { type, ...withoutEmbedding };
 }
+
+// Reverse lookup for the `Person.identifiers[]` array: mirrors
+// StateManager#human_person_getByIdentifier's exact matching semantics
+// (case-insensitive `type`, exact `value`; `type` is a user-extensible
+// string like "Ei Persona" or "GitHub", not an enum) so a caller who only
+// has a (type, value) pair — e.g. a Persona record's linked human identity —
+// can resolve straight to the same enriched shape `lookupById` returns.
+// Like the StateManager method it mirrors, this returns the FIRST matching
+// Person and does not change that first-match behavior — safe for identifier
+// types that are unique by construction (e.g. "Ei Persona", a UUID assigned
+// once per persona), but arbitrary if more than one Person shares a value
+// under a type that isn't guaranteed unique (e.g. "Nickname", "First Name").
+// Delegating to lookupById reuses all of its enrichment (embedding
+// stripping, linked_quotes) with zero duplication; this does mean
+// loadLatestState() is called twice on the not-found-then-found path,
+// consistent with every other exported function in this file already
+// calling it independently.
+export async function lookupByIdentifier(type: string, value: string): Promise<({ type: string } & Record<string, unknown>) | null> {
+  const state = await loadLatestState();
+  if (!state) return null;
+  const typeLower = type.toLowerCase();
+  const person = state.human.people.find(p =>
+    p.identifiers?.some(i => i.type.toLowerCase() === typeLower && i.value === value)
+  );
+  if (!person) return null;
+  return lookupById(person.id);
+}

package/src/cli.ts

@@ -12,7 +12,7 @@
  */
 
 import { parseArgs } from "util";
-import { retrieveBalanced, lookupById, resolveExternalMessage, loadLatestState } from "./cli/retrieval";
+import { retrieveBalanced, lookupById, lookupByIdentifier, resolveExternalMessage, loadLatestState } from "./cli/retrieval";
 import type { StorageState } from "./core/types";
 import { resolvePersonaId, filterByPersona, filterTypeSpecificByPersona, filterBySource, filterTypeSpecificBySource } from "./cli/persona-filter.js";
 import { installMcpClients } from "./cli/install.js";
@@ -80,7 +80,7 @@ Ei
 
 Usage:
   ei                            Launch the TUI chat interface
-  ei "search text"              Search all data types (top 10)
+  ei "search text"              Balanced search: facts/people/topics/quotes, no personas (top 10; use "ei personas")
   ei -n 5 "search text"         Limit results
   ei <type> "search text"       Search a specific data type
   ei <type> -n 5 "search text"  Type-specific with limit
@@ -90,6 +90,7 @@ Usage:
   ei --persona "Name" "query"   Filter results to what a persona has learned
   ei --id <id>                  Look up a specific entity by ID
   echo <id> | ei --id           Look up entity by ID from stdin
+  ei --identifier <type> <value>  Look up a person by identifier type + value, e.g. --identifier "GitHub" "flare576"
   ei mcp                        Start the Ei MCP stdio server (for Claude Code/Cursor/Codex)
   ei create <type> --json '<json>'  Create a new entity (fact/topic/person/persona)
   ei update <type> <id> --json '<json>'  Replace an entity by ID (full record, not a patch; fact/topic/person/quote/persona)
@@ -108,7 +109,8 @@ Options:
   --persona, -p       Filter to entities a specific persona has learned about
   --source, -s        Filter to entities from a specific source (prefix match, e.g. "cursor", "codex:my-machine", "opencode:my-machine:ses_abc123")
   --id                Look up entity by ID (accepts value or stdin)
-  --install           Register Ei with Claude Code, Cursor, Codex, and OpenCode (MCP + context hooks + skills where supported)
+  --identifier <type> <value>  Look up a person by identifier type + value (case-insensitive type, exact value; no stdin support)
+  --install           Register Ei with Claude Code, Cursor, Codex, and OpenCode (skills + context hooks where supported; MCP is removed by default on Claude Code/Cursor/Codex — see README for manual MCP setup)
   --sync              Pull latest state from remote sync server into state.backup.json (no TUI required)
   --session <id>      Session ID to enrich the query with recent context (use with --hook-source)
   --hook-source <src> Source of the hook: "opencode-plugin" (OpenCode SQLite), "cursor", or "codex"
@@ -118,14 +120,15 @@ Options:
 
 Examples:
   ei "debugging"                         # Search everything
-  ei -n 5 "API design"                   # Top 5 across all types
+  ei -n 5 "API design"                   # Top 5 across facts/people/topics/quotes (no personas)
   ei quote "you guessed it"              # Search quotes only
   ei --recent                            # Most recently mentioned items
   ei topics --recent "work"              # Recent work-related topics
   ei --persona "Architect" "work stuff"  # What Architect knows about work
   ei topics --source cursor "X"          # Topics learned from Cursor sessions
   ei --id abc-123                        # Look up entity by ID
-  ei "memory leak" | jq .[0].id | ei --id  # Pipe ID from search
+  ei --identifier "GitHub" "flare576"    # Look up a person by identifier type + value
+  ei "memory leak" | jq -r '.[0] | if .id != null then .id else .message_id end' | ei --id  # Pipe ID from search (quote-safe)
   ei create fact --json '{"name":"Field of Study","description":"CS","sentiment":0,"validated_date":""}'
   ei update fact abc-123 --json '{"name":"Field of Study","description":"Updated","sentiment":0,"validated_date":""}'
   ei update quote <id> --json '{"data_item_ids":["person-b-id"], ...}'  # Repoint a quote after splitting a bad merge (fetch the full record via 'ei --id <id>' first)
@@ -160,15 +163,16 @@ async function main(): Promise<void> {
     await installMcpClients();
     console.log(`
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Codex
+  MCP (optional, manual)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  If Codex was detected, Ei MCP was registered via:
+  Ei now ships as Agent Skills by default. Any existing Ei MCP registration
+  in Claude Code, Cursor, or Codex was just removed in favor of the
+  ei-search, ei-curate, and ei-persona skills. MCP is still available if you
+  want it — add it back manually:
 
     codex mcp add ei --env EI_DATA_PATH="${process.env.EI_DATA_PATH ?? "~/.local/share/ei"}" -- bunx ei-tui mcp
 
-  Restart Codex to activate.
-
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   OpenCode: add to ~/.config/opencode/opencode.jsonc
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -392,6 +396,28 @@ async function main(): Promise<void> {
     console.log(JSON.stringify(entity, null, 2));
     process.exit(0);
   }
+
+  // Handle --identifier flag: look up a person by identifier type + value.
+  // Deliberately simpler than --id: exactly two positional args, no
+  // stdin-piping support (--id remains the primary pipe-drill-down target).
+  const identifierFlagIndex = args.indexOf("--identifier");
+  if (identifierFlagIndex !== -1) {
+    const idType = args[identifierFlagIndex + 1]?.trim();
+    const idValue = args[identifierFlagIndex + 2]?.trim();
+
+    if (!idType || !idValue) {
+      console.error("--identifier requires two values. Usage: ei --identifier <type> <value>");
+      process.exit(1);
+    }
+
+    const entity = await lookupByIdentifier(idType, idValue);
+    if (!entity) {
+      console.error(`No person found with identifier ${idType}: ${idValue}`);
+      process.exit(1);
+    }
+    console.log(JSON.stringify(entity, null, 2));
+    process.exit(0);
+  }
   let targetType: string | null = null;
   let parseableArgs = args;
 

package/src/core/handlers/human-extraction.ts

@@ -14,6 +14,9 @@ import { BUILT_IN_FACT_NAMES } from "../constants/built-in-facts.js";
 import { getEmbeddingService, getItemEmbeddingText, cosineSimilarity, getPersonEmbeddingText } from "../embedding-service.js";
 import { levenshtein, normalizeForMatch } from "../utils/levenshtein.js";
 
+export type PersonMatchStrength = 'strong' | 'weak';
+export interface PersonMatch { person: Person; strength: PersonMatchStrength; }
+
 const MULTI_MATCH_SIMILARITY_THRESHOLD = 0.75;
 const ZERO_MATCH_COSINE_THRESHOLD = 0.80;
 
@@ -27,13 +30,25 @@ const SINGLETON_RELATIONSHIPS = new Set([
   'father', 'mother',
 ]);
 
+function sharesNameToken(normalizedCandidateName: string, person: Person): boolean {
+  const candidateTokens = new Set(normalizedCandidateName.split(/\s+/).filter(t => t.length >= 3));
+  if (candidateTokens.size === 0) return false;
+  const personStrings = [normalizeForMatch(person.name), ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value))];
+  for (const s of personStrings) {
+    for (const tok of s.split(/\s+/)) {
+      if (tok.length >= 3 && candidateTokens.has(tok)) return true;
+    }
+  }
+  return false;
+}
+
 function matchPersonCandidate(
   candidateName: string,
   candidateIdentifiers: PersonIdentifier[],
   people: Person[]
-): Person[] {
+): PersonMatch[] {
   const normName = normalizeForMatch(candidateName);
-  const matched = new Set<Person>();
+  const matched = new Map<Person, PersonMatchStrength>();
 
   // Step 1: Exact match on any identifier value (type-agnostic)
   for (const person of people) {
@@ -41,19 +56,24 @@ function matchPersonCandidate(
       ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
       normalizeForMatch(person.name),
     ];
-    if (allValues.includes(normName)) matched.add(person);
+    if (allValues.includes(normName)) matched.set(person, 'strong');
   }
   // Also check scan-extracted identifiers against existing identifier values
   for (const scanId of candidateIdentifiers) {
     const normVal = normalizeForMatch(scanId.value);
     for (const person of people) {
       if ((person.identifiers ?? []).some(i => normalizeForMatch(i.value) === normVal)) {
-        matched.add(person);
+        // Corroboration gate (#78 C1): a scan-extracted identifier only STRONG-binds when the
+        // candidate's name shares a token with the match. A bare identifier hit with zero name
+        // overlap is the cross-attribution signature (one person's handle on another's record),
+        // so it drops to WEAK and must clear the cosine gate — or become a new record.
+        const strength: PersonMatchStrength = sharesNameToken(normName, person) ? 'strong' : 'weak';
+        if (matched.get(person) !== 'strong') matched.set(person, strength);
       }
     }
   }
 
-  if (matched.size > 0) return [...matched];
+  if (matched.size > 0) return [...matched].map(([person, strength]) => ({ person, strength }));
 
   // Step 2: Fuzzy match — skip for short names (< 6 chars): "mike"↔"jake" = 2 edits, false positive.
   if (normName.length >= 6) {
@@ -63,11 +83,11 @@ function matchPersonCandidate(
         ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
         normalizeForMatch(person.name),
       ];
-      if (allValues.some(v => levenshtein(normName, v) <= threshold)) matched.add(person);
+      if (allValues.some(v => levenshtein(normName, v) <= threshold)) matched.set(person, 'weak');
     }
   }
 
-  if (matched.size > 0) return [...matched];
+  if (matched.size > 0) return [...matched].map(([person, strength]) => ({ person, strength }));
 
   // Step 2.5: First-name match — "Lucas Jeremy Scherer" should find "Lucas".
   // Only fires when first word is >= 4 chars to avoid short-name collisions.
@@ -78,11 +98,11 @@ function matchPersonCandidate(
         normalizeForMatch(person.name),
         ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
       ];
-      if (allNames.some(n => n.split(/\s+/)[0] === candidateFirstWord)) matched.add(person);
+      if (allNames.some(n => n.split(/\s+/)[0] === candidateFirstWord)) matched.set(person, 'weak');
     }
   }
 
-  return [...matched];
+  return [...matched].map(([person, strength]) => ({ person, strength }));
 }
 
 export async function handleFactFind(response: LLMResponse, state: StateManager): Promise<void> {
@@ -182,6 +202,27 @@ export async function handleHumanTopicScan(response: LLMResponse, state: StateMa
   console.log(`[handleHumanTopicScan] Queued ${result.topics.length} topic(s) for matching`);
 }
 
+async function confirmMatchByCosine(
+  person: Person,
+  candidate: { name: string; relationship?: string; description?: string },
+  threshold: number
+): Promise<Person | null> {
+  if (!person.embedding || person.embedding.length === 0) return null;
+  try {
+    const embeddingService = getEmbeddingService();
+    const candidateVector = await embeddingService.embed(getPersonEmbeddingText({
+      name: candidate.name, relationship: candidate.relationship, description: candidate.description,
+    }));
+    const sim = cosineSimilarity(person.embedding, candidateVector);
+    if (sim >= threshold) return person;
+    console.debug(`[handleHumanPersonScan] Weak single-match "${candidate.name}" → "${person.name}" rejected (cosine ${sim.toFixed(3)} < ${threshold}) — new record`);
+    return null;
+  } catch (err) {
+    console.warn(`[handleHumanPersonScan] Weak-match cosine failed for "${candidate.name}":`, err);
+    return null;
+  }
+}
+
 export async function handleHumanPersonScan(response: LLMResponse, state: StateManager): Promise<void> {
   const result = response.parsed as PersonScanResult | undefined;
   
@@ -213,7 +254,12 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
     let matchedPerson: Person | null = null;
 
     if (matches.length === 1) {
-      matchedPerson = matches[0];
+      const { person, strength } = matches[0];
+      if (strength === 'strong') {
+        matchedPerson = person;
+      } else {
+        matchedPerson = await confirmMatchByCosine(person, candidate, MULTI_MATCH_SIMILARITY_THRESHOLD);
+      }
     } else if (matches.length > 1) {
       try {
         const embeddingService = getEmbeddingService();
@@ -224,7 +270,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         });
         const candidateVector = await embeddingService.embed(candidateText);
         let bestSimilarity = MULTI_MATCH_SIMILARITY_THRESHOLD;
-        for (const person of matches) {
+        for (const { person } of matches) {
           if (person.embedding) {
             const sim = cosineSimilarity(person.embedding, candidateVector);
             if (sim > bestSimilarity) {
@@ -238,7 +284,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         }
       } catch (err) {
         console.warn(`[handleHumanPersonScan] Multi-match embedding failed for "${candidate.name}", using first match:`, err);
-        matchedPerson = matches[0];
+        matchedPerson = matches[0].person;
       }
     } else {
       // Step 3: relationship filter → uniqueness match or cosine on the relevant subset.
@@ -253,10 +299,13 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         const normExistingName = normalizeForMatch(existing.name);
         const isUnknownPlaceholder = normExistingName === 'unknown' || normExistingName === normRel;
         const isSingleton = SINGLETON_RELATIONSHIPS.has(normRel!);
-        if (isUnknownPlaceholder || isSingleton) {
+        if (isSingleton) {
           matchedPerson = existing;
-          const reason = isUnknownPlaceholder ? 'unnamed placeholder' : 'singleton relationship';
-          console.debug(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, ${reason})`);
+          console.debug(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, singleton relationship)`);
+        } else if (isUnknownPlaceholder) {
+          // M1 (deferred, #78): a placeholder with no embedding cannot be confirmed here and will fork a new record instead of promoting. Acceptable under the dupe-tolerant policy; revisit with embedding backfill.
+          matchedPerson = await confirmMatchByCosine(existing, candidate, ZERO_MATCH_COSINE_THRESHOLD);
+          console.debug(`[handleHumanPersonScan] Relationship unique match gated by cosine: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, unnamed placeholder) — ${matchedPerson ? 'confirmed' : 'rejected, new record'}`);
         }
       } else {
         // N>1 same relationship → cosine within that subset.

package/src/core/orchestrators/human-extraction.ts

@@ -607,17 +607,6 @@ export function queuePersonUpdate(
 
   const candidateIdentifiers = context.candidateIdentifiers ?? [];
 
-  if (!isNewItem && existingItem && candidateIdentifiers.length > 0) {
-    const merged = [...(existingItem.identifiers ?? [])];
-    for (const ci of candidateIdentifiers) {
-      if (!merged.some(ei => ei.value === ci.value)) {
-        merged.push(ci);
-      }
-    }
-    existingItem = { ...existingItem, identifiers: merged };
-    state.human_person_upsert(existingItem);
-  }
-
   const userIdentifierTypes = [...new Set(
     state.getHuman().people
       .flatMap(p => (p.identifiers ?? []).map(i => i.type))
@@ -642,6 +631,7 @@ export function queuePersonUpdate(
       persona_name: chunk.channelDisplayName,
       participant_context: buildParticipantContext(primaryPersonaIdForUpdate, state),
       known_identifier_types: userIdentifierTypes,
+      suggested_identifiers: !isNewItem ? candidateIdentifiers : undefined,
     });
 
     state.queue_enqueue({

package/src/core/persona-manager.ts

@@ -128,15 +128,26 @@ export async function updatePersona(
   const persona = sm.persona_getById(personaId);
   if (!persona) return false;
 
-  if ('long_description' in updates) {
-    const merged = { ...persona, ...updates };
-    const embedding = await computePersonaDescriptionEmbedding(merged);
-    if (embedding) {
-      updates = { ...updates, description_embedding: embedding };
-    }
-  }
+  const shouldRefreshDescriptionEmbedding = 'long_description' in updates;
+  const mergedForEmbedding = shouldRefreshDescriptionEmbedding
+    ? { ...persona, ...updates }
+    : null;
 
   sm.persona_update(personaId, updates);
+
+  if (shouldRefreshDescriptionEmbedding && mergedForEmbedding) {
+    void computePersonaDescriptionEmbedding(mergedForEmbedding).then((embedding) => {
+      if (!embedding) return;
+      const current = sm.persona_getById(personaId);
+      if (!current) return;
+      if (
+        current.long_description !== mergedForEmbedding.long_description ||
+        current.short_description !== mergedForEmbedding.short_description
+      ) return;
+      sm.persona_update(personaId, { description_embedding: embedding });
+    });
+  }
+
   return true;
 }
 

package/src/prompts/human/person-scan.ts

@@ -107,6 +107,8 @@ If you are unsure of the type, use \`Nickname\` as a fallback. Do NOT invent typ
 
 Only include \`identifiers\` when explicitly mentioned in the conversation — omit it entirely if nothing qualifies.
 
+Do NOT attribute one person's handle or identifier to another person discussed in the same window. If "Marcus's GitHub is @mcodes" appears alongside a mention of Priya, @mcodes belongs to Marcus's record only — never Priya's.
+
 ## Confidence & Relationship Type
 
 For each person, rate how important they are to the human user's life: