claude-smart 0.2.44 → 0.2.46

package/plugin/scripts/_lib.sh

@@ -3,11 +3,53 @@
 # Claude Code hooks run with a minimal non-interactive PATH that often omits
 # nvm/asdf/brew shims where `npm`, `uv`, etc. live. Pull the user's login-shell
 # PATH the same way claude-mem does so hook-spawned scripts find them without
-# the user having to mutate their global PATH. Best-effort — failures silent.
+# the user having to mutate their global PATH. Best-effort and bounded: shell
+# profile startup can be slow or stuck on Windows, so this must never outlive a
+# hook's timeout budget.
+claude_smart_login_path_timeout_seconds() {
+  local _VALUE
+  _VALUE="${CLAUDE_SMART_LOGIN_PATH_TIMEOUT_SECONDS:-2}"
+  case "$_VALUE" in
+    ''|*[!0-9]*) printf '%s\n' "2" ;;
+    *) printf '%s\n' "$_VALUE" ;;
+  esac
+}
+
+claude_smart_capture_login_path() {
+  local _TIMEOUT _TMP _PID _WAITED _LINE
+  _TIMEOUT="$(claude_smart_login_path_timeout_seconds)"
+  [ "$_TIMEOUT" -gt 0 ] || return 1
+
+  _TMP="${TMPDIR:-/tmp}/claude-smart-login-path.$$"
+  rm -f "$_TMP" 2>/dev/null || true
+  "$SHELL" -lc 'printf %s "$PATH"' >"$_TMP" 2>/dev/null &
+  _PID=$!
+  _WAITED=0
+  while kill -0 "$_PID" 2>/dev/null; do
+    if [ "$_WAITED" -ge "$_TIMEOUT" ]; then
+      kill "$_PID" 2>/dev/null || true
+      wait "$_PID" 2>/dev/null || true
+      rm -f "$_TMP" 2>/dev/null || true
+      return 1
+    fi
+    sleep 1
+    _WAITED=$((_WAITED + 1))
+  done
+  if wait "$_PID" 2>/dev/null; then
+    while IFS= read -r _LINE || [ -n "$_LINE" ]; do
+      printf '%s' "$_LINE"
+    done <"$_TMP"
+    rm -f "$_TMP" 2>/dev/null || true
+    return 0
+  fi
+  rm -f "$_TMP" 2>/dev/null || true
+  return 1
+}
+
 claude_smart_source_login_path() {
   local _SHELL_PATH
   if [ -n "${SHELL:-}" ] && [ -x "$SHELL" ]; then
-    if _SHELL_PATH="$("$SHELL" -lc 'printf %s "$PATH"' 2>/dev/null)"; then
+    if _SHELL_PATH="$(claude_smart_capture_login_path)"; then
       [ -n "$_SHELL_PATH" ] && export PATH="$_SHELL_PATH:$PATH"
     fi
   fi
@@ -45,8 +87,12 @@ claude_smart_env_unquote() {
 }
 
 claude_smart_source_reflexio_env() {
+  # claude-smart's env lives at ~/.claude-smart/.env (kept separate from the OSS
+  # reflexio default ~/.reflexio/.env). Stays in sync with
+  # env_config.REFLEXIO_ENV_PATH and the REFLEXIO_ENV_FILE export in
+  # backend-service.sh.
   local env_file line key value
-  env_file="$HOME/.reflexio/.env"
+  env_file="$HOME/.claude-smart/.env"
   [ -f "$env_file" ] || return 0
   while IFS= read -r line || [ -n "$line" ]; do
     line="${line#"${line%%[![:space:]]*}"}"
@@ -116,30 +162,24 @@ claude_smart_dashboard_unavailable_marker() {
 }
 
 claude_smart_node_recovery_hint() {
-  cat <<'EOF'
-Recovery:
-  1. Restart Claude Code to let claude-smart retry its private Node.js install.
-  2. If the retry is blocked by your network or OS policy, install Node.js 20.9+ manually:
-EOF
+  printf '%s\n' \
+    "Recovery:" \
+    "  1. Restart Claude Code to let claude-smart retry its private Node.js install." \
+    "  2. If the retry is blocked by your network or OS policy, install Node.js 20.9+ manually:"
   if claude_smart_is_windows; then
-    cat <<'EOF'
-     - winget install OpenJS.NodeJS.LTS
-     - or download the LTS installer from https://nodejs.org/
-EOF
+    printf '%s\n' \
+      "     - winget install OpenJS.NodeJS.LTS" \
+      "     - or download the LTS installer from https://nodejs.org/"
   elif [ "$(uname -s 2>/dev/null)" = "Darwin" ]; then
-    cat <<'EOF'
-     - brew install node
-     - or download the LTS installer from https://nodejs.org/
-EOF
+    printf '%s\n' \
+      "     - brew install node" \
+      "     - or download the LTS installer from https://nodejs.org/"
   else
-    cat <<'EOF'
-     - use your distro package manager for nodejs/npm
-     - or download the LTS archive from https://nodejs.org/
-EOF
+    printf '%s\n' \
+      "     - use your distro package manager for nodejs/npm" \
+      "     - or download the LTS archive from https://nodejs.org/"
   fi
-  cat <<'EOF'
-  3. Run /claude-smart:restart, then /claude-smart:dashboard.
-EOF
+  printf '%s\n' "  3. Run /claude-smart:restart, then /claude-smart:dashboard."
 }
 
 claude_smart_write_dashboard_unavailable() {
@@ -527,14 +567,22 @@ claude_smart_append_capped_log() {
 # POSIX: setsid → python3 os.setsid → nohup (in that order of strength).
 # Windows: nohup alone — Git Bash has no setsid, no process groups, and
 # `os.setsid()` is POSIX-only; nohup ignores SIGHUP which is enough to
-# survive the parent console closing. The python3 fallback is gated on a
-# real-interpreter probe (-V) so the Windows App Execution Alias stub
-# doesn't get invoked. Caller is responsible for redirecting stdout/stderr;
-# we do not impose a log destination here. Stdin is closed so the child
-# cannot inherit a tty. Use `$!` after this call to capture the pid.
+# survive the parent console closing. On Windows, stdout/stderr are also
+# closed here so hook-runner pipes cannot be kept alive by long-lived
+# background children after the hook script exits unless the caller explicitly
+# opts into preserving stdout/stderr for a file redirection. The python3
+# fallback is gated on a real-interpreter probe (-V) so the Windows App
+# Execution Alias stub doesn't get invoked. POSIX callers are responsible for
+# redirecting stdout/stderr; we do not impose a log destination there. Stdin is
+# closed so the child cannot inherit a tty. Use `$!` after this call to capture
+# the pid.
 claude_smart_spawn_detached() {
   if claude_smart_is_windows; then
-    nohup "$@" < /dev/null &
+    if [ "${CLAUDE_SMART_SPAWN_KEEP_OUTPUT:-}" = "1" ]; then
+      nohup "$@" < /dev/null &
+    else
+      nohup "$@" < /dev/null > /dev/null 2>&1 &
+    fi
     return 0
   fi
   if command -v setsid >/dev/null 2>&1; then

package/plugin/scripts/backend-service.sh

@@ -20,11 +20,13 @@ set -eu
 HERE="$(cd "$(dirname "$0")" && pwd)"
 # shellcheck source=_lib.sh
 . "$HERE/_lib.sh"
-claude_smart_source_login_path
+CMD="${1:-start}"
+if [ "$CMD" != "session-end" ]; then
+  claude_smart_source_login_path
+fi
 claude_smart_prepend_astral_bins
 claude_smart_source_reflexio_env
 
-CMD="${1:-start}"
 PORT=8071
 EMBEDDING_PORT="${EMBEDDING_PORT:-8072}"
 # Pass through to `reflexio services start/stop` so the spawned backend
@@ -32,6 +34,21 @@ EMBEDDING_PORT="${EMBEDDING_PORT:-8072}"
 export BACKEND_PORT="$PORT"
 export EMBEDDING_PORT
 
+# Run claude-smart's backend under its own org id. The reflexio no-auth resolver
+# reads REFLEXIO_DEFAULT_ORG_ID, which scopes the request org -> config file
+# name (config_<org>.json) and SQLite data. Hard-set (not :-defaulted) so a
+# value in the shared ~/.reflexio/.env can't drag claude-smart back onto
+# "self-host-org" and collide with the enterprise self-host backend over
+# config_self-host-org.json. Must stay in sync with cli.py's config path.
+export REFLEXIO_DEFAULT_ORG_ID="claude-smart"
+
+# Load claude-smart's env from ~/.claude-smart/.env instead of the reflexio
+# default ~/.reflexio/.env, so an OSS reflexio backend's .env on this machine
+# can't leak in. The data dir is independent (LOCAL_STORAGE_PATH), so both still
+# share ~/.reflexio/data. Must stay in sync with env_config.REFLEXIO_ENV_PATH and
+# the source path in _lib.sh (claude_smart_source_reflexio_env).
+export REFLEXIO_ENV_FILE="$HOME/.claude-smart/.env"
+
 # 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.
@@ -48,7 +65,12 @@ PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "backend-service.sh" "$@"
 
 if [ -z "${CLAUDE_SMART_CLI_PATH:-}" ]; then
-  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
+  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "opencode" ] && command -v opencode >/dev/null 2>&1; then
+    # Preserve Reflexio's Claude CLI provider contract while routing
+    # generation through the user's authenticated OpenCode setup.
+    claude_smart_prepend_node_bins
+    export CLAUDE_SMART_CLI_PATH="$PLUGIN_ROOT/scripts/opencode-claude-compat"
+  elif [ "${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`.
@@ -262,7 +284,7 @@ case "$CMD" in
     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; starting installer in background"
-        claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+        CLAUDE_SMART_SPAWN_KEEP_OUTPUT=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
@@ -284,7 +306,7 @@ case "$CMD" in
     # Keep plugin runtime data in ~/.reflexio even when the backend imports
     # Reflexio from an editable checkout inside a larger repo with its own
     # .env. python-dotenv respects pre-existing env vars, so this prevents a
-    # parent REFLEXIO_LOG_DIR from sending claude-smart to enterprise configs.
+    # parent REFLEXIO_LOG_DIR from sending claude-smart to unrelated configs.
     export REFLEXIO_LOG_DIR="${REFLEXIO_LOG_DIR:-$HOME}"
 
     # Force sqlite: the plugin venv ships only the open-source reflexio

package/plugin/scripts/dashboard-service.sh

@@ -21,11 +21,13 @@ set -eu
 HERE="$(cd "$(dirname "$0")" && pwd)"
 # shellcheck source=_lib.sh
 . "$HERE/_lib.sh"
-claude_smart_source_login_path
+CMD="${1:-start}"
+if [ "$CMD" != "session-end" ]; then
+  claude_smart_source_login_path
+fi
 claude_smart_prepend_node_bins
 claude_smart_source_reflexio_env
 
-CMD="${1:-start}"
 PORT=3001
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
@@ -192,7 +194,7 @@ case "$CMD" in
     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; starting installer in background" >>"$LOG_FILE"
-        claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+        CLAUDE_SMART_SPAWN_KEEP_OUTPUT=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
@@ -214,7 +216,7 @@ case "$CMD" in
       BUILD_PID_FILE="$STATE_DIR/dashboard-build.pid"
       if ! claude_smart_pid_alive_file "$BUILD_PID_FILE"; then
         echo "[claude-smart] dashboard: .next missing — starting background build (~1-2 min)" >>"$LOG_FILE"
-        claude_smart_spawn_detached bash "$HERE/dashboard-build.sh" >>"$LOG_FILE" 2>&1
+        CLAUDE_SMART_SPAWN_KEEP_OUTPUT=1 claude_smart_spawn_detached bash "$HERE/dashboard-build.sh" >>"$LOG_FILE" 2>&1
       fi
       emit_ok; exit 0
     fi
@@ -229,7 +231,7 @@ case "$CMD" in
     # Caller-side `>>file 2>&1` redirection is honoured before the child
     # detaches, so per-OS log paths stay identical.
     export CLAUDE_SMART_DASHBOARD_WORKSPACE="$WORKSPACE_CWD"
-    claude_smart_spawn_detached "$NPM_BIN" run start >>"$LOG_FILE" 2>&1
+    CLAUDE_SMART_SPAWN_KEEP_OUTPUT=1 claude_smart_spawn_detached "$NPM_BIN" run start >>"$LOG_FILE" 2>&1
     dash_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/ensure-plugin-root.sh

@@ -32,12 +32,12 @@ if [ "$FORCE" = "--force" ]; then
 fi
 
 # Opt-in: when CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=1 (set in the
-# environment or in ~/.reflexio/.env), always relink to $TARGET so the
+# environment or in ~/.claude-smart/.env), always relink to $TARGET so the
 # symlink tracks the currently loaded plugin.
 FOLLOW="${CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION:-}"
-if [ -z "$FOLLOW" ] && [ -f "$HOME/.reflexio/.env" ]; then
-    FOLLOW="$(grep -E '^CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.reflexio/.env" \
-        | tail -n1 | cut -d= -f2-)"
+if [ -z "$FOLLOW" ] && [ -f "$HOME/.claude-smart/.env" ]; then
+    FOLLOW="$(grep -E '^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.claude-smart/.env" \
+        | tail -n1 | sed -E 's/^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=//')"
     # Strip a single pair of surrounding double or single quotes, if present.
     FOLLOW="${FOLLOW#\"}"; FOLLOW="${FOLLOW%\"}"
     FOLLOW="${FOLLOW#\'}"; FOLLOW="${FOLLOW%\'}"

package/plugin/scripts/hook_entry.sh

@@ -15,7 +15,7 @@ set -eu
 HOST="claude-code"
 EVENT="${1:-}"
 case "$EVENT" in
-  claude-code|codex)
+  claude-code|codex|opencode)
     HOST="$EVENT"
     EVENT="${2:-}"
     ;;
@@ -96,7 +96,7 @@ if ! command -v uv >/dev/null 2>&1; then
   fi
   if [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
     mkdir -p "$STATE_DIR"
-    claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
+    CLAUDE_SMART_SPAWN_KEEP_OUTPUT=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
@@ -123,7 +123,7 @@ ensure_hook_package_importable() {
     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 \
+  CLAUDE_SMART_SPAWN_KEEP_OUTPUT=1 claude_smart_spawn_detached env CLAUDE_SMART_BOOTSTRAPPING=1 \
     bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
     >>"$STATE_DIR/install.log" 2>&1 || true
 

package/plugin/scripts/opencode-claude-compat

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)/"
+exec node "$SCRIPT_DIR/opencode-claude-compat.js" "$@"

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

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

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

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+"use strict";
+
+/*
+ * Translate Reflexio's Claude CLI provider contract to `opencode run`.
+ *
+ * Reflexio shells out to CLAUDE_SMART_CLI_PATH as if it were Claude Code:
+ *
+ *   <path> -p --output-format stream-json --model <model> ...
+ *
+ * Under OpenCode, this bridge preserves that executable contract while routing
+ * generation through the user's authenticated OpenCode CLI/provider setup.
+ */
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const AGENT_NAME = "claude-smart-extractor";
+
+function main(argv) {
+  let workDir = null;
+  try {
+    const { outputFormat, systemPrompt, model } = parseSupportedArgs(argv);
+    const prompt = fs.readFileSync(0, "utf8");
+    workDir = prepareWorkDir();
+    const content = runOpenCode({
+      prompt: combinedPrompt({ prompt, systemPrompt }),
+      model,
+      workDir,
+    });
+    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(`opencode-claude-compat: ${message}\n`);
+    return 1;
+  } finally {
+    if (workDir) {
+      try {
+        fs.rmSync(workDir, { recursive: true, force: true });
+      } catch {
+        // Best effort cleanup only.
+      }
+    }
+  }
+}
+
+function parseSupportedArgs(argv) {
+  let outputFormat = "json";
+  let systemPrompt = "";
+  let model = "";
+  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") {
+      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, model };
+}
+
+function requireValue(argv, idx, name) {
+  if (idx + 1 >= argv.length) {
+    throw new Error(`${name} requires a value`);
+  }
+  return argv[idx + 1];
+}
+
+function prepareWorkDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-smart-opencode-"));
+  const config = {
+    agent: {
+      [AGENT_NAME]: {
+        description: "Internal claude-smart learning extraction",
+        prompt:
+          "You are running as an internal claude-smart extraction subprocess. " +
+          "Return only the requested text or JSON. Do not use tools, edit files, " +
+          "search the workspace, or ask follow-up questions.",
+        steps: 2,
+        permission: "deny",
+      },
+    },
+  };
+  const opencodeDir = path.join(dir, ".opencode");
+  fs.mkdirSync(opencodeDir, { recursive: true });
+  fs.writeFileSync(path.join(opencodeDir, "opencode.json"), `${JSON.stringify(config, null, 2)}\n`);
+  return dir;
+}
+
+function runOpenCode({ prompt, model, workDir }) {
+  const opencodePath = process.env.CLAUDE_SMART_OPENCODE_PATH || commandPath(opencodeNames());
+  if (!opencodePath) {
+    throw new Error("opencode CLI not found on PATH");
+  }
+
+  const args = [
+    "run",
+    "--pure",
+    "--format",
+    "json",
+    "--agent",
+    AGENT_NAME,
+    "--dir",
+    workDir,
+  ];
+  const selectedModel = opencodeModel(model);
+  if (selectedModel) {
+    args.push("--model", selectedModel);
+  }
+  const variant = (process.env.CLAUDE_SMART_OPENCODE_VARIANT || "").trim();
+  if (variant) {
+    args.push("--variant", variant);
+  }
+
+  const proc = spawnSync(opencodePath, args, {
+    input: prompt,
+    cwd: workDir,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      CLAUDE_SMART_HOST: "opencode",
+      CLAUDE_SMART_INTERNAL: "1",
+      CLAUDE_CODE_ENTRYPOINT: "optimizer",
+    },
+    timeout: timeoutMs(),
+    windowsHide: true,
+    shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(opencodePath),
+  });
+  if (proc.error) {
+    if (proc.error.code === "ETIMEDOUT") {
+      throw new Error(`opencode CLI timed out after ${timeoutMs() / 1000}s`);
+    }
+    throw proc.error;
+  }
+  if (proc.status !== 0) {
+    const stderr = String(proc.stderr || "").trim().slice(0, 500);
+    throw new Error(`opencode CLI exited ${proc.status}: ${stderr}`);
+  }
+  const content = parseOpenCodeJson(proc.stdout);
+  if (!content) {
+    throw new Error("opencode CLI returned empty output");
+  }
+  return content;
+}
+
+function opencodeModel(modelFromArgs) {
+  const explicit = (process.env.CLAUDE_SMART_OPENCODE_MODEL || "").trim();
+  if (explicit) return explicit;
+  const candidate = (modelFromArgs || "").trim();
+  return candidate.includes("/") ? candidate : "";
+}
+
+function parseOpenCodeJson(stdout) {
+  const chunks = [];
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const part = event && typeof event === "object" ? event.part : null;
+    if (part && part.type === "text" && typeof part.text === "string") {
+      chunks.push(part.text);
+    } else if (event.type === "text" && typeof event.text === "string") {
+      chunks.push(event.text);
+    } else if (event.type === "result" && typeof event.result === "string") {
+      chunks.push(event.result);
+    }
+  }
+  return chunks.join("").trim();
+}
+
+function timeoutMs() {
+  const raw = Number(process.env.CLAUDE_SMART_CLI_TIMEOUT || "");
+  if (Number.isFinite(raw) && raw > 0) return raw * 1000;
+  return DEFAULT_TIMEOUT_MS;
+}
+
+function opencodeNames() {
+  return process.platform === "win32" ? ["opencode.cmd", "opencode.exe", "opencode"] : ["opencode"];
+}
+
+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 combinedPrompt({ prompt, systemPrompt }) {
+  if (!systemPrompt) return prompt;
+  return `${systemPrompt}\n\n## Task\n${prompt}`;
+}
+
+process.exitCode = main(process.argv.slice(2));

package/plugin/scripts/smart-install.sh

@@ -108,10 +108,10 @@ install_complete() {
   [ -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
+    [ -f "$HOME/.claude-smart/.env" ] || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.claude-smart/.env" || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.claude-smart/.env" || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_READ_ONLY=' "$HOME/.claude-smart/.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
@@ -480,10 +480,12 @@ if ! claude_smart_python_imports "$PLUGIN_ROOT" claude_smart.hook; then
   write_failure "claude-smart package is not importable after vendored Reflexio install in $PLUGIN_ROOT/.venv"
 fi
 
-# Reflexio's CLI reads ~/.reflexio/.env (see reflexio/cli/env_loader.py);
-# append our two opt-in flags there so `reflexio services start` picks
-# them up regardless of which directory the user runs it from.
-REFLEXIO_ENV="$HOME/.reflexio/.env"
+# claude-smart's backend loads ~/.claude-smart/.env (backend-service.sh exports
+# REFLEXIO_ENV_FILE so reflexio's CLI reads it instead of ~/.reflexio/.env);
+# append our opt-in flags there so `reflexio services start` picks them up. Keep
+# this path in sync with env_config.REFLEXIO_ENV_PATH and backend-service.sh.
+REFLEXIO_ENV="$HOME/.claude-smart/.env"
+mkdir -p "$(dirname "$REFLEXIO_ENV")"
 claude_smart_env_quote() {
   printf '%s' "$1" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
 }

package/plugin/src/README.md

@@ -28,7 +28,7 @@ Description: Python package powering the claude-smart plugin — hook handlers t
 
 | File | Purpose |
 |------|---------|
-| `env_config.py` | Parses `~/.reflexio/.env` (`REFLEXIO_URL`, `REFLEXIO_API_KEY`, `CLAUDE_SMART_READ_ONLY`, local embedding/CLI flags). |
+| `env_config.py` | Parses `~/.claude-smart/.env` (`REFLEXIO_URL`, `REFLEXIO_API_KEY`, `CLAUDE_SMART_READ_ONLY`, local embedding/CLI flags). |
 | `runtime.py` | Host detection (Claude Code vs Codex); shared agent version. |
 | `ids.py` | Session / project ID generation and resolution. |
 | `context_inject.py`, `context_format.py`, `query_compose.py`, `cs_cite.py` | Build search queries, format learned skills as markdown, inject into context, format citations. |