ei-tui 1.2.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.2.0",
+  "version": "1.3.0",
   "author": "Flare576",
   "repository": {
     "type": "git",

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/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]*?)```/);
@@ -48,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);
   }
@@ -71,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`);

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

@@ -18,17 +18,15 @@ export function handleKnowledgeSynthesis(response: LLMResponse, state: StateMana
   }
 
   const now = new Date().toISOString();
-  const sourceTag = `generate:document:${slug}`;
 
   const message: Message = {
-    id: crypto.randomUUID(),
+    id: `generate:document:${slug}:${crypto.randomUUID()}`,
     role: "system",
     content,
     timestamp: now,
     read: true,
     context_status: ContextStatus.Always,
     external: true,
-    source_tag: sourceTag,
   };
 
   state.messages_append("emmet", message);

package/src/core/heartbeat-manager.ts

@@ -168,6 +168,16 @@ export async function queueEiHeartbeat(
     });
   }
 
+  // Ei's own pending reflection — separate item type so she can introspect on herself
+  const eiPersona = personas.find((p) => p.id === "ei");
+  if (eiPersona?.pending_update?.critique) {
+    items.push({
+      id: eiPersona.id,
+      type: "Self Reflection Alert",
+      critique: eiPersona.pending_update.critique,
+    });
+  }
+
   const personasWithPendingUpdate = personas.filter(
     (p) => !p.is_archived && !p.is_paused && !p.is_static && p.id !== "ei" && p.pending_update?.critique
   );

package/src/core/orchestrators/ceremony.ts

@@ -264,14 +264,6 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
     !p.is_static
   );
   
-  const eiIndex = activePersonas.findIndex(p => 
-    (p.aliases?.[0] ?? "").toLowerCase() === "ei"
-  );
-  
-  // Ei's topics don't change
-  if (eiIndex > -1) {
-    activePersonas.splice(eiIndex, 1);
-  }
   // Decay phase: apply decay + prune for ALL active personas
   for (const persona of activePersonas) {
     applyDecayPhase(persona.id, state);
@@ -623,7 +615,7 @@ function queueEventSummaryForAll(state: StateManager, options?: ExtractionOption
 
 function queueReflectionPhase(state: StateManager): void {
   const personas = state.persona_getAll().filter(p =>
-    !p.is_paused && !p.is_archived && !p.is_static && p.id !== "ei"
+    !p.is_paused && !p.is_archived && !p.is_static
   );
 
   let queued = 0;

package/src/core/processor.ts

@@ -139,6 +139,9 @@ import {
 import type { RoomCreationInput, RoomEntity, RoomMessage, RoomSummary } from "./types.js";
 import { previewUnsource as _previewUnsource } from "../integrations/document/unsource.js";
 import type { UnsourcePreview, UnsourceResult } from "../integrations/document/unsource.js";
+import { isQualifiedMessageId, qualifyEiMessage, qualifyOpenCodeMessage } from "./utils/message-id.js";
+
+import type { IOpenCodeReader } from "../integrations/opencode/types.js";
 
 const DEFAULT_LOOP_INTERVAL_MS = 100;
 const DEFAULT_OPENCODE_POLLING_MS = 60000;
@@ -242,18 +245,30 @@ export class Processor {
     this.bootstrapTools();
     this.seedBuiltinFacts();
     this.migrateLearnedOn();
+    await this.migrateMessageIds();
     this.seedSettings();
     registerFindMemoryExecutor(createFindMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this), this.stateManager.getHuman.bind(this.stateManager)));
     registerFetchMemoryExecutor(createFetchMemoryExecutor(this.stateManager.getHuman.bind(this.stateManager)));
-    registerFetchMessageExecutor(createFetchMessageExecutor(
-      this.stateManager.persona_getAll.bind(this.stateManager),
-      this.stateManager.messages_get.bind(this.stateManager),
-      this.stateManager.getRoomList.bind(this.stateManager),
-      this.stateManager.getRoomMessages.bind(this.stateManager),
-      (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null
-    ));
     if (this.isTUI) {
       await registerFileReadExecutor();
+      const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+      const openCodeReader = await createOpenCodeReader().catch(() => null);
+      registerFetchMessageExecutor(createFetchMessageExecutor(
+        this.stateManager.persona_getAll.bind(this.stateManager),
+        this.stateManager.messages_get.bind(this.stateManager),
+        this.stateManager.getRoomList.bind(this.stateManager),
+        this.stateManager.getRoomMessages.bind(this.stateManager),
+        (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null,
+        openCodeReader ? (id, before, after) => openCodeReader.getMessageById(id, before, after) : undefined
+      ));
+    } else {
+      registerFetchMessageExecutor(createFetchMessageExecutor(
+        this.stateManager.persona_getAll.bind(this.stateManager),
+        this.stateManager.messages_get.bind(this.stateManager),
+        this.stateManager.getRoomList.bind(this.stateManager),
+        this.stateManager.getRoomMessages.bind(this.stateManager),
+        (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null
+      ));
     }
     this.running = true;
     console.log(`[Processor ${this.instanceId}] initialized, starting loop`);
@@ -454,7 +469,7 @@ export class Processor {
   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);
+    const message = messages.find(m => m.id.startsWith(`${target}:`));
     return message?.content ?? null;
   }
 
@@ -1009,6 +1024,104 @@ export class Processor {
     }
   }
 
+  private async migrateMessageIds(): Promise<void> {
+    try {
+      let msgRewrites = 0;
+      let quoteRewrites = 0;
+
+      const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+      const personas = this.stateManager.persona_getAll();
+      for (const persona of personas) {
+        for (const msg of this.stateManager.messages_get(persona.id)) {
+          if (!msg.external && UUID_PATTERN.test(msg.id)) {
+            this.stateManager.messages_update(persona.id, msg.id, { id: qualifyEiMessage(msg.id) });
+            msgRewrites++;
+          }
+        }
+      }
+
+      const rooms = this.stateManager.getRoomList();
+      for (const room of rooms) {
+        for (const msg of this.stateManager.getRoomMessages(room.id).slice()) {
+          if (UUID_PATTERN.test(msg.id)) {
+            this.stateManager.updateRoomMessage(room.id, msg.id, { id: qualifyEiMessage(msg.id) });
+            msgRewrites++;
+          }
+        }
+      }
+
+      const human = this.stateManager.getHuman();
+      const quotes = human.quotes ?? [];
+
+      const eiUuidMap = new Map<string, string>();
+      for (const persona of personas) {
+        for (const msg of this.stateManager.messages_get(persona.id)) {
+          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+        }
+      }
+      for (const room of rooms) {
+        for (const msg of this.stateManager.getRoomMessages(room.id)) {
+          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+        }
+      }
+
+      const MSG_PATTERN = /^msg_[a-zA-Z0-9]+$/;
+
+      let openCodeReader: IOpenCodeReader | null = null;
+      if (this.isTUI) {
+        const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+        openCodeReader = await createOpenCodeReader().catch(() => null);
+      }
+
+      const updatedQuotes: typeof quotes = [];
+      for (const quote of quotes) {
+        const mid = quote.message_id;
+        if (!mid || isQualifiedMessageId(mid)) {
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        if (MSG_PATTERN.test(mid)) {
+          if (openCodeReader) {
+            const ocWindow = await openCodeReader.getMessageById(mid).catch(() => null);
+            if (ocWindow) {
+              const { getMachineId } = await import("../integrations/machine-id.js");
+              updatedQuotes.push({ ...quote, message_id: qualifyOpenCodeMessage(getMachineId(), ocWindow.session.id, mid) });
+              quoteRewrites++;
+              continue;
+            }
+          }
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        if (UUID_PATTERN.test(mid)) {
+          const fqId = eiUuidMap.get(mid);
+          if (fqId) {
+            updatedQuotes.push({ ...quote, message_id: fqId });
+            quoteRewrites++;
+            continue;
+          }
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        updatedQuotes.push(quote);
+      }
+
+      if (quoteRewrites > 0) {
+        this.stateManager.setHuman({ ...human, quotes: updatedQuotes });
+      }
+
+      if (msgRewrites > 0 || quoteRewrites > 0) {
+        console.log(`[Processor] migrateMessageIds: rewrote ${msgRewrites} message IDs, ${quoteRewrites} quote message_ids`);
+      }
+    } catch (err) {
+      console.error("[Processor] migrateMessageIds failed, continuing:", err);
+    }
+  }
+
   private seedSettings(): void {
     const human = this.stateManager.getHuman();
     let modified = false;
@@ -1912,7 +2025,7 @@ const toolNextSteps = new Set([
       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}`);
+          .some(m => m.id.startsWith(`generate:document:${slug}:`));
         if (hasContent) this.interface.onDocumentGenerated?.(slug);
       }
     } catch (err) {

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

@@ -2,6 +2,7 @@ import type { ToolExecutor } from "../types.js";
 import type { Message } from "../../types.js";
 import type { RoomMessage, RoomSummary } from "../../types/rooms.js";
 import type { PersonaEntity } from "../../types/entities.js";
+import type { OpenCodeMessageWindow } from "../../../integrations/opencode/types.js";
 
 interface CleanMessage {
   id: string;
@@ -17,6 +18,9 @@ type GetPersonaMessages = (personaId: string) => Message[];
 type GetRoomList = () => RoomSummary[];
 type GetRoomMessages = (roomId: string) => RoomMessage[];
 type GetRoomDisplayName = (roomId: string) => string | null;
+type GetOpenCodeMessage = (id: string, before: number, after: number) => Promise<OpenCodeMessageWindow | null>;
+
+const OPENCODE_MESSAGE_ID = /^msg_[a-zA-Z0-9]+$/;
 
 function stripMessage(m: Message): CleanMessage {
   return {
@@ -45,7 +49,8 @@ export function createFetchMessageExecutor(
   getPersonaMessages: GetPersonaMessages,
   getRoomList: GetRoomList,
   getRoomMessages: GetRoomMessages,
-  getRoomDisplayName: GetRoomDisplayName
+  getRoomDisplayName: GetRoomDisplayName,
+  getOpenCodeMessage?: GetOpenCodeMessage
 ): ToolExecutor {
   return {
     name: "fetch_message",
@@ -62,6 +67,27 @@ export function createFetchMessageExecutor(
         return JSON.stringify({ error: "Missing required argument: id" });
       }
 
+      if (OPENCODE_MESSAGE_ID.test(id)) {
+        if (!getOpenCodeMessage) {
+          return JSON.stringify({ error: "OpenCode message lookup not available in this runtime", id });
+        }
+        const window = await getOpenCodeMessage(id, before, after);
+        if (!window) {
+          return JSON.stringify({
+            error: "OpenCode message not found on this machine. It may exist on another device.",
+            id,
+            hint: "Check the linked topic's sources for the originating machine and session.",
+          });
+        }
+        return JSON.stringify({
+          message: { id: window.message.id, role: window.message.role, content: window.message.content, timestamp: window.message.timestamp, agent: window.message.agent },
+          before: window.before.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          after: window.after.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          session: { id: window.session.id, title: window.session.title, directory: window.session.directory },
+          source: "opencode",
+        });
+      }
+
       const personas = getAllPersonas();
 
       // TODO: add persona access gate when calling context is available —