company-skill 4.6.9 → 4.6.10

package/README.md

@@ -195,6 +195,35 @@ State lives in `./.company/` (relocate with `COMPANY_DIR`):
 ```
 
 
+## State is per-project, code is global
+
+Run state is per-project. Every `.company/` lives inside the project it belongs to
+(or wherever `COMPANY_DIR` points), so two projects never share or leak state.
+
+The skill code is global on purpose. One install lives under `~/.claude/skills/company`
+and serves every project. There are no per-project copies, which avoids version drift
+across projects, a separate update path per project, and duplicated disk. Isolation
+comes from per-project state, not per-project code.
+
+Per-session resources are keyed on the session id. The dashboard port and the
+statusline render cache derive from `$CLAUDE_CODE_SESSION_ID`, so concurrent sessions
+do not collide and dead sessions release their slot.
+
+Stop-guard anchors live outside the project, under `~/.claude/company-guard-state/`,
+keyed by `sha256(realpath(COMPANY_DIR))`. They sit outside the project so an in-run
+actor cannot forge them. The key set grows by one for every distinct `.company` path
+ever used and is never pruned by the default reset. Reclaim old ones by age with:
+
+```bash
+node ~/.claude/skills/company/scripts/reset-company-guard.js --gc --dry-run
+node ~/.claude/skills/company/scripts/reset-company-guard.js --gc --max-age-days 30
+```
+
+`--gc` is opt-in and never auto-run. It removes only anchors older than the cutoff
+(default 30 days), `--dry-run` lists what would go without removing anything, and it
+only ever touches dirs under `~/.claude/company-guard-state/`.
+
+
 ## Examples
 
 [`startup.md`](examples/startup.md), [`research-lab.md`](examples/research-lab.md), [`dev-team.md`](examples/dev-team.md).

package/agents/company-reviewer.md

@@ -22,7 +22,19 @@ Additional duties:
 - **Stall counter.** When you keep a criterion failing, increment (or create) an `attempts` field on its criteria.json entry. At 2+ state in your verdict that the approach is stalled and the next cycle must re-plan, not re-try. Writing `attempts` is required: the stall detector and the high-stakes 3-lens gate both read it from criteria.json.
 - **Anti-vacuous test check (SKILL.md ANTI-VACUOUS TEST).** For every new test introduced this cycle, confirm it FAILS against the pre-change code. A test that passes before the fix is vacuous and must be rejected.
 - **Feature reachability check (SKILL.md FEATURE REACHABILITY).** For every new feature that gates on a field in criteria.json (e.g. `stakes: "high"`), confirm the authoring path that sets that field exists in the skill or agent instructions. A gate that is never set is a dead feature; reject it until the wiring is present.
-- **Respawn reflection.** For any task that will be respawned, write a 3-line block into your verdict for the orchestrator to paste into the fresh contract: WHAT-WAS-TRIED / WHY-IT-FAILED (cited to the findings file) / DO-DIFFERENTLY. The failed worker's self-report is not a source.
+- **Respawn diagnosis.** For any task that will be respawned, author a structured FAILURE-DIAGNOSIS block into your verdict for the orchestrator to paste into the fresh contract. You author it by reading the shaped FINDINGS file (and re-running the cited command), NEVER the raw transcript and never the failed worker's self-report. The block:
+
+  ```
+  FAILURE-DIAGNOSIS (task {id}, attempt {n})
+  ROOT-CAUSE-CLASS: one of [wrong-approach, missing-context, environment/tooling, spec-ambiguity, flaky/transient, scope-too-large, vacuous-or-misdirected-test]
+  ROOT-CAUSE: {one line}
+  EVIDENCE: {a findings-file:line you read, or a command you re-ran + its output, verbatim}
+  WHAT-TO-CHANGE: {concrete, contract-shaped: the next contract's TASK/INPUTS/surfaces}
+  KEEP: {what worked and must not be thrown away}
+  CONFIDENCE: high|low
+  ```
+
+  EVIDENCE must cite a real findings line or a re-run command and its output, never your memory of the failure. A diagnosis with an empty ROOT-CAUSE, EVIDENCE, or WHAT-TO-CHANGE, or a ROOT-CAUSE-CLASS outside the enum, is not actionable (the anti "try-harder" guard) and the orchestrator falls back to the plain 3-line reflection (WHAT-WAS-TRIED / WHY-IT-FAILED cited to the findings file / DO-DIFFERENTLY). When CONFIDENCE is low, say so in the block so the next THINK varies the decomposition rather than trusting one read.
 
 Audit each verdict against a tool result from THIS session. Only mark a criterion MET when you can cite the command you ran and its output from this run.
 

package/bin/install.js

@@ -19,12 +19,14 @@ function copyFile(src, dest) {
 copyFile(path.join(srcDir, 'skill', 'SKILL.md'), path.join(skillDir, 'SKILL.md'));
 
 // Scripts are runtime dependencies referenced from SKILL.md. check.sh, lint-*,
-// check-doc-commands.js, check-version.js, and test files stay in the repo only.
+// check-doc-commands.js, check-version.js, check-regression.js, and test files
+// stay in the repo only.
 const INSTALL_SCRIPTS = [
   'codegraph.js',
   'check-contracts.js',
   'check-findings.js',
   'check-criteria.js',
+  'diagnosis-block.js',
   'check-playbook.js',
   'restart-debate.js',
   'dashboard.js',

package/install.sh

@@ -34,9 +34,9 @@ for agent in lead worker reviewer critic digest; do
 done
 
 # Scripts (runtime dependencies referenced from SKILL.md).
-# check.sh, lint-*, check-doc-commands.js, check-version.js, and test files stay in the repo only.
+# check.sh, lint-*, check-doc-commands.js, check-version.js, check-regression.js, and test files stay in the repo only.
 mkdir -p "$HOME/.claude/skills/company/scripts"
-for script in codegraph.js check-contracts.js check-findings.js check-criteria.js check-playbook.js restart-debate.js dashboard.js secret-scan.js reset-company-guard.js cleanup.js statusline.js workspace-guard.js migrate-state.js check-isolation.js check-roster.js clean-stale-dashboards.js; do
+for script in codegraph.js check-contracts.js check-findings.js check-criteria.js diagnosis-block.js check-playbook.js restart-debate.js dashboard.js secret-scan.js reset-company-guard.js cleanup.js statusline.js workspace-guard.js migrate-state.js check-isolation.js check-roster.js clean-stale-dashboards.js; do
   fetch "$REPO/scripts/$script" "$HOME/.claude/skills/company/scripts/$script" || echo "Warning: failed to download script $script"
 done
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "company-skill",
-  "version": "4.6.9",
+  "version": "4.6.10",
   "description": "Goal-driven multi-employee company for Claude Code. Give it a goal, it runs until done.",
   "bin": {
     "company-skill": "./bin/install.js"
@@ -27,6 +27,7 @@
     "scripts/check-contracts.js",
     "scripts/check-findings.js",
     "scripts/check-criteria.js",
+    "scripts/diagnosis-block.js",
     "scripts/check-playbook.js",
     "scripts/restart-debate.js",
     "scripts/company-autoloop.js",

package/scripts/dashboard.js

@@ -1784,11 +1784,6 @@ footer { margin-top: 2rem; font-size: 12.5px; color: var(--dim); border-top: 1px
 .table-scroll { overflow-x: auto; -webkit-overflow-scrolling: touch; }
 img { max-width: 100%; height: auto; }
 .wrap { width: 100%; }
-/* C102: numbered tier chips for the delegation tree legend, manifest zero-JS style. */
-.tier-legend { display: flex; flex-wrap: wrap; gap: 0.5rem; margin-bottom: 0.75rem; }
-.tier-chip { display: inline-flex; align-items: baseline; gap: 0.4rem; background: var(--accent-tint); color: var(--text); border-radius: var(--radius-pill); padding: 0.2rem 0.7rem; font-size: 12px; }
-.tier-chip b { color: var(--accent); font-weight: 700; font-family: var(--font-mono); }
-.tier-chip .role { color: var(--dim); }
 @media (max-width: 768px) {
   .wrap { padding: 1.25rem 1rem 3rem; }
   .stat-row, .cycles-row, .stats { gap: 1.25rem; }
@@ -1872,11 +1867,6 @@ img { max-width: 100%; height: auto; }
         <button class="tree-btn" id="tree-fullscreen" aria-label="Expand" title="Expand"><svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><polyline points="1,5 1,1 5,1"/><polyline points="9,1 13,1 13,5"/><polyline points="13,9 13,13 9,13"/><polyline points="5,13 1,13 1,9"/></svg></button>
       </div>
     </div>
-    <div class="tier-legend">
-      <span class="tier-chip"><b>0</b> CEO <span class="role">orchestrator</span></span>
-      <span class="tier-chip"><b>1</b> Lead <span class="role">department head</span></span>
-      <span class="tier-chip"><b>2</b> Worker <span class="role">delegated agent</span></span>
-    </div>
     <div class="tree-container" id="tree-container">
       <div class="tree-svg-wrap" id="tree-svg-wrap">
         <svg id="tree" preserveAspectRatio="xMidYMin meet"></svg>

package/scripts/diagnosis-block.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Parser for the structured FAILURE-DIAGNOSIS block the reviewer authors from
+// the shaped FINDINGS file (never the raw transcript) when a task is respawned.
+// parseDiagnosis(text) extracts the fields, isActionable(diag) is the anti
+// "try-harder" guard: a diagnosis only drives a respawn when it classifies the
+// root cause AND carries a root cause, cited evidence, and a concrete change.
+//
+// Block format the reviewer writes:
+//   FAILURE-DIAGNOSIS (task {id}, attempt {n})
+//   ROOT-CAUSE-CLASS: one of the enum below
+//   ROOT-CAUSE: {one line}
+//   EVIDENCE: {findings-file:line or a re-run command + output}
+//   WHAT-TO-CHANGE: {concrete, contract-shaped}
+//   KEEP: {what worked}
+//   CONFIDENCE: high|low
+'use strict';
+
+// The allowed root-cause classes. A class outside this set is not actionable.
+// It cannot drive a structurally different decomposition the orchestrator trusts.
+const ROOT_CAUSE_CLASSES = [
+  'wrong-approach',
+  'missing-context',
+  'environment/tooling',
+  'spec-ambiguity',
+  'flaky/transient',
+  'scope-too-large',
+  'vacuous-or-misdirected-test',
+];
+
+// Pull the value after `LABEL:` on its own line. Returns '' when the field is
+// absent or has only whitespace after the colon (the empty-field case the guard
+// must reject). The label is matched at line start so a label inside prose is
+// not picked up.
+function fieldValue(text, label) {
+  const re = new RegExp('^' + label.replace('/', '\\/') + ':[ \\t]*(.*)$', 'm');
+  const m = text.match(re);
+  if (!m) return '';
+  return m[1].trim();
+}
+
+// parseDiagnosis(text) -> object|null. Returns null when the block header is
+// absent (no diagnosis to act on). Otherwise returns the six fields plus the
+// parsed task id, attempt, and a confidenceLow flag.
+function parseDiagnosis(text) {
+  if (typeof text !== 'string' || text.indexOf('FAILURE-DIAGNOSIS') === -1) return null;
+  const header = text.match(/FAILURE-DIAGNOSIS\s*\(task\s*([^,]+),\s*attempt\s*([^)]+)\)/);
+  const rootCauseClass = fieldValue(text, 'ROOT-CAUSE-CLASS');
+  const confidenceRaw = fieldValue(text, 'CONFIDENCE').toLowerCase();
+  return {
+    taskId: header ? header[1].trim() : '',
+    attempt: header ? header[2].trim() : '',
+    rootCauseClass: rootCauseClass,
+    rootCause: fieldValue(text, 'ROOT-CAUSE'),
+    evidence: fieldValue(text, 'EVIDENCE'),
+    whatToChange: fieldValue(text, 'WHAT-TO-CHANGE'),
+    keep: fieldValue(text, 'KEEP'),
+    confidence: confidenceRaw,
+    confidenceLow: confidenceRaw === 'low',
+  };
+}
+
+// isActionable(diag) -> bool. The anti "try-harder" guard. A diagnosis only
+// earns a respawn when the class is one of the known enum values AND the root
+// cause, the cited evidence, and the concrete change are all present. Mirrors
+// the FINDING-without-SOURCE rule: a claim with no cited basis is not actionable.
+function isActionable(diag) {
+  if (!diag || typeof diag !== 'object') return false;
+  if (ROOT_CAUSE_CLASSES.indexOf(diag.rootCauseClass) === -1) return false;
+  if (!diag.rootCause) return false;
+  if (!diag.evidence) return false;
+  if (!diag.whatToChange) return false;
+  return true;
+}
+
+module.exports = { parseDiagnosis, isActionable, ROOT_CAUSE_CLASSES };

package/scripts/reset-company-guard.js

@@ -24,11 +24,129 @@
 // USAGE: node <skill-scripts-dir>/reset-company-guard.js
 //   COMPANY_DIR defaults to ./.company (same as stop-guard).
 //   Override: COMPANY_DIR=/path/to/.company node reset-company-guard.js
+//
+// GARBAGE-COLLECT MODE (opt-in, separate from the default reset above):
+//   node <skill-scripts-dir>/reset-company-guard.js --gc [--max-age-days N] [--dry-run]
+//   Removes guard-state anchor dirs under ~/.claude/company-guard-state/ whose most
+//   recent mtime is older than the cutoff (default 30 days). The anchor key is
+//   sha256(realpath(companyDir)), so the key set grows by one for every distinct
+//   .company path ever used and is never pruned by the default reset (which only
+//   removes one exact key). This bounds that growth by age.
+//
+//   --dry-run lists what WOULD be removed and removes nothing.
+//   The root is fixed at ~/.claude/company-guard-state/ and re-checked before any
+//   removal so a bug cannot rm outside it. GC is OPT-IN and never auto-run by the
+//   stop guard: a stale anchor for a long-dead run is safe to drop by age, but the
+//   anti-forge property (anchors live OUTSIDE the project so an in-run actor cannot
+//   forge or delete a live anchor for a DIFFERENT active run) is preserved because
+//   nothing here is reachable from inside a run and recent anchors are always kept.
+//   Tests override the root with COMPANY_GUARD_STATE_DIR so they never touch the
+//   real anchors.
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
+const DEFAULT_MAX_AGE_DAYS = 30;
+
+// Resolve the guard-state root. Honors COMPANY_GUARD_STATE_DIR for test isolation,
+// otherwise the canonical ~/.claude/company-guard-state.
+function guardStateRoot() {
+  if (process.env.COMPANY_GUARD_STATE_DIR) return process.env.COMPANY_GUARD_STATE_DIR;
+  const home = process.env.HOME || '';
+  return path.join(home, '.claude', 'company-guard-state');
+}
+
+// Most-recent mtime across the anchor dir itself and its immediate children
+// (the lock file + optional owners file). Used as the activity timestamp.
+function newestMtimeMs(dir) {
+  let newest = 0;
+  try { newest = fs.statSync(dir).mtimeMs; } catch (e) { return 0; }
+  let entries = [];
+  try { entries = fs.readdirSync(dir); } catch (e) { entries = []; }
+  for (const name of entries) {
+    try {
+      const m = fs.statSync(path.join(dir, name)).mtimeMs;
+      if (m > newest) newest = m;
+    } catch (e) { /* ignore unreadable child */ }
+  }
+  return newest;
+}
+
+function parseGcOpts(argv) {
+  const opts = { dryRun: false, maxAgeDays: DEFAULT_MAX_AGE_DAYS };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--dry-run') opts.dryRun = true;
+    else if (a === '--max-age-days') {
+      const v = Number(argv[i + 1]);
+      if (!Number.isFinite(v) || v < 0) {
+        console.error('reset-company-guard --gc: --max-age-days needs a non-negative number');
+        process.exit(2);
+      }
+      opts.maxAgeDays = v;
+      i += 1;
+    }
+  }
+  return opts;
+}
+
+// Bounded, age-based GC of guard-state anchor dirs. Safe by construction:
+// only direct children of the resolved root are candidates, the root is
+// re-resolved per removal, and each rm target must stay inside the root.
+function runGc(argv) {
+  const opts = parseGcOpts(argv);
+  const root = path.resolve(guardStateRoot());
+  if (!fs.existsSync(root)) {
+    console.log('reset-company-guard --gc: no guard-state root at ' + root + ' (nothing to GC)');
+    return 0;
+  }
+  const cutoffMs = Date.now() - opts.maxAgeDays * 24 * 60 * 60 * 1000;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch (e) {
+    console.error('reset-company-guard --gc: cannot read ' + root + ': ' + e.message);
+    return 1;
+  }
+  let scanned = 0, removed = 0, kept = 0, errors = 0;
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    scanned += 1;
+    const dir = path.resolve(root, ent.name);
+    // Hard safety: never touch anything that is not a direct child of root.
+    if (path.dirname(dir) !== root) { kept += 1; continue; }
+    const mtime = newestMtimeMs(dir);
+    if (mtime === 0 || mtime >= cutoffMs) { kept += 1; continue; }
+    const ageDays = ((Date.now() - mtime) / (24 * 60 * 60 * 1000)).toFixed(1);
+    if (opts.dryRun) {
+      console.log('would remove ' + dir + ' (age ' + ageDays + 'd)');
+      removed += 1;
+      continue;
+    }
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+      console.log('removed ' + dir + ' (age ' + ageDays + 'd)');
+      removed += 1;
+    } catch (e) {
+      console.error('reset-company-guard --gc: failed to remove ' + dir + ': ' + e.message);
+      errors += 1;
+    }
+  }
+  const verb = opts.dryRun ? 'would remove' : 'removed';
+  console.log('reset-company-guard --gc: root=' + root +
+    ' max-age-days=' + opts.maxAgeDays +
+    ' scanned=' + scanned + ' ' + verb + '=' + removed + ' kept=' + kept +
+    (errors ? ' errors=' + errors : '') + (opts.dryRun ? ' (dry-run)' : ''));
+  return errors ? 1 : 0;
+}
+
+// Opt-in GC mode short-circuits the default reset entirely. The default
+// reset behaviour below is unchanged and runs only when --gc is absent.
+if (process.argv.slice(2).indexOf('--gc') !== -1) {
+  process.exit(runGc(process.argv.slice(2)));
+}
+
 // Resolve companyDir robustly: COMPANY_DIR env wins; else prefer the dir that holds
 // a clean OWNER (at least one valid session-id line); fall back to cwd/.company.
 // A blank/garbled OWNER does NOT qualify a dir as the active run (BLOCKER-1 fix).

package/scripts/statusline.js

@@ -17,6 +17,7 @@
 
 'use strict';
 const { execFileSync } = require('child_process');
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -81,6 +82,180 @@ function resolveDir() {
 }
 const dir = resolveDir();
 
+// --- Short-TTL render cache -------------------------------------------------
+// SKILL.md forces this script as the GLOBAL statusLine.command, refreshed on a
+// sub-second cadence, so a render storm spawns a fresh cold node per refresh and
+// slow renders overlap and pile up. The cache collapses that storm to ONE real
+// compute per CACHE_TTL_MS: a re-render whose sid + transcript size + mtime match
+// a recent cache entry writes the cached line and exits immediately.
+//
+// Fail-OPEN by construction: every read/write is wrapped and any error falls
+// through to a fresh render. The cache NEVER throws and NEVER blocks a render.
+const CACHE_TTL_MS = 1500; // one real compute per ~1.5s; collapses the sub-second storm.
+const BASE_CACHE_TTL_MS = 5000; // base output reused for ~5s; spawn at most once per window.
+// Base-spawn timeout. Node cold-start on this box is 0.65s-4.6s under load, so a
+// short cap (the old 500ms) SIGKILLs a legitimate node base on every render and
+// erases the founder's own statusline. The pile-up it was meant to prevent is now
+// stopped structurally by the tail-read + the base-output cache + the single-flight
+// lock below, so a generous timeout that clears interpreter cold-start is safe: the
+// spawn happens at most once per BASE_CACHE_TTL_MS and is single-flighted.
+const BASE_SPAWN_TIMEOUT_MS = 4000;
+
+// --- Secure per-user cache dir (CWE-59 hardening) --------------------------
+// The render cache, the base-output cache, and the single-flight lock all live in
+// a PER-USER subdir of os.tmpdir() created mode 0700, so another user on a shared
+// box cannot pre-plant a symlink at a predictable path, clobber a victim-writable
+// file, read the dashboard port, or inject ANSI escapes within the TTL. Every file
+// is written 0600 via O_EXCL to a random temp name then renamed into place, and
+// every read lstats the target and trusts it only when it is a REGULAR file owned
+// by the current uid. Fail-OPEN throughout: any error -> fresh render, never throw.
+function currentUid() {
+  try { return typeof process.getuid === 'function' ? process.getuid() : -1; }
+  catch (_) { return -1; }
+}
+// Resolve (and lazily create, 0700) the per-user cache dir. Returns null on any
+// failure so callers fall back to a fresh render rather than throwing.
+let _cacheDir = null;
+function cacheDir() {
+  if (_cacheDir) return _cacheDir;
+  try {
+    const uid = currentUid();
+    const name = 'company-statusline-' + (uid >= 0 ? uid : 'nouid');
+    const d = path.join(os.tmpdir(), name);
+    fs.mkdirSync(d, { recursive: true, mode: 0o700 });
+    // Re-assert 0700 even if the dir already existed (mkdir's mode is ignored for
+    // an existing dir). Only trust a dir we own; otherwise refuse to use it.
+    const st = fs.lstatSync(d);
+    if (!st.isDirectory() || (uid >= 0 && st.uid !== uid)) return null;
+    try { fs.chmodSync(d, 0o700); } catch (_) {}
+    _cacheDir = d;
+    return d;
+  } catch (_) {
+    return null;
+  }
+}
+// lstat the target and return true only when it is a REGULAR file owned by us and
+// not a symlink. A symlink, a non-regular file, or a file owned by another uid is
+// refused (do not read it). Fail-closed on the trust decision (treat as untrusted).
+function isTrustedFile(p) {
+  try {
+    const st = fs.lstatSync(p);
+    if (!st.isFile()) return false; // isFile() is false for symlinks (lstat)
+    const uid = currentUid();
+    if (uid >= 0 && st.uid !== uid) return false;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+// Atomically write content to a trusted path: write to a random sibling temp name
+// with O_EXCL|O_CREAT (flag 'wx', fails if a pre-planted file exists) mode 0600,
+// then rename into place. The rename replaces any symlink at the destination with
+// our regular file rather than following it. Best-effort: errors are swallowed.
+function atomicWrite(p, content) {
+  const dir = path.dirname(p);
+  const tmp = path.join(dir,
+    '.tmp-' + crypto.randomBytes(8).toString('hex'));
+  let fd = null;
+  try {
+    fd = fs.openSync(tmp, 'wx', 0o600); // O_EXCL: never follow/clobber a planted file
+    fs.writeSync(fd, content);
+    fs.closeSync(fd); fd = null;
+    fs.renameSync(tmp, p);
+  } catch (_) {
+    try { if (fd !== null) fs.closeSync(fd); } catch (__) {}
+    try { fs.unlinkSync(tmp); } catch (__) {}
+  }
+}
+function cachePathFor(sessionId) {
+  // Keyed by session_id so concurrent sessions never share a line. A blank sid
+  // gets a stable shared slot; that is harmless (the size+mtime guard still gates).
+  const safe = String(sessionId || 'nosid').replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120);
+  const d = cacheDir();
+  if (!d) return null;
+  return path.join(d, 'render-' + safe + '.cache');
+}
+// Fingerprint the transcript cheaply (size + mtime) so a grown/edited transcript
+// invalidates the cache even within the TTL. Returns '0:0' when there is no
+// transcript (the model+ctx still render; the TTL alone bounds those re-renders).
+function transcriptFingerprint(transcriptFile) {
+  if (!transcriptFile) return '0:0';
+  try {
+    const st = fs.statSync(transcriptFile);
+    return st.size + ':' + Math.round(st.mtimeMs);
+  } catch (_) {
+    return '0:0';
+  }
+}
+// Fingerprint a small control file (registry / base config) by a hash of its
+// CONTENTS, not mtime. These files are tiny and can be rewritten twice inside one
+// millisecond (mtime would collide and wrongly serve a stale cache); a content hash
+// invalidates correctly on any change. Returns '0' when the file is absent.
+function contentFingerprint(file) {
+  try {
+    return crypto.createHash('sha1').update(fs.readFileSync(file)).digest('hex').slice(0, 16);
+  } catch (_) {
+    return '0';
+  }
+}
+// Try to serve from cache. Writes the cached line + returns true on a hit; returns
+// false (no output) on any miss/error so the caller proceeds to a fresh render.
+// Refuses to read a symlinked / foreign-owned cache path (CWE-59).
+function tryServeFromCache(cachePath, fingerprint) {
+  if (!cachePath) return false;
+  try {
+    if (!isTrustedFile(cachePath)) return false;
+    const st = fs.statSync(cachePath);
+    if (Date.now() - st.mtimeMs >= CACHE_TTL_MS) return false;
+    const cached = fs.readFileSync(cachePath, 'utf8');
+    const nl = cached.indexOf('\n');
+    if (nl < 0) return false;
+    const head = cached.slice(0, nl);
+    if (head !== fingerprint) return false;
+    process.stdout.write(cached.slice(nl + 1));
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+// Store the composed line keyed by fingerprint. Atomic 0600 write via O_EXCL temp +
+// rename so a pre-planted symlink at the cache path is never followed. Best-effort.
+function storeInCache(cachePath, fingerprint, line) {
+  if (!cachePath) return;
+  atomicWrite(cachePath, fingerprint + '\n' + line);
+}
+
+// Parse stdin once for the cache-key inputs and attempt an early cache hit BEFORE
+// the expensive base spawn + registry lookups. A hit exits the process immediately.
+let cacheSid = '';
+let cacheTranscript = '';
+try {
+  const parsed = JSON.parse(input) || {};
+  cacheSid = parsed.session_id || '';
+  cacheTranscript = parsed.transcript_path || '';
+} catch (_) {}
+const CACHE_PATH = cachePathFor(cacheSid);
+// Fingerprint = transcript size+mtime PLUS a hash of the full stdin PLUS the
+// size+mtime of every input the LINK resolution reads (global + per-project
+// registries, base-command config). The output is a pure function of exactly these
+// inputs, so the cached line is valid iff all of them are unchanged. Including the
+// registry fingerprints keeps the cache CORRECT when a dashboard dies or a base is
+// (re)configured between renders, while still collapsing the genuine sub-second
+// storm where every input is byte-identical (the common case).
+const GLOBAL_REGISTRY_FP_PATH =
+  path.join(process.env.HOME || os.homedir(), '.claude', 'company-dashboards.json');
+const CACHE_FP = [
+  transcriptFingerprint(cacheTranscript),
+  crypto.createHash('sha1').update(input || '').digest('hex').slice(0, 16),
+  contentFingerprint(GLOBAL_REGISTRY_FP_PATH),
+  contentFingerprint(path.join(dir, 'dashboard-registry.json')),
+  contentFingerprint(path.join(dir, 'statusline-base.json')),
+].join('|');
+// Env escape hatch so the test (and any debug run) can force a fresh compute.
+if (!process.env.COMPANY_STATUSLINE_NO_CACHE && tryServeFromCache(CACHE_PATH, CACHE_FP)) {
+  return;
+}
+
 // --- Model + context helpers, mirrored from scripts/dashboard.js ---
 // Keep these in sync with dashboard.js so the statusline matches the dashboard.
 const KNOWN_1M_SUBSTRINGS = ['[1m]', 'claude-opus-4', 'claude-opus-4-5', 'claude-opus-4-8'];
@@ -130,34 +305,99 @@ function humanizeModel(modelId) {
   return name + ' (' + win + ')';
 }
 
-// Read the transcript jsonl and compute fill % from the last assistant usage block.
-function contextFillPct(transcriptFile, overrideModel) {
-  if (!transcriptFile) return null;
-  let raw;
-  try { raw = fs.readFileSync(transcriptFile, 'utf8'); } catch (_) { return null; }
-  if (!raw) return null;
+// Read at most maxBytes from the END of a file, dropping the leading partial line
+// when the window does not start at byte 0. Mirrors dashboard.js readTail (ORCH_TAIL
+// at dashboard.js:416) so the statusline never reads a whole multi-MB transcript on
+// every render. ALWAYS closes the fd (finally). Returns '' on any error (fail-open).
+const TRANSCRIPT_TAIL = 256 * 1024; // start window: covers the common last record.
+const TRANSCRIPT_TAIL_MAX = 8 * 1024 * 1024; // cap: never read more than 8MB.
+function readTail(p, maxBytes) {
+  let fd = null;
+  try {
+    fd = fs.openSync(p, 'r');
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - maxBytes);
+    const len = size - start;
+    if (len <= 0) return '';
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    let text = buf.toString('utf8');
+    if (start > 0) {
+      // Drop the partial first line of the tail window so JSON.parse never sees a
+      // truncated record. If there is no newline the whole window is one partial
+      // line and yields nothing.
+      const nl = text.indexOf('\n');
+      text = nl >= 0 ? text.slice(nl + 1) : '';
+    }
+    return text;
+  } catch (_) {
+    return '';
+  } finally {
+    if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} }
+  }
+}
+
+// Scan tail text (newest line first) for the last complete assistant usage record.
+// Returns { usage, modelId, completeLines } where completeLines is how many full
+// newline-delimited records the window held. completeLines distinguishes "the
+// window contained whole records but none had usage" (the usage is genuinely old;
+// do NOT grow) from "the window held one giant partial record and no complete line"
+// (the last record straddles the window's leading edge; grow to capture it).
+function findLastUsage(raw, overrideModel) {
   const lines = raw.split('\n');
-  let lastUsage = null;
   let lastModelId = overrideModel || null;
+  let completeLines = 0;
   for (let i = lines.length - 1; i >= 0; i--) {
     const line = lines[i].trim();
     if (!line) continue;
     let msg;
     try { msg = JSON.parse(line); } catch (_) { continue; }
+    completeLines += 1;
     const inner = msg.message || msg;
     if (inner && inner.role === 'assistant' && inner.usage) {
-      lastUsage = inner.usage;
-      if (!lastModelId) {
-        if (typeof inner.model === 'string') lastModelId = inner.model;
-        else if (typeof msg.model === 'string') lastModelId = msg.model;
+      let modelId = lastModelId;
+      if (!modelId) {
+        if (typeof inner.model === 'string') modelId = inner.model;
+        else if (typeof msg.model === 'string') modelId = msg.model;
       }
-      break;
+      return { usage: inner.usage, modelId, completeLines };
     }
   }
-  if (!lastUsage) return null;
-  const used = usedTokens(lastUsage);
-  const win = detectWindow(lastModelId);
-  return Math.round((used / win) * 100);
+  return { usage: null, modelId: null, completeLines };
+}
+
+// Read the transcript jsonl and compute fill % from the last assistant usage block.
+// ADAPTIVE tail: start at TRANSCRIPT_TAIL. Grow (double, up to TRANSCRIPT_TAIL_MAX)
+// ONLY when the window parsed NO complete record at all - that is the signature of a
+// single last record larger than the window, dropped as the partial first line (the
+// >64KB-record bug a fixed window mis-rendered as 0%). Once the window holds at least
+// one complete record, the newest usage in it is authoritative: a window full of
+// recent non-usage records means the last usage is genuinely old, so we do NOT keep
+// growing to resurrect an ancient buried usage (that would defeat the tail semantics).
+function contextFillPct(transcriptFile, overrideModel) {
+  if (!transcriptFile) return null;
+  let win = TRANSCRIPT_TAIL;
+  let fileSize = Infinity;
+  for (;;) {
+    const raw = readTail(transcriptFile, win);
+    if (!raw) return null;
+    const found = findLastUsage(raw, overrideModel);
+    if (found.usage) {
+      const used = usedTokens(found.usage);
+      const window = detectWindow(found.modelId);
+      return Math.round((used / window) * 100);
+    }
+    // A usage was NOT found. Only grow when the window held NO complete record (one
+    // oversized partial record straddling the leading edge). If it held complete
+    // records but none with usage, the recent window has no usage -> stop (null).
+    if (found.completeLines > 0) return null;
+    try {
+      const st = fs.statSync(transcriptFile);
+      fileSize = st.size;
+    } catch (_) {}
+    if (win >= TRANSCRIPT_TAIL_MAX || win >= fileSize) return null;
+    win = Math.min(win * 2, TRANSCRIPT_TAIL_MAX);
+  }
 }
 
 // Pick the context percentage to show. Prefer Claude's native pre-calculated
@@ -212,7 +452,44 @@ function renderSelfSegments(rawInput) {
 }
 
 // --- Chaining: run the prior statusline command if one is stored ---
+// The base spawn is the expensive, pile-up-prone step. Three mechanisms keep it
+// safe WITHOUT a short timeout that would SIGKILL a legitimate cold-starting node
+// base (node cold-start here is 0.65s-4.6s under load):
+//   1. BASE-OUTPUT CACHE: the base stdout is cached in the per-user cache dir with
+//      a short TTL (BASE_CACHE_TTL_MS). A render inside the TTL reuses it WITHOUT
+//      spawning. So the spawn happens at most once per ~5s, not once per render.
+//   2. SINGLE-FLIGHT LOCK: an atomic mkdir lockdir guards the spawn. If the lock is
+//      held (another render is already spawning), this render does NOT spawn a
+//      second base; it serves the last cached base (even if slightly stale) or
+//      omits the base lead. This is what actually prevents concurrent pile-up.
+//   3. GENEROUS TIMEOUT: because the spawn is rate-limited + single-flighted, a
+//      generous timeout (BASE_SPAWN_TIMEOUT_MS, >= node cold-start under load) no
+//      longer causes pile-up, so a real node base actually finishes and chains.
 const baseCfgPath = path.join(dir, 'statusline-base.json');
+// Per-(dir + base-config-content) cache key so a reconfigured base invalidates.
+function baseCacheKey(cmd) {
+  return crypto.createHash('sha1')
+    .update(String(dir) + '|' + String(cmd || '')).digest('hex').slice(0, 24);
+}
+// Read a fresh cached base output (trusted file, within ttl). Returns string or null.
+function readBaseCache(p, ttlMs) {
+  if (!p) return null;
+  try {
+    if (!isTrustedFile(p)) return null;
+    const st = fs.statSync(p);
+    if (Date.now() - st.mtimeMs >= ttlMs) return null;
+    return fs.readFileSync(p, 'utf8');
+  } catch (_) { return null; }
+}
+// Read the last cached base output regardless of age (used when the lock is held by
+// another render so we serve slightly-stale rather than pile up a second spawn).
+function readBaseCacheAny(p) {
+  if (!p) return null;
+  try {
+    if (!isTrustedFile(p)) return null;
+    return fs.readFileSync(p, 'utf8');
+  } catch (_) { return null; }
+}
 let base = '';
 try {
   const cfg = JSON.parse(fs.readFileSync(baseCfgPath, 'utf8'));
@@ -223,17 +500,76 @@ try {
     // Strip surrounding quotes from each part.
     const argv = parts.map(p => p.replace(/^['"]|['"]$/g, ''));
     // Skip a self-referential base: running it would spawn a child statusline.js
-    // that pays the 4s timeout for nothing. Treat self-reference as no base.
+    // that pays the full timeout for nothing. Treat self-reference as no base.
     if (argv.length > 0 && !isSelfReferential(argv, __filename)) {
-      try {
-        base = execFileSync(argv[0], argv.slice(1), {
-          input,
-          encoding: 'utf8',
-          timeout: 4000,
-        });
-      } catch (_) {
-        // Prior command failed - continue with empty base rather than crashing.
-        base = '';
+      const cdir = cacheDir();
+      const key = baseCacheKey(cfg.command);
+      const baseCachePath = cdir ? path.join(cdir, 'base-' + key + '.out') : null;
+      const lockDir = cdir ? path.join(cdir, 'base-' + key + '.lock') : null;
+      // 1. Fresh cached base output -> use it, no spawn.
+      const fresh = readBaseCache(baseCachePath, BASE_CACHE_TTL_MS);
+      if (fresh !== null) {
+        base = fresh;
+      } else {
+        // 2. Single-flight: try to acquire the lock by atomically creating lockDir.
+        let haveLock = false;
+        if (lockDir) {
+          try {
+            fs.mkdirSync(lockDir); // atomic: fails (EEXIST) if another render holds it
+            haveLock = true;
+          } catch (e) {
+            // Lock held. Treat a STALE lock (older than the spawn timeout + slack)
+            // as abandoned and reclaim it, so a crashed render never wedges chaining.
+            try {
+              const lst = fs.statSync(lockDir);
+              if (Date.now() - lst.mtimeMs > BASE_SPAWN_TIMEOUT_MS + 2000) {
+                try { fs.rmdirSync(lockDir); } catch (__) {}
+                try { fs.mkdirSync(lockDir); haveLock = true; } catch (__) {}
+              }
+            } catch (__) {}
+          }
+        }
+        if (haveLock) {
+          try {
+            // 3. Generous timeout clears node cold-start. SIGKILL reaps the direct
+            // child so a wedged base never lingers. Spawn is rate-limited by the
+            // cache TTL + single-flighted by the lock, so the long timeout is safe.
+            base = execFileSync(argv[0], argv.slice(1), {
+              input,
+              encoding: 'utf8',
+              timeout: BASE_SPAWN_TIMEOUT_MS,
+              killSignal: 'SIGKILL',
+            });
+            // Cache the fresh output for the next render within the TTL.
+            if (baseCachePath) atomicWrite(baseCachePath, base);
+          } catch (e) {
+            // A timed-out base still SALVAGES whatever it already wrote to stdout
+            // before the deadline. Some bases (e.g. the founder's cli-statusline.mjs)
+            // print their line immediately, then keep a detached grandchild holding
+            // the stdout pipe open, so execFileSync ALWAYS hits ETIMEDOUT even though
+            // the useful output landed instantly. Discarding e.stdout there would
+            // erase the base on every render (the rejected behavior). Use the captured
+            // stdout when present; only fall back to the cache/empty when there is none.
+            const partial = e && e.stdout != null ? e.stdout.toString() : '';
+            if (partial) {
+              base = partial;
+              if (baseCachePath) atomicWrite(baseCachePath, base);
+            } else {
+              // True failure with no output: serve last cached output if any.
+              // execFileSync already SIGKILL-reaped the direct child by here.
+              const stale = readBaseCacheAny(baseCachePath);
+              base = stale !== null ? stale : '';
+            }
+          } finally {
+            // ALWAYS release the lock.
+            try { fs.rmdirSync(lockDir); } catch (_) {}
+          }
+        } else {
+          // Lock held by another render: do NOT spawn a second base. Serve the last
+          // cached output (slightly stale) or omit the base lead for this render.
+          const stale = readBaseCacheAny(baseCachePath);
+          base = stale !== null ? stale : '';
+        }
       }
     }
   }
@@ -376,4 +712,7 @@ if (url) {
   link = '\u{1F4CA} ' + label + ' ' + url;
 }
 const out = [lead, link].filter(Boolean).join('  |  ');
+// Store the freshly composed line so the next sub-second re-render (same sid +
+// transcript fingerprint, within TTL) is served from cache instead of recomputing.
+storeInCache(CACHE_PATH, CACHE_FP, out);
 process.stdout.write(out);

package/skill/SKILL.md

@@ -493,7 +493,7 @@ Novel ideas use "NOVEL - needs validation" and MUST be tested in the same or nex
 
 Every findings append ends with a machine-greppable `STATUS: complete`, `STATUS: blocked`, or `STATUS: incomplete` line, and the orchestrator greps that line rather than parsing prose. If a task is blocked or impossible, the worker reports `BLOCKED: reason + what would unblock it` as the finding. Never silently return nothing, never expand scope to compensate. A `NEEDS-SPEC` block is answered by you from the goal and criteria context, and the SAME contract is re-issued with the answer pasted in. No replan, no respawn penalty, no guessing.
 
-**Continuity versus respawn:** for a follow-up question to a HEALTHY finished agent (a re-gate at a new head, a clarification), continue that agent by its id when the harness supports it, an uncorrupted context is an asset. **Retry by respawn:** a worker that fails, stalls, or returns confused output is never coached in place and never continued. Spawn a FRESH worker with the same contract plus the reviewer's 3-line reflection block (WHAT-WAS-TRIED / WHY-IT-FAILED cited to the findings file / DO-DIFFERENTLY), never the failed worker's self-report and never your own memory of the failure. Per-task commits make this safe to repeat. A corrupted context is abandoned, not repaired.
+**Continuity versus respawn:** for a follow-up question to a HEALTHY finished agent (a re-gate at a new head, a clarification), continue that agent by its id when the harness supports it, an uncorrupted context is an asset. **Retry by respawn:** a worker that fails, stalls, or returns confused output is never coached in place and never continued. Spawn a FRESH worker with the same contract plus a FAILURE-DIAGNOSIS block (structured: root-cause-class + cited evidence + what-to-change + keep + confidence) authored by the reviewer FROM THE FINDINGS FILE, never the raw transcript, never the failed worker's self-report, and never your own memory of the failure. The reviewer authors the block per agents/company-reviewer.md and the orchestrator pastes it into the fresh contract. This FAILURE-DIAGNOSIS block is the respawn driver, and it is MANDATORY at attempts >= 2: at the second attempt the next contract MUST carry a parsed-actionable diagnosis (a ROOT-CAUSE-CLASS in the enum plus a non-empty ROOT-CAUSE, EVIDENCE, and WHAT-TO-CHANGE, validated by `scripts/diagnosis-block.js` isActionable). FALLBACK: when an actionable diagnosis is unavailable (the reviewer could not author one, or it parses as not-actionable), degrade to the plain 3-line reflection block (WHAT-WAS-TRIED / WHY-IT-FAILED cited to the findings file / DO-DIFFERENTLY) so a respawn still happens. It degrades, it never bricks. Do NOT read the raw transcript to build a diagnosis, the no-raw-logs rule holds. Per-task commits make this safe to repeat. A corrupted context is abandoned, not repaired.
 
 ### VERIFY
 
@@ -538,7 +538,7 @@ CYCLE {N} VERDICT: {DONE or NOT DONE}
 ALL criteria pass + critic accepts + `SWEEP-CLEAN-STREAK >= K` = EXIT.
 Otherwise = loop, re-spawning the FAILING tasks plus any bug the proactive sweep confirmed, with the review feedback in their contracts.
 
-**Stall detector:** the reviewer keeps an `attempts` count on each criterion's entry in criteria.json (increment on every cycle it stays failing - the stop guard ignores extra fields). At `attempts >= 2` with same-shape evidence, the next THINK MUST produce a structurally different decomposition for that criterion: new approach, new surfaces, or HIRE. Re-issuing a near-identical contract after two same-shape failures is a planning bug, not persistence. The reviewer agent file instructs the reviewer to increment `attempts` every cycle a criterion stays failing; that instruction is what puts the value into criteria.json so the stall detector and the high-stakes gate can read it.
+**Stall detector:** the reviewer keeps an `attempts` count on each criterion's entry in criteria.json (increment on every cycle it stays failing - the stop guard ignores extra fields). At `attempts >= 2` with same-shape evidence, the next THINK MUST produce a structurally different decomposition for that criterion: new approach, new surfaces, or HIRE. That structurally-different decomposition is DRIVEN by the FAILURE-DIAGNOSIS block from retry-by-respawn above: the ROOT-CAUSE-CLASS picks the lever (wrong-approach -> new approach, missing-context -> add the inputs, scope-too-large -> split the contract, environment/tooling -> fix or swap the tool, spec-ambiguity -> resolve via NEEDS-SPEC, vacuous-or-misdirected-test -> re-point the test, flaky/transient -> re-run not re-plan) and the WHAT-TO-CHANGE is the contract-shaped delta the new spawn carries. The mandatory diagnosis at attempts >= 2 is what makes the re-decomposition concrete instead of a bare "try a new approach". Re-issuing a near-identical contract after two same-shape failures is a planning bug, not persistence. The reviewer agent file instructs the reviewer to increment `attempts` every cycle a criterion stays failing; that instruction is what puts the value into criteria.json so the stall detector and the high-stakes gate can read it.
 
 **ANTI-VACUOUS TEST:** a test must exercise the exact code path it claims to verify, never bypass it (e.g. by setting an env that short-circuits the code under test, or asserting on base state that predates the change). A test that passes against the pre-change code is vacuous and provides no signal. The reviewer confirms that every new test FAILS against the unfixed code before accepting it as evidence. The critic probes for this on every passing criterion.