@ngockhoale/ukit 2.6.3 → 2.6.5

package/CHANGELOG.md

@@ -2,6 +2,129 @@
 
 All notable changes to UKit are documented here.
 
+## 2.6.5 - 2026-09-19
+
+Stability release — third full audit pass on the 2.6.4 base (cycle C23). 15
+confirmed hang / freeze / silent-idle / silent-hook defects fixed with root
+causes (full register: `docs/AI_HANDOFF/BUGS-2.6.5.md`). Headline: the
+cycle-lockout mechanism observed live — stall-breaker streak erased on every
+Stop (BUG-C23-08) — is fixed, plus every blocking/degrading hook exit now
+announces on stdout per the §8 contract.
+
+- **Handoff stall-breaker streak erased every Stop (BUG-C23-08)**: the
+  stop-coordinator dedupe write dropped the `handoff` streak slot, so a wedged
+  RUN.md blocked forever; the merge now preserves the slot.
+- **Silent non-zero hook failures (BUG-C23-01, -03, -07)**: stderr-only crash
+  reasons in `output-compression`/`reinject-context`/`post-edit-verify`/
+  `stale-spec-check` + safe-patch exit-2 blocks + skill-router/vision-router/
+  task-watchdog crash paths now emit a stdout `systemMessage` before exit —
+  stderr reaches the model, not reliably the user.
+- **Lost/silent deadline emissions (BUG-C23-02, -04)**: compact-threshold's
+  same-tick `stdout.write` + `process.exit(0)` discarded the announce on pipes
+  (now `writeSync(1)`); deadline-expiry `exit 0` in four called `.mjs` modules
+  and `handoff-resume.sh` now announces the abandoned work.
+- **Fail-open/crash-posture defects (BUG-C23-05, -06)**: context-hardcap-gate's
+  internal-error catch now announces its fail-open degrade on stdout;
+  completion-gate's stop-coordinator spawn is deadline-bounded with forced
+  kill routed to the crash-streak path.
+- **Silent data loss + hot-path waste (BUG-C23-09, -10, -13, -15)**:
+  compact-threshold double capacity read collapsed to one; sweep failures
+  announce (bounded) instead of `.catch(() => {})` swallow; unguarded `main()`
+  no longer runs on `import()`; route-audit merges stage to an append-only
+  sidecar with a locked + exit fold instead of silently dropping entries.
+- **Unbounded growth + unbounded stalls (BUG-C23-11, -12, -14)**: memory
+  project archives capped; `permission-audit.log` rotates inside the prune
+  pass; `bin/ukit` runCli got an overall deadline watchdog.
+
+Regression gate: 138 files / 2360 tests green, liveness 120/120, §8 sweep
+clean, template↔installed parity byte-identical, async-caller census clean,
+all 25 C22 verdicts re-confirmed.
+
+## 2.6.4 - 2026-09-19
+
+Stability release — second full audit pass on the 2.6.3 base (cycle C22). 25
+confirmed hang / freeze / silent-idle / silent-hook defects fixed with root causes
+(full register: `docs/AI_HANDOFF/BUGS-2.6.4.md`), including the two carried C21
+residual lineages: **R1** (sync fs inside the hardcap-gate deadline → BUG-C22-01)
+and **R2** (sync fs inside handoff-resume deadline → BUG-C22-02).
+
+- **Stalled-mount freeze in the compact/hardcap chain (R1, BUG-C22-01)**: the entire
+  compact-threshold fs path (`readNegotiatedCapacity`, `buildCompactThresholds`,
+  `resolveCompactPhase`, `buildCompactPressureState`, pressure registration, compact
+  plan) converted to async `fsp`; every caller in hooks, `src/core/compact`, and
+  `src/core/status.js` now awaits; `isDirectRun` in `execution-ledger.mjs` /
+  `stop-coordinator.mjs` guards `realpathSync` behind a basename check so module
+  import no longer does sync fs on the deadline path.
+- **handoff-resume sync fs inside its deadline (R2, BUG-C22-02)** plus the same
+  sync-fs-under-deadline class in `reset-compact-pressure` (BUG-C22-03),
+  `auto-prune-bash` (BUG-C22-04) and `auto-allow-bash` (BUG-C22-06) — sync calls
+  inside armed unref'd hook deadlines parked the event loop so the deadline itself
+  could never fire.
+- **Stop-gate crash → block-forever (BUG-C22-05)**: a `completion-gate` coordinator
+  crash used to produce an unconditional `decision:block` on every subsequent stop.
+  New crash-streak breaker (`.ukit/storage/cache/completion-gate-crash.streak`,
+  byte-append counter, cap `handoff.fullstack.stopGateMaxCrashStreaks` default 3)
+  fails closed up to the cap then releases *loud*; omp bridge got the identical
+  try/catch + streak parity.
+- **Silent `exit 0` / `exit(0)` clusters now announce (§8 contract)**: missing-script
+  silent exits in 4 hooks (BUG-C22-07), deadline-expiry silent exits on 3 gated
+  hooks plus the hardcap-gate sites (BUG-C22-08), and `verification-guard`
+  stderr-only catch-all (BUG-C22-09) all emit the fail-open §8 JSON + stderr
+  announcement instead of going quiet.
+- **Unbounded spawned children get self-deadlines**: `compact-threshold.mjs`
+  `runCli` (BUG-C22-15, `UKIT_COMPACT_CLI_DEADLINE_MS` default 4s — bounds the
+  skill-router spawn too), `verify-release.mjs` spawn watchdog + tree-kill
+  (BUG-C22-20), `parallel-agents.mjs` per-level `UKIT_BENCH_LEVEL_TIMEOUT_MS`
+  30 min deadline with detached process-group SIGKILL (BUG-C22-21).
+- **`withFileLock` busy-spin on persistent stat errors (BUG-C22-16 runtime twin /
+  BUG-C22-17 core twin)**: a stat error inside the retry loop skipped both the
+  `maxWaitMs` check and the backoff sleep → tight spin for the process lifetime.
+  The budget check now lives inside the catch path in both copies.
+- **Sweep caps that could never fire (BUG-C22-10/11/12/13)**: tee sweep,
+  hook-telemetry sweep, exec-ledger sweep and omp hook-errors sweep computed the
+  overflow from the scanned *sample* instead of the eligible count, so configured
+  max-file caps (e.g. `TEE_MAX_FILES=500`) were unreachable.
+- **Vision receipts eaten / orphaned (BUG-C22-14/18)**: the vision marker-dir sweep
+  deleted `analyzed-*` receipts early → vision gate re-fired on every image; legacy
+  top-level `vision/analyzed-*.json` orphans had no pruner at all. Both prunes are
+  now TTL-coordinated with `isAlreadyAnalyzed`.
+- **Unbounded `.bak` backup writer (BUG-C22-19)**: `.claude/ukit/.ukit/backups/`
+  had no pruner; `pruneOldBackups` is now bounded.
+- **Registered timeout < internal worst case (BUG-C22-22/23/24/25)**:
+  `auto-allow-bash` 12→15s (internal worst 13s), `skill-router` 8→20s (worst
+  ~18s), `stale-spec-guard` 8→11s, and omp chain child budget 4000→12000ms with
+  ceiling 16000→52000ms — a hook can no longer be killed mid-work by a budget
+  smaller than its own declared worst case.
+
+Full fixed-bug enumeration (register `docs/AI_HANDOFF/BUGS-2.6.4.md`, all rows
+`verified`):
+
+- BUG-C22-01 (R1) — sync fs inside hardcap-gate deadline (compact-threshold + execution-ledger)
+- BUG-C22-02 (R2) — sync fs inside handoff-resume deadline
+- BUG-C22-03 — reset-compact-pressure: swallow-all + sync fs inside deadline
+- BUG-C22-04 — auto-prune-bash: invisible prune failure + sync fs inside deadline
+- BUG-C22-05 — completion-gate: persistent coordinator crash → block-forever (crash-streak breaker)
+- BUG-C22-06 — auto-allow-bash: sync fs inside deadline
+- BUG-C22-07 — missing-script silent `exit 0` cluster (4 hooks)
+- BUG-C22-08 — deadline-expiry silent `exit(0)` on gated hooks (+ hardcap sites)
+- BUG-C22-09 — verification-guard catch-all degrade on stderr only
+- BUG-C22-10 — tee sweep count cap unreachable (`TEE_MAX_FILES=500` never enforced)
+- BUG-C22-11 — hook-telemetry sweep count cap unreachable
+- BUG-C22-12 — exec-ledger sweep count cap unreachable
+- BUG-C22-13 — omp hook-errors sweep count cap unreachable
+- BUG-C22-14 — vision marker-dir sweep deletes `analyzed-*` receipts → vision gate re-fires
+- BUG-C22-15 — skill-router spawns `node compact-threshold.mjs prompt` unbounded (CLI self-deadline)
+- BUG-C22-16 — `withFileLock` busy-spin, runtime twin (token-utils.mjs)
+- BUG-C22-17 — `withFileLock` busy-spin, core twin (fileOps.js)
+- BUG-C22-18 — legacy top-level `vision/analyzed-*.json` orphans never pruned
+- BUG-C22-19 — `.claude/ukit/.ukit/backups/` `.bak` writer had no pruner
+- BUG-C22-20 — `verify-release.mjs` spawns with no timeout (watchdog + tree-kill)
+- BUG-C22-21 — `parallel-agents.mjs` N children, no timeout, partial-settle hang
+- BUG-C22-22 — auto-allow-bash registered timeout < internal worst case (12→15s)
+- BUG-C22-23 — skill-router registered timeout < internal worst case (8→20s)
+- BUG-C22-24 — stale-spec-guard registered timeout zero margin (8→11s)
+- BUG-C22-25 — omp chain child budget < every staged hook's worst case (4000→12000ms, ceiling 16000→52000ms)
+
 ## 2.6.3 - 2026-09-18
 
 - **Informational side-questions no longer self-block at the Stop gate.** A no-route

package/bin/ukit

@@ -11,17 +11,37 @@ async function readPackageVersion(packageRoot) {
   return packageJson.version;
 }
 
+const DEFAULT_CLI_DEADLINE_MS = 120_000;
+
+function resolveCliDeadlineMs() {
+  const raw = Number(process.env.UKIT_CLI_DEADLINE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CLI_DEADLINE_MS;
+}
+
 async function main() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const packageRoot = path.resolve(path.dirname(currentFile), '..');
-  const packageVersion = await readPackageVersion(packageRoot);
-
-  await runCli({
-    argv: process.argv.slice(2),
-    packageRoot,
-    projectRoot: process.cwd(),
-    packageVersion,
-  });
+  // Overall wall-clock watchdog: individual fs/readline awaits inside runCli are
+  // unbounded, so a wedged .ukit/external mount would park the CLI forever.
+  const deadlineMs = resolveCliDeadlineMs();
+  const watchdog = setTimeout(() => {
+    console.error(`[UKit] timed out after ${deadlineMs}ms — likely wedged filesystem; retry`);
+    process.exit(1);
+  }, deadlineMs);
+  watchdog.unref();
+
+  try {
+    const currentFile = fileURLToPath(import.meta.url);
+    const packageRoot = path.resolve(path.dirname(currentFile), '..');
+    const packageVersion = await readPackageVersion(packageRoot);
+
+    await runCli({
+      argv: process.argv.slice(2),
+      packageRoot,
+      projectRoot: process.cwd(),
+      packageVersion,
+    });
+  } finally {
+    clearTimeout(watchdog);
+  }
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "2.6.3",
+  "version": "2.6.5",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex, OpenCode, and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/scripts/bench/parallel-agents.mjs

@@ -18,6 +18,14 @@ import { spawn } from 'node:child_process';
 
 const SLOWDOWN_LIMIT = 2.0;
 
+// BUG-C22-21: a level must never wait forever — one wedged `shell:true` child
+// used to leave `settled < n` permanently and hang the whole benchmark
+// mid-level. A per-level deadline SIGKILLs unsettled children (their whole
+// process group — detached:true puts each `sh -c` in its own group so
+// grandchildren die too) and resolves the level marked timedOut.
+// UKIT_BENCH_LEVEL_TIMEOUT_MS overrides the budget for tests.
+const LEVEL_TIMEOUT_MS = Number(process.env.UKIT_BENCH_LEVEL_TIMEOUT_MS) || 30 * 60 * 1000; // 30 min
+
 function parseArgs(argv) {
   const opts = { levels: '1,3,5,10', cmd: 'yarn test:release-core', out: '.cache/bench/parallel-agents.json' };
   for (let i = 0; i < argv.length; i += 2) {
@@ -46,19 +54,43 @@ function runLevel(n, cmd) {
     let highWater = 0;
     let failures = 0;
     let settled = 0;
+    let timedOut = false;
+    let finished = false;
     const children = [];
+    // BUG-C22-21: per-level deadline — kill stragglers and resolve marked-failed.
+    const deadline = setTimeout(() => {
+      timedOut = true;
+      for (const child of children) {
+        if (!child.ukitSettled) {
+          child.ukitSettled = true;
+          settled += 1;
+          failures += 1;
+          try {
+            process.kill(-child.pid, 'SIGKILL'); // kill the whole process tree
+          } catch {
+            try { child.kill('SIGKILL'); } catch { /* already gone */ }
+          }
+        }
+      }
+      maybeFinish();
+    }, LEVEL_TIMEOUT_MS);
+    deadline.unref();
     for (let i = 0; i < n; i += 1) {
-      const child = spawn(cmd, { shell: true, stdio: 'ignore' });
+      const child = spawn(cmd, { shell: true, stdio: 'ignore', detached: true });
       live += 1;
       highWater = Math.max(highWater, live);
       children.push(child);
       child.on('error', () => {
+        if (child.ukitSettled) return;
+        child.ukitSettled = true;
         live -= 1;
         settled += 1;
         failures += 1;
         maybeFinish();
       });
       child.on('exit', (code) => {
+        if (child.ukitSettled) return;
+        child.ukitSettled = true;
         live -= 1;
         settled += 1;
         if (code !== 0) failures += 1;
@@ -66,8 +98,14 @@ function runLevel(n, cmd) {
       });
     }
     function maybeFinish() {
+      if (finished) return;
       if (settled === n) {
-        resolve({ n, wallClockMs: Date.now() - t0, failures, concurrencyHighWaterMark: highWater });
+        finished = true;
+        clearTimeout(deadline);
+        if (timedOut) {
+          console.error(`[bench] level n=${n}: deadline ${LEVEL_TIMEOUT_MS}ms exceeded — unsettled children killed and counted as failures`);
+        }
+        resolve({ n, wallClockMs: Date.now() - t0, failures, concurrencyHighWaterMark: highWater, timedOut });
       }
     }
   });
@@ -110,8 +148,8 @@ async function main() {
 
   const result = {
     cpuCount,
-    levels: rows.map(({ n, wallClockMs, slowdownFactor, perRunCost, failures, concurrencyHighWaterMark }) => ({
-      n, wallClockMs, slowdownFactor, perRunCost, failures, concurrencyHighWaterMark,
+    levels: rows.map(({ n, wallClockMs, slowdownFactor, perRunCost, failures, concurrencyHighWaterMark, timedOut }) => ({
+      n, wallClockMs, slowdownFactor, perRunCost, failures, concurrencyHighWaterMark, timedOut,
     })),
     recommended,
     measurementConditions: { loadAvgStart, loadAvgEnd, startedAt, finishedAt, cpuCount },

package/scripts/release/verify-release.mjs

@@ -6,6 +6,14 @@ import path from 'node:path';
 const rootDir = process.cwd();
 const npmCacheDir = path.join(os.tmpdir(), 'ukit-npm-cache');
 
+// BUG-C22-20: every spawned child carries an explicit timeout + killSignal so a
+// wedged npm/yarn child (network partition, hung credential helper) fails the
+// step instead of hanging the verifier forever. Per-step budgets: release test
+// steps are the slowest (full suite); the registry read is a single network call.
+// UKIT_VERIFY_STEP_TIMEOUT_MS overrides the step budget for tests.
+const STEP_TIMEOUT_MS = Number(process.env.UKIT_VERIFY_STEP_TIMEOUT_MS) || 10 * 60 * 1000; // 10 min
+const REGISTRY_TIMEOUT_MS = Number(process.env.UKIT_VERIFY_REGISTRY_TIMEOUT_MS) || 60 * 1000; // 1 min
+
 // Opt-in post-publish registry-parity check (Release Policy invariant: npm and git always hold
 // the same latest version). Only meaningful AFTER `npm publish` — before publish the registry is
 // behind by definition — so it is gated behind --post-publish and never runs by default.
@@ -67,32 +75,61 @@ for (const step of steps) {
 
 console.log('\n[release:verify] All release checks passed.');
 
+// BUG-C22-20: bounded spawn — an armed watchdog SIGKILLs the child's whole
+// process group on expiry (detached: true puts the child in its own group so
+// grandchildren like `sh -c "sleep …"` can't keep our stdio pipes open).
+function spawnBounded(command, args, opts, timeoutMs) {
+  const child = spawn(command, args, { ...opts, detached: true });
+  child.ukitTimedOut = false;
+  const watchdog = setTimeout(() => {
+    child.ukitTimedOut = true;
+    try {
+      process.kill(-child.pid, 'SIGKILL'); // kill the whole tree
+    } catch {
+      try { child.kill('SIGKILL'); } catch { /* already gone */ }
+    }
+  }, timeoutMs);
+  watchdog.unref();
+  child.on('exit', () => clearTimeout(watchdog));
+  return child;
+}
+
 function runStep({ command, args, env }) {
   return new Promise((resolve) => {
-    const child = spawn(command, args, {
+    const child = spawnBounded(command, args, {
       cwd: rootDir,
       env,
       stdio: 'inherit',
-    });
+    }, STEP_TIMEOUT_MS);
 
-    child.on('close', (code) => resolve(code ?? 1));
+    child.on('exit', (code) => {
+      if (child.ukitTimedOut) {
+        console.error(`[release:verify] step timed out after ${STEP_TIMEOUT_MS}ms — child killed (check for a wedged ${command}/network)`);
+      }
+      resolve(code ?? 1);
+    });
     child.on('error', () => resolve(1));
   });
 }
 
 function readRegistryVersion() {
   return new Promise((resolve) => {
-    const child = spawn('npm', ['view', '@ngockhoale/ukit', 'version'], {
+    const child = spawnBounded('npm', ['view', '@ngockhoale/ukit', 'version'], {
       cwd: rootDir,
       env: { ...process.env, npm_config_cache: npmCacheDir },
       stdio: ['ignore', 'pipe', 'inherit'],
-    });
+    }, REGISTRY_TIMEOUT_MS);
 
     let stdout = '';
     child.stdout.on('data', (chunk) => {
       stdout += chunk;
     });
-    child.on('close', () => {
+    child.on('exit', () => {
+      if (child.ukitTimedOut) {
+        console.error(`[release:verify] registry version check timed out after ${REGISTRY_TIMEOUT_MS}ms — child killed (check npm/network)`);
+        resolve('<unavailable>');
+        return;
+      }
       const version = stdout.trim();
       resolve(version.length > 0 ? version : '<unavailable>');
     });

package/src/core/applyPlan.js

@@ -15,6 +15,71 @@ export function isTccProtectedPath(filePath) {
   });
 }
 
+// BUG-C22-19: every `overwrite_with_backup` write adds a timestamped `.bak` under
+// backupRoot and nothing ever removed them (239 live files at census, still
+// growing). Bound the dir: keep at most BACKUP_MAX_FILES of the newest `.bak`
+// files and nothing older than BACKUP_MAX_AGE_MS. The listing itself is capped
+// (BACKUP_SCAN_LIMIT) so a huge pre-existing dir can't stall install on a slow
+// external mount; a backlog beyond the cap drains over successive installs.
+export const BACKUP_MAX_FILES = 100;
+export const BACKUP_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+export const BACKUP_SCAN_LIMIT = 5000;
+
+async function collectBackupFiles(dir, out, budget) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return; // unreadable/missing dir — nothing to prune here
+  }
+  for (const entry of entries) {
+    if (out.length >= budget) return;
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectBackupFiles(entryPath, out, budget);
+    } else if (entry.isFile() && entry.name.endsWith('.bak')) {
+      let mtimeMs = 0;
+      try {
+        ({ mtimeMs } = await fs.stat(entryPath));
+      } catch {
+        // Vanished or unstat-able — keep mtimeMs 0 so it is treated as oldest.
+      }
+      out.push({ path: entryPath, mtimeMs });
+    }
+  }
+}
+
+export async function pruneOldBackups(backupRoot, {
+  maxFiles = BACKUP_MAX_FILES,
+  maxAgeMs = BACKUP_MAX_AGE_MS,
+  scanLimit = BACKUP_SCAN_LIMIT,
+  now = Date.now(),
+} = {}) {
+  const files = [];
+  await collectBackupFiles(backupRoot, files, scanLimit);
+
+  // Newest first — survivors are the newest maxFiles that are also within the age bound.
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  let removed = 0;
+  for (let i = 0; i < files.length; i += 1) {
+    const file = files[i];
+    const overCount = i >= maxFiles;
+    const overAge = now - file.mtimeMs > maxAgeMs;
+    if (!overCount && !overAge) continue;
+    try {
+      await fs.rm(file.path, { force: true }); // force:true — ENOENT under a concurrent reader is fine
+      removed += 1;
+    } catch {
+      // Advisory prune — a stubborn file is retried next install, never a hard failure.
+    }
+  }
+
+  if (removed > 0) {
+    console.log(`[UKit] Pruned ${removed} old backup file(s) under ${backupRoot} (kept ≤${maxFiles}, ≤${Math.round(maxAgeMs / 86400000)}d old).`);
+  }
+  return { scanned: files.length, removed };
+}
+
 export async function applyDiffResults(diffResults, { backupRoot, projectRoot } = {}) {
   const writes = [];
   let skippedUpdates = 0;

package/src/core/compact/threshold.js

@@ -445,8 +445,10 @@ function computeEstimatedTotalTokens({
 
 // The record the advisory guard published for this project, or null when nothing has been
 // negotiated yet (fresh install, non-project caller, tests).
-function readNegotiatedCapacity(config = {}) {
-  const record = readContextCapacityRecord(config?.projectRoot);
+// BUG-C22-01: async on purpose — readContextCapacityRecord now uses fsp so a
+// stalled .ukit mount cannot park the event loop inside an armed hook deadline.
+async function readNegotiatedCapacity(config = {}) {
+  const record = await readContextCapacityRecord(config?.projectRoot);
   if (!record) return null;
   return resolveContextCapTokens({
     env: process.env,
@@ -455,7 +457,7 @@ function readNegotiatedCapacity(config = {}) {
   });
 }
 
-export function buildCompactThresholds(config = {}) {
+export async function buildCompactThresholds(config = {}) {
   const shippedHardCap = positiveInteger(
     config?.compact?.hardCapTokens,
     loadShippedCompactBudget().hardCapTokens,
@@ -463,7 +465,7 @@ export function buildCompactThresholds(config = {}) {
   const explicitSoftThreshold = finiteNumber(config?.compact?.tokenThreshold, 0);
   // Negotiated capacity (H22): the guard publishes what it derived from the live route and
   // this shared path consumes it; without a record the shipped tuning applies unchanged.
-  const negotiated = readNegotiatedCapacity(config);
+  const negotiated = await readNegotiatedCapacity(config);
   const hardCapTokens = negotiated
     ? Math.max(1, Math.min(shippedHardCap, negotiated.capTokens))
     : shippedHardCap;
@@ -485,7 +487,7 @@ export function buildCompactThresholds(config = {}) {
   };
 }
 
-function buildReleaseThresholds(thresholds = buildCompactThresholds()) {
+function buildReleaseThresholds(thresholds) {
   const softReleaseThreshold = Math.max(
     Math.min(thresholds.softThreshold, Math.round(thresholds.softThreshold * SOFT_RELEASE_RATIO)),
     1,
@@ -501,11 +503,12 @@ function buildReleaseThresholds(thresholds = buildCompactThresholds()) {
   };
 }
 
-export function resolveCompactPhase(
+export async function resolveCompactPhase(
   estimatedTotalTokens,
-  thresholds = buildCompactThresholds(),
+  thresholds = null,
   previousState = {},
 ) {
+  thresholds = thresholds ?? await buildCompactThresholds();
   const previousPhase = normalizePhase(previousState?.phase ?? previousState);
   const releaseThresholds = buildReleaseThresholds(thresholds);
   if (estimatedTotalTokens >= thresholds.hardThreshold) {
@@ -527,7 +530,7 @@ function resolvePhaseCooldownMs(phase) {
   return PHASE_COOLDOWN_MS[normalizePhase(phase)] ?? 0;
 }
 
-function resolvePlanDeltaThreshold(phase, thresholds = buildCompactThresholds()) {
+function resolvePlanDeltaThreshold(phase, thresholds) {
   return normalizePhase(phase) === 'hard'
     ? Math.max(60, Math.round(thresholds.hardThreshold * 0.14))
     : Math.max(40, Math.round(thresholds.softThreshold * 0.12));
@@ -660,9 +663,9 @@ function projectPressureDocument(sessions) {
   };
 }
 
-export function buildCompactPressureState(rawState = null, config = {}) {
+export async function buildCompactPressureState(rawState = null, config = {}) {
   rawState = resolvePressureRecord(rawState, config);
-  const thresholds = buildCompactThresholds(config);
+  const thresholds = await buildCompactThresholds(config);
   const rawSoftThreshold = finiteNumber(rawState?.softThreshold, 0);
   const rawHardThreshold = finiteNumber(rawState?.hardThreshold, 0);
   if (!finiteNumber(config?.compact?.tokenThreshold, 0) && rawSoftThreshold > 0) {
@@ -711,7 +714,7 @@ export function buildCompactPressureState(rawState = null, config = {}) {
     estimatedContextTokens,
     sessionTokens,
     estimatedTotalTokens,
-    phase: resolveCompactPhase(estimatedTotalTokens, thresholds, rawState),
+    phase: await resolveCompactPhase(estimatedTotalTokens, thresholds, rawState),
     taskMode,
     cooldownUntil: finiteNumber(rawState?.cooldownUntil, 0),
     routingContext: rawState?.routingContext && typeof rawState.routingContext === 'object'
@@ -725,14 +728,14 @@ export function buildCompactPressureState(rawState = null, config = {}) {
   };
 }
 
-export function registerPromptPressure(state, {
+export async function registerPromptPressure(state, {
   promptText = '',
   routingContext = {},
   previousContext = null,
   routeSummary = null,
   timestamp = Date.now(),
 } = {}, config = {}) {
-  const current = buildCompactPressureState(state, config);
+  const current = await buildCompactPressureState(state, config);
   const normalizedPrompt = String(promptText || routingContext?.lastExplicitUserPromptText || '').trim();
   if (!normalizedPrompt) {
     return current;
@@ -753,7 +756,7 @@ export function registerPromptPressure(state, {
       })
     : current.recentPrompts;
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: timestamp,
     routingContext,
@@ -773,7 +776,7 @@ export function registerPromptPressure(state, {
   }, config);
 }
 
-export function registerOutputPressure(state, {
+export async function registerOutputPressure(state, {
   command = '',
   profile = 'generic',
   summary = '',
@@ -783,7 +786,7 @@ export function registerOutputPressure(state, {
   exitCode = null,
   timestamp = Date.now(),
 } = {}, config = {}) {
-  const current = buildCompactPressureState(state, config);
+  const current = await buildCompactPressureState(state, config);
   const normalizedSummary = summarizeOutputText(summary, command);
   if (!normalizedSummary) {
     return current;
@@ -805,7 +808,7 @@ export function registerOutputPressure(state, {
     keyBuilder: (candidate) => `${candidate.command ?? ''}|${candidate.summary ?? ''}`,
   });
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: timestamp,
     recentOutputs,
@@ -819,8 +822,8 @@ export function registerOutputPressure(state, {
   }, config);
 }
 
-export function registerThresholdCompactPlan(state, plan, config = {}) {
-  const current = buildCompactPressureState(state, config);
+export async function registerThresholdCompactPlan(state, plan, config = {}) {
+  const current = await buildCompactPressureState(state, config);
   if (!plan?.active) {
     return current;
   }
@@ -836,7 +839,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
     lines: plan.lines,
   });
   if (current.latestPlan?.fingerprint === fingerprint) {
-    return buildCompactPressureState({
+    return await buildCompactPressureState({
       ...current,
       updatedAt: now,
       latestPlan: {
@@ -854,7 +857,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
   const materialChange = isMaterialThresholdPlanChange(current.latestPlan, plan, thresholds);
 
   if (withinCooldown && !materialChange) {
-    return buildCompactPressureState({
+    return await buildCompactPressureState({
       ...current,
       updatedAt: now,
       latestPlan: {
@@ -889,7 +892,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
     ? Math.min(current.sessionTokens, decayTarget)
     : current.sessionTokens;
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: now,
     sessionTokens: decayedSessionTokens,
@@ -910,7 +913,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
   }, config);
 }
 
-export function buildThresholdCompactPlan({
+export async function buildThresholdCompactPlan({
   state,
   config = {},
   routeState = {},
@@ -918,8 +921,8 @@ export function buildThresholdCompactPlan({
   dynamicLines = [],
   maxTokens = 280,
 } = {}) {
-  const normalizedState = buildCompactPressureState(state, config);
-  const thresholds = buildCompactThresholds(config);
+  const normalizedState = await buildCompactPressureState(state, config);
+  const thresholds = await buildCompactThresholds(config);
   const phase = normalizedState.phase;
   if (phase === 'monitor') {
     return {
@@ -1042,7 +1045,7 @@ export function buildThresholdCompactPlan({
 
 export async function readCompactPressureState(projectRoot, config = {}) {
   const runtimePaths = buildRuntimePaths(projectRoot);
-  return buildCompactPressureState(await readJsonIfExists(runtimePaths.compactPressurePath), config);
+  return await buildCompactPressureState(await readJsonIfExists(runtimePaths.compactPressurePath), config);
 }
 
 // All compact-pressure mutations share one lock on the state file: without it,
@@ -1055,9 +1058,9 @@ async function mutateCompactPressureState(projectRoot, mutator, config = {}) {
   return withFileLock(runtimePaths.compactPressurePath, async () => {
     const sessions = readPressureDocument(await readJsonIfExists(runtimePaths.compactPressurePath));
     const { id, record } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
-    const current = buildCompactPressureState(record, config);
-    const next = mutator(current);
-    const normalized = buildCompactPressureState(next, config);
+    const current = await buildCompactPressureState(record, config);
+    const next = await mutator(current);
+    const normalized = await buildCompactPressureState(next, config);
     sessions[id] = { ...normalized, updatedAt: Date.now() };
     await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
@@ -1069,7 +1072,7 @@ export async function writeCompactPressureState(projectRoot, state, config = {})
   return withFileLock(runtimePaths.compactPressurePath, async () => {
     const sessions = readPressureDocument(await readJsonIfExists(runtimePaths.compactPressurePath));
     const { id } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
-    const normalized = buildCompactPressureState(state, config);
+    const normalized = await buildCompactPressureState(state, config);
     sessions[id] = { ...normalized, updatedAt: Date.now() };
     await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;

package/src/core/fileOps.js

@@ -255,8 +255,15 @@ export async function withFileLock(filePath, fn, { staleMs = LOCK_STALE_MS, maxW
           continue; // the slot is free now — retry immediately
         }
       }
-    } catch {
-      continue; // lock vanished between mkdir and stat — retry immediately
+    } catch (statError) {
+      // BUG-C22-17: a persistent stat error (EPERM/ENOTDIR/EIO on a failing
+      // mount, or ELOOP/ENOENT on a dangling symlink where mkdir still reports
+      // EEXIST) must not busy-spin — a bare `continue` skipped both the
+      // maxWait break and the backoff sleep, looping mkdir→stat→throw forever.
+      if (Date.now() - startedAt >= maxWaitMs) break; // fail open — run unlocked
+      if (statError?.code === 'ENOENT') continue; // lock vanished — retry immediately
+      await sleep(lockBackoffDelayMs());
+      continue;
     }
 
     if (Date.now() - startedAt >= maxWaitMs) break; // fail open — run unlocked