ei-tui 0.9.4 → 1.0.0

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/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,4 +1,5 @@
-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 type {

package/src/prompts/ceremony/people-rewrite.ts

@@ -0,0 +1,190 @@
+import type { RewriteScanPromptData, RewritePromptData } from "./types.js";
+
+// =============================================================================
+// What belongs in a Person record (shared reference for both prompts)
+// =============================================================================
+//
+// A Person record is a RELATIONSHIP PROFILE — who this person is, how they
+// relate to the human user, and anything a persona would use to meaningfully
+// reference them in conversation 6+ months from now.
+//
+// A Person record is NOT:
+//   - A project status log
+//   - A record of ticket numbers, PR numbers, or sprint assignments
+//   - A biography of their personal habits and hobbies
+//   - A shared-interest tracker (those are Topics)
+//
+// The test: "Would this still be true and useful if you ran into this person
+// at a coffee shop, unrelated to any current project?"
+
+const PERSON_CONTRACT = `A Person record is a **relationship profile** — who this person IS, how they relate to the human user, their character and communication style, and anything that makes them recognizable across time and context.
+
+It is NOT:
+- A project status log (ticket numbers, PR references, sprint assignments)
+- A record of shared interests that could stand alone as a Topic
+- Personal biography unrelated to the relationship (commute, hobbies, hometown)
+- Technical knowledge attributed to them rather than about them
+
+**The test**: Would this detail still be true and useful if you ran into this person at a coffee shop, unrelated to any current project, in six months?`;
+
+// =============================================================================
+// PHASE 1: SCAN — Identify subjects that don't belong in a Person record
+// =============================================================================
+
+export function buildPersonRewriteScanPrompt(data: RewriteScanPromptData): { system: string; user: string } {
+  const system = `You are auditing a Person record in a personal knowledge base.
+
+${PERSON_CONTRACT}
+
+Your job: identify **subjects buried in this description that fail the test above**.
+
+For each subject that doesn't belong, return a short phrase (3-8 words) that describes it — specific enough to search for matching records. These phrases will be used to find existing Topics this content might belong in.
+
+Rules:
+- Do NOT include the relationship profile itself — who they are, their role, how you know them, their character
+- Be specific: "React performance patterns" beats "technical stuff"
+- If the record is clean — everything in it passes the test — return an empty array
+
+Return a raw JSON array of strings. No markdown fencing, no commentary.
+
+Example — a Person named "Nicholas" whose description includes sprint ticket numbers:
+["CMIDP sprint ticket assignments", "ASU Data Lake access provisioning details"]`;
+
+  const payload = JSON.stringify({
+    name: (data.item as { name?: string }).name,
+    description: data.item.description,
+    relationship: (data.item as { relationship?: string }).relationship,
+  }, null, 2);
+
+  const user = `${payload}
+
+---
+
+Return a raw JSON array of subject phrases found in this Person record that don't belong there. Return [] if the record is clean.`;
+
+  return { system, user };
+}
+
+// =============================================================================
+// PHASE 2: SPLIT — Slim the Person, redistribute subjects to Topics
+// =============================================================================
+
+function buildPersonExistingExample(): string {
+  return `{
+  "id": "existing-uuid",
+  "type": "person",
+  "name": "Nicholas",
+  "description": "Backend engineer on the CMIDP team. Thoughtful code reviewer who flags architectural concerns — specifically around concurrency and queue isolation. Direct point of contact for Data Lake access provisioning.",
+  "relationship": "coworker"
+}`;
+}
+
+function buildPersonNewTopicExample(): string {
+  return `{
+  "type": "topic",
+  "name": "CMIDP Sprint 86 work",
+  "description": "Nicholas owns 4 tickets in Sprint 86 including course list ordering bugs (CMIDP-2604, CMIDP-2441, CMIDP-2686) and course sequencing (CMIDP-2624).",
+  "sentiment": 0.5,
+  "category": "Project"
+}`;
+}
+
+export function buildPersonRewriteSplitPrompt(data: RewritePromptData): { system: string; user: string } {
+  const system = `You are reorganizing a Person record in a personal knowledge base.
+
+${PERSON_CONTRACT}
+
+An earlier scan identified subjects in this Person record that don't belong there. For each subject, we searched the knowledge base for existing Topics that might already cover it.
+
+Your job:
+1. **Slim the Person** — remove the identified subjects AND any other content that fails the relationship profile test (personal trivia, lifestyle details, biographical facts unrelated to the relationship). Keep only: who they are, their role, their character, how the human user knows and works with them.
+2. **Redistribute each identified subject** — if a matching Topic exists in the search results, move the content there. If not, create a new Topic.
+3. **Discard what isn't worth a Topic** — personal trivia (hobbies, commute, hometown) that has no standalone value doesn't need to become a Topic. Just remove it from the Person.
+4. **Lose NO relationship data** — everything about how this person relates to the human user must survive.
+
+Record format for the Person (MUST keep "id", type stays "person"):
+${buildPersonExistingExample()}
+
+Record format for a new Topic created from extracted content:
+${buildPersonNewTopicExample()}
+
+Rules:
+- The original Person record (id: "${data.item.id}") MUST appear in "existing", slimmed down
+- Person description after slimming: 2-4 sentences, relationship profile only. **If it still contains city, commute, hobbies, or lifestyle details after slimming — remove them.** Those are not relationship data.
+- Topics created from person content: use the most appropriate category (Technical, Project, Interest, etc.)
+- People MUST include "relationship"
+- Topics MUST include "category"
+- Do NOT invent information — only redistribute what exists in the original record
+- Do NOT remove the person's relationship, role, character, or how the human user knows them — only the non-person content
+
+**What to KEEP in the Person description**: role, expertise, *why* the human user works with them (their operational function in the relationship), how they communicate, character traits, how the human user knows them.
+**What to REMOVE from the Person description**: current project status, ticket/PR numbers, shared interests (→ Topic), city/commute/hobbies (→ discard).
+
+The distinction:
+- "Data Lake bucket owner responsible for access provisioning" → KEEP (operational role in the relationship)
+- "Currently owns 4 tickets in Sprint 86" → REMOVE (current sprint status, not who they are)
+- "Left detailed comments on PR #1644 identifying architectural concerns around concurrency" → KEEP the insight, DROP the PR reference: "Flags architectural concerns around concurrency and queue isolation" belongs in the description; "PR #1644" does not.
+
+Return raw JSON with exactly two keys:
+{
+  "existing": [ /* slimmed Person + any existing Topics being updated */ ],
+  "new": [ /* new Topics for subjects with no existing match */ ]
+}
+
+No markdown fencing, no commentary.`;
+
+  const subjects = data.subjects.map(s => ({
+    search_term: s.searchTerm,
+    matches: s.matches.map(m => ({
+      id: (m as { id?: string }).id,
+      name: (m as { name?: string }).name,
+      description: m.description,
+      category: (m as { category?: string }).category,
+    })),
+  }));
+
+  const payload = JSON.stringify({
+    original_person: {
+      id: data.item.id,
+      name: (data.item as { name?: string }).name,
+      description: data.item.description,
+      relationship: (data.item as { relationship?: string }).relationship,
+      sentiment: data.item.sentiment,
+    },
+    subjects_to_extract: subjects,
+  }, null, 2);
+
+  const schemaReminder = `**Return JSON:**
+\`\`\`json
+{
+  "existing": [
+    {
+      "id": "uuid-of-person",
+      "type": "person",
+      "name": "Person Name",
+      "description": "Slimmed relationship profile only",
+      "relationship": "coworker"
+    }
+  ],
+  "new": [
+    {
+      "type": "topic",
+      "name": "Subject Name",
+      "description": "Content extracted from person record",
+      "sentiment": 0.5,
+      "category": "Project|Technical|Interest|etc."
+    }
+  ]
+}
+\`\`\`
+
+Return raw JSON only.`;
+
+  const user = `${payload}
+
+---
+
+${schemaReminder}`;
+
+  return { system, user };
+}