claude-smart 0.2.36 → 0.2.37

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.36-green.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-0.2.37-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">
@@ -81,9 +81,6 @@ Four things this changes:
 npx claude-smart install     # or: uvx claude-smart install
 ```
 
-Use `--read-only` to install context-loading hooks without the hooks that
-publish interactions for learning.
-
 Then restart Claude Code.
 
 Requires Node.js (for `npx`) or uv (for `uvx`) to already exist.
@@ -113,8 +110,6 @@ claude plugin uninstall claude-smart@reflexioai
 npx claude-smart install --host codex
 ```
 
-Add `--read-only` to skip the publish interactions hook.
-
 Then fully quit and reopen Codex so hooks reload.
 
 Requires the `codex` CLI on `PATH` and Node.js (for `npx`).

package/bin/claude-smart.js

@@ -5,7 +5,9 @@
  * plugin. For Codex it copies the bundled local marketplace, registers it,
  * and enables plugin hooks. Both paths seed ~/.reflexio/.env with the two
  * local-provider flags so reflexio can route generation through local tools
- * with no API key.
+ * with no API key. Managed/read-only/global setup is handled by
+ * `npx claude-smart setup`, which writes ~/.reflexio/.env before running this
+ * installer.
  *
  * Keep this file dependency-free — it runs via `npx` with no install step.
  */
@@ -14,8 +16,6 @@
 const { execSync, spawn, spawnSync } = require("child_process");
 const crypto = require("crypto");
 const {
-  appendFileSync,
-  chmodSync,
   cpSync,
   existsSync,
   lstatSync,
@@ -41,6 +41,7 @@ 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 REFLEXIO_USER_ID_ENV = "REFLEXIO_USER_ID";
 const REFLEXIO_DIR = join(homedir(), ".reflexio");
 const CLAUDE_SMART_STATE_DIR = join(homedir(), ".claude-smart");
 const CODEX_CONFIG_PATH = join(homedir(), ".codex", "config.toml");
@@ -196,28 +197,6 @@ function runCodex(args) {
   });
 }
 
-function seedReflexioEnv() {
-  mkdirSync(dirname(REFLEXIO_ENV_PATH), { recursive: true });
-  const existing = existsSync(REFLEXIO_ENV_PATH)
-    ? readFileSync(REFLEXIO_ENV_PATH, "utf8")
-    : "";
-  const flags = [
-    "CLAUDE_SMART_USE_LOCAL_CLI",
-    "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
-  ];
-  const missing = flags.filter((f) => !new RegExp(`^${f}=`, "m").test(existing));
-  if (missing.length === 0) return [];
-  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-  const body = missing.map((f) => `${f}=1`).join("\n") + "\n";
-  appendFileSync(REFLEXIO_ENV_PATH, prefix + body);
-  chmodSync(REFLEXIO_ENV_PATH, 0o600);
-  return missing;
-}
-
-function escapeEnvValue(value) {
-  return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-
 function parseEnvLine(line) {
   let trimmed = String(line || "").trim();
   if (!trimmed || trimmed.startsWith("#")) return null;
@@ -226,36 +205,15 @@ function parseEnvLine(line) {
   if (eq < 0) return null;
   const key = trimmed.slice(0, eq).trim();
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return null;
-  return { key };
-}
-
-function setReflexioEnvVars(values) {
-  mkdirSync(dirname(REFLEXIO_ENV_PATH), { recursive: true });
-  const existing = existsSync(REFLEXIO_ENV_PATH)
-    ? readFileSync(REFLEXIO_ENV_PATH, "utf8")
-    : "";
-  const lines = existing ? existing.split(/\r?\n/) : [];
-  const seen = new Set();
-  const out = [];
-  for (const line of lines) {
-    const parsed = parseEnvLine(line);
-    if (parsed && Object.prototype.hasOwnProperty.call(values, parsed.key)) {
-      out.push(`${parsed.key}="${escapeEnvValue(values[parsed.key])}"`);
-      seen.add(parsed.key);
-    } else {
-      out.push(line);
-    }
-  }
-  const added = [];
-  for (const [key, value] of Object.entries(values)) {
-    if (seen.has(key)) continue;
-    out.push(`${key}="${escapeEnvValue(value)}"`);
-    added.push(key);
+  let value = trimmed.slice(eq + 1).trim();
+  if (
+    value.length >= 2 &&
+    ((value[0] === '"' && value[value.length - 1] === '"') ||
+      (value[0] === "'" && value[value.length - 1] === "'"))
+  ) {
+    value = value.slice(1, -1);
   }
-  const content = out.join("\n").replace(/\n*$/, "\n");
-  writeFileSync(REFLEXIO_ENV_PATH, content);
-  chmodSync(REFLEXIO_ENV_PATH, 0o600);
-  return added;
+  return { key, value };
 }
 
 function maskSecret(value) {
@@ -265,38 +223,47 @@ function maskSecret(value) {
   return `${prefix}****${value.slice(-4)}`;
 }
 
-function configureReflexioSetup(args) {
-  const apiKey = parseOptionalArg(args, "--api-key").trim();
-  const readOnly = parseReadOnly(args);
+function loadReflexioSetupEnv() {
+  let readOnlyValue = "";
+  let fileApiKey = "";
+  let fileUrl = "";
+  if (existsSync(REFLEXIO_ENV_PATH)) {
+    const text = readFileSync(REFLEXIO_ENV_PATH, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      const parsed = parseEnvLine(line);
+      if (!parsed) continue;
+      if (parsed.key === "REFLEXIO_API_KEY") {
+        fileApiKey = parsed.value;
+      } else if (parsed.key === "REFLEXIO_URL") {
+        fileUrl = parsed.value;
+      } else if (parsed.key === REFLEXIO_USER_ID_ENV) {
+        process.env[parsed.key] = parsed.value;
+      } else if (parsed.key === CLAUDE_SMART_READ_ONLY_ENV) {
+        readOnlyValue = parsed.value;
+      }
+    }
+  }
+  const apiKey = (fileApiKey || process.env.REFLEXIO_API_KEY || "").trim();
   if (apiKey) {
-    const reflexioUrl = parseOptionalArg(args, "--reflexio-url") || MANAGED_REFLEXIO_URL;
-    const values = {
-      REFLEXIO_URL: reflexioUrl,
-      REFLEXIO_API_KEY: apiKey,
-    };
-    if (readOnly) values[CLAUDE_SMART_READ_ONLY_ENV] = "1";
-    const added = setReflexioEnvVars(values);
-    const changed = added.length > 0 ? added.join(", ") : "managed Reflexio settings";
-    process.stdout.write(
-      `Configured ${REFLEXIO_ENV_PATH} for managed Reflexio (${changed}; API key ${maskSecret(apiKey)}).\n`,
-    );
-    process.env.REFLEXIO_URL = reflexioUrl;
     process.env.REFLEXIO_API_KEY = apiKey;
+    process.env.REFLEXIO_URL = (fileUrl || process.env.REFLEXIO_URL || MANAGED_REFLEXIO_URL).trim();
     process.env[MANAGED_SETUP_ENV] = "1";
-    return;
-  }
-
-  const added = seedReflexioEnv();
-  if (readOnly) {
-    added.push(
-      ...setReflexioEnvVars({
-        [CLAUDE_SMART_READ_ONLY_ENV]: "1",
-      }),
+    process.stdout.write(
+      `Using managed Reflexio at ${process.env.REFLEXIO_URL} (API key ${maskSecret(apiKey)}).\n`,
     );
+  } else {
+    delete process.env.REFLEXIO_URL;
+    delete process.env.REFLEXIO_API_KEY;
+    delete process.env[MANAGED_SETUP_ENV];
   }
-  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(),
+  );
+  return { readOnly };
+}
+
+function configureReflexioSetup() {
+  return loadReflexioSetupEnv();
 }
 
 function findClaudeCodePluginRoot() {
@@ -772,6 +739,18 @@ function prunePublishHooksForReadOnly(pluginRoot) {
   }
 }
 
+function restorePublishHooksFromSource(pluginRoot) {
+  const sourceHooksDir = join(PACKAGE_ROOT, "plugin", "hooks");
+  const targetHooksDir = join(pluginRoot, "hooks");
+  for (const hookFile of ["hooks.json", "codex-hooks.json"]) {
+    const sourcePath = join(sourceHooksDir, hookFile);
+    const targetPath = join(targetHooksDir, hookFile);
+    if (!existsSync(sourcePath) || !existsSync(targetPath)) continue;
+    if (sourcePath === targetPath) continue;
+    cpSync(sourcePath, targetPath, { force: true });
+  }
+}
+
 function patchCodexHooksForNode(pluginRoot, nodePath) {
   const hookPath = join(pluginRoot, "hooks", "codex-hooks.json");
   const parsed = JSON.parse(readFileSync(hookPath, "utf8"));
@@ -870,17 +849,14 @@ function printHelp() {
       "  npx claude-smart install                       Install the plugin into Claude Code",
       "  npx claude-smart install --host codex          Register the plugin marketplace for Codex",
       "  npx claude-smart install --source <owner/repo> Override the marketplace source",
-      "  npx claude-smart install --api-key <key>        Use managed Reflexio service",
-      "  npx claude-smart install --read-only            Install without publish interactions hooks",
+      "  npx claude-smart setup                         Configure managed/read-only/global setup",
       "  npx claude-smart uninstall --host codex        Remove the Codex marketplace registration",
       "  npx claude-smart --help                        Show this help",
       "",
       "Claude Code install:",
       "  1. claude plugin marketplace add <source>",
       `  2. claude plugin install ${PLUGIN_SPEC}`,
-      "  3. Appends CLAUDE_SMART_USE_LOCAL_CLI=1 and CLAUDE_SMART_USE_LOCAL_EMBEDDING=1",
-      "     to ~/.reflexio/.env (idempotent).",
-      "     Passing --api-key writes REFLEXIO_URL and REFLEXIO_API_KEY instead.",
+      "  3. Reads ~/.reflexio/.env when managed/read-only setup was configured.",
       "",
       "Codex install:",
       `  1. Copies the bundled marketplace to ${CODEX_MARKETPLACE_DIR}`,
@@ -893,7 +869,7 @@ function printHelp() {
       "",
       "Update:",
       "  npx claude-smart update                        Update to the latest version",
-      "  npx claude-smart update --api-key <key>        Update and configure managed Reflexio",
+      "  npx claude-smart setup                         Configure managed/read-only/global setup",
       "",
       "Uninstall:",
       "  npx claude-smart uninstall                     Remove the plugin from Claude Code",
@@ -913,17 +889,6 @@ function parseSource(args) {
   return value;
 }
 
-function parseOptionalArg(args, flag) {
-  const idx = args.indexOf(flag);
-  if (idx === -1) return "";
-  const value = args[idx + 1];
-  if (!value) {
-    process.stderr.write(`error: ${flag} requires a value\n`);
-    process.exit(1);
-  }
-  return value;
-}
-
 function parseHost(args) {
   const idx = args.indexOf("--host");
   if (idx === -1) return "claude-code";
@@ -939,10 +904,6 @@ function parseHost(args) {
   return value;
 }
 
-function parseReadOnly(args) {
-  return args.includes("--read-only");
-}
-
 function copyCodexMarketplace() {
   for (const rel of CODEX_REQUIRED_FILES) {
     const path = join(PACKAGE_ROOT, rel);
@@ -1324,6 +1285,7 @@ function installCodexPluginCache(pluginRoot) {
 }
 
 async function runUpdate(args) {
+  const setup = configureReflexioSetup();
   if (!hasClaudeCli()) {
     process.stderr.write(
       "error: 'claude' CLI not found on PATH. " +
@@ -1341,7 +1303,14 @@ async function runUpdate(args) {
   }
 
   process.stdout.write("\nclaude-smart updated. Restart Claude Code to apply.\n");
-  if (args.includes("--api-key")) configureReflexioSetup(args);
+  const pluginRoot = findClaudeCodePluginRoot();
+  if (pluginRoot) {
+    restorePublishHooksFromSource(pluginRoot);
+    if (setup.readOnly) {
+      prunePublishHooksForReadOnly(pluginRoot);
+      process.stdout.write("Installed read-only hook manifest; publish interactions hooks are disabled.\n");
+    }
+  }
 }
 
 async function runUninstall(args) {
@@ -1379,6 +1348,21 @@ async function runUninstall(args) {
   );
 }
 
+async function runSetup(args) {
+  const bash = resolveCommand(isWindows() ? ["bash.exe", "bash"] : ["bash"]);
+  if (!bash) {
+    process.stderr.write("error: bash is required to run claude-smart setup.\n");
+    process.exit(1);
+  }
+  const script = join(PACKAGE_ROOT, "scripts", "setup-claude-smart.sh");
+  if (!existsSync(script)) {
+    process.stderr.write(`error: setup script not found at ${script}\n`);
+    process.exit(1);
+  }
+  const code = await runChecked(bash, [script, ...args], { cwd: PACKAGE_ROOT });
+  if (code !== 0) process.exit(code);
+}
+
 async function runInstall(args) {
   if (parseHost(args) === "codex") {
     await runInstallCodex(args);
@@ -1394,8 +1378,8 @@ async function runInstall(args) {
   }
 
   const source = parseSource(args);
-  const readOnly = parseReadOnly(args);
-  configureReflexioSetup(args);
+  const setup = configureReflexioSetup();
+  const readOnly = setup.readOnly;
 
   const steps = [
     { args: ["plugin", "marketplace", "add", source], label: "Adding marketplace…" },
@@ -1414,6 +1398,7 @@ async function runInstall(args) {
 
   try {
     const pluginRoot = await bootstrapClaudeCodeInstall();
+    restorePublishHooksFromSource(pluginRoot);
     if (readOnly) {
       prunePublishHooksForReadOnly(pluginRoot);
       process.stdout.write("Installed read-only hook manifest; publish interactions hooks are disabled.\n");
@@ -1448,8 +1433,8 @@ async function runInstallCodex(args) {
     process.stderr.write("error: 'codex' CLI not found on PATH. Install Codex first.\n");
     process.exit(1);
   }
-  const readOnly = parseReadOnly(args);
-  configureReflexioSetup(args);
+  const setup = configureReflexioSetup();
+  const readOnly = setup.readOnly;
 
   const marketplaceRoot = copyCodexMarketplace();
   if (readOnly) {
@@ -1591,6 +1576,11 @@ async function main() {
     return;
   }
 
+  if (cmd === "setup") {
+    await runSetup(args.slice(1));
+    return;
+  }
+
   if (cmd === "uninstall") {
     await runUninstall(args.slice(1));
     return;
@@ -1620,4 +1610,5 @@ module.exports = {
   patchCodexHooksForNode,
   platformSupportError,
   prunePublishHooksForReadOnly,
+  restorePublishHooksFromSource,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "description": "Self-improving Claude Code plugin — learns from corrections via reflexio",
   "keywords": [
     "claude",
@@ -27,6 +27,7 @@
   },
   "files": [
     "bin",
+    "scripts/setup-claude-smart.sh",
     ".agents/plugins/marketplace.json",
     "plugin",
     "!plugin/**/__pycache__",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "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.36",
+  "version": "0.2.37",
   "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.36"
+version = "0.2.37"
 description = "Self-improving Claude Code plugin — learns from corrections via reflexio"
 readme = "README.md"
 requires-python = ">=3.12"

package/plugin/scripts/_lib.sh

@@ -65,13 +65,13 @@ claude_smart_source_reflexio_env() {
     case "$key" in
       # Managed Reflexio config: file always wins so a rotated key/url overrides
       # whatever a long-lived managed backend or dashboard process inherited.
-      REFLEXIO_URL|REFLEXIO_API_KEY)
+      REFLEXIO_URL|REFLEXIO_API_KEY|REFLEXIO_USER_ID|CLAUDE_SMART_READ_ONLY)
         value="$(claude_smart_env_unquote "$value")"
         export "$key=$value"
         ;;
       # CLAUDE_SMART_* flags: respect anything the caller already exported so
       # per-session overrides (e.g., a manual test) take precedence over the file.
-      CLAUDE_SMART_USE_LOCAL_CLI|CLAUDE_SMART_USE_LOCAL_EMBEDDING|CLAUDE_SMART_READ_ONLY|CLAUDE_SMART_BACKEND_AUTOSTART|CLAUDE_SMART_DASHBOARD_AUTOSTART|CLAUDE_SMART_CLI_PATH|CLAUDE_SMART_CLI_TIMEOUT|CLAUDE_SMART_STATE_DIR|CLAUDE_SMART_ENABLE_OPTIMIZER)
+      CLAUDE_SMART_USE_LOCAL_CLI|CLAUDE_SMART_USE_LOCAL_EMBEDDING|CLAUDE_SMART_BACKEND_AUTOSTART|CLAUDE_SMART_DASHBOARD_AUTOSTART|CLAUDE_SMART_CLI_PATH|CLAUDE_SMART_CLI_TIMEOUT|CLAUDE_SMART_STATE_DIR|CLAUDE_SMART_ENABLE_OPTIMIZER)
         if [ -z "$(eval "printf '%s' \"\${$key:-}\"")" ]; then
           value="$(claude_smart_env_unquote "$value")"
           export "$key=$value"
@@ -97,10 +97,10 @@ claude_smart_is_internal_invocation_env() {
   if [ "${CLAUDE_SMART_INTERNAL:-}" = "1" ]; then
     return 0
   fi
-  if [ -n "${CLAUDE_CODE_ENTRYPOINT:-}" ] && [ "${CLAUDE_CODE_ENTRYPOINT:-}" != "cli" ]; then
-    return 0
-  fi
-  return 1
+  case "${CLAUDE_CODE_ENTRYPOINT:-}" in
+    ""|"cli"|"claude-desktop") return 1 ;;
+    *) return 0 ;;
+  esac
 }
 
 claude_smart_emit_continue() {

package/plugin/scripts/codex-hook.js

@@ -183,11 +183,12 @@ function loadReflexioEnv() {
   const managedReflexioKeys = new Set([
     "REFLEXIO_URL",
     "REFLEXIO_API_KEY",
+    "REFLEXIO_USER_ID",
+    "CLAUDE_SMART_READ_ONLY",
   ]);
   const localConfigKeys = new Set([
     "CLAUDE_SMART_USE_LOCAL_CLI",
     "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
-    "CLAUDE_SMART_READ_ONLY",
     "CLAUDE_SMART_BACKEND_AUTOSTART",
     "CLAUDE_SMART_DASHBOARD_AUTOSTART",
     "CLAUDE_SMART_CLI_PATH",

package/plugin/scripts/smart-install.sh

@@ -105,11 +105,6 @@ install_complete() {
   [ "$(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
-  if [ -z "${REFLEXIO_API_KEY:-}" ]; then
-    grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
-    grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$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
@@ -432,8 +427,6 @@ fi
 # 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"
-mkdir -p "$(dirname "$REFLEXIO_ENV")"
-touch "$REFLEXIO_ENV"
 claude_smart_env_quote() {
   printf '%s' "$1" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
 }
@@ -472,27 +465,11 @@ claude_smart_env_upsert() {
   fi
 }
 
-if [ "${CLAUDE_SMART_MANAGED_SETUP:-}" = "1" ] && [ -n "${REFLEXIO_API_KEY:-}" ]; then
-  REFLEXIO_URL="${REFLEXIO_URL:-https://www.reflexio.ai/}"
-  claude_smart_env_upsert REFLEXIO_URL "$REFLEXIO_URL"
-  claude_smart_env_upsert REFLEXIO_API_KEY "$REFLEXIO_API_KEY"
-  chmod 600 "$REFLEXIO_ENV"
-  echo "[claude-smart] configured managed Reflexio in $REFLEXIO_ENV" >&2
-elif [ -z "${REFLEXIO_API_KEY:-}" ]; then
-  if ! grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$REFLEXIO_ENV"; then
-    printf '\n# Route reflexio generation through the local Claude Code CLI\nCLAUDE_SMART_USE_LOCAL_CLI=1\n' >> "$REFLEXIO_ENV"
-    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=1 to $REFLEXIO_ENV" >&2
-  fi
-  if ! grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
-    printf '# Use the in-process ONNX embedder (chromadb) — no API key for semantic search\nCLAUDE_SMART_USE_LOCAL_EMBEDDING=1\n' >> "$REFLEXIO_ENV"
-    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
-  fi
-fi
 # Migrate stale REFLEXIO_URL from reflexio's library default (8081) to the
 # plugin backend port (8071). Matches the quoted and unquoted forms but
 # requires paired quotes, so malformed or deliberately different values
 # (e.g. a remote reflexio URL) are preserved.
-if grep -qE '^REFLEXIO_URL=("http://localhost:8081/?"|http://localhost:8081/?)$' "$REFLEXIO_ENV"; then
+if [ -f "$REFLEXIO_ENV" ] && grep -qE '^REFLEXIO_URL=("http://localhost:8081/?"|http://localhost:8081/?)$' "$REFLEXIO_ENV"; then
   sed -i.bak -E \
     -e 's|^REFLEXIO_URL="http://localhost:8081(/?)"$|REFLEXIO_URL="http://localhost:8071\1"|' \
     -e 's|^REFLEXIO_URL=http://localhost:8081(/?)$|REFLEXIO_URL=http://localhost:8071\1|' \

package/plugin/src/claude_smart/cli.py

@@ -119,40 +119,6 @@ def _latest_session_id() -> str | None:
     return files[0].stem
 
 
-def _seed_reflexio_env() -> list[str]:
-    """Append the two local-provider flags to ``~/.reflexio/.env``, idempotently.
-
-    Returns:
-        list[str]: Flag names that were newly appended (empty if already present).
-    """
-    _REFLEXIO_ENV_PATH.parent.mkdir(parents=True, exist_ok=True)
-    _REFLEXIO_ENV_PATH.touch(exist_ok=True)
-    existing = _REFLEXIO_ENV_PATH.read_text()
-    flags = (
-        "CLAUDE_SMART_USE_LOCAL_CLI",
-        "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
-    )
-    missing = [f for f in flags if f"{f}=" not in existing]
-    if not missing:
-        return []
-    prefix = "" if not existing or existing.endswith("\n") else "\n"
-    with _REFLEXIO_ENV_PATH.open("a") as fh:
-        fh.write(prefix + "\n".join(f"{f}=1" for f in missing) + "\n")
-    _REFLEXIO_ENV_PATH.chmod(0o600)
-    return missing
-
-
-def _seed_managed_reflexio_env(*, api_key: str, reflexio_url: str) -> list[str]:
-    """Write managed Reflexio connection settings to ``~/.reflexio/.env``."""
-    return env_config.set_env_vars(
-        _REFLEXIO_ENV_PATH,
-        {
-            env_config.REFLEXIO_URL_ENV: reflexio_url,
-            env_config.REFLEXIO_API_KEY_ENV: api_key,
-        },
-    )
-
-
 def _semver_tuple(path: Path) -> tuple[int, int, int] | None:
     parts = path.name.split(".", 2)
     if len(parts) != 3:
@@ -356,6 +322,21 @@ def _prune_publish_hooks_for_read_only(plugin_root: Path) -> None:
         hook_path.write_text(json.dumps(parsed, indent=2) + "\n")
 
 
+def _restore_publish_hooks_from_source(plugin_root: Path) -> None:
+    """Restore full hook manifests before applying the current read-only state."""
+    source_hooks_dir = _PLUGIN_ROOT / "hooks"
+    target_hooks_dir = plugin_root / "hooks"
+    for hook_file in ("hooks.json", "codex-hooks.json"):
+        source_path = source_hooks_dir / hook_file
+        target_path = target_hooks_dir / hook_file
+        if (
+            source_path.is_file()
+            and target_path.is_file()
+            and source_path.resolve() != target_path.resolve()
+        ):
+            shutil.copyfile(source_path, target_path)
+
+
 def _run_codex(args: list[str]) -> subprocess.CompletedProcess[str]:
     """Invoke the ``codex`` CLI with a hard timeout.
 
@@ -823,38 +804,54 @@ def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
     return False, output or "Codex CLI does not expose plugin marketplace commands"
 
 
-def _configure_reflexio_setup(args: argparse.Namespace) -> None:
-    api_key = (getattr(args, "api_key", "") or "").strip()
-    read_only = getattr(args, "read_only", None)
+def _configure_reflexio_setup() -> bool:
+    """Load setup state from ``~/.reflexio/.env`` without writing local defaults.
+
+    Returns:
+        bool: Whether read-only mode is enabled.
+    """
+    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    try:
+        env_text = _REFLEXIO_ENV_PATH.read_text()
+    except OSError:
+        env_text = ""
+    read_only_value = ""
+    file_api_key = ""
+    file_url = ""
+    for line in env_text.splitlines():
+        parsed = env_config.parse_env_line(line)
+        if parsed is None:
+            continue
+        key, value = parsed
+        if key == env_config.REFLEXIO_API_KEY_ENV:
+            file_api_key = value
+        elif key == env_config.REFLEXIO_URL_ENV:
+            file_url = value
+        elif key == "REFLEXIO_USER_ID":
+            os.environ[key] = value
+        elif key == env_config.CLAUDE_SMART_READ_ONLY_ENV:
+            read_only_value = value
+    api_key = (
+        file_api_key or os.environ.get(env_config.REFLEXIO_API_KEY_ENV, "")
+    ).strip()
+    read_only = read_only_value.strip().lower() in {"1", "true", "yes", "on"}
     if api_key:
         reflexio_url = (
-            getattr(args, "reflexio_url", "") or _MANAGED_REFLEXIO_URL
+            file_url
+            or os.environ.get(env_config.REFLEXIO_URL_ENV, _MANAGED_REFLEXIO_URL)
         ).strip()
-        added = _seed_managed_reflexio_env(api_key=api_key, reflexio_url=reflexio_url)
-        if read_only:
-            added.extend(
-                env_config.set_env_vars(
-                    _REFLEXIO_ENV_PATH,
-                    {env_config.CLAUDE_SMART_READ_ONLY_ENV: "1"},
-                )
-            )
-        changed = ", ".join(added) if added else "managed Reflexio settings"
+        os.environ[env_config.REFLEXIO_URL_ENV] = reflexio_url
+        os.environ[env_config.REFLEXIO_API_KEY_ENV] = api_key
+        os.environ["CLAUDE_SMART_MANAGED_SETUP"] = "1"
         sys.stdout.write(
-            f"Configured {_REFLEXIO_ENV_PATH} for managed Reflexio "
-            f"({changed}; API key {env_config.mask_secret(api_key)}).\n"
-        )
-        return
-
-    added = _seed_reflexio_env()
-    if read_only:
-        added.extend(
-            env_config.set_env_vars(
-                _REFLEXIO_ENV_PATH,
-                {env_config.CLAUDE_SMART_READ_ONLY_ENV: "1"},
-            )
+            f"Using managed Reflexio at {reflexio_url} "
+            f"(API key {env_config.mask_secret(api_key)}).\n"
         )
-    if added:
-        sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+    else:
+        os.environ.pop(env_config.REFLEXIO_URL_ENV, None)
+        os.environ.pop(env_config.REFLEXIO_API_KEY_ENV, None)
+        os.environ.pop("CLAUDE_SMART_MANAGED_SETUP", None)
+    return read_only
 
 
 def cmd_install_codex(args: argparse.Namespace) -> int:
@@ -878,7 +875,7 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
             "error: 'uv' not found on PATH. Install uv or restart your shell.\n"
         )
         return 1
-    _configure_reflexio_setup(args)
+    read_only = _configure_reflexio_setup()
 
     missing = _missing_codex_marketplace_files(_REPO_ROOT)
     if missing:
@@ -889,11 +886,8 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
         )
         return 1
     marketplace_root = _prepare_codex_local_marketplace()
-    read_only = bool(getattr(args, "read_only", False))
     if read_only:
-        _prune_publish_hooks_for_read_only(
-            marketplace_root / _CODEX_LOCAL_PLUGIN_PATH
-        )
+        _prune_publish_hooks_for_read_only(marketplace_root / _CODEX_LOCAL_PLUGIN_PATH)
 
     hooks_ok, hooks_msg = _enable_codex_plugin_hooks()
     if hooks_ok:
@@ -988,7 +982,7 @@ def cmd_install(args: argparse.Namespace) -> int:
             "Install Claude Code first: https://claude.com/claude-code\n"
         )
         return 1
-    _configure_reflexio_setup(args)
+    read_only = _configure_reflexio_setup()
 
     for cmd in (
         ["claude", "plugin", "marketplace", "add", args.source],
@@ -1009,7 +1003,8 @@ def cmd_install(args: argparse.Namespace) -> int:
             "Fix the issue above, then run /claude-smart:restart or restart Claude Code to retry.\n"
         )
         return 1
-    if bool(getattr(args, "read_only", False)):
+    _restore_publish_hooks_from_source(Path(message))
+    if read_only:
         _prune_publish_hooks_for_read_only(Path(message))
         sys.stdout.write(
             "Installed read-only hook manifest; publish interactions hooks are disabled.\n"
@@ -1041,6 +1036,7 @@ def cmd_update(args: argparse.Namespace) -> int:
         )
         return 1
 
+    read_only = _configure_reflexio_setup()
     cmd = ["claude", "plugin", "update", _PLUGIN_SPEC]
     try:
         subprocess.run(cmd, check=True)
@@ -1049,8 +1045,14 @@ def cmd_update(args: argparse.Namespace) -> int:
         return exc.returncode or 1
 
     sys.stdout.write("\nclaude-smart updated. Restart Claude Code to apply.\n")
-    if getattr(args, "api_key", ""):
-        _configure_reflexio_setup(args)
+    plugin_root = _find_claude_code_plugin_root()
+    if plugin_root is not None:
+        _restore_publish_hooks_from_source(plugin_root)
+        if read_only:
+            _prune_publish_hooks_for_read_only(plugin_root)
+            sys.stdout.write(
+                "Installed read-only hook manifest; publish interactions hooks are disabled.\n"
+            )
     return 0
 
 
@@ -1143,7 +1145,7 @@ def cmd_show(args: argparse.Namespace) -> int:
     Returns:
         int: 0 on success.
     """
-    project_id = args.project or ids.resolve_project_id()
+    project_id = args.project or ids.resolve_user_id()
     adapter = Adapter()
     user_playbooks, agent_playbooks, profiles = adapter.fetch_all(
         project_id=project_id,
@@ -1202,7 +1204,7 @@ def cmd_learn(args: argparse.Namespace) -> int:
     if not session_id:
         sys.stdout.write("No active claude-smart session buffer found.\n")
         return 0
-    project_id = args.project or ids.resolve_project_id()
+    project_id = args.project or ids.resolve_user_id()
 
     note = (args.note or "").strip()
     if note:
@@ -1832,36 +1834,9 @@ def _build_parser() -> argparse.ArgumentParser:
         default=_DEFAULT_MARKETPLACE_SOURCE,
         help="Marketplace ref — GitHub owner/repo, or a local directory path",
     )
-    inst.add_argument(
-        "--api-key",
-        default="",
-        help="Configure managed Reflexio with this API key instead of local mode",
-    )
-    inst.add_argument(
-        "--reflexio-url",
-        default=_MANAGED_REFLEXIO_URL,
-        help="Managed Reflexio URL used only when --api-key is provided",
-    )
-    inst.add_argument(
-        "--read-only",
-        action="store_const",
-        const=True,
-        default=None,
-        help="Install without publish interactions hooks",
-    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
-    upd.add_argument(
-        "--api-key",
-        default="",
-        help="Configure managed Reflexio with this API key after updating",
-    )
-    upd.add_argument(
-        "--reflexio-url",
-        default=_MANAGED_REFLEXIO_URL,
-        help="Managed Reflexio URL used only when --api-key is provided",
-    )
     upd.set_defaults(func=cmd_update)
 
     uni = sub.add_parser("uninstall", help="Remove claude-smart")

package/plugin/src/claude_smart/events/pre_tool.py

@@ -36,7 +36,7 @@ def handle(payload: dict[str, Any]) -> None:
         hook.emit_continue()
         return
 
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
     try:
         emitted = context_inject.emit_context(
             session_id=session_id,

package/plugin/src/claude_smart/events/session_end.py

@@ -51,7 +51,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     session_id = payload.get("session_id")
     if not session_id:
         return None
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
 
     _maybe_synthesize_assistant_anchor(
         session_id=session_id,

package/plugin/src/claude_smart/events/stop.py

@@ -9,7 +9,15 @@ import time
 from pathlib import Path
 from typing import Any
 
-from claude_smart import cs_cite, env_config, ids, internal_call, publish, runtime, state
+from claude_smart import (
+    cs_cite,
+    env_config,
+    ids,
+    internal_call,
+    publish,
+    runtime,
+    state,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -354,7 +362,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     # without this placeholder, those tools would be misattributed to the
     # next assistant turn.
     transcript_path = payload.get("transcript_path")
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
 
     entries: list[dict[str, Any]] = []
     if transcript_path:
@@ -362,9 +370,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
         if path.is_file():
             entries = _load_transcript_with_retry(path)
 
-    prompt = payload.get("prompt") or (
-        _scan_transcript_for_user_text(entries) if runtime.is_codex() else ""
-    )
+    prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
     if runtime.is_codex() and internal_call.is_codex_internal_prompt(prompt):
         return None
 
@@ -393,13 +399,24 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     plan_decisions = _scan_transcript_for_plan_decisions(entries)
 
     now = int(time.time())
-    for decision_text in plan_decisions:
+    if plan_decisions:
+        for decision_text in plan_decisions:
+            state.append(
+                session_id,
+                {
+                    "ts": now,
+                    "role": "User",
+                    "content": decision_text,
+                    "user_id": project_id,
+                },
+            )
+    elif prompt and not _has_unpublished_user_turn(session_id):
         state.append(
             session_id,
             {
                 "ts": now,
                 "role": "User",
-                "content": decision_text,
+                "content": prompt,
                 "user_id": project_id,
             },
         )

package/plugin/src/claude_smart/events/user_prompt.py

@@ -50,7 +50,7 @@ def handle(payload: dict[str, Any]) -> None:
     if not session_id or not prompt:
         return
 
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
     state.append(
         session_id,
         {

package/plugin/src/claude_smart/hook.py

@@ -68,7 +68,26 @@ def _read_stdin_json() -> dict[str, Any]:
     except json.JSONDecodeError as exc:
         _LOGGER.debug("stdin JSON decode failed: %s", exc)
         return {}
-    return parsed if isinstance(parsed, dict) else {}
+    return _normalize_payload_keys(parsed) if isinstance(parsed, dict) else {}
+
+
+def _normalize_payload_keys(payload: dict[str, Any]) -> dict[str, Any]:
+    """Accept both classic Claude Code and Desktop/Cowork hook key shapes."""
+    aliases = {
+        "sessionId": "session_id",
+        "transcriptPath": "transcript_path",
+        "toolName": "tool_name",
+        "toolInput": "tool_input",
+        "toolResponse": "tool_response",
+        "lastAssistantMessage": "last_assistant_message",
+        "workingDirectory": "cwd",
+        "currentWorkingDirectory": "cwd",
+    }
+    normalized = dict(payload)
+    for source, target in aliases.items():
+        if target not in normalized and source in normalized:
+            normalized[target] = normalized[source]
+    return normalized
 
 
 def emit_continue() -> None:

package/plugin/src/claude_smart/hook_log.py

@@ -163,8 +163,8 @@ def log_path() -> Path:
 
     Resolution order:
 
-    1. ``CLAUDE_SMART_HOOK_LOG`` env var — escape hatch for tests and
-       advanced users who want the log elsewhere.
+    1. ``CLAUDE_SMART_HOOK_LOG`` env var — boolean-like values enable the
+       default log, while path-like values redirect it.
     2. ``_LOG_PATH`` module attribute — what monkeypatched tests override.
     3. ``~/.claude-smart/hook.log`` — the default.
 
@@ -173,6 +173,11 @@ def log_path() -> Path:
     """
     override = os.environ.get("CLAUDE_SMART_HOOK_LOG")
     if override:
+        override = override.strip()
+        if not override:
+            return _LOG_PATH
+        if override.lower() in {"1", "true", "yes", "on"}:
+            return _LOG_PATH
         return Path(override)
     return _LOG_PATH
 

package/plugin/src/claude_smart/ids.py

@@ -21,8 +21,12 @@ import os
 import subprocess  # noqa: S404 — git invocation with a fixed flag set.
 from pathlib import Path
 
+from claude_smart import env_config
+
 _LOGGER = logging.getLogger(__name__)
 
+_USER_ID_OVERRIDE_ENV = "REFLEXIO_USER_ID"
+
 
 def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     """Return a stable project identifier for the given working directory.
@@ -57,3 +61,25 @@ def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
         _LOGGER.debug("git toplevel resolution failed: %s", exc)
     return base.name or "unknown-project"
+
+
+def resolve_user_id(cwd: str | os.PathLike[str] | None = None) -> str:
+    """Return the Reflexio ``user_id`` for the given working directory.
+
+    Honors the ``REFLEXIO_USER_ID`` env var as an explicit override (e.g. so a
+    user can point multiple projects at a single Reflexio identity), and
+    otherwise falls back to :func:`resolve_project_id`. The env var is
+    loaded from ``~/.reflexio/.env`` before reading the process environment so
+    CLI commands and hooks use the same identity resolution.
+
+    Args:
+        cwd: Working directory to resolve when falling back to the project id.
+
+    Returns:
+        str: The override value if set and non-empty, else the project id.
+    """
+    env_config.load_reflexio_env()
+    override = os.environ.get(_USER_ID_OVERRIDE_ENV, "").strip()
+    if override:
+        return override
+    return resolve_project_id(cwd)

package/plugin/src/claude_smart/internal_call.py

@@ -19,10 +19,10 @@ Two distinct sources of unwanted hook fires:
    tool..."`` into reflexio as a fake user interaction.
 
 Detection signals, OR'd:
-  - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than ``"cli"`` —
-    the interactive REPL sets ``cli``; headless ``claude -p`` sets
-    ``sdk-cli`` (and the SDKs may set other values). This catches
-    case (2) for any third-party tool, not just claude-mem.
+  - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than an interactive entrypoint
+    (``"cli"`` or Claude Desktop's ``"claude-desktop"``). Headless
+    ``claude -p`` sets ``sdk-cli`` (and the SDKs may set other values). This
+    catches case (2) for any third-party tool, not just claude-mem.
   - Env var ``CLAUDE_SMART_INTERNAL=1``, set by reflexio's provider
     before spawning ``claude``. Belt-and-suspenders for case (1) in
     case the entrypoint check ever misses a future SDK variant.
@@ -46,7 +46,7 @@ from typing import Any
 from claude_smart import runtime
 
 _ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
-_INTERACTIVE_ENTRYPOINT = "cli"
+_INTERACTIVE_ENTRYPOINTS = frozenset({"cli", "claude-desktop"})
 _CODEX_TITLE_PROMPT_PREFIX = (
     "You are a helpful assistant. You will be presented with a user prompt, "
     "and your job is to provide a short title for a task"
@@ -92,7 +92,7 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     if runtime.is_internal_invocation_env():
         return True
     entrypoint = os.environ.get(_ENTRYPOINT_VAR)
-    if entrypoint and entrypoint != _INTERACTIVE_ENTRYPOINT:
+    if entrypoint and entrypoint not in _INTERACTIVE_ENTRYPOINTS:
         return True
     if runtime.is_codex() and is_codex_internal_prompt(payload.get("prompt")):
         return True

package/plugin/uv.lock

@@ -419,7 +419,7 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.36"
+version = "0.2.37"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },

package/scripts/setup-claude-smart.sh

@@ -0,0 +1,329 @@
+#!/usr/bin/env bash
+# Interactive setup for claude-smart's shared ~/.reflexio/.env.
+#
+# Plain installs stay local and do not need this script. Use this when a user
+# wants managed Reflexio, read-only mode, global sharing, or to switch back to
+# local mode after a managed setup.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HERE/.." && pwd)"
+INSTALLER="$REPO_ROOT/bin/claude-smart.js"
+REFLEXIO_ENV="${REFLEXIO_ENV_PATH:-$HOME/.reflexio/.env}"
+MANAGED_REFLEXIO_URL="https://www.reflexio.ai/"
+GLOBAL_USER_ID="global_user"
+
+log() { printf '[claude-smart setup] %s\n' "$*" >&2; }
+
+env_unquote() {
+  local value first last
+  value="$1"
+  first="${value%"${value#?}"}"
+  last="${value#"${value%?}"}"
+  if { [ "$first" = '"' ] && [ "$last" = '"' ]; } || { [ "$first" = "'" ] && [ "$last" = "'" ]; }; then
+    value="${value#?}"
+    value="${value%?}"
+  fi
+  printf '%s\n' "$value"
+}
+
+env_quote() {
+  printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g'
+}
+
+get_env_value() {
+  local key line raw_key value
+  key="$1"
+  [ -f "$REFLEXIO_ENV" ] || return 1
+  while IFS= read -r line || [ -n "$line" ]; do
+    line="${line#"${line%%[![:space:]]*}"}"
+    line="${line%"${line##*[![:space:]]}"}"
+    [ -n "$line" ] || continue
+    case "$line" in
+      \#*) continue ;;
+      export\ *) line="${line#export }" ;;
+    esac
+    raw_key="${line%%=*}"
+    [ "$raw_key" != "$line" ] || continue
+    raw_key="${raw_key%"${raw_key##*[![:space:]]}"}"
+    [ "$raw_key" = "$key" ] || continue
+    value="${line#*=}"
+    value="${value#"${value%%[![:space:]]*}"}"
+    value="${value%"${value##*[![:space:]]}"}"
+    env_unquote "$value"
+    return 0
+  done < "$REFLEXIO_ENV"
+  return 1
+}
+
+remove_env_keys() {
+  local tmp line key raw_key remove target
+  [ -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:]]}"}"
+    remove=0
+    if [ "$key" != "$raw_key" ]; then
+      if [ "$#" -gt 0 ]; then
+        for target in "$@"; do
+          [ "$key" = "$target" ] && remove=1
+        done
+      else
+        case "$key" in
+          REFLEXIO_API_KEY|REFLEXIO_URL|REFLEXIO_USER_ID|CLAUDE_SMART_READ_ONLY)
+            remove=1
+            ;;
+        esac
+      fi
+    fi
+    [ "$remove" = "1" ] || printf '%s\n' "$line" >> "$tmp"
+  done < "$REFLEXIO_ENV"
+
+  if ! grep -q '[^[:space:]]' "$tmp"; then
+    rm -f "$tmp" "$REFLEXIO_ENV"
+    return 0
+  fi
+  mv "$tmp" "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+}
+
+append_env_value() {
+  local key value quoted
+  key="$1"
+  value="$2"
+  quoted="$(env_quote "$value")"
+  mkdir -p "$(dirname "$REFLEXIO_ENV")"
+  touch "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+  printf '%s="%s"\n' "$key" "$quoted" >> "$REFLEXIO_ENV"
+  chmod 600 "$REFLEXIO_ENV"
+}
+
+mask_secret() {
+  local value len suffix
+  value="$1"
+  len="${#value}"
+  if [ "$len" -eq 0 ]; then
+    printf '%s\n' ''
+  elif [ "$len" -le 4 ]; then
+    printf '****%s\n' "$value"
+  else
+    suffix="${value: -4}"
+    printf '****%s\n' "$suffix"
+  fi
+}
+
+prompt() {
+  local message default answer
+  message="$1"
+  default="$2"
+  if [ -n "$default" ]; then
+    printf '%s [%s]: ' "$message" "$default" >&2
+  else
+    printf '%s: ' "$message" >&2
+  fi
+  IFS= read -r answer
+  if [ -z "$answer" ]; then
+    answer="$default"
+  fi
+  printf '%s\n' "$answer"
+}
+
+prompt_api_key() {
+  local existing masked answer
+  existing="$1"
+  masked="$(mask_secret "$existing")"
+  while :; do
+    if [ -n "$existing" ]; then
+      printf 'Reflexio API key [%s; press Enter to keep]: ' "$masked" >&2
+    else
+      printf 'Reflexio API key: ' >&2
+    fi
+    if [ -t 0 ]; then
+      IFS= read -rs answer
+      printf '\n' >&2
+    else
+      IFS= read -r answer
+    fi
+    if [ -z "$answer" ] && [ -n "$existing" ]; then
+      answer="$existing"
+    fi
+    if [ -z "$answer" ]; then
+      log "API key is required for managed Reflexio."
+      continue
+    fi
+    case "$answer" in
+      *[[:space:]]*)
+        log "API key must not contain whitespace."
+        continue
+        ;;
+    esac
+    printf '%s\n' "$answer"
+    return 0
+  done
+}
+
+normalize_host() {
+  case "$1" in
+    1|claude|claude-code|Claude*) printf 'claude-code\n' ;;
+    2|codex|Codex*) printf 'codex\n' ;;
+    3|both|Both*) printf 'both\n' ;;
+    *) return 1 ;;
+  esac
+}
+
+normalize_mode() {
+  case "$1" in
+    1|local|Local*) printf 'local\n' ;;
+    2|managed|remote|Remote*) printf 'managed\n' ;;
+    *) return 1 ;;
+  esac
+}
+
+normalize_yes_no() {
+  case "$1" in
+    y|Y|yes|Yes|YES|true|1) printf 'yes\n' ;;
+    n|N|no|No|NO|false|0) printf 'no\n' ;;
+    *) return 1 ;;
+  esac
+}
+
+normalize_scope() {
+  case "$1" in
+    1|project|Project*) printf 'project\n' ;;
+    2|global|Global*) printf 'global\n' ;;
+    *) return 1 ;;
+  esac
+}
+
+is_local_url() {
+  case "$1" in
+    http://localhost|http://localhost/|http://localhost:*|http://127.0.0.1|http://127.0.0.1/|http://127.0.0.1:*|http://0.0.0.0|http://0.0.0.0/|http://0.0.0.0:*)
+      return 0
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+}
+
+prompt_normalized() {
+  local label default normalizer answer normalized
+  label="$1"
+  default="$2"
+  normalizer="$3"
+  while :; do
+    answer="$(prompt "$label" "$default")"
+    if normalized="$("$normalizer" "$answer")"; then
+      printf '%s\n' "$normalized"
+      return 0
+    fi
+    log "Invalid choice: $answer"
+  done
+}
+
+install_for_host() {
+  local host node_bin
+  host="$1"
+  if [ "${CLAUDE_SMART_SETUP_NO_INSTALL:-}" = "1" ]; then
+    log "skipping plugin install because CLAUDE_SMART_SETUP_NO_INSTALL=1"
+    return 0
+  fi
+  node_bin="${NODE:-node}"
+  if [ ! -f "$INSTALLER" ]; then
+    log "ERROR: installer not found at $INSTALLER"
+    exit 1
+  fi
+  case "$host" in
+    claude-code)
+      "$node_bin" "$INSTALLER" install
+      ;;
+    codex)
+      "$node_bin" "$INSTALLER" install --host codex
+      ;;
+    both)
+      "$node_bin" "$INSTALLER" install
+      "$node_bin" "$INSTALLER" install --host codex
+      ;;
+  esac
+}
+
+main() {
+  local existing_api_key existing_url existing_user_id existing_read_only
+  local default_mode default_read_only default_scope host mode api_key read_only scope
+  local managed_url managed_user_id
+
+  existing_api_key="$(get_env_value REFLEXIO_API_KEY || true)"
+  existing_url="$(get_env_value REFLEXIO_URL || true)"
+  existing_user_id="$(get_env_value REFLEXIO_USER_ID || true)"
+  existing_read_only="$(get_env_value CLAUDE_SMART_READ_ONLY || true)"
+
+  default_mode="local"
+  if [ -n "$existing_api_key" ] || [ -n "$existing_url" ]; then
+    default_mode="managed"
+  fi
+  default_read_only="no"
+  case "$existing_read_only" in
+    1|true|yes|on) default_read_only="yes" ;;
+  esac
+  default_scope="project"
+  if [ -n "$existing_user_id" ]; then
+    default_scope="global"
+  fi
+
+  host="$(prompt_normalized "Host (1=Claude Code, 2=Codex, 3=both)" "claude-code" normalize_host)"
+  mode="$(prompt_normalized "Setup mode (1=local, 2=managed Reflexio)" "$default_mode" normalize_mode)"
+
+  if [ "$mode" = "local" ]; then
+    if [ -f "$REFLEXIO_ENV" ]; then
+      remove_env_keys
+      log "removed managed Reflexio settings from $REFLEXIO_ENV"
+    else
+      log "local mode selected; no $REFLEXIO_ENV exists, so no env file was created"
+    fi
+    install_for_host "$host"
+    return 0
+  fi
+
+  api_key="$(prompt_api_key "$existing_api_key")"
+  read_only="$(prompt_normalized "Read-only mode? (yes/no)" "$default_read_only" normalize_yes_no)"
+  scope="$(prompt_normalized "Sharing scope (1=project, 2=global)" "$default_scope" normalize_scope)"
+
+  managed_url="${existing_url:-$MANAGED_REFLEXIO_URL}"
+  if is_local_url "$managed_url"; then
+    managed_url="$MANAGED_REFLEXIO_URL"
+  fi
+  managed_user_id=""
+  if [ "$scope" = "global" ]; then
+    managed_user_id="${existing_user_id:-$GLOBAL_USER_ID}"
+  fi
+
+  remove_env_keys \
+    REFLEXIO_API_KEY \
+    REFLEXIO_URL \
+    REFLEXIO_USER_ID \
+    CLAUDE_SMART_READ_ONLY \
+    CLAUDE_SMART_USE_LOCAL_CLI \
+    CLAUDE_SMART_USE_LOCAL_EMBEDDING
+  append_env_value REFLEXIO_URL "$managed_url"
+  append_env_value REFLEXIO_API_KEY "$api_key"
+  if [ "$read_only" = "yes" ]; then
+    append_env_value CLAUDE_SMART_READ_ONLY "1"
+  fi
+  if [ -n "$managed_user_id" ]; then
+    append_env_value REFLEXIO_USER_ID "$managed_user_id"
+  fi
+  chmod 600 "$REFLEXIO_ENV"
+  log "configured managed Reflexio in $REFLEXIO_ENV"
+  log "If a real API key was pasted visibly into a terminal or chat, rotate it in Reflexio."
+  install_for_host "$host"
+}
+
+main "$@"