codebyplan 1.13.22 → 1.13.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.13.22",
+  "version": "1.13.24",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {

package/templates/hooks/README.md

@@ -18,7 +18,7 @@ Renders up to 6 structured lines below Claude Code's prompt area. Reads JSON fro
 
 **Render lines:**
 
-- **Line 1 — Identity**: **folder name** (basename of `cwd`) + **git branch** (always shown — taken from `worktree.branch`, else derived via `git -C <cwd> rev-parse --abbrev-ref HEAD`, so it appears even without a registered worktree); single prefix (`wt:NAME` / `session:NAME` / `agent:NAME`, priority order); model **display name only**; `effort:LEVEL` (when set); `thinking:on` (only when thinking is enabled); `style:NAME` (when output style is not "default"); `[VIM_MODE]`
+- **Line 1 — Identity**: **folder name** (basename of `cwd`) + **git branch** (always shown — taken from `worktree.branch`, else derived via `git -C <cwd> rev-parse --abbrev-ref HEAD`, so it appears even without a registered worktree); single prefix (`wt:NAME` / `session:NAME` / `agent:NAME`, priority order); model **display name only**; `effort:LEVEL` (when set); `style:NAME` (when output style is not "default"); `[VIM_MODE]`
 - **Line 2 — Context**: 20-character progress bar (green / yellow / red at 50% / 75%); `used% / ctx_size`; per-call token breakdown — `in:N out:N cache_cr:N cache_rd:N` (from `context_window.current_usage`); `⚠ 200k+` banner when `exceeds_200k_tokens` is true
 - **Line 3 — Cost**: session cost in USD; total wall duration (`dur:`) and API-only duration (`api:`) via human-readable format; lines added/removed
 - **Line 4 — Rate limits**: `5h: PCT% (resets in Xh)` and `7d: PCT% (resets in Xd)` with relative-time helper; colour-coded green / yellow / red at 60% / 80%; emitted only when at least one window has a non-zero `resets_at` epoch
@@ -224,63 +224,13 @@ After a `complete_round` MCP call succeeds, reconciles the round's `files_change
 
 ---
 
-### `cbp-cmux-workspace-sync.sh` — SessionStart, matcher `*`
-
-On every session start, syncs the active [cmux](https://github.com/nicholasgasior/cmux) workspace title to the current git branch, the workspace description to the repo folder basename (the directory that contains `.git/`), and applies the workspace color from `.codebyplan/cmux.json` via `cmux workspace-action --action set-color`. All three actions are delegated to `codebyplan cmux-sync`. If no `workspace_color` is configured, a one-line nudge is printed to stdout prompting the user to run `/cbp-setup-cmux`.
-
-**Blocks vs warns**: never blocks — exit 0 on every path. A SessionStart hook must never prevent a session from opening.
-
-**Skips when**: `$CMUX_WORKSPACE_ID` is unset (not running inside a cmux workspace). No-ops silently — cmux is an optional integration and repos without it are completely unaffected.
-
-**cmux binary resolution order**: `$CMUX_BUNDLED_CLI_PATH` → `$CMUX_CLAUDE_HOOK_CMUX_BIN` → `cmux` on `$PATH`. All three are resolved by the `codebyplan cmux-sync` subcommand; the hook itself does not replicate this logic.
-
-**Opt out**: settings.json override removing this entry, or plugin disable.
-
----
-
-### `cbp-cmux-branch-watch.sh` — PostToolUse, matcher `Bash`
-
-After any Bash tool call that contains a `git checkout` or `git switch` invocation, syncs the active cmux workspace title to the current branch and the workspace description to the repo folder basename. The match is broad — it also fires on file-restore forms like `git checkout -- <file>` — but `codebyplan cmux-sync` is idempotent, so a redundant sync on a non-branch-change is harmless, and a real branch change is never missed.
-
-**Blocks vs warns**: never blocks — exit 0 on every path. PostToolUse hooks must never abort Claude.
-
-**Skips when**: `$CMUX_WORKSPACE_ID` is unset; or the Bash command contains no `git checkout` / `git switch`; or `jq` is not on `$PATH` (safe parse failure → exit 0). Outside cmux or on commands without checkout/switch, the hook exits immediately with no work done.
-
-**cmux binary resolution order**: same as `cbp-cmux-workspace-sync.sh` — delegated to `codebyplan cmux-sync`.
-
-**Opt out**: settings.json override removing the PostToolUse Bash entry for this hook, or plugin disable.
-
----
-
-### Auto dev server (`codebyplan cmux-serve`)
-
-At the start of each round, `cbp-round-execute` (Step 2a) calls `codebyplan cmux-serve --files "<round files>"` to auto-start the dev server for any app whose source files are touched. The subcommand probes each allocated port via `node:net`, starts a `cmux new-split` terminal pane + sends the dev command for any non-listening app, then opens a browser pane. If the port is already listening (another worktree) it only opens the browser pane. No hook registration is needed — the skill invokes the subcommand directly. Gated by `auto_dev_server` in `.codebyplan/cmux.json`; no-op outside cmux.
-
----
-
-### Status surface (`codebyplan cmux-status`)
-
-The lifecycle skills push CodeByPlan development state into the cmux workspace sidebar via `codebyplan cmux-status`. No hook registration is needed — the skills invoke the subcommand directly:
-
-| Skill | What is pushed |
-| --- | --- |
-| `cbp-task-start` (Step 4.5) | `--checkpoint "CHK-NNN: title" --task "TASK-N: title"` |
-| `cbp-task-complete` (Step 7.3) | `--task "TASK-N: title done" --progress completed/total` |
-| `cbp-round-execute` (Step 3d) | `--qa "R{n} {status}"` where status ∈ completed / blocked / re-triggering |
-
-**`auto_status` toggle.** Gated by the `auto_status` field in `.codebyplan/cmux.json` (configured via `/cbp-setup-cmux`). When `auto_status` is `false`, every call is a no-op. Default is `true` (enabled).
-
-**No-op outside cmux.** `codebyplan cmux-status` checks for `$CMUX_WORKSPACE_ID` before doing anything. Outside a cmux workspace it exits immediately — safe to call unconditionally from skills and hooks.
-
----
-
 ## Supporting (not registered)
 
 ### `test-hooks.sh` — invoked by `auto-test-hooks.sh`
 
-Test suite for the plugin's 11 registered hooks. Runs two passes:
+Test suite for the plugin's 9 registered hooks. Runs two passes:
 
-1. **Header check** — every registered hook (`lint-format-on-edit`, `test-coverage-gate`, `pre-commit-quality-gate`, `maestro-yaml-validate`, `auto-test-hooks`, `mcp-migration-guard`, `validate-git-stash-deny`, `cbp-mcp-round-sync`, `cbp-cmux-workspace-sync`, `cbp-cmux-branch-watch`) carries the required `# Hook:` and `# Purpose:` header comments. `statusline` uses its own `# Claude Code Status Line` marker.
+1. **Header check** — every registered hook (`lint-format-on-edit`, `test-coverage-gate`, `pre-commit-quality-gate`, `maestro-yaml-validate`, `auto-test-hooks`, `mcp-migration-guard`, `validate-git-stash-deny`, `cbp-mcp-round-sync`) carries the required `# Hook:` and `# Purpose:` header comments. `statusline` uses its own `# Claude Code Status Line` marker.
 2. **Functional smoke tests** — each hook is invoked with synthetic stdin matching its fast-path / graceful-degrade input; all must exit 0.
 
 Not in `hooks.json` — invoked indirectly via `auto-test-hooks.sh` on hook edits, or directly via `bash ${CLAUDE_PLUGIN_ROOT}/hooks/test-hooks.sh`.

package/templates/hooks/cbp-statusline.mjs

@@ -77,7 +77,6 @@ function main() {
   );
   const EXCEEDS_200K = get(data, ["exceeds_200k_tokens"], false);
   const EFFORT = get(data, ["effort", "level"], "");
-  const THINKING = get(data, ["thinking", "enabled"], false);
   const RATE_5H_PCT = get(
     data,
     ["rate_limits", "five_hour", "used_percentage"],
@@ -119,6 +118,7 @@ function main() {
     repo_pr: true,
     worktree: true,
     infra_drift: true,
+    package_freshness: true,
     no_color: false,
   };
   try {
@@ -138,6 +138,7 @@ function main() {
           "repo_pr",
           "worktree",
           "infra_drift",
+          "package_freshness",
         ]) {
           if (typeof parsed.lines[k] === "boolean") cfg[k] = parsed.lines[k];
         }
@@ -190,6 +191,9 @@ function main() {
     return String(n);
   };
 
+  // Percentage formatter (integer round-half-up; cross-runtime identical).
+  const fmtPct = (n) => String(Math.floor(Number(n) + 0.5));
+
   const fmtK = (val) => {
     const v = Number(val);
     if (v >= 1000000) {
@@ -203,9 +207,9 @@ function main() {
   };
 
   const fmtCost = (c) => {
-    const n = Math.floor(Number(c) * 10000 + 0.5);
-    const frac = String(n % 10000).padStart(4, "0");
-    return `$${Math.floor(n / 10000)}.${frac}`;
+    const n = Math.floor(Number(c) * 100 + 0.5);
+    const frac = String(n % 100).padStart(2, "0");
+    return `$${Math.floor(n / 100)}.${frac}`;
   };
 
   const fmtDur = (ms) => {
@@ -281,7 +285,6 @@ function main() {
       L1 += `${C.BOLD}${C.CYAN}${MODEL_ID}${C.RST}`;
     }
     if (EFFORT) L1 += ` ${C.DIM}effort:${C.RST}${EFFORT}`;
-    if (THINKING === true) L1 += ` ${C.YELLOW}thinking:on${C.RST}`;
     if (OUTPUT_STYLE && OUTPUT_STYLE !== "default")
       L1 += ` ${C.DIM}style:${C.RST}${OUTPUT_STYLE}`;
     if (VIM_MODE) L1 += ` ${C.DIM}[${VIM_MODE}]${C.RST}`;
@@ -325,18 +328,20 @@ function main() {
     if (has5h || has7d) {
       let L4 = "";
       if (has5h) {
+        const r5 = fmtPct(RATE_5H_PCT);
         let c5;
-        if (gte(RATE_5H_PCT, 80)) c5 = C.RED;
-        else if (gte(RATE_5H_PCT, 60)) c5 = C.YELLOW;
+        if (gte(r5, 80)) c5 = C.RED;
+        else if (gte(r5, 60)) c5 = C.YELLOW;
         else c5 = C.GREEN;
-        L4 = `${C.DIM}5h:${C.RST}${c5}${numStr(RATE_5H_PCT)}%${C.RST} ${C.DIM}(resets in ${fmtRelTime(RATE_5H_RESETS)})${C.RST}`;
+        L4 = `${C.DIM}5h:${C.RST}${c5}${r5}%${C.RST} ${C.DIM}(resets in ${fmtRelTime(RATE_5H_RESETS)})${C.RST}`;
       }
       if (has7d) {
+        const r7 = fmtPct(RATE_7D_PCT);
         let c7;
-        if (gte(RATE_7D_PCT, 80)) c7 = C.RED;
-        else if (gte(RATE_7D_PCT, 60)) c7 = C.YELLOW;
+        if (gte(r7, 80)) c7 = C.RED;
+        else if (gte(r7, 60)) c7 = C.YELLOW;
         else c7 = C.GREEN;
-        const seg7 = `${C.DIM}7d:${C.RST}${c7}${numStr(RATE_7D_PCT)}%${C.RST} ${C.DIM}(resets in ${fmtRelTime(RATE_7D_RESETS)})${C.RST}`;
+        const seg7 = `${C.DIM}7d:${C.RST}${c7}${r7}%${C.RST} ${C.DIM}(resets in ${fmtRelTime(RATE_7D_RESETS)})${C.RST}`;
         L4 = L4 ? `${L4} ${C.DIM}|${C.RST} ${seg7}` : seg7;
       }
       out.push(L4);
@@ -418,6 +423,96 @@ function main() {
     }
   }
 
+  // ============================================================
+  // LINE 8 — Package freshness (codebyplan version / sync state)
+  // ============================================================
+  // Source: .codebyplan/claude-status.local.json (written by background refresh).
+  // Inline fallback (cache absent): read .claude/.cbp.manifest.json vs
+  // node_modules/codebyplan/package.json. HIDE when guarded (canonical_source /
+  // no_manifest / unknown) or when manifest absent (not a managed consumer).
+  if (shouldShow("PACKAGE_FRESHNESS", cfg.package_freshness)) {
+    let guarded = false;
+    let installed = "";
+    let newer = false;
+    let latest = "";
+    let inSync = true;
+
+    const cachePath = path.join(
+      root,
+      ".codebyplan",
+      "claude-status.local.json"
+    );
+    if (fs.existsSync(cachePath)) {
+      try {
+        const cacheRaw = fs.readFileSync(cachePath, "utf8");
+        const cache = JSON.parse(cacheRaw);
+        if (cache && typeof cache === "object") {
+          const gr = cache.guard_reason;
+          if (
+            gr === "canonical_source" ||
+            gr === "no_manifest" ||
+            gr === "unknown"
+          ) {
+            guarded = true;
+          } else {
+            installed =
+              typeof cache.installed === "string" ? cache.installed : "";
+            newer = cache.newer === true;
+            latest = typeof cache.latest === "string" ? cache.latest : "";
+            inSync = cache.in_sync !== false;
+          }
+        }
+      } catch {
+        // Unreadable / invalid → keep guarded=false, installed=""
+      }
+    } else {
+      // Inline fallback: no cache — read-only file reads only, no network.
+      const manifestPath = path.join(root, ".claude", ".cbp.manifest.json");
+      const pkgPath = path.join(
+        root,
+        "node_modules",
+        "codebyplan",
+        "package.json"
+      );
+      if (!fs.existsSync(manifestPath)) {
+        // No manifest → not a managed consumer → hide.
+        guarded = true;
+      } else {
+        try {
+          const mRaw = fs.readFileSync(manifestPath, "utf8");
+          const mParsed = JSON.parse(mRaw);
+          const mVer =
+            typeof mParsed?.version === "string" ? mParsed.version : "";
+          const pRaw = fs.readFileSync(pkgPath, "utf8");
+          const pParsed = JSON.parse(pRaw);
+          const iVer =
+            typeof pParsed?.version === "string" ? pParsed.version : "";
+          installed = iVer;
+          if (mVer && iVer && mVer !== iVer) {
+            // manifest ≠ installed → .claude is out of sync → ⟳ run claude update
+            // (mirrors the doctor's version_skip → in_sync:false). No npm info in
+            // the offline fallback, so never the ↑ newer-available marker.
+            inSync = false;
+          }
+        } catch {
+          // Can't read files → hide segment.
+          guarded = true;
+        }
+      }
+    }
+
+    if (!guarded && installed) {
+      let L8 = `${C.DIM}cbp${C.RST} ${installed}`;
+      if (newer && latest) {
+        L8 += ` ${C.YELLOW}↑${latest}${C.RST}`;
+      }
+      if (!inSync) {
+        L8 += ` ${C.YELLOW}⟳ run claude update${C.RST}`;
+      }
+      out.push(L8);
+    }
+  }
+
   process.stdout.write(out.length ? out.join("\n") + "\n" : "");
 }
 

package/templates/hooks/cbp-statusline.py

@@ -60,7 +60,6 @@ def main():
     CACHE_READ = _get(data, ["context_window", "current_usage", "cache_read_input_tokens"], 0)
     EXCEEDS_200K = _get(data, ["exceeds_200k_tokens"], False)
     EFFORT = _get(data, ["effort", "level"], "")
-    THINKING = _get(data, ["thinking", "enabled"], False)
     RATE_5H_PCT = _get(data, ["rate_limits", "five_hour", "used_percentage"], "")
     RATE_5H_RESETS = _get(data, ["rate_limits", "five_hour", "resets_at"], 0)
     RATE_7D_PCT = _get(data, ["rate_limits", "seven_day", "used_percentage"], "")
@@ -81,7 +80,7 @@ def main():
     cfg = {
         "identity": True, "context": True, "cost": True,
         "rate_limits": True, "repo_pr": True, "worktree": True,
-        "infra_drift": True, "no_color": False,
+        "infra_drift": True, "package_freshness": True, "no_color": False,
     }
     try:
         with open(os.path.join(root, ".codebyplan", "statusline.json"), "r", encoding="utf-8") as fh:
@@ -91,7 +90,7 @@ def main():
                 cfg["no_color"] = parsed["no_color"]
             lines = parsed.get("lines")
             if isinstance(lines, dict):
-                for k in ["identity", "context", "cost", "rate_limits", "repo_pr", "worktree", "infra_drift"]:
+                for k in ["identity", "context", "cost", "rate_limits", "repo_pr", "worktree", "infra_drift", "package_freshness"]:
                     if isinstance(lines.get(k), bool):
                         cfg[k] = lines[k]
     except Exception:
@@ -134,6 +133,10 @@ def main():
             return str(int(x))
         return str(n)
 
+    # Percentage formatter (integer round-half-up; cross-runtime identical).
+    def fmt_pct(n):
+        return "%d" % int(float(n) + 0.5)
+
     def fmt_k(val):
         v = float(val)
         if v >= 1000000:
@@ -145,8 +148,8 @@ def main():
         return str(int(v))
 
     def fmt_cost(c):
-        n = math.floor(float(c) * 10000 + 0.5)
-        return "$%d.%04d" % (n // 10000, n % 10000)
+        n = math.floor(float(c) * 100 + 0.5)
+        return "$%d.%02d" % (n // 100, n % 100)
 
     def fmt_dur(ms):
         secs = math.trunc(float(ms) / 1000)
@@ -217,8 +220,6 @@ def main():
             l1 += "%s%s%s%s" % (BOLD, CYAN, MODEL_ID, RST)
         if EFFORT:
             l1 += " %seffort:%s%s" % (DIM, RST, EFFORT)
-        if THINKING is True:
-            l1 += " %sthinking:on%s" % (YELLOW, RST)
         if OUTPUT_STYLE and OUTPUT_STYLE != "default":
             l1 += " %sstyle:%s%s" % (DIM, RST, OUTPUT_STYLE)
         if VIM_MODE:
@@ -273,24 +274,26 @@ def main():
         if has_5h or has_7d:
             l4 = ""
             if has_5h:
-                if gte(RATE_5H_PCT, 80):
+                r5 = fmt_pct(RATE_5H_PCT)
+                if gte(r5, 80):
                     c5 = RED
-                elif gte(RATE_5H_PCT, 60):
+                elif gte(r5, 60):
                     c5 = YELLOW
                 else:
                     c5 = GREEN
                 l4 = "%s5h:%s%s%s%%%s %s(resets in %s)%s" % (
-                    DIM, RST, c5, num_str(RATE_5H_PCT), RST, DIM, fmt_rel_time(RATE_5H_RESETS), RST,
+                    DIM, RST, c5, r5, RST, DIM, fmt_rel_time(RATE_5H_RESETS), RST,
                 )
             if has_7d:
-                if gte(RATE_7D_PCT, 80):
+                r7 = fmt_pct(RATE_7D_PCT)
+                if gte(r7, 80):
                     c7 = RED
-                elif gte(RATE_7D_PCT, 60):
+                elif gte(r7, 60):
                     c7 = YELLOW
                 else:
                     c7 = GREEN
                 seg7 = "%s7d:%s%s%s%%%s %s(resets in %s)%s" % (
-                    DIM, RST, c7, num_str(RATE_7D_PCT), RST, DIM, fmt_rel_time(RATE_7D_RESETS), RST,
+                    DIM, RST, c7, r7, RST, DIM, fmt_rel_time(RATE_7D_RESETS), RST,
                 )
                 l4 = ("%s %s|%s %s" % (l4, DIM, RST, seg7)) if l4 else seg7
             out.append(l4)
@@ -343,6 +346,69 @@ def main():
             if behind > 0:
                 out.append("%s⚠ infra %d behind%s %s→ /cbp-refresh-infra%s" % (YELLOW, behind, RST, DIM, RST))
 
+    # ===== LINE 8 — Package freshness (codebyplan version / sync state) =====
+    # Source: .codebyplan/claude-status.local.json (written by background refresh).
+    # Inline fallback (cache absent): read .claude/.cbp.manifest.json vs
+    # node_modules/codebyplan/package.json. HIDE when guarded (canonical_source /
+    # no_manifest / unknown) or when manifest absent (not a managed consumer).
+    if should_show("PACKAGE_FRESHNESS", cfg["package_freshness"]):
+        _guarded = False
+        _installed = ""
+        _newer = False
+        _latest = ""
+        _in_sync = True
+
+        cache_path = os.path.join(root, ".codebyplan", "claude-status.local.json")
+        if os.path.isfile(cache_path):
+            try:
+                with open(cache_path, "r", encoding="utf-8") as fh:
+                    cache = json.load(fh)
+                if isinstance(cache, dict):
+                    gr = cache.get("guard_reason")
+                    if gr in ("canonical_source", "no_manifest", "unknown"):
+                        _guarded = True
+                    else:
+                        _installed = cache.get("installed") if isinstance(cache.get("installed"), str) else ""
+                        _newer = cache.get("newer") is True
+                        _latest = cache.get("latest") if isinstance(cache.get("latest"), str) else ""
+                        _in_sync = cache.get("in_sync") is not False
+            except Exception:
+                pass  # Unreadable / invalid → keep _installed=""
+        else:
+            # Inline fallback: no cache — read-only file reads only, no network.
+            manifest_path = os.path.join(root, ".claude", ".cbp.manifest.json")
+            pkg_path = os.path.join(root, "node_modules", "codebyplan", "package.json")
+            if not os.path.isfile(manifest_path):
+                # No manifest → not a managed consumer → hide.
+                _guarded = True
+            else:
+                try:
+                    with open(manifest_path, "r", encoding="utf-8") as fh:
+                        m_data = json.load(fh)
+                    m_ver = m_data.get("version") if isinstance(m_data, dict) else ""
+                    m_ver = m_ver if isinstance(m_ver, str) else ""
+                    with open(pkg_path, "r", encoding="utf-8") as fh:
+                        p_data = json.load(fh)
+                    i_ver = p_data.get("version") if isinstance(p_data, dict) else ""
+                    i_ver = i_ver if isinstance(i_ver, str) else ""
+                    _installed = i_ver
+                    if m_ver and i_ver and m_ver != i_ver:
+                        # manifest != installed -> .claude is out of sync -> run claude update
+                        # (mirrors the doctor's version_skip -> in_sync:false). No npm info
+                        # in the offline fallback, so never the up-arrow newer marker.
+                        _in_sync = False
+                except Exception:
+                    # Can't read files → hide segment.
+                    _guarded = True
+
+        if not _guarded and _installed:
+            l8 = "%scbp%s %s" % (DIM, RST, _installed)
+            if _newer and _latest:
+                l8 += " %s↑%s%s" % (YELLOW, _latest, RST)
+            if not _in_sync:
+                l8 += " %s⟳ run claude update%s" % (YELLOW, RST)
+            out.append(l8)
+
     sys.stdout.write(("\n".join(out) + "\n") if out else "")
 
 

package/templates/hooks/cbp-statusline.sh

@@ -15,7 +15,7 @@
 #
 # DISPLAY OPTIONS (team-shared, committed)
 #   .codebyplan/statusline.json -> { "lines": {identity,context,cost,rate_limits,
-#                                    repo_pr,worktree,infra_drift}, "no_color": bool }
+#                                    repo_pr,worktree,infra_drift,package_freshness}, "no_color": bool }
 #
 # ENV-VAR OVERRIDES (env > config > default)
 #   CBP_STATUSLINE_HIDE_IDENTITY=1     suppress line 1 (folder, branch, model, effort, …)
@@ -24,7 +24,8 @@
 #   CBP_STATUSLINE_HIDE_RATE_LIMITS=1  suppress line 4 (5h / 7d rate limits)
 #   CBP_STATUSLINE_HIDE_REPO_PR=1      suppress line 5 (repo host/owner/name, PR)
 #   CBP_STATUSLINE_HIDE_WORKTREE=1     suppress line 6 (worktree name/branch/path)
-#   CBP_STATUSLINE_HIDE_INFRA_DRIFT=1  suppress line 7 (.claude infra commits behind main)
+#   CBP_STATUSLINE_HIDE_INFRA_DRIFT=1         suppress line 7 (.claude infra commits behind main)
+#   CBP_STATUSLINE_HIDE_PACKAGE_FRESHNESS=1   suppress line 8 (codebyplan package version)
 #   CBP_STATUSLINE_NO_COLOR=1          strip all ANSI colour codes (also honoured by $NO_COLOR)
 #
 # TEST SEAMS (no effect in normal use)
@@ -48,6 +49,17 @@ if [ -f "$CBP_LOCAL_CFG" ] && command -v jq >/dev/null 2>&1; then
   case "$_r" in bash|node|python) CBP_RENDERER="$_r" ;; esac
 fi
 
+# Background claude-status cache refresh (6h staleness gate).
+# `find -mmin -360` PRINTS the path only when the file exists AND is younger
+# than 6h; an EMPTY result means the cache is absent OR stale (>6h) — both
+# need a refresh. (find's exit code is 0 for a present-but-non-matching path,
+# so we must test its output, not its status.)
+# Fully detached — never blocks the render, never writes to this stdout.
+CBP_STATUS_CACHE="$CBP_ROOT/.codebyplan/claude-status.local.json"
+if [ -z "$(find "$CBP_STATUS_CACHE" -mmin -360 2>/dev/null)" ]; then
+  (npx codebyplan claude status --write-cache --quiet >/dev/null 2>&1 &)
+fi
+
 if [ "$CBP_RENDERER" = "node" ] && command -v node >/dev/null 2>&1 \
    && [ -f "$CBP_HOOK_DIR/cbp-statusline.mjs" ]; then
   CBP_STATUSLINE_ROOT="$CBP_ROOT" exec node "$CBP_HOOK_DIR/cbp-statusline.mjs"
@@ -83,7 +95,6 @@ eval "$(echo "$INPUT" | jq -r '
   @sh "CACHE_READ=\(.context_window.current_usage.cache_read_input_tokens // 0)",
   @sh "EXCEEDS_200K=\(.exceeds_200k_tokens // false)",
   @sh "EFFORT=\(.effort.level // "")",
-  @sh "THINKING=\(.thinking.enabled // false)",
   @sh "RATE_5H_PCT=\(.rate_limits.five_hour.used_percentage // "")",
   @sh "RATE_5H_RESETS=\(.rate_limits.five_hour.resets_at // 0)",
   @sh "RATE_7D_PCT=\(.rate_limits.seven_day.used_percentage // "")",
@@ -105,7 +116,7 @@ eval "$(echo "$INPUT" | jq -r '
 
 # ---- Config: line toggles + no_color from .codebyplan/statusline.json --------
 CFG_IDENTITY=true; CFG_CONTEXT=true; CFG_COST=true
-CFG_RATE_LIMITS=true; CFG_REPO_PR=true; CFG_WORKTREE=true; CFG_INFRA_DRIFT=true; CFG_NO_COLOR=false
+CFG_RATE_LIMITS=true; CFG_REPO_PR=true; CFG_WORKTREE=true; CFG_INFRA_DRIFT=true; CFG_PACKAGE_FRESHNESS=true; CFG_NO_COLOR=false
 CBP_CFG="$CBP_ROOT/.codebyplan/statusline.json"
 if [ -f "$CBP_CFG" ] && command -v jq >/dev/null 2>&1; then
   # Use `!= false` / `== true` (NOT jq `//`): the `//` operator treats an explicit
@@ -119,6 +130,7 @@ if [ -f "$CBP_CFG" ] && command -v jq >/dev/null 2>&1; then
     "CFG_REPO_PR=\(.lines.repo_pr != false)",
     "CFG_WORKTREE=\(.lines.worktree != false)",
     "CFG_INFRA_DRIFT=\(.lines.infra_drift != false)",
+    "CFG_PACKAGE_FRESHNESS=\(.lines.package_freshness != false)",
     "CFG_NO_COLOR=\(.no_color == true)"
   ' "$CBP_CFG" 2>/dev/null)"
 fi
@@ -150,6 +162,9 @@ fi
 # ---- Float-safe percentage comparison ----------------------------------------
 awk_gte() { awk -v v="$1" -v t="$2" 'BEGIN{exit !(v+0 >= t+0)}'; }
 
+# ---- Percentage formatter (integer round-half-up; cross-runtime identical) ----
+fmt_pct() { awk -v v="$1" 'BEGIN{ printf "%d", int(v + 0.5) }'; }
+
 # ---- Token/size formatter (K / M) — integer round-half-up (cross-runtime) -----
 fmt_k() {
   local val=$1
@@ -164,9 +179,9 @@ fmt_k() {
   fi
 }
 
-# ---- Cost formatter ($X.XXXX) — integer round-half-up (cross-runtime) ---------
+# ---- Cost formatter ($X.XX) — integer round-half-up (cross-runtime) -----------
 fmt_cost() {
-  awk -v c="$1" 'BEGIN{ n=int(c*10000 + 0.5); printf "$%d.%04d", int(n/10000), n%10000 }'
+  awk -v c="$1" 'BEGIN{ n=int(c*100 + 0.5); printf "$%d.%02d", int(n/100), n%100 }'
 }
 
 # ---- Duration formatter (ms → Xh Xm Xs) --------------------------------------
@@ -245,11 +260,6 @@ if should_show IDENTITY "$CFG_IDENTITY"; then
     L1="${L1} ${DIM}effort:${RST}${EFFORT}"
   fi
 
-  # Thinking (only when explicitly true)
-  if [ "$THINKING" = "true" ]; then
-    L1="${L1} ${YELLOW}thinking:on${RST}"
-  fi
-
   # Output style (when present and not "default")
   if [ -n "$OUTPUT_STYLE" ] && [ "$OUTPUT_STYLE" != "default" ]; then
     L1="${L1} ${DIM}style:${RST}${OUTPUT_STYLE}"
@@ -324,27 +334,29 @@ if should_show RATE_LIMITS "$CFG_RATE_LIMITS"; then
     L4=""
 
     if [ -n "$RATE_5H_PCT" ] && [ "$RATE_5H_RESETS" != "0" ]; then
-      if awk_gte "$RATE_5H_PCT" 80; then
+      R5=$(fmt_pct "$RATE_5H_PCT")
+      if awk_gte "$R5" 80; then
         C5="$RED"
-      elif awk_gte "$RATE_5H_PCT" 60; then
+      elif awk_gte "$R5" 60; then
         C5="$YELLOW"
       else
         C5="$GREEN"
       fi
       REL5=$(fmt_rel_time "$RATE_5H_RESETS")
-      L4="${DIM}5h:${RST}${C5}${RATE_5H_PCT}%${RST} ${DIM}(resets in ${REL5})${RST}"
+      L4="${DIM}5h:${RST}${C5}${R5}%${RST} ${DIM}(resets in ${REL5})${RST}"
     fi
 
     if [ -n "$RATE_7D_PCT" ] && [ "$RATE_7D_RESETS" != "0" ]; then
-      if awk_gte "$RATE_7D_PCT" 80; then
+      R7=$(fmt_pct "$RATE_7D_PCT")
+      if awk_gte "$R7" 80; then
         C7="$RED"
-      elif awk_gte "$RATE_7D_PCT" 60; then
+      elif awk_gte "$R7" 60; then
         C7="$YELLOW"
       else
         C7="$GREEN"
       fi
       REL7=$(fmt_rel_time "$RATE_7D_RESETS")
-      SEG7="${DIM}7d:${RST}${C7}${RATE_7D_PCT}%${RST} ${DIM}(resets in ${REL7})${RST}"
+      SEG7="${DIM}7d:${RST}${C7}${R7}%${RST} ${DIM}(resets in ${REL7})${RST}"
       if [ -n "$L4" ]; then
         L4="${L4} ${DIM}|${RST} ${SEG7}"
       else
@@ -421,3 +433,71 @@ if should_show INFRA_DRIFT "$CFG_INFRA_DRIFT"; then
       ;;
   esac
 fi
+
+# ============================================================
+# LINE 8 — Package freshness (codebyplan version / sync state)
+# ============================================================
+# Source: .codebyplan/claude-status.local.json (written by background refresh).
+# Inline fallback (cache absent): read .claude/.cbp.manifest.json vs
+# node_modules/codebyplan/package.json. HIDE when guarded (canonical_source /
+# no_manifest / unknown) or when manifest absent (not a managed consumer).
+if should_show PACKAGE_FRESHNESS "$CFG_PACKAGE_FRESHNESS"; then
+  L8=""
+  _CBP_GUARDED=false
+  _CBP_INSTALLED=""
+  _CBP_NEWER=false
+  _CBP_LATEST=""
+  _CBP_IN_SYNC=true
+
+  if [ -f "$CBP_STATUS_CACHE" ] && command -v jq >/dev/null 2>&1; then
+    # Cache present — read fields.
+    _cbp_guard_reason="$(jq -r '.guard_reason // ""' "$CBP_STATUS_CACHE" 2>/dev/null)"
+    case "$_cbp_guard_reason" in
+      canonical_source|no_manifest|unknown)
+        _CBP_GUARDED=true
+        ;;
+    esac
+    if [ "$_CBP_GUARDED" = "false" ]; then
+      _CBP_INSTALLED="$(jq -r '.installed // ""' "$CBP_STATUS_CACHE" 2>/dev/null)"
+      _CBP_NEWER="$(jq -r '.newer == true' "$CBP_STATUS_CACHE" 2>/dev/null)"
+      _CBP_LATEST="$(jq -r '.latest // ""' "$CBP_STATUS_CACHE" 2>/dev/null)"
+      # NOTE: `!= false` (NOT jq `//`): the `//` operator treats an explicit
+      # `false` as absent, so `.in_sync // true` would yield "true" for an
+      # out-of-sync cache and silently drop the ⟳ indicator (CHK-175 TASK-3 R1
+      # finding #1). `!= false` mirrors node `in_sync !== false` / python.
+      _CBP_IN_SYNC="$(jq -r '.in_sync != false' "$CBP_STATUS_CACHE" 2>/dev/null)"
+    fi
+  else
+    # Inline fallback: no cache, no network — read-only file reads only.
+    _cbp_manifest="$CBP_ROOT/.claude/.cbp.manifest.json"
+    _cbp_pkg="$CBP_ROOT/node_modules/codebyplan/package.json"
+    if [ ! -f "$_cbp_manifest" ]; then
+      # No manifest → not a managed consumer → hide segment.
+      _CBP_GUARDED=true
+    elif [ -f "$_cbp_pkg" ] && command -v jq >/dev/null 2>&1; then
+      _cbp_mver="$(jq -r '.version // ""' "$_cbp_manifest" 2>/dev/null)"
+      _cbp_iver="$(jq -r '.version // ""' "$_cbp_pkg" 2>/dev/null)"
+      _CBP_INSTALLED="$_cbp_iver"
+      if [ -n "$_cbp_mver" ] && [ -n "$_cbp_iver" ] && [ "$_cbp_mver" != "$_cbp_iver" ]; then
+        # manifest ≠ installed → .claude is out of sync → ⟳ run claude update
+        # (mirrors the doctor's version_skip → in_sync:false). No npm info in the
+        # offline fallback, so never the ↑ newer-available marker.
+        _CBP_IN_SYNC=false
+      fi
+    else
+      # Can't read package.json or no jq → hide segment.
+      _CBP_GUARDED=true
+    fi
+  fi
+
+  if [ "$_CBP_GUARDED" = "false" ] && [ -n "$_CBP_INSTALLED" ]; then
+    L8="${DIM}cbp${RST} ${_CBP_INSTALLED}"
+    if [ "$_CBP_NEWER" = "true" ] && [ -n "$_CBP_LATEST" ]; then
+      L8="${L8} ${YELLOW}↑${_CBP_LATEST}${RST}"
+    fi
+    if [ "$_CBP_IN_SYNC" = "false" ]; then
+      L8="${L8} ${YELLOW}⟳ run claude update${RST}"
+    fi
+    printf "%b\n" "$L8"
+  fi
+fi