ei-tui 1.6.1 → 1.6.3

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * EI CLI - Memory retrieval interface for OpenCode integration
+ * EI CLI - Memory retrieval interface for coding tool integrations
  *
  * Usage:
  *   ei "search text"               Search all data types
@@ -53,7 +53,7 @@ Usage:
   ei --persona "Name" "query"   Filter results to what a persona has learned
   ei --id <id>                  Look up a specific entity by ID
   echo <id> | ei --id           Look up entity by ID from stdin
-  ei mcp                        Start the Ei MCP stdio server (for Cursor/Claude Desktop)
+  ei mcp                        Start the Ei MCP stdio server (for Claude Code/Cursor/Codex)
 
 Types:
   quote / quotes      Quotes from conversation history
@@ -66,11 +66,11 @@ Options:
   --number, -n        Maximum number of results (default: 10)
   --recent, -r        Sort by last_mentioned date (most recent first)
   --persona, -p       Filter to entities a specific persona has learned about
-  --source, -s        Filter to entities from a specific source (prefix match, e.g. "cursor", "opencode:my-machine", "opencode:my-machine:ses_abc123")
+  --source, -s        Filter to entities from a specific source (prefix match, e.g. "cursor", "codex:my-machine", "opencode:my-machine:ses_abc123")
   --id                Look up entity by ID (accepts value or stdin)
-  --install           Register Ei with Claude Code, Cursor, and OpenCode (MCP + context hooks)
+  --install           Register Ei with Claude Code, Cursor, Codex, and OpenCode (MCP + context hooks where supported)
   --session <id>      Session ID to enrich the query with recent context (use with --hook-source)
-  --hook-source <src> Source of the hook: "opencode-plugin" (OpenCode SQLite) or "cursor"
+  --hook-source <src> Source of the hook: "opencode-plugin" (OpenCode SQLite), "cursor", or "codex"
   --transcript <path> Path to a Claude Code JSONL transcript file for context enrichment
   --help, -h          Show this help message
 
@@ -93,6 +93,12 @@ async function installMcpClients(): Promise<void> {
 
   const home = process.env.HOME || "~";
 
+  if (await commandExists("codex")) {
+    await installCodex();
+  } else {
+    console.log(`ℹ️  Codex CLI not detected — skipping Codex MCP install.`);
+  }
+
   const cursorDataDirs = [
     join(home, "Library", "Application Support", "Cursor"),
     join(home, ".config", "Cursor"),
@@ -115,6 +121,180 @@ async function installMcpClients(): Promise<void> {
   } else {
     console.log(`ℹ️  OpenCode not detected — skipping OpenCode plugin install.`);
   }
+
+  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) {
+    await installPi();
+  } else {
+    console.log(`ℹ️  Pi/OMP not detected — skipping Pi extension install.`);
+  }
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    const proc = Bun.spawn([command, "--version"], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+function hookEntryHasCommand(entry: unknown, command: string): boolean {
+  if (typeof entry !== "object" || entry === null || !("hooks" in entry)) return false;
+  const hooks = (entry as { hooks?: unknown }).hooks;
+  if (!Array.isArray(hooks)) return false;
+
+  return hooks.some((hook) => {
+    if (typeof hook !== "object" || hook === null) return false;
+    const candidate = hook as { type?: unknown; command?: unknown };
+    return candidate.type === "command" && candidate.command === command;
+  });
+}
+
+async function installCodex(): Promise<void> {
+  const dataPath = process.env.EI_DATA_PATH ?? join(process.env.HOME || "~", ".local", "share", "ei");
+  const proc = Bun.spawn(
+    ["codex", "mcp", "add", "ei", "--env", `EI_DATA_PATH=${dataPath}`, "--", "bunx", "ei-tui", "mcp"],
+    {
+      stdout: "pipe",
+      stderr: "pipe",
+    }
+  );
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (exitCode !== 0) {
+    console.warn(`⚠️  Codex MCP install failed.`);
+    const detail = (stderr || stdout).trim();
+    if (detail) console.warn(`   ${detail}`);
+  } else {
+    console.log(`✓ Installed Ei MCP server to Codex config (~/.codex/config.toml)`);
+    console.log(`  Restart Codex to activate MCP.`);
+  }
+
+  await installCodexHooks();
+}
+
+async function installCodexHooks(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const hooksDir = join(home, ".codex", "hooks");
+  const scriptPath = join(hooksDir, "ei-inject.ts");
+  const hooksJsonPath = join(home, ".codex", "hooks.json");
+
+  await Bun.$`mkdir -p ${hooksDir}`;
+
+  try {
+    await Bun.$`test -w ${hooksDir}`.quiet();
+  } catch {
+    console.warn(`⚠️  Cannot write to ${hooksDir} (permission denied).`);
+    console.warn(`   Fix with: sudo chown ${process.env.USER ?? "$(whoami)"} ${hooksDir}`);
+    console.warn(`   Then re-run: ei --install`);
+    return;
+  }
+
+  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\`,
+    },
+  }));
+}
+`;
+
+  await Bun.write(scriptPath, scriptContent);
+  await Bun.$`chmod +x ${scriptPath}`;
+
+  type CodexUserPromptHook = {
+    hooks: Array<{ type: string; command: string; statusMessage?: string; timeout?: number }>;
+  };
+
+  interface CodexHooksConfig {
+    hooks: {
+      UserPromptSubmit?: CodexUserPromptHook[];
+      [key: string]: unknown;
+    };
+  }
+
+  let hooksConfig: CodexHooksConfig = { hooks: {} };
+  try {
+    const text = await Bun.file(hooksJsonPath).text();
+    hooksConfig = JSON.parse(text) as CodexHooksConfig;
+    if (!hooksConfig.hooks || typeof hooksConfig.hooks !== "object") {
+      hooksConfig.hooks = {};
+    }
+  } catch {
+    // File doesn't exist or isn't valid JSON — start fresh
+  }
+
+  const userPromptSubmit = (hooksConfig.hooks.UserPromptSubmit ?? []) as CodexUserPromptHook[];
+  const hookEntry = {
+    hooks: [{
+      type: "command",
+      command: scriptPath,
+      statusMessage: "Loading Ei memory context",
+      timeout: 30,
+    }],
+  };
+  const alreadyInstalled = userPromptSubmit.some((entry) => hookEntryHasCommand(entry, scriptPath));
+  if (!alreadyInstalled) {
+    userPromptSubmit.push(hookEntry);
+  }
+
+  hooksConfig.hooks.UserPromptSubmit = userPromptSubmit;
+
+  const tmpPath = `${hooksJsonPath}.ei-install.tmp`;
+  await Bun.write(tmpPath, JSON.stringify(hooksConfig, null, 2) + "\n");
+  const { rename } = await import(/* @vite-ignore */ "fs/promises");
+  await rename(tmpPath, hooksJsonPath);
+
+  console.log(`✓ Installed Ei Codex context hook to ~/.codex/hooks/ei-inject.ts`);
+  console.log(`  Use /hooks in Codex to review/trust the hook if prompted.`);
 }
 
 async function installClaudeCode(): Promise<void> {
@@ -182,12 +362,11 @@ const heading = \`
 *(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 topics MAY be relevant to your current task — use \\\`ei_search\\\` or \\\`ei_lookup\\\` for targeted queries.
+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 typeArgs = ["topics", "-n", "5"];
 
 const sessionArgs = [];
 if (input.session_id && input.hook_source) {
@@ -196,7 +375,7 @@ if (input.session_id && input.hook_source) {
   sessionArgs.push("--transcript", input.transcript_path);
 }
 
-const args = raw ? [...typeArgs, ...sessionArgs, raw] : ["--recent", ...typeArgs];
+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\`);
@@ -217,9 +396,7 @@ if (output.trim()) process.stdout.write(\`\\n\${heading}\\n\${output.trim()}\\n\
   const userPromptSubmit = (hooks.UserPromptSubmit ?? []) as unknown[];
 
   const hookEntry = { hooks: [{ type: "command", command: "~/.claude/hooks/ei-inject.ts" }] };
-  const alreadyInstalled = userPromptSubmit.some(
-    (entry) => JSON.stringify(entry) === JSON.stringify(hookEntry)
-  );
+  const alreadyInstalled = userPromptSubmit.some((entry) => hookEntryHasCommand(entry, "~/.claude/hooks/ei-inject.ts"));
   if (!alreadyInstalled) {
     userPromptSubmit.push(hookEntry);
   }
@@ -340,6 +517,135 @@ exit 0
   console.log(`✓ Installed Ei context hook to ~/.cursor/hooks/ei-inject.sh`);
 }
 
+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";
+
+export default function eiIntegration(pi: ExtensionAPI) {
+  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 $\`bunx ei-tui@latest \${args}\`
+      .env({ ...process.env, EI_DATA_PATH: "${dataPath}" })
+      .quiet()
+      .text()
+      .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,
+      },
+    };
+  });
+
+  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({
+      query: Type.String({ description: "Natural language search query" }),
+      type: Type.Optional(Type.Union([
+        Type.Literal("facts"),
+        Type.Literal("topics"),
+        Type.Literal("people"),
+        Type.Literal("quotes"),
+        Type.Literal("personas"),
+      ], { description: "Filter to a specific data type. Omit for balanced results across all types." })),
+    }),
+    async execute(_id, params, _signal, _onUpdate, _ctx) {
+      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");
+      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({
+      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");
+      return {
+        content: [{ type: "text" as const, text: output.trim() || "Not found" }],
+        details: {},
+      };
+    },
+  });
+}
+`;
+
+  const piExtDir = join(home, ".pi", "agent", "extensions");
+  const ompExtDir = join(home, ".omp", "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();
+
+  if (hasPiAgent) {
+    await Bun.$`mkdir -p ${piExtDir}`;
+    await Bun.write(join(piExtDir, extFilename), extensionContent);
+    console.log(`✓ Installed Ei extension to ~/.pi/agent/extensions/${extFilename}`);
+  }
+
+  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 installOpenCodePlugin(): Promise<void> {
   const home = process.env.HOME || "~";
   const opencodeDir = join(home, ".config", "opencode");
@@ -497,6 +803,15 @@ async function getRecentSessionMessages(
   if (transcriptPath) {
     try {
       const text = await Bun.file(transcriptPath).text();
+
+      const { parseCodexRolloutMessages } = await import(
+        /* @vite-ignore */ "./integrations/codex/reader.js"
+      );
+      const codexMessages = parseCodexRolloutMessages(text, sessionId ?? "transcript");
+      if (codexMessages.length > 0) {
+        return codexMessages.slice(-5).map((m) => `${m.role}: ${m.content}`);
+      }
+
       const messages: Array<{ content: string }> = [];
 
       for (const line of text.split("\n")) {
@@ -529,7 +844,7 @@ async function getRecentSessionMessages(
         }
       }
 
-      return messages.slice(-4).map((m) => m.content);
+      return messages.slice(-5).map((m) => m.content);
     } catch {
       return [];
     }
@@ -544,7 +859,7 @@ async function getRecentSessionMessages(
       );
       const reader = await createOpenCodeReader();
       const messages = await reader.getMessagesForSession(sessionId);
-      return messages.slice(-4).map((m) => m.content);
+      return messages.slice(-5).map((m) => `${m.role}: ${m.content}`);
     }
 
     if (hookSource === "cursor") {
@@ -556,7 +871,20 @@ async function getRecentSessionMessages(
       const session =
         sessions.find((s) => s.id === sessionId) ?? sessions[sessions.length - 1];
       if (session) {
-        return session.messages.slice(-4).map((m) => m.text);
+        return session.messages.slice(-5).map((m) => `${m.type === 1 ? "user" : "assistant"}: ${m.text}`);
+      }
+    }
+
+    if (hookSource === "codex") {
+      const { CodexReader } = await import(
+        /* @vite-ignore */ "./integrations/codex/reader.js"
+      );
+      const reader = new CodexReader();
+      const sessions = await reader.getSessions();
+      const session =
+        sessions.find((s) => s.id === sessionId) ?? sessions[sessions.length - 1];
+      if (session) {
+        return session.messages.slice(-5).map((m) => `${m.role}: ${m.content}`);
       }
     }
   } catch {
@@ -589,6 +917,16 @@ async function main(): Promise<void> {
   if (args[0] === "--install") {
     await installMcpClients();
     console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Codex
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  If Codex was detected, Ei MCP was registered via:
+
+    codex mcp add ei --env EI_DATA_PATH="${process.env.EI_DATA_PATH ?? "~/.local/share/ei"}" -- bunx ei-tui mcp
+
+  Restart Codex to activate.
+
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   OpenCode: add to ~/.config/opencode/opencode.jsonc
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/src/core/context-utils.ts

@@ -18,7 +18,6 @@ export function filterMessagesForContext(
 
   return messages.filter((msg) => {
     if (msg.external === true) return false;
-    if (msg.context_status === ContextStatusEnum.Always) return true;
     if (msg.context_status === ContextStatusEnum.Never) return false;
 
     const msgMs = new Date(msg.timestamp).getTime();

package/src/core/orchestrators/ceremony.ts

@@ -475,7 +475,7 @@ export function queueReflectionDrain(personaId: string, state: StateManager): vo
     messages_analyze: unextractedPeople,
     extraction_flag: "p",
   };
-  queuePersonScan(context, state);
+  queuePersonScan(context, state, { reflection_progress: 1 });
   console.log(`[reflection:drain] Queued Person scan for ${persona.display_name} (${unextractedPeople.length} messages) — clears on completion`);
 }
 

package/src/core/processor.ts

@@ -148,6 +148,8 @@ const DEFAULT_LOOP_INTERVAL_MS = 100;
 const DEFAULT_OPENCODE_POLLING_MS = 60000;
 const DEFAULT_CLAUDE_CODE_POLLING_MS = 60000;
 const DEFAULT_CURSOR_POLLING_MS = 60000;
+const DEFAULT_CODEX_POLLING_MS = 60000;
+const DEFAULT_PI_POLLING_MS = 60000;
 
 let processorInstanceCount = 0;
 
@@ -170,6 +172,10 @@ export class Processor {
   private claudeCodeImportInProgress = false;
   private lastCursorSync = 0;
   private cursorImportInProgress = false;
+  private lastCodexSync = 0;
+  private codexImportInProgress = false;
+  private lastPiSync = 0;
+  private piImportInProgress = false;
   private lastSlackSync = 0;
   private slackImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
@@ -1200,6 +1206,14 @@ export class Processor {
       modified = true;
     }
 
+    if (!human.settings.codex) {
+      human.settings.codex = {
+        integration: false,
+        polling_interval_ms: 60000,
+      };
+      modified = true;
+    }
+
     if (!human.settings.ceremony) {
       human.settings.ceremony = {
         time: "09:00",
@@ -1277,6 +1291,18 @@ export class Processor {
       console.log(`[Processor ${this.instanceId}] Clearing claudeCodeImportInProgress flag`);
       this.claudeCodeImportInProgress = false;
     }
+    if (this.cursorImportInProgress) {
+      console.log(`[Processor ${this.instanceId}] Clearing cursorImportInProgress flag`);
+      this.cursorImportInProgress = false;
+    }
+    if (this.codexImportInProgress) {
+      console.log(`[Processor ${this.instanceId}] Clearing codexImportInProgress flag`);
+      this.codexImportInProgress = false;
+    }
+    if (this.piImportInProgress) {
+      console.log(`[Processor ${this.instanceId}] Clearing piImportInProgress flag`);
+      this.piImportInProgress = false;
+    }
     if (this.slackImportInProgress) {
       console.log(`[Processor ${this.instanceId}] Clearing slackImportInProgress flag`);
       this.slackImportInProgress = false;
@@ -1522,6 +1548,22 @@ const toolNextSteps = new Set([
       await this.checkAndSyncCursor(human, now);
     }
 
+    if (
+      this.isTUI &&
+      human.settings?.codex?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncCodex(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.pi?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncPi(human, now);
+    }
+
     if (
       this.isTUI &&
       human.settings?.personaHistory?.integration &&
@@ -1779,6 +1821,114 @@ const toolNextSteps = new Set([
       });
   }
 
+  private async checkAndSyncCodex(human: HumanEntity, now: number): Promise<void> {
+    if (this.codexImportInProgress) {
+      return;
+    }
+
+    const codex = human.settings?.codex;
+    const pollingInterval = codex?.polling_interval_ms ?? DEFAULT_CODEX_POLLING_MS;
+    const lastSync = codex?.last_sync ? new Date(codex.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastCodexSync > 0) {
+      return;
+    }
+
+    this.lastCodexSync = now;
+    const syncTimestamp = new Date().toISOString();
+    const currentHuman = this.stateManager.getHuman();
+    this.stateManager.setHuman({
+      ...currentHuman,
+      settings: {
+        ...currentHuman.settings,
+        codex: {
+          ...codex,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.codexImportInProgress = true;
+    import("../integrations/codex/importer.js")
+      .then(({ importCodexSessions }) =>
+        importCodexSessions({
+          stateManager: this.stateManager,
+          interface: this.interface,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Codex sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Codex sync failed:`, err);
+      })
+      .finally(() => {
+        this.codexImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncPi(human: HumanEntity, now: number): Promise<void> {
+    if (this.piImportInProgress) {
+      return;
+    }
+
+    const pi = human.settings?.pi;
+    const pollingInterval = pi?.polling_interval_ms ?? DEFAULT_PI_POLLING_MS;
+    const lastSync = pi?.last_sync ? new Date(pi.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastPiSync > 0) {
+      return;
+    }
+
+    this.lastPiSync = now;
+    const syncTimestamp = new Date().toISOString();
+    const currentHuman = this.stateManager.getHuman();
+    this.stateManager.setHuman({
+      ...currentHuman,
+      settings: {
+        ...currentHuman.settings,
+        pi: {
+          ...pi,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.piImportInProgress = true;
+    import("../integrations/pi/importer.js")
+      .then(({ importPiSessions }) =>
+        importPiSessions({
+          stateManager: this.stateManager,
+          interface: this.interface,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Pi sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Pi sync failed:`, err);
+      })
+      .finally(() => {
+        this.piImportInProgress = false;
+      });
+  }
+
   private async checkAndSyncSlack(human: HumanEntity, now: number): Promise<void> {
     if (this.slackImportInProgress) return;
 

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

@@ -15,7 +15,7 @@ export interface DataItemBase {
   learned_by?: string;           // Persona ID that originally learned this item (stable UUID)
   last_changed_by?: string;      // Persona ID that most recently updated this item (stable UUID)
   interested_personas?: string[]; // Persona IDs that have extracted/touched this item (accumulated)
-  sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId"). Grow-only union.
+  sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId", "codex:threadId"). Grow-only union.
   persona_groups?: string[];
   embedding?: number[];
   rewrite_length_floor?: number; // Set after every rewrite scan: ceil(description.length * 1.1). Item is skipped by ceremony until description grows past this floor. Preserved across extraction upserts — only cleared when description exceeds it.

package/src/core/types/entities.ts

@@ -130,6 +130,8 @@ export interface HumanSettings {
   backup?: BackupConfig;
   claudeCode?: import("../../integrations/claude-code/types.js").ClaudeCodeSettings;
   cursor?: import("../../integrations/cursor/types.js").CursorSettings;
+  codex?: import("../../integrations/codex/types.js").CodexSettings;
+  pi?: import("../../integrations/pi/types.js").PiSettings;
   document?: DocumentSettings;
   active_theme?: string;
   custom_themes?: ThemeDefinition[];