claude-smart 0.2.28 → 0.2.29

package/plugin/hooks/hooks.json

@@ -14,6 +14,16 @@
       }
     ],
     "SessionStart": [
+      {
+        "matcher": "startup|clear|compact|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "_R=\"${CLAUDE_PLUGIN_ROOT}\"; [ -z \"$_R\" ] && _R=\"$HOME/.claude/plugins/marketplaces/reflexioai/plugin\"; bash \"$_R/scripts/smart-install.sh\"",
+            "timeout": 300
+          }
+        ]
+      },
       {
         "matcher": "startup|clear|compact|resume",
         "hooks": [

package/plugin/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-smart"
-version = "0.2.28"
+version = "0.2.29"
 description = "Self-improving Claude Code plugin — learns from corrections via reflexio"
 readme = "README.md"
 requires-python = ">=3.12"

package/plugin/scripts/_lib.sh

@@ -233,6 +233,44 @@ claude_smart_npm_available() {
   "$npm_bin" --version >/dev/null 2>&1
 }
 
+claude_smart_log_max_bytes() {
+  printf '%s\n' "10000000"
+}
+
+claude_smart_trim_log_file() {
+  local file max_bytes size tmp
+  file="$1"
+  max_bytes="${2:-$(claude_smart_log_max_bytes)}"
+  case "$max_bytes" in
+    ''|*[!0-9]*) return 0 ;;
+  esac
+  [ -f "$file" ] || return 0
+  size=$(wc -c < "$file" 2>/dev/null | tr -d '[:space:]') || return 0
+  case "$size" in
+    ''|*[!0-9]*) return 0 ;;
+  esac
+  [ "$size" -le "$max_bytes" ] && return 0
+
+  tmp="${file}.trim.$$"
+  if tail -c "$max_bytes" "$file" > "$tmp" 2>/dev/null; then
+    # Rewrite the existing path instead of replacing it, so a process with
+    # this file already open in append mode keeps writing to the capped file.
+    cat "$tmp" > "$file"
+  fi
+  rm -f "$tmp"
+}
+
+claude_smart_append_capped_log() {
+  local file max_bytes
+  file="$1"
+  max_bytes="${2:-$(claude_smart_log_max_bytes)}"
+  shift 2
+  mkdir -p "$(dirname "$file")"
+  claude_smart_trim_log_file "$file" "$max_bytes"
+  printf '%s\n' "$*" >> "$file"
+  claude_smart_trim_log_file "$file" "$max_bytes"
+}
+
 # Spawn a command fully detached from the current shell so a hook timeout
 # (Claude Code's install/SessionStart budget) cannot kill it mid-flight.
 # POSIX: setsid → python3 os.setsid → nohup (in that order of strength).

package/plugin/scripts/backend-log-runner.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Run the backend command and stream its stdout/stderr into a capped log file.
+set -eu
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=_lib.sh
+. "$HERE/_lib.sh"
+
+if [ "$#" -lt 4 ] || [ "$3" != "--" ]; then
+  exit 2
+fi
+
+LOG_FILE="$1"
+MAX_BYTES="$2"
+shift 3
+
+mkdir -p "$(dirname "$LOG_FILE")"
+claude_smart_trim_log_file "$LOG_FILE" "$MAX_BYTES"
+
+STATUS_FILE="${TMPDIR:-/tmp}/claude-smart-backend-log-runner.$$.status"
+rm -f "$STATUS_FILE"
+
+(
+  set +e
+  "$@" 2>&1
+  printf '%s\n' "$?" > "$STATUS_FILE"
+) | while IFS= read -r line || [ -n "$line" ]; do
+  claude_smart_append_capped_log "$LOG_FILE" "$MAX_BYTES" "$line"
+done
+
+status=$(cat "$STATUS_FILE" 2>/dev/null || printf '1')
+rm -f "$STATUS_FILE"
+exit "$status"

package/plugin/scripts/backend-service.sh

@@ -41,9 +41,11 @@ PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 
 if [ -z "${CLAUDE_SMART_CLI_PATH:-}" ]; then
   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"
+    # 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`.
+    claude_smart_prepend_node_bins
+    export CLAUDE_SMART_CLI_PATH="$PLUGIN_ROOT/scripts/codex-claude-compat"
   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
@@ -55,7 +57,9 @@ fi
 STATE_DIR="$HOME/.claude-smart"
 PID_FILE="$STATE_DIR/backend.pid"
 LOG_FILE="$STATE_DIR/backend.log"
+LOG_MAX_BYTES="$(claude_smart_log_max_bytes)"
 mkdir -p "$STATE_DIR"
+claude_smart_trim_log_file "$LOG_FILE" "$LOG_MAX_BYTES"
 
 emit_ok() { echo '{"continue":true,"suppressOutput":true}'; }
 
@@ -178,11 +182,11 @@ case "$CMD" in
     if port_occupied; then
       # Something answered the TCP probe but /health didn't — don't
       # start a second uvicorn on top of it.
-      echo "[claude-smart] backend: port $PORT held by another process; skipping" >>"$LOG_FILE"
+      claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: port $PORT held by another process; skipping"
       emit_ok; exit 0
     fi
     if ! command -v uv >/dev/null 2>&1; then
-      echo "[claude-smart] backend: uv not on PATH; skipping" >>"$LOG_FILE"
+      claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: uv not on PATH; skipping"
       emit_ok; exit 0
     fi
     cd "$PLUGIN_ROOT"
@@ -198,12 +202,12 @@ case "$CMD" in
     # bookkeeping harder and we don't need hot-reload for a user-facing
     # service. Detach via claude_smart_spawn_detached so the same code
     # path covers Linux (setsid), macOS (python3 os.setsid), and Windows
-    # (nohup; no process groups). Caller-side stdout/stderr redirection
-    # works across all three primitives — Git Bash routes the > and 2>&1
-    # through to the underlying CRT before nohup execs the child.
-    claude_smart_spawn_detached uv run --project "$PLUGIN_ROOT" --quiet \
-      reflexio services start --only backend --no-reload \
-      >>"$LOG_FILE" 2>&1
+    # (nohup; no process groups). backend-log-runner.sh owns stdout/stderr
+    # capture so process output cannot grow backend.log past its cap.
+    claude_smart_spawn_detached bash "$HERE/backend-log-runner.sh" \
+      "$LOG_FILE" "$LOG_MAX_BYTES" -- \
+      uv run --project "$PLUGIN_ROOT" --quiet \
+      reflexio services start --only backend --no-reload
     svc_pid=$!
     # Record the spawned pid, not a pgid sampled with ps. On POSIX,
     # setsid/python os.setsid make this pid the new process group leader;

package/plugin/scripts/cli.sh

@@ -32,9 +32,33 @@ if [ -f "$FAILURE_MARKER" ]; then
 fi
 
 if ! command -v uv >/dev/null 2>&1; then
-  echo "claude-smart: 'uv' not found on PATH." >&2
-  echo "Install it from https://docs.astral.sh/uv/ or restart Claude Code so the Setup hook can install it." >&2
-  exit 1
+  # Self-heal: the Setup/SessionStart hook may have been skipped (trust
+  # prompt declined, plugin enabled mid-session, etc.) leaving the install
+  # half-done. Run smart-install.sh inline so the user does not have to
+  # restart Claude Code just to recover.
+  # Guard against recursion: if smart-install.sh ever shells back through
+  # this wrapper (e.g. a future migration step) we must not loop forever.
+  if [ "${CLAUDE_SMART_BOOTSTRAPPING:-}" = "1" ]; then
+    echo "claude-smart: bootstrap recursion detected; aborting." >&2
+    exit 1
+  fi
+  if [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
+    echo "claude-smart: 'uv' not found — bootstrapping dependencies (~1-3 min on first install)..." >&2
+    CLAUDE_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >&2
+    claude_smart_prepend_astral_bins
+    claude_smart_prepend_node_bins
+  fi
+  if ! command -v uv >/dev/null 2>&1; then
+    if [ -f "$FAILURE_MARKER" ]; then
+      msg="$(cat "$FAILURE_MARKER" 2>/dev/null || echo "unknown error")"
+      echo "claude-smart: install failed: $msg" >&2
+      echo "Fix the underlying issue and delete $FAILURE_MARKER to retry." >&2
+    else
+      echo "claude-smart: 'uv' not found on PATH after bootstrap attempt." >&2
+      echo "Install it from https://docs.astral.sh/uv/ or rerun $PLUGIN_ROOT/scripts/smart-install.sh manually." >&2
+    fi
+    exit 1
+  fi
 fi
 
 exec uv run --project "$PLUGIN_ROOT" --quiet python -m claude_smart.cli "$@"

package/plugin/scripts/codex-claude-compat

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+set -eu
+
+case "$0" in
+  */*) SCRIPT_DIR=${0%/*} ;;
+  *) SCRIPT_DIR=. ;;
+esac
+SCRIPT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR" && pwd)
+exec node "$SCRIPT_DIR/codex-claude-compat.js" "$@"

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

@@ -0,0 +1,4 @@
+@echo off
+setlocal
+set "SCRIPT_DIR=%~dp0"
+node "%SCRIPT_DIR%codex-claude-compat.js" %*

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

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+"use strict";
+
+/*
+ * Translate Reflexio's Claude CLI provider contract to `codex exec`.
+ *
+ * Reflexio shells out to CLAUDE_SMART_CLI_PATH as if it were Claude Code:
+ *
+ *   <path> -p --output-format stream-json --model <model> ...
+ *
+ * Under Codex, this small bridge preserves that executable contract while
+ * routing the actual generation through the authenticated Codex CLI.
+ */
+
+const { spawnSync } = require("node:child_process");
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const TIMEOUT_MS = 120_000;
+
+function main(argv) {
+  try {
+    const { outputFormat, systemPrompt } = parseSupportedArgs(argv);
+    const content = runCodex({
+      prompt: fs.readFileSync(0, "utf8"),
+      systemPrompt,
+    });
+    const payload =
+      outputFormat === "stream-json"
+        ? { type: "result", subtype: "success", result: content }
+        : { result: content };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`codex-claude-compat: ${message}\n`);
+    return 1;
+  }
+}
+
+function parseSupportedArgs(argv) {
+  let outputFormat = "json";
+  let systemPrompt = "";
+  let idx = 0;
+  while (idx < argv.length) {
+    const arg = argv[idx];
+    if (arg === "-p") {
+      idx += 1;
+    } else if (arg === "--output-format") {
+      outputFormat = requireValue(argv, idx, arg);
+      idx += 2;
+    } else if (arg === "--model") {
+      requireValue(argv, idx, arg);
+      idx += 2;
+    } else if (arg === "--verbose" || arg === "--include-partial-messages") {
+      idx += 1;
+    } else if (arg === "--append-system-prompt") {
+      systemPrompt = requireValue(argv, idx, arg);
+      idx += 2;
+    } else {
+      throw new Error(`unsupported Claude CLI argument: ${arg}`);
+    }
+  }
+  if (outputFormat !== "json" && outputFormat !== "stream-json") {
+    throw new Error(`unsupported --output-format: ${outputFormat}`);
+  }
+  return { outputFormat, systemPrompt };
+}
+
+function requireValue(argv, idx, name) {
+  if (idx + 1 >= argv.length) {
+    throw new Error(`${name} requires a value`);
+  }
+  return argv[idx + 1];
+}
+
+function runCodex({ prompt, systemPrompt }) {
+  const codexPath = process.env.CLAUDE_SMART_CODEX_PATH || commandPath(codexNames());
+  if (!codexPath) {
+    throw new Error("codex CLI not found on PATH");
+  }
+
+  const outputPath = temporaryOutputPath();
+  const args = [
+    "exec",
+    "--sandbox",
+    "read-only",
+    "--skip-git-repo-check",
+    "--ephemeral",
+    "--ignore-rules",
+    "--output-last-message",
+    outputPath,
+    "-",
+  ];
+  const env = {
+    ...process.env,
+    CLAUDE_SMART_HOST: "codex",
+    CLAUDE_SMART_INTERNAL: "1",
+    CLAUDE_CODE_ENTRYPOINT: "optimizer",
+  };
+
+  try {
+    const proc = spawnSync(codexPath, args, {
+      input: codexPrompt({ prompt, systemPrompt }),
+      encoding: "utf8",
+      env,
+      timeout: TIMEOUT_MS,
+      windowsHide: true,
+      shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(codexPath),
+    });
+    if (proc.error) {
+      if (proc.error.code === "ETIMEDOUT") {
+        throw new Error(`codex CLI timed out after ${TIMEOUT_MS / 1000}s`);
+      }
+      throw proc.error;
+    }
+    if (proc.status !== 0) {
+      const stderr = String(proc.stderr || "").trim().slice(0, 500);
+      throw new Error(`codex CLI exited ${proc.status}: ${stderr}`);
+    }
+    const content = fs.readFileSync(outputPath, "utf8").trim();
+    if (!content) {
+      throw new Error("codex CLI returned empty output");
+    }
+    return content;
+  } finally {
+    try {
+      fs.unlinkSync(outputPath);
+    } catch {
+      // Best effort cleanup only.
+    }
+  }
+}
+
+function codexNames() {
+  return process.platform === "win32" ? ["codex.cmd", "codex.exe", "codex"] : ["codex"];
+}
+
+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 temporaryOutputPath() {
+  const suffix = crypto.randomBytes(8).toString("hex");
+  return path.join(os.tmpdir(), `claude-smart-codex-${process.pid}-${Date.now()}-${suffix}`);
+}
+
+function codexPrompt({ prompt, systemPrompt }) {
+  if (!systemPrompt) return prompt;
+  return `${systemPrompt}\n\n## Task\n${prompt}`;
+}
+
+process.exitCode = main(process.argv.slice(2));

package/plugin/scripts/codex-hook.js

@@ -13,6 +13,7 @@ const REFLEXIO_DIR = path.join(HOME, ".reflexio");
 const DEFAULT_BACKEND_PORT = 8071;
 const FALLBACK_BACKEND_PORT = 8072;
 const DASHBOARD_PORT = 3001;
+const LOG_MAX_BYTES = 10000000;
 
 function emitOk() {
   process.stdout.write('{"continue":true,"suppressOutput":true}\n');
@@ -22,9 +23,31 @@ function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+function trimLog(file) {
+  if (!Number.isFinite(LOG_MAX_BYTES) || LOG_MAX_BYTES < 1) return;
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return;
+  }
+  if (!stat.isFile() || stat.size <= LOG_MAX_BYTES) return;
+  const fd = fs.openSync(file, "r");
+  try {
+    const buffer = Buffer.alloc(LOG_MAX_BYTES);
+    fs.readSync(fd, buffer, 0, LOG_MAX_BYTES, stat.size - LOG_MAX_BYTES);
+    fs.writeFileSync(file, buffer);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
 function appendLog(name, line) {
   ensureDir(STATE_DIR);
-  fs.appendFileSync(path.join(STATE_DIR, name), `${line}\n`);
+  const file = path.join(STATE_DIR, name);
+  trimLog(file);
+  fs.appendFileSync(file, `${line}\n`);
+  trimLog(file);
 }
 
 function pluginRoot() {
@@ -95,7 +118,10 @@ function writeBackendUrl(port) {
 }
 
 function codexCompatPath(root) {
-  return path.join(root, "scripts", "codex-claude-compat.py");
+  const filename = process.platform === "win32"
+    ? "codex-claude-compat.cmd"
+    : "codex-claude-compat";
+  return path.join(root, "scripts", filename);
 }
 
 function readBackendUrl() {
@@ -216,6 +242,7 @@ function ensurePluginRoot(root) {
 }
 
 async function startBackend(root) {
+  trimLog(path.join(STATE_DIR, "backend.log"));
   if (process.env.CLAUDE_SMART_BACKEND_AUTOSTART === "0") {
     emitOk();
     return;
@@ -326,6 +353,7 @@ async function startDashboard(root) {
 }
 
 function runHook(root, event) {
+  trimLog(path.join(STATE_DIR, "backend.log"));
   const uv = uvPath();
   if (!uv) {
     appendLog("backend.log", "[claude-smart] hook: uv not on PATH; skipping");

package/plugin/scripts/smart-install.sh

@@ -20,18 +20,121 @@ REPO_ROOT="$(cd "$HERE/../.." && pwd)"
 
 MARKER_DIR="$HOME/.claude-smart"
 FAILURE_MARKER="$MARKER_DIR/install-failed"
+SUCCESS_MARKER="$MARKER_DIR/install-complete"
+INSTALL_LOCK="$MARKER_DIR/install.lock"
 mkdir -p "$MARKER_DIR"
+
+# Serialize concurrent installer runs (SessionStart hook + slash-command
+# self-heal can both invoke this script). Wait for the active installer
+# rather than returning early, otherwise callers can re-check uv before
+# the first install has finished and report a false missing-dependency error.
+if command -v flock >/dev/null 2>&1; then
+  exec 9>"$INSTALL_LOCK"
+  if ! flock 9; then
+    echo "[claude-smart] install lock failed; continuing without serialization" >&2
+    echo '{"continue":true,"suppressOutput":true}'
+    exit 0
+  fi
+fi
+
 rm -f "$FAILURE_MARKER"
 
 write_failure() {
   local reason
   reason="$1"
   printf '%s\n' "$reason" > "$FAILURE_MARKER"
+  rm -f "$SUCCESS_MARKER"
   echo "[claude-smart] install failed: $reason" >&2
   echo '{"continue":true,"suppressOutput":true}'
   exit 0
 }
 
+fingerprint_file() {
+  local path
+  path="$1"
+  if [ -f "$path" ]; then
+    cksum "$path" 2>/dev/null | awk '{print $1 ":" $2}'
+  else
+    printf 'missing\n'
+  fi
+}
+
+install_fingerprint() {
+  printf 'plugin_root=%s\n' "$PLUGIN_ROOT"
+  printf 'smart_install=%s\n' "$(fingerprint_file "$HERE/smart-install.sh")"
+  printf 'pyproject=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/pyproject.toml")"
+  printf 'uv_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/uv.lock")"
+  # Resolved python interpreter — catches a system upgrade (3.12.4 → 3.12.5)
+  # that would otherwise let install_complete return true against a venv
+  # built against a now-deleted interpreter.
+  if command -v uv >/dev/null 2>&1; then
+    printf 'python=%s\n' "$(uv python find 3.12 2>/dev/null || echo missing)"
+  else
+    printf 'python=no-uv\n'
+  fi
+  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
+    printf 'dashboard_pkg=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package.json")"
+    printf 'dashboard_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package-lock.json")"
+  else
+    printf 'dashboard_pkg=none\n'
+    printf 'dashboard_lock=none\n'
+  fi
+}
+
+install_complete() {
+  [ -f "$SUCCESS_MARKER" ] || return 1
+  [ "$(cat "$SUCCESS_MARKER" 2>/dev/null || true)" = "$(install_fingerprint)" ] || return 1
+  command -v uv >/dev/null 2>&1 || return 1
+  [ -d "$PLUGIN_ROOT/.venv" ] || return 1
+  [ -f "$HOME/.reflexio/.env" ] || return 1
+  grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
+  grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.reflexio/.env" || return 1
+  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
+    [ -d "$PLUGIN_ROOT/dashboard/.next" ] || [ -f "$MARKER_DIR/dashboard-build.pid" ] || [ -f "$(claude_smart_dashboard_unavailable_marker)" ] || return 1
+  fi
+  return 0
+}
+
+write_success_marker() {
+  install_fingerprint > "$SUCCESS_MARKER"
+}
+
+preflight_supported_runtime_platform() {
+  local os_name machine darwin_major
+  os_name="$(uname -s 2>/dev/null || echo unknown)"
+  machine="$(uname -m 2>/dev/null || echo unknown)"
+  case "$os_name" in
+    Darwin*)
+      if [ "$machine" != "arm64" ]; then
+        write_failure "claude-smart currently supports Apple Silicon macOS 14+ only; Intel Mac is not supported because native ML wheels are unavailable."
+      fi
+      darwin_major="$(uname -r 2>/dev/null | awk -F. '{print $1}')"
+      case "$darwin_major" in
+        ''|*[!0-9]*)
+          write_failure "claude-smart could not determine the macOS version; Apple Silicon macOS 14+ is required."
+          ;;
+      esac
+      if [ "$darwin_major" -lt 23 ]; then
+        write_failure "claude-smart currently supports macOS 14+ on Apple Silicon; macOS 13 and older are not supported because native ML wheels are unavailable."
+      fi
+      ;;
+    MINGW*|MSYS*|CYGWIN*)
+      case "$machine" in
+        x86_64|amd64) : ;;
+        *)
+          write_failure "claude-smart currently supports Windows x64 only; Windows ARM is not supported because native ML wheels are unavailable."
+          ;;
+      esac
+      ;;
+    Linux*)
+      : # Existing Linux installs remain supported when package wheels are available.
+      ;;
+    *)
+      write_failure "claude-smart currently supports Apple Silicon macOS 14+, Windows x64, and Linux for vanilla installs."
+      ;;
+  esac
+}
+
 install_private_node() {
   local NODE_MIN_MAJOR NODE_MIN_MINOR NODE_LTS_MAJOR
   local node_os archive_ext reason node_arch node_platform base_url node_root
@@ -236,6 +339,13 @@ if [ "${CLAUDE_SMART_INSTALL_PRIVATE_NODE_ONLY:-}" = "1" ]; then
   exit $?
 fi
 
+preflight_supported_runtime_platform
+
+if install_complete; then
+  echo '{"continue":true,"suppressOutput":true}'
+  exit 0
+fi
+
 # Dev-mode only: when running from a git checkout, pull the reflexio
 # submodule so tests/benchmarks can use its sources. In install mode the
 # plugin lives under ~/.claude/plugins/cache and reflexio-ai resolves
@@ -327,57 +437,32 @@ if ! command -v claude >/dev/null 2>&1; then
   echo "[claude-smart] WARNING: 'claude' CLI not on PATH — reflexio extractors will have no LLM until it's installed" >&2
 fi
 
-# Allowlist cs-cite globally so Claude's citation Bash calls don't pop a
-# permission prompt mid-turn. Idempotent: no-ops when the entry is already
-# present. Uses Python to preserve the rest of settings.json intact.
-# Resolves python via claude_smart_resolve_python so we don't fire the
-# Windows App Execution Alias stub (which exits non-zero with "Python
-# was not found" when no real interpreter is installed).
+LEGACY_CS_CITE="$HOME/.claude-smart/bin/cs-cite"
+if [ -e "$LEGACY_CS_CITE" ]; then
+  rm -f "$LEGACY_CS_CITE"
+  echo "[claude-smart] removed legacy cs-cite helper at $LEGACY_CS_CITE" >&2
+fi
+
 CLAUDE_SETTINGS="$HOME/.claude/settings.json"
-mkdir -p "$(dirname "$CLAUDE_SETTINGS")"
-PY_BIN=$(claude_smart_resolve_python || true)
-if [ -z "$PY_BIN" ]; then
-  echo "[claude-smart] WARNING: no working python interpreter found; skipping cs-cite allowlist" >&2
-elif "$PY_BIN" - "$CLAUDE_SETTINGS" <<'PY' >&2
-import json
-import sys
-from pathlib import Path
-
-path = Path(sys.argv[1])
-entry = "Bash(cs-cite:*)"
-data: dict = {}
-if path.is_file():
-    try:
-        data = json.loads(path.read_text() or "{}")
-    except json.JSONDecodeError:
-        print(
-            f"[claude-smart] WARNING: {path} is not valid JSON; skipping cs-cite allowlist",
-            file=sys.stderr,
-        )
-        sys.exit(2)
-def _warn_and_exit(reason: str) -> None:
-    print(
-        f"[claude-smart] WARNING: {path} {reason}; skipping cs-cite allowlist",
-        file=sys.stderr,
-    )
-    sys.exit(2)
-
-if not isinstance(data, dict):
-    _warn_and_exit("top-level is not a JSON object")
-permissions = data.setdefault("permissions", {})
-if not isinstance(permissions, dict):
-    _warn_and_exit("'permissions' is not a JSON object")
-allow = permissions.setdefault("allow", [])
-if not isinstance(allow, list):
-    _warn_and_exit("'permissions.allow' is not a JSON array")
-if entry in allow:
-    sys.exit(1)  # already present — convey via exit code so shell can skip the log
-allow.append(entry)
-path.write_text(json.dumps(data, indent=2) + "\n")
-sys.exit(0)
-PY
-then
-  echo "[claude-smart] added Bash(cs-cite:*) to $CLAUDE_SETTINGS permissions.allow" >&2
+if [ -f "$CLAUDE_SETTINGS" ] && command -v node >/dev/null 2>&1; then
+  node - "$CLAUDE_SETTINGS" <<'JS' >&2 || true
+const fs = require("fs");
+const path = process.argv[2];
+const entry = "Bash(cs-cite:*)";
+let data;
+try {
+  data = JSON.parse(fs.readFileSync(path, "utf8") || "{}");
+} catch {
+  process.exit(0);
+}
+const allow = data?.permissions?.allow;
+if (!Array.isArray(allow)) process.exit(0);
+const next = allow.filter((item) => item !== entry);
+if (next.length === allow.length) process.exit(0);
+data.permissions.allow = next;
+fs.writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+console.error(`[claude-smart] removed legacy ${entry} permission from ${path}`);
+JS
 fi
 
 # Spawn the dashboard build detached so install returns immediately and
@@ -406,5 +491,6 @@ if ! bash "$HERE/ensure-plugin-root.sh" "$PLUGIN_ROOT"; then
   echo "[claude-smart] WARNING: failed to set ~/.reflexio/plugin-root symlink — slash commands may not resolve" >&2
 fi
 
+write_success_marker
 echo "[claude-smart] install complete. Backend and dashboard auto-start on session start." >&2
 echo '{"continue":true,"suppressOutput":true}'