claude-smart 0.2.27 → 0.2.29

package/plugin/scripts/smart-install.sh

@@ -20,18 +20,121 @@ REPO_ROOT="$(cd "$HERE/../.." && pwd)"
 
 MARKER_DIR="$HOME/.claude-smart"
 FAILURE_MARKER="$MARKER_DIR/install-failed"
+SUCCESS_MARKER="$MARKER_DIR/install-complete"
+INSTALL_LOCK="$MARKER_DIR/install.lock"
 mkdir -p "$MARKER_DIR"
+
+# Serialize concurrent installer runs (SessionStart hook + slash-command
+# self-heal can both invoke this script). Wait for the active installer
+# rather than returning early, otherwise callers can re-check uv before
+# the first install has finished and report a false missing-dependency error.
+if command -v flock >/dev/null 2>&1; then
+  exec 9>"$INSTALL_LOCK"
+  if ! flock 9; then
+    echo "[claude-smart] install lock failed; continuing without serialization" >&2
+    echo '{"continue":true,"suppressOutput":true}'
+    exit 0
+  fi
+fi
+
 rm -f "$FAILURE_MARKER"
 
 write_failure() {
   local reason
   reason="$1"
   printf '%s\n' "$reason" > "$FAILURE_MARKER"
+  rm -f "$SUCCESS_MARKER"
   echo "[claude-smart] install failed: $reason" >&2
   echo '{"continue":true,"suppressOutput":true}'
   exit 0
 }
 
+fingerprint_file() {
+  local path
+  path="$1"
+  if [ -f "$path" ]; then
+    cksum "$path" 2>/dev/null | awk '{print $1 ":" $2}'
+  else
+    printf 'missing\n'
+  fi
+}
+
+install_fingerprint() {
+  printf 'plugin_root=%s\n' "$PLUGIN_ROOT"
+  printf 'smart_install=%s\n' "$(fingerprint_file "$HERE/smart-install.sh")"
+  printf 'pyproject=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/pyproject.toml")"
+  printf 'uv_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/uv.lock")"
+  # Resolved python interpreter — catches a system upgrade (3.12.4 → 3.12.5)
+  # that would otherwise let install_complete return true against a venv
+  # built against a now-deleted interpreter.
+  if command -v uv >/dev/null 2>&1; then
+    printf 'python=%s\n' "$(uv python find 3.12 2>/dev/null || echo missing)"
+  else
+    printf 'python=no-uv\n'
+  fi
+  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
+    printf 'dashboard_pkg=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package.json")"
+    printf 'dashboard_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package-lock.json")"
+  else
+    printf 'dashboard_pkg=none\n'
+    printf 'dashboard_lock=none\n'
+  fi
+}
+
+install_complete() {
+  [ -f "$SUCCESS_MARKER" ] || return 1
+  [ "$(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
+  grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
+  grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.reflexio/.env" || return 1
+  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
+    [ -d "$PLUGIN_ROOT/dashboard/.next" ] || [ -f "$MARKER_DIR/dashboard-build.pid" ] || [ -f "$(claude_smart_dashboard_unavailable_marker)" ] || return 1
+  fi
+  return 0
+}
+
+write_success_marker() {
+  install_fingerprint > "$SUCCESS_MARKER"
+}
+
+preflight_supported_runtime_platform() {
+  local os_name machine darwin_major
+  os_name="$(uname -s 2>/dev/null || echo unknown)"
+  machine="$(uname -m 2>/dev/null || echo unknown)"
+  case "$os_name" in
+    Darwin*)
+      if [ "$machine" != "arm64" ]; then
+        write_failure "claude-smart currently supports Apple Silicon macOS 14+ only; Intel Mac is not supported because native ML wheels are unavailable."
+      fi
+      darwin_major="$(uname -r 2>/dev/null | awk -F. '{print $1}')"
+      case "$darwin_major" in
+        ''|*[!0-9]*)
+          write_failure "claude-smart could not determine the macOS version; Apple Silicon macOS 14+ is required."
+          ;;
+      esac
+      if [ "$darwin_major" -lt 23 ]; then
+        write_failure "claude-smart currently supports macOS 14+ on Apple Silicon; macOS 13 and older are not supported because native ML wheels are unavailable."
+      fi
+      ;;
+    MINGW*|MSYS*|CYGWIN*)
+      case "$machine" in
+        x86_64|amd64) : ;;
+        *)
+          write_failure "claude-smart currently supports Windows x64 only; Windows ARM is not supported because native ML wheels are unavailable."
+          ;;
+      esac
+      ;;
+    Linux*)
+      : # Existing Linux installs remain supported when package wheels are available.
+      ;;
+    *)
+      write_failure "claude-smart currently supports Apple Silicon macOS 14+, Windows x64, and Linux for vanilla installs."
+      ;;
+  esac
+}
+
 install_private_node() {
   local NODE_MIN_MAJOR NODE_MIN_MINOR NODE_LTS_MAJOR
   local node_os archive_ext reason node_arch node_platform base_url node_root
@@ -236,6 +339,13 @@ if [ "${CLAUDE_SMART_INSTALL_PRIVATE_NODE_ONLY:-}" = "1" ]; then
   exit $?
 fi
 
+preflight_supported_runtime_platform
+
+if install_complete; then
+  echo '{"continue":true,"suppressOutput":true}'
+  exit 0
+fi
+
 # Dev-mode only: when running from a git checkout, pull the reflexio
 # submodule so tests/benchmarks can use its sources. In install mode the
 # plugin lives under ~/.claude/plugins/cache and reflexio-ai resolves
@@ -327,57 +437,32 @@ if ! command -v claude >/dev/null 2>&1; then
   echo "[claude-smart] WARNING: 'claude' CLI not on PATH — reflexio extractors will have no LLM until it's installed" >&2
 fi
 
-# Allowlist cs-cite globally so Claude's citation Bash calls don't pop a
-# permission prompt mid-turn. Idempotent: no-ops when the entry is already
-# present. Uses Python to preserve the rest of settings.json intact.
-# Resolves python via claude_smart_resolve_python so we don't fire the
-# Windows App Execution Alias stub (which exits non-zero with "Python
-# was not found" when no real interpreter is installed).
+LEGACY_CS_CITE="$HOME/.claude-smart/bin/cs-cite"
+if [ -e "$LEGACY_CS_CITE" ]; then
+  rm -f "$LEGACY_CS_CITE"
+  echo "[claude-smart] removed legacy cs-cite helper at $LEGACY_CS_CITE" >&2
+fi
+
 CLAUDE_SETTINGS="$HOME/.claude/settings.json"
-mkdir -p "$(dirname "$CLAUDE_SETTINGS")"
-PY_BIN=$(claude_smart_resolve_python || true)
-if [ -z "$PY_BIN" ]; then
-  echo "[claude-smart] WARNING: no working python interpreter found; skipping cs-cite allowlist" >&2
-elif "$PY_BIN" - "$CLAUDE_SETTINGS" <<'PY' >&2
-import json
-import sys
-from pathlib import Path
-
-path = Path(sys.argv[1])
-entry = "Bash(cs-cite:*)"
-data: dict = {}
-if path.is_file():
-    try:
-        data = json.loads(path.read_text() or "{}")
-    except json.JSONDecodeError:
-        print(
-            f"[claude-smart] WARNING: {path} is not valid JSON; skipping cs-cite allowlist",
-            file=sys.stderr,
-        )
-        sys.exit(2)
-def _warn_and_exit(reason: str) -> None:
-    print(
-        f"[claude-smart] WARNING: {path} {reason}; skipping cs-cite allowlist",
-        file=sys.stderr,
-    )
-    sys.exit(2)
-
-if not isinstance(data, dict):
-    _warn_and_exit("top-level is not a JSON object")
-permissions = data.setdefault("permissions", {})
-if not isinstance(permissions, dict):
-    _warn_and_exit("'permissions' is not a JSON object")
-allow = permissions.setdefault("allow", [])
-if not isinstance(allow, list):
-    _warn_and_exit("'permissions.allow' is not a JSON array")
-if entry in allow:
-    sys.exit(1)  # already present — convey via exit code so shell can skip the log
-allow.append(entry)
-path.write_text(json.dumps(data, indent=2) + "\n")
-sys.exit(0)
-PY
-then
-  echo "[claude-smart] added Bash(cs-cite:*) to $CLAUDE_SETTINGS permissions.allow" >&2
+if [ -f "$CLAUDE_SETTINGS" ] && command -v node >/dev/null 2>&1; then
+  node - "$CLAUDE_SETTINGS" <<'JS' >&2 || true
+const fs = require("fs");
+const path = process.argv[2];
+const entry = "Bash(cs-cite:*)";
+let data;
+try {
+  data = JSON.parse(fs.readFileSync(path, "utf8") || "{}");
+} catch {
+  process.exit(0);
+}
+const allow = data?.permissions?.allow;
+if (!Array.isArray(allow)) process.exit(0);
+const next = allow.filter((item) => item !== entry);
+if (next.length === allow.length) process.exit(0);
+data.permissions.allow = next;
+fs.writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+console.error(`[claude-smart] removed legacy ${entry} permission from ${path}`);
+JS
 fi
 
 # Spawn the dashboard build detached so install returns immediately and
@@ -406,5 +491,6 @@ 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
 
+write_success_marker
 echo "[claude-smart] install complete. Backend and dashboard auto-start on session start." >&2
 echo '{"continue":true,"suppressOutput":true}'

package/plugin/src/claude_smart/cli.py

@@ -69,6 +69,8 @@ _DASHBOARD_DIR = _PLUGIN_ROOT / "dashboard"
 _BACKEND_SCRIPT = _SCRIPTS_DIR / "backend-service.sh"
 _DASHBOARD_SCRIPT = _SCRIPTS_DIR / "dashboard-service.sh"
 _REFLEXIO_DIR = Path.home() / ".reflexio"
+_STATE_DIR = Path.home() / ".claude-smart"
+_INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
 _REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
@@ -76,8 +78,11 @@ _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
     Path("plugin/.codex-plugin/plugin.json"),
     Path("plugin/hooks/codex-hooks.json"),
-    Path("plugin/scripts/codex-claude-compat.py"),
+    Path("plugin/scripts/codex-claude-compat"),
+    Path("plugin/scripts/codex-claude-compat.cmd"),
+    Path("plugin/scripts/codex-claude-compat.js"),
     Path("plugin/scripts/codex-hook.js"),
+    Path("plugin/scripts/backend-log-runner.sh"),
     Path("plugin/scripts/_codex_env.sh"),
 )
 _COPYTREE_IGNORE = shutil.ignore_patterns(
@@ -125,6 +130,86 @@ def _seed_reflexio_env() -> list[str]:
     return missing
 
 
+def _find_claude_code_plugin_root() -> Path | None:
+    """Locate the installed Claude Code plugin root after native install."""
+    cache_root = (
+        Path.home()
+        / ".claude"
+        / "plugins"
+        / "cache"
+        / _CODEX_MARKETPLACE_NAME
+        / "claude-smart"
+    )
+    candidates: list[Path] = []
+    if cache_root.is_dir():
+        for child in cache_root.iterdir():
+            if (
+                child.is_dir()
+                and (child / "pyproject.toml").is_file()
+                and (child / "scripts" / "smart-install.sh").is_file()
+            ):
+                candidates.append(child)
+    candidates.sort(key=lambda path: path.stat().st_mtime, reverse=True)
+    candidates.extend(
+        [
+            Path.home()
+            / ".claude"
+            / "plugins"
+            / "marketplaces"
+            / _CODEX_MARKETPLACE_NAME
+            / "plugin",
+            _PLUGIN_ROOT,
+        ]
+    )
+    for candidate in candidates:
+        if (
+            (candidate / "pyproject.toml").is_file()
+            and (candidate / "scripts" / "smart-install.sh").is_file()
+        ):
+            return candidate
+    return None
+
+
+def _force_plugin_root(plugin_root: Path) -> None:
+    """Point ~/.reflexio/plugin-root at the installed plugin root."""
+    _REFLEXIO_DIR.mkdir(parents=True, exist_ok=True)
+    link = _REFLEXIO_DIR / "plugin-root"
+    if link.is_symlink() or link.is_file():
+        link.unlink()
+    elif link.exists():
+        raise OSError(f"refusing to replace non-symlink plugin-root at {link}")
+    try:
+        link.symlink_to(plugin_root, target_is_directory=True)
+    except OSError:
+        if link.exists():
+            raise
+        (_REFLEXIO_DIR / "plugin-root.txt").write_text(f"{plugin_root}\n")
+
+
+def _bootstrap_claude_code_install() -> tuple[bool, str]:
+    """Run smart-install immediately for the installed Claude Code plugin."""
+    plugin_root = _find_claude_code_plugin_root()
+    if plugin_root is None:
+        return False, "could not locate installed Claude Code plugin root after install"
+    try:
+        _force_plugin_root(plugin_root)
+    except OSError as exc:
+        return False, str(exc)
+    bash = shutil.which("bash")
+    if not bash:
+        return False, "bash is required to bootstrap claude-smart dependencies"
+    result = subprocess.run(
+        [bash, str(plugin_root / "scripts" / "smart-install.sh")],
+        cwd=plugin_root,
+    )
+    if result.returncode != 0:
+        return False, f"smart-install.sh failed in {plugin_root}"
+    if _INSTALL_FAILURE_MARKER.is_file():
+        reason = _INSTALL_FAILURE_MARKER.read_text().strip() or "unknown error"
+        return False, reason
+    return True, str(plugin_root)
+
+
 def _missing_codex_marketplace_files(root: Path) -> list[Path]:
     return [entry for entry in _CODEX_REQUIRED_FILES if not (root / entry).is_file()]
 
@@ -789,7 +874,21 @@ def cmd_install(args: argparse.Namespace) -> int:
     if added:
         sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
 
-    sys.stdout.write("\nclaude-smart installed. Restart Claude Code in your project.\n")
+    bootstrapped, message = _bootstrap_claude_code_install()
+    if not bootstrapped:
+        sys.stderr.write(
+            f"error: claude-smart installed, but dependency bootstrap failed: {message}\n"
+        )
+        sys.stderr.write(
+            "Fix the issue above, then run /claude-smart:restart or restart Claude Code to retry.\n"
+        )
+        return 1
+    sys.stdout.write(f"Prepared claude-smart runtime at {message}.\n")
+
+    sys.stdout.write(
+        "\nclaude-smart installed and dependencies are prepared. "
+        "Restart Claude Code in your project.\n"
+    )
     return 0
 
 

package/plugin/src/claude_smart/context_inject.py

@@ -6,8 +6,7 @@ search, (b) render the hits with ``context_format.render_inline_with_registry``,
 (d) emit a Claude Code ``hookSpecificOutput.additionalContext`` envelope
 on stdout. This module owns that shared pipeline so the two hook
 handlers keep exactly one source of truth for the injection contract —
-the envelope shape, the registry schema, and the ordering of
-``ensure_installed`` / ``append_injected``.
+the envelope shape, the registry schema, and the injected context append.
 
 The caller remains responsible for handler-specific framing (PreToolUse
 needs ``hook.emit_continue()`` on the empty path; UserPromptSubmit wraps
@@ -21,7 +20,7 @@ import json
 import sys
 import time
 
-from claude_smart import context_format, cs_cite, state
+from claude_smart import context_format, state
 from claude_smart.reflexio_adapter import Adapter
 
 
@@ -69,7 +68,6 @@ def emit_context(
     if not markdown:
         return False
 
-    cs_cite.ensure_installed()
     state.append_injected(
         session_id,
         (dict(entry, ts=int(time.time())) for entry in registry),

package/plugin/src/claude_smart/cs_cite.py

@@ -11,8 +11,7 @@ impactful replies with a marker like::
 
 The Stop hook later scans the assistant text for those markers and resolves
 the ids against a per-session registry persisted at
-``~/.claude-smart/sessions/<session_id>.injected.jsonl``. Legacy ``cs-cite``
-Bash tool calls are still accepted as a fallback for older instructions.
+``~/.claude-smart/sessions/<session_id>.injected.jsonl``.
 
 Why rank + fingerprint: rank alone resets at every injection, so a
 later injection's ``s1`` would silently overwrite an earlier entry in
@@ -27,48 +26,19 @@ This module holds:
 - ``rank_id``: ``p{n}-{fp}`` / ``s{n}-{fp}`` tag for a given
   (kind, rank, real_id) tuple. Fingerprint is omitted when no real id
   is available. ``p`` is preference, ``s`` is skill.
-- ``CITATION_CMD_RE``: regex matching a valid legacy ``cs-cite`` command line.
-- ``ensure_installed``: idempotent copy of ``plugin/bin/cs-cite`` to
-  ``~/.claude-smart/bin/cs-cite`` with the executable bit set.
 - ``CITATION_INSTRUCTION``: the trailer text appended to injected context
   so the assistant knows when and how to emit the citation marker.
 """
 
 from __future__ import annotations
 
-import logging
 import re
-import shutil
-import stat as stat_
-from pathlib import Path
 from typing import Any
 
-_LOGGER = logging.getLogger(__name__)
-
-_THIS_DIR = Path(__file__).resolve().parent
-_PLUGIN_ROOT = _THIS_DIR.parents[1]  # plugin/src/claude_smart/ -> plugin/
-_SOURCE_SCRIPT = _PLUGIN_ROOT / "bin" / "cs-cite"
-_INSTALL_DIR = Path.home() / ".claude-smart" / "bin"
-INSTALL_PATH = _INSTALL_DIR / "cs-cite"
-
 _FINGERPRINT_LEN = 4
 
-# Match a bare `cs-cite <ids>` invocation. Ids are rank tokens of the
-# form `p<N>` (preference) or `s<N>` (skill) with an optional
-# `-<fp>` fingerprint (1-4 alphanumeric chars), optionally
-# `cs:`-prefixed (since bullets render as `[cs:p1-ab12]` and the model
-# often copies the tag verbatim). The `(?i:...)` inline flags make the
-# prefix, kind letter, and fingerprint case-insensitive so `CS:P1-AB12`
-# is accepted — matching the `re.IGNORECASE` used by the standalone
-# `cs-cite` script. Tokens may be comma- and/or whitespace-separated.
-# Chained commands (&&, |, ;) and extra trailing tokens remain rejected
-# by the anchored `\s*$` terminator so accidental mentions don't
-# register as citations.
 _ID_TOKEN = r"(?i:cs:)?(?i:[ps])\d+(?:-(?i:[a-z0-9]){1,4})?"
 _ID_SEP = r"[,\s]+"
-CITATION_CMD_RE = re.compile(
-    rf"^\s*(?:[^\s]*/)?cs-cite\s+({_ID_TOKEN}(?:{_ID_SEP}{_ID_TOKEN})*)\s*$"
-)
 _CLEAN_ID_RE = re.compile(r"^(?i:cs:)?((?i:[ps])\d+(?:-(?i:[a-z0-9]){1,4})?)$")
 _SPLIT_RE = re.compile(_ID_SEP)
 _TEXT_CITATION_LINE_RE = re.compile(
@@ -82,7 +52,7 @@ CITATION_INSTRUCTION = (
     "only if — an injected `[cs:…]` item materially changed your reply "
     "(different wording, action, or conclusion than you would have produced "
     "without it), append exactly one final citation line after your answer. "
-    "Do not call `cs-cite` or any other tool for citations. Ids come verbatim "
+    "Do not call a shell command or any other tool for citations. Ids come verbatim "
     "from the `[cs:…]` tags — keep the leading `p` (preference) or `s` "
     "(skill) and the `-<fp>` suffix. Use this exact format for one id: "
     "`✨ 1 claude-smart learning applied [cs:s1-ab12]`. Use this exact format "
@@ -155,29 +125,6 @@ def rank_id(kind: str, rank: int, real_id: Any = None) -> str:
     return f"{prefix}{rank}-{fp}" if fp else f"{prefix}{rank}"
 
 
-def parse_citation_command(command: str) -> list[str]:
-    """Extract citation ids from a ``cs-cite`` Bash command string.
-
-    Returns an empty list when the command does not match the expected
-    shape (chained commands, extra arguments, or anything other than a
-    bare ``cs-cite <ids>`` invocation are rejected to avoid false
-    positives from accidental mentions).
-
-    Args:
-        command: The raw ``input.command`` value from a Bash tool_use
-            block.
-
-    Returns:
-        list[str]: Lowercase rank ids (e.g. ``"p1"``, ``"s3"``), in the
-            order Claude cited them. Empty when the command does not
-            match.
-    """
-    match = CITATION_CMD_RE.match(command or "")
-    if not match:
-        return []
-    return _parse_id_tokens(match.group(1))
-
-
 def parse_text_citations(text: str) -> list[str]:
     """Extract Codex text-only citation ids from a final learning marker line.
 
@@ -199,38 +146,3 @@ def _parse_id_tokens(raw_ids: str) -> list[str]:
         if clean := _CLEAN_ID_RE.match(tok):
             ids.append(clean.group(1).lower())
     return ids
-
-
-def ensure_installed() -> Path:
-    """Idempotently install ``cs-cite`` into ``~/.claude-smart/bin/``.
-
-    Called from every PreToolUse / UserPromptSubmit inject, so we
-    short-circuit when the target file already exists with
-    the executable bit set — the steady-state path is one ``stat`` syscall
-    instead of mkdir + copy + stat + chmod. Keying on filesystem state
-    (rather than a module-level boolean) keeps test isolation working when
-    tests monkeypatch ``INSTALL_PATH`` to a fresh tmpdir.
-
-    Never raises — filesystem errors are logged at DEBUG and the caller
-    proceeds with injection regardless (the citation feature degrades to
-    silent if the script is unreachable).
-
-    Returns:
-        Path: Target path, whether or not install succeeded.
-    """
-    try:
-        if (
-            INSTALL_PATH.is_file()
-            and INSTALL_PATH.stat().st_mode & stat_.S_IXUSR
-            and _SOURCE_SCRIPT.is_file()
-            and INSTALL_PATH.read_bytes() == _SOURCE_SCRIPT.read_bytes()
-        ):
-            return INSTALL_PATH
-        _INSTALL_DIR.mkdir(parents=True, exist_ok=True)
-        if _SOURCE_SCRIPT.is_file():
-            shutil.copy2(_SOURCE_SCRIPT, INSTALL_PATH)
-            mode = INSTALL_PATH.stat().st_mode
-            INSTALL_PATH.chmod(mode | stat_.S_IXUSR | stat_.S_IXGRP | stat_.S_IXOTH)
-    except OSError as exc:
-        _LOGGER.debug("cs-cite install failed: %s", exc)
-    return INSTALL_PATH

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

@@ -34,7 +34,7 @@ _EXIT_PLAN_MODE_TOOL = "ExitPlanMode"
 def _read_transcript_entries(path: Path) -> list[dict[str, Any]]:
     """Parse the transcript JSONL once into a list of entries.
 
-    Stop's three scanners (assistant text, cs-cite ids, plan decisions) all
+    Stop's scanners (assistant text and plan decisions) both
     need the same parsed view; reading once and passing the list around keeps
     the hook's wall-clock cost to a single ``read_text`` per fire even on
     multi-megabyte transcripts.
@@ -267,43 +267,10 @@ def _parse_plan_decision(text: str) -> str | None:
     return None
 
 
-def _scan_transcript_for_cs_cite_ids(entries: list[dict[str, Any]]) -> list[str]:
-    """Scan the current assistant turn for ``cs-cite`` Bash tool_use calls.
-
-    Collects citation ids from every matching Bash ``tool_use`` block in
-    the current turn. Multiple calls are merged; order follows Claude's
-    emission order (earliest first).
-
-    Args:
-        entries (list[dict[str, Any]]): Pre-parsed transcript entries.
-
-    Returns:
-        list[str]: Rank ids (e.g. ``"s1-ab12"``, ``"p2-cd34"``) in
-            emission order. Empty when no ``cs-cite`` call is found.
-    """
-    out: list[str] = []
-    for entry in _current_turn_assistant_entries(entries):
-        message = entry.get("message") or {}
-        out.extend(_extract_cs_cite_ids(message.get("content")))
-    return out
-
-
-def _extract_cs_cite_ids(content: Any) -> list[str]:
-    """Return citation ids from all Bash ``cs-cite`` tool_use blocks in ``content``."""
-    if not isinstance(content, list):
-        return []
-    out: list[str] = []
-    for block in content:
-        if not isinstance(block, dict) or block.get("type") != "tool_use":
-            continue
-        if block.get("name") != "Bash":
-            continue
-        tool_input = block.get("input") or {}
-        command = tool_input.get("command")
-        if not isinstance(command, str):
-            continue
-        out.extend(cs_cite.parse_citation_command(command))
-    return out
+def _has_unpublished_user_turn(session_id: str) -> bool:
+    """True when the session buffer already has a user turn awaiting publish."""
+    _, interactions = state.unpublished_slice(state.read_all(session_id))
+    return any(item.get("role") == "User" for item in interactions)
 
 
 def _resolve_cited_items(session_id: str, cited_ids: list[str]) -> list[dict[str, Any]]:
@@ -360,8 +327,10 @@ def handle(payload: dict[str, Any]) -> 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 ""
+    )
     if runtime.is_codex():
-        prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
         if internal_call.is_codex_internal_prompt(prompt):
             return
 
@@ -373,10 +342,15 @@ def handle(payload: dict[str, Any]) -> None:
         and last_assistant_message
         else _scan_transcript_for_assistant_text(entries)
     )
-    transcript_cited_ids = _scan_transcript_for_cs_cite_ids(entries)
+    if (
+        runtime.is_codex()
+        and internal_call.is_codex_title_response(assistant_text)
+        and not prompt
+        and not _has_unpublished_user_turn(session_id)
+    ):
+        return
     text_cited_ids = cs_cite.parse_text_citations(assistant_text)
-    cited_ids = [*text_cited_ids, *transcript_cited_ids]
-    cited_items = _resolve_cited_items(session_id, cited_ids)
+    cited_items = _resolve_cited_items(session_id, text_cited_ids)
     plan_decisions = _scan_transcript_for_plan_decisions(entries)
 
     now = int(time.time())

package/plugin/src/claude_smart/internal_call.py

@@ -36,6 +36,7 @@ Detection signals, OR'd:
 
 from __future__ import annotations
 
+import json
 import os
 from pathlib import Path
 from typing import Any
@@ -117,3 +118,25 @@ def is_codex_internal_prompt(prompt: Any) -> bool:
         and _CODEX_SUGGESTIONS_PROMPT_MARKER in text
         and _CODEX_SUGGESTIONS_APPS_MARKER in text
     )
+
+
+def is_codex_title_response(content: Any) -> bool:
+    """True for Codex's title-generator response body.
+
+    Codex can run a separate title-generation task whose Stop payload contains
+    only the assistant response, e.g. ``{"title":"Fix tests"}``, with no
+    corresponding user turn. That metadata is useful to Codex's UI, but it is
+    not a user interaction and should not be published to reflexio.
+    """
+    if not isinstance(content, str):
+        return False
+    try:
+        parsed = json.loads(content)
+    except json.JSONDecodeError:
+        return False
+    return (
+        isinstance(parsed, dict)
+        and set(parsed) == {"title"}
+        and isinstance(parsed.get("title"), str)
+        and bool(parsed["title"].strip())
+    )

package/plugin/src/claude_smart/state.py

@@ -77,7 +77,7 @@ def session_path(session_id: str) -> Path:
 
 
 def injected_path(session_id: str) -> Path:
-    """Return the JSONL path for the per-session cs-cite registry."""
+    """Return the JSONL path for the per-session citation registry."""
     return state_dir() / f"{session_id}.injected.jsonl"
 
 
@@ -85,8 +85,8 @@ def append_injected(session_id: str, entries: Iterable[dict[str, Any]]) -> None:
     """Append citation-registry entries to the per-session injected-items file.
 
     Each entry maps a short ``id`` (4-hex-char) back to the skill or
-    preference it came from so the Stop hook can resolve ids cited by
-    Claude via ``cs-cite`` into human-readable titles for the dashboard.
+    preference it came from so the Stop hook can resolve citation ids into
+    human-readable titles for the dashboard.
     Silently no-ops when ``entries`` is empty.
     """
     records = list(entries)