codebyplan 1.13.23 → 1.13.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.13.23",
+  "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

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

package/templates/skills/cbp-session-start/SKILL.md

@@ -97,6 +97,8 @@ Check whether a newer `codebyplan` is published and safe to auto-install on this
 
 ```bash
 VERSION_JSON=$(npx codebyplan version-status 2>/dev/null)
+# Populate the claude-status cache best-effort (pure cache population — never gates session-start).
+npx codebyplan claude status --write-cache --quiet 2>/dev/null || true
 ```
 
 Parse `$VERSION_JSON` as JSON and branch on the result: