claude-smart 0.2.25 → 0.2.27

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.25"
+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