ei-tui 0.9.3 → 1.0.0

package/src/integrations/document/importer.ts

@@ -0,0 +1,82 @@
+import type { PersonaEntity } from "../../core/types.js";
+import { LLMRequestType, LLMPriority, LLMNextStep } from "../../core/types.js";
+import { EMMETT_PERSONA_DEFINITION } from "../../templates/emmett.js";
+import { recursiveCharacterSplit } from "./chunker.js";
+import type { DocumentImportOptions, DocumentImportResult } from "./types.js";
+
+const SEGMENTATION_SYSTEM_PROMPT = `You are a document segmentation assistant. Your job is to identify natural conceptual boundaries in document content and split it into coherent segments suitable for knowledge extraction. Each segment should be a self-contained unit of information.`;
+
+const SEGMENTATION_USER_TEMPLATE = `Split the following document content into conceptual segments. Return a JSON array of strings, where each string is one segment. Preserve all original text — do not summarize or paraphrase. Identify boundaries at topic shifts, section changes, or logical breaks.
+
+---
+
+{content}`;
+
+export async function importDocument(options: DocumentImportOptions): Promise<DocumentImportResult> {
+  const { stateManager, interface: eiInterface, content: rawContent, filename, signal } = options;
+
+  const isMarkdown = filename.toLowerCase().endsWith(".md") || filename.toLowerCase().endsWith(".markdown");
+
+  const result: DocumentImportResult = {
+    chunksQueued: 0,
+    documentName: filename,
+  };
+
+  let emmett = stateManager.persona_getById("emmet");
+  if (emmett?.is_archived) {
+    stateManager.persona_unarchive("emmet");
+    emmett = stateManager.persona_getById("emmet")!;
+  }
+  if (!emmett) {
+    const emmettEntity: PersonaEntity = {
+      ...EMMETT_PERSONA_DEFINITION,
+      id: "emmet",
+      display_name: "Emmett",
+      last_updated: new Date().toISOString(),
+    };
+    stateManager.persona_add(emmettEntity);
+    eiInterface.onPersonaAdded?.();
+    emmett = stateManager.persona_getById("emmet")!;
+  }
+
+  const sourceTag = `import:document:${filename}`;
+  const existingMsgs = stateManager.messages_get("emmet");
+  const staleIds = existingMsgs
+    .filter(m => m.external === true && m.source_tag === sourceTag)
+    .map(m => m.id);
+  if (staleIds.length > 0) {
+    stateManager.messages_remove("emmet", staleIds);
+  }
+
+  if (signal?.aborted) return result;
+
+  const preChunks = recursiveCharacterSplit(rawContent, { isMarkdown });
+
+  if (preChunks.length === 0) return result;
+
+  const batchId = crypto.randomUUID();
+  const docSettings = stateManager.getHuman().settings?.document;
+  const model = docSettings?.extraction_model ?? stateManager.getHuman().settings?.default_model;
+
+  for (let i = 0; i < preChunks.length; i++) {
+    const chunk = preChunks[i];
+    stateManager.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Low,
+      system: SEGMENTATION_SYSTEM_PROMPT,
+      user: SEGMENTATION_USER_TEMPLATE.replace("{content}", chunk),
+      next_step: LLMNextStep.HandleDocumentSegmentation,
+      model,
+      data: {
+        batchId,
+        filename,
+        chunkIndex: i,
+        originalContent: chunk,
+      },
+    });
+  }
+
+  result.chunksQueued = preChunks.length;
+  result.batchId = batchId;
+  return result;
+}

package/src/integrations/document/index.ts

@@ -0,0 +1,2 @@
+export { importDocument } from "./importer.js";
+export type { DocumentImportOptions, DocumentImportResult } from "./types.js";

package/src/integrations/document/invoice.ts

@@ -0,0 +1,63 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { UnsourcePreview, UnsourceResult } from "./unsource.js";
+
+/**
+ * Pure function — no filesystem access. Safe to call in any environment.
+ * Returns the invoice as a markdown string.
+ */
+export function generateInvoiceMarkdown(preview: UnsourcePreview, result: UnsourceResult): string {
+  const timestamp = new Date().toISOString();
+
+  const deletedCount = result.deleted.facts + result.deleted.topics + result.deleted.people;
+  const strippedCount = result.stripped.facts + result.stripped.topics + result.stripped.people;
+
+  const lines: string[] = [
+    `# Unsource: ${preview.sourceTag}`,
+    `Run at: ${timestamp}`,
+    "",
+    `## Deleted (${deletedCount} items, ${result.deleted.quotes} quotes)`,
+  ];
+
+  for (const f of preview.toDelete.facts) lines.push(`- [Fact] ${f.name}`);
+  for (const t of preview.toDelete.topics) lines.push(`- [Topic] ${t.name}`);
+  for (const p of preview.toDelete.people) lines.push(`- [Person] ${p.name}`);
+  for (const q of preview.toDelete.quotes) {
+    const excerpt = q.text.length > 80 ? `${q.text.slice(0, 80)}...` : q.text;
+    lines.push(`- [Quote] "${excerpt}"`);
+  }
+
+  if (
+    preview.toStrip.facts.length > 0 ||
+    preview.toStrip.topics.length > 0 ||
+    preview.toStrip.people.length > 0
+  ) {
+    lines.push("");
+    lines.push(`## Retained — shared with other sources (${strippedCount} items)`);
+    lines.push(`Source removed from these items. They had additional sources or non-Emmett personas.`);
+    lines.push("");
+    for (const f of preview.toStrip.facts) lines.push(`- [Fact] ${f.name}`);
+    for (const t of preview.toStrip.topics) lines.push(`- [Topic] ${t.name}`);
+    for (const p of preview.toStrip.people) lines.push(`- [Person] ${p.name}`);
+    lines.push("");
+    lines.push(`Run \`/me topics\` or \`/me people\` to review or delete retained items manually.`);
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+export async function writeUnsourceInvoice(
+  preview: UnsourcePreview,
+  result: UnsourceResult,
+  dataPath: string
+): Promise<string> {
+  const timestamp = new Date().toISOString();
+  const sanitizedTag = preview.sourceTag.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const filename = `${timestamp.replace(/[:.]/g, "-")}-${sanitizedTag}.md`;
+  const dir = join(dataPath, "unsourced");
+  const filePath = join(dir, filename);
+
+  await mkdir(dir, { recursive: true });
+  await writeFile(filePath, generateInvoiceMarkdown(preview, result), "utf8");
+  return filePath;
+}

package/src/integrations/document/types.ts

@@ -0,0 +1,16 @@
+import type { StateManager } from "../../core/state-manager.js";
+import type { Ei_Interface } from "../../core/types.js";
+
+export interface DocumentImportOptions {
+  stateManager: StateManager;
+  interface: Ei_Interface;
+  content: string;
+  filename: string;
+  signal?: AbortSignal;
+}
+
+export interface DocumentImportResult {
+  chunksQueued: number;
+  documentName: string;
+  batchId?: string;
+}

package/src/integrations/document/unsource.ts

@@ -0,0 +1,164 @@
+import type { StateManager } from "../../core/state-manager.js";
+
+export interface UnsourcePreview {
+  sourceTag: string;
+  toDelete: {
+    facts: Array<{ id: string; name: string }>;
+    topics: Array<{ id: string; name: string }>;
+    people: Array<{ id: string; name: string }>;
+    quotes: Array<{ id: string; text: string }>;
+  };
+  toStrip: {
+    facts: Array<{ id: string; name: string }>;
+    topics: Array<{ id: string; name: string }>;
+    people: Array<{ id: string; name: string }>;
+  };
+}
+
+export interface UnsourceResult {
+  sourceTag: string;
+  deleted: { facts: number; topics: number; people: number; quotes: number };
+  stripped: { facts: number; topics: number; people: number };
+}
+
+export function previewUnsource(sourceTag: string, stateManager: StateManager): UnsourcePreview {
+  const human = stateManager.getHuman();
+
+  const preview: UnsourcePreview = {
+    sourceTag,
+    toDelete: { facts: [], topics: [], people: [], quotes: [] },
+    toStrip: { facts: [], topics: [], people: [] },
+  };
+
+  for (const fact of human.facts) {
+    if (!fact.sources?.includes(sourceTag)) continue;
+    const remainingSources = fact.sources.filter(s => s !== sourceTag);
+    const nonEmmettPersonas = (fact.interested_personas ?? []).filter(id => id !== "emmet");
+    if (remainingSources.length === 0 && nonEmmettPersonas.length === 0) {
+      preview.toDelete.facts.push({ id: fact.id, name: fact.name });
+    } else {
+      preview.toStrip.facts.push({ id: fact.id, name: fact.name });
+    }
+  }
+
+  for (const topic of human.topics) {
+    if (!topic.sources?.includes(sourceTag)) continue;
+    const remainingSources = topic.sources.filter(s => s !== sourceTag);
+    const nonEmmettPersonas = (topic.interested_personas ?? []).filter(id => id !== "emmet");
+    if (remainingSources.length === 0 && nonEmmettPersonas.length === 0) {
+      preview.toDelete.topics.push({ id: topic.id, name: topic.name });
+    } else {
+      preview.toStrip.topics.push({ id: topic.id, name: topic.name });
+    }
+  }
+
+  for (const person of human.people) {
+    if (!person.sources?.includes(sourceTag)) continue;
+    const remainingSources = person.sources.filter(s => s !== sourceTag);
+    const nonEmmettPersonas = (person.interested_personas ?? []).filter(id => id !== "emmet");
+    if (remainingSources.length === 0 && nonEmmettPersonas.length === 0) {
+      preview.toDelete.people.push({ id: person.id, name: person.name });
+    } else {
+      preview.toStrip.people.push({ id: person.id, name: person.name });
+    }
+  }
+
+  const emmettMessages = stateManager.messages_get("emmet");
+  const sourceMessageIds = new Set(
+    emmettMessages
+      .filter(m => m.source_tag === sourceTag)
+      .map(m => m.id)
+  );
+
+  for (const quote of human.quotes) {
+    if (quote.message_id && sourceMessageIds.has(quote.message_id)) {
+      preview.toDelete.quotes.push({ id: quote.id, text: quote.text });
+    }
+  }
+
+  return preview;
+}
+
+export async function executeUnsource(
+  preview: UnsourcePreview,
+  stateManager: StateManager
+): Promise<UnsourceResult> {
+  const result: UnsourceResult = {
+    sourceTag: preview.sourceTag,
+    deleted: { facts: 0, topics: 0, people: 0, quotes: 0 },
+    stripped: { facts: 0, topics: 0, people: 0 },
+  };
+
+  for (const q of preview.toDelete.quotes) {
+    stateManager.human_quote_remove(q.id);
+    result.deleted.quotes++;
+  }
+
+  for (const f of preview.toDelete.facts) {
+    stateManager.human_fact_remove(f.id);
+    result.deleted.facts++;
+  }
+
+  for (const t of preview.toDelete.topics) {
+    stateManager.human_topic_remove(t.id);
+    result.deleted.topics++;
+  }
+
+  for (const p of preview.toDelete.people) {
+    stateManager.human_person_remove(p.id);
+    result.deleted.people++;
+  }
+
+  if (
+    preview.toStrip.facts.length > 0 ||
+    preview.toStrip.topics.length > 0 ||
+    preview.toStrip.people.length > 0
+  ) {
+    const human = stateManager.getHuman();
+    const stripIds = new Set([
+      ...preview.toStrip.facts.map(f => f.id),
+      ...preview.toStrip.topics.map(t => t.id),
+      ...preview.toStrip.people.map(p => p.id),
+    ]);
+
+    for (const fact of human.facts) {
+      if (stripIds.has(fact.id) && fact.sources) {
+        fact.sources = fact.sources.filter(s => s !== preview.sourceTag);
+        result.stripped.facts++;
+      }
+    }
+    for (const topic of human.topics) {
+      if (stripIds.has(topic.id) && topic.sources) {
+        topic.sources = topic.sources.filter(s => s !== preview.sourceTag);
+        result.stripped.topics++;
+      }
+    }
+    for (const person of human.people) {
+      if (stripIds.has(person.id) && person.sources) {
+        person.sources = person.sources.filter(s => s !== preview.sourceTag);
+        result.stripped.people++;
+      }
+    }
+
+    stateManager.setHuman(human);
+  }
+
+  const sourceMessageIds = stateManager.messages_get("emmet")
+    .filter(m => m.source_tag === preview.sourceTag)
+    .map(m => m.id);
+  if (sourceMessageIds.length > 0) {
+    stateManager.messages_remove("emmet", sourceMessageIds);
+  }
+
+  const filename = preview.sourceTag.startsWith("import:document:")
+    ? preview.sourceTag.slice("import:document:".length)
+    : preview.sourceTag;
+
+  const human = stateManager.getHuman();
+  if (human.settings?.document?.processed_documents) {
+    delete human.settings.document.processed_documents[filename];
+    stateManager.setHuman(human);
+  }
+
+  return result;
+}

package/src/integrations/opencode/importer.ts

@@ -245,7 +245,7 @@ export async function importOpenCodeSessions(
 
       const context: ExtractionContext = {
         personaId: persona.id,
-        personaDisplayName: persona.display_name,
+        channelDisplayName: persona.display_name,
         messages_context: contextMsgs,
         messages_analyze: toAnalyze,
         sources: [`opencode:${getMachineId()}:${targetSession.id}`],

package/src/integrations/persona-history/importer.ts

@@ -0,0 +1,197 @@
+import type { StateManager } from "../../core/state-manager.js";
+import type { Message } from "../../core/types.js";
+import {
+  queueTopicScan,
+  queuePersonScan,
+  type ExtractionContext,
+} from "../../core/orchestrators/human-extraction.js";
+
+export interface PersonaHistoryImportResult {
+  daysQueued: number;
+  personasProcessed: number;
+  scansQueued: number;
+  complete: boolean;
+}
+
+export interface PersonaHistoryImporterOptions {
+  stateManager: StateManager;
+}
+
+function dayBounds(dateStr: string): { start: number; end: number } {
+  const start = new Date(dateStr + "T00:00:00.000Z").getTime();
+  const end = new Date(dateStr + "T23:59:59.999Z").getTime();
+  return { start, end };
+}
+
+function nextDay(dateStr: string): string {
+  const d = new Date(dateStr + "T12:00:00.000Z");
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+}
+
+function todayUTC(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function messagesForDay(messages: Message[], start: number, end: number): Message[] {
+  return messages.filter(m => {
+    const ts = new Date(m.timestamp).getTime();
+    return ts >= start && ts <= end;
+  });
+}
+
+function hasUnprocessed(messages: Message[]): boolean {
+  return messages.some(m => !m.t || !m.p);
+}
+
+export async function importPersonaHistory(
+  options: PersonaHistoryImporterOptions
+): Promise<PersonaHistoryImportResult> {
+  const { stateManager } = options;
+  const human = stateManager.getHuman();
+  const settings = human.settings?.personaHistory;
+
+  const result: PersonaHistoryImportResult = {
+    daysQueued: 0,
+    personasProcessed: 0,
+    scansQueued: 0,
+    complete: false,
+  };
+
+  if (settings?.complete) {
+    result.complete = true;
+    return result;
+  }
+
+  const personas = stateManager.persona_getAll().filter(p => !p.is_archived);
+  const today = todayUTC();
+
+  let currentDate = settings?.last_queued_date
+    ? nextDay(settings.last_queued_date)
+    : settings?.start_date ?? findEarliestMessageDate(stateManager) ?? today;
+
+  if (currentDate > today) {
+    markComplete(stateManager);
+    result.complete = true;
+    return result;
+  }
+
+  console.log(`[PersonaHistory] Queuing day: ${currentDate}`);
+
+  const { start, end } = dayBounds(currentDate);
+
+  for (const persona of personas) {
+    const allMessages = stateManager.messages_get(persona.id);
+    const dayMessages = messagesForDay(allMessages, start, end);
+
+    if (dayMessages.length === 0) continue;
+    if (!hasUnprocessed(dayMessages)) continue;
+
+    const firstDayIdx = allMessages.findIndex(m => {
+      const ts = new Date(m.timestamp).getTime();
+      return ts >= start;
+    });
+    const contextMsgs = firstDayIdx > 0 ? allMessages.slice(Math.max(0, firstDayIdx - 20), firstDayIdx) : [];
+
+    const context: ExtractionContext = {
+      personaId: persona.id,
+      channelDisplayName: persona.display_name,
+      messages_context: contextMsgs,
+      messages_analyze: dayMessages,
+    };
+
+    const extractionModel = settings?.extraction_model;
+    queueTopicScan(context, stateManager, { extraction_model: extractionModel });
+    queuePersonScan(context, stateManager, { extraction_model: extractionModel });
+
+    result.personasProcessed++;
+    result.scansQueued += 2;
+  }
+
+  for (const room of Object.values((stateManager.getStorageState() as any).rooms ?? {})) {
+    const r = room as { id: string; display_name: string; messages?: Message[] };
+    if (!r.messages || r.messages.length === 0) continue;
+
+    const dayMessages = messagesForDay(r.messages, start, end);
+    if (dayMessages.length === 0) continue;
+    if (!hasUnprocessed(dayMessages)) continue;
+
+    const firstDayIdx = r.messages.findIndex((m: Message) => {
+      const ts = new Date(m.timestamp).getTime();
+      return ts >= start;
+    });
+    const contextMsgs = firstDayIdx > 0 ? r.messages.slice(Math.max(0, firstDayIdx - 20), firstDayIdx) : [];
+
+    const context: ExtractionContext = {
+      personaId: r.id,
+      channelDisplayName: r.display_name,
+      messages_context: contextMsgs,
+      messages_analyze: dayMessages,
+      roomId: r.id,
+    };
+
+    const extractionModel = settings?.extraction_model;
+    queueTopicScan(context, stateManager, { extraction_model: extractionModel });
+    queuePersonScan(context, stateManager, { extraction_model: extractionModel });
+
+    result.scansQueued += 2;
+  }
+
+  result.daysQueued = 1;
+
+  const isLastDay = currentDate >= today;
+  advanceProgress(stateManager, currentDate, isLastDay);
+
+  if (isLastDay) {
+    result.complete = true;
+    console.log(`[PersonaHistory] All days queued — marking complete`);
+  } else {
+    console.log(`[PersonaHistory] Day ${currentDate} queued (${result.scansQueued} scans), next: ${nextDay(currentDate)}`);
+  }
+
+  return result;
+}
+
+function findEarliestMessageDate(stateManager: StateManager): string | null {
+  const personas = stateManager.persona_getAll();
+  let earliest: number | null = null;
+
+  for (const persona of personas) {
+    const msgs = stateManager.messages_get(persona.id);
+    for (const m of msgs) {
+      const ts = new Date(m.timestamp).getTime();
+      if (earliest === null || ts < earliest) earliest = ts;
+    }
+  }
+
+  return earliest !== null ? new Date(earliest).toISOString().slice(0, 10) : null;
+}
+
+function advanceProgress(stateManager: StateManager, date: string, complete: boolean): void {
+  const human = stateManager.getHuman();
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      personaHistory: {
+        ...human.settings?.personaHistory,
+        last_queued_date: date,
+        ...(complete && { complete: true }),
+      },
+    },
+  });
+}
+
+function markComplete(stateManager: StateManager): void {
+  const human = stateManager.getHuman();
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      personaHistory: {
+        ...human.settings?.personaHistory,
+        complete: true,
+      },
+    },
+  });
+}

package/src/integrations/persona-history/index.ts

@@ -0,0 +1,3 @@
+export { importPersonaHistory } from "./importer.js";
+export type { PersonaHistoryImportResult, PersonaHistoryImporterOptions } from "./importer.js";
+export type { PersonaHistorySettings } from "./types.js";

package/src/integrations/persona-history/types.ts

@@ -0,0 +1,7 @@
+export interface PersonaHistorySettings {
+  integration?: boolean;
+  extraction_model?: string;
+  start_date?: string;      // ISO date string "YYYY-MM-DD", defaults to earliest message found
+  last_queued_date?: string; // ISO date of last day fully queued — resume point if interrupted
+  complete?: boolean;       // Set true when all days have been queued; prevents re-runs
+}

package/src/prompts/ceremony/dedup.ts

@@ -89,7 +89,7 @@ ${buildRecordFormatExamples(data.itemType)}
 
 ### Rules:
 - Do NOT invent information. Only redistribute what exists in the cluster.
-- Descriptions should be concise—ideally under 300 characters, never over 500.
+- Descriptions should be concise — ideally under 300 characters, never over 500 for regular topics. Technical topics (category: "Technical") may go up to 900 characters — preserve their specific gotchas, decisions, and open questions.
 - Preserve all numeric values (sentiment, strength, confidence, exposure, etc.) from source records. When merging, take the HIGHER value for strength/confidence, AVERAGE for sentiment.
 - Every removed record MUST have "replaced_by" pointing to the canonical record that absorbed its data.
 - The "update" array should contain AT LEAST ONE record (the canonical/merged one), even if all others are removed.
@@ -165,6 +165,8 @@ Similarity of meaning is not the same as identity. "Concern about job security"
 
 Ask yourself: *If a persona referenced the established record in conversation, would the newcomer feel like a repeat? Or would it feel like something different being said?*
 
+**Default to keeping both.** Merge only when you are certain these describe the same concept — thematic overlap, shared vocabulary, or similar domain are not sufficient. A false merge destroys information permanently; a false keep is harmless.
+
 If they are the same thing: **merge**. Preserve every unique detail from both. The newcomer's description is synthesized and current — weight it, but don't discard what the established record learned first.
 
 If they are distinct: **keep both**. Return them both in \`update\` unchanged. Leave \`remove\` and \`add\` empty.
@@ -183,7 +185,8 @@ Rules:
 - \`add\` is always empty here. We are not creating new records from this decision.
 - If merging: the merged record goes in \`update\`, the absorbed record goes in \`remove\`.
 - If keeping both: return both in \`update\` exactly as received. Do not modify either.
-- Descriptions must stay concise — under 300 characters, never over 500. Synthesize; don't concatenate.
+- Descriptions must stay concise — under 300 characters, never over 500 for regular topics. **Technical topics** (category: "Technical") may go up to 900 characters — they are knowledge bases, not summaries. Synthesize regular topics; preserve detail in Technical ones.
+- For Technical topics: two records about the same technology but different aspects (e.g., "Uniform composition model" vs "Uniform preview setup") are **NOT duplicates** — keep both. Only merge if they are genuinely the same concept described twice.
 - When merging numeric fields: take the HIGHER value for \`exposure_current\`, \`exposure_desired\`, \`strength\`, \`confidence\`. Average \`sentiment\`.
 - Do NOT invent information. Only what exists in these two records.
 
@@ -297,7 +300,7 @@ function buildTopicExamples(): string {
   "name": "Software Architecture",    // REQUIRED
   "description": "System design patterns, microservices, event-driven architecture. Passionate about scalability and maintainability.", // REQUIRED
   "sentiment": 0.8,                    // -1.0 to 1.0 (average when merging)
-  "category": "Interest",             // REQUIRED - Interest, Goal, Dream, Conflict, Concern, Fear, Hope, Plan, Project (pick most common)
+  "category": "Interest",             // REQUIRED - Interest, Goal, Dream, Conflict, Concern, Fear, Hope, Plan, Project, Event, Technical (pick most common)
   "exposure_current": 0.6,            // 0.0 to 1.0, how recently discussed (take HIGHER when merging)
   "exposure_desired": 0.9,            // 0.0 to 1.0, how much they want to discuss (take HIGHER when merging)
   "last_ei_asked": "2024-03-10T08:00:00Z", // OPTIONAL - ISO timestamp or null
@@ -330,6 +333,7 @@ CATEGORIES explained:
 - Goal: Things they want to achieve
 - Concern/Fear: Things that worry them
 - Plan/Project: Active work or intentions
+- Technical: Tools, platforms, frameworks, or technical concepts being learned or used — knowledge base entries, NOT summaries
 
 GOOD vs BAD descriptions:
 ✅ GOOD: "Functional programming paradigm. Loves immutability and pure functions. Uses in side projects."

package/src/prompts/ceremony/index.ts

@@ -1,17 +1,8 @@
-export { buildPersonaExpirePrompt } from "./expire.js";
-export { buildPersonaExplorePrompt } from "./explore.js";
-export { buildDescriptionCheckPrompt } from "./description-check.js";
-export { buildRewriteScanPrompt, buildRewritePrompt } from "./rewrite.js";
+export { buildPersonRewriteScanPrompt, buildPersonRewriteSplitPrompt } from "./people-rewrite.js";
+export { buildTopicRewriteScanPrompt, buildTopicRewriteSplitPrompt } from "./topic-rewrite.js";
 export { buildDedupPrompt, buildValidatePrompt } from "./dedup.js";
 export { buildUserDedupPrompt } from "./user-dedup.js";
-export { buildPersonMigrationPrompt, type PersonMigrationPromptData } from "./person-migration.js";
 export type {
-  PersonaExpirePromptData,
-  PersonaExpireResult,
-  PersonaExplorePromptData,
-  PersonaExploreResult,
-  DescriptionCheckPromptData,
-  DescriptionCheckResult,
   RewriteItemType,
   RewriteScanPromptData,
   RewriteScanResult,