ei-tui 1.1.0 → 1.2.0

package/src/core/orchestrators/human-extraction.ts

@@ -195,6 +195,15 @@ export function queuePersonScan(context: ExtractionContext, state: StateManager,
   
   if (chunks.length === 0) return 0;
 
+  // If the persona has a pending_update (reflection in progress), gate person
+  // scans so handleHumanPersonScan won't queue updates for persona-linked people.
+  // This prevents importers and other callers from bypassing the reflection lock
+  // — they don't know about pending_update, so we enforce it here centrally.
+  const persona = state.persona_getById(context.personaId);
+  const effectiveOptions: ExtractionOptions | undefined = persona?.pending_update
+    ? { ...options, reflection_progress: 1 }
+    : options;
+
   // Pre-mark messages before enqueuing — prevents duplicate scans if the
   // queue check fires again during LLM latency (100ms loop × 5s call = 50 dupes)
   for (const chunk of chunks) {
@@ -225,7 +234,7 @@ export function queuePersonScan(context: ExtractionContext, state: StateManager,
       user: prompt.user,
       next_step: LLMNextStep.HandleHumanPersonScan,
       data: {
-        ...options,
+        ...effectiveOptions,
         personaId: chunk.personaId,
         personaDisplayName: chunk.channelDisplayName,
         analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),

package/src/core/processor.ts

@@ -44,6 +44,7 @@ import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.
 import { EMMETT_PERSONA_DEFINITION } from "../templates/emmett.js";
 import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueReflectionDrain, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
 import { finishDocumentBatch } from "./handlers/document-segmentation.js";
+import { buildSynthesisPrompt } from "../prompts/synthesis/index.js";
 import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 import { DEFAULT_SEED_TRAITS } from "./constants/seed-traits.js";
 
@@ -335,6 +336,140 @@ export class Processor {
     return executeUnsource(preview, this.stateManager);
   }
 
+  async generateDocument(subject: string): Promise<{ slug: string }> {
+    this.bootstrapEmmett();
+    const slugBase = subject
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .slice(0, 40);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const slug = `${slugBase}_${timestamp}`;
+
+    const primary = await this.searchHumanData(subject, { limit: 20 });
+    if (
+      primary.facts.length === 0 &&
+      primary.topics.length === 0 &&
+      primary.people.length === 0 &&
+      primary.quotes.length === 0
+    ) {
+      throw new Error(`No knowledge found about '${subject}'`);
+    }
+
+    const seenQuoteIds = new Set<string>();
+    const seenItemIds = new Set<string>(
+      [...primary.topics, ...primary.people, ...primary.facts].map(i => i.id)
+    );
+
+    const MAX_QUOTES_PER_ENTITY = 3;
+
+    const enrichTopic = (topic: import("../prompts/synthesis/types.js").EnrichedTopic["topic"]) => {
+      const linked = this.stateManager.human_quote_getForDataItem(topic.id)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+        .slice(0, MAX_QUOTES_PER_ENTITY);
+      linked.forEach(q => seenQuoteIds.add(q.id));
+      return { topic, quotes: linked };
+    };
+
+    const enrichPerson = (person: import("../prompts/synthesis/types.js").EnrichedPerson["person"]) => {
+      const linked = this.stateManager.human_quote_getForDataItem(person.id)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+        .slice(0, MAX_QUOTES_PER_ENTITY);
+      linked.forEach(q => seenQuoteIds.add(q.id));
+      return { person, quotes: linked };
+    };
+
+    const enrichedTopics = primary.topics.map(enrichTopic);
+    const enrichedPeople = primary.people.map(enrichPerson);
+
+    const human = this.stateManager.getHuman();
+    const allItems = [...human.facts, ...human.topics, ...human.people];
+
+    const MAX_SECONDARY_ENTITIES = 10;
+
+    const secondaryTopics: typeof enrichedTopics = [];
+    const secondaryPeople: typeof enrichedPeople = [];
+    const secondaryFacts: typeof primary.facts = [];
+
+    outer: for (const quote of [...enrichedTopics.flatMap(e => e.quotes), ...enrichedPeople.flatMap(e => e.quotes)]) {
+      for (const itemId of quote.data_item_ids) {
+        if (secondaryTopics.length + secondaryPeople.length + secondaryFacts.length >= MAX_SECONDARY_ENTITIES) break outer;
+        if (seenItemIds.has(itemId)) continue;
+        seenItemIds.add(itemId);
+        const item = allItems.find(i => i.id === itemId);
+        if (!item) continue;
+        if (human.topics.find(t => t.id === itemId)) {
+          secondaryTopics.push(enrichTopic(item as typeof primary.topics[0]));
+        } else if (human.people.find(p => p.id === itemId)) {
+          secondaryPeople.push(enrichPerson(item as typeof primary.people[0]));
+        } else if (human.facts.find(f => f.id === itemId)) {
+          secondaryFacts.push(item as typeof primary.facts[0]);
+        }
+      }
+    }
+
+    const standaloneQuotes = primary.quotes.filter(q => !seenQuoteIds.has(q.id));
+
+    const allLoadedFacts = [...primary.facts, ...secondaryFacts];
+    const allLoadedTopics = [...enrichedTopics, ...secondaryTopics];
+    const allLoadedPeople = [...enrichedPeople, ...secondaryPeople];
+
+    const loadedEntityNames = new Map<string, string>();
+    for (const f of allLoadedFacts) loadedEntityNames.set(f.id, f.name);
+    for (const { topic } of allLoadedTopics) loadedEntityNames.set(topic.id, topic.name);
+    for (const { person } of allLoadedPeople) loadedEntityNames.set(person.id, person.name);
+
+    const prompt = buildSynthesisPrompt({
+      subject,
+      facts: allLoadedFacts,
+      topics: allLoadedTopics,
+      people: allLoadedPeople,
+      standaloneQuotes,
+      loadedEntityNames,
+    });
+
+    const model = this.stateManager.getHuman().settings?.rewrite_model
+      ?? this.stateManager.getHuman().settings?.default_model;
+
+    this.stateManager.queue_enqueue({
+      type: LLMRequestType.Raw,
+      priority: LLMPriority.Normal,
+      system: prompt.system,
+      user: prompt.user,
+      next_step: LLMNextStep.HandleKnowledgeSynthesis,
+      model,
+      data: { slug, subject },
+    });
+
+    return { slug };
+  }
+
+  checkGenerationModel(): { model: string; isRewriteModel: boolean } {
+    const settings = this.stateManager.getHuman().settings;
+    if (settings?.rewrite_model) {
+      return { model: settings.rewrite_model, isRewriteModel: true };
+    }
+    return { model: settings?.default_model ?? "unknown", isRewriteModel: false };
+  }
+
+  async getGeneratedDocumentContent(slug: string): Promise<string | null> {
+    const messages = this.stateManager.messages_get("emmet");
+    const target = `generate:document:${slug}`;
+    const message = messages.find(m => m.source_tag === target);
+    return message?.content ?? null;
+  }
+
+  async reRunDocument(slug: string): Promise<{ slug: string }> {
+    const docs = this.stateManager.getHuman().settings?.document?.processed_documents ?? {};
+    const entry = docs[slug];
+    if (!entry || entry.type !== "generated" || !entry.subject) {
+      throw new Error(`No generated document found for slug "${slug}"`);
+    }
+    const subject = entry.subject;
+    const preview = this.getUnsourcePreview(`generate:document:${slug}`);
+    await this.executeUnsource(preview);
+    return this.generateDocument(subject);
+  }
+
   /**
    * Seed built-in tool providers and tools if they don't exist yet.
    * Called on every startup (after state load/restore) — safe to call repeatedly.
@@ -1087,6 +1222,7 @@ const toolNextSteps = new Set([
   LLMNextStep.HandleEiHeartbeat,
   LLMNextStep.HandleToolContinuation,
   LLMNextStep.HandleDedupCurate,
+  LLMNextStep.HandleKnowledgeSynthesis,
 ]);
             const toolPersonaId =
               personaId ??
@@ -1101,9 +1237,17 @@ const toolNextSteps = new Set([
               (request.next_step === LLMNextStep.HandleToolContinuation &&
                 request.data.originalNextStep === LLMNextStep.HandleDedupCurate);
 
+            const isSynthesisRequest = request.next_step === LLMNextStep.HandleKnowledgeSynthesis ||
+              (request.next_step === LLMNextStep.HandleToolContinuation &&
+                request.data.originalNextStep === LLMNextStep.HandleKnowledgeSynthesis);
+
             let tools: ToolDefinition[] = [];
             if (isDedupRequest) {
               tools = SYSTEM_TOOLS.filter(t => t.name === "find_memory");
+            } else if (isSynthesisRequest) {
+              tools = SYSTEM_TOOLS.filter(t =>
+                t.name === "find_memory" || t.name === "fetch_memory" || t.name === "fetch_message"
+              );
             } else if (toolNextSteps.has(request.next_step) && toolPersonaId) {
               tools = [...SYSTEM_TOOLS, ...this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)];
             }
@@ -1760,6 +1904,17 @@ const toolNextSteps = new Set([
           this.interface.onHumanUpdated?.();
         }
       }
+
+      const isSynthesisCompletion =
+        response.request.next_step === LLMNextStep.HandleKnowledgeSynthesis ||
+        (response.request.next_step === LLMNextStep.HandleToolContinuation &&
+          response.request.data.originalNextStep === LLMNextStep.HandleKnowledgeSynthesis);
+      if (isSynthesisCompletion) {
+        const slug = response.request.data.slug as string;
+        const hasContent = slug && this.stateManager.messages_get("emmet")
+          .some(m => m.source_tag === `generate:document:${slug}`);
+        if (hasContent) this.interface.onDocumentGenerated?.(slug);
+      }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       const result = this.stateManager.queue_fail(response.request.id, errorMsg);

package/src/core/queue-manager.ts

@@ -51,6 +51,15 @@ export async function getQueueStatus(sm: StateManager): Promise<QueueStatus> {
   }
   const extracting_documents = extractingSet.size > 0 ? Array.from(extractingSet) : undefined;
 
+  const generatingSet: string[] = [];
+  for (const item of activeItems) {
+    if (item.next_step === LLMNextStep.HandleKnowledgeSynthesis) {
+      const slug = (item.data as { slug?: string }).slug;
+      if (slug) generatingSet.push(slug);
+    }
+  }
+  const generating_documents = generatingSet.length > 0 ? generatingSet : undefined;
+
   return {
     state: sm.queue_isPaused()
       ? "paused"
@@ -62,6 +71,7 @@ export async function getQueueStatus(sm: StateManager): Promise<QueueStatus> {
     embedding_warning: sm.embedding_getWarning() || undefined,
     pending_documents,
     extracting_documents,
+    generating_documents,
   };
 }
 

package/src/core/state-manager.ts

@@ -71,6 +71,7 @@ export class StateManager {
     this.migrateProviderModel();
     this.migrateThemes();
     this.migrateFfaParentIds();
+    this.migrateDocumentSettings();
   }
 
   /**
@@ -586,6 +587,40 @@ export class StateManager {
     }
   }
 
+  private migrateDocumentSettings(): void {
+    const human = this.humanState.get();
+    const doc = human.settings?.document;
+    if (!doc) return;
+
+    let migrated = false;
+
+    const existing = doc.processed_documents ?? {};
+    for (const [key, value] of Object.entries(existing)) {
+      if (typeof value === "string") {
+        (existing as Record<string, unknown>)[key] = { created_at: value, type: "imported" };
+        migrated = true;
+      }
+    }
+
+    const legacy = (doc as Record<string, unknown>).generated_documents as
+      | Record<string, { subject: string; created_at: string }>
+      | undefined;
+    if (legacy) {
+      for (const [slug, record] of Object.entries(legacy)) {
+        existing[slug] = { created_at: record.created_at, type: "generated", subject: record.subject };
+      }
+      delete (doc as Record<string, unknown>).generated_documents;
+      migrated = true;
+    }
+
+    if (migrated) {
+      doc.processed_documents = existing as import("./types/entities.js").DocumentSettings["processed_documents"];
+      this.humanState.set(human);
+      this.scheduleSave();
+      console.log("[StateManager] Migrated document settings to unified processed_documents schema");
+    }
+  }
+
   getHuman(): HumanEntity {
     return this.humanState.get();
   }

package/src/core/tools/builtin/fetch-memory.ts

@@ -4,20 +4,20 @@ import type { Fact, Topic, Person, Quote, HumanEntity } from "../../types.js";
 type GetHuman = () => HumanEntity;
 
 function cleanFact(f: Fact): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, ...rest } = f;
-  void embedding; void rewrite_checked; void persona_groups;
+  const { embedding, persona_groups, ...rest } = f;
+  void embedding; void persona_groups;
   return rest;
 }
 
 function cleanTopic(t: Topic): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, last_ei_asked, ...rest } = t;
-  void embedding; void rewrite_checked; void persona_groups; void last_ei_asked;
+  const { embedding, rewrite_length_floor, persona_groups, last_ei_asked, ...rest } = t;
+  void embedding; void rewrite_length_floor; void persona_groups; void last_ei_asked;
   return rest;
 }
 
 function cleanPerson(p: Person): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, last_ei_asked, ...rest } = p;
-  void embedding; void rewrite_checked; void persona_groups; void last_ei_asked;
+  const { embedding, rewrite_length_floor, persona_groups, last_ei_asked, ...rest } = p;
+  void embedding; void rewrite_length_floor; void persona_groups; void last_ei_asked;
   return rest;
 }
 

package/src/core/tools/index.ts

@@ -64,7 +64,7 @@ export const SYSTEM_TOOLS: ToolDefinition[] = [
     builtin: true,
     enabled: true,
     created_at: new Date(0).toISOString(),
-    max_calls_per_interaction: 3,
+    max_calls_per_interaction: 10,
   },
   {
     id: "builtin-fetch-message",

package/src/core/tools/types.ts

@@ -6,7 +6,7 @@
 /** A single tool call the LLM wants to make (from the API response). */
 export interface ToolCall {
   id: string;           // call_abc123 — must be echoed back in tool result message
-  name: string;         // snake_case tool name ("web_search", "read_memory")
+  name: string;         // snake_case tool name ("web_search", "find_memory")
   arguments: Record<string, unknown>;  // Parsed from JSON string in the API response
 }
 

package/src/core/types/data-items.ts

@@ -18,7 +18,7 @@ export interface DataItemBase {
   sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId"). Grow-only union.
   persona_groups?: string[];
   embedding?: number[];
-  rewrite_checked?: boolean;     // True after rewrite scan finds no changes. Cleared automatically when extraction upserts a fresh item.
+  rewrite_length_floor?: number; // Set after every rewrite scan: ceil(description.length * 1.1). Item is skipped by ceremony until description grows past this floor. Preserved across extraction upserts — only cleared when description exceeds it.
 }
 
 export interface Fact extends DataItemBase {

package/src/core/types/entities.ts

@@ -20,9 +20,15 @@ export interface OpenCodeSettings {
   processed_sessions?: Record<string, string>;  // sessionId → ISO timestamp of last import
 }
 
+export interface DocumentRecord {
+  created_at: string;
+  type: "imported" | "generated";
+  subject?: string;
+}
+
 export interface DocumentSettings {
   extraction_model?: string;
-  processed_documents?: Record<string, string>;
+  processed_documents?: Record<string, DocumentRecord>;
 }
 
 export interface CeremonyConfig {

package/src/core/types/enums.ts

@@ -53,6 +53,7 @@ export enum LLMNextStep {
   HandleTopicValidate = "handleTopicValidate",
   HandleReflectionCritic = "handleReflectionCritic",
   HandleDocumentSegmentation = "handleDocumentSegmentation",
+  HandleKnowledgeSynthesis = "handleKnowledgeSynthesis",
 }
 
 export enum ProviderType {

package/src/core/types/integrations.ts

@@ -29,7 +29,7 @@ export interface ToolProvider {
 export interface ToolDefinition {
   id: string;                          // UUID
   provider_id: string;                 // FK → ToolProvider.id (required)
-  name: string;                        // Snake_case machine name ("web_search", "read_memory")
+  name: string;                        // Snake_case machine name ("web_search", "find_memory")
   display_name: string;                // Human label
   description: string;                 // What the LLM reads to decide whether to call this tool
   input_schema: Record<string, unknown>; // JSON Schema for parameters the LLM can pass
@@ -77,6 +77,7 @@ export interface QueueStatus {
   embedding_warning?: boolean;
   pending_documents?: Array<{ batchId: string; filename: string; count: number }>;
   extracting_documents?: string[];
+  generating_documents?: string[];
 }
 
 export interface EiError {
@@ -121,6 +122,7 @@ export interface Ei_Interface {
   onRoomMessageAdded?: (roomId: string) => void;
   onRoomMessageQueued?: (roomId: string) => void;
   onRoomMessageProcessing?: (roomId: string) => void;
+  onDocumentGenerated?: (slug: string) => void;
 }
 
 // =============================================================================

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

@@ -11,6 +11,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 import { isProcessRunning } from "../process-check.js";
 import { getMachineId } from "../machine-id.js";
 
@@ -268,6 +272,8 @@ export async function importClaudeCodeSessions(
       sources: [`claudecode:${getMachineId()}:${targetSession.id}`],
     };
 
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
     const ccSettings = stateManager.getHuman().settings?.claudeCode;
     queueAllScans(context, stateManager, {
       extraction_model: ccSettings?.extraction_model,

package/src/integrations/cursor/importer.ts

@@ -13,6 +13,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 
 export interface CursorImportResult {
   sessionsProcessed: number;
@@ -227,6 +231,8 @@ export async function importCursorSessions(
       sources: [`cursor:${getMachineId()}:${targetSession.id}`],
     };
 
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
     queueAllScans(context, stateManager, { external_filter: "only" });
     result.extractionScansQueued += 4;
   }

package/src/integrations/document/unsource.ts

@@ -150,13 +150,15 @@ export async function executeUnsource(
     stateManager.messages_remove("emmet", sourceMessageIds);
   }
 
-  const filename = preview.sourceTag.startsWith("import:document:")
+  const key = preview.sourceTag.startsWith("import:document:")
     ? preview.sourceTag.slice("import:document:".length)
-    : preview.sourceTag;
+    : preview.sourceTag.startsWith("generate:document:")
+      ? preview.sourceTag.slice("generate:document:".length)
+      : preview.sourceTag;
 
   const human = stateManager.getHuman();
   if (human.settings?.document?.processed_documents) {
-    delete human.settings.document.processed_documents[filename];
+    delete human.settings.document.processed_documents[key];
     stateManager.setHuman(human);
   }
 

package/src/integrations/opencode/importer.ts

@@ -8,6 +8,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 import { isProcessRunning } from "../process-check.js";
 import { getMachineId } from "../machine-id.js";
 
@@ -195,6 +199,7 @@ export async function importOpenCodeSessions(
 
   const cutoffIso = processedSessions[targetSession.id] ?? null;
   const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+  let anyPersonaHasChanges = false;
 
   for (const [, { persona, msgs: agentMsgs, isNew, agentName }] of byPersonaId) {
     if (isNew) {
@@ -252,6 +257,7 @@ export async function importOpenCodeSessions(
       };
 
       if (!signal?.aborted) {
+        anyPersonaHasChanges = true;
         const openCodeSettings = stateManager.getHuman().settings?.opencode;
         queueAllScans(context, stateManager, {
           extraction_model: openCodeSettings?.extraction_model,
@@ -264,7 +270,13 @@ export async function importOpenCodeSessions(
 
   result.sessionsProcessed = 1;
 
-  // ─── Step 6: Advance extraction state ────────────────────────────────
+  // ─── Step 6: Queue rewrite checks if any persona had new messages ─────
+  if (anyPersonaHasChanges && !signal?.aborted) {
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+  }
+
+  // ─── Step 7: Advance extraction state ────────────────────────────────
   updateExtractionState(stateManager, targetSession);
 
   console.log(

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

@@ -6,6 +6,10 @@ import {
   queueFactFind,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 
 export interface PersonaHistoryImportResult {
   daysQueued: number;
@@ -141,6 +145,11 @@ export async function importPersonaHistory(
 
   result.daysQueued = 1;
 
+  if (result.scansQueued > 0) {
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+  }
+
   const isLastDay = currentDate >= today;
   advanceProgress(stateManager, currentDate, isLastDay);
 

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

@@ -45,7 +45,7 @@ Rules:
 - 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.
+Return a raw JSON array of strings. No markdown fencing, no commentary. Thinking text WILL break the parser.
 
 Example — a Person named "Nicholas" whose description includes sprint ticket numbers:
 ["CMIDP sprint ticket assignments", "ASU Data Lake access provisioning details"]`;
@@ -60,7 +60,7 @@ Example — a Person named "Nicholas" whose description includes sprint ticket n
 
 ---
 
-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 a raw JSON array of subject phrases found in this Person record that don't belong there. Return [] if the record is clean. Thinking text WILL break the parser.`;
 
   return { system, user };
 }

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

@@ -35,7 +35,7 @@ Rules:
 - Be specific: "TypeScript coding conventions" beats "technical preferences"
 - If the record is cohesive and on-topic despite its length, return an empty array
 ${technicalGuidance}
-Return a raw JSON array of strings. No markdown fencing, no commentary.
+Return a raw JSON array of strings. No markdown fencing, no commentary. Thinking text WILL break the parser.
 
 Example — a Topic named "Software Engineering" whose description also discusses vim keybindings, git conventions, and AI tooling:
 ["vim keybindings and editor configuration", "git and GitHub workflow conventions", "AI coding assistant preferences"]`;
@@ -51,7 +51,7 @@ Example — a Topic named "Software Engineering" whose description also discusse
 ]
 \`\`\`
 
-Respond with raw JSON array only.`;
+Respond with raw JSON array only. Thinking text WILL break the parser.`;
 
   const user = `${payload}
 

package/src/prompts/index.ts

@@ -79,3 +79,6 @@ export type {
   RoomHistoryMessage,
   RoomJudgeCandidate,
 } from "./room/types.js";
+
+export { buildSynthesisPrompt } from "./synthesis/index.js";
+export type { SynthesisPromptData } from "./synthesis/types.js";