claude-smart 0.2.26 → 0.2.28

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.28-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.28",
   "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.28",
   "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.28",
   "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.28"
 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,29 @@ 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
+    # Prefer the compatibility executable for older provider entrypoints; the
+    # provider can also resolve `codex` directly when this override is absent.
+    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"
@@ -55,6 +59,37 @@ mkdir -p "$STATE_DIR"
 
 emit_ok() { echo '{"continue":true,"suppressOutput":true}'; }
 
+emit_start_failure() {
+  reason="$1"
+  if py=$(claude_smart_resolve_python 2>/dev/null); then
+    "$py" - "$reason" <<'PY'
+import json
+import sys
+
+reason = sys.argv[1].strip()
+message = (
+    "> **claude-smart learning backend is not running.** "
+    "Interactions are being buffered locally, but learning will not publish "
+    "until the backend starts.\n"
+)
+if reason:
+    message += f">\n> Last startup error: `{reason}`\n"
+message += (
+    ">\n> Make sure the local model provider is available: Claude Code needs "
+    "`claude`, Codex needs `codex`. Then run `/claude-smart:restart`."
+)
+print(json.dumps({
+    "hookSpecificOutput": {
+        "hookEventName": "SessionStart",
+        "additionalContext": message,
+    }
+}))
+PY
+  else
+    emit_ok
+  fi
+}
+
 # Tree-kill the recorded process. Delegates to claude_smart_kill_tree
 # (POSIX: signal the process group; Windows: taskkill /T /F /PID).
 kill_group() {
@@ -184,6 +219,14 @@ case "$CMD" in
       backend_healthy && break
       sleep 1
     done
+    if ! backend_healthy; then
+      pid=$(cat "$PID_FILE" 2>/dev/null || echo "")
+      if [ -n "$pid" ] && ! kill -0 "$pid" 2>/dev/null; then
+        reason=$(tail -n 120 "$LOG_FILE" 2>/dev/null | grep -E "No LLM provider available|No generation-capable LLM provider available|CLI not found|skipping provider registration|Application startup failed" | tail -n 1 | sed 's/^[[:space:]]*//')
+        emit_start_failure "$reason"
+        exit 0
+      fi
+    fi
     emit_ok
     ;;
   stop)

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())