@caddis/cli 0.4.60 → 0.4.62

package/bundles/antigravity-plugin/scripts/caddis_roadmap_run.py

@@ -899,6 +899,9 @@ def _one_session(ctx: _Ctx, prompt: str, relay_slug: str, n: int, spent: float,
     cmd = build_command(ctx.engine, ctx.model, prompt, usd=usd, timeout_min=remaining_s / 60, governor=ctx.governor,
                         engine_cmd=ctx.engine_cmd, worktree=cwd)
     rid = _spend_reserve(ctx.home, spend_slug, ctx.now(), n > 1) if ctx.engine == "agy" else None
+    if ctx.engine == "agy":  # agy's tool consoles open on a hidden desktop, not on the owner's screen
+        g = len(ctx.governor)
+        cmd = [*cmd[:g], *caddis_spend.hidden_argv(cmd[g:], session_env())]
     launched, outcome = ctx.clock(), None
     try:
         _, hash_before = _read_relay(cwd, relay_slug)

package/bundles/antigravity-plugin/scripts/caddis_spend.py

@@ -42,6 +42,8 @@ CLI:
         CADDIS_SPEND_RUN_TIMEOUT_S, else 3600 s) and its process tree was killed. 75 and 78 are never
         agy's own codes for a refusal, so a caller can tell "the cap refused" from "agy failed". Each
         refusal also prints a `caddis_spend:` line.
+        On Windows the command runs on a hidden desktop (caddis_hidden_desktop.py), so the console windows agy opens
+        for its tools never show; CADDIS_AGY_VISIBLE=1 runs it on the normal desktop.
 """
 
 from __future__ import annotations
@@ -50,6 +52,7 @@ import argparse
 import json
 import math
 import os
+import shutil
 import subprocess
 import sys
 import time
@@ -385,11 +388,30 @@ def _kill_tree(proc: subprocess.Popen) -> None:
         pass
 
 
+HIDDEN_DESKTOP_SCRIPT = Path(__file__).with_name("caddis_hidden_desktop.py")
+AGY_VISIBLE_VAR = "CADDIS_AGY_VISIBLE"
+
+
+def hidden_argv(argv: list[str], env: dict | None = None) -> list[str]:
+    """`argv` wrapped to run on the hidden desktop (caddis_hidden_desktop.py), so the console windows agy opens for
+    its tools never show on the owner's screen. Unchanged when: not Windows, env CADDIS_AGY_VISIBLE=1, the launcher
+    is not beside this file, or the program is not found. In the last case the caller's own start raises
+    FileNotFoundError as before; the program is resolved here, so the launcher never has to report it."""
+    env = os.environ if env is None else env
+    if os.name != "nt" or not argv or env.get(AGY_VISIBLE_VAR) == "1" or not HIDDEN_DESKTOP_SCRIPT.is_file():
+        return list(argv)
+    program = shutil.which(argv[0], path=env.get("PATH"))
+    if program is None:
+        return list(argv)
+    return [sys.executable, str(HIDDEN_DESKTOP_SCRIPT), "--", program, *argv[1:]]
+
+
 def _run_child(argv: list[str], env: dict, timeout_s: float) -> tuple[int | None, str, str]:
-    """Run `argv` with a time limit. Returns (returncode, stdout, stderr); returncode is None on a timeout, after
-    the whole process tree was killed. Raises FileNotFoundError when the program does not exist."""
+    """Run `argv` with a time limit, on the hidden desktop on Windows (hidden_argv). Returns (returncode, stdout,
+    stderr); returncode is None on a timeout, after the whole process tree was killed. Raises FileNotFoundError when
+    the program does not exist."""
     group = {} if os.name == "nt" else {"start_new_session": True}
-    proc = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8",
+    proc = subprocess.Popen(hidden_argv(argv, env), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8",
                             errors="replace", env=env, **_NO_WINDOW_KW, **group)
     try:
         out, err = proc.communicate(timeout=timeout_s)

package/bundles/antigravity-plugin/scripts/caddis_statusline.py

@@ -71,8 +71,9 @@ DEFAULT_CONFIG = {
     "bar_width": 8,
     "token_counts": True,   # ◉ 412k/1M  — off falls back to a bare ctx:41%
     "cached_tokens": True,  # ⚡38k cached — rendered LOUD, see render_claude()
-    "ram": True,            # 💻 69% (44 GB)
-    "clock": True,          # ◷ 03:41
+    "ram": False,           # 💻 69% (44 GB) - off by default (owner, 20 Oct 2026)
+    "thinking": False,      # Claude's "thinking" flag, agy's "thinking" state - off by default (20 Oct 2026)
+    "clock": False,         # ◷ 03:41 - off by default (owner, 20 Oct 2026)
     "relay": True,          # ⏺ relay  (a parked resume pointer exists)
     "rate_limits": True,    # 5h:12% 7d:40%
     "session_id": False,    # #a1b2c3d4
@@ -468,7 +469,7 @@ def cached_segment(c: C, cfg: dict, cached: int) -> str:
 
 
 def ram_segment(c: C, cfg: dict) -> str:
-    if not cfg.get("ram", True):
+    if not cfg.get("ram", False):
         return ""
     min_w = as_int(cfg.get("ram_min_width"), 0)
     if min_w and term_width() < min_w:
@@ -482,7 +483,7 @@ def ram_segment(c: C, cfg: dict) -> str:
 
 
 def clock_segment(c: C, cfg: dict) -> str:
-    if not cfg.get("clock", True):
+    if not cfg.get("clock", False):
         return ""
     return c.dim + icon(cfg, "clock") + time.strftime("%H:%M") + c.reset
 
@@ -549,7 +550,7 @@ def render_claude(data: dict, cfg: dict) -> str:
     if style and str(style).lower() != "default":
         parts.append(c.blue + "style:" + str(style) + c.reset)
 
-    if dig(data, "thinking", "enabled") is True:
+    if cfg.get("thinking", False) and dig(data, "thinking", "enabled") is True:
         parts.append(c.magenta + "thinking" + c.reset)
 
     if cfg.get("rate_limits", True):
@@ -581,7 +582,7 @@ def render_claude(data: dict, cfg: dict) -> str:
 
     session_name = dig(data, "session_name")
     if session_name:
-        parts.append(c.dim + '"' + str(session_name) + '"' + c.reset)
+        parts.append(c.bold + c.magenta + str(session_name) + c.reset)  # bright, so the session is easy to spot
 
     if cfg.get("session_id", False):
         sid = str(dig(data, "session_id") or "")
@@ -616,6 +617,8 @@ def render_agy(data: dict, cfg: dict) -> str:
         parts.append(c.white + c.bold + "agy" + c.reset)
 
     state = str(dig(data, "agent_state") or dig(data, "execution_mode") or "").lower()
+    if state == "thinking" and not cfg.get("thinking", False):
+        state = ""  # working and idle still show
     if state:
         label, col = {
             "working": (icon(cfg, "bolt") + "working", c.green),
@@ -704,6 +707,61 @@ HOST_SETTINGS = {
 }
 
 
+VERSION_STAMP = INSTALL_DIR / "statusline.version"
+
+
+def plugin_version(here: Path | None = None) -> str:
+    """The caddis version of the plugin this file ships in: `.claude-plugin/plugin.json` or a root `plugin.json`
+    one folder above `scripts/`. "" in a source checkout or when unreadable."""
+    base = Path(here or Path(__file__).resolve().parent).parent
+    for manifest in (base / ".claude-plugin" / "plugin.json", base / "plugin.json"):
+        try:
+            data = json.loads(manifest.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if isinstance(data, dict) and str(data.get("name", "")).startswith("caddis") and data.get("version"):
+            return str(data["version"])
+    return ""
+
+
+def _version_key(text: str):
+    parts = str(text or "").strip().split(".")
+    return tuple(int(x) for x in parts) if parts and all(x.isdigit() for x in parts) else None
+
+
+def refresh_installed(src: Path | None = None, version: str | None = None) -> bool:
+    """Bring the installed renderer (`~/.caddis/statusline.py`) up to this plugin's copy.
+
+    Why (20 Oct 2026): only `--install` copied the renderer, so a caddis update never reached it. This machine
+    kept a copy whose `git` calls opened a console window each time agy drew its status line.
+    Rules: nothing happens unless the status line was installed; the copy happens only when this plugin's version
+    is newer than the one stamped at the last copy (an older session never downgrades it); a source checkout
+    (no plugin version) never copies. Returns True when it copied."""
+    src = Path(src or Path(__file__).resolve())
+    version = plugin_version() if version is None else version
+    if not INSTALLED_SCRIPT.is_file() or _version_key(version) is None:
+        return False
+    try:
+        stamped = VERSION_STAMP.read_text(encoding="utf-8").strip()
+    except OSError:
+        stamped = ""
+    old = _version_key(stamped)
+    if old is not None and old >= _version_key(version):
+        return False
+    try:
+        if src.resolve() != INSTALLED_SCRIPT.resolve() and src.read_bytes() != INSTALLED_SCRIPT.read_bytes():
+            tmp = INSTALLED_SCRIPT.with_name("%s.%d.tmp" % (INSTALLED_SCRIPT.name, os.getpid()))
+            shutil.copyfile(str(src), str(tmp))
+            os.replace(str(tmp), str(INSTALLED_SCRIPT))
+            copied = True
+        else:
+            copied = False
+        VERSION_STAMP.write_text(version + "\n", encoding="utf-8")
+        return copied
+    except OSError:
+        return False  # a session start must never fail over the status line
+
+
 def python_command() -> str:
     """The interpreter NAME to write into settings — not an absolute path.
 
@@ -726,6 +784,14 @@ def install(hosts, dry_run: bool = False) -> int:
     # because the version is in the path.
     if not dry_run and src != INSTALLED_SCRIPT.resolve():
         shutil.copyfile(str(src), str(INSTALLED_SCRIPT))
+    if not dry_run:
+        # Stamp the version, so a later --refresh from an OLDER plugin session cannot replace this copy.
+        version = plugin_version()
+        if _version_key(version) is not None:
+            try:
+                VERSION_STAMP.write_text(version + "\n", encoding="utf-8")
+            except OSError:
+                pass
     print("renderer -> %s" % INSTALLED_SCRIPT)
 
     if not CONFIG_PATH.exists():
@@ -903,8 +969,14 @@ def main(argv=None) -> int:
     parser.add_argument("--dry-run", action="store_true", help="with --install: print, write nothing")
     parser.add_argument("--no-color", action="store_true", help="render without ANSI colour")
     parser.add_argument("--title", action="store_true", help="render terminal title (agy)")
+    parser.add_argument("--refresh", action="store_true",
+                        help="copy this plugin's renderer over an older installed one (session-start hook)")
     args = parser.parse_args(argv)
 
+    if args.refresh:
+        refresh_installed()
+        return 0  # silent and never failing: it runs at every session start
+
     # The line is Unicode. On Windows the default cp1252 stdout raises on ◆/⎇/█.
     try:
         sys.stdout.reconfigure(encoding="utf-8", errors="replace")

package/bundles/antigravity-plugin/scripts/caddis_todo.py

@@ -43,7 +43,10 @@ def _path(root: Path, workstream: str | None) -> tuple[Path, Path]:
     artifact = _artifact(root)
     name = _name(workstream) if workstream is not None else "inbox"
     folder = artifact / "todo-list"
-    if folder.is_symlink() or not folder.resolve().is_relative_to(artifact.resolve()):
+    # Only a folder that EXISTS can point elsewhere. Resolving one that does not exist yet raced a concurrent
+    # writer creating it: on Windows the two paths could resolve differently (a short 8.3 name on one side), and a
+    # safe add failed with this error (main CI, 20 Oct 2026, test_concurrent_inbox_add_loses_no_item).
+    if folder.is_symlink() or (folder.exists() and not folder.resolve().is_relative_to(artifact.resolve())):
         raise ValueError("todo-list path escapes artifact root")
     path = folder / f"{name}.md"
     # Reads are unlocked, so refuse here as well as in locked_path. On Windows a writer replacing the file

package/bundles/antigravity-plugin/scripts/caddis_workstreams.py

@@ -58,7 +58,9 @@ def _plain_name(value: str) -> str:
 def _artifact(root: Path) -> Path:
     project = Path(root).resolve()
     artifact = Path(root) / ".caddis"
-    if not artifact.resolve().is_relative_to(project) or artifact.is_symlink():
+    # Only an existing .caddis can point elsewhere; resolving one that does not exist yet raced a concurrent writer
+    # creating it (see caddis_todo._path, 20 Oct 2026).
+    if artifact.is_symlink() or (artifact.exists() and not artifact.resolve().is_relative_to(project)):
         raise ValueError("artifact root escapes project")
     return artifact
 

package/bundles/manifest.json

@@ -1,7 +1,7 @@
 {
-  "poolVersion": "1.3.146",
+  "poolVersion": "1.3.148",
   "bundles": {
-    "antigravity-plugin": "1.3.146",
+    "antigravity-plugin": "1.3.148",
     "antigravity-plugin-extras": "1.3.45",
     "codex": "unknown"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caddis/cli",
-  "version": "0.4.60",
+  "version": "0.4.62",
   "description": "Install, update and diagnose the caddis dev harness across every coding agent you use (Claude Code, agy/Antigravity, and more).",
   "keywords": [
     "caddis",