ei-tui 1.6.1 → 1.6.2

package/README.md

@@ -1,12 +1,12 @@
 # Ei
 
-A local-first AI companion system with persistent personas and coding tool integrations (OpenCode, Claude Code, Cursor).
+A local-first AI companion system with persistent personas and coding tool integrations (OpenCode, Claude Code, Cursor, Codex).
 
 You can access the Web version at [ei.flare576.com](https://ei.flare576.com).
 
 You can run the local version via `bunx ei-tui` — no install needed, always current (see [### TUI](#tui) for details).
 
-If you're here to give your coding tools (OpenCode, Claude Code, Cursor) persistent memory, jump over to [TUI README.md](./tui/README.md) to learn how to get information _into_ Ei, and [CLI README.md](./src/cli/README.md) to wire up automatic context injection so your agents receive relevant memory before every message — no tool calls required.
+If you're here to give your coding tools (OpenCode, Claude Code, Cursor, Codex) persistent memory, jump over to [TUI README.md](./tui/README.md) to learn how to get information _into_ Ei, and [CLI README.md](./src/cli/README.md) to wire up MCP/context injection so your agents can read relevant memory when they need it.
 
 ## What Does "Local First" Mean?
 
@@ -83,7 +83,7 @@ Ei can operate with three types of input, and three types of output.
                        ^
                     Sessions
                        |
-          [OpenCode / Claude Code / Cursor]
+          [OpenCode / Claude Code / Cursor / Codex]
 ```
 
 ```
@@ -91,7 +91,7 @@ Ei can operate with three types of input, and three types of output.
                           |
                        CLI Data
                           v
-                      [OpenCode]
+              [OpenCode / Claude Code / Cursor / Codex]
 ```
 
 Optionally, users can opt into a server-side data sync. This is ideal for users who want to use multiple devices or switch between TUI and Web throughout the day. All data is encrypted _before_ being sent to the server, using a key that only the user can generate (your `username` and `passphrase` never leave your device - I couldn't decrypt your data if I wanted to).
@@ -129,7 +129,7 @@ More information (including commands) can be found in the [TUI Readme](tui/READM
 
 Ei can import sessions from your coding tools and extract what you've been working on — pulling out facts, topics, and context that persist across sessions. Enable any combination; they work independently and feed into the same knowledge base.
 
-All three integrations are enabled via `/settings` in the TUI.
+All four integrations are enabled via `/settings` in the TUI.
 
 #### OpenCode
 
@@ -165,6 +165,21 @@ Reads from Cursor's SQLite databases:
 
 All sessions map to a single "Cursor" persona.
 
+#### Codex
+
+```yaml
+codex:
+  integration: true
+```
+
+Reads from Codex's local state database and rollout JSONL files:
+- `~/.codex/state_*.sqlite`
+- `~/.codex/sessions/`
+
+All sessions map to a single "Codex" persona. Codex may store thread-level agent metadata for custom agents, but rollout messages do not reliably expose per-message sub-agent speaker identity yet. Tool calls, prompt scaffolding, and token-count events are stripped — only visible user/agent messages are imported.
+
+Codex can also read Ei's knowledge back out. Run `ei --install` to register the Ei MCP server and install a Codex `UserPromptSubmit` hook that injects relevant memory before each message, using your current prompt plus recent Codex transcript context when available.
+
 ---
 
 Sessions are processed oldest-first, one per queue cycle, so Ei won't overwhelm your LLM provider on first run. See [TUI Readme](tui/README.md)
@@ -233,7 +248,7 @@ Personas can use tools. Not just read-from-memory tools — *actual* tools. Web
 |------|-------------|
 | `find_memory` | Semantic search of your personal memory — facts, traits, topics, people, quotes. Personas call this automatically when the conversation touches something they might know about you. Supports the `persona` filter to scope results to what a specific persona has learned. |
 | `fetch_memory` | Full-record lookup for a specific human entity (Fact, Topic, Person, or Quote) by ID. Use after `find_memory` to retrieve complete details. |
-| `fetch_message` | Retrieve a specific message by ID with optional surrounding context. Searches persona conversations and room messages. |
+| `fetch_message` | Retrieve a specific message by fully-qualified ID with optional surrounding context. Searches Ei conversations and supported external coding-session stores. |
 | `file_read` | Read a file from your local filesystem *(TUI only)* |
 | `list_directory` | Explore folder structure *(TUI only)* |
 | `directory_tree` | Recursive directory tree *(TUI only)* |

package/package.json

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

package/src/cli/README.md

@@ -15,8 +15,8 @@ ei --recent                            # Most recently mentioned items (no query
 ei --persona "Beta" --recent           # Most recently mentioned items Beta has learned
 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                   # Wire Ei into Claude Code, Cursor, and OpenCode (MCP + hooks + persona plugin)
-ei mcp                         # Start the Ei MCP stdio server (for Cursor/Claude Desktop)
+ei --install                   # Wire Ei into Claude Code, Cursor, Codex, and OpenCode (MCP + hooks + persona plugin)
+ei mcp                         # Start the Ei MCP stdio server (for Claude Code/Cursor/Codex)
 ```
 
 Type aliases: `fact`, `person`, `topic`, `quote`, `persona` all work (singular or plural).
@@ -35,6 +35,7 @@ It also resolves fully-qualified message IDs from any supported integration, ret
 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"
+ei --id "codex:my-machine:thread-uuid:evt_42"
 ```
 
 Quotes surfaced by `ei_search` include a `message_id` field in this format — pipe it to `ei --id` to read the original conversation.
@@ -47,15 +48,16 @@ Quotes surfaced by `ei_search` include a `message_id` field in this format — p
 ei --install
 ```
 
-This registers Ei with Claude Code, Cursor, and OpenCode — MCP server config, context injection hooks, and (for OpenCode) a persona identity plugin so agents know who they are before the first message:
+This registers Ei with Claude Code, Cursor, Codex, and OpenCode — MCP server config, context injection hooks where supported, and (for OpenCode) a persona identity plugin so agents know who they are before the first message:
 
 | Tool | MCP | Context Hook | Persona Plugin |
 |------|-----|-------------|----------------|
 | **Claude Code** | `~/.claude.json` | `~/.claude/settings.json` (`UserPromptSubmit`) + `~/.claude/hooks/ei-inject.ts` | — |
 | **Cursor** | `~/.cursor/mcp.json` | `~/.cursor/hooks.json` (`beforeSubmitPrompt`) + `~/.cursor/hooks/ei-inject.sh` | — |
+| **Codex** | `~/.codex/config.toml` via `codex mcp add ei` | `~/.codex/hooks.json` (`UserPromptSubmit`) + `~/.codex/hooks/ei-inject.ts` | Local Codex agent plugin if installed separately |
 | **OpenCode** | manual (see below) | Via Oh My OpenCode compatibility layer (reads `~/.claude/settings.json`) | `~/.config/opencode/plugins/ei-persona.ts` |
 
-**Context hook**: fires before every message, searches Ei for topics relevant to what you just asked, injects them silently. No tool call required.
+**Context hook**: fires before every message, searches Ei for relevant memory, and injects it silently. No tool call required.
 
 **Persona plugin** (OpenCode + [Oh My OpenCode](https://github.com/code-yeongyu/oh-my-opencode) only): injects the agent's Ei relationship record directly into the system prompt at session start — traits, working style, shared context. The agent knows who it is *to you* before it reads a word of your message.
 
@@ -80,7 +82,7 @@ Restart your agent tool after changes to activate.
 
 ### MCP Server
 
-Claude Code and Cursor call `ei mcp` to start the MCP stdio server. You can run it directly to test:
+Claude Code, Cursor, and Codex call `ei mcp` to start the MCP stdio server. You can run it directly to test:
 
 ```sh
 ei mcp
@@ -97,7 +99,7 @@ The `ei_search`, `ei_lookup`, and `ei_fetch_message` MCP tools are still availab
 
 ## MCP Tools Reference
 
-The MCP server exposes these tools to Claude Code, Cursor, and OpenCode:
+The MCP server exposes these tools to Claude Code, Cursor, Codex, and OpenCode:
 
 | Tool | Description |
 |------|-------------|
@@ -112,7 +114,7 @@ The MCP server exposes these tools to Claude Code, Cursor, and OpenCode:
 | `query` | string (optional) | Search text. Omit to browse by recency. |
 | `type` | enum (optional) | `facts` \| `people` \| `topics` \| `quotes` \| `personas` — omit for balanced results across all types |
 | `persona` | string (optional) | Persona display_name to scope results to what that persona has learned |
-| `source` | string (optional) | Prefix match against source identifiers (e.g. `opencode`, `cursor:my-machine`) |
+| `source` | string (optional) | Prefix match against source identifiers (e.g. `opencode`, `cursor:my-machine`, `codex:my-machine`) |
 | `limit` | number (optional) | Max results, default 10 |
 | `recent` | boolean (optional) | Sort by most recently mentioned instead of relevance |
 

package/src/cli/mcp.ts

@@ -37,7 +37,7 @@ export function createMcpServer(): McpServer {
           .string()
           .optional()
           .describe(
-            "Filter to entities from a specific source. Prefix match against namespaced source identifiers (e.g. 'cursor', 'opencode', 'opencode:my-machine', 'opencode:my-machine:ses_abc123')."
+            "Filter to entities from a specific source. Prefix match against namespaced source identifiers (e.g. 'cursor', 'codex', 'opencode', 'opencode:my-machine', 'codex:my-machine:thread-id')."
           ),
         limit: z
           .number()
@@ -106,7 +106,7 @@ export function createMcpServer(): McpServer {
           .string()
           .optional()
           .describe(
-            "Filter to entities from a specific source. Prefix match against namespaced source identifiers (e.g. 'cursor', 'opencode', 'opencode:my-machine', 'opencode:my-machine:ses_abc123'). If the entity does not match, returns not found."
+            "Filter to entities from a specific source. Prefix match against namespaced source identifiers (e.g. 'cursor', 'codex', 'opencode', 'opencode:my-machine', 'codex:my-machine:thread-id'). If the entity does not match, returns not found."
           ),
       },
     },
@@ -134,7 +134,7 @@ export function createMcpServer(): McpServer {
     "ei_fetch_message",
     {
       description:
-        "Retrieve a specific message by its fully-qualified ID, with optional surrounding conversation context. Use when ei_search returns a quote with a message_id and you want to read the original exchange. The 'before' and 'after' parameters expand the context window in either direction (default 0). Accepts IDs from any integrated source: 'ei:uuid' searches Ei state, 'opencode:machine:session:id' queries OpenCode SQLite, 'claudecode:...' scans Claude Code JSONL files, 'cursor:...' reads the Cursor DB.",
+        "Retrieve a specific message by its fully-qualified ID, with optional surrounding conversation context. Use when ei_search returns a quote with a message_id and you want to read the original exchange. The 'before' and 'after' parameters expand the context window in either direction (default 0). Accepts IDs from any integrated source: 'ei:uuid' searches Ei state, 'opencode:machine:session:id' queries OpenCode SQLite, 'claudecode:...' scans Claude Code JSONL files, 'cursor:...' reads the Cursor DB, and 'codex:...' reads Codex rollout history.",
       inputSchema: {
         id: z.string().describe("The ID of the message to retrieve"),
         before: z

package/src/cli/retrieval.ts

@@ -499,6 +499,28 @@ export async function resolveExternalMessage(
       }
     }
 
+    case "codex": {
+      if (parsed.machine !== getMachineId()) {
+        return { error: `Message is from machine '${parsed.machine}', not available on this machine (${getMachineId()})` };
+      }
+      try {
+        const { CodexReader } = await import("../integrations/codex/reader.js");
+        const reader = new CodexReader();
+        const win = await reader.getMessageById(parsed.session!, 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 },
+          before: win.before.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp })),
+          after: win.after.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp })),
+          session: { id: win.session.id, title: win.session.title, directory: win.session.cwd },
+          source: "codex",
+        };
+      } catch {
+        return null;
+      }
+    }
+
     case "unknown":
     default: {
       // Backward compat: bare msg_xxx → treat as opencode (no machine qualifier)

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"),
@@ -117,6 +123,169 @@ async function installMcpClients(): Promise<void> {
   }
 }
 
+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> {
   const home = process.env.HOME || "~";
   const claudeJsonPath = join(home, ".claude.json");
@@ -217,9 +386,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);
   }
@@ -497,6 +664,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 +705,7 @@ async function getRecentSessionMessages(
         }
       }
 
-      return messages.slice(-4).map((m) => m.content);
+      return messages.slice(-5).map((m) => m.content);
     } catch {
       return [];
     }
@@ -544,7 +720,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 +732,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 +778,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,7 @@ 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;
 
 let processorInstanceCount = 0;
 
@@ -170,6 +171,8 @@ export class Processor {
   private claudeCodeImportInProgress = false;
   private lastCursorSync = 0;
   private cursorImportInProgress = false;
+  private lastCodexSync = 0;
+  private codexImportInProgress = false;
   private lastSlackSync = 0;
   private slackImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
@@ -1200,6 +1203,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 +1288,14 @@ 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.slackImportInProgress) {
       console.log(`[Processor ${this.instanceId}] Clearing slackImportInProgress flag`);
       this.slackImportInProgress = false;
@@ -1522,6 +1541,14 @@ 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?.personaHistory?.integration &&
@@ -1779,6 +1806,60 @@ 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 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,7 @@ 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;
   document?: DocumentSettings;
   active_theme?: string;
   custom_themes?: ThemeDefinition[];

package/src/core/types/llm.ts

@@ -25,7 +25,7 @@ export interface Message {
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
   speaker_name?: string;       // Display name of actual speaker; set on room messages for clean hydration
 
-  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code); invisible to LLM context
+  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code, Codex); invisible to LLM context
 
 }