claude-smart 0.2.41 → 0.2.43

package/plugin/scripts/codex-hook.js

@@ -89,14 +89,82 @@ function appendLog(name, line) {
   trimLog(file);
 }
 
+function realDir(dir) {
+  try {
+    if (!fs.statSync(dir).isDirectory()) return null;
+    return fs.realpathSync(dir);
+  } catch {
+    return null;
+  }
+}
+
+function isInsideDir(parent, child) {
+  const rel = path.relative(parent, child);
+  return rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+function isPluginLikeRoot(root) {
+  return fs.existsSync(path.join(root, "pyproject.toml")) && fs.existsSync(path.join(root, "scripts"));
+}
+
+function isReflexioStrayPluginCopy(root) {
+  if (!isPluginLikeRoot(root)) return false;
+  const rootReal = realDir(root);
+  const reflexioReal = realDir(REFLEXIO_DIR);
+  if (!rootReal || !reflexioReal) return false;
+  return isInsideDir(reflexioReal, rootReal);
+}
+
+function stablePluginRootForStrayCopy(root) {
+  if (!isReflexioStrayPluginCopy(root)) return null;
+  const rootReal = realDir(root);
+  const candidates = [
+    path.join(REFLEXIO_DIR, "plugin-root"),
+    path.join(HOME, ".claude", "plugins", "marketplaces", "reflexioai", "plugin"),
+    path.join(HOME, ".codex", "plugins", "cache", "reflexioai", "claude-smart", "current"),
+  ];
+  for (const cacheRoot of [
+    path.join(HOME, ".claude", "plugins", "cache", "reflexioai", "claude-smart"),
+    path.join(HOME, ".codex", "plugins", "cache", "reflexioai", "claude-smart"),
+  ]) {
+    try {
+      const versions = fs
+        .readdirSync(cacheRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(cacheRoot, entry.name))
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+      candidates.push(...versions);
+    } catch {
+      // Missing cache roots are fine; try the next candidate family.
+    }
+  }
+  for (const candidate of candidates) {
+    if (!isPluginLikeRoot(candidate)) continue;
+    const candidateReal = realDir(candidate);
+    if (!candidateReal || candidateReal === rootReal) continue;
+    if (isReflexioStrayPluginCopy(candidateReal)) continue;
+    return candidateReal;
+  }
+  return null;
+}
+
+function stablePluginRoot(root) {
+  const stable = stablePluginRootForStrayCopy(root);
+  if (stable) {
+    appendLog("backend.log", `[claude-smart] redirecting stray plugin copy under ~/.reflexio (${root}) to stable root ${stable}`);
+    return stable;
+  }
+  return root;
+}
+
 function pluginRoot() {
   for (const value of [process.env.CLAUDE_PLUGIN_ROOT, process.env.PLUGIN_ROOT]) {
     if (value && fs.existsSync(path.join(value, "pyproject.toml"))) {
-      return path.resolve(value);
+      return stablePluginRoot(path.resolve(value));
     }
   }
   const fromScript = path.resolve(__dirname, "..");
-  if (fs.existsSync(path.join(fromScript, "pyproject.toml"))) return fromScript;
+  if (fs.existsSync(path.join(fromScript, "pyproject.toml"))) return stablePluginRoot(fromScript);
   const cacheRoot = path.join(HOME, ".codex", "plugins", "cache", "reflexioai", "claude-smart");
   try {
     const versions = fs
@@ -105,12 +173,12 @@ function pluginRoot() {
       .map((entry) => path.join(cacheRoot, entry.name))
       .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
     for (const candidate of versions) {
-      if (fs.existsSync(path.join(candidate, "pyproject.toml"))) return candidate;
+      if (fs.existsSync(path.join(candidate, "pyproject.toml"))) return stablePluginRoot(candidate);
     }
   } catch {
     // Fall through to the stable plugin-root link.
   }
-  return path.join(REFLEXIO_DIR, "plugin-root");
+  return stablePluginRoot(path.join(REFLEXIO_DIR, "plugin-root"));
 }
 
 function prependRuntimePath() {

package/plugin/scripts/dashboard-build.sh

@@ -27,6 +27,7 @@ claude_smart_source_login_path
 claude_smart_prepend_node_bins
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "dashboard-build.sh" "$@"
 DASHBOARD_DIR="$PLUGIN_ROOT/dashboard"
 
 STATE_DIR="$HOME/.claude-smart"

package/plugin/scripts/dashboard-service.sh

@@ -29,6 +29,7 @@ CMD="${1:-start}"
 PORT=3001
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "dashboard-service.sh" "$@"
 DASHBOARD_DIR="$PLUGIN_ROOT/dashboard"
 WORKSPACE_CWD="${PWD:-}"
 

package/plugin/scripts/ensure-plugin-root.sh

@@ -1,11 +1,9 @@
 #!/usr/bin/env bash
 # Maintain ~/.reflexio/plugin-root as a symlink to the active plugin
-# install dir so slash commands can reference one short path regardless
-# of whether the user is on the remote marketplace (reflexioai) or the
-# local-dev marketplace (reflexioai-local).
+# install dir so slash commands can reference one short path.
 #
 # Usage: ensure-plugin-root.sh <target-dir> [--force]
-#   --force  overwrite any existing link (used by setup-local-dev.sh)
+#   --force  overwrite any existing link
 #   default  self-heal only if the link is missing or points at an
 #            invalid target
 set -eu
@@ -34,8 +32,7 @@ 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
-# symlink tracks the currently loaded plugin. Off by default to preserve
-# a pinned local-dev link across sessions that load the remote plugin.
+# 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" \
@@ -52,11 +49,9 @@ fi
 
 # Cache-tracking: if the link currently resolves to a path under the
 # managed plugin cache (~/.claude/plugins/cache/ or ~/.codex/plugins/cache/),
-# always retarget it to
-# $TARGET. Plugin updates leave old version directories behind, so a
-# valid pyproject.toml at the stale target is not proof the link is
-# fresh. Links pointing outside the cache (e.g., a user's local-dev
-# checkout) are left alone here and handled by the self-heal below.
+# always retarget it to $TARGET. Plugin updates leave old version
+# directories behind, so a valid pyproject.toml at the stale target is
+# not proof the link is fresh.
 if [ -L "$LINK" ]; then
     # Literal target string, not realpath: we compare against what was written by ln -s.
     CURRENT="$(readlink "$LINK" 2>/dev/null || true)"
@@ -74,9 +69,7 @@ if [ -L "$LINK" ]; then
 fi
 
 # Self-heal path: only rewrite the link if it's missing or its target is
-# gone/invalid. This preserves a valid local-dev symlink set earlier by
-# setup-local-dev.sh, so SessionStart hooks on the local install don't
-# clobber the user's repo-pointing link.
+# gone/invalid.
 if [ -f "$LINK/pyproject.toml" ]; then
     exit 0
 fi

package/plugin/scripts/hook_entry.sh

@@ -46,6 +46,7 @@ claude_smart_prepend_astral_bins
 claude_smart_source_reflexio_env
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "hook_entry.sh" "$@"
 
 FAILURE_MARKER="$HOME/.claude-smart/install-failed"
 STATE_DIR="$HOME/.claude-smart"

package/plugin/scripts/smart-install.sh

@@ -17,6 +17,7 @@ claude_smart_prepend_node_bins
 claude_smart_source_reflexio_env
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "smart-install.sh" "$@"
 REPO_ROOT="$(cd "$HERE/../.." && pwd)"
 
 MARKER_DIR="$HOME/.claude-smart"
@@ -446,6 +447,22 @@ if ! command -v uv >/dev/null 2>&1; then
 fi
 
 cd "$PLUGIN_ROOT"
+# Self-heal a corrupt .venv before uv sync. uv refuses to reuse a venv that
+# exists but has no python executable (e.g. partial cleanup of an npm/npx
+# tree, an interrupted earlier install, or the underlying interpreter being
+# uninstalled) — it errors with "not a valid Python environment" instead of
+# rebuilding. Pre-clearing lets uv recreate it cleanly.
+if [ -d "$PLUGIN_ROOT/.venv" ]; then
+  if claude_smart_is_windows; then
+    plugin_python_path="$PLUGIN_ROOT/.venv/Scripts/python.exe"
+  else
+    plugin_python_path="$PLUGIN_ROOT/.venv/bin/python"
+  fi
+  if [ ! -x "$plugin_python_path" ]; then
+    echo "[claude-smart] .venv at $PLUGIN_ROOT/.venv has no python executable; recreating" >&2
+    rm -rf "$PLUGIN_ROOT/.venv"
+  fi
+fi
 echo "[claude-smart] running uv sync..." >&2
 if ! uv sync --locked --python 3.12 --quiet >&2; then
   write_failure "uv sync failed in $PLUGIN_ROOT — run 'uv sync --locked --python 3.12' there to diagnose"
@@ -626,8 +643,7 @@ elif [ -d "$DASHBOARD_DIR" ]; then
 fi
 
 # Point ~/.reflexio/plugin-root at this install so slash commands can
-# reference one stable short path regardless of which marketplace
-# (reflexioai or reflexioai-local) loaded us.
+# reference one stable short path regardless of which install loaded us.
 if ! bash "$HERE/ensure-plugin-root.sh" "$PLUGIN_ROOT"; then
   echo "[claude-smart] WARNING: failed to set ~/.reflexio/plugin-root symlink — slash commands may not resolve" >&2
 fi

package/plugin/src/claude_smart/cli.py

@@ -38,7 +38,6 @@ from claude_smart.reflexio_adapter import Adapter
 
 _REFLEXIO_ENV_PATH = env_config.REFLEXIO_ENV_PATH
 _MANAGED_REFLEXIO_URL = env_config.MANAGED_REFLEXIO_URL
-_DEFAULT_MARKETPLACE_SOURCE = "ReflexioAI/claude-smart"
 _PLUGIN_SPEC = "claude-smart@reflexioai"
 _CODEX_MARKETPLACE_NAME = "reflexioai"
 _CODEX_MARKETPLACE_DISPLAY_NAME = "ReflexioAI"
@@ -803,6 +802,23 @@ def _install_codex_plugin_cache(plugin_root: Path) -> tuple[bool, str]:
     return True, f"installed Codex plugin cache at {cache_dir}"
 
 
+def _find_codex_plugin_root() -> Path | None:
+    """Locate the latest installed Codex plugin cache root."""
+    candidates = (
+        [
+            child
+            for child in _CODEX_PLUGIN_CACHE_DIR.iterdir()
+            if child.is_dir()
+            and (child / "pyproject.toml").is_file()
+            and (child / "scripts" / "smart-install.sh").is_file()
+        ]
+        if _CODEX_PLUGIN_CACHE_DIR.is_dir()
+        else []
+    )
+    candidates.sort(key=_installed_plugin_sort_key, reverse=True)
+    return candidates[0] if candidates else None
+
+
 def _cleanup_codex_install_state() -> bool:
     """Remove Codex's local install artifacts while preserving shared learning data.
 
@@ -1055,13 +1071,13 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
 def cmd_install(args: argparse.Namespace) -> int:
     """Install claude-smart into Claude Code via the native plugin CLI.
 
-    Runs ``claude plugin marketplace add`` followed by ``claude plugin install``,
-    then appends the local-provider flags to ``~/.reflexio/.env`` so reflexio
-    can route generation through the local Claude Code CLI.
+    Runs ``claude plugin marketplace add`` (pointed at the bundled marketplace
+    at ``_REPO_ROOT``) followed by ``claude plugin install``, then appends the
+    local-provider flags to ``~/.reflexio/.env`` so reflexio can route
+    generation through the local Claude Code CLI.
 
     Args:
-        args (argparse.Namespace): Parsed CLI args. Uses ``args.source`` as the
-            marketplace ref (``owner/repo`` on GitHub, or a local directory).
+        args (argparse.Namespace): Parsed CLI args.
 
     Returns:
         int: 0 on success, non-zero if the ``claude`` CLI is missing or fails.
@@ -1077,13 +1093,27 @@ def cmd_install(args: argparse.Namespace) -> int:
         return 1
     read_only = _configure_reflexio_setup()
 
+    refresh_existing = bool(getattr(args, "refresh_existing", False))
     for cmd in (
-        ["claude", "plugin", "marketplace", "add", args.source],
+        ["claude", "plugin", "marketplace", "add", str(_REPO_ROOT)],
         ["claude", "plugin", "install", _PLUGIN_SPEC],
     ):
         try:
             subprocess.run(cmd, check=True)
         except subprocess.CalledProcessError as exc:
+            if refresh_existing and cmd[1:3] == ["plugin", "install"]:
+                sys.stderr.write(
+                    f"warning: {' '.join(cmd)} failed (exit {exc.returncode}); "
+                    f"retrying after uninstalling {_PLUGIN_SPEC}\n"
+                )
+                subprocess.run(
+                    ["claude", "plugin", "uninstall", _PLUGIN_SPEC], check=False
+                )
+                try:
+                    subprocess.run(cmd, check=True)
+                    continue
+                except subprocess.CalledProcessError as retry_exc:
+                    exc = retry_exc
             sys.stderr.write(f"error: {' '.join(cmd)} failed (exit {exc.returncode})\n")
             return exc.returncode or 1
 
@@ -1112,41 +1142,44 @@ def cmd_install(args: argparse.Namespace) -> int:
 
 
 def cmd_update(args: argparse.Namespace) -> int:
-    """Update claude-smart to the latest version via the native plugin CLI.
+    """Update claude-smart by reinstalling from this package.
 
-    Runs ``claude plugin update claude-smart@reflexioai``.
+    The simplified install path registers the bundled package root as the
+    marketplace, so update is a stop + reinstall instead of
+    ``claude plugin update``.
 
     Args:
-        args (argparse.Namespace): Parsed CLI args (unused).
+        args (argparse.Namespace): Parsed CLI args.
 
     Returns:
-        int: 0 on success, non-zero if the ``claude`` CLI is missing or fails.
+        int: 0 on success, non-zero if the host CLI is missing or install fails.
     """
-    if not shutil.which("claude"):
-        sys.stderr.write(
-            "error: 'claude' CLI not found on PATH. "
-            "Install Claude Code first: https://claude.com/claude-code\n"
-        )
-        return 1
+    if getattr(args, "host", "claude-code") == "codex":
+        return cmd_update_codex(args)
 
-    read_only = _configure_reflexio_setup()
-    cmd = ["claude", "plugin", "update", _PLUGIN_SPEC]
-    try:
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError as exc:
-        sys.stderr.write(f"error: {' '.join(cmd)} failed (exit {exc.returncode})\n")
-        return exc.returncode or 1
+    _run_service(_DASHBOARD_SCRIPT, "stop")
+    _run_service(_BACKEND_SCRIPT, "stop")
+    sys.stdout.write("Updating claude-smart by reinstalling from this package...\n")
+    install_args = argparse.Namespace(**vars(args), refresh_existing=True)
+    install_args.host = "claude-code"
+    return cmd_install(install_args)
 
-    sys.stdout.write("\nclaude-smart updated. Restart Claude Code to apply.\n")
-    plugin_root = _find_claude_code_plugin_root()
+
+def cmd_update_codex(_args: argparse.Namespace) -> int:
+    """Update Codex support by refreshing its marketplace/cache install."""
+    plugin_root = _find_codex_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
+        _run_service(plugin_root / "scripts" / "dashboard-service.sh", "stop")
+        _run_service(plugin_root / "scripts" / "backend-service.sh", "stop")
+    else:
+        _run_service(_DASHBOARD_SCRIPT, "stop")
+        _run_service(_BACKEND_SCRIPT, "stop")
+    sys.stdout.write(
+        "Updating claude-smart Codex support by reinstalling from this package...\n"
+    )
+    install_args = argparse.Namespace(**vars(_args))
+    install_args.host = "codex"
+    return cmd_install_codex(install_args)
 
 
 def cmd_uninstall(_args: argparse.Namespace) -> int:
@@ -1952,14 +1985,15 @@ def _build_parser() -> argparse.ArgumentParser:
         default="claude-code",
         help="Install target host",
     )
-    inst.add_argument(
-        "--source",
-        default=_DEFAULT_MARKETPLACE_SOURCE,
-        help="Marketplace ref — GitHub owner/repo, or a local directory path",
-    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
+    upd.add_argument(
+        "--host",
+        choices=("claude-code", "codex"),
+        default="claude-code",
+        help="Update target host",
+    )
     upd.set_defaults(func=cmd_update)
 
     uni = sub.add_parser("uninstall", help="Remove claude-smart")

package/plugin/src/claude_smart/context_format.py

@@ -266,6 +266,7 @@ def render_inline_compact_with_registry(
 def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
     if os.environ.get("CLAUDE_SMART_CITATIONS", "on") == "off":
         return ""
+    gate = cs_cite.WHEN_TO_CITE_COMPACT
     link_style = os.environ.get(_CITATION_LINK_STYLE_ENV, "markdown")
     if link_style == "osc8" and marker_parts:
         marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
@@ -275,15 +276,14 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
             else ""
         )
         return _remoteize_citation_instruction(
-            f"If used, copy this final marker exactly, preserving its hidden "
-            f"OSC 8 terminal link: `{marker}`.{separator_instruction} "
-            f"Skip when unrelated."
+            f"{gate} If you do, copy this final marker exactly, preserving its "
+            f"hidden OSC 8 terminal link: `{marker}`.{separator_instruction}"
         )
     if link_style == "osc8":
         return _remoteize_citation_instruction(
-            "If used, end with `✨ claude-smart rule applied:` followed by "
-            "the same linked memory text; keep the link, but do not show the "
-            "URL. Skip when unrelated."
+            f"{gate} If you do, end with `✨ claude-smart rule applied:` "
+            "followed by the same linked memory text; keep the link, but do "
+            "not show the URL."
         )
     if marker_parts:
         marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
@@ -293,14 +293,13 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
             else ""
         )
         return _remoteize_citation_instruction(
-            f"If used, copy this final marker exactly with markdown links: "
-            f"`{marker}`.{separator_instruction} Skip when unrelated."
+            f"{gate} If you do, copy this final marker exactly with markdown "
+            f"links: `{marker}`.{separator_instruction}"
         )
     return _remoteize_citation_instruction(
-        "Only if a listed [cs:...] item materially changes your answer, end "
-        "with one final marker like `✨ claude-smart rule applied: "
-        "[verify process state](http://localhost:3001/rules/s1-123)` using "
-        "the shown rule URL; skip the marker when unrelated."
+        f"{gate} If you do, end with one final marker like `✨ claude-smart "
+        "rule applied: [verify process state](http://localhost:3001/rules/"
+        "s1-123)` using the shown rule URL."
     )
 
 

package/plugin/src/claude_smart/cs_cite.py

@@ -55,9 +55,7 @@ _APPLIED_LINK_LINE_RE = re.compile(
     r"(?im)^\s*✨\s+(?:Applied|claude-smart rules? applied):\s+(?P<body>.+?)\s*$"
 )
 _MARKDOWN_LINK_RE = re.compile(r"\[[^\]]+\]\((?P<url>[^)]+)\)")
-_OSC8_URL_RE = re.compile(
-    r"\x1b\]8;[^\x07\x1b]*;(?P<url>[^\x07\x1b]+)(?:\x07|\x1b\\)"
-)
+_OSC8_URL_RE = re.compile(r"\x1b\]8;[^\x07\x1b]*;(?P<url>[^\x07\x1b]+)(?:\x07|\x1b\\)")
 _RAW_DASHBOARD_URL_RE = re.compile(
     r"(?P<url>(?:https?://[^\s),\x1b\\]+)?/"
     r"(?:skills/(?:project|shared)/[^\s),\x1b\\]+|"
@@ -65,14 +63,31 @@ _RAW_DASHBOARD_URL_RE = re.compile(
     r"rules/[^\s),\x1b\\]+))"
 )
 
-_COMPACT_INTRO = (
-    "_If you use any listed `[cs:…]` item to answer and it materially changes "
-    "your answer, you must end with one final marker line. Skip the marker "
-    "only when no listed item affected the answer."
+# The single "when to cite" decision, shared across every render path so the
+# bar can't drift between markdown / OSC8 / compact-Codex variants. The
+# counterfactual is the deciding test; relatedness alone is not enough.
+WHEN_TO_CITE = (
+    "When to cite: add a marker only when a listed `[cs:…]` item materially "
+    "and meaningfully changed your response — it must be clearly related to "
+    "what you actually did, and your answer would be substantively different "
+    "if the item had not been shown. The counterfactual is the deciding test: "
+    "if your response would be essentially the same without the item, omit the "
+    "marker."
+)
+
+# One-line form of WHEN_TO_CITE for the compact Codex path, which renders the
+# whole context block as a single logical line.
+WHEN_TO_CITE_COMPACT = (
+    "Cite only if a listed memory materially and meaningfully changed your "
+    "response — counterfactual: the answer would be substantively different "
+    "without it; otherwise omit."
 )
 
+_COMPACT_INTRO = f"_{WHEN_TO_CITE}"
+
 _MARKDOWN_MARKER_PARAGRAPH = (
-    "Use human-readable linked titles, not raw ids. Format for one item: "
+    "How to format: use human-readable linked titles, not raw ids. "
+    "Format for one item: "
     "`✨ claude-smart rule applied: "
     "[verify process state](http://localhost:3001/rules/s1-123)`. "
     "For multiple items: "
@@ -102,14 +117,13 @@ _OSC8_EXAMPLE_MULTI = (
     "\x1b]8;;\x1b\\"
 )
 _OSC8_MARKER_PARAGRAPH = (
-    "Use human-readable OSC 8 terminal hyperlinks, not raw ids or visible "
-    "URLs. Format for one item: "
+    "How to format: use human-readable OSC 8 terminal hyperlinks, not raw ids "
+    "or visible URLs. Format for one item: "
     f"`{_OSC8_EXAMPLE_ONE}`. For multiple items: "
     f"`{_OSC8_EXAMPLE_MULTI}`. Use the dashboard URL shown beside each cited "
     "item; do not invent URLs. Separate multiple linked memories with the "
     "visible ` | ` separator. If OSC 8 is unavailable, use markdown links. "
-    "Do not include `[cs:…]` ids in the marker line. Do not omit the marker "
-    "after using listed memory._"
+    "Do not include `[cs:…]` ids in the marker line._"
 )
 
 CITATION_MODES = ("on", "auto", "marker-only", "off")

package/plugin/src/claude_smart/ids.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import logging
 import os
 import subprocess  # noqa: S404 — git invocation with a fixed flag set.
-from pathlib import Path
+from pathlib import Path, PureWindowsPath
 
 from claude_smart import env_config
 
@@ -28,6 +28,14 @@ _LOGGER = logging.getLogger(__name__)
 _USER_ID_OVERRIDE_ENV = "REFLEXIO_USER_ID"
 
 
+def _basename(path: str | os.PathLike[str]) -> str:
+    """Return a cwd basename, including native Windows paths under Git Bash."""
+    text = os.fspath(path)
+    if "\\" in text or (len(text) >= 2 and text[0].isalpha() and text[1] == ":"):
+        return PureWindowsPath(text).name or "unknown-project"
+    return Path(path).name or "unknown-project"
+
+
 def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     """Return a stable project identifier for the given working directory.
 
@@ -47,7 +55,7 @@ def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     base = Path(cwd) if cwd is not None else Path.cwd()
     try:
         result = subprocess.run(  # noqa: S603, S607 — fixed argv, cwd is a Path.
-            ["git", "rev-parse", "--show-toplevel"],
+            ["git", "rev-parse", "--show-toplevel"],  # noqa: S607
             cwd=base,
             capture_output=True,
             text=True,
@@ -57,10 +65,10 @@ def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
         if result.returncode == 0:
             toplevel = result.stdout.strip()
             if toplevel:
-                return Path(toplevel).name
-    except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
+                return _basename(toplevel)
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired) as exc:
         _LOGGER.debug("git toplevel resolution failed: %s", exc)
-    return base.name or "unknown-project"
+    return _basename(cwd) if cwd is not None else _basename(base)
 
 
 def resolve_user_id(cwd: str | os.PathLike[str] | None = None) -> str:

package/plugin/uv.lock

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

package/plugin/vendor/reflexio/.env.example

@@ -0,0 +1,53 @@
+# .env
+
+# ====================
+# LLM API Keys
+# ====================
+# Set at least one API key. The system auto-detects available providers and
+# selects appropriate default models per role (generation, evaluation, should_run,
+# pre_retrieval, embedding). Provider priority when multiple keys are set:
+# Anthropic > Gemini > OpenRouter > DeepSeek > MiniMax > DashScope > xAI > Moonshot > ZAI > OpenAI
+# For the embedding role, if the top-priority provider has no embedding support,
+# the next embedding-capable provider is used (currently OpenAI or Gemini).
+# Model resolution order (highest priority first):
+#   1. Org-level LLMConfig override
+#   2. Non-empty values in reflexio/server/site_var/site_var_sources/llm_model_setting.json
+#   3. Auto-detected default for the primary available provider
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+OPENROUTER_API_KEY=
+GEMINI_API_KEY=
+MINIMAX_API_KEY=
+DEEPSEEK_API_KEY=
+DASHSCOPE_API_KEY=
+ZAI_API_KEY=
+MOONSHOT_API_KEY=
+XAI_API_KEY=
+
+# ====================
+# Observability (Optional)
+# ====================
+# Set to enable Braintrust LLM observability (https://www.braintrust.dev)
+# BRAINTRUST_API_KEY=
+# BRAINTRUST_PROJECT_NAME=reflexio
+
+# ====================
+# Local Storage Configuration
+# ====================
+# Local storage directory — houses disk-storage artifacts and the SQLite
+# database file (reflexio.db). Defaults to ~/.reflexio/data/.
+LOCAL_STORAGE_PATH=
+
+# ====================
+# Testing & Logging
+# ====================
+# Set to true to enable test environment mode
+IS_TEST_ENV=true
+# Set to enable debug logging to console
+DEBUG_LOG_TO_CONSOLE=true
+# Mock LLM call response
+MOCK_LLM_RESPONSE=false
+# Override the base directory for log files. The .reflexio/logs suffix is
+# always preserved, so e.g. REFLEXIO_LOG_DIR=/tmp/foo writes logs to
+# /tmp/foo/.reflexio/logs/. Defaults to $HOME (i.e. ~/.reflexio/logs/).
+REFLEXIO_LOG_DIR=