claude-smart 0.2.39 → 0.2.41

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.39-green.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-0.2.41-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

@@ -16,6 +16,7 @@
 const { execSync, spawn, spawnSync } = require("child_process");
 const crypto = require("crypto");
 const {
+  chmodSync,
   cpSync,
   existsSync,
   lstatSync,
@@ -41,6 +42,8 @@ const REFLEXIO_ENV_PATH = join(homedir(), ".reflexio", ".env");
 const MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/";
 const MANAGED_SETUP_ENV = "CLAUDE_SMART_MANAGED_SETUP";
 const CLAUDE_SMART_READ_ONLY_ENV = "CLAUDE_SMART_READ_ONLY";
+const CLAUDE_SMART_USE_LOCAL_CLI_ENV = "CLAUDE_SMART_USE_LOCAL_CLI";
+const CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV = "CLAUDE_SMART_USE_LOCAL_EMBEDDING";
 const REFLEXIO_USER_ID_ENV = "REFLEXIO_USER_ID";
 const REFLEXIO_DIR = join(homedir(), ".reflexio");
 const CLAUDE_SMART_STATE_DIR = join(homedir(), ".claude-smart");
@@ -90,6 +93,24 @@ const COPYTREE_IGNORE_NAMES = new Set([
   "node_modules",
   ".next",
 ]);
+const LOCAL_DEFAULT_ENV_ENTRIES = [
+  [
+    "# Route reflexio generation through the local Claude Code CLI",
+    CLAUDE_SMART_USE_LOCAL_CLI_ENV,
+    "1",
+  ],
+  [
+    "# Use the in-process ONNX embedder (chromadb) - no API key for semantic search",
+    CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV,
+    "1",
+  ],
+  [null, CLAUDE_SMART_READ_ONLY_ENV, "0"],
+];
+const LOCAL_MODE_PRUNE_KEYS = new Set([
+  "REFLEXIO_URL",
+  "REFLEXIO_API_KEY",
+  REFLEXIO_USER_ID_ENV,
+]);
 
 function shouldCopyPath(src) {
   const base = src.split(/[\\/]/).pop() || "";
@@ -216,6 +237,57 @@ function parseEnvLine(line) {
   return { key, value };
 }
 
+function escapeEnvValue(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function ensureLocalReflexioEnv() {
+  mkdirSync(dirname(REFLEXIO_ENV_PATH), { recursive: true });
+  const existing = existsSync(REFLEXIO_ENV_PATH)
+    ? readFileSync(REFLEXIO_ENV_PATH, "utf8")
+    : "";
+  const present = new Set();
+  const keptLines = [];
+  let pruned = false;
+  for (const line of existing.split(/\r?\n/)) {
+    const parsed = parseEnvLine(line);
+    if (parsed) {
+      if (LOCAL_MODE_PRUNE_KEYS.has(parsed.key)) {
+        pruned = true;
+        continue;
+      }
+      present.add(parsed.key);
+    }
+    keptLines.push(line);
+  }
+
+  const additions = [];
+  const added = [];
+  for (const [comment, key, value] of LOCAL_DEFAULT_ENV_ENTRIES) {
+    if (present.has(key)) continue;
+    if (comment) additions.push(comment);
+    if (key === CLAUDE_SMART_READ_ONLY_ENV) {
+      additions.push(`${key}="${escapeEnvValue(value)}"`);
+    } else {
+      additions.push(`${key}=${escapeEnvValue(value)}`);
+    }
+    added.push(key);
+  }
+
+  if (additions.length > 0 || pruned) {
+    let content = keptLines.join("\n").replace(/\n*$/, "");
+    if (additions.length > 0) {
+      const prefix = content ? "\n" : "";
+      content = content + prefix + additions.join("\n");
+    }
+    writeFileSync(REFLEXIO_ENV_PATH, content ? `${content}\n` : "");
+  } else if (!existsSync(REFLEXIO_ENV_PATH)) {
+    writeFileSync(REFLEXIO_ENV_PATH, "");
+  }
+  chmodSync(REFLEXIO_ENV_PATH, 0o600);
+  return added;
+}
+
 function maskSecret(value) {
   if (!value) return "";
   if (value.length <= 8) return "*".repeat(value.length);
@@ -254,7 +326,12 @@ function loadReflexioSetupEnv() {
   } else {
     delete process.env.REFLEXIO_URL;
     delete process.env.REFLEXIO_API_KEY;
+    delete process.env[REFLEXIO_USER_ID_ENV];
     delete process.env[MANAGED_SETUP_ENV];
+    const added = ensureLocalReflexioEnv();
+    if (added.length > 0) {
+      process.stdout.write(`Seeded ${REFLEXIO_ENV_PATH} with ${added.join(", ")}.\n`);
+    }
   }
   const readOnly = ["1", "true", "yes", "on"].includes(
     String(readOnlyValue).trim().toLowerCase(),
@@ -431,14 +508,14 @@ function runChecked(command, args, options = {}) {
   });
 }
 
-function runPluginService(pluginRoot, scriptName, subcommand) {
+function runPluginService(pluginRoot, scriptName, subcommand, envOverrides = {}) {
   const script = join(pluginRoot, "scripts", scriptName);
   if (!existsSync(script)) return false;
   const bash = resolveCommand(isWindows() ? ["bash.exe", "bash"] : ["bash"]);
   if (!bash) return false;
   const result = spawnSync(bash, [script, subcommand], {
     cwd: pluginRoot,
-    env: runtimeEnv(),
+    env: { ...runtimeEnv(), ...envOverrides },
     stdio: "ignore",
     windowsHide: true,
     timeout: PLUGIN_SERVICE_TIMEOUT_MS,
@@ -465,6 +542,12 @@ function refreshDashboardService(pluginRoot) {
   return runPluginService(pluginRoot, "dashboard-service.sh", "start");
 }
 
+function startBackendService(pluginRoot, host) {
+  return runPluginService(pluginRoot, "backend-service.sh", "start", {
+    CLAUDE_SMART_HOST: host,
+  });
+}
+
 function stopClaudeSmartServices(pluginRoot) {
   runPluginService(pluginRoot, "dashboard-service.sh", "stop");
   runPluginService(pluginRoot, "backend-service.sh", "stop");
@@ -757,9 +840,7 @@ function patchCodexHooksForNode(pluginRoot, nodePath) {
   const runner = join(pluginRoot, "scripts", "codex-hook.js");
   const command = (...args) => [nodePath, runner, ...args].map(quoteCommandPart).join(" ");
   // Dispatch by command content rather than index — entries can be added or
-  // reordered (e.g. the SessionStart install hook at index 0) without
-  // breaking the patch. Entries that must run as bash (smart-install.sh)
-  // are left untouched.
+  // reordered without breaking the patch.
   const patchOne = (original) => {
     if (typeof original !== "string") return original;
     if (original.includes("smart-install.sh")) return original;
@@ -1435,6 +1516,9 @@ async function runInstall(args) {
       process.stdout.write("Installed read-only hook manifest; publish interactions hooks are disabled.\n");
     }
     process.stdout.write(`Prepared claude-smart runtime at ${pluginRoot}.\n`);
+    if (startBackendService(pluginRoot, "claude-code")) {
+      process.stdout.write("Started claude-smart backend service.\n");
+    }
     if (refreshDashboardService(pluginRoot)) {
       process.stdout.write("Refreshed claude-smart dashboard service.\n");
     }
@@ -1515,6 +1599,9 @@ async function runInstallCodex(args) {
     if (readOnly) {
       process.stdout.write("Installed read-only hook manifest; publish interactions hooks are disabled.\n");
     }
+    if (startBackendService(cacheDir, "codex")) {
+      process.stdout.write("Started claude-smart backend service.\n");
+    }
     if (refreshDashboardService(cacheDir)) {
       process.stdout.write("Refreshed claude-smart dashboard service.\n");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "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.39",
+  "version": "0.2.41",
   "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.39",
+  "version": "0.2.41",
   "description": "Self-improving coding assistant plugin — learns from corrections across sessions via reflexio",
   "author": {
     "name": "Yi Lu"

package/plugin/hooks/codex-hooks.json

@@ -5,11 +5,6 @@
       {
         "matcher": "startup|resume",
         "hooks": [
-          {
-            "type": "command",
-            "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/smart-install.sh\" || true",
-            "timeout": 300
-          },
           {
             "type": "command",
             "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",

package/plugin/hooks/hooks.json

@@ -14,16 +14,6 @@
       }
     ],
     "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.39"
+version = "0.2.41"
 description = "Self-improving Claude Code plugin — learns from corrections via reflexio"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,6 +15,10 @@ dependencies = [
     # downloaded on first use, not at install time.
     "chromadb>=0.5",
     "einops>=0.8.0",
+    # Native SQLite vector KNN for local storage. Reflexio can fall back to
+    # Python ranking without this, but installed claude-smart should include
+    # the accelerator by default.
+    "sqlite-vec>=0.1.6",
 ]
 
 [project.scripts]

package/plugin/scripts/backend-service.sh

@@ -201,13 +201,13 @@ case "$CMD" in
     fi
     if ! command -v uv >/dev/null 2>&1; then
       if [ "${CLAUDE_SMART_BOOTSTRAPPING:-}" != "1" ] && [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
-        claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: uv not on PATH; running installer"
-        CLAUDE_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >>"$STATE_DIR/install.log" 2>&1 || true
-        claude_smart_source_login_path
-        claude_smart_prepend_astral_bins
+        claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: uv not on PATH; starting installer in background"
+        claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+          bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
+          >>"$STATE_DIR/install.log" 2>&1 || true
       fi
       if ! command -v uv >/dev/null 2>&1; then
-        claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: uv not on PATH after installer; skipping"
+        claude_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[claude-smart] backend: uv not on PATH; installer recovery scheduled; skipping"
         emit_ok; exit 0
       fi
     fi

package/plugin/scripts/codex-hook.js

@@ -302,33 +302,6 @@ function detached(command, args, options = {}) {
   return child.pid;
 }
 
-function runInstaller(root, reason) {
-  if (process.env.CLAUDE_SMART_BOOTSTRAPPING === "1") return false;
-  const script = path.join(root, "scripts", "smart-install.sh");
-  if (!fs.existsSync(script)) return false;
-  const bash = bashPath();
-  if (!bash) return false;
-  appendLog("backend.log", `[claude-smart] ${reason}; running installer`);
-  const result = spawnSync(bash, [script], {
-    cwd: root,
-    env: {
-      ...process.env,
-      CLAUDE_SMART_BOOTSTRAPPING: "1",
-    },
-    encoding: "utf8",
-    maxBuffer: 20 * 1024 * 1024,
-    windowsHide: true,
-  });
-  const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
-  if (output) {
-    ensureDir(STATE_DIR);
-    fs.appendFileSync(path.join(STATE_DIR, "install.log"), `${output}\n`);
-    trimLog(path.join(STATE_DIR, "install.log"));
-  }
-  prependRuntimePath();
-  return result.status === 0;
-}
-
 function startInstallerDetached(root, reason) {
   if (process.env.CLAUDE_SMART_BOOTSTRAPPING === "1") return false;
   const script = path.join(root, "scripts", "smart-install.sh");
@@ -410,11 +383,11 @@ async function startBackend(root) {
   }
   const uv = uvPath();
   if (!uv) {
-    runInstaller(root, "backend: uv not on PATH");
+    startInstallerDetached(root, "backend: uv not on PATH");
   }
   const readyUv = uvPath();
   if (!readyUv) {
-    appendLog("backend.log", "[claude-smart] backend: uv not on PATH after installer; skipping");
+    appendLog("backend.log", "[claude-smart] backend: uv not on PATH; installer recovery scheduled; skipping");
     emitOk();
     return;
   }
@@ -478,11 +451,11 @@ async function startDashboard(root) {
   }
   const npm = npmPath();
   if (!npm) {
-    runInstaller(root, "dashboard: npm not on PATH");
+    startInstallerDetached(root, "dashboard: npm not on PATH");
   }
   const readyNpm = npmPath();
   if (!readyNpm) {
-    appendLog("dashboard.log", "[claude-smart] dashboard: npm not on PATH after installer; skipping");
+    appendLog("dashboard.log", "[claude-smart] dashboard: npm not on PATH; installer recovery scheduled; skipping");
     emitOk();
     return;
   }
@@ -512,14 +485,10 @@ function runHook(root, event) {
   trimLog(path.join(STATE_DIR, "backend.log"));
   let uv = uvPath();
   if (!uv) {
-    if (event === "session-start") {
-      runInstaller(root, "hook: uv not on PATH");
-      uv = uvPath();
-    } else {
-      startInstallerDetached(root, "hook: uv not on PATH");
-    }
+    startInstallerDetached(root, "hook: uv not on PATH");
+    uv = uvPath();
     if (!uv) {
-      appendLog("backend.log", "[claude-smart] hook: uv not on PATH after installer; skipping");
+      appendLog("backend.log", "[claude-smart] hook: uv not on PATH; installer recovery scheduled; skipping");
       emitHookOk();
       return 0;
     }
@@ -535,7 +504,7 @@ function runHook(root, event) {
         REFLEXIO_URL: readBackendUrl(),
         CLAUDE_SMART_HOST: "codex",
         CLAUDE_SMART_CLI_PATH: process.env.CLAUDE_SMART_CLI_PATH || codexCompatPath(root),
-        CLAUDE_SMART_CITATION_LINK_STYLE: process.env.CLAUDE_SMART_CITATION_LINK_STYLE || "osc8",
+        CLAUDE_SMART_CITATION_LINK_STYLE: process.env.CLAUDE_SMART_CITATION_LINK_STYLE || "markdown",
       },
       input,
       stdio: ["pipe", "pipe", "inherit"],

package/plugin/scripts/dashboard-service.sh

@@ -190,14 +190,13 @@ case "$CMD" in
     NPM_BIN=$(claude_smart_resolve_npm || true)
     if [ -z "$NPM_BIN" ] || ! "$NPM_BIN" --version >/dev/null 2>&1; then
       if [ "${CLAUDE_SMART_BOOTSTRAPPING:-}" != "1" ] && [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
-        echo "[claude-smart] dashboard: npm is not on PATH; running installer" >>"$LOG_FILE"
-        CLAUDE_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >>"$STATE_DIR/install.log" 2>&1 || true
-        claude_smart_source_login_path
-        claude_smart_prepend_node_bins
-        NPM_BIN=$(claude_smart_resolve_npm || true)
+        echo "[claude-smart] dashboard: npm is not on PATH; starting installer in background" >>"$LOG_FILE"
+        claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+          bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
+          >>"$STATE_DIR/install.log" 2>&1 || true
       fi
       if [ -z "$NPM_BIN" ] || ! "$NPM_BIN" --version >/dev/null 2>&1; then
-        reason="npm is not on PATH after installer; dashboard cannot start"
+        reason="npm is not on PATH; installer recovery scheduled; dashboard cannot start yet"
         echo "[claude-smart] dashboard: $reason; skipping" >>"$LOG_FILE"
         claude_smart_write_dashboard_unavailable "$reason"
         emit_ok; exit 0

package/plugin/scripts/hook_entry.sh

@@ -21,7 +21,7 @@ case "$EVENT" in
 esac
 export CLAUDE_SMART_HOST="$HOST"
 if [ "$HOST" = "codex" ] && [ -z "${CLAUDE_SMART_CITATION_LINK_STYLE:-}" ]; then
-  export CLAUDE_SMART_CITATION_LINK_STYLE="osc8"
+  export CLAUDE_SMART_CITATION_LINK_STYLE="markdown"
 fi
 
 HERE="$(cd "$(dirname "$0")" && pwd)"
@@ -59,8 +59,9 @@ if [ -f "$FAILURE_MARKER" ]; then
   if [ -z "$stored_fp" ] || [ "$stored_fp" != "$current_fp" ]; then
     rm -f "$FAILURE_MARKER"
   else
-    if [ "$EVENT" = "session-start" ] && command -v python3 >/dev/null 2>&1; then
-      python3 - "$FAILURE_MARKER" <<'PY'
+    failure_py="$(claude_smart_resolve_python 2>/dev/null || true)"
+    if [ "$EVENT" = "session-start" ] && [ -n "$failure_py" ]; then
+      "$failure_py" - "$FAILURE_MARKER" <<'PY'
 import json, pathlib, sys
 first = pathlib.Path(sys.argv[1]).read_text().splitlines()
 msg = (first[0].strip() if first else "") or "unknown error"
@@ -84,29 +85,18 @@ PY
 fi
 
 if ! command -v uv >/dev/null 2>&1; then
-  # Self-heal from skipped Setup/SessionStart bootstrap. SessionStart can
-  # afford to wait because it has the install budget; prompt/tool hooks start
-  # the same installer detached so normal work is not blocked by first-run
-  # dependency setup.
+  # Self-heal from skipped setup without blocking the first prompt. The
+  # installer and Setup hook own dependency bootstrap; hooks only schedule
+  # recovery and return so SessionStart stays lightweight.
   if [ "${CLAUDE_SMART_BOOTSTRAPPING:-}" = "1" ]; then
     claude_smart_emit_continue
     exit 0
   fi
   if [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
     mkdir -p "$STATE_DIR"
-    if [ "$EVENT" = "session-start" ]; then
-      CLAUDE_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >&2
-      claude_smart_prepend_astral_bins
-      claude_smart_prepend_node_bins
-      if command -v uv >/dev/null 2>&1; then
-        bash "$HERE/backend-service.sh" start >/dev/null 2>&1 || true
-        bash "$HERE/dashboard-service.sh" start >/dev/null 2>&1 || true
-      fi
-    else
-      claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
-        bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
-        >>"$STATE_DIR/install.log" 2>&1 || true
-    fi
+    claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+      bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
+      >>"$STATE_DIR/install.log" 2>&1 || true
   fi
   if ! command -v uv >/dev/null 2>&1; then
     claude_smart_emit_continue
@@ -127,17 +117,13 @@ ensure_hook_package_importable() {
   fi
 
   mkdir -p "$STATE_DIR"
-  if [ "$EVENT" = "session-start" ]; then
-    CLAUDE_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >&2
-  else
-    {
-      printf '%s\n' "[claude-smart] hook: claude_smart.hook is not importable; retrying install in background"
-      date 2>/dev/null || true
-    } >>"$STATE_DIR/install.log" 2>&1
-    claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
-      bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
-      >>"$STATE_DIR/install.log" 2>&1 || true
-  fi
+  {
+    printf '%s\n' "[claude-smart] hook: claude_smart.hook is not importable; retrying install in background"
+    date 2>/dev/null || true
+  } >>"$STATE_DIR/install.log" 2>&1
+  claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+    bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
+    >>"$STATE_DIR/install.log" 2>&1 || true
 
   claude_smart_python_imports "$PLUGIN_ROOT" claude_smart.hook
 }

package/plugin/scripts/smart-install.sh

@@ -106,12 +106,25 @@ install_complete() {
   command -v uv >/dev/null 2>&1 || return 1
   [ -d "$PLUGIN_ROOT/.venv" ] || return 1
   claude_smart_python_imports "$PLUGIN_ROOT" claude_smart.hook || return 1
+  if [ -z "${REFLEXIO_API_KEY:-}" ]; then
+    [ -f "$HOME/.reflexio/.env" ] || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.reflexio/.env" || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_READ_ONLY=' "$HOME/.reflexio/.env" || return 1
+  fi
   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
 }
 
+start_backend_service() {
+  if [ -x "$HERE/backend-service.sh" ]; then
+    echo "[claude-smart] starting backend service in background" >&2
+    bash "$HERE/backend-service.sh" start >/dev/null 2>&1 || true
+  fi
+}
+
 install_vendored_reflexio() {
   local VENDORED_REFLEXIO PLUGIN_PYTHON
 
@@ -385,6 +398,7 @@ fi
 preflight_supported_runtime_platform
 
 if install_complete; then
+  start_backend_service
   claude_smart_emit_continue
   exit 0
 fi
@@ -491,6 +505,63 @@ claude_smart_env_upsert() {
   fi
 }
 
+claude_smart_env_append_raw_if_missing() {
+  local key value
+  key="$1"
+  value="$2"
+  if ! grep -qE "^(export[[:space:]]+)?${key}=" "$REFLEXIO_ENV"; then
+    printf '%s=%s\n' "$key" "$value" >> "$REFLEXIO_ENV"
+  fi
+}
+
+claude_smart_prune_managed_env_keys_for_local() {
+  local tmp line raw_key key
+  [ -f "$REFLEXIO_ENV" ] || return 0
+  tmp="$(mktemp "${REFLEXIO_ENV}.tmp.XXXXXX")"
+  while IFS= read -r line || [ -n "$line" ]; do
+    raw_key="$line"
+    raw_key="${raw_key#"${raw_key%%[![:space:]]*}"}"
+    case "$raw_key" in
+      export\ *) raw_key="${raw_key#export }" ;;
+    esac
+    key="${raw_key%%=*}"
+    key="${key%"${key##*[![:space:]]}"}"
+    case "$key" in
+      REFLEXIO_URL|REFLEXIO_API_KEY|REFLEXIO_USER_ID)
+        continue
+        ;;
+    esac
+    printf '%s\n' "$line" >> "$tmp"
+  done < "$REFLEXIO_ENV"
+  mv "$tmp" "$REFLEXIO_ENV"
+}
+
+claude_smart_ensure_local_env_defaults() {
+  [ -z "${REFLEXIO_API_KEY:-}" ] || return 0
+  mkdir -p "$(dirname "$REFLEXIO_ENV")"
+  touch "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+  claude_smart_prune_managed_env_keys_for_local
+  unset REFLEXIO_URL REFLEXIO_API_KEY REFLEXIO_USER_ID CLAUDE_SMART_MANAGED_SETUP
+  if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_CLI=' "$REFLEXIO_ENV"; then
+    printf '# Route reflexio generation through the local Claude Code CLI\n' >> "$REFLEXIO_ENV"
+    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_CLI "1"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=1 to $REFLEXIO_ENV" >&2
+  fi
+  if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
+    printf '# Use the in-process ONNX embedder (chromadb) - no API key for semantic search\n' >> "$REFLEXIO_ENV"
+    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_EMBEDDING "1"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
+  fi
+  if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_READ_ONLY=' "$REFLEXIO_ENV"; then
+    claude_smart_env_upsert CLAUDE_SMART_READ_ONLY "0"
+    echo "[claude-smart] appended CLAUDE_SMART_READ_ONLY=0 to $REFLEXIO_ENV" >&2
+  fi
+  chmod 600 "$REFLEXIO_ENV"
+}
+
+claude_smart_ensure_local_env_defaults
+
 # 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
@@ -561,6 +632,8 @@ 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
 
+start_backend_service
+
 write_success_marker
-echo "[claude-smart] install complete. Backend and dashboard auto-start on session start." >&2
+echo "[claude-smart] install complete. Backend started; dashboard auto-starts on session start." >&2
 claude_smart_emit_continue

package/plugin/src/claude_smart/cli.py

@@ -894,7 +894,7 @@ def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
 
 
 def _configure_reflexio_setup() -> bool:
-    """Load setup state from ``~/.reflexio/.env`` without writing local defaults.
+    """Load setup state and ensure local defaults when unmanaged.
 
     Returns:
         bool: Whether read-only mode is enabled.
@@ -939,7 +939,11 @@ def _configure_reflexio_setup() -> bool:
     else:
         os.environ.pop(env_config.REFLEXIO_URL_ENV, None)
         os.environ.pop(env_config.REFLEXIO_API_KEY_ENV, None)
+        os.environ.pop("REFLEXIO_USER_ID", None)
         os.environ.pop("CLAUDE_SMART_MANAGED_SETUP", None)
+        added = env_config.ensure_local_env_defaults(_REFLEXIO_ENV_PATH)
+        if added:
+            sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
     return read_only
 
 
@@ -1342,7 +1346,9 @@ def _run_service(script: Path, subcmd: str) -> int:
         return 1
     bash = _resolve_bash()
     if not bash:
-        sys.stderr.write("error: bash is required to run claude-smart service scripts\n")
+        sys.stderr.write(
+            "error: bash is required to run claude-smart service scripts\n"
+        )
         return 1
     try:
         subprocess.run([bash, str(script), subcmd], check=True)

package/plugin/src/claude_smart/context_format.py

@@ -238,6 +238,11 @@ def render_inline_compact_with_registry(
             item = f"{content} (title: {title}"
             if rule_url:
                 item += f"; open: {rule_url}"
+                marker_parts.append(
+                    _markdown_link(
+                        rule_url, _strip_trailing_sentence_punctuation(title)
+                    )
+                )
             item += ")"
         if entry.get("kind") == "profile":
             preference_parts.append(item)
@@ -280,6 +285,17 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
             "the same linked memory text; keep the link, but do not show the "
             "URL. Skip when unrelated."
         )
+    if marker_parts:
+        marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
+        separator_instruction = (
+            " Separate multiple linked memories with the visible ` | ` separator."
+            if len(marker_parts) > 1
+            else ""
+        )
+        return _remoteize_citation_instruction(
+            f"If used, copy this final marker exactly with markdown links: "
+            f"`{marker}`.{separator_instruction} Skip when unrelated."
+        )
     return _remoteize_citation_instruction(
         "Only if a listed [cs:...] item materially changes your answer, end "
         "with one final marker like `✨ claude-smart rule applied: "
@@ -368,7 +384,7 @@ def _append_playbook_bullet(
     item_id = cs_cite.rank_id("playbook", rank, real_id)
     title = _title_from_content(content)
     dashboard_url = _dashboard_url("playbook", real_id, source_kind)
-    rule_url = _rule_url(item_id, "playbook")
+    rule_url = _rule_url(item_id, "playbook", real_id, source_kind)
     bullet = f"- [cs:{item_id}] {content}"
     if trigger:
         bullet += f" _(when: {trigger})_"
@@ -407,7 +423,7 @@ def _format_profiles(
         item_id = cs_cite.rank_id("profile", rank, real_id)
         title = _title_from_content(content)
         dashboard_url = _dashboard_url("profile", real_id)
-        rule_url = _rule_url(item_id, "profile")
+        rule_url = _rule_url(item_id, "profile", real_id)
         bullet = f"- [cs:{item_id}] {content}"
         if rule_url:
             bullet += f" _(open: {rule_url})_"
@@ -427,7 +443,7 @@ def _format_profiles(
 
 
 def _dashboard_url(kind: str, real_id: Any, source_kind: str | None = None) -> str:
-    remote_url = _remote_reflexio_page_url(kind)
+    remote_url = _remote_reflexio_item_url(kind, real_id, source_kind)
     if remote_url:
         return remote_url
     if real_id is None:
@@ -442,8 +458,10 @@ def _dashboard_url(kind: str, real_id: Any, source_kind: str | None = None) -> s
     return ""
 
 
-def _rule_url(item_id: str, kind: str) -> str:
-    remote_url = _remote_reflexio_page_url(kind)
+def _rule_url(
+    item_id: str, kind: str, real_id: Any = None, source_kind: str | None = None
+) -> str:
+    remote_url = _remote_reflexio_item_url(kind, real_id, source_kind)
     if remote_url:
         return remote_url
     if not item_id:
@@ -453,6 +471,27 @@ def _rule_url(item_id: str, kind: str) -> str:
     return f"{base}/rules/{encoded_id}"
 
 
+def _remote_reflexio_item_url(
+    kind: str, real_id: Any, source_kind: str | None = None
+) -> str:
+    origin = _remote_reflexio_origin()
+    if not origin:
+        return ""
+    if real_id is None:
+        return _remote_reflexio_page_url(kind)
+    encoded_id = quote(str(real_id), safe="")
+    if kind == "profile":
+        return f"{origin}/profiles?profile_id={encoded_id}"
+    if kind == "playbook":
+        if source_kind == "user_playbook":
+            return (
+                f"{origin}/playbooks?resource=user_playbook&"
+                f"user_playbook_id={encoded_id}"
+            )
+        return f"{origin}/playbooks?agent_playbook_id={encoded_id}"
+    return ""
+
+
 def _remote_reflexio_page_url(kind: str) -> str:
     origin = _remote_reflexio_origin()
     if not origin:
@@ -504,6 +543,12 @@ def _osc8_link(url: str, label: str) -> str:
     return f"\x1b]8;;{url}\x1b\\{label}\x1b]8;;\x1b\\"
 
 
+def _markdown_link(url: str, label: str) -> str:
+    safe_label = label.replace("[", "\\[").replace("]", "\\]")
+    safe_url = url.replace(")", "%29")
+    return f"[{safe_label}]({safe_url})"
+
+
 def _strip_trailing_sentence_punctuation(text: str) -> str:
     return text.rstrip().rstrip(".!?")
 

package/plugin/src/claude_smart/cs_cite.py

@@ -39,7 +39,7 @@ from __future__ import annotations
 
 import re
 from typing import Any
-from urllib.parse import unquote, urlparse
+from urllib.parse import parse_qs, unquote, urlparse
 
 _FINGERPRINT_LEN = 4
 
@@ -287,6 +287,17 @@ def dashboard_url_token(url: str) -> str:
     parsed = urlparse(url)
     path = parsed.path if parsed.scheme else url.split("?", 1)[0].split("#", 1)[0]
     parts = [unquote(part) for part in path.strip("/").split("/") if part]
+    query = parse_qs(parsed.query)
+    if len(parts) == 1 and parts[0] == "profiles":
+        profile_ids = query.get("profile_id") or []
+        return f"route:profile:profile:{profile_ids[0]}" if profile_ids else ""
+    if len(parts) == 1 and parts[0] == "playbooks":
+        user_playbook_ids = query.get("user_playbook_id") or []
+        if query.get("resource") == ["user_playbook"] and user_playbook_ids:
+            return f"route:playbook:user_playbook:{user_playbook_ids[0]}"
+        agent_playbook_ids = query.get("agent_playbook_id") or []
+        if agent_playbook_ids:
+            return f"route:playbook:agent_playbook:{agent_playbook_ids[0]}"
     if len(parts) == 3 and parts[0] == "skills" and parts[1] in {"project", "shared"}:
         source_kind = "user_playbook" if parts[1] == "project" else "agent_playbook"
         return f"route:playbook:{source_kind}:{parts[2]}"

package/plugin/src/claude_smart/env_config.py

@@ -10,6 +10,27 @@ MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/"
 REFLEXIO_URL_ENV = "REFLEXIO_URL"
 REFLEXIO_API_KEY_ENV = "REFLEXIO_API_KEY"
 CLAUDE_SMART_READ_ONLY_ENV = "CLAUDE_SMART_READ_ONLY"
+CLAUDE_SMART_USE_LOCAL_CLI_ENV = "CLAUDE_SMART_USE_LOCAL_CLI"
+CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
+
+_LOCAL_DEFAULT_ENTRIES = (
+    (
+        "# Route reflexio generation through the local Claude Code CLI",
+        CLAUDE_SMART_USE_LOCAL_CLI_ENV,
+        "1",
+    ),
+    (
+        "# Use the in-process ONNX embedder (chromadb) - no API key for semantic search",
+        CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV,
+        "1",
+    ),
+    (None, CLAUDE_SMART_READ_ONLY_ENV, "0"),
+)
+_LOCAL_MODE_PRUNE_KEYS = {
+    REFLEXIO_URL_ENV,
+    REFLEXIO_API_KEY_ENV,
+    "REFLEXIO_USER_ID",
+}
 
 
 def parse_env_line(line: str) -> tuple[str, str] | None:
@@ -89,6 +110,59 @@ def set_env_vars(path: Path, values: dict[str, str]) -> list[str]:
     return added
 
 
+def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
+    """Create or augment ``~/.reflexio/.env`` for claude-smart local mode.
+
+    Existing active assignments win. This repairs first installs and deleted
+    env files without clobbering explicit user overrides such as
+    ``CLAUDE_SMART_READ_ONLY=1``.
+    """
+    path = path or REFLEXIO_ENV_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        existing = path.read_text()
+    except OSError:
+        existing = ""
+
+    present: set[str] = set()
+    kept_lines: list[str] = []
+    pruned = False
+    for line in existing.splitlines():
+        parsed = parse_env_line(line)
+        if parsed is not None:
+            key, _value = parsed
+            if key in _LOCAL_MODE_PRUNE_KEYS:
+                pruned = True
+                continue
+            present.add(key)
+        kept_lines.append(line)
+
+    additions: list[str] = []
+    added_keys: list[str] = []
+    for comment, key, value in _LOCAL_DEFAULT_ENTRIES:
+        if key in present:
+            continue
+        if comment:
+            additions.append(comment)
+        if key == CLAUDE_SMART_READ_ONLY_ENV:
+            additions.append(f'{key}="{_escape_env_value(value)}"')
+        else:
+            additions.append(f"{key}={_escape_env_value(value)}")
+        added_keys.append(key)
+
+    if additions or pruned:
+        content = "\n".join(kept_lines)
+        if additions:
+            prefix = "" if not content or content.endswith("\n") else "\n"
+            content = content + prefix + "\n".join(additions)
+        content = content + ("\n" if content else "")
+        path.write_text(content, encoding="utf-8")
+    elif not path.exists():
+        path.touch()
+    path.chmod(0o600)
+    return added_keys
+
+
 def env_truthy(name: str) -> bool:
     """Return True when an environment flag is explicitly enabled."""
     return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}

package/plugin/uv.lock

@@ -419,12 +419,13 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.39"
+version = "0.2.41"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },
     { name = "einops" },
     { name = "reflexio-ai" },
+    { name = "sqlite-vec" },
 ]
 
 [package.dev-dependencies]
@@ -437,6 +438,7 @@ requires-dist = [
     { name = "chromadb", specifier = ">=0.5" },
     { name = "einops", specifier = ">=0.8.0" },
     { name = "reflexio-ai", specifier = ">=0.2.23" },
+    { name = "sqlite-vec", specifier = ">=0.1.6" },
 ]
 
 [package.metadata.requires-dev]
@@ -3107,6 +3109,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
+[[package]]
+name = "sqlite-vec"
+version = "0.1.9"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/85/9fad0045d8e7c8df3e0fa5a56c630e8e15ad6e5ca2e6106fceb666aa6638/sqlite_vec-0.1.9-py3-none-macosx_10_6_x86_64.whl", hash = "sha256:1b62a7f0a060d9475575d4e599bbf94a13d85af896bc1ce86ee80d1b5b48e5fb", size = 131171, upload-time = "2026-03-31T08:02:31.717Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/3d/3677e0cd2f92e5ebc43cd29fbf565b75582bff1ccfa0b8327c7508e1084f/sqlite_vec-0.1.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d52e30513bae4cc9778ddbf6145610434081be4c3afe57cd877893bad9f6b6c", size = 165434, upload-time = "2026-03-31T08:02:32.712Z" },
+    { url = "https://files.pythonhosted.org/packages/00/d4/f2b936d3bdc38eadcbd2a87875815db36430fab0363182ba5d12cd8e0b51/sqlite_vec-0.1.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e921e592f24a5f9a18f590b6ddd530eb637e2d474e3b1972f9bbeb773aa3cb9", size = 160076, upload-time = "2026-03-31T08:02:33.796Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ad/6afd073b0f817b3e03f9e37ad626ae341805891f23c74b5292818f49ac63/sqlite_vec-0.1.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux1_x86_64.whl", hash = "sha256:1515727990b49e79bcaf75fdee2ffc7d461f8b66905013231251f1c8938e7786", size = 163388, upload-time = "2026-03-31T08:02:34.888Z" },
+    { url = "https://files.pythonhosted.org/packages/42/89/81b2907cda14e566b9bf215e2ad82fc9b349edf07d2010756ffdb902f328/sqlite_vec-0.1.9-py3-none-win_amd64.whl", hash = "sha256:4a28dc12fa4b53d7b1dced22da2488fade444e96b5d16fd2d698cd670675cf32", size = 292804, upload-time = "2026-03-31T08:02:36.035Z" },
+]
+
 [[package]]
 name = "sseclient-py"
 version = "1.9.0"

package/scripts/setup-claude-smart.sh

@@ -106,6 +106,34 @@ append_env_value() {
   chmod 600 "$REFLEXIO_ENV"
 }
 
+append_env_raw() {
+  local key value
+  key="$1"
+  value="$2"
+  mkdir -p "$(dirname "$REFLEXIO_ENV")"
+  touch "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+  printf '%s=%s\n' "$key" "$value" >> "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+}
+
+ensure_local_env_defaults() {
+  mkdir -p "$(dirname "$REFLEXIO_ENV")"
+  touch "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+  if ! get_env_value CLAUDE_SMART_USE_LOCAL_CLI >/dev/null 2>&1; then
+    printf '# Route reflexio generation through the local Claude Code CLI\n' >> "$REFLEXIO_ENV"
+    append_env_raw CLAUDE_SMART_USE_LOCAL_CLI "1"
+  fi
+  if ! get_env_value CLAUDE_SMART_USE_LOCAL_EMBEDDING >/dev/null 2>&1; then
+    printf '# Use the in-process ONNX embedder (chromadb) - no API key for semantic search\n' >> "$REFLEXIO_ENV"
+    append_env_raw CLAUDE_SMART_USE_LOCAL_EMBEDDING "1"
+  fi
+  if ! get_env_value CLAUDE_SMART_READ_ONLY >/dev/null 2>&1; then
+    append_env_value CLAUDE_SMART_READ_ONLY "0"
+  fi
+}
+
 mask_secret() {
   local value len suffix
   value="$1"
@@ -283,11 +311,11 @@ main() {
 
   if [ "$mode" = "local" ]; then
     if [ -f "$REFLEXIO_ENV" ]; then
-      remove_env_keys
+      remove_env_keys REFLEXIO_API_KEY REFLEXIO_URL REFLEXIO_USER_ID
       log "removed managed Reflexio settings from $REFLEXIO_ENV"
-    else
-      log "local mode selected; no $REFLEXIO_ENV exists, so no env file was created"
     fi
+    ensure_local_env_defaults
+    log "configured local Reflexio defaults in $REFLEXIO_ENV"
     install_for_host "$host"
     return 0
   fi