code-context-control 2.42.0__py3-none-any.whl → 2.43.0__py3-none-any.whl

cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.42.0"
+__version__ = "2.43.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -6475,6 +6475,24 @@ def cmd_upgrade(args):
     print("  In each project, run  c3 init . --force  to apply any migrations.")
 
 
+def _stdio_is_interactive() -> bool:
+    """True when stdin AND stdout are attached to a real terminal.
+
+    Used to decide whether bare `c3` may launch the full-screen TUI. With
+    redirected stdio (pytest capture_output, CI, shell pipes) a TUI child
+    would inherit our pipe handles and keep them open past our own death;
+    on Windows the caller's communicate() then blocks forever because
+    subprocess timeouts kill only the direct child, never the tree.
+    """
+    try:
+        return bool(
+            sys.stdin is not None and sys.stdin.isatty()
+            and sys.stdout is not None and sys.stdout.isatty()
+        )
+    except Exception:
+        return False
+
+
 def _launch_tui() -> None:
     """Launch the interactive TUI — what `c3` with no arguments does.
 
@@ -6524,8 +6542,16 @@ def main():
     args = parser.parse_args()
 
     if not args.command:
-        # Bare `c3` launches the interactive TUI (replaces the old c3.bat wrapper).
-        _launch_tui()
+        # Bare `c3` launches the interactive TUI (replaces the old c3.bat
+        # wrapper) — but only when attached to a real console. With redirected
+        # stdio there is no terminal for a full-screen app anyway, and the TUI
+        # child would inherit our stdout/stderr pipe handles and hold them
+        # open past our own death (a caller's communicate() then hangs forever
+        # on Windows). Print help instead of spawning anything.
+        if _stdio_is_interactive():
+            _launch_tui()
+        else:
+            parser.print_help()
         return
 
     commands = {

cli/hook_ghost_files.py

@@ -212,6 +212,21 @@ def cleanup_ghost_files(ghosts: list[dict]) -> list[str]:
     return deleted
 
 
+def sweep_ghost_files(project_root) -> list[str]:
+    """Scan *project_root* and delete any ghost files in one call.
+
+    Convenience wrapper (scan + cleanup) so callers outside the Bash PostToolUse
+    hook — e.g. long-lived MCP-server background agents whose cwd is the project
+    root, or git worktrees where no PostToolUse hook runs — can self-clean the
+    root. Returns the list of deleted file names (empty if none). Never raises.
+    """
+    try:
+        root = project_root if isinstance(project_root, Path) else Path(project_root)
+        return cleanup_ghost_files(scan_ghost_files(root))
+    except Exception:
+        return []
+
+
 # Tools whose output can carry shell-meta text that leaks into 0-byte files:
 # native shells, c3_shell (its `N->Mtok` filter header), and file reads whose
 # content has `-> Type` hints. A downstream shell sees `> word` and creates an

cli/mcp_server.py

@@ -423,9 +423,10 @@ async def c3_session(action: str, data: str = "", reasoning: str = "",
 @mcp.tool()
 async def c3_memory(action: str, query: str = "", fact: str = "",
               category: str = "", top_k: int = 3,
-              fact_id: str = "", ctx: Context = None) -> str:
+              fact_id: str = "", include_scores: bool = False,
+              ctx: Context = None) -> str:
     """Durable facts — cross-session knowledge. Read-only actions safe in plan mode.
-    Retrieve: recall (search), index (compact IDs+snippets, then fetch), fetch (full text by fact_id="id1,id2"), query (multi-source: facts+sessions+files).
+    Retrieve: recall (search; include_scores=True adds per-fact salience), index (compact IDs+snippets, then fetch), fetch (full text by fact_id="id1,id2"), query (multi-source: facts+sessions+files).
     Write:    add (fact+category, empty category→'general'), update (fact_id+fact), delete (fact_id).
     Browse:   list (category='' shows all; 'foo' filters), export (markdown).
     Audit:    review (health), ground (verify against code), score (salience), graph (edges), trends, lifespan, consolidate, consolidate_deep."""
@@ -435,7 +436,7 @@ async def c3_memory(action: str, query: str = "", fact: str = "",
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
     return await asyncio.to_thread(handle_memory, action, query, fact, category, top_k, svc, finalize,
-                                   fact_id=fact_id)
+                                   fact_id=fact_id, include_scores=include_scores)
 
 
 @mcp.tool()

cli/tools/_helpers.py

@@ -8,6 +8,26 @@ def maybe_related_facts(svc, topic: str, top_k: int = 3, width: int = 100) -> st
     return ""
 
 
+# ── Response boilerplate diet (P6) ───────────────────────────────────────────
+
+def show_token_ratios(svc) -> bool:
+    """Debug flag: restore per-call "raw->optimized tok" ratio headers.
+
+    Off by default — the ratio header was ~100-200 tokens/session of
+    boilerplate the model does nothing with. Accounting no longer depends on
+    the displayed header: migrated tools report (raw_tokens, optimized_tokens)
+    structurally via finalize_with_tokens(). Set
+    ``{"hybrid": {"show_token_ratios": true}}`` in .c3/config.json to see the
+    old headers again (same convention as SHOW_SAVINGS_SUMMARY /
+    show_savings_footer).
+    """
+    try:
+        return bool((getattr(svc, "hybrid_config", None) or {}).get(
+            "show_token_ratios", False))
+    except Exception:
+        return False
+
+
 # ── Structured token accounting (honest measurement layer) ──────────────────
 
 def finalize_with_tokens(finalize, svc, tool_name: str, args: dict,

cli/tools/compress.py

@@ -10,6 +10,8 @@ from pathlib import Path
 
 from core import count_tokens
 
+from cli.tools._helpers import finalize_with_tokens, show_token_ratios
+
 
 def _run_memory_mcp_cli(args: list, cwd: str, timeout: int = 30) -> tuple:
     """Run codebase-memory-mcp CLI and return (success, output_or_error)."""
@@ -139,23 +141,32 @@ def _compress_single(file_path: str, mode: str, svc, finalize, maybe_facts) -> s
         res = (svc.file_memory.get_or_build_dense_map(rel)
                if mode == "dense_map"
                else svc.file_memory.get_or_build_map(rel))
+        # Structured accounting: pass the (full-read baseline, map) pair via
+        # record_tool_tokens() instead of a "raw->maptok" summary for the
+        # legacy regex fallback to scrape.
+        raw_tokens = None
         map_tokens = 0
         try:
             raw_tokens = count_tokens(full.read_text(encoding="utf-8", errors="replace"))
             map_tokens = count_tokens(res)
-            summary = f"{raw_tokens}->{map_tokens}tok"
+            summary = mode
         except Exception:
             summary = "mapped"
-        return finalize("c3_compress", {"file_path": file_path, "mode": mode}, res, summary,
-                        response_tokens=map_tokens)
+        return finalize_with_tokens(
+            finalize, svc, "c3_compress", {"file_path": file_path, "mode": mode},
+            res, summary,
+            raw_tokens=raw_tokens, optimized_tokens=map_tokens or None,
+            response_tokens=map_tokens)
 
     res = svc.compressor.compress_file(str(full), mode)
     if "error" in res:
         return f"Error: {res['error']}"
     resp = res['compressed']
-    summary = f"{res['original_tokens']}->{res['compressed_tokens']}tok"
-    return finalize("c3_compress", {"file_path": file_path},
-                    resp + maybe_facts(svc, Path(file_path).name), summary)
+    return finalize_with_tokens(
+        finalize, svc, "c3_compress", {"file_path": file_path},
+        resp + maybe_facts(svc, Path(file_path).name), mode,
+        raw_tokens=res.get('original_tokens'),
+        optimized_tokens=res.get('compressed_tokens'))
 
 
 def _compress_batch(paths: list, mode: str, svc, finalize, maybe_facts) -> str:
@@ -166,12 +177,13 @@ def _compress_batch(paths: list, mode: str, svc, finalize, maybe_facts) -> str:
     results = {}
 
     def _do_one(fp):
+        """Returns (fp, compressed_text, raw_tokens, optimized_tokens, error)."""
         try:
             full = Path(svc.project_path) / fp
             if not full.exists():
                 full = Path(fp)
             if not full.exists():
-                return fp, None, "not found"
+                return fp, None, None, None, "not found"
 
             if mode in ("map", "dense_map"):
                 rel = str(full.resolve().relative_to(
@@ -182,34 +194,50 @@ def _compress_batch(paths: list, mode: str, svc, finalize, maybe_facts) -> str:
                 try:
                     raw_tok = count_tokens(full.read_text(encoding="utf-8", errors="replace"))
                     map_tok = count_tokens(res)
-                    return fp, res, f"{raw_tok}->{map_tok}tok"
+                    return fp, res, raw_tok, map_tok, None
                 except Exception:
-                    return fp, res, "mapped"
+                    return fp, res, None, None, None
             else:
                 res = svc.compressor.compress_file(str(full), mode)
                 if "error" in res:
-                    return fp, None, res["error"]
-                return fp, res["compressed"], f"{res['original_tokens']}->{res['compressed_tokens']}tok"
+                    return fp, None, None, None, res["error"]
+                return (fp, res["compressed"], res.get("original_tokens"),
+                        res.get("compressed_tokens"), None)
         except Exception as e:
-            return fp, None, str(e)
+            return fp, None, None, None, str(e)
 
     with ThreadPoolExecutor(max_workers=min(len(paths), 8)) as pool:
         futures = {pool.submit(_do_one, fp): fp for fp in paths}
         for fut in as_completed(futures):
-            fp, compressed, summary = fut.result()
-            results[fp] = (compressed, summary)
+            fp, compressed, raw_tok, opt_tok, err = fut.result()
+            results[fp] = (compressed, raw_tok, opt_tok, err)
 
+    ratios = show_token_ratios(svc)
     parts = []
     total_ok = 0
+    total_raw = 0
+    total_opt = 0
+    measured = 0
     for fp in paths:
-        compressed, summary = results.get(fp, (None, "unknown"))
+        compressed, raw_tok, opt_tok, err = results.get(fp, (None, None, None, "unknown"))
         if compressed:
-            parts.append(f"## {fp} ({summary})\n{compressed}")
+            tag = ""
+            if raw_tok is not None and opt_tok is not None:
+                measured += 1
+                total_raw += raw_tok
+                total_opt += opt_tok
+                if ratios:
+                    tag = f" ({raw_tok}->{opt_tok}tok)"
+            parts.append(f"## {fp}{tag}\n{compressed}")
             total_ok += 1
         else:
-            parts.append(f"## {fp} — ERROR: {summary}")
+            parts.append(f"## {fp} — ERROR: {err}")
 
     header = f"[compress:batch] {total_ok}/{len(paths)} files ({mode})"
     body = header + "\n\n" + "\n\n".join(parts)
-    return finalize("c3_compress", {"file_path": ",".join(paths), "mode": mode, "batch": True},
-                    body, f"batch {total_ok}/{len(paths)}")
+    return finalize_with_tokens(
+        finalize, svc, "c3_compress",
+        {"file_path": ",".join(paths), "mode": mode, "batch": True},
+        body, f"batch {total_ok}/{len(paths)}",
+        raw_tokens=total_raw if measured else None,
+        optimized_tokens=total_opt if measured else None)

cli/tools/delegate.py

@@ -17,6 +17,7 @@ from pathlib import Path
 
 from core import count_tokens
 from services.circuit_breaker import CircuitBreaker
+from services.win_subprocess import harden_win_argv
 
 log = logging.getLogger(__name__)
 
@@ -220,7 +221,7 @@ def _run_claude(task: str, context: str, cwd: str | None = None,
     cmd = [exe, "-p", prompt, "--output-format", "text"]
     try:
         proc = subprocess.Popen(
-            cmd,
+            harden_win_argv(cmd),
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
             text=True, encoding="utf-8", errors="replace", cwd=cwd,
@@ -466,7 +467,7 @@ def _run_gemini(task: str, context: str, model: str,
 
     try:
         proc = subprocess.Popen(
-            cmd,
+            harden_win_argv(cmd),
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
             text=True, encoding="utf-8", errors="replace",
@@ -581,7 +582,7 @@ def _run_codex(task: str, context: str, model: str, sandbox: str,
     ]
     try:
         proc = subprocess.Popen(
-            cmd,
+            harden_win_argv(cmd),
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
             text=True, encoding="utf-8", errors="replace",

cli/tools/filter.py

@@ -12,6 +12,8 @@ from pathlib import Path
 
 from core import count_tokens
 
+from cli.tools._helpers import finalize_with_tokens, show_token_ratios
+
 
 def handle_filter(file_path: str, text: str, pattern: str, max_lines: int,
                   depth: str, use_llm: bool, svc, finalize) -> str:
@@ -62,13 +64,19 @@ def _filter_text(text: str, depth: str, svc, finalize) -> str:
 
     filtered_tokens = count_tokens(result_text)
     raw_tokens = res['raw_tokens']
-    savings_pct = round((1 - filtered_tokens / raw_tokens) * 100, 1) if raw_tokens > 0 else 0
 
-    header = f"[filter:{method}] {raw_tokens}→{filtered_tokens}tok ({savings_pct}%saved)"
+    # The method tag is actionable signal (which pass ran); the token ratio is
+    # boilerplate — shown only under the show_token_ratios debug flag. The
+    # (raw, filtered) pair still flows to accounting structurally below.
+    header = f"[filter:{method}]"
+    if show_token_ratios(svc):
+        savings_pct = round((1 - filtered_tokens / raw_tokens) * 100, 1) if raw_tokens > 0 else 0
+        header = f"[filter:{method}] {raw_tokens}→{filtered_tokens}tok ({savings_pct}%saved)"
     resp = f"{header}\n{result_text}"
-    return finalize("c3_filter", {"depth": depth},
-                    resp, f"{raw_tokens}→{filtered_tokens}tok",
-                    response_tokens=filtered_tokens)
+    return finalize_with_tokens(
+        finalize, svc, "c3_filter", {"depth": depth}, resp, method,
+        raw_tokens=raw_tokens, optimized_tokens=filtered_tokens,
+        response_tokens=filtered_tokens)
 
 
 def _heuristic_collapse(text: str) -> str | None:
@@ -279,7 +287,12 @@ def _filter_file(full: Path, file_path: str, pattern: str, max_lines: int,
         extracted = "\n".join(lines[:max_lines])
 
     res_tok = count_tokens(extracted)
-    saved = round((1 - res_tok / orig_tok) * 100) if orig_tok > 0 else 0
-    return finalize("c3_filter", {"file": file_path, "pattern": pattern},
-                    f"[extract:{ext}] {orig_tok}->{res_tok}tok ({saved}% saved)\n{extracted}",
-                    f"{orig_tok}->{res_tok}tok")
+    header = f"[extract:{ext}]"
+    if show_token_ratios(svc):
+        saved = round((1 - res_tok / orig_tok) * 100) if orig_tok > 0 else 0
+        header = f"[extract:{ext}] {orig_tok}->{res_tok}tok ({saved}% saved)"
+    return finalize_with_tokens(
+        finalize, svc, "c3_filter", {"file": file_path, "pattern": pattern},
+        f"{header}\n{extracted}", "extract",
+        raw_tokens=orig_tok, optimized_tokens=res_tok,
+        response_tokens=res_tok)

cli/tools/memory.py

@@ -3,7 +3,8 @@ from datetime import datetime, timezone
 
 
 def handle_memory(action: str, query: str, fact: str, category: str,
-                  top_k: int, svc, finalize, fact_id: str = "") -> str:
+                  top_k: int, svc, finalize, fact_id: str = "",
+                  include_scores: bool = False) -> str:
     if action == "add":
         if not fact or not fact.strip():
             return finalize("c3_memory", {"action": action},
@@ -17,8 +18,9 @@ def handle_memory(action: str, query: str, fact: str, category: str,
     if action == "recall":
         session_id = (svc.session_mgr.current_session or {}).get("id", "")
         results = svc.memory.recall(query, top_k=top_k, session_id=session_id)
-        # Small recalls skip scoring + graph spreading to stay fast —
-        # agents using top_k<=3 want quick lookups, not full enrichment.
+        # Small recalls skip graph spreading to stay fast — agents using
+        # top_k<=3 want quick lookups, not full enrichment. (Salience scoring
+        # is opt-in via include_scores, independent of this.)
         fast_mode = top_k <= 3
         backend = "tfidf"
         if svc.vector_store:
@@ -43,9 +45,11 @@ def handle_memory(action: str, query: str, fact: str, category: str,
             if len(recalled_ids) >= 2:
                 graph.record_co_recall(recalled_ids[:top_k])
 
-        # Enrich results with salience scores (skipped in fast_mode)
+        # Enrich results with salience scores — opt-in only. Per-fact scores
+        # on every recall were display boilerplate; callers who want them ask
+        # via include_scores=True (explicit request overrides fast_mode).
         scorer = getattr(svc, "memory_scorer", None)
-        if scorer and not fast_mode:
+        if scorer and include_scores:
             for r in results:
                 if r.get("id"):
                     s = scorer.score(r, graph)
@@ -75,7 +79,8 @@ def handle_memory(action: str, query: str, fact: str, category: str,
                             f"[memory:recall:{query}] 0 results (backend:{backend})", "0")
         parts = []
         for f in results[:top_k]:
-            sal = f" sal={f['salience']:.2f}/{f['tier']}" if f.get("salience") is not None else ""
+            sal = (f" sal={f['salience']:.2f}/{f['tier']}"
+                   if include_scores and f.get("salience") is not None else "")
             parts.append(f"[{f['category']}]{sal} {f['fact']}")
         if activated_extra:
             parts.append(f"  [graph:activated] {len(activated_extra)} related facts:")

cli/tools/search.py

@@ -7,6 +7,8 @@ from pathlib import Path
 
 from core import count_tokens
 
+from cli.tools._helpers import finalize_with_tokens, show_token_ratios
+
 # Hard cap: responses above this are truncated to avoid filling context.
 _RESPONSE_TOKEN_CAP = 2400
 
@@ -173,6 +175,7 @@ def _transcript_search(query, top_k, max_tokens, svc, finalize):
         srcs = ",".join(sorted(available_names))
         return finalize("c3_search", {"action": "transcript"},
                         f"[transcript:{query}] 0 results sources:{srcs}", "0")
+    ratios = show_token_ratios(svc)
     parts = []
     total_tokens = 0
     emitted = 0
@@ -188,14 +191,23 @@ def _transcript_search(query, top_k, max_tokens, svc, finalize):
             ts_str = ""
         source = r.get("source") or r.get("turn_source") or "manual"
         role = r.get("role", "")
-        session_id = r.get("session_id", "")
-        header = f"--- {source}:{session_id} [{ts_str}] role:{role} score:{r['score']}"
+        session_id = str(r.get("session_id", ""))
+        if ratios:
+            # Debug view: full session id + relevance score (old header).
+            header = f"--- {source}:{session_id} [{ts_str}] role:{role} score:{r['score']}"
+        else:
+            # Minimal per-item header — full UUIDs and scores were ~40 tokens
+            # of boilerplate per result the model does nothing with.
+            header = f"--- {source}:{session_id[:8]} {ts_str} {role}".rstrip()
         text = r.get("text", "")
         parts.extend([header, text])
         emitted += 1
         if emitted >= top_k:
             break
-    resp = f"[transcript:{query}] {emitted}r,{total_tokens}tok\n" + "\n".join(parts)
+    head = f"[transcript:{query}] {emitted}r"
+    if ratios:
+        head += f",{total_tokens}tok"
+    resp = head + "\n" + "\n".join(parts)
     return finalize("c3_search", {"action": "transcript"}, resp, f"{emitted}r")
 
 
@@ -221,8 +233,10 @@ def _semantic_search(query, top_k, max_tokens, svc, finalize, maybe_facts):
 
     resp = "\n".join(lines)
     resp += maybe_facts(svc, query, top_k=2)
-    return finalize("c3_search", {"query": query, "action": "semantic"}, resp,
-                    f"{len(results)}r,{total_tokens}tok", response_tokens=total_tokens)
+    return finalize_with_tokens(
+        finalize, svc, "c3_search", {"query": query, "action": "semantic"}, resp,
+        f"{len(results)}r",
+        optimized_tokens=total_tokens, response_tokens=total_tokens)
 
 
 def _code_search(query, top_k, max_tokens, svc, finalize, maybe_facts):
@@ -255,10 +269,14 @@ def _code_search(query, top_k, max_tokens, svc, finalize, maybe_facts):
 
     resp = "\n".join(lines)
     resp += maybe_facts(svc, query, top_k=2)
+    # Structured accounting: the (full-read baseline, returned) pair flows via
+    # record_tool_tokens() instead of being regex-scraped from the summary.
     full_tokens = sum(r.get("file_tokens", r["tokens"]) for r in deduped)
-    summary = f"{full_tokens}->{total_tokens}tok" if total_tokens < full_tokens else f"{len(deduped)}r"
-    return finalize("c3_search", {"query": query, "top_k": top_k}, resp, summary,
-                    response_tokens=total_tokens)
+    return finalize_with_tokens(
+        finalize, svc, "c3_search", {"query": query, "top_k": top_k}, resp,
+        f"{len(deduped)}r",
+        raw_tokens=full_tokens, optimized_tokens=total_tokens,
+        response_tokens=total_tokens)
 
 
 def _append_prefetch(resp: str, query: str, top_k: int, svc) -> str:

cli/tools/status.py

@@ -89,16 +89,31 @@ def _budget_view(svc, detailed, finalize):
     if c3_calls + native_calls > 0:
         lines.append(f"[c3_adoption] {adoption}% ({c3_calls}c3/{native_calls}native)")
 
-    # Per-tool token breakdown
+    # Per-tool token breakdown — adaptive: only tools actually used this
+    # session (non-zero tokens), no fixed-width padding.
     by_tool = snap.get("by_tool", {})
-    if by_tool:
-        sorted_tools = sorted(by_tool.items(), key=lambda x: -x[1])
-        shown = sorted_tools[:6]
+    used_tools = sorted(((n, t) for n, t in by_tool.items() if t > 0),
+                        key=lambda x: -x[1])
+    if used_tools:
+        shown = used_tools[:6]
         breakdown = " | ".join(f"{n}:{t}tok" for n, t in shown)
-        if len(sorted_tools) > 6:
-            breakdown += f" (+{len(sorted_tools) - 6} more)"
+        if len(used_tools) > 6:
+            breakdown += f" (+{len(used_tools) - 6} more)"
         lines.append(f"[breakdown] {breakdown}")
 
+    # ONE aggregate savings line — the session-level story lives here, not in
+    # per-call response headers. Fed by structured record_tool_tokens()
+    # accounting; labeled honestly (full-read baseline is a counterfactual).
+    try:
+        usage = (svc.session_mgr.current_session or {}).get("token_usage") or {}
+        saved = int(usage.get("estimated_saved_vs_full_read", 0) or 0)
+        ops = int(usage.get("measured_ops", 0) or 0)
+        if saved > 0:
+            lines.append(f"[savings] ~{format_token_count(saved)} est. saved "
+                         f"vs full-read baseline ({ops} measured ops)")
+    except Exception:
+        pass
+
     if detailed:
         stats = svc.indexer.get_stats()
         lines.append(f"[index] files:{stats['files_indexed']} "

{code_context_control-2.42.0.dist-info → code_context_control-2.43.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.42.0
+Version: 2.43.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0