ei-tui 0.3.9 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "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/dedup-phase.ts

@@ -2,6 +2,7 @@ import { StateManager } from "../state-manager.js";
 import { LLMRequestType, LLMPriority, LLMNextStep, type DataItemBase } from "../types.js";
 import type { DataItemType } from "../types/data-items.js";
 import { buildDedupPrompt } from "../../prompts/ceremony/dedup.js";
+import { buildUserDedupPrompt } from "../../prompts/ceremony/user-dedup.js";
 
 // =============================================================================
 // TYPES
@@ -201,3 +202,48 @@ export function queueDedupPhase(state: StateManager): void {
   
   console.log(`[Dedup] Queued ${totalClusters} clusters for curation`);
 }
+
+// =============================================================================
+// USER-TRIGGERED DEDUP
+// =============================================================================
+
+export function queueUserDedupRequest(
+  state: StateManager,
+  itemType: "topic" | "person",
+  entityIds: string[]
+): void {
+  const human = state.getHuman();
+
+  const collection = (itemType === "topic" ? human.topics : human.people) as DedupableItem[];
+  const entities = entityIds
+    .map(id => collection.find(item => item.id === id))
+    .filter((item): item is DedupableItem => item !== undefined);
+
+  if (entities.length < 2) {
+    console.warn("[UserDedup] Need at least 2 entities to merge");
+    return;
+  }
+
+  const prompt = buildUserDedupPrompt({
+    cluster: entities,
+    itemType,
+    similarityRange: { min: 1.0, max: 1.0 },
+  });
+
+  const model = human.settings?.rewrite_model ?? undefined;
+
+  state.queue_enqueue({
+    type: LLMRequestType.JSON,
+    priority: LLMPriority.High,
+    system: prompt.system,
+    user: prompt.user,
+    next_step: LLMNextStep.HandleDedupCurate,
+    ...(model ? { model } : {}),
+    data: {
+      entity_type: itemType,
+      entity_ids: entityIds,
+    },
+  });
+
+  console.log(`[UserDedup] Queued merge of ${entities.length} ${itemType} entities`);
+}

package/src/core/orchestrators/index.ts

@@ -22,7 +22,7 @@ export {
   queueDescriptionCheck,
   runHumanCeremony,
   } from "./ceremony.js";
-export { queueDedupPhase } from "./dedup-phase.js";
+export { queueDedupPhase, queueUserDedupRequest } from "./dedup-phase.js";
 export {
   queuePersonaTopicScan,
   queuePersonaTopicMatch,

package/src/core/personas/opencode-agent.ts

@@ -19,7 +19,14 @@ function resolveCanonicalAgent(agentName: string): { canonical: string; aliases:
       return { canonical, aliases: variants };
     }
   }
-  return { canonical: agentName, aliases: [agentName] };
+
+  let name = agentName;
+  name = name.replace(/^ai-sdlc[:-]/, "");
+  name = name.replace(/\s*\([^)]+\)\s*$/, "").trim();
+  name = name.replace(/-/g, " ");
+  const canonical = name.replace(/\b\w/g, (c) => c.toUpperCase());
+
+  return { canonical, aliases: [agentName] };
 }
 
 export async function ensureAgentPersona(

package/src/core/processor.ts

@@ -31,7 +31,7 @@ import { ContextStatus as ContextStatusEnum } from "./types.js";
 import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/index.js";
 import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
-import { shouldStartCeremony, startCeremony, handleCeremonyProgress } from "./orchestrators/index.js";
+import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueUserDedupRequest } from "./orchestrators/index.js";
 import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 
 // Static module imports
@@ -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;
     }
@@ -1578,6 +1578,10 @@ const toolNextSteps = new Set([
     return clearQueue(this.stateManager, this.queueProcessor);
   }
 
+  queueUserDedup(itemType: "topic" | "person", entityIds: string[]): void {
+    queueUserDedupRequest(this.stateManager, itemType, entityIds);
+  }
+
   async submitOneShot(guid: string, systemPrompt: string, userPrompt: string): Promise<void> {
     return submitOneShot(
       this.stateManager,

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/importer.ts

@@ -11,6 +11,7 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import { isProcessRunning } from "../process-check.js";
 
 // =============================================================================
 // Export Types
@@ -219,6 +220,7 @@ export async function importClaudeCodeSessions(
   const settings = human.settings?.claudeCode;
   const processedSessions = settings?.processed_sessions ?? {};
   const now = Date.now();
+  const toolRunning = await isProcessRunning("claude");
 
   let targetSession: ClaudeCodeSession | null = null;
 
@@ -228,7 +230,7 @@ export async function importClaudeCodeSessions(
     const sessionLastMs = new Date(session.lastMessageAt).getTime();
     const ageMs = now - sessionLastMs;
 
-    if (ageMs < MIN_SESSION_AGE_MS) continue; // too fresh
+    if (ageMs < MIN_SESSION_AGE_MS && toolRunning) continue;
 
     if (!lastImported) {
       targetSession = session;

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/importer.ts

@@ -7,6 +7,7 @@ import {
   MIN_SESSION_AGE_MS,
 } from "./types.js";
 import { CursorReader } from "./reader.js";
+import { isProcessRunning } from "../process-check.js";
 import {
   queueAllScans,
   type ExtractionContext,
@@ -184,6 +185,7 @@ export async function importCursorSessions(
   const human = stateManager.getHuman();
   const processedSessions = human.settings?.cursor?.processed_sessions ?? {};
   const now = Date.now();
+  const toolRunning = await isProcessRunning("Cursor");
 
   let targetSession: CursorSession | null = null;
 
@@ -191,7 +193,7 @@ export async function importCursorSessions(
     const sessionLastMs = new Date(session.lastMessageAt).getTime();
     const ageMs = now - sessionLastMs;
 
-    if (ageMs < MIN_SESSION_AGE_MS) continue;
+    if (ageMs < MIN_SESSION_AGE_MS && toolRunning) continue;
 
     const lastImported = processedSessions[session.id];
     if (lastImported && sessionLastMs <= new Date(lastImported).getTime()) continue;

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/integrations/opencode/importer.ts

@@ -8,6 +8,7 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import { isProcessRunning } from "../process-check.js";
 
 // =============================================================================
 // Constants
@@ -125,19 +126,20 @@ export async function importOpenCodeSessions(
   let targetSession: OpenCodeSession | null = null;
   const MIN_SESSION_AGE_MS = 20 * 60 * 1000; // 20 minutes
   const now = Date.now();
+  const toolRunning = await isProcessRunning("opencode");
 
   for (const session of sortedSessions) {
     const lastImported = processedSessions[session.id];
     if (!lastImported) {
       const ageMs = now - session.time.updated;
-      if (ageMs >= MIN_SESSION_AGE_MS) {
+      if (ageMs >= MIN_SESSION_AGE_MS || !toolRunning) {
         targetSession = session;
         break;
       }
     }
     if (session.time.updated > new Date(lastImported).getTime()) {
       const ageMs = now - session.time.updated;
-      if (ageMs >= MIN_SESSION_AGE_MS) {
+      if (ageMs >= MIN_SESSION_AGE_MS || !toolRunning) {
         targetSession = session;
         break;
       }

package/src/integrations/opencode/types.ts

@@ -175,6 +175,7 @@ export const AGENT_TO_AGENT_PREFIXES = [
  * Value = array of variants that should resolve to this persona
  */
 export const AGENT_ALIASES: Record<string, string[]> = {
+  // ── OhMyOpenCode primary agents ──────────────────────────────────────────
   Sisyphus: [
     "sisyphus",
     "Sisyphus",
@@ -182,6 +183,44 @@ export const AGENT_ALIASES: Record<string, string[]> = {
     "Planner-Sisyphus",
     "planner-sisyphus",
   ],
+  Build: ["build", "Build"],
+  Plan: ["plan", "Plan"],
+  Atlas: [
+    "atlas",
+    "Atlas",
+    "atlas (plan executor)",
+    "Atlas (plan executor)",
+  ],
+  Prometheus: [
+    "prometheus",
+    "Prometheus",
+    "prometheus (plan builder)",
+    "Prometheus (plan builder)",
+  ],
+  Hephaestus: [
+    "hephaestus",
+    "Hephaestus",
+    "hephaestus (deep agent)",
+    "Hephaestus (deep agent)",
+  ],
+
+  // ── ai-sdlc agents (RobotsAndPencils/ai-sdlc-claude-code-template) ───────
+  // Installed via scripts/install-opencode.sh as "ai-sdlc-{name}" in OpenCode.
+  // Bare names included for direct/custom installs.
+  Architect: ["ai-sdlc-architect", "architect"],
+  "Frontend Engineer": ["ai-sdlc-frontend-engineer", "frontend-engineer"],
+  "Backend Engineer": ["ai-sdlc-backend-engineer", "backend-engineer"],
+  "Code Reviewer": ["ai-sdlc-code-reviewer", "code-reviewer"],
+  "Database Engineer": ["ai-sdlc-database-engineer", "database-engineer"],
+  Debugger: ["ai-sdlc-debugger", "debugger"],
+  "DevOps Engineer": ["ai-sdlc-devops-engineer", "devops-engineer"],
+  "Mobile Engineer": ["ai-sdlc-mobile-engineer", "mobile-engineer"],
+  "QA Engineer": ["ai-sdlc-qa-engineer", "qa-engineer"],
+  "Security Reviewer": ["ai-sdlc-security-reviewer", "security-reviewer"],
+  "Spec Validator": ["ai-sdlc-spec-validator", "spec-validator"],
+  "Technical Writer": ["ai-sdlc-technical-writer", "technical-writer"],
+  "Test Writer": ["ai-sdlc-test-writer", "test-writer"],
+  "AI Engineer": ["ai-sdlc-ai-engineer", "ai-engineer"],
 };
 
 /**

package/src/integrations/process-check.ts

@@ -0,0 +1,24 @@
+const isBrowser = typeof document !== "undefined";
+
+/**
+ * Returns true if any process with the given name is currently running.
+ * Always returns true in browser environments (process inspection not available).
+ * On Windows uses `tasklist`; on macOS/Linux uses `pgrep -x`.
+ */
+export async function isProcessRunning(processName: string): Promise<boolean> {
+  if (isBrowser) return true;
+  try {
+    const CHILD_PROCESS = "child_process";
+    const { execSync } = await import(/* @vite-ignore */ CHILD_PROCESS);
+    if (process.platform === "win32") {
+      const out = execSync(
+        `tasklist /FI "IMAGENAME eq ${processName}.exe" /NH 2>NUL`
+      ).toString();
+      return out.toLowerCase().includes(`${processName.toLowerCase()}.exe`);
+    }
+    execSync(`pgrep -x ${processName}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/prompts/ceremony/index.ts

@@ -3,6 +3,7 @@ export { buildPersonaExplorePrompt } from "./explore.js";
 export { buildDescriptionCheckPrompt } from "./description-check.js";
 export { buildRewriteScanPrompt, buildRewritePrompt } from "./rewrite.js";
 export { buildDedupPrompt } from "./dedup.js";
+export { buildUserDedupPrompt } from "./user-dedup.js";
 export type {
   PersonaExpirePromptData,
   PersonaExpireResult,

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

@@ -0,0 +1,74 @@
+import type { DedupPromptData } from "./types.js";
+
+// =============================================================================
+// USER-TRIGGERED DEDUP — Direct merge, no candidate-finding, no hedging
+// =============================================================================
+
+/**
+ * Prompt for user-confirmed deduplication.
+ *
+ * Unlike buildDedupPrompt (ceremony), this skips all decision-making — the user
+ * has already confirmed these entities are duplicates. Opus just merges.
+ * No hedging, no "our system BELIEVES these MAY be duplicates" language.
+ */
+export function buildUserDedupPrompt(data: DedupPromptData): { system: string; user: string } {
+  const typeLabel = data.itemType.charAt(0).toUpperCase() + data.itemType.slice(1);
+
+  const system = `You are merging duplicate ${typeLabel} records in a user's personal knowledge base. The user has manually confirmed that all records in this cluster refer to the same entity.
+
+**YOUR PRIME DIRECTIVE: LOSE NO DATA.**
+
+Your job is synthesis, not decision-making. Do not question whether these are duplicates — they are. Simply collapse them into one comprehensive, non-repetitive record.
+
+### Merge Rules:
+- Pick the most descriptive, commonly-used name as the canonical name
+- Union all unique details from every description — if it was in any record, it belongs in the merged record
+- Descriptions should be concise (under 300 chars) but complete — no detail left behind
+- Numeric fields: strength/confidence → take HIGHER; sentiment → AVERAGE; exposure → take HIGHER
+- relationship/category → pick most specific/accurate
+
+### Output Format:
+{
+  "update": [
+    /* The single merged canonical record with ALL fields preserved */
+    /* MUST include "id" (use the oldest/most-referenced record's ID), "type", "name", "description" */
+  ],
+  "remove": [
+    {"to_be_removed": "uuid-of-duplicate", "replaced_by": "uuid-of-canonical-record"},
+    /* One entry per record being absorbed */
+  ],
+  "add": []
+}
+
+Return raw JSON only. No markdown, no commentary.
+
+${buildRecordFormatHint(data.itemType)}`;
+
+  const user = JSON.stringify({
+    cluster: data.cluster.map(stripEmbedding),
+    cluster_type: data.itemType,
+    user_confirmed: true,
+  }, null, 2);
+
+  return { system, user };
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function stripEmbedding<T extends { embedding?: unknown }>(item: T): Omit<T, "embedding"> {
+  const { embedding: _, ...rest } = item;
+  return rest as Omit<T, "embedding">;
+}
+
+function buildRecordFormatHint(itemType: string): string {
+  switch (itemType) {
+    case "person":
+      return `Person fields: id, type, name, description, sentiment (-1 to 1), relationship, exposure_current (0-1), exposure_desired (0-1), learned_by (optional), last_changed_by (optional)`;
+    case "topic":
+      return `Topic fields: id, type, name, description, sentiment (-1 to 1), category, exposure_current (0-1), exposure_desired (0-1), learned_by (optional), last_changed_by (optional)`;
+    default:
+      return "";
+  }
+}

package/tui/README.md

@@ -87,6 +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> <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

@@ -0,0 +1,150 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+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, terms: string[], entities: Array<Topic | Person>): string {
+  const termDisplay = terms.map(t => t.includes(" ") ? `"${t}"` : t).join(" | ");
+  const header = [
+    `# /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).`,
+    ``,
+  ].join("\n");
+
+  const blocks = entities.map(entity => {
+    const lines = [
+      `- id: "${entity.id}"`,
+      `  name: "${entity.name.replace(/"/g, '\\"')}"`,
+      `  description: "${entity.description.replace(/"/g, '\\"')}"`,
+    ];
+
+    if ("relationship" in entity && entity.relationship) {
+      lines.push(`  relationship: "${entity.relationship}"`);
+    }
+    if ("category" in entity && entity.category) {
+      lines.push(`  category: "${entity.category}"`);
+    }
+    if (entity.learned_by) {
+      lines.push(`  learned_by: "${entity.learned_by}"`);
+    }
+
+    const date = entity.last_updated ? entity.last_updated.slice(0, 10) : "";
+    if (date) lines.push(`  last_updated: "${date}"`);
+
+    return lines.join("\n");
+  });
+
+  return header + blocks.join("\n\n") + "\n";
+}
+
+function parseDedupeYAML(content: string): string[] {
+  const ids: string[] = [];
+  const pattern = /^\s*- id:\s*"([^"]+)"/gm;
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(content)) !== null) {
+    ids.push(match[1]);
+  }
+  return ids;
+}
+
+function fuzzySearch(entities: Array<Topic | Person>, query: string): Array<Topic | Person> {
+  const lower = query.toLowerCase();
+  return entities.filter(entity =>
+    entity.name.toLowerCase().includes(lower)
+  );
+}
+
+export const dedupeCommand: Command = {
+  name: "dedupe",
+  aliases: [],
+  description: "Merge duplicate people or topics",
+  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> <term> ["term 2" ...]. Got: ${args[0] ?? "(none)"}`,
+        "error"
+      );
+      return;
+    }
+
+    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 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 ${terms.map(t => `"${t}"`).join(" | ")}`, "info");
+      return;
+    }
+
+    if (matches.length === 1) {
+      ctx.showNotification(`Only 1 ${type} matched — need at least 2 to merge`, "info");
+      return;
+    }
+
+    const yamlContent = buildDedupeYAML(type, terms, matches);
+
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: "ei-dedupe.yaml",
+      renderer: ctx.renderer,
+    });
+
+    if (result.aborted) {
+      ctx.showNotification("Dedupe cancelled", "info");
+      return;
+    }
+
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return;
+    }
+
+    if (result.content === null) {
+      ctx.showNotification("No changes — dedupe cancelled", "info");
+      return;
+    }
+
+    const keptIds = parseDedupeYAML(result.content);
+
+    if (keptIds.length < 2) {
+      ctx.showNotification("Need at least 2 entries to merge — dedupe cancelled", "error");
+      return;
+    }
+
+    ctx.ei.queueUserDedup(type, keptIds);
+    ctx.showNotification(
+      `Queued merge of ${keptIds.length} ${type}s — Opus will synthesize at high priority`,
+      "info"
+    );
+  },
+};

package/tui/src/components/PromptInput.tsx

@@ -25,6 +25,7 @@ import { queueCommand } from "../commands/queue";
 import { dlqCommand } from "../commands/dlq";
 import { toolsCommand } from "../commands/tools";
 import { authCommand } from '../commands/auth';
+import { dedupeCommand } from "../commands/dedupe";
 import { useOverlay } from "../context/overlay";
 import { CommandSuggest } from "./CommandSuggest";
 import { useKeyboard } from "@opentui/solid";
@@ -64,6 +65,7 @@ export function PromptInput() {
   registerCommand(dlqCommand);
   registerCommand(toolsCommand);
   registerCommand(authCommand);
+  registerCommand(dedupeCommand);
 
   let textareaRef: TextareaRenderable | undefined;
 
@@ -163,7 +165,8 @@ export function PromptInput() {
                                  text.startsWith("/context") ||
                                  text.startsWith("/messages") ||
                                  text === "/queue" ||
-                                 text === "/dlq";
+                                 text === "/dlq" ||
+                                 text.startsWith("/dedupe");
 
       if (!isEditorCmd && !opensEditorForData) {
         textareaRef?.clear();

package/tui/src/context/ei.tsx

@@ -106,6 +106,7 @@ export interface EiContextValue {
   getToolList: () => ToolDefinition[];
   updateToolProvider: (id: string, updates: Partial<Omit<ToolProvider, 'id' | 'created_at'>>) => Promise<boolean>;
   updateTool: (id: string, updates: Partial<Omit<ToolDefinition, 'id' | 'created_at'>>) => Promise<boolean>;
+  queueUserDedup: (itemType: "topic" | "person", entityIds: string[]) => void;
   cleanupTimers: () => void;
 }
 const EiContext = createContext<EiContextValue>();
@@ -141,6 +142,11 @@ export const EiProvider: ParentComponent = (props) => {
     }, 5000);
   };
 
+  const queueUserDedup = (itemType: "topic" | "person", entityIds: string[]): void => {
+    if (!processor) return;
+    processor.queueUserDedup(itemType, entityIds);
+  };
+
   const cleanupTimers = () => {
     if (notificationTimer) {
       clearTimeout(notificationTimer);
@@ -406,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> => {
@@ -661,6 +669,7 @@ export const EiProvider: ParentComponent = (props) => {
     getToolList,
     updateToolProvider,
     updateTool,
+    queueUserDedup,
     cleanupTimers,
   };
   return (

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,
     },