ei-tui 0.3.9 → 0.4.0

package/package.json

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

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
@@ -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/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/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/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> "<query>"` | | Fuzzy-search and merge duplicate people or topics in `$EDITOR` |
 | `/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,132 @@
+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, query: string, entities: Array<Topic | Person>): string {
+  const header = [
+    `# /dedupe ${type} "${query}"`,
+    `# 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> "<query>"',
+
+  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)"}`,
+        "error"
+      );
+      return;
+    }
+
+    const query = args.slice(1).join(" ").trim();
+    if (!query) {
+      ctx.showNotification(`Usage: /dedupe ${type} "<query>" — query is required`, "error");
+      return;
+    }
+
+    const human = await ctx.ei.getHuman();
+    const pool: Array<Topic | Person> = type === "topic" ? human.topics : human.people;
+    const matches = fuzzySearch(pool, query);
+
+    if (matches.length === 0) {
+      ctx.showNotification(`No ${type}s matching "${query}"`, "info");
+      return;
+    }
+
+    if (matches.length === 1) {
+      ctx.showNotification(`Only 1 ${type} matches "${query}" — need at least 2 to merge`, "info");
+      return;
+    }
+
+    const yamlContent = buildDedupeYAML(type, query, 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);
@@ -661,6 +667,7 @@ export const EiProvider: ParentComponent = (props) => {
     getToolList,
     updateToolProvider,
     updateTool,
+    queueUserDedup,
     cleanupTimers,
   };
   return (