ei-tui 1.6.7 → 1.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "1.6.7",
+  "version": "1.6.9",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/cli/commands/personas.ts

@@ -1,4 +1,4 @@
-import { loadLatestState, retrievePersonas, retrievePersonasSemantic } from "../retrieval";
+import { loadLatestState, retrievePersonas, retrievePersonasSemantic, mapPersona } from "../retrieval";
 import { getEmbeddingService } from "../../core/embedding-service";
 import type { PersonaResult } from "../retrieval";
 
@@ -14,8 +14,53 @@ export async function execute(query: string, limit: number, options: { recent?:
     return nameResults;
   }
 
+  // BUG-2 fix: query may be longer than the stored persona name
+  // (e.g. "Beta — QA Goddess" vs stored "Beta"). Try reverse containment
+  // before falling to semantic search, which requires an embedding.
+  const queryLower = query.toLowerCase();
+  const reverseResults = Object.values(state.personas)
+    .map((p) => p.entity)
+    .filter((p) => queryLower.includes(p.display_name.toLowerCase()))
+    .slice(0, limit)
+    .map(mapPersona);
+  if (reverseResults.length > 0) {
+    return reverseResults;
+  }
+
   const embeddingService = getEmbeddingService();
   const queryVector = await embeddingService.embed(query);
   const semanticResults = await retrievePersonasSemantic(queryVector, state, limit);
   return semanticResults;
 }
+
+/**
+ * Format a PersonaResult as a <ei-relationship> block for injection into
+ * AI system prompts. Equivalent to the jq formatter in .zshenv.omp and
+ * the inline builder previously in the OpenCode plugin — consolidated here
+ * so all integrations can call `ei personas <name> --format prompt`.
+ */
+export function buildEiRelationshipBlock(persona: PersonaResult): string {
+  const strongTraits = (persona.traits ?? [])
+    .filter((t) => t.strength >= 0.7)
+    .sort((a, b) => b.strength - a.strength)
+    .map((t) => `**${t.name}** (${Math.round(t.strength * 100)}%): ${t.description}`)
+    .join("\n");
+  const sortedTopics = [...(persona.topics ?? [])]
+    .sort((a, b) => b.exposure_current - a.exposure_current)
+    .map((t) => `**${t.name}**: ${t.perspective} — ${t.approach}`)
+    .join("\n");
+  return [
+    "<!-- ei-relationship-injected -->",
+    "<ei-relationship>",
+    "## Ei: Relationship Context",
+    "",
+    persona.base_prompt ?? "",
+    "",
+    "### Working Style",
+    strongTraits || "(no traits above threshold)",
+    "",
+    "### Shared Context",
+    sortedTopics || "(no topics)",
+    "</ei-relationship>",
+  ].join("\n");
+}

package/src/cli/install.ts

@@ -34,15 +34,26 @@ export async function installMcpClients(): Promise<void> {
     console.log(`ℹ️  OpenCode not detected — skipping OpenCode plugin install.`);
   }
 
-  const hasPi = await Bun.file(join(home, ".pi", "agent", "settings.json")).exists() ||
+  const hasPi =
+    await Bun.file(join(home, ".pi", "agent", "settings.json")).exists() ||
     await Bun.file(join(home, ".pi", "agent", "auth.json")).exists();
-  const hasOmp = await Bun.file(join(home, ".omp", "agent", "settings.json")).exists() ||
-    await Bun.file(join(home, ".omp", "agent", "auth.json")).exists();
 
-  if (hasPi || hasOmp) {
+  if (hasPi) {
     await installPi();
   } else {
-    console.log(`ℹ️  Pi/OMP not detected — skipping Pi extension install.`);
+    console.log(`ℹ️  Pi not detected — skipping Pi extension install.`);
+  }
+
+  const hasOmp =
+    await Bun.file(join(home, ".omp", "agent", "settings.json")).exists() ||
+    await Bun.file(join(home, ".omp", "agent", "auth.json")).exists() ||
+    await Bun.file(join(home, ".omp", "agent", "config.yml")).exists() ||
+    await Bun.file(join(home, ".omp", "agent", "agent.db")).exists();
+
+  if (hasOmp) {
+    await installOmp();
+  } else {
+    console.log(`ℹ️  OMP not detected — skipping OMP extension install.`);
   }
 }
 
@@ -119,43 +130,45 @@ async function installCodexHooks(): Promise<void> {
   const scriptContent = `#!/usr/bin/env bun
 import { $ } from "bun";
 
-const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
-const raw = (input.prompt ?? "").replace(/<[^>]*>/g, "").trim();
-const searchArgs = ["-n", "8"];
-
-const sessionArgs = [];
-if (input.transcript_path) {
-  sessionArgs.push("--transcript", input.transcript_path);
-}
-if (input.session_id) {
-  sessionArgs.push("--session", input.session_id, "--hook-source", "codex");
-}
-
-const args = raw ? [...searchArgs, ...sessionArgs, raw] : ["--recent", ...searchArgs];
-
 async function runEi(commandArgs) {
   const direct = await $\`ei \${commandArgs}\`.quiet().text().catch(() => "");
   if (direct.trim()) return direct;
   return await $\`bunx ei-tui@latest \${commandArgs}\`.quiet().text().catch(() => "");
 }
 
-const output = await runEi(args);
-if (output.trim()) {
-  const heading = [
-    "## Ei Memory Context",
-    "*(The user cannot see this block. It is injected automatically before their message.)*",
-    "*(If you reference anything from it, briefly explain where it came from — e.g. \\"Ei shows you've been working on X\\" — so the user isn't confused by knowledge that appeared from nowhere.)*",
-    "",
-    "Ei is a personal knowledge base built from the user's coding sessions, Slack, documents, and conversations.",
-    "The following memories MAY be relevant to your current task — use \`ei_search\` or \`ei_lookup\` for targeted queries.",
-  ].join("\\n");
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "UserPromptSubmit",
-      additionalContext: \`\\n\${heading}\\n\${output.trim()}\\n\`,
-    },
-  }));
+if (import.meta.main) {
+  const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
+  const raw = (input.prompt ?? "").replace(/<[^>]*>/g, "").trim();
+  const searchArgs = ["-n", "8"];
+
+  const sessionArgs = [];
+  if (input.transcript_path) {
+    sessionArgs.push("--transcript", input.transcript_path);
+  }
+  if (input.session_id) {
+    sessionArgs.push("--session", input.session_id, "--hook-source", "codex");
+  }
+
+  const args = raw ? [...searchArgs, ...sessionArgs, raw] : ["--recent", ...searchArgs];
+
+  const output = await runEi(args);
+  if (output.trim()) {
+    const heading = [
+      "## Ei Memory Context",
+      "*(The user cannot see this block. It is injected automatically before their message.)*",
+      "*(If you reference anything from it, briefly explain where it came from — e.g. \\"Ei shows you've been working on X\\" — so the user isn't confused by knowledge that appeared from nowhere.)*",
+      "",
+      "Ei is a personal knowledge base built from the user's coding sessions, Slack, documents, and conversations.",
+      "The following memories MAY be relevant to your current task — use \`ei_search\` or \`ei_lookup\` for targeted queries.",
+    ].join("\\n");
+
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: \`\\n\${heading}\\n\${output.trim()}\\n\`,
+      },
+    }));
+  }
 }
 `;
 
@@ -268,7 +281,14 @@ async function installClaudeCodeHooks(): Promise<void> {
   const scriptContent = `#!/usr/bin/env bun
 import { $ } from "bun";
 
-const heading = \`
+async function runEi(commandArgs) {
+  const direct = await $\`ei \${commandArgs}\`.quiet().text().catch(() => "");
+  if (direct.trim()) return direct;
+  return await $\`bunx ei-tui@latest \${commandArgs}\`.quiet().text().catch(() => "");
+}
+
+if (import.meta.main) {
+  const heading = \`
 ## Ei Memory Context
 *(The user cannot see this block. It is injected automatically before their message.)*
 *(If you reference anything from it, briefly explain where it came from — e.g. "Ei shows you've been working on X" — so the user isn't confused by knowledge that appeared from nowhere.)*
@@ -277,20 +297,21 @@ Ei is a personal knowledge base built from the user's coding sessions, Slack, do
 The following items MAY be relevant to your current task — use \\\`ei_search\\\` or \\\`ei_lookup\\\` for targeted queries.
 \`;
 
-const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
-const raw = (input.prompt ?? "").replace(/<[^>]*>/g, "").trim();
+  const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
+  const raw = (input.prompt ?? "").replace(/<[^>]*>/g, "").trim();
 
-const sessionArgs = [];
-if (input.session_id && input.hook_source) {
-  sessionArgs.push("--session", input.session_id, "--hook-source", input.hook_source);
-} else if (input.transcript_path) {
-  sessionArgs.push("--transcript", input.transcript_path);
-}
+  const sessionArgs = [];
+  if (input.session_id && input.hook_source) {
+    sessionArgs.push("--session", input.session_id, "--hook-source", input.hook_source);
+  } else if (input.transcript_path) {
+    sessionArgs.push("--transcript", input.transcript_path);
+  }
 
-const args = raw ? ["-n", "5", ...sessionArgs, raw] : ["--recent", "-n", "5"];
+  const args = raw ? ["-n", "5", ...sessionArgs, raw] : ["--recent", "-n", "5"];
 
-const output = await $\`bunx ei-tui@latest \${args}\`.quiet().text().catch(() => "");
-if (output.trim()) process.stdout.write(\`\\n\${heading}\\n\${output.trim()}\\n\`);
+  const output = await runEi(args);
+  if (output.trim()) process.stdout.write(\`\\n\${heading}\\n\${output.trim()}\\n\`);
+}
 `;
 
   await Bun.write(scriptPath, scriptContent);
@@ -431,12 +452,18 @@ exit 0
 
 async function installPi(): Promise<void> {
   const home = process.env.HOME || "~";
-  const dataPath = process.env.EI_DATA_PATH ?? join(home, ".local", "share", "ei");
 
   const extensionContent = `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { $ } from "bun";
 
+const runEi = async (cmdArgs: string[]): Promise<string> => {
+  const direct = await $\`ei \${cmdArgs}\`.quiet().text().catch(() => "");
+  if (direct.trim()) return direct;
+  return $\`bunx ei-tui@latest \${cmdArgs}\`.quiet().text().catch(() => "");
+};
+
+
 export default function eiIntegration(pi: ExtensionAPI) {
   pi.on("before_agent_start", async (event, ctx) => {
     const entries = ctx.sessionManager.getEntries();
@@ -457,11 +484,7 @@ export default function eiIntegration(pi: ExtensionAPI) {
       ? ["-n", "5", "--", prompt]
       : ["--recent", "-n", "5"];
 
-    const output = await $\`bunx ei-tui@latest \${args}\`
-      .env({ ...process.env, EI_DATA_PATH: "${dataPath}" })
-      .quiet()
-      .text()
-      .catch(() => "");
+    const output = await runEi(args).catch(() => "");
 
     if (!output.trim()) return undefined;
 
@@ -502,11 +525,7 @@ export default function eiIntegration(pi: ExtensionAPI) {
       const args = params.type
         ? [params.type, "-n", "5", "--", params.query]
         : ["-n", "5", "--", params.query];
-      const output = await $\`bunx ei-tui@latest \${args}\`
-        .env({ ...process.env, EI_DATA_PATH: "${dataPath}" })
-        .quiet()
-        .text()
-        .catch(() => "No results found");
+      const output = await runEi(args).catch(() => "");
       return {
         content: [{ type: "text" as const, text: output.trim() || "No results found" }],
         details: {},
@@ -522,11 +541,7 @@ export default function eiIntegration(pi: ExtensionAPI) {
       id: Type.String({ description: "Entity ID from ei_search results" }),
     }),
     async execute(_id, params, _signal, _onUpdate, _ctx) {
-      const output = await $\`bunx ei-tui@latest --id \${params.id}\`
-        .env({ ...process.env, EI_DATA_PATH: "${dataPath}" })
-        .quiet()
-        .text()
-        .catch(() => "Not found");
+      const output = await runEi(["--id", params.id]).catch(() => "");
       return {
         content: [{ type: "text" as const, text: output.trim() || "Not found" }],
         details: {},
@@ -536,28 +551,163 @@ export default function eiIntegration(pi: ExtensionAPI) {
 }
 `;
 
-  const piExtDir = join(home, ".pi", "agent", "extensions");
-  const ompExtDir = join(home, ".omp", "agent", "extensions");
+  const extDir = join(home, ".pi", "agent", "extensions");
   const extFilename = "ei-integration.ts";
 
-  const hasPiAgent = await Bun.file(join(home, ".pi", "agent", "auth.json")).exists() ||
-    await Bun.file(join(home, ".pi", "agent", "settings.json")).exists();
-  const hasOmpAgent = await Bun.file(join(home, ".omp", "agent", "auth.json")).exists() ||
-    await Bun.file(join(home, ".omp", "agent", "settings.json")).exists();
+  await Bun.$`mkdir -p ${extDir}`;
+  await Bun.write(join(extDir, extFilename), extensionContent);
+  console.log(`✓ Installed Ei extension to ~/.pi/agent/extensions/${extFilename}`);
+}
 
-  if (hasPiAgent) {
-    await Bun.$`mkdir -p ${piExtDir}`;
-    await Bun.write(join(piExtDir, extFilename), extensionContent);
-    console.log(`✓ Installed Ei extension to ~/.pi/agent/extensions/${extFilename}`);
-  }
+async function installOmp(): Promise<void> {
+  const home = process.env.HOME || "~";
+
+  const extensionContent = `import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { $ } from "bun";
+
+const runEi = async (cmdArgs: string[]): Promise<string> => {
+  const direct = await $\`ei \${cmdArgs}\`.quiet().text().catch(() => "");
+  if (direct.trim()) return direct;
+  return $\`bunx ei-tui@latest \${cmdArgs}\`.quiet().text().catch(() => "");
+};
+
+// WHO block deduplication: Promise identity reuse — resolving is synchronous on subsequent calls.
+const personaBlockFetch = new Map<string, Promise<string | null>>();
 
-  if (hasOmpAgent) {
-    await Bun.$`mkdir -p ${ompExtDir}`;
-    await Bun.write(join(ompExtDir, extFilename), extensionContent);
-    console.log(`✓ Installed Ei extension to ~/.omp/agent/extensions/${extFilename}`);
+async function fetchPersonaBlock(name: string): Promise<string | null> {
+  try {
+    const block = await runEi(["personas", "--format", "prompt", "--", name]);
+    return block.trim() || null;
+  } catch {
+    return null;
   }
 }
 
+export default function eiIntegration(pi: ExtensionAPI) {
+  // WHO: inject <ei-relationship> block for the active primary persona.
+  // Prefer ctx.activePersonaName (OMP >= persona-tab-cycle PR); fall back to
+  // parsing "You are \\"<Name>\\"" from the HOW block in event.systemPrompt.
+  pi.on("before_agent_start", async (event, ctx) => {
+    const joined = ((event as any).systemPrompt as string[] | undefined)?.join("\\n") ?? "";
+    const quoted = joined.match(/You are "([^"]+)"/);
+    const personaName: string | null =
+      (ctx as any).activePersonaName ??
+      (quoted?.[1]?.trim() || null);
+    if (!personaName) return undefined;
+
+    if (!personaBlockFetch.has(personaName)) {
+      personaBlockFetch.set(personaName, fetchPersonaBlock(personaName));
+    }
+    const block = await personaBlockFetch.get(personaName)!;
+    if (!block) return undefined;
+
+    return {
+      message: {
+        customType: "ei-persona-who",
+        content: block,
+        display: false,
+      },
+    };
+  });
+
+  // MEMORY: inject relevant Ei context based on the current prompt.
+  pi.on("before_agent_start", async (event, ctx) => {
+    const entries = ctx.sessionManager.getEntries();
+    const recentMsgs = entries
+      .filter((e: any) => e.type === "message" && (e.message?.role === "user" || e.message?.role === "assistant"))
+      .slice(-5)
+      .map((e: any) => {
+        const role = e.message?.role ?? "unknown";
+        const text = Array.isArray(e.message?.content)
+          ? e.message.content.filter((b: any) => b.type === "text").map((b: any) => b.text).join(" ")
+          : (e.message?.content ?? "");
+        return \`\${role}: \${text.slice(0, 200)}\`;
+      })
+      .join("\\n");
+
+    const prompt = event.prompt ?? "";
+    const args = prompt ? ["-n", "5", "--", prompt] : ["--recent", "-n", "5"];
+    const output = await runEi(args).catch(() => "");
+    if (!output.trim()) return undefined;
+
+    const heading = [
+      "## Ei Memory Context",
+      "*(The user cannot see this block. It is injected automatically before their message.)*",
+      "*(If you reference anything from it, briefly explain where it came from.)*",
+      "",
+      "Ei is a personal knowledge base built from your coding sessions, Slack, documents, and conversations.",
+      "The following items MAY be relevant to your current task — use ei_search or ei_lookup for targeted queries.",
+    ].join("\\n");
+
+    return {
+      message: {
+        customType: "ei-context",
+        content: \`\${heading}\\n\\n\${output.trim()}\`,
+        display: false,
+      },
+    };
+  });
+
+  // Tools use plain JSON Schema — no typebox import needed (not available in source mode).
+  pi.registerTool({
+    name: "ei_search",
+    label: "Search Ei Memory",
+    description: "Semantic search of Ei's personal knowledge base — facts, topics, people, quotes across all sources. Use when you need context about the user, their work, or anything Ei has learned.",
+    promptSnippet: "Search Ei's personal memory for relevant facts, topics, people, or quotes.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural language search query" },
+        type: {
+          type: "string",
+          enum: ["facts", "topics", "people", "quotes", "personas"],
+          description: "Filter to a specific data type. Omit for balanced results across all types.",
+        },
+      },
+      required: ["query"],
+    },
+    async execute(_id, params: { query: string; type?: string }, _signal, _onUpdate, _ctx) {
+      const args = params.type
+        ? [params.type, "-n", "5", "--", params.query]
+        : ["-n", "5", "--", params.query];
+      const output = await runEi(args).catch(() => "");
+      return {
+        content: [{ type: "text" as const, text: output.trim() || "No results found" }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "ei_lookup",
+    label: "Lookup Ei Entity",
+    description: "Full-record lookup for a specific Ei entity (Fact, Topic, Person, Quote, or Persona) by ID. Use after ei_search to retrieve complete details for an item.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Entity ID from ei_search results" },
+      },
+      required: ["id"],
+    },
+    async execute(_id, params: { id: string }, _signal, _onUpdate, _ctx) {
+      const output = await runEi(["--id", params.id]).catch(() => "");
+      return {
+        content: [{ type: "text" as const, text: output.trim() || "Not found" }],
+        details: {},
+      };
+    },
+  });
+}
+`;
+
+  const extDir = join(home, ".omp", "agent", "extensions");
+  const extFilename = "ei-integration.ts";
+
+  await Bun.$`mkdir -p ${extDir}`;
+  await Bun.write(join(extDir, extFilename), extensionContent);
+  console.log(`✓ Installed Ei extension to ~/.omp/agent/extensions/${extFilename}`);
+}
+
 async function installOpenCodePlugin(): Promise<void> {
   const home = process.env.HOME || "~";
   const opencodeDir = join(home, ".config", "opencode");
@@ -570,8 +720,8 @@ async function installOpenCodePlugin(): Promise<void> {
 import { join } from "path"
 import { appendFileSync } from "fs"
 
-const sessionCache = new Map<string, string | null>()
-const sessionFetch = new Map<string, Promise<string | null>>()
+// Deduplication: the Promise itself is re-awaited on subsequent calls (synchronous once resolved).
+const personaFetch = new Map<string, Promise<string | null>>()
 
 const logPath = join(process.env.EI_DATA_PATH ?? join(process.env.HOME ?? "~", ".local", "share", "ei"), "ei-persona-plugin.log")
 
@@ -581,11 +731,7 @@ function log(msg: string) {
   } catch {}
 }
 
-type PersonaTrait = { name: string; description: string; strength: number }
-type PersonaTopic = { name: string; perspective: string; approach: string; exposure_current: number }
-type PersonaResult = { display_name: string; base_prompt?: string; traits?: PersonaTrait[]; topics?: PersonaTopic[] }
-
-// Pulls the agent name from the system prompt. Handles OMO's multiple formats:
+// Pulls the agent name from the system prompt. Handles OMO/OMP formats:
 //   You are "Sisyphus" - ...           (quoted, dash)
 //   You are "Sisyphus - Ultraworker"   (quoted, dash in name)
 //   You are Atlas - ...                (unquoted, dash)
@@ -599,50 +745,26 @@ export function extractAgentName(systemPrompt: string): string | null {
   return null
 }
 
-// Queries Ei for persona candidates and validates by name containment —
-// tolerates OMO renaming agents without requiring a hardcoded alias map.
-export async function resolveEiPersona(rawName: string): Promise<PersonaResult | null> {
+const runEi = async (cmdArgs: string[]): Promise<string> => {
+  const direct = await $\`ei \${cmdArgs}\`.quiet().text().catch(() => "")
+  if (direct.trim()) return direct
+  return $\`bunx ei-tui@latest \${cmdArgs}\`.quiet().text().catch(() => "")
+}
+
+// Fetch the <ei-relationship> block for a named persona via the Ei CLI.
+// Delegates all formatting to \`ei personas <name> --format prompt\` so
+// the block format is maintained in one place.
+async function fetchRelationshipBlock(rawName: string): Promise<string | null> {
   try {
-    const out = await $\`bunx ei-tui@latest personas -n 5 \${rawName}\`.text()
-    const candidates = JSON.parse(out.trim()) as PersonaResult[]
-    if (!Array.isArray(candidates) || candidates.length === 0) return null
-    const rawLower = rawName.toLowerCase()
-    const match = candidates.find((p) => {
-      const nameLower = p.display_name.toLowerCase()
-      return rawLower.includes(nameLower) || nameLower.includes(rawLower)
-    })
-    return match ?? null
+    const block = await runEi(["personas", "--format", "prompt", "--", rawName])
+    if (!block.trim() || block.includes("No saved state")) return null
+    log(\`ei-persona: injecting block for \${rawName}\`)
+    return block.trim()
   } catch {
     return null
   }
 }
 
-function buildEiRelationshipBlock(persona: PersonaResult): string {
-  const strongTraits = (persona.traits ?? [])
-    .filter((t) => t.strength >= 0.7)
-    .sort((a, b) => b.strength - a.strength)
-    .map((t) => \`**\${t.name}** (\${Math.round(t.strength * 100)}%): \${t.description}\`)
-    .join("\\n")
-  const sortedTopics = [...(persona.topics ?? [])]
-    .sort((a, b) => b.exposure_current - a.exposure_current)
-    .map((t) => \`**\${t.name}**: \${t.perspective} — \${t.approach}\`)
-    .join("\\n")
-  return [
-    "<!-- ei-relationship-injected -->",
-    "<ei-relationship>",
-    "## Ei: Relationship Context",
-    "",
-    persona.base_prompt ?? "",
-    "",
-    "### Working Style",
-    strongTraits || "(no traits above threshold)",
-    "",
-    "### Shared Context",
-    sortedTopics || "(no topics)",
-    "</ei-relationship>",
-  ].join("\\n")
-}
-
 export default async function EiPersonaPlugin() {
   return {
     name: "ei-persona",
@@ -650,29 +772,17 @@ export default async function EiPersonaPlugin() {
       input: { sessionID?: string; model: { id: string; providerID: string; [key: string]: unknown } },
       output: { system: string[] },
     ): Promise<void> => {
-      const rawName = extractAgentName(output.system[0] ?? "")
+      if (!Array.isArray(output.system) || typeof output.system[0] !== "string") return
+      const rawName = extractAgentName(output.system[0])
       if (!rawName) return
 
-      const cacheKey = \`\${input.sessionID ?? "unknown"}:\${rawName}\`
-
-      if (sessionCache.has(cacheKey)) {
-        const cached = sessionCache.get(cacheKey) ?? null
-        if (cached !== null && !output.system[0].includes("<!-- ei-relationship-injected -->"))
-          output.system[0] = output.system[0] + "\\n\\n" + cached
-        return
-      }
-
-      if (!sessionFetch.has(cacheKey)) {
-        sessionFetch.set(cacheKey, (async () => {
-          const persona = await resolveEiPersona(rawName)
-          if (!persona) return null
-          log(\`ei-persona: injecting \${persona.display_name}\`)
-          return buildEiRelationshipBlock(persona)
-        })())
+      // Cache per persona name (not per session) — block only changes when the
+      // persona's Ei data changes, which is infrequent.
+      if (!personaFetch.has(rawName)) {
+        personaFetch.set(rawName, fetchRelationshipBlock(rawName))
       }
 
-      const block = await sessionFetch.get(cacheKey)!
-      sessionCache.set(cacheKey, block)
+      const block = await personaFetch.get(rawName)!
       if (block !== null && !output.system[0].includes("<!-- ei-relationship-injected -->"))
         output.system[0] = output.system[0] + "\\n\\n" + block
     },

package/src/cli.ts

@@ -283,6 +283,7 @@ async function main(): Promise<void> {
         session: { type: "string" },
         "hook-source": { type: "string" },
         transcript: { type: "string" },
+        format: { type: "string", short: "f" },
       },
       allowPositionals: true,
       strict: true,
@@ -336,6 +337,8 @@ async function main(): Promise<void> {
     ? [...recentMessages, query].join(" ").trim()
     : query;
 
+  const format = parsed.values.format?.trim();
+
   let result;
   if (targetType) {
     const module = await import(`./cli/commands/${targetType}.js`);
@@ -346,6 +349,20 @@ async function main(): Promise<void> {
     if (sourcePrefix && state) {
       result = filterTypeSpecificBySource(result, state, sourcePrefix, targetType);
     }
+
+    // --format prompt: output a formatted text block instead of JSON.
+    // Currently supported for personas only; other types tracked in GitHub issue #77.
+    if (format === "prompt" && targetType === "personas") {
+      // BUG-1 fix: when no persona matches, emit nothing and exit clean.
+      // Do NOT fall through to JSON — callers check block.trim() truthiness
+      // and "[]".trim() is truthy, corrupting system prompts.
+      if (!Array.isArray(result) || result.length === 0) {
+        process.exit(0);
+      }
+      const { buildEiRelationshipBlock } = await import("./cli/commands/personas.js");
+      process.stdout.write(buildEiRelationshipBlock(result[0]) + "\n");
+      process.exit(0);
+    }
   } else {
     result = await retrieveBalanced(enrichedQuery, limit, options);
     if (personaId && state) {

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

@@ -169,7 +169,10 @@ export async function handleHumanTopicScan(response: LLMResponse, state: StateMa
     return;
   }
 
-  const context = response.request.data as unknown as ExtractionContext;
+  const context = {
+    ...(response.request.data as unknown as ExtractionContext),
+    channelDisplayName: (response.request.data as Record<string, unknown>).personaDisplayName as string,
+  };
   if (!context?.personaId) return;
 
   const extractionModel = (response.request.data as Record<string, unknown>).extraction_model as string | undefined;
@@ -347,7 +350,10 @@ export async function handleEventScan(response: LLMResponse, state: StateManager
     return;
   }
 
-  const context = response.request.data as unknown as ExtractionContext;
+  const context = {
+    ...(response.request.data as unknown as ExtractionContext),
+    channelDisplayName: (response.request.data as Record<string, unknown>).personaDisplayName as string,
+  };
   if (!context?.personaId) return;
 
   const extractionModel = (response.request.data as Record<string, unknown>).extraction_model as string | undefined;

package/src/core/llm-client.ts

@@ -310,10 +310,16 @@ export async function callLLMRaw(
     headers["anthropic-dangerous-direct-browser-access"] = "true";
   }
   
+  // Omit temperature for models that don't accept it (e.g. Anthropic extended-thinking models).
+  // Also omit when thinking_budget > 0: Anthropic rejects temperature alongside thinking params.
+  const sendTemperature =
+    !modelConfig?.temperature_disabled &&
+    !(modelConfig?.thinking_budget !== undefined && modelConfig.thinking_budget > 0);
+
   const requestBody: Record<string, unknown> = {
     ...(model !== undefined && { model }),
     messages: finalMessages,
-    temperature,
+    ...(sendTemperature && { temperature }),
     max_tokens: modelConfig?.max_output_tokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
   };
 

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

@@ -479,6 +479,7 @@ export function queueTopicUpdate(
       next_step: LLMNextStep.HandleTopicUpdate,
       data: {
         ...context,
+        personaDisplayName: context.channelDisplayName,
         isNewItem,
         existingItemId: existingItem?.id,
         candidateName: isNewItem ? context.candidateName : undefined,

package/src/core/personas/opencode-agent.ts

@@ -3,7 +3,6 @@ import type { PersonaTrait } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 import type { IOpenCodeReader } from "../../integrations/opencode/types.js";
 import { AGENT_ALIASES } from "../../integrations/opencode/types.js";
-import { createOpenCodeReader } from "../../integrations/opencode/reader-factory.js";
 import { DEFAULT_SEED_TRAITS } from "../constants/seed-traits.js";
 
 const OPENCODE_GROUP = "OpenCode";
@@ -52,8 +51,7 @@ export async function ensureAgentPersona(
     return existing;
   }
 
-  const agentReader = reader ?? await createOpenCodeReader();
-  const agentInfo = await agentReader.getAgentInfo(canonical);
+  const agentInfo = reader ? await reader.getAgentInfo(canonical) : null;
 
   const now = new Date().toISOString();
   const personaId = crypto.randomUUID();

package/src/core/types/entities.ts

@@ -60,6 +60,7 @@ export interface ModelConfig {
   token_limit?: number;             // Input token limit (user sets effective limit)
   max_output_tokens?: number;       // Output token limit (API-enforced)
   thinking_budget?: number;         // Thinking token budget: 0 = disabled, N = enable with N tokens, undefined = don't send
+  temperature_disabled?: boolean;   // Set true for models that reject temperature (e.g. Anthropic extended-thinking models)
   total_calls?: number;             // Usage counter
   total_tokens_in?: number;         // Usage counter
   total_tokens_out?: number;        // Usage counter

package/src/integrations/pi/importer.ts

@@ -20,11 +20,16 @@ import {
   type IPiReader,
 } from "./types.js";
 import { MIN_SESSION_AGE_MS, TWELVE_HOURS_MS } from "../constants.js";
+import {
+  ensureAgentPersona,
+  resolveCanonicalAgent,
+} from "../../core/personas/opencode-agent.js";
 
 export interface PiImportResult {
   sessionsProcessed: number;
   messagesImported: number;
   personaCreated: boolean;
+  personasCreated: string[];
   extractionScansQueued: number;
 }
 
@@ -121,6 +126,7 @@ export async function importPiSessions(options: PiImporterOptions): Promise<PiIm
     sessionsProcessed: 0,
     messagesImported: 0,
     personaCreated: false,
+    personasCreated: [],
     extractionScansQueued: 0,
   };
 
@@ -167,56 +173,142 @@ export async function importPiSessions(options: PiImporterOptions): Promise<PiIm
 
   if (signal?.aborted) return result;
 
-  const personaExistedBefore = stateManager.persona_getByName(PI_PERSONA_NAME) !== null;
-  const persona = ensurePiPersona(stateManager, eiInterface);
-  result.personaCreated = !personaExistedBefore;
-
-  const existingMsgs = stateManager.messages_get(persona.id);
-  const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
-  if (externalIds.length > 0) {
-    stateManager.messages_remove(persona.id, externalIds);
-  }
-
-  const cutoffIso = processedSessions[targetSession.id] ?? null;
-  const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
-  const toAnalyze: Message[] = [];
-
-  for (const msg of messages) {
-    const msgMs = new Date(msg.timestamp).getTime();
-    const isOld = cutoffMs !== null && msgMs < cutoffMs;
-    const eiMsg = isOld
-      ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
-      : convertToEiMessage(msg, targetSession.id, qualify);
-
-    stateManager.messages_append(persona.id, eiMsg);
-    result.messagesImported++;
-    if (!isOld) toAnalyze.push(eiMsg);
-  }
-
-  stateManager.messages_sort(persona.id);
-  eiInterface?.onMessageAdded?.(persona.id);
-
-  if (toAnalyze.length > 0 && !signal?.aborted) {
-    const allInState = stateManager.messages_get(persona.id);
-    const analyzeIds = new Set(toAnalyze.map((m) => m.id));
-    const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
-    const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
-
-    const context: ExtractionContext = {
-      personaId: persona.id,
-      channelDisplayName: persona.display_name,
-      messages_context: contextMsgs,
-      messages_analyze: toAnalyze,
-      sources: [`pi:${getMachineId()}:${targetSession.id}`],
-    };
-
-    queuePersonRewritePhase(stateManager);
-    queueTopicRewritePhase(stateManager);
-    queueAllScans(context, stateManager, {
-      extraction_model: human.settings?.pi?.extraction_model,
-      external_filter: "only",
-    });
-    result.extractionScansQueued += 4;
+  const hasAgentAttribution = messages.some((m) => m.agent != null);
+
+  if (!hasAgentAttribution) {
+    // ─── Single-persona path (vanilla Pi / OMP without active agent) ────────
+    const personaExistedBefore = stateManager.persona_getByName(PI_PERSONA_NAME) !== null;
+    const persona = ensurePiPersona(stateManager, eiInterface);
+    result.personaCreated = !personaExistedBefore;
+
+    const existingMsgs = stateManager.messages_get(persona.id);
+    const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+    if (externalIds.length > 0) {
+      stateManager.messages_remove(persona.id, externalIds);
+    }
+
+    const cutoffIso = processedSessions[targetSession.id] ?? null;
+    const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+    const toAnalyze: Message[] = [];
+
+    for (const msg of messages) {
+      const msgMs = new Date(msg.timestamp).getTime();
+      const isOld = cutoffMs !== null && msgMs < cutoffMs;
+      const eiMsg = isOld
+        ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+        : convertToEiMessage(msg, targetSession.id, qualify);
+
+      stateManager.messages_append(persona.id, eiMsg);
+      result.messagesImported++;
+      if (!isOld) toAnalyze.push(eiMsg);
+    }
+
+    stateManager.messages_sort(persona.id);
+    eiInterface?.onMessageAdded?.(persona.id);
+
+    if (toAnalyze.length > 0 && !signal?.aborted) {
+      const allInState = stateManager.messages_get(persona.id);
+      const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+      const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+      const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+      const context: ExtractionContext = {
+        personaId: persona.id,
+        channelDisplayName: persona.display_name,
+        messages_context: contextMsgs,
+        messages_analyze: toAnalyze,
+        sources: [`pi:${getMachineId()}:${targetSession.id}`],
+      };
+
+      queuePersonRewritePhase(stateManager);
+      queueTopicRewritePhase(stateManager);
+      queueAllScans(context, stateManager, {
+        extraction_model: human.settings?.pi?.extraction_model,
+        external_filter: "only",
+      });
+      result.extractionScansQueued += 4;
+    }
+  } else {
+    // ─── Multi-agent path (OMP sessions with agent attribution) ─────────────
+    const byPersonaId = new Map<string, { persona: NonNullable<ReturnType<typeof stateManager.persona_getByName>>; msgs: typeof messages; agentName: string }>();
+
+    for (const msg of messages) {
+      const agentName = msg.agent ?? PI_PERSONA_NAME;
+      let persona = stateManager.persona_getByName(agentName);
+      if (!persona) {
+        const { canonical } = resolveCanonicalAgent(agentName);
+        persona = stateManager.persona_getByName(canonical);
+      }
+      if (!persona) {
+        persona = await ensureAgentPersona(agentName, {
+          stateManager,
+          interface: eiInterface,
+          reader: undefined,
+        });
+        result.personasCreated.push(agentName);
+      }
+      const bucket = byPersonaId.get(persona.id);
+      if (bucket) {
+        bucket.msgs.push(msg);
+      } else {
+        byPersonaId.set(persona.id, { persona, msgs: [msg], agentName });
+      }
+    }
+
+    const cutoffIso = processedSessions[targetSession.id] ?? null;
+    const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+    let anyPersonaHasChanges = false;
+
+    for (const [, { persona, msgs: agentMsgs }] of byPersonaId) {
+      const existingMsgs = stateManager.messages_get(persona.id);
+      const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+      if (externalIds.length > 0) {
+        stateManager.messages_remove(persona.id, externalIds);
+      }
+
+      const toAnalyze: Message[] = [];
+      for (const msg of agentMsgs) {
+        const msgMs = new Date(msg.timestamp).getTime();
+        const isOld = cutoffMs !== null && msgMs < cutoffMs;
+        const eiMsg = isOld
+          ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+          : convertToEiMessage(msg, targetSession.id, qualify);
+
+        stateManager.messages_append(persona.id, eiMsg);
+        result.messagesImported++;
+        if (!isOld) toAnalyze.push(eiMsg);
+      }
+
+      stateManager.messages_sort(persona.id);
+      eiInterface?.onMessageAdded?.(persona.id);
+
+      if (toAnalyze.length > 0 && !signal?.aborted) {
+        const allInState = stateManager.messages_get(persona.id);
+        const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+        const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+        const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+        const context: ExtractionContext = {
+          personaId: persona.id,
+          channelDisplayName: persona.display_name,
+          messages_context: contextMsgs,
+          messages_analyze: toAnalyze,
+          sources: [`pi:${getMachineId()}:${targetSession.id}`],
+        };
+
+        anyPersonaHasChanges = true;
+        queueAllScans(context, stateManager, {
+          extraction_model: human.settings?.pi?.extraction_model,
+          external_filter: "only",
+        });
+        result.extractionScansQueued += 4;
+      }
+    }
+
+    if (anyPersonaHasChanges && !signal?.aborted) {
+      queuePersonRewritePhase(stateManager);
+      queueTopicRewritePhase(stateManager);
+    }
   }
 
   result.sessionsProcessed = 1;

package/src/integrations/pi/reader.ts

@@ -199,6 +199,7 @@ export class PiReader implements IPiReader {
         role,
         content,
         timestamp: ts ?? new Date(0).toISOString(),
+        agent: entry.agent as string | undefined,
       });
     }
 

package/src/integrations/pi/types.ts

@@ -49,6 +49,8 @@ export interface PiMessageEntry {
   id: string;
   parentId?: string;
   timestamp: string;
+  /** Active agent definition name, present only for OMP sessions. Mirrors the `agent` field on OpenCode message rows. */
+  agent?: string;
   message: PiMessagePayload;
   [key: string]: unknown;
 }
@@ -112,6 +114,8 @@ export interface PiMessage {
   role: "user" | "assistant";
   content: string;
   timestamp: string;
+  /** Active agent definition name when this message was recorded; undefined for vanilla Pi or OMP without an active agent. */
+  agent?: string;
 }
 
 // ============================================================================

package/tui/src/util/provider-detection.ts

@@ -63,8 +63,10 @@ export const ALL_PROVIDER_NAMES: ReadonlyArray<string> = [
 // For example, Haiku's advertised context is 200k but real-world extraction quality degrades
 // above ~100k, so we cap it there. When adding new models, prefer conservative values based
 // on actual usage over marketing specs.
-export const KNOWN_MODEL_LIMITS: Readonly<Record<string, { token_limit?: number; max_output_tokens?: number }>> = {
+export const KNOWN_MODEL_LIMITS: Readonly<Record<string, { token_limit?: number; max_output_tokens?: number; temperature_disabled?: boolean }>> = {
   // Anthropic — claude-opus-4.x
+  // Models from 4-8 onward always use extended thinking and reject the temperature parameter.
+  "claude-opus-4-8":              { token_limit: 200000, max_output_tokens: 128000, temperature_disabled: true },
   "claude-opus-4-7":              { token_limit: 200000, max_output_tokens: 128000 },
   "claude-opus-4-6":              { token_limit: 200000, max_output_tokens: 128000 },
   "claude-opus-4-5-20251101":     { token_limit: 200000, max_output_tokens: 64000 },
@@ -361,9 +363,9 @@ export function buildProviderAccounts(
         name: modelName,
         ...(limits?.token_limit !== undefined && { token_limit: limits.token_limit }),
         ...(limits?.max_output_tokens !== undefined && { max_output_tokens: limits.max_output_tokens }),
+        ...(limits?.temperature_disabled === true && { temperature_disabled: true }),
       };
     };
-
     const seenNames = new Set<string>();
     const models: ModelConfig[] = [];