claude-smart 0.2.26 → 0.2.27

package/README.md

@@ -13,7 +13,7 @@
     <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License">
   </a>
   <a href="plugin/pyproject.toml">
-    <img src="https://img.shields.io/badge/version-0.2.26-green.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-0.2.27-green.svg" alt="Version">
   </a>
   <a href="plugin/pyproject.toml">
     <img src="https://img.shields.io/badge/python-%3E%3D3.12-brightgreen.svg" alt="Python">

package/bin/claude-smart.js

@@ -12,6 +12,7 @@
 "use strict";
 
 const { execSync, spawn } = require("child_process");
+const crypto = require("crypto");
 const {
   appendFileSync,
   cpSync,
@@ -21,7 +22,8 @@ const {
   rmSync,
   writeFileSync,
 } = require("fs");
-const { homedir } = require("os");
+const https = require("https");
+const { homedir, tmpdir } = require("os");
 const { dirname, join } = require("path");
 
 const DEFAULT_MARKETPLACE_SOURCE = "ReflexioAI/claude-smart";
@@ -52,6 +54,8 @@ const CODEX_REQUIRED_FILES = [
   ".agents/plugins/marketplace.json",
   "plugin/.codex-plugin/plugin.json",
   "plugin/hooks/codex-hooks.json",
+  "plugin/scripts/codex-claude-compat.py",
+  "plugin/scripts/codex-hook.js",
   "plugin/scripts/_codex_env.sh",
 ];
 const CODEX_CLI_TIMEOUT_MS = 30_000;
@@ -175,7 +179,10 @@ function seedReflexioEnv() {
   const existing = existsSync(REFLEXIO_ENV_PATH)
     ? readFileSync(REFLEXIO_ENV_PATH, "utf8")
     : "";
-  const flags = ["CLAUDE_SMART_USE_LOCAL_CLI", "CLAUDE_SMART_USE_LOCAL_EMBEDDING"];
+  const flags = [
+    "CLAUDE_SMART_USE_LOCAL_CLI",
+    "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+  ];
   const missing = flags.filter((f) => !new RegExp(`^${f}=`, "m").test(existing));
   if (missing.length === 0) return [];
   const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
@@ -184,6 +191,246 @@ function seedReflexioEnv() {
   return missing;
 }
 
+function isWindows() {
+  return process.platform === "win32";
+}
+
+function runChecked(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      shell: isWindows() && /\.(?:cmd|bat)$/i.test(command),
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    child.on("exit", (code) => resolve(typeof code === "number" ? code : 1));
+    child.on("error", () => resolve(1));
+  });
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, (response) => {
+      if (
+        response.statusCode &&
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        downloadFile(new URL(response.headers.location, url).toString(), dest)
+          .then(resolve, reject);
+        response.resume();
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`download failed (${response.statusCode}) for ${url}`));
+        return;
+      }
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => {
+        writeFileSync(dest, Buffer.concat(chunks));
+        resolve();
+      });
+    });
+    request.on("error", reject);
+    request.setTimeout(120_000, () => request.destroy(new Error(`download timed out for ${url}`)));
+  });
+}
+
+function resolveCommand(names, extraDirs = []) {
+  const pathParts = [
+    ...extraDirs,
+    ...(process.env.PATH || "").split(process.platform === "win32" ? ";" : ":"),
+  ].filter(Boolean);
+  for (const dir of pathParts) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function privateNodeRoot() {
+  return join(homedir(), ".claude-smart", "node", "current");
+}
+
+function privateNodeBinDirs() {
+  const root = privateNodeRoot();
+  return [join(root, "bin"), root];
+}
+
+function resolvePrivateNode() {
+  return resolveCommand(isWindows() ? ["node.exe", "node"] : ["node"], privateNodeBinDirs());
+}
+
+function resolvePrivateNpm() {
+  return resolveCommand(
+    isWindows() ? ["npm.cmd", "npm.exe", "npm"] : ["npm"],
+    privateNodeBinDirs(),
+  );
+}
+
+function runtimeEnv(extraDirs = []) {
+  const delimiter = process.platform === "win32" ? ";" : ":";
+  const dirs = [
+    ...extraDirs,
+    ...privateNodeBinDirs(),
+    join(homedir(), ".local", "bin"),
+    join(homedir(), ".cargo", "bin"),
+  ];
+  return {
+    ...process.env,
+    PATH: `${dirs.join(delimiter)}${delimiter}${process.env.PATH || ""}`,
+  };
+}
+
+async function ensureWindowsPrivateNode() {
+  if (!isWindows()) return null;
+  const existing = resolvePrivateNode();
+  const existingNpm = resolvePrivateNpm();
+  if (existing && existingNpm) return { node: existing, npm: existingNpm };
+
+  const major = process.env.CLAUDE_SMART_NODE_LTS_MAJOR || "22";
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const baseUrl = process.env.CLAUDE_SMART_NODE_BASE_URL || `https://nodejs.org/dist/latest-v${major}.x`;
+  const nodeRoot = join(homedir(), ".claude-smart", "node");
+  const temp = join(tmpdir(), `claude-smart-node-${process.pid}`);
+  mkdirSync(nodeRoot, { recursive: true });
+  rmSync(temp, { recursive: true, force: true });
+  mkdirSync(temp, { recursive: true });
+
+  const sumsPath = join(temp, "SHASUMS256.txt");
+  await downloadFile(`${baseUrl}/SHASUMS256.txt`, sumsPath);
+  const sums = readFileSync(sumsPath, "utf8");
+  const match = sums
+    .split(/\r?\n/)
+    .map((line) => line.trim().split(/\s+/))
+    .find((parts) => parts[1] && new RegExp(`^node-v[^ ]+-win-${arch}\\.zip$`).test(parts[1]));
+  if (!match) throw new Error(`could not resolve Node.js win-${arch} archive from ${baseUrl}`);
+  const [expectedHash, archiveName] = match;
+  const archivePath = join(temp, archiveName);
+  await downloadFile(`${baseUrl}/${archiveName}`, archivePath);
+  const actualHash = crypto.createHash("sha256").update(readFileSync(archivePath)).digest("hex");
+  if (actualHash !== expectedHash) {
+    throw new Error(`Node.js checksum verification failed for ${archiveName}`);
+  }
+
+  const powershell = resolveCommand(["powershell.exe", "powershell", "pwsh"]);
+  if (!powershell) throw new Error("PowerShell is required to extract private Node.js on Windows");
+  const extractDir = join(temp, "extract");
+  mkdirSync(extractDir, { recursive: true });
+  const code = await runChecked(
+    powershell,
+    [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "$ProgressPreference='SilentlyContinue'; Expand-Archive -LiteralPath $env:ARCHIVE_PATH -DestinationPath $env:DEST_DIR -Force",
+    ],
+    { env: { ...process.env, ARCHIVE_PATH: archivePath, DEST_DIR: extractDir } },
+  );
+  if (code !== 0) throw new Error(`Node.js archive extraction failed for ${archiveName}`);
+  const extracted = join(extractDir, archiveName.replace(/\.zip$/, ""));
+  const current = privateNodeRoot();
+  rmSync(current, { recursive: true, force: true });
+  cpSync(extracted, current, { recursive: true, force: true });
+  rmSync(temp, { recursive: true, force: true });
+
+  const node = resolvePrivateNode();
+  const npm = resolvePrivateNpm();
+  if (!node || !npm) throw new Error("private Node.js install completed but node/npm are not usable");
+  return { node, npm };
+}
+
+function resolveUv() {
+  return resolveCommand(isWindows() ? ["uv.exe", "uv"] : ["uv"], [
+    join(homedir(), ".local", "bin"),
+    join(homedir(), ".cargo", "bin"),
+  ]);
+}
+
+async function ensureWindowsUv() {
+  let uv = resolveUv();
+  if (uv) return uv;
+  const powershell = resolveCommand(["powershell.exe", "powershell", "pwsh"]);
+  if (!powershell) throw new Error("PowerShell is required to install uv on Windows");
+  const code = await runChecked(powershell, [
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    "irm https://astral.sh/uv/install.ps1 | iex",
+  ]);
+  if (code !== 0) throw new Error("uv install via PowerShell failed");
+  uv = resolveUv();
+  if (!uv) throw new Error("uv install reported success but uv.exe was not found");
+  return uv;
+}
+
+function quoteCommandPart(part) {
+  return `"${String(part).replace(/"/g, '\\"')}"`;
+}
+
+function patchCodexHooksForWindows(pluginRoot, nodePath) {
+  const hookPath = join(pluginRoot, "hooks", "codex-hooks.json");
+  const parsed = JSON.parse(readFileSync(hookPath, "utf8"));
+  const runner = join(pluginRoot, "scripts", "codex-hook.js");
+  const command = (...args) => [nodePath, runner, ...args].map(quoteCommandPart).join(" ");
+  const sessionHooks = parsed.hooks.SessionStart?.[0]?.hooks || [];
+  if (sessionHooks[0]) sessionHooks[0].command = command("ensure-root");
+  if (sessionHooks[1]) sessionHooks[1].command = command("backend");
+  if (sessionHooks[2]) sessionHooks[2].command = command("dashboard");
+  if (sessionHooks[3]) sessionHooks[3].command = command("hook", "session-start");
+  const userPrompt = parsed.hooks.UserPromptSubmit?.[0]?.hooks?.[0];
+  if (userPrompt) userPrompt.command = command("hook", "user-prompt");
+  const postTool = parsed.hooks.PostToolUse?.[0]?.hooks?.[0];
+  if (postTool) postTool.command = command("hook", "post-tool");
+  const stop = parsed.hooks.Stop?.[0]?.hooks?.[0];
+  if (stop) stop.command = command("hook", "stop");
+  writeFileSync(hookPath, JSON.stringify(parsed, null, 2) + "\n");
+}
+
+function ensureWindowsPluginRoot(pluginRoot) {
+  const reflexioDir = dirname(REFLEXIO_ENV_PATH);
+  const link = join(reflexioDir, "plugin-root");
+  mkdirSync(reflexioDir, { recursive: true });
+  rmSync(link, { recursive: true, force: true });
+  try {
+    require("fs").symlinkSync(pluginRoot, link, "junction");
+  } catch {
+    writeFileSync(join(reflexioDir, "plugin-root.txt"), `${pluginRoot}\n`);
+  }
+}
+
+async function bootstrapWindowsCodexCache(pluginRoot) {
+  if (!isWindows()) return;
+  process.stdout.write("Preparing Windows Codex runtime for claude-smart hooks...\n");
+  const nodeRuntime = await ensureWindowsPrivateNode();
+  patchCodexHooksForWindows(pluginRoot, nodeRuntime.node);
+  ensureWindowsPluginRoot(pluginRoot);
+  const uv = await ensureWindowsUv();
+  const env = runtimeEnv([dirname(uv), ...privateNodeBinDirs()]);
+  let code = await runChecked(
+    uv,
+    ["sync", "--locked", "--python", "3.12", "--quiet"],
+    { cwd: pluginRoot, env },
+  );
+  if (code !== 0) throw new Error(`uv sync failed in ${pluginRoot}`);
+
+  const dashboardDir = join(pluginRoot, "dashboard");
+  if (existsSync(dashboardDir)) {
+    code = await runChecked(nodeRuntime.npm, ["ci"], { cwd: dashboardDir, env });
+    if (code !== 0) throw new Error(`npm ci failed in ${dashboardDir}`);
+    code = await runChecked(nodeRuntime.npm, ["run", "build"], { cwd: dashboardDir, env });
+    if (code !== 0) throw new Error(`npm run build failed in ${dashboardDir}`);
+  }
+}
+
 function printHelp() {
   process.stdout.write(
     [
@@ -760,6 +1007,7 @@ async function runInstallCodex() {
   try {
     cacheDir = installCodexPluginCache(join(marketplaceRoot, CODEX_MARKETPLACE_PLUGIN_PATH));
     process.stdout.write(`Installed Codex plugin cache at ${cacheDir}.\n`);
+    await bootstrapWindowsCodexCache(cacheDir);
   } catch (err) {
     process.stderr.write(
       `error: automatic Codex plugin install failed: ${err && err.message ? err.message : err}\n`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Self-improving Claude Code plugin — learns from corrections via reflexio",
   "keywords": [
     "claude",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Self-improving Claude Code plugin — learns from corrections across sessions via reflexio",
   "author": {
     "name": "Yi Lu"

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Self-improving coding assistant plugin — learns from corrections across sessions via reflexio",
   "author": {
     "name": "Yi Lu"

package/plugin/hooks/codex-hooks.json

@@ -7,22 +7,22 @@
         "hooks": [
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/ensure-plugin-root.sh\" \"$_R\" || true",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/ensure-plugin-root.sh\" \"$_R\" || true",
             "timeout": 10
           },
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/backend-service.sh\" start",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/backend-service.sh\" start",
             "timeout": 30
           },
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/dashboard-service.sh\" start",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/dashboard-service.sh\" start",
             "timeout": 10
           },
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex session-start",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex session-start",
             "timeout": 30,
             "statusMessage": "Loading claude-smart context"
           }
@@ -34,7 +34,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex user-prompt",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex user-prompt",
             "timeout": 15
           }
         ]
@@ -46,7 +46,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex post-tool",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex post-tool",
             "timeout": 15
           }
         ]
@@ -57,7 +57,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/plugins/claude-smart\" \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex stop",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}\"; [ -z \"$_R\" ] && _R=$(ls -dt \"$HOME/.codex/plugins/cache/reflexioai/claude-smart\"/*/ 2>/dev/null | head -n 1); [ -n \"$_R\" ] && . \"${_R%/}/scripts/_codex_env.sh\" && bash \"$_R/scripts/hook_entry.sh\" codex stop",
             "timeout": 30
           }
         ]

package/plugin/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-smart"
-version = "0.2.26"
+version = "0.2.27"
 description = "Self-improving Claude Code plugin — learns from corrections via reflexio"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -10,6 +10,7 @@ dependencies = [
     # Pulls in onnxruntime + tokenizers; the ~80 MB ONNX model itself is
     # downloaded on first use, not at install time.
     "chromadb>=0.5",
+    "einops>=0.8.0",
 ]
 
 [project.scripts]

package/plugin/scripts/_codex_env.sh

@@ -25,3 +25,4 @@ _R="${_R%/}"
 export _R
 export PLUGIN_ROOT="$_R"
 export CLAUDE_PLUGIN_ROOT="$_R"
+export CLAUDE_SMART_HOST="codex"

package/plugin/scripts/backend-service.sh

@@ -29,25 +29,30 @@ PORT=8071
 # binds to PORT instead of reflexio's library default (8081).
 export BACKEND_PORT="$PORT"
 
-# Default: route extraction through the local claude CLI + ONNX embedder
+# Default: route extraction through the active host CLI + ONNX embedder
 # so claude-smart works without any LLM API key. Users can opt out by
 # pre-exporting these to 0.
 export CLAUDE_SMART_USE_LOCAL_CLI="${CLAUDE_SMART_USE_LOCAL_CLI:-1}"
 export CLAUDE_SMART_USE_LOCAL_EMBEDDING="${CLAUDE_SMART_USE_LOCAL_EMBEDDING:-1}"
-# The backend can be spawned from contexts whose PATH lacks the claude
+# The backend can be spawned from contexts whose PATH lacks the host
 # CLI dir (commonly ~/.local/bin or /opt/homebrew/bin). Pin the CLI
 # explicitly if we can resolve it from our own (post-login-path) PATH.
+PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+
 if [ -z "${CLAUDE_SMART_CLI_PATH:-}" ]; then
-  if _cs_claude_path=$(command -v claude 2>/dev/null) && [ -n "$_cs_claude_path" ]; then
-    export CLAUDE_SMART_CLI_PATH="$_cs_claude_path"
+  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
+    # Reflexio's provider still calls CLAUDE_SMART_CLI_PATH with Claude CLI
+    # flags. Use a small compatibility executable that translates that narrow
+    # contract to `codex exec`.
+    export CLAUDE_SMART_CLI_PATH="$PLUGIN_ROOT/scripts/codex-claude-compat.py"
+  elif _cs_cli_path=$(command -v claude 2>/dev/null) && [ -n "$_cs_cli_path" ]; then
+    export CLAUDE_SMART_CLI_PATH="$_cs_cli_path"
   elif [ -x "$HOME/.local/bin/claude" ]; then
     export CLAUDE_SMART_CLI_PATH="$HOME/.local/bin/claude"
   fi
-  unset _cs_claude_path
+  unset _cs_cli_path
 fi
 
-PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
-
 STATE_DIR="$HOME/.claude-smart"
 PID_FILE="$STATE_DIR/backend.pid"
 LOG_FILE="$STATE_DIR/backend.log"

package/plugin/scripts/codex-claude-compat.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Translate Reflexio's Claude CLI provider contract to ``codex exec``.
+
+Reflexio's local provider currently shells out to ``CLAUDE_SMART_CLI_PATH`` as
+if it were the Claude Code CLI:
+
+    <path> -p --output-format json --model <model> [--append-system-prompt ...]
+
+When claude-smart runs under Codex, this executable preserves that narrow
+contract while routing the actual model call through ``codex exec``. The
+stdout shape intentionally matches Claude Code's JSON output enough for
+Reflexio's provider to read ``result``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+_TIMEOUT_SECONDS = 120
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    try:
+        output_format, system_prompt = _parse_supported_args(argv)
+        content = _run_codex(
+            prompt=sys.stdin.read(),
+            system_prompt=system_prompt,
+        )
+    except Exception as exc:  # noqa: BLE001 - CLI bridge errors go to stderr.
+        print(f"codex-claude-compat: {exc}", file=sys.stderr)
+        return 1
+
+    payload = {"result": content}
+    if output_format == "stream-json":
+        payload = {"type": "result", "subtype": "success", "result": content}
+    json.dump(payload, sys.stdout, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+def _parse_supported_args(argv: list[str]) -> tuple[str, str]:
+    output_format = "json"
+    system_prompt = ""
+    idx = 0
+    while idx < len(argv):
+        arg = argv[idx]
+        if arg == "-p":
+            idx += 1
+        elif arg == "--output-format":
+            if idx + 1 >= len(argv):
+                raise ValueError("--output-format requires a value")
+            output_format = argv[idx + 1]
+            idx += 2
+        elif arg == "--model":
+            idx += 2
+        elif arg in {"--verbose", "--include-partial-messages"}:
+            idx += 1
+        elif arg == "--append-system-prompt":
+            if idx + 1 >= len(argv):
+                raise ValueError("--append-system-prompt requires a value")
+            system_prompt = argv[idx + 1]
+            idx += 2
+        else:
+            raise ValueError(f"unsupported Claude CLI argument: {arg}")
+    if output_format not in {"json", "stream-json"}:
+        raise ValueError(f"unsupported --output-format: {output_format}")
+    return output_format, system_prompt
+
+
+def _run_codex(*, prompt: str, system_prompt: str) -> str:
+    codex_path = os.environ.get("CLAUDE_SMART_CODEX_PATH") or shutil.which("codex")
+    if not codex_path:
+        raise FileNotFoundError("codex CLI not found on PATH")
+
+    output_path = _temporary_output_path()
+    cmd = [
+        codex_path,
+        "exec",
+        "--sandbox",
+        "read-only",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--ignore-rules",
+        "--output-last-message",
+        str(output_path),
+        "-",
+    ]
+
+    env = os.environ.copy()
+    env["CLAUDE_SMART_HOST"] = "codex"
+    env["CLAUDE_SMART_INTERNAL"] = "1"
+    env["CLAUDE_CODE_ENTRYPOINT"] = "optimizer"
+
+    try:
+        proc = subprocess.run(  # noqa: S603 - fixed command plus resolved executable.
+            cmd,
+            input=_codex_prompt(prompt=prompt, system_prompt=system_prompt),
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SECONDS,
+            check=False,
+            env=env,
+        )
+        if proc.returncode != 0:
+            stderr = proc.stderr.strip()
+            raise RuntimeError(f"codex CLI exited {proc.returncode}: {stderr[:500]}")
+        content = output_path.read_text(encoding="utf-8").strip()
+    except subprocess.TimeoutExpired as exc:
+        raise TimeoutError(f"codex CLI timed out after {_TIMEOUT_SECONDS}s") from exc
+    finally:
+        try:
+            output_path.unlink()
+        except OSError:
+            pass
+
+    if not content:
+        raise RuntimeError("codex CLI returned empty output")
+    return content
+
+
+def _temporary_output_path() -> Path:
+    handle = tempfile.NamedTemporaryFile(prefix="claude-smart-codex-", delete=False)
+    try:
+        return Path(handle.name)
+    finally:
+        handle.close()
+
+
+def _codex_prompt(*, prompt: str, system_prompt: str) -> str:
+    if not system_prompt:
+        return prompt
+    return f"{system_prompt}\n\n## Task\n{prompt}"
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugin/scripts/codex-hook.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn, spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
+
+const HOME = os.homedir();
+const STATE_DIR = path.join(HOME, ".claude-smart");
+const REFLEXIO_DIR = path.join(HOME, ".reflexio");
+const DEFAULT_BACKEND_PORT = 8071;
+const FALLBACK_BACKEND_PORT = 8072;
+const DASHBOARD_PORT = 3001;
+
+function emitOk() {
+  process.stdout.write('{"continue":true,"suppressOutput":true}\n');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function appendLog(name, line) {
+  ensureDir(STATE_DIR);
+  fs.appendFileSync(path.join(STATE_DIR, name), `${line}\n`);
+}
+
+function pluginRoot() {
+  for (const value of [process.env.CLAUDE_PLUGIN_ROOT, process.env.PLUGIN_ROOT]) {
+    if (value && fs.existsSync(path.join(value, "pyproject.toml"))) {
+      return path.resolve(value);
+    }
+  }
+  const fromScript = path.resolve(__dirname, "..");
+  if (fs.existsSync(path.join(fromScript, "pyproject.toml"))) return fromScript;
+  const cacheRoot = path.join(HOME, ".codex", "plugins", "cache", "reflexioai", "claude-smart");
+  try {
+    const versions = fs
+      .readdirSync(cacheRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => path.join(cacheRoot, entry.name))
+      .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    for (const candidate of versions) {
+      if (fs.existsSync(path.join(candidate, "pyproject.toml"))) return candidate;
+    }
+  } catch {
+    // Fall through to the stable plugin-root link.
+  }
+  return path.join(REFLEXIO_DIR, "plugin-root");
+}
+
+function prependRuntimePath() {
+  const privateNode = path.join(STATE_DIR, "node", "current");
+  const parts = [
+    path.join(privateNode, "bin"),
+    privateNode,
+    path.join(HOME, ".local", "bin"),
+    path.join(HOME, ".cargo", "bin"),
+  ];
+  process.env.PATH = `${parts.join(path.delimiter)}${path.delimiter}${process.env.PATH || ""}`;
+}
+
+function commandPath(names) {
+  const pathParts = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  for (const dir of pathParts) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function uvPath() {
+  return commandPath(process.platform === "win32" ? ["uv.exe", "uv"] : ["uv"]);
+}
+
+function npmPath() {
+  return commandPath(process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"]);
+}
+
+function stateFile(name) {
+  return path.join(STATE_DIR, name);
+}
+
+function backendUrlFile() {
+  return stateFile("backend-url");
+}
+
+function writeBackendUrl(port) {
+  ensureDir(STATE_DIR);
+  fs.writeFileSync(backendUrlFile(), `http://localhost:${port}/\n`);
+}
+
+function codexCompatPath(root) {
+  return path.join(root, "scripts", "codex-claude-compat.py");
+}
+
+function readBackendUrl() {
+  if (process.env.REFLEXIO_URL) return process.env.REFLEXIO_URL;
+  try {
+    const value = fs.readFileSync(backendUrlFile(), "utf8").trim();
+    if (value) return value;
+  } catch {
+    // Fall through to default.
+  }
+  return `http://localhost:${DEFAULT_BACKEND_PORT}/`;
+}
+
+function healthOk(port, pathname, markerHeader) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        path: pathname,
+        method: "GET",
+        timeout: 1200,
+      },
+      (res) => {
+        const ok = res.statusCode && res.statusCode >= 200 && res.statusCode < 400;
+        const markerOk = markerHeader ? Boolean(res.headers[markerHeader]) : true;
+        res.resume();
+        resolve(Boolean(ok && markerOk));
+      },
+    );
+    req.on("timeout", () => req.destroy());
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+
+function portOccupied(port) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        path: "/",
+        method: "GET",
+        timeout: 900,
+      },
+      (res) => {
+        res.resume();
+        resolve(true);
+      },
+    );
+    req.on("timeout", () => req.destroy());
+    req.on("error", (err) => {
+      resolve(err && err.code !== "ECONNREFUSED");
+    });
+    req.end();
+  });
+}
+
+async function waitForHealth(port, pathname, markerHeader, attempts) {
+  for (let i = 0; i < attempts; i += 1) {
+    if (await healthOk(port, pathname, markerHeader)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  return false;
+}
+
+function detached(command, args, options = {}) {
+  const child = spawn(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    detached: true,
+    shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(command),
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  child.unref();
+  return child.pid;
+}
+
+function readPid(file) {
+  try {
+    const value = fs.readFileSync(file, "utf8").trim();
+    return value ? Number(value) : null;
+  } catch {
+    return null;
+  }
+}
+
+function pidAlive(pid) {
+  if (!pid || Number.isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function writePid(file, pid) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, `${pid}\n`);
+}
+
+function ensurePluginRoot(root) {
+  ensureDir(REFLEXIO_DIR);
+  const link = path.join(REFLEXIO_DIR, "plugin-root");
+  try {
+    fs.rmSync(link, { recursive: true, force: true });
+  } catch {
+    // Ignore and try to recreate below.
+  }
+  try {
+    fs.symlinkSync(root, link, process.platform === "win32" ? "junction" : "dir");
+  } catch {
+    fs.writeFileSync(path.join(REFLEXIO_DIR, "plugin-root.txt"), `${root}\n`);
+  }
+}
+
+async function startBackend(root) {
+  if (process.env.CLAUDE_SMART_BACKEND_AUTOSTART === "0") {
+    emitOk();
+    return;
+  }
+  const pidFile = path.join(STATE_DIR, "backend.pid");
+  for (const port of [DEFAULT_BACKEND_PORT, FALLBACK_BACKEND_PORT]) {
+    if (pidAlive(readPid(pidFile)) && await healthOk(port, "/health")) {
+      writeBackendUrl(port);
+      emitOk();
+      return;
+    }
+    if (await healthOk(port, "/health")) {
+      writeBackendUrl(port);
+      emitOk();
+      return;
+    }
+  }
+  const uv = uvPath();
+  if (!uv) {
+    appendLog("backend.log", "[claude-smart] backend: uv not on PATH; skipping");
+    emitOk();
+    return;
+  }
+  let selectedPort = DEFAULT_BACKEND_PORT;
+  if (await portOccupied(DEFAULT_BACKEND_PORT)) {
+    appendLog("backend.log", "[claude-smart] backend: port 8071 occupied; trying 8072");
+    selectedPort = FALLBACK_BACKEND_PORT;
+  }
+  const backendUrl = `http://localhost:${selectedPort}/`;
+  const env = {
+    ...process.env,
+    BACKEND_PORT: String(selectedPort),
+    REFLEXIO_URL: backendUrl,
+    CLAUDE_SMART_USE_LOCAL_CLI: process.env.CLAUDE_SMART_USE_LOCAL_CLI || "1",
+    CLAUDE_SMART_USE_LOCAL_EMBEDDING: process.env.CLAUDE_SMART_USE_LOCAL_EMBEDDING || "1",
+    CLAUDE_SMART_HOST: "codex",
+    CLAUDE_SMART_CLI_PATH: process.env.CLAUDE_SMART_CLI_PATH || codexCompatPath(root),
+    INTERACTION_CLEANUP_THRESHOLD: process.env.INTERACTION_CLEANUP_THRESHOLD || "500",
+    INTERACTION_CLEANUP_DELETE_COUNT: process.env.INTERACTION_CLEANUP_DELETE_COUNT || "200",
+  };
+  const pid = detached(
+    uv,
+    [
+      "run",
+      "--project",
+      root,
+      "--quiet",
+      "reflexio",
+      "services",
+      "start",
+      "--only",
+      "backend",
+      "--no-reload",
+    ],
+    { cwd: root, env },
+  );
+  writePid(pidFile, pid);
+  if (await waitForHealth(selectedPort, "/health", null, 10)) {
+    writeBackendUrl(selectedPort);
+  }
+  emitOk();
+}
+
+async function startDashboard(root) {
+  if (process.env.CLAUDE_SMART_DASHBOARD_AUTOSTART === "0") {
+    emitOk();
+    return;
+  }
+  const dashboard = path.join(root, "dashboard");
+  if (!fs.existsSync(dashboard)) {
+    emitOk();
+    return;
+  }
+  const pidFile = path.join(STATE_DIR, "dashboard.pid");
+  if (
+    pidAlive(readPid(pidFile)) &&
+    await healthOk(DASHBOARD_PORT, "/api/health", "x-claude-smart-dashboard")
+  ) {
+    emitOk();
+    return;
+  }
+  const npm = npmPath();
+  if (!npm) {
+    appendLog("dashboard.log", "[claude-smart] dashboard: npm not on PATH; skipping");
+    emitOk();
+    return;
+  }
+  if (!fs.existsSync(path.join(dashboard, ".next"))) {
+    const buildPidFile = path.join(STATE_DIR, "dashboard-build.pid");
+    if (!pidAlive(readPid(buildPidFile))) {
+      const pid = detached(npm, ["run", "build"], { cwd: dashboard });
+      writePid(buildPidFile, pid);
+      appendLog("dashboard.log", "[claude-smart] dashboard: .next missing; started background build");
+    }
+    emitOk();
+    return;
+  }
+  const env = {
+    ...process.env,
+    PORT: String(DASHBOARD_PORT),
+    REFLEXIO_URL: readBackendUrl(),
+    CLAUDE_SMART_DASHBOARD_WORKSPACE: process.cwd(),
+  };
+  const pid = detached(npm, ["run", "start"], { cwd: dashboard, env });
+  writePid(pidFile, pid);
+  await waitForHealth(DASHBOARD_PORT, "/api/health", "x-claude-smart-dashboard", 5);
+  emitOk();
+}
+
+function runHook(root, event) {
+  const uv = uvPath();
+  if (!uv) {
+    appendLog("backend.log", "[claude-smart] hook: uv not on PATH; skipping");
+    emitOk();
+    return 0;
+  }
+  const input = fs.readFileSync(0);
+  const result = spawnSync(
+    uv,
+    ["run", "--project", root, "--quiet", "python", "-m", "claude_smart.hook", "codex", event],
+    {
+      cwd: root,
+      env: {
+        ...process.env,
+        REFLEXIO_URL: readBackendUrl(),
+        CLAUDE_SMART_HOST: "codex",
+        CLAUDE_SMART_CLI_PATH: process.env.CLAUDE_SMART_CLI_PATH || codexCompatPath(root),
+      },
+      input,
+      stdio: ["pipe", "inherit", "inherit"],
+      windowsHide: true,
+    },
+  );
+  return typeof result.status === "number" ? result.status : 1;
+}
+
+async function main() {
+  prependRuntimePath();
+  const root = pluginRoot();
+  process.env.PLUGIN_ROOT = root;
+  process.env.CLAUDE_PLUGIN_ROOT = root;
+  const action = process.argv[2] || "hook";
+  if (action === "ensure-root") {
+    ensurePluginRoot(root);
+    emitOk();
+    return 0;
+  }
+  if (action === "backend") {
+    await startBackend(root);
+    return 0;
+  }
+  if (action === "dashboard") {
+    await startDashboard(root);
+    return 0;
+  }
+  if (action === "hook") {
+    return runHook(root, process.argv[3] || "session-start");
+  }
+  emitOk();
+  return 0;
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    appendLog("backend.log", `[claude-smart] codex hook failed: ${err && err.stack ? err.stack : err}`);
+    emitOk();
+  });

package/plugin/scripts/ensure-plugin-root.sh

@@ -51,7 +51,8 @@ if [ "$FOLLOW" = "1" ]; then
 fi
 
 # Cache-tracking: if the link currently resolves to a path under the
-# managed plugin cache (~/.claude/plugins/cache/), always retarget it to
+# managed plugin cache (~/.claude/plugins/cache/ or ~/.codex/plugins/cache/),
+# always retarget it to
 # $TARGET. Plugin updates leave old version directories behind, so a
 # valid pyproject.toml at the stale target is not proof the link is
 # fresh. Links pointing outside the cache (e.g., a user's local-dev
@@ -60,7 +61,7 @@ if [ -L "$LINK" ]; then
     # Literal target string, not realpath: we compare against what was written by ln -s.
     CURRENT="$(readlink "$LINK" 2>/dev/null || true)"
     case "$CURRENT" in
-        "$HOME/.claude/plugins/cache/"*)
+        "$HOME/.claude/plugins/cache/"*|"$HOME/.codex/plugins/cache/"*)
             CURRENT_NORM="${CURRENT%/}"
             TARGET_NORM="${TARGET%/}"
             if [ "$CURRENT_NORM" != "$TARGET_NORM" ]; then

package/plugin/scripts/smart-install.sh

@@ -311,7 +311,6 @@ if ! grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
   printf '# Use the in-process ONNX embedder (chromadb) — no API key for semantic search\nCLAUDE_SMART_USE_LOCAL_EMBEDDING=1\n' >> "$REFLEXIO_ENV"
   echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
 fi
-
 # Migrate stale REFLEXIO_URL from reflexio's library default (8081) to the
 # plugin backend port (8071). Matches the quoted and unquoted forms but
 # requires paired quotes, so malformed or deliberately different values

package/plugin/src/claude_smart/cli.py

@@ -76,6 +76,8 @@ _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
     Path("plugin/.codex-plugin/plugin.json"),
     Path("plugin/hooks/codex-hooks.json"),
+    Path("plugin/scripts/codex-claude-compat.py"),
+    Path("plugin/scripts/codex-hook.js"),
     Path("plugin/scripts/_codex_env.sh"),
 )
 _COPYTREE_IGNORE = shutil.ignore_patterns(
@@ -110,7 +112,10 @@ def _seed_reflexio_env() -> list[str]:
     _REFLEXIO_ENV_PATH.parent.mkdir(parents=True, exist_ok=True)
     _REFLEXIO_ENV_PATH.touch(exist_ok=True)
     existing = _REFLEXIO_ENV_PATH.read_text()
-    flags = ("CLAUDE_SMART_USE_LOCAL_CLI", "CLAUDE_SMART_USE_LOCAL_EMBEDDING")
+    flags = (
+        "CLAUDE_SMART_USE_LOCAL_CLI",
+        "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+    )
     missing = [f for f in flags if f"{f}=" not in existing]
     if not missing:
         return []

package/plugin/src/claude_smart/events/stop.py

@@ -8,7 +8,7 @@ import time
 from pathlib import Path
 from typing import Any
 
-from claude_smart import cs_cite, ids, publish, runtime, state
+from claude_smart import cs_cite, ids, internal_call, publish, runtime, state
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -112,6 +112,16 @@ def _scan_transcript_for_assistant_text(entries: list[dict[str, Any]]) -> str:
     return "\n\n".join(parts)
 
 
+def _scan_transcript_for_user_text(entries: list[dict[str, Any]]) -> str:
+    """Return the user text that opened the current transcript turn."""
+    for entry in reversed(entries):
+        if not _is_user_turn_boundary(entry):
+            continue
+        message = entry.get("message") or {}
+        return "\n\n".join(_extract_text_blocks(message.get("content")))
+    return ""
+
+
 def _is_user_turn_boundary(entry: dict[str, Any]) -> bool:
     """True if ``entry`` is the user message that opened the current turn.
 
@@ -350,6 +360,11 @@ def handle(payload: dict[str, Any]) -> None:
         if path.is_file():
             entries = _load_transcript_with_retry(path)
 
+    if runtime.is_codex():
+        prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
+        if internal_call.is_codex_internal_prompt(prompt):
+            return
+
     last_assistant_message = payload.get("last_assistant_message")
     assistant_text = (
         last_assistant_message

package/plugin/src/claude_smart/internal_call.py

@@ -29,6 +29,9 @@ Detection signals, OR'd:
   - ``payload.cwd`` resolves inside the reflexio submodule. Catches
     direct interactive ``claude`` runs from inside reflexio (manual
     debugging) that would otherwise pollute the corpus.
+  - Known Codex-internal prompt templates (title generation and home-screen
+    suggestions). These are model calls made by Codex itself, not user
+    coding turns, and must never be reflected into claude-smart memory.
 """
 
 from __future__ import annotations
@@ -41,6 +44,19 @@ from claude_smart import runtime
 
 _ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
 _INTERACTIVE_ENTRYPOINT = "cli"
+_CODEX_TITLE_PROMPT_PREFIX = (
+    "You are a helpful assistant. You will be presented with a user prompt, "
+    "and your job is to provide a short title for a task"
+)
+_CODEX_SUGGESTIONS_PROMPT_PREFIX = "# Overview\n\nGenerate 0 to 3 "
+_CODEX_SUGGESTIONS_PROMPT_MARKER = (
+    "hyperpersonalized suggestions for what this user can do with Codex "
+    "in this local project:"
+)
+_CODEX_SUGGESTIONS_APPS_MARKER = (
+    "Get an understanding of the user's intent and goals by deeply viewing "
+    "their connected apps."
+)
 
 # Reflexio submodule lives at <repo>/reflexio when this package runs from
 # a dev checkout (<repo>/plugin/src/claude_smart/internal_call.py); anchor
@@ -75,6 +91,8 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     entrypoint = os.environ.get(_ENTRYPOINT_VAR)
     if entrypoint and entrypoint != _INTERACTIVE_ENTRYPOINT:
         return True
+    if runtime.is_codex() and is_codex_internal_prompt(payload.get("prompt")):
+        return True
     cwd = payload.get("cwd")
     if not isinstance(cwd, str) or not cwd:
         return False
@@ -87,3 +105,15 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     except ValueError:
         return False
     return True
+
+
+def is_codex_internal_prompt(prompt: Any) -> bool:
+    """True for Codex's own UI/task prompts, not user-authored turns."""
+    if not isinstance(prompt, str):
+        return False
+    text = prompt.strip()
+    return text.startswith(_CODEX_TITLE_PROMPT_PREFIX) or (
+        text.startswith(_CODEX_SUGGESTIONS_PROMPT_PREFIX)
+        and _CODEX_SUGGESTIONS_PROMPT_MARKER in text
+        and _CODEX_SUGGESTIONS_APPS_MARKER in text
+    )

package/plugin/src/claude_smart/optimizer_assistant.py

@@ -2,22 +2,24 @@
 
 Reflexio's ``LocalScriptAssistant`` sends one JSON payload on stdin and expects
 one JSON object on stdout. This module bridges that protocol to a guarded
-``claude -p`` subprocess so candidate playbooks can be evaluated against Claude
-Code without re-entering claude-smart/reflexio hooks.
+local CLI subprocess so candidate playbooks can be evaluated against the active
+host without re-entering claude-smart/reflexio hooks.
 """
 
 from __future__ import annotations
 
 import json
 import os
+from pathlib import Path
 import shutil
 import subprocess
 import sys
+import tempfile
 from typing import Any
 
 from claude_smart import internal_call, runtime
 
-_CLAUDE_TIMEOUT_SECONDS = 300
+_CLI_TIMEOUT_SECONDS = 300
 _READ_ONLY_TOOLS = "Read,Grep,Glob,LS"
 _MUTATING_TOOLS = "Bash,Edit,Write,MultiEdit,NotebookEdit"
 
@@ -33,7 +35,7 @@ def main() -> int:
         messages = _validated_list(payload, "messages")
         playbooks = _validated_list(payload, "playbooks")
         prompt, system_prompt = _build_prompt(messages, playbooks)
-        content = _run_claude(prompt=prompt, system_prompt=system_prompt)
+        content = _run_local_cli(prompt=prompt, system_prompt=system_prompt)
     except Exception as exc:  # noqa: BLE001 - script errors become LocalScript failures.
         sys.stderr.write(f"{type(exc).__name__}: {exc}\n")
         return 1
@@ -134,6 +136,12 @@ def _render_transcript(messages: list[dict[str, str]]) -> str:
     )
 
 
+def _run_local_cli(*, prompt: str, system_prompt: str) -> str:
+    if runtime.is_codex():
+        return _run_codex(prompt=prompt, system_prompt=system_prompt)
+    return _run_claude(prompt=prompt, system_prompt=system_prompt)
+
+
 def _run_claude(*, prompt: str, system_prompt: str) -> str:
     cli_path = shutil.which("claude") or "claude"
     # This is an evaluation rollout, not a real user session: allow local
@@ -167,13 +175,13 @@ def _run_claude(*, prompt: str, system_prompt: str) -> str:
             input=prompt,
             capture_output=True,
             text=True,
-            timeout=_CLAUDE_TIMEOUT_SECONDS,
+            timeout=_CLI_TIMEOUT_SECONDS,
             check=False,
             env=env,
         )
     except subprocess.TimeoutExpired as exc:
         raise OptimizerAssistantError(
-            f"claude CLI timed out after {_CLAUDE_TIMEOUT_SECONDS}s"
+            f"claude CLI timed out after {_CLI_TIMEOUT_SECONDS}s"
         ) from exc
     except FileNotFoundError as exc:
         raise OptimizerAssistantError("claude CLI not found on PATH") from exc
@@ -199,5 +207,77 @@ def _run_claude(*, prompt: str, system_prompt: str) -> str:
     return content
 
 
+def _run_codex(*, prompt: str, system_prompt: str) -> str:
+    cli_path = shutil.which("codex") or "codex"
+    output_path = _temporary_output_path()
+    cmd = [
+        cli_path,
+        "exec",
+        "--sandbox",
+        "read-only",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--ignore-rules",
+        "--output-last-message",
+        str(output_path),
+        "-",
+    ]
+
+    env = os.environ.copy()
+    env[runtime.HOST_ENV] = runtime.HOST_CODEX
+    env[runtime.INTERNAL_ENV] = "1"
+    env[internal_call._ENTRYPOINT_VAR] = "optimizer"  # noqa: SLF001
+
+    try:
+        proc = subprocess.run(  # noqa: S603 - command is fixed plus resolved executable.
+            cmd,
+            input=_codex_prompt(prompt=prompt, system_prompt=system_prompt),
+            capture_output=True,
+            text=True,
+            timeout=_CLI_TIMEOUT_SECONDS,
+            check=False,
+            env=env,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise OptimizerAssistantError(
+            f"codex CLI timed out after {_CLI_TIMEOUT_SECONDS}s"
+        ) from exc
+    except FileNotFoundError as exc:
+        raise OptimizerAssistantError("codex CLI not found on PATH") from exc
+
+    try:
+        content = output_path.read_text(encoding="utf-8").strip()
+    except OSError as exc:
+        raise OptimizerAssistantError("codex CLI did not write output") from exc
+    finally:
+        try:
+            output_path.unlink()
+        except OSError:
+            pass
+
+    if proc.returncode != 0:
+        stderr = proc.stderr.strip()
+        raise OptimizerAssistantError(
+            f"codex CLI exited {proc.returncode}: {stderr[:500]}"
+        )
+    if not content:
+        raise OptimizerAssistantError("codex CLI returned empty output")
+    return content
+
+
+def _temporary_output_path() -> Path:
+    handle = tempfile.NamedTemporaryFile(prefix="claude-smart-codex-", delete=False)
+    try:
+        return Path(handle.name)
+    finally:
+        handle.close()
+
+
+def _codex_prompt(*, prompt: str, system_prompt: str) -> str:
+    if not system_prompt:
+        return prompt
+    return f"{system_prompt}\n\n## Task\n{prompt}"
+
+
 if __name__ == "__main__":
     raise SystemExit(main())

package/plugin/uv.lock

@@ -419,10 +419,11 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.26"
+version = "0.2.27"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },
+    { name = "einops" },
     { name = "reflexio-ai" },
 ]
 
@@ -434,6 +435,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "chromadb", specifier = ">=0.5" },
+    { name = "einops", specifier = ">=0.8.0" },
     { name = "reflexio-ai", specifier = ">=0.2.22" },
 ]
 
@@ -616,6 +618,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/79/119091c98e2bf49e24ed9f3ae69f816d715d2904aefa6a2baa039a2ba0b0/ecdsa-0.19.2-py2.py3-none-any.whl", hash = "sha256:840f5dc5e375c68f36c1a7a5b9caad28f95daa65185c9253c0c08dd952bb7399", size = 150818, upload-time = "2026-03-26T09:58:15.808Z" },
 ]
 
+[[package]]
+name = "einops"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" },
+]
+
 [[package]]
 name = "email-validator"
 version = "2.3.0"