claude-smart 0.2.39 → 0.2.40

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.40-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(),

package/package.json

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

package/plugin/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-smart"
-version = "0.2.39"
+version = "0.2.40"
 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/codex-hook.js

@@ -535,7 +535,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/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"

package/plugin/scripts/smart-install.sh

@@ -106,6 +106,12 @@ 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
@@ -491,6 +497,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

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.40"
 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