ei-tui 1.1.0 → 1.3.0

package/README.md

@@ -185,6 +185,22 @@ Ei splits the document into segments, runs them through the extraction pipeline,
 
 Both surfaces show you which documents have been imported and let you remove their extracted knowledge (web: Delete button in the Documents tab; TUI: `/unsource <source_tag>`).
 
+## Knowledge Share
+
+Sometimes you want to take what Ei knows and turn it into something you can hand to another human. A new teammate joining a project. A briefing doc before a meeting. A brain dump before a vacation.
+
+**TUI**:
+```bash
+/generate everything about the Uniform project
+/generate comprehensive runbook for the IDP deployment issues
+```
+
+Give it a subject description and Ei searches its memory, chases down related entities, and synthesizes a clean markdown document using your `rewrite_model` (an Opus-class model is recommended — it'll warn you if you're about to use something less capable). The document lands in `$EI_DATA_PATH/docs/` automatically.
+
+`/generate` with no args opens a list of your existing generated documents where you can re-run, re-export, or delete them.
+
+**Web**: Open **☰ menu** → **My Data** → **Documents** tab. Click **Generate**, enter a subject, and Ei does the rest. Generated docs appear in the same list as imported ones.
+
 ## Built-in Tool Integrations
 
 Personas can use tools. Not just read-from-memory tools — *actual* tools. Web search. Your music. Your filesystem. Here's what ships with Ei out of the box:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "author": "Flare576",
   "repository": {
     "type": "git",
@@ -51,28 +51,7 @@
     "test:e2e:tui": "cd tui && npm run test:e2e",
     "test:e2e:ui": "playwright test --ui",
     "test:e2e:debug": "playwright test --debug",
-    "test:evals": "vite-node tests/evals/reflection-critic.eval.ts",
-    "test:evals:observe": "vite-node tests/evals/reflection-critic.observe.ts",
-    "test:evals:fact-find": "vite-node tests/evals/fact-find.eval.ts",
-    "test:evals:topic-scan": "vite-node tests/evals/topic-scan.eval.ts",
-    "test:evals:topic-match": "vite-node tests/evals/topic-match.eval.ts",
-    "test:evals:topic-update": "vite-node tests/evals/topic-update.eval.ts",
-    "test:evals:topic-technical": "vite-node tests/evals/topic-technical.eval.ts",
-    "test:evals:rewrite-scan": "vite-node tests/evals/rewrite-scan.eval.ts",
-    "test:evals:rewrite-rewrite": "vite-node tests/evals/rewrite-rewrite.eval.ts",
-    "test:evals:rewrite-real-data": "vite-node tests/evals/rewrite-real-data.eval.ts",
-    "test:evals:topic-validate": "vite-node tests/evals/topic-validate.eval.ts",
-    "test:evals:person-scan": "vite-node tests/evals/person-scan.eval.ts",
-    "test:evals:person-scan-confidence": "vite-node tests/evals/person-scan-confidence.eval.ts",
-
-    "test:evals:person-update": "vite-node tests/evals/person-update.eval.ts",
-    "test:evals:persona-trait": "vite-node tests/evals/persona-trait-extraction.eval.ts",
-    "test:evals:dedup": "vite-node tests/evals/dedup-tool-calls.eval.ts",
-    "test:evals:response-read-memory": "vite-node tests/evals/response-read-memory.eval.ts",
-    "test:evals:response-pending-update": "vite-node tests/evals/response-pending-update.eval.ts",
-    "test:evals:heartbeat-pending-update": "vite-node tests/evals/heartbeat-pending-update.eval.ts",
-    "test:evals:real-data": "vite-node tests/evals/real-data-example.eval.ts",
-    "test:evals:persona-data-check": "vite-node tests/evals/persona-data-check.eval.ts",
+    "test:evals": "vite-node tests/evals/run.ts",
     "test:all": "npm run test && npm run test:e2e && npm run test:e2e:tui",
     "typecheck": "tsc --noEmit",
     "web": "cd web && npm run dev",

package/src/cli/README.md

@@ -13,7 +13,7 @@ ei personas -n 5 "query string"   # Return up to 5 personas (name match)
 ei --persona "Beta" "query string"    # Filter results to what Beta has learned
 ei --recent                            # Most recently mentioned items (no query needed)
 ei --persona "Beta" --recent           # Most recently mentioned items Beta has learned
-ei --id <id>                   # Look up a specific entity by ID
+ei --id <id>                   # Look up entity by ID — or fetch a message by FQ ID
 echo <id> | ei --id            # Look up entity by ID from stdin
 ei --install                   # Register Ei with OpenCode, Claude Code, and Cursor
 ei mcp                         # Start the Ei MCP stdio server (for Cursor/Claude Desktop)
@@ -29,6 +29,16 @@ The `--id` flag is designed for piping. For example, search for a topic and then
 ei "memory leak" | jq '.[0].id' | ei --id
 ```
 
+It also resolves fully-qualified message IDs from any supported integration, returning the original message content and session context:
+
+```sh
+ei --id "opencode:jeremys-macbook-pro:ses_38a7...:msg_c75b..."
+ei --id "claudecode:my-machine:session-uuid:message-uuid"
+ei --id "cursor:my-machine:composer-uuid:bubble-uuid"
+```
+
+Quotes surfaced by `ei_search` or `ei_find_memory` include a `message_id` field in this format — pipe it to `ei --id` to read the original conversation.
+
 # OpenCode Integration
 
 ## Quick Install
@@ -156,7 +166,7 @@ The MCP server exposes these tools to Claude Code, Cursor, and OpenCode:
 | `ei_lookup` | Full-record lookup for any entity by ID (facts, topics, people, quotes, personas). |
 | `ei_find_memory` | Grouped human-data search — facts, topics, people, quotes. Returns results grouped by type. Mirrors the persona `find_memory` tool interface. |
 | `ei_fetch_memory` | Full-record lookup for a human entity (Fact, Topic, Person, or Quote) by ID. Returns the complete record including all fields. |
-| `ei_fetch_message` | Retrieve a specific message by ID with optional `before`/`after` context window. Searches persona conversations and room messages. |
+| `ei_fetch_message` | Retrieve a specific message by fully-qualified ID with optional `before`/`after` context window. Routes to the correct source: `ei:uuid` searches Ei state, `opencode:machine:session:id` queries the OpenCode SQLite DB, `claudecode:...` scans Claude Code JSONL files, `cursor:...` reads the Cursor global DB. Returns message content, surrounding context, and session metadata. |
 
 ### `ei_search` / `ei_find_memory` arguments
 

package/src/cli/mcp.ts

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { retrieveBalanced, lookupById, loadLatestState, type BalancedResult } from "./retrieval.js";
+import { retrieveBalanced, lookupById, resolveExternalMessage, loadLatestState, type BalancedResult } from "./retrieval.js";
 import type { StorageState } from "../core/types.js";
 import type { Message } from "../core/types.js";
 import type { RoomMessage } from "../core/types/rooms.js";
@@ -270,6 +270,17 @@ export function createMcpServer(): McpServer {
       },
     },
     async ({ id, before: beforeCount, after: afterCount }) => {
+      const beforeN = Math.max(0, Math.floor(beforeCount ?? 0));
+      const afterN = Math.max(0, Math.floor(afterCount ?? 0));
+
+      const externalResult = await resolveExternalMessage(id, beforeN, afterN);
+      if (externalResult) {
+        if ("error" in externalResult) {
+          return { content: [{ type: "text" as const, text: String(externalResult.error) }] };
+        }
+        return { content: [{ type: "text" as const, text: JSON.stringify(externalResult, null, 2) }] };
+      }
+
       const state = await loadLatestState();
       if (!state) {
         return {
@@ -277,9 +288,6 @@ export function createMcpServer(): McpServer {
         };
       }
 
-      const beforeN = Math.max(0, Math.floor(beforeCount ?? 0));
-      const afterN = Math.max(0, Math.floor(afterCount ?? 0));
-
       const stripPersonaMessage = (m: Message) => ({
         id: m.id,
         role: m.role,

package/src/cli/retrieval.ts

@@ -6,6 +6,8 @@ import { crossFind } from "../core/utils/index.ts";
 import { join } from "path";
 import { readFile } from "fs/promises";
 import { getEmbeddingService, findTopK } from "../core/embedding-service";
+import { parseMessageId } from "../core/utils/message-id.js";
+import { getMachineId } from "../integrations/machine-id.js";
 
 const STATE_FILE = "state.json";
 const BACKUP_FILE = "state.backup.json";
@@ -86,6 +88,7 @@ export interface QuoteResult {
   text: string;
   speaker: string;
   timestamp: string;
+  message_id: string | null;
   linked_items: LinkedItem[];
 }
 
@@ -164,6 +167,7 @@ export function mapQuote(quote: Quote, state: StorageState): QuoteResult {
     text: quote.text,
     speaker: quote.speaker,
     timestamp: quote.timestamp,
+    message_id: quote.message_id,
     linked_items: resolveLinkedItems(quote.data_item_ids, state),
   };
 }
@@ -394,6 +398,164 @@ export async function retrieveBalanced(
   return embeddingFinal;
 }
 
+const OPENCODE_MESSAGE_ID = /^msg_[a-zA-Z0-9]+$/;
+
+/** @deprecated Use resolveExternalMessage */
+export async function resolveOpenCodeMessage(
+  id: string,
+  before = 0,
+  after = 0
+): Promise<Record<string, unknown> | null> {
+  return resolveExternalMessage(id, before, after);
+}
+
+export async function resolveExternalMessage(
+  id: string,
+  before = 0,
+  after = 0
+): Promise<Record<string, unknown> | null> {
+  const parsed = parseMessageId(id);
+
+  switch (parsed.integration) {
+    case "ei": {
+      const state = await loadLatestState();
+      if (!state) return null;
+
+      for (const { entity: persona, messages } of Object.values(state.personas)) {
+        const idx = messages.findIndex(m => m.id === id);
+        if (idx === -1) continue;
+        const msg = messages[idx];
+        return {
+          type: "opencode_message",
+          message: { id: msg.id, role: msg.role, content: msg.content ?? "", timestamp: msg.timestamp },
+          before: messages.slice(Math.max(0, idx - before), idx).map(m => ({ id: m.id, role: m.role, content: m.content ?? "", timestamp: m.timestamp })),
+          after: messages.slice(idx + 1, idx + 1 + after).map(m => ({ id: m.id, role: m.role, content: m.content ?? "", timestamp: m.timestamp })),
+          session: { id: persona.id, title: persona.display_name, directory: "" },
+          source: "ei",
+        };
+      }
+
+      for (const room of Object.values(state.rooms ?? {})) {
+        const idx = room.messages.findIndex(m => m.id === id);
+        if (idx === -1) continue;
+        const msg = room.messages[idx];
+        return {
+          type: "opencode_message",
+          message: { id: msg.id, role: msg.role, content: msg.content ?? "", timestamp: msg.timestamp },
+          before: room.messages.slice(Math.max(0, idx - before), idx).map(m => ({ id: m.id, role: m.role, content: m.content ?? "", timestamp: m.timestamp })),
+          after: room.messages.slice(idx + 1, idx + 1 + after).map(m => ({ id: m.id, role: m.role, content: m.content ?? "", timestamp: m.timestamp })),
+          session: { id: room.id, title: room.display_name, directory: "" },
+          source: "ei",
+        };
+      }
+
+      return null;
+    }
+
+    case "opencode": {
+      if (parsed.machine !== getMachineId()) {
+        return { error: `Message is from machine '${parsed.machine}', not available on this machine (${getMachineId()})` };
+      }
+      try {
+        const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+        const reader = await createOpenCodeReader();
+        const win = await reader.getMessageById(parsed.nativeId, before, after);
+        if (!win) return null;
+        return {
+          type: "opencode_message",
+          message: { id: win.message.id, role: win.message.role, content: win.message.content, timestamp: win.message.timestamp, agent: win.message.agent },
+          before: win.before.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          after: win.after.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          session: { id: win.session.id, title: win.session.title, directory: win.session.directory },
+          source: "opencode",
+        };
+      } catch {
+        return null;
+      }
+    }
+
+    case "claudecode": {
+      if (parsed.machine !== getMachineId()) {
+        return { error: `Message is from machine '${parsed.machine}', not available on this machine (${getMachineId()})` };
+      }
+      try {
+        const { ClaudeCodeReader } = await import("../integrations/claude-code/reader.js");
+        const reader = new ClaudeCodeReader();
+        const messages = await reader.getMessagesForSession(parsed.session!);
+        const idx = messages.findIndex(m => m.id === parsed.nativeId);
+        if (idx === -1) return null;
+        const msg = messages[idx];
+        return {
+          type: "opencode_message",
+          message: { id: msg.id, role: msg.role, content: msg.content, timestamp: msg.timestamp },
+          before: messages.slice(Math.max(0, idx - before), idx).map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp })),
+          after: messages.slice(idx + 1, idx + 1 + after).map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp })),
+          session: { id: parsed.session!, title: parsed.session!, directory: "" },
+          source: "claudecode",
+        };
+      } catch {
+        return null;
+      }
+    }
+
+    case "cursor": {
+      if (parsed.machine !== getMachineId()) {
+        return { error: `Message is from machine '${parsed.machine}', not available on this machine (${getMachineId()})` };
+      }
+      try {
+        const { CursorReader } = await import("../integrations/cursor/reader.js");
+        const reader = new CursorReader();
+        const sessions = await reader.getSessions();
+        const session = sessions.find(s => s.id === parsed.session);
+        if (!session) return null;
+        const idx = session.messages.findIndex(m => m.id === parsed.nativeId);
+        if (idx === -1) return null;
+        const msg = session.messages[idx];
+        const mapCursor = (m: { id: string; type: 1 | 2; text: string; timestamp: string }) => ({
+          id: m.id,
+          role: (m.type === 1 ? "user" : "assistant") as "user" | "assistant",
+          content: m.text,
+          timestamp: m.timestamp,
+        });
+        return {
+          type: "opencode_message",
+          message: mapCursor(msg),
+          before: session.messages.slice(Math.max(0, idx - before), idx).map(mapCursor),
+          after: session.messages.slice(idx + 1, idx + 1 + after).map(mapCursor),
+          session: { id: session.id, title: session.name, directory: session.workspacePath },
+          source: "cursor",
+        };
+      } catch {
+        return null;
+      }
+    }
+
+    case "unknown":
+    default: {
+      // Backward compat: bare msg_xxx → treat as opencode (no machine qualifier)
+      if (OPENCODE_MESSAGE_ID.test(id)) {
+        try {
+          const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+          const reader = await createOpenCodeReader();
+          const win = await reader.getMessageById(id, before, after);
+          if (!win) return null;
+          return {
+            type: "opencode_message",
+            message: { id: win.message.id, role: win.message.role, content: win.message.content, timestamp: win.message.timestamp, agent: win.message.agent },
+            before: win.before.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+            after: win.after.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+            session: { id: win.session.id, title: win.session.title, directory: win.session.directory },
+            source: "opencode",
+          };
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+  }
+}
+
 export async function lookupById(id: string): Promise<({ type: string } & Record<string, unknown>) | null> {
   const state = await loadLatestState();
   if (!state) {

package/src/cli.ts

@@ -13,7 +13,7 @@
 
 import { parseArgs } from "util";
 import { join } from "path";
-import { retrieveBalanced, lookupById, loadLatestState } from "./cli/retrieval";
+import { retrieveBalanced, lookupById, resolveExternalMessage, loadLatestState } from "./cli/retrieval";
 import type { StorageState } from "./core/types";
 import { resolvePersonaId, filterByPersona, filterTypeSpecificByPersona, filterBySource, filterTypeSpecificBySource } from "./cli/persona-filter.js";
 import pkg from "../package.json" assert { type: "json" };
@@ -247,6 +247,12 @@ mentions a person, or corrects something you assumed.
     // Strip surrounding quotes (from jq output or shell quoting)
     id = id.replace(/^["']|["']$/g, "");
 
+    const ocMessage = await resolveExternalMessage(id);
+    if (ocMessage) {
+      console.log(JSON.stringify(ocMessage, null, 2));
+      process.exit(0);
+    }
+
     const entity = await lookupById(id);
     if (!entity) {
       console.error(`No entity found with ID: ${id}`);

package/src/core/handlers/dedup.ts

@@ -25,8 +25,7 @@ export async function handleDedupCurate(
   
   // Validate entity_type
   if (!entity_type || !['topic', 'person'].includes(entity_type)) {
-    console.error(`[Dedup] Invalid entity_type: "${entity_type}" (from request data)`, response.request.data);
-    return;
+    throw new Error(`[Dedup] Invalid entity_type: "${entity_type}" (from request data)`);
   }
   
   // Parse Opus response
@@ -37,14 +36,12 @@ export async function handleDedupCurate(
       throw new Error("Invalid response format");
     }
   } catch (err) {
-    console.error(`[Dedup] Failed to parse Opus response:`, err);
-    return;
+    throw new Error(`[Dedup] Failed to parse Opus response: ${err instanceof Error ? err.message : String(err)}`);
   }
   
   // Validate response structure
   if (!Array.isArray(decisions.update) || !Array.isArray(decisions.remove) || !Array.isArray(decisions.add)) {
-    console.error(`[Dedup] Invalid response structure - missing update/remove/add arrays`);
-    return;
+    throw new Error(`[Dedup] Invalid response structure - missing update/remove/add arrays`);
   }
   
   console.log(`[Dedup] Processing cluster: ${decisions.update.length} updates, ${decisions.remove.length} removals, ${decisions.add.length} additions`);
@@ -63,15 +60,7 @@ export async function handleDedupCurate(
   
   // Validate entityList exists
   if (!entityList || !Array.isArray(entityList)) {
-    console.error(`[Dedup] entityList is ${entityList === undefined ? 'undefined' : 'not an array'} for entity_type="${entity_type}" (looking for state.${entity_type}s)`, {
-      entity_type,
-      entity_ids,
-      stateKeys: Object.keys(state),
-      factsExists: !!state.facts,
-      topicsExists: !!state.topics,
-      peopleExists: !!state.people
-    });
-    return;
+    throw new Error(`[Dedup] entityList is ${entityList === undefined ? 'undefined' : 'not an array'} for entity_type="${entity_type}" (looking for state.${entity_type}s)`);
   }
   const entities = entity_ids
     .map((id: string) => entityList.find((e: Fact | Topic | Person) => e.id === id))

package/src/core/handlers/document-segmentation.ts

@@ -5,6 +5,7 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../orchestrators/human-extraction.js";
+import { qualifyDocumentMessage } from "../utils/message-id.js";
 
 function parseSegmentArray(content: string): string[] | null {
   const jsonMatch = content.match(/```json\s*([\s\S]*?)```/) ?? content.match(/```\s*([\s\S]*?)```/);
@@ -30,8 +31,7 @@ export function handleDocumentSegmentation(response: LLMResponse, state: StateMa
   };
 
   if (!batchId || !filename) {
-    console.error("[handleDocumentSegmentation] Missing batchId or filename in request data");
-    return;
+    throw new Error("[handleDocumentSegmentation] Missing batchId or filename in request data");
   }
 
   let segments: string[];
@@ -49,18 +49,16 @@ export function handleDocumentSegmentation(response: LLMResponse, state: StateMa
   }
 
   const now = new Date().toISOString();
-  const sourceTag = `import:document:${filename}`;
 
   for (const segment of segments) {
     const message: Message = {
-      id: crypto.randomUUID(),
+      id: qualifyDocumentMessage(filename, crypto.randomUUID()),
       role: "system",
       content: segment,
       timestamp: now,
       read: true,
       context_status: ContextStatus.Always,
       external: true,
-      source_tag: sourceTag,
     };
     state.messages_append("emmet", message);
   }
@@ -72,7 +70,7 @@ export function finishDocumentBatch(batchId: string, filename: string, state: St
   const sourceTag = `import:document:${filename}`;
 
   const emmettMessages = state.messages_get("emmet");
-  const docMessages = emmettMessages.filter(m => m.external === true && m.source_tag === sourceTag);
+  const docMessages = emmettMessages.filter(m => m.external === true && m.id.startsWith(`${sourceTag}:`));
 
   if (docMessages.length === 0) {
     console.warn(`[finishDocumentBatch] No messages found for ${sourceTag} — skipping extraction`);
@@ -103,7 +101,7 @@ export function finishDocumentBatch(batchId: string, filename: string, state: St
         ...updatedHuman.settings?.document,
         processed_documents: {
           ...(updatedHuman.settings?.document?.processed_documents ?? {}),
-          [filename]: new Date().toISOString(),
+          [filename]: { created_at: new Date().toISOString(), type: "imported" },
         },
       },
     },

package/src/core/handlers/heartbeat.ts

@@ -13,14 +13,12 @@ export function handleHeartbeatCheck(response: LLMResponse, state: StateManager)
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;
   if (!personaId) {
-    console.error("[handleHeartbeatCheck] No personaId in request data");
-    return;
+    throw new Error("[handleHeartbeatCheck] No personaId in request data");
   }
 
   const result = response.parsed as HeartbeatCheckResult | undefined;
   if (!result) {
-    console.error(`[HeartbeatCheck ${personaDisplayName}] No parsed result`);
-    return;
+    throw new Error(`[HeartbeatCheck ${personaDisplayName}] No parsed result`);
   }
   console.log(`[HeartbeatCheck ${personaDisplayName}] Parsed result - should_respond: ${result.should_respond}, topic: ${result.topic ?? '(none)'}, message: ${result.message ? '(present)' : '(none)'}`);
 
@@ -52,8 +50,7 @@ export function handleHeartbeatCheck(response: LLMResponse, state: StateManager)
 export function handleEiHeartbeat(response: LLMResponse, state: StateManager): void {
   const result = response.parsed as EiHeartbeatResult | undefined;
   if (!result) {
-    console.error("[EiHeartbeat] No parsed result");
-    return;
+    throw new Error("[EiHeartbeat] No parsed result");
   }
   console.log(`[EiHeartbeat] Parsed result - should_respond: ${result.should_respond}, id: ${result.id ?? '(none)'}, my_response: ${result.my_response ? '(present)' : '(none)'}`);
   const now = new Date().toISOString();
@@ -127,8 +124,7 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
 
   const result = response.parsed as ReflectionCriticResult | undefined;
   if (!result?.critique) {
-    console.error(`[ReflectionCritic ${personaDisplayName}] Invalid or missing parsed result`);
-    return;
+    throw new Error(`[ReflectionCritic ${personaDisplayName}] Invalid or missing parsed result`);
   }
 
   const personRecord = state.human_person_getByIdentifier("Ei Persona", personaId);
@@ -150,8 +146,7 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
 
   const persona = state.persona_getById(personaId);
   if (!persona) {
-    console.error(`[ReflectionCritic ${personaDisplayName}] Persona not found after critic`);
-    return;
+    throw new Error(`[ReflectionCritic ${personaDisplayName}] Persona not found after critic`);
   }
 
   const mergedTopics = result.updated_identity.topics.map(updatedTopic => {

package/src/core/handlers/human-matching.ts

@@ -139,6 +139,8 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     ? incomingSources
     : [...new Set([...(existingTopic?.sources ?? []), ...incomingSources])];
 
+  const newDescLen = resolvedDescription?.length ?? 0;
+  const existingFloor = existingTopic?.rewrite_length_floor;
   const topic: Topic = {
     id: itemId,
     name: resolvedName,
@@ -156,6 +158,7 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     sources: sources.length > 0 ? sources : undefined,
     persona_groups: personaGroupsMerged,
     embedding,
+    rewrite_length_floor: existingFloor !== undefined && newDescLen < existingFloor ? existingFloor : undefined,
   };
   state.human_topic_upsert(topic);
 
@@ -333,6 +336,11 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
     sources: personSources.length > 0 ? personSources : undefined,
     persona_groups: personaGroupsMerged,
     embedding,
+    rewrite_length_floor: (() => {
+      const floor = existingPerson?.rewrite_length_floor;
+      const newLen = resolvedDescription?.length ?? 0;
+      return floor !== undefined && newLen < floor ? floor : undefined;
+    })(),
   };
   state.human_person_upsert(person);
 

package/src/core/handlers/index.ts

@@ -16,6 +16,7 @@ import { handleDedupCurate } from "./dedup.js";
 import { handleRoomResponse, handleRoomJudge } from "./rooms.js";
 import { handlePersonaPreview } from "./persona-preview.js";
 import { handleDocumentSegmentation } from "./document-segmentation.js";
+import { handleKnowledgeSynthesis } from "./knowledge-synthesis.js";
 
 export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
@@ -43,4 +44,5 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   [LLMNextStep.HandleTopicValidate]: handleDedupCurate,
   [LLMNextStep.HandleReflectionCritic]: handleReflectionCritic,
   [LLMNextStep.HandleDocumentSegmentation]: handleDocumentSegmentation,
+  [LLMNextStep.HandleKnowledgeSynthesis]: handleKnowledgeSynthesis,
 };

package/src/core/handlers/knowledge-synthesis.ts

@@ -0,0 +1,48 @@
+import { ContextStatus } from "../types.js";
+import type { LLMResponse, Message } from "../types.js";
+import type { StateManager } from "../state-manager.js";
+
+export function handleKnowledgeSynthesis(response: LLMResponse, state: StateManager): void {
+  const { slug, subject } = response.request.data as {
+    slug: string;
+    subject: string;
+  };
+
+  if (!slug || !subject) {
+    throw new Error("[handleKnowledgeSynthesis] Missing slug or subject in request data");
+  }
+
+  const content = response.content?.trim() ?? "";
+  if (!content) {
+    throw new Error(`[handleKnowledgeSynthesis] Empty or null response content for slug "${slug}"`);
+  }
+
+  const now = new Date().toISOString();
+
+  const message: Message = {
+    id: `generate:document:${slug}:${crypto.randomUUID()}`,
+    role: "system",
+    content,
+    timestamp: now,
+    read: true,
+    context_status: ContextStatus.Always,
+    external: true,
+  };
+
+  state.messages_append("emmet", message);
+
+  const updatedHuman = state.getHuman();
+  state.setHuman({
+    ...updatedHuman,
+    settings: {
+      ...updatedHuman.settings,
+      document: {
+        ...updatedHuman.settings?.document,
+        processed_documents: {
+          ...(updatedHuman.settings?.document?.processed_documents ?? {}),
+          [slug]: { created_at: now, type: "generated", subject },
+        },
+      },
+    },
+  });
+}

package/src/core/handlers/persona-generation.ts

@@ -12,8 +12,7 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;
   if (!personaId) {
-    console.error("[handlePersonaGeneration] No personaId in request data");
-    return;
+    throw new Error("[handlePersonaGeneration] No personaId in request data");
   }
 
   const result = response.parsed as PersonaGenerationResult | undefined;
@@ -115,14 +114,12 @@ export function handlePersonaTraitExtraction(response: LLMResponse, state: State
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;
   if (!personaId) {
-    console.error("[handlePersonaTraitExtraction] No personaId in request data");
-    return;
+    throw new Error("[handlePersonaTraitExtraction] No personaId in request data");
   }
 
   const result = response.parsed as TraitResult[] | undefined;
   if (!result || !Array.isArray(result)) {
-    console.error("[handlePersonaTraitExtraction] Invalid parsed result");
-    return;
+    throw new Error("[handlePersonaTraitExtraction] Invalid parsed result");
   }
 
   if (result.length === 0) {
@@ -131,8 +128,7 @@ export function handlePersonaTraitExtraction(response: LLMResponse, state: State
 
   const persona = state.persona_getById(personaId);
   if (!persona) {
-    console.error(`[handlePersonaTraitExtraction] Persona ${personaId} not found`);
-    return;
+    throw new Error(`[handlePersonaTraitExtraction] Persona ${personaId} not found`);
   }
 
   const now = new Date().toISOString();

package/src/core/handlers/persona-response.ts

@@ -15,8 +15,7 @@ export function handlePersonaResponse(response: LLMResponse, state: StateManager
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;
   if (!personaId) {
-    console.error("[handlePersonaResponse] No personaId in request data");
-    return;
+    throw new Error("[handlePersonaResponse] No personaId in request data");
   }
 
   state.messages_markPendingAsRead(personaId);
@@ -108,7 +107,7 @@ export function handleToolContinuation(response: LLMResponse, state: StateManage
   const originalStep = response.request.data.originalNextStep as LLMNextStep | undefined;
   
   if (!originalStep) {
-    console.error(`[handleToolContinuation] No originalNextStep in data, falling back to handlePersonaResponse`);
+    console.warn(`[handleToolContinuation] No originalNextStep in data, falling back to handlePersonaResponse`);
     handlePersonaResponse(response, state);
     return;
   }
@@ -118,7 +117,7 @@ export function handleToolContinuation(response: LLMResponse, state: StateManage
   const handler = handlers[originalStep];
   
   if (!handler) {
-    console.error(`[handleToolContinuation] No handler found for ${originalStep}, falling back to handlePersonaResponse`);
+    console.warn(`[handleToolContinuation] No handler found for ${originalStep}, falling back to handlePersonaResponse`);
     handlePersonaResponse(response, state);
     return;
   }