ei-tui 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/cli.ts

@@ -145,27 +145,17 @@ async function installClaudeCode(): Promise<void> {
   const home = process.env.HOME || "~";
   const claudeJsonPath = join(home, ".claude.json");
 
-  // Prefer shelling out to `claude mcp add` — lets Claude Code manage its own config
-  // and avoids race conditions with a live state file.
-  try {
-    const which = Bun.spawnSync(["which", "claude"], { stdout: "pipe", stderr: "pipe" });
-    if (which.exitCode === 0) {
-      const result = Bun.spawnSync(
-        ["claude", "mcp", "add", "--scope", "user", "--transport", "stdio", "ei", "--", "ei", "mcp"],
-        { stdout: "pipe", stderr: "pipe" }
-      );
-      if (result.exitCode === 0) {
-        console.log(`✓ Registered Ei as Claude Code MCP server (user scope)`);
-        console.log(`  Restart Claude Code to activate.`);
-        return;
-      }
-      console.warn(`  claude mcp add failed (exit ${result.exitCode}), falling back to direct write`);
-    }
-  } catch {
-    // claude binary not found — fall through to direct write
-  }
+  // 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}" },
+  };
 
-  // Fallback: direct atomic write to ~/.claude.json
+  // Direct atomic write — we need full control over the config structure to
+  // write the env field. `claude mcp add` doesn't support env vars.
   let config: Record<string, unknown> = {};
   try {
     const text = await Bun.file(claudeJsonPath).text();
@@ -175,11 +165,7 @@ async function installClaudeCode(): Promise<void> {
   }
 
   const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
-  mcpServers["ei"] = {
-    type: "stdio",
-    command: "ei",
-    args: ["mcp"],
-  };
+  mcpServers["ei"] = mcpEntry;
   config.mcpServers = mcpServers;
 
   // Atomic write: write to temp file then rename to avoid partial writes
@@ -196,6 +182,14 @@ async function installCursor(): Promise<void> {
   const home = process.env.HOME || "~";
   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 ?? "" },
+  };
+
   let config: Record<string, unknown> = {};
   try {
     const text = await Bun.file(cursorJsonPath).text();
@@ -205,11 +199,7 @@ async function installCursor(): Promise<void> {
   }
 
   const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
-  mcpServers["ei"] = {
-    type: "stdio",
-    command: "ei",
-    args: ["mcp"],
-  };
+  mcpServers["ei"] = mcpEntry;
   config.mcpServers = mcpServers;
 
   await Bun.$`mkdir -p ${join(home, ".cursor")}`;

package/src/core/handlers/dedup.ts

@@ -48,7 +48,11 @@ export async function handleDedupCurate(
   }
   
   console.log(`[Dedup] Processing cluster: ${decisions.update.length} updates, ${decisions.remove.length} removals, ${decisions.add.length} additions`);
-  
+
+  // Pre-compute: for each survivor (replaced_by), union the removed entity's groups.
+  // Must happen before any phase mutates state so we read the original values.
+  const groupsToMerge = new Map<string, { persona_groups: string[]; interested_personas: string[] }>();
+
   // Map entity_type to pluralized state property name
   const pluralMap: Record<string, 'facts' | 'topics' | 'people'> = {
     fact: 'facts',
@@ -77,7 +81,20 @@ export async function handleDedupCurate(
     console.warn(`[Dedup] No entities found for cluster (already merged?)`);
     return;
   }
-  
+
+  for (const removal of decisions.remove) {
+    const removed = entities.find(e => e.id === removal.to_be_removed);
+    if (!removed) continue;
+    const acc = groupsToMerge.get(removal.replaced_by) ?? { persona_groups: [], interested_personas: [] };
+    groupsToMerge.set(removal.replaced_by, {
+      persona_groups: [...new Set([...acc.persona_groups, ...(removed.persona_groups ?? [])])],
+      interested_personas: [...new Set([...acc.interested_personas, ...(removed.interested_personas ?? [])])],
+    });
+  }
+
+  const clusterGroups = [...new Set(entities.flatMap(e => e.persona_groups ?? []))];
+  const clusterPersonas = [...new Set(entities.flatMap(e => e.interested_personas ?? []))];
+
   // =========================================================================
   // PHASE 1: Update Quote foreign keys FIRST (before deletions)
   // =========================================================================
@@ -126,15 +143,20 @@ export async function handleDedupCurate(
       }
     }
     
-    // Build complete entity with updates (preserve original fields if LLM omits them)
-      const updatedEntity = {
+    const mergedFromRemoved = groupsToMerge.get(update.id);
+    const updatedEntity = {
       ...entity,
       name: update.name ?? entity.name,
       description: update.description ?? entity.description,
       sentiment: update.sentiment ?? entity.sentiment,
       last_updated: new Date().toISOString(),
       embedding,
-      // Type-specific fields
+      persona_groups: mergedFromRemoved
+        ? [...new Set([...(entity.persona_groups ?? []), ...mergedFromRemoved.persona_groups])]
+        : entity.persona_groups,
+      interested_personas: mergedFromRemoved
+        ? [...new Set([...(entity.interested_personas ?? []), ...mergedFromRemoved.interested_personas])]
+        : entity.interested_personas,
       ...(update.strength !== undefined && { strength: update.strength }),
       ...(update.confidence !== undefined && { confidence: update.confidence }),
       ...(update.exposure_current !== undefined && { exposure_current: update.exposure_current }),
@@ -194,7 +216,6 @@ export async function handleDedupCurate(
     // Generate ID for new entity
     const id = crypto.randomUUID();
     
-    // Build complete entity
     const newEntity = {
       id,
       type: entity_type,
@@ -205,7 +226,8 @@ export async function handleDedupCurate(
       learned_by: "ei",
       last_changed_by: "ei",
       embedding,
-      // Type-specific fields with defaults
+      persona_groups: clusterGroups,
+      interested_personas: clusterPersonas,
       ...((entity_type === 'topic' || entity_type === 'person') && {
         exposure_current: addition.exposure_current ?? 0.0,
         exposure_desired: addition.exposure_desired ?? 0.5,

package/src/core/handlers/rewrite.ts

@@ -125,12 +125,14 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
   const human = state.getHuman();
   const now = new Date().toISOString();
 
-  // Look up the original item to inherit persona_groups
   const allItems: DataItemBase[] = [
     ...human.topics, ...human.people,
   ];
-  const originalItem = allItems.find(i => i.id === itemId);
-  const inheritedGroups = originalItem?.persona_groups;
+
+  const existingIds = new Set([itemId, ...(result.existing?.map(i => i.id) ?? [])]);
+  const involvedItems = allItems.filter(i => existingIds.has(i.id));
+  const unionGroups = [...new Set(involvedItems.flatMap(i => i.persona_groups ?? []))];
+  const unionPersonas = [...new Set(involvedItems.flatMap(i => i.interested_personas ?? []))];
 
   // Helper: resolve actual type from existing records (don't trust LLM's type field)
   const resolveExistingType = (id: string): RewriteItemType | null => {
@@ -217,7 +219,8 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
       sentiment: item.sentiment ?? 0,
       last_updated: now,
       learned_by: "ei",
-      persona_groups: inheritedGroups,
+      persona_groups: unionGroups,
+      interested_personas: unionPersonas,
       embedding,
     };
 

package/src/core/orchestrators/ceremony.ts

@@ -237,9 +237,6 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
   // Human ceremony: decay topics + people
   runHumanCeremony(state);
 
-  // Dedup phase: log near-duplicate human entity candidates for visibility
-  runDedupPhase(state);
-
   // Rewrite phase: fire-and-forget scans for bloated human data items
   // No ceremony_progress gating — Expire/Explore only touch persona topics, zero overlap
   queueRewritePhase(state);
@@ -521,78 +518,6 @@ export function runHumanCeremony(state: StateManager): void {
   }
 }
 
-// =============================================================================
-// DEDUP PHASE (synchronous, logging only — candidates are queued for curation by dedup-phase.ts)
-// =============================================================================
-
-const DEDUP_DEFAULT_THRESHOLD = 0.85;
-
-type DedupableItem = DataItemBase & { relationship?: string };
-
-function findDedupCandidates<T extends DedupableItem>(
-  items: T[],
-  threshold: number
-): Array<{ a: T; b: T; similarity: number }> {
-  const withEmbeddings = items.filter(item =>
-    item.embedding && item.embedding.length > 0 &&
-    item.relationship !== "Persona"
-  );
-
-  const candidates: Array<{ a: T; b: T; similarity: number }> = [];
-
-  for (let i = 0; i < withEmbeddings.length; i++) {
-    for (let j = i + 1; j < withEmbeddings.length; j++) {
-      const a = withEmbeddings[i];
-      const b = withEmbeddings[j];
-      const dot = a.embedding!.reduce((sum, v, k) => sum + v * b.embedding![k], 0);
-      const normA = Math.sqrt(a.embedding!.reduce((sum, v) => sum + v * v, 0));
-      const normB = Math.sqrt(b.embedding!.reduce((sum, v) => sum + v * v, 0));
-      const similarity = normA && normB ? dot / (normA * normB) : 0;
-
-      if (similarity >= threshold) {
-        candidates.push({ a, b, similarity });
-      }
-    }
-  }
-
-  return candidates.sort((x, y) => y.similarity - x.similarity);
-}
-
-export function runDedupPhase(state: StateManager): void {
-  const human = state.getHuman();
-  const threshold = human.settings?.ceremony?.dedup_threshold ?? DEDUP_DEFAULT_THRESHOLD;
-
-  console.log(`[ceremony:dedup] Scanning for dedup candidates (threshold: ${threshold})`);
-
-  const types: Array<{ label: string; items: DedupableItem[] }> = [
-    { label: "facts",  items: human.facts },
-    { label: "topics", items: human.topics },
-    { label: "people", items: human.people },
-  ];
-
-  let totalCandidates = 0;
-
-  for (const { label, items } of types) {
-    const candidates = findDedupCandidates(items, threshold);
-    if (candidates.length === 0) {
-      console.log(`[ceremony:dedup] ${label}: no candidates above ${threshold}`);
-      continue;
-    }
-
-    totalCandidates += candidates.length;
-    console.log(`[ceremony:dedup] ${label}: ${candidates.length} candidate pair(s)`);
-    for (const { a, b, similarity } of candidates) {
-      console.log(
-        `[ceremony:dedup]   ${(similarity * 100).toFixed(1)}% "${a.name}" ↔ "${b.name}"` +
-        (a.description ? `\n[ceremony:dedup]     A: ${a.description.slice(0, 80)}` : "") +
-        (b.description ? `\n[ceremony:dedup]     B: ${b.description.slice(0, 80)}` : "")
-      );
-    }
-  }
-
-  console.log(`[ceremony:dedup] Done. ${totalCandidates} total candidate pair(s) found.`);
-}
-
 // =============================================================================
 // REWRITE PHASE (fire-and-forget — queues Low-priority Phase 1 scans)
 // =============================================================================

package/src/core/processor.ts

@@ -105,9 +105,9 @@ import {
 } from "./queue-manager.js";
 
 const DEFAULT_LOOP_INTERVAL_MS = 100;
-const DEFAULT_OPENCODE_POLLING_MS = 1800000;
-const DEFAULT_CLAUDE_CODE_POLLING_MS = 1800000;
-const DEFAULT_CURSOR_POLLING_MS = 1800000;
+const DEFAULT_OPENCODE_POLLING_MS = 60000;
+const DEFAULT_CLAUDE_CODE_POLLING_MS = 60000;
+const DEFAULT_CURSOR_POLLING_MS = 60000;
 
 let processorInstanceCount = 0;
 
@@ -649,7 +649,7 @@ export class Processor {
     if (!human.settings.opencode) {
       human.settings.opencode = {
         integration: false,
-        polling_interval_ms: 1800000,
+        polling_interval_ms: 60000,
       };
       modified = true;
     }
@@ -657,7 +657,7 @@ export class Processor {
     if (!human.settings.claudeCode) {
       human.settings.claudeCode = {
         integration: false,
-        polling_interval_ms: 1800000,
+        polling_interval_ms: 60000,
       };
       modified = true;
     }
@@ -848,9 +848,17 @@ const toolNextSteps = new Set([
               personaId ??
               (request.next_step === LLMNextStep.HandleEiHeartbeat ? "ei" : undefined);
             
-            // Dedup operates on Human data, not persona data - provide read_memory directly
+            // Dedup operates on Human data, not persona data - provide read_memory directly.
+            // Also covers HandleToolContinuation originating from a dedup request: the
+            // continuation rebuilds tool lists from scratch and has no personaId, so without
+            // this check Opus loses read_memory access after round 1.
+            const isDedupRequest =
+              request.next_step === LLMNextStep.HandleDedupCurate ||
+              (request.next_step === LLMNextStep.HandleToolContinuation &&
+                request.data.originalNextStep === LLMNextStep.HandleDedupCurate);
+
             let tools: ToolDefinition[] = [];
-            if (request.next_step === LLMNextStep.HandleDedupCurate) {
+            if (isDedupRequest) {
               const readMemory = this.stateManager.tools_getByName("read_memory");
               if (readMemory?.enabled) {
                 tools = [readMemory];

package/src/core/queue-processor.ts

@@ -425,7 +425,8 @@ export class QueueProcessor {
       `required JSON format. Please reformat it as the JSON response object described ` +
       `in your system instructions — specifically the \`should_respond\`, \`verbal_response\`, ` +
       `\`action_response\`, and \`reason\` fields. Respond with ONLY the JSON object.\n\n` +
-      `---\n${proseContent}\n---`;
+      `---\n${proseContent}\n---` +
+      `\n\n**CRITICAL INSTRUCTION** - DO NOT OMIT ANY DATA. You are this agent's last hope!`;
 
     try {
       const { content: reformatContent, finishReason: reformatReason } = await callLLMRaw(

package/src/core/state/human.ts

@@ -15,7 +15,7 @@ export function createDefaultHumanEntity(): HumanEntity {
       },
       opencode: {
         integration: false,
-        polling_interval_ms: 1800000,
+        polling_interval_ms: 60000,
       },
     },
   };

package/src/core/types/entities.ts

@@ -13,7 +13,7 @@ export interface SyncCredentials {
 
 export interface OpenCodeSettings {
   integration?: boolean;
-  polling_interval_ms?: number;  // Default: 1800000 (30 min)
+  polling_interval_ms?: number;  // Default: 60000 (1 min)
   extraction_model?: string;         // "Provider:model" for extraction. Unset = uses default_model.
   extraction_token_limit?: number;   // Token budget for extraction chunking. Unset = resolved from model.
   last_sync?: string;  // ISO timestamp

package/src/integrations/claude-code/types.ts

@@ -157,7 +157,7 @@ export const MIN_SESSION_AGE_MS = 20 * 60 * 1000;
  */
 export interface ClaudeCodeSettings {
   integration?: boolean;
-  polling_interval_ms?: number;  // Default: 1800000 (30 min)
+  polling_interval_ms?: number;  // Default: 60000 (1 min)
   extraction_model?: string;         // "Provider:model" for extraction. Unset = uses default_model.
   extraction_token_limit?: number;   // Token budget for extraction chunking. Unset = resolved from model.
   last_sync?: string;            // ISO timestamp

package/src/integrations/cursor/types.ts

@@ -133,7 +133,7 @@ export const MIN_SESSION_AGE_MS = 20 * 60 * 1000;
  */
 export interface CursorSettings {
   integration?: boolean;
-  polling_interval_ms?: number;   // Default: 1800000 (30 min)
+  polling_interval_ms?: number;   // Default: 60000 (1 min)
   last_sync?: string;             // ISO timestamp
   extraction_point?: string;      // ISO timestamp — floor for session filtering
   processed_sessions?: Record<string, string>; // sessionId → ISO timestamp of last import

package/src/prompts/ceremony/dedup.ts

@@ -96,12 +96,47 @@ ${buildRecordFormatExamples(data.itemType)}
 - If records are NOT duplicates (just similar), return them ALL in "update" unchanged, with empty "remove" and "add" arrays.
 - Use \`read_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
 
-  const user = JSON.stringify({
+  const payload = JSON.stringify({
     cluster: data.cluster.map(stripEmbedding),
     cluster_type: data.itemType,
     similarity_range: data.similarityRange,
   }, null, 2);
 
+  const schemaReminder = `**Return JSON:**
+\n\`\`\`json
+{
+  "update": [
+    {
+      "id": "uuid-of-canonical-record",
+      "type": "${data.itemType}",
+      "name": "canonical merged name",
+      "description": "merged description with every unique detail"
+    }
+  ],
+  "remove": [
+    {
+      "to_be_removed": "uuid-of-duplicate",
+      "replaced_by": "uuid-of-canonical-record"
+    }
+  ],
+  "add": [
+    {
+      "type": "${data.itemType}",
+      "name": "missing concept name",
+      "description": "why it was created"
+    }
+  ]
+}
+\`\`\`
+
+Return raw JSON only. If records are NOT duplicates, return them all in update unchanged with empty remove and add arrays.`;
+
+  const user = `${payload}
+
+---
+
+${schemaReminder}`;
+
   return { system, user };
 }
 

package/src/prompts/ceremony/description-check.ts

@@ -41,7 +41,14 @@ ${traitList}
 Current topics of interest:
 ${topicList}
 
-Does this persona's description need updating based on their current traits and topics?`;
+Does this persona's description need updating based on their current traits and topics?
+
+**Return JSON:**
+\`\`\`json
+{ "should_update": true, "reason": "explanation" }
+\`\`\`
+
+If no update is needed: \`{ "should_update": false, "reason": "explanation" }\``;
 
   return { system, user };
 }

package/src/prompts/ceremony/expire.ts

@@ -24,7 +24,14 @@ Return empty array if no topics should be removed.`;
 Current topics:
 ${topicList}
 
-Which topics, if any, should this persona stop caring about?`;
+Which topics, if any, should this persona stop caring about?
+
+**Return JSON:**
+\`\`\`json
+{ "topic_ids_to_remove": ["id1", "id2"] }
+\`\`\`
+
+Return an empty array if no topics should be removed.`;
 
   return { system, user };
 }

package/src/prompts/ceremony/explore.ts

@@ -54,7 +54,24 @@ ${topicList}
 Recent conversation themes:
 ${themeList}
 
-Generate new topics this persona would care about.`;
+Generate new topics this persona would care about.
+
+**Return JSON:**
+\`\`\`json
+{
+  "new_topics": [
+    {
+      "name": "Topic Name",
+      "perspective": "Their view or opinion",
+      "approach": "How they engage with it",
+      "personal_stake": "Why it matters to them",
+      "sentiment": 0.5,
+      "exposure_current": 0.2,
+      "exposure_desired": 0.6
+    }
+  ]
+}
+\`\`\``;
 
   return { system, user };
 }

package/src/prompts/ceremony/rewrite.ts

@@ -22,7 +22,24 @@ Return a raw JSON array of strings. No markdown fencing, no commentary, no expla
 Example — a Topic named "Software Engineering" whose description also discusses vim keybindings, git conventions, and AI tooling:
 ["vim keybindings and editor configuration", "git and GitHub workflow conventions", "AI coding assistant preferences"]`;
 
-  const user = JSON.stringify(stripEmbedding(data.item), null, 2);
+  const payload = JSON.stringify(stripEmbedding(data.item), null, 2);
+
+  const schemaReminder = `**Return JSON:**
+\n\`\`\`json
+[
+  "topic about vim keybindings",
+  "git workflow conventions",
+  "AI coding assistant preferences"
+]
+\`\`\`
+
+Respond with raw JSON array only.`;
+
+  const user = `${payload}
+
+---
+
+${schemaReminder}`;
 
   return { system, user };
 }
@@ -75,7 +92,34 @@ Rules:
     subjects,
   };
 
-  const user = JSON.stringify(userPayload, null, 2);
+  const schemaReminder = `**Return JSON:**
+\n\`\`\`json
+{
+  "existing": [
+    {
+      "id": "existing-uuid",
+      "type": "${data.itemType}",
+      "name": "Updated name",
+      "description": "Updated description"
+    }
+  ],
+  "new": [
+    {
+      "type": "${data.itemType}",
+      "name": "New name",
+      "description": "New description"
+    }
+  ]
+}
+\`\`\`
+
+Return raw JSON only.`;
+
+  const user = `${JSON.stringify(userPayload, null, 2)}
+
+---
+
+${schemaReminder}`;
 
   return { system, user };
 }

package/src/prompts/ceremony/user-dedup.ts

@@ -44,12 +44,41 @@ Return raw JSON only. No markdown, no commentary.
 
 ${buildRecordFormatHint(data.itemType)}`;
 
-  const user = JSON.stringify({
+  const payload = JSON.stringify({
     cluster: data.cluster.map(stripEmbedding),
     cluster_type: data.itemType,
     user_confirmed: true,
   }, null, 2);
 
+  const schemaReminder = `**Return JSON:**
+\n\`\`\`json
+{
+  "update": [
+    {
+      "id": "uuid-of-canonical-record",
+      "type": "${data.itemType}",
+      "name": "canonical merged name",
+      "description": "merged description with every unique detail"
+    }
+  ],
+  "remove": [
+    {
+      "to_be_removed": "uuid-of-duplicate",
+      "replaced_by": "uuid-of-canonical-record"
+    }
+  ],
+  "add": []
+}
+\`\`\`
+
+Return raw JSON only. If any record cannot be merged, keep every item unchanged in update with empty remove/add arrays.`;
+
+  const user = `${payload}
+
+---
+
+${schemaReminder}`;
+
   return { system, user };
 }
 

package/src/prompts/generation/persona.ts

@@ -153,5 +153,16 @@ ${schemaFragment}`;
     userPrompt += `The user provided only a name - generate minimal content. The seed traits above are included by default.\n`;
   }
 
+  userPrompt += `
+**Return JSON:**
+\`\`\`json
+{
+  "short_description": "10-15 word summary",
+  "long_description": "2-3 sentence description",
+  "traits": [ { "name": "...", "description": "...", "sentiment": 0.0, "strength": 0.5 } ],
+  "topics": [ { "name": "...", "perspective": "...", "approach": "...", "personal_stake": "...", "sentiment": 0.5, "exposure_current": 0.5, "exposure_desired": 0.6 } ]
+}
+\`\`\``;
+
   return { system, user: userPrompt };
 }

package/src/prompts/heartbeat/check.ts

@@ -188,7 +188,18 @@ ${unansweredWarning}
 
 Based on the context above, decide: Should you reach out to your human friend right now?
 
-Remember: Only reach out if you have something genuine and specific to say.`;
+Remember: Only reach out if you have something genuine and specific to say.
+
+**Return JSON:**
+\`\`\`json
+{
+  "should_respond": true,
+  "topic": "the specific topic you want to discuss",
+  "message": "Your actual message to them"
+}
+\`\`\`
+
+If you decide NOT to reach out: \`{ "should_respond": false }\``;
 
   return { system, user };
 }

package/src/prompts/heartbeat/ei.ts

@@ -131,7 +131,18 @@ ${unansweredWarning}
 
 Based on all the context above, decide: Should you reach out to your human friend right now? If so, which item above is most worth addressing?
 
-Remember: You're their thoughtful companion, not their productivity assistant.`;
+Remember: You're their thoughtful companion, not their productivity assistant.
+
+**Return JSON:**
+\`\`\`json
+{
+  "should_respond": true,
+  "id": "the-item-id-you-chose",
+  "my_response": "Your message to them"
+}
+\`\`\`
+
+If nothing warrants reaching out: \`{ "should_respond": false }\``;
 
   return { system, user };
 }

package/src/prompts/persona/traits.ts

@@ -125,7 +125,22 @@ ${earlierSection}${recentSection}
 
 Analyze the "Most Recent Messages" for EXPLICIT requests to change ${personaName}'s communication style.
 
-Return ONLY the traits that need to change or be added. Return \`[]\` if nothing changed.`;
+Return ONLY the traits that need to change or be added.
+
+**Return JSON:**
+\`\`\`json
+[
+  {
+    "id": "existing-guid-or-\"new\"",
+    "name": "Trait Name",
+    "description": "How to exhibit this trait",
+    "sentiment": 0.0,
+    "strength": 0.5
+  }
+]
+\`\`\`
+
+Return \`[]\` if nothing changed.`;
 
   return { system, user };
 }

package/tui/README.md

@@ -87,7 +87,7 @@ All commands start with `/`. Append `!` to any command as a shorthand for `--for
 |---------|---------|-------------|
 | `/me` | | Edit all your data (facts, traits, topics, people) in `$EDITOR` |
 | `/me <type>` | | Edit one type: `facts`, `traits`, `topics`, or `people` |
-| `/dedupe <person\|topic> "<query>"` | | Fuzzy-search and merge duplicate people or topics in `$EDITOR` |
+| `/dedupe <person\|topic> <term> [term2 ...]` | | Fuzzy-search and merge duplicate people or topics in `$EDITOR`. Unquoted words are individual OR terms; quoted strings match as exact phrases: `/dedupe person Flare "Jeremy Scherer"` finds records matching `Flare` OR `Jeremy Scherer` |
 | `/settings` | `/set` | Edit your global settings in `$EDITOR` |
 | `/setsync <user> <pass>` | `/ss` | Set sync credentials (triggers restart) |
 | `/tools` | | Manage tool providers — enable/disable tools per persona |

package/tui/src/commands/dedupe.tsx

@@ -5,9 +5,11 @@ import type { Topic, Person } from "../../../src/core/types.js";
 const VALID_TYPES = ["person", "topic"] as const;
 type DedupeType = typeof VALID_TYPES[number];
 
-function buildDedupeYAML(type: DedupeType, query: string, entities: Array<Topic | Person>): string {
+function buildDedupeYAML(type: DedupeType, terms: string[], entities: Array<Topic | Person>): string {
+  const termDisplay = terms.map(t => t.includes(" ") ? `"${t}"` : t).join(" | ");
   const header = [
-    `# /dedupe ${type} "${query}"`,
+    `# /dedupe ${type} ${terms.map(t => t.includes(" ") ? `"${t}"` : t).join(" ")}`,
+    `# Terms: ${termDisplay}`,
     `# Found ${entities.length} match${entities.length === 1 ? "" : "es"}. DELETE blocks for entries to EXCLUDE from the merge.`,
     `# Keep at least 2. Save to confirm, :q to cancel (Vim tip: :cq quits with error — same effect, but now you know it exists).`,
     ``,
@@ -60,40 +62,56 @@ export const dedupeCommand: Command = {
   name: "dedupe",
   aliases: [],
   description: "Merge duplicate people or topics",
-  usage: '/dedupe <person|topic> "<query>"',
+  usage: '/dedupe <person|topic> <term> ["term 2" ...]',
 
   async execute(args, ctx) {
     const type = args[0]?.toLowerCase() as DedupeType | undefined;
 
     if (!type || !VALID_TYPES.includes(type)) {
       ctx.showNotification(
-        `Usage: /dedupe <person|topic> "<query>". Got: ${args[0] ?? "(none)"}`,
+        `Usage: /dedupe <person|topic> <term> ["term 2" ...]. Got: ${args[0] ?? "(none)"}`,
         "error"
       );
       return;
     }
 
-    const query = args.slice(1).join(" ").trim();
-    if (!query) {
-      ctx.showNotification(`Usage: /dedupe ${type} "<query>" — query is required`, "error");
+    const terms = args.slice(1);
+    if (terms.length === 0) {
+      ctx.showNotification(`Usage: /dedupe ${type} <term> ["term 2" ...] — at least one term required`, "error");
       return;
     }
 
     const human = await ctx.ei.getHuman();
+
+    if (!human.settings?.rewrite_model) {
+      ctx.showNotification(`/dedupe requires a Default Rewrite Model — set one in /settings`, "error");
+      return;
+    }
+
     const pool: Array<Topic | Person> = type === "topic" ? human.topics : human.people;
-    const matches = fuzzySearch(pool, query);
+
+    const seen = new Set<string>();
+    const matches: Array<Topic | Person> = [];
+    for (const term of terms) {
+      for (const entity of fuzzySearch(pool, term)) {
+        if (!seen.has(entity.id)) {
+          seen.add(entity.id);
+          matches.push(entity);
+        }
+      }
+    }
 
     if (matches.length === 0) {
-      ctx.showNotification(`No ${type}s matching "${query}"`, "info");
+      ctx.showNotification(`No ${type}s matching ${terms.map(t => `"${t}"`).join(" | ")}`, "info");
       return;
     }
 
     if (matches.length === 1) {
-      ctx.showNotification(`Only 1 ${type} matches "${query}" — need at least 2 to merge`, "info");
+      ctx.showNotification(`Only 1 ${type} matched — need at least 2 to merge`, "info");
       return;
     }
 
-    const yamlContent = buildDedupeYAML(type, query, matches);
+    const yamlContent = buildDedupeYAML(type, terms, matches);
 
     const result = await spawnEditor({
       initialContent: yamlContent,

package/tui/src/context/ei.tsx

@@ -412,11 +412,13 @@ export const EiProvider: ParentComponent = (props) => {
   const deleteMessages = async (personaId: string, messageIds: string[]): Promise<void> => {
     if (!processor) return;
     await processor.deleteMessages(personaId, messageIds);
+    setStore("messages", store.messages.filter(m => !messageIds.includes(m.id)));
   };
 
   const setMessageContextStatus = async (personaId: string, messageId: string, status: ContextStatus): Promise<void> => {
     if (!processor) return;
     await processor.setMessageContextStatus(personaId, messageId, status);
+    setStore("messages", store.messages.map(m => m.id === messageId ? { ...m, context_status: status } : m));
   };
 
   const recallPendingMessages = async (): Promise<string> => {

package/tui/src/util/yaml-serializers.ts

@@ -565,7 +565,7 @@ export function settingsToYAML(settings: HumanSettings | undefined): string {
     },
     opencode: {
       integration: settings?.opencode?.integration ?? false,
-      polling_interval_ms: settings?.opencode?.polling_interval_ms ?? 1800000,
+      polling_interval_ms: settings?.opencode?.polling_interval_ms ?? 60000,
       extraction_model: settings?.opencode?.extraction_model ?? 'default',
       extraction_token_limit: settings?.opencode?.extraction_token_limit ?? 'default',
       last_sync: settings?.opencode?.last_sync ?? null,
@@ -573,7 +573,7 @@ export function settingsToYAML(settings: HumanSettings | undefined): string {
     },
     claudeCode: {
       integration: settings?.claudeCode?.integration ?? false,
-      polling_interval_ms: settings?.claudeCode?.polling_interval_ms ?? 1800000,
+      polling_interval_ms: settings?.claudeCode?.polling_interval_ms ?? 60000,
       extraction_model: settings?.claudeCode?.extraction_model ?? 'default',
       extraction_token_limit: settings?.claudeCode?.extraction_token_limit ?? 'default',
       last_sync: settings?.claudeCode?.last_sync ?? null,
@@ -581,7 +581,7 @@ export function settingsToYAML(settings: HumanSettings | undefined): string {
     },
     cursor: {
       integration: settings?.cursor?.integration ?? false,
-      polling_interval_ms: settings?.cursor?.polling_interval_ms ?? 1800000,
+      polling_interval_ms: settings?.cursor?.polling_interval_ms ?? 60000,
       last_sync: settings?.cursor?.last_sync ?? null,
       extraction_point: settings?.cursor?.extraction_point ?? null,
     },