@ngockhoale/ukit 2.6.3 → 2.6.4

package/templates/.claude/hooks/verification-guard.sh

@@ -65,7 +65,16 @@ PROGRESS_FILE="$PROJECT_ROOT/.claude/ukit/verification-progress.json"
 INPUT_FILE="$UKIT_INPUT_FILE" STATE_FILE="$STATE_FILE" ROUTE_CACHE_FILE="$ROUTE_CACHE_FILE" PROGRESS_FILE="$PROGRESS_FILE" UKIT_RUNTIME_DIR="$SCRIPT_DIR/../ukit/runtime" node <<'NODE'
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10) || 3000;
 const LOCK_STARTED_AT = Date.now();
-setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+// SPEC §8: a timed-out gate silently passes work it never evaluated — announce the
+// degrade (fail-open posture kept: still exit 0).
+setTimeout(() => {
+  try {
+    process.stdout.write(JSON.stringify({
+      systemMessage: `UKit verification-guard: evaluation exceeded its ${HOOK_DEADLINE_MS}ms deadline; this command was allowed without verification tracking.`,
+    }) + '\n');
+  } catch {}
+  process.exit(0);
+}, HOOK_DEADLINE_MS).unref();
 // TASK-015 fix round 1: the awaitable fs surface. Every state/progress read and
 // the atomic progress mutation is awaited so the unref'd self-deadline above can
 // always preempt it; synchronous fs calls park the event loop instead.
@@ -544,6 +553,13 @@ process.exit(0);
 })().catch((err) => {
   // Advisory hook: an unexpected error (including a rejected lock) must never
   // turn into a non-zero exit — degrade to a bounded diagnostic and exit 0.
+  // SPEC §8: the degrade is emitted on stdout too — stderr alone may never reach
+  // the user, and a wedged gate must not look identical to a clean pass.
+  try {
+    process.stdout.write(JSON.stringify({
+      systemMessage: `UKit verification-guard: unexpected error (${err?.message ?? err}); command allowed without verification tracking.`,
+    }) + '\n');
+  } catch {}
   try {
     process.stderr.write(`verification-guard: unexpected error (${err?.message ?? err})\n`);
   } catch {}

package/templates/.claude/settings.json

@@ -73,7 +73,7 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/stale-spec-guard.sh\"",
-            "timeout": 8
+            "timeout": 11
           },
           {
             "type": "command",
@@ -83,7 +83,7 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-router.sh\"",
-            "timeout": 8
+            "timeout": 20
           },
           {
             "type": "command",
@@ -103,7 +103,7 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/auto-allow-bash.sh\"",
-            "timeout": 12
+            "timeout": 15
           },
           {
             "type": "command",
@@ -191,7 +191,7 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-router.sh\"",
-            "timeout": 8
+            "timeout": 20
           },
           {
             "type": "command",

package/templates/.claude/ukit/index/extract-image.mjs

@@ -46,6 +46,12 @@ const DEFAULT_LIMIT = 3;
 const MAX_DECODED_BYTES = 10 * 1024 * 1024; // 10 MB
 const RETENTION_MAX_IMAGE_FILES = 20;
 const MARKER_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
+// analyzed-<sha>.json receipts outlive their marker dir: deleting the dir at
+// 24h also deletes the receipt isAlreadyAnalyzed() reads, which re-arms
+// pending-<sha>.json for an already-analyzed image and re-fires the vision
+// gate every sweep (BUG-C22-14). Receipts get their own longer TTL, shared
+// with the legacy top-level analyzed-*.json pruner (BUG-C22-18).
+const ANALYZED_RECEIPT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30d
 
 /**
  * Single shared hash function for both the image filename sha and the
@@ -491,6 +497,23 @@ function pruneImageFiles(outDir) {
       // ignore
     }
   }
+
+  // BUG-C22-18: legacy top-level analyzed-<sha>.json receipts match neither
+  // pruner and never converge — remove them once past the shared receipt TTL.
+  // Safe: isAlreadyAnalyzed() only reads receipts INSIDE marker dirs; nothing
+  // consults the top-level orphans.
+  const now = Date.now();
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.startsWith('analyzed-') || !e.name.endsWith('.json')) continue;
+    try {
+      const full = path.join(outDir, e.name);
+      if (now - fs.statSync(full).mtimeMs > ANALYZED_RECEIPT_MAX_AGE_MS) {
+        fs.unlinkSync(full);
+      }
+    } catch {
+      // ignore
+    }
+  }
 }
 
 function pruneMarkerDirs(outDir) {
@@ -511,6 +534,10 @@ function pruneMarkerDirs(outDir) {
       continue;
     }
     if (now - mtimeMs > MARKER_MAX_AGE_MS) {
+      // BUG-C22-14: a dir holding an analyzed-<sha>.json receipt younger than
+      // the receipt TTL is kept — deleting it would erase the only record
+      // isAlreadyAnalyzed() reads and re-arm the vision gate every sweep.
+      if (hasLiveAnalyzedReceipt(full, now)) continue;
       try {
         fs.rmSync(full, { recursive: true, force: true });
       } catch {
@@ -520,6 +547,28 @@ function pruneMarkerDirs(outDir) {
   }
 }
 
+// Returns true when the marker dir still carries an analyzed-<sha>.json receipt
+// inside its TTL — the receipt outlives the 24h dir sweep so the analyzed-sha
+// filter keeps suppressing re-arms until the receipt itself ages out.
+function hasLiveAnalyzedReceipt(markerDir, now) {
+  let names;
+  try {
+    names = fs.readdirSync(markerDir);
+  } catch {
+    return false;
+  }
+  for (const name of names) {
+    if (!name.startsWith('analyzed-') || !name.endsWith('.json')) continue;
+    try {
+      const mtimeMs = fs.statSync(path.join(markerDir, name)).mtimeMs;
+      if (now - mtimeMs <= ANALYZED_RECEIPT_MAX_AGE_MS) return true;
+    } catch {
+      // ignore
+    }
+  }
+  return false;
+}
+
 function printResult(opts, result) {
   if (opts.json) {
     console.log(JSON.stringify(result));

package/templates/.claude/ukit/runtime/compact-threshold.mjs

@@ -1,5 +1,4 @@
 import fs from 'node:fs/promises';
-import fsSync from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import {
@@ -456,13 +455,17 @@ export const CAPACITY_RECORD_SEGMENTS = ['.ukit', 'storage', 'cache', 'context-c
 // smaller verified window moves the advisory phases down with the cap they precede.
 export const SOFT_TO_CAP_RATIO = 0.3;
 
-export function readContextCapacityRecord(projectRoot) {
+// BUG-C22-01: async on purpose — every consumer of this module runs inside an
+// unref'd hook deadline (context-hardcap-gate.sh, skill-router's prompt CLI). A
+// synchronous readFileSync on a stalled .ukit mount parks the event loop so the
+// armed deadline can never fire (C21-04 class). Callers must await.
+export async function readContextCapacityRecord(projectRoot) {
   const root = projectRoot
     || process.env.CLAUDE_PROJECT_DIR
     || process.env.PROJECT_ROOT
     || process.cwd();
   try {
-    const parsed = JSON.parse(fsSync.readFileSync(path.join(root, ...CAPACITY_RECORD_SEGMENTS), 'utf8'));
+    const parsed = JSON.parse(await fs.readFile(path.join(root, ...CAPACITY_RECORD_SEGMENTS), 'utf8'));
     return parsed && typeof parsed === 'object' ? parsed : null;
   } catch {
     return null;
@@ -471,8 +474,8 @@ export function readContextCapacityRecord(projectRoot) {
 
 // Negotiated capacity: env override > config override > the model the guard last observed >
 // conservative fallback. Exported so the source twin and diagnostics read the same number.
-export function resolveCompactCapacity(config = {}) {
-  const record = readContextCapacityRecord(config?.projectRoot);
+export async function resolveCompactCapacity(config = {}) {
+  const record = await readContextCapacityRecord(config?.projectRoot);
   return resolveContextCapTokens({
     env: process.env,
     config,
@@ -480,13 +483,13 @@ export function resolveCompactCapacity(config = {}) {
   });
 }
 
-export function buildCompactThresholds(config = {}) {
+export async function buildCompactThresholds(config = {}) {
   const explicitSoftThreshold = finiteNumber(config?.compact?.tokenThreshold, 0);
   const shippedHardCap = positiveInteger(config?.compact?.hardCapTokens, 500_000);
   // Only tighten once a record exists: an install with no evidence yet (and every caller
   // that passes no project root) keeps the shipped tuning unchanged.
-  const record = readContextCapacityRecord(config?.projectRoot);
-  const negotiated = record ? resolveCompactCapacity(config) : null;
+  const record = await readContextCapacityRecord(config?.projectRoot);
+  const negotiated = record ? await resolveCompactCapacity(config) : null;
   const hardCapTokens = negotiated
     ? Math.max(1, Math.min(shippedHardCap, negotiated.capTokens))
     : shippedHardCap;
@@ -511,16 +514,16 @@ export function buildCompactThresholds(config = {}) {
 
 // Absolute, non-negotiable ceiling — separate from the soft/hard advisory phases above.
 // Crossing this means the advisory nudges were not followed; real compaction is mandatory.
-export function isHardCapExceeded(estimatedTotalTokens, config = {}) {
-  const { hardCapTokens } = buildCompactThresholds(config);
+export async function isHardCapExceeded(estimatedTotalTokens, config = {}) {
+  const { hardCapTokens } = await buildCompactThresholds(config);
   return finiteNumber(estimatedTotalTokens, 0) >= hardCapTokens;
 }
 
 // Called from the PreCompact hook path once real compaction has happened, so the
 // hard-cap gate unblocks on the next tool call instead of staying tripped forever.
-export function resetCompactPressureState(rawState = {}, config = {}) {
-  const current = buildCompactPressureState(rawState, config);
-  return buildCompactPressureState({
+export async function resetCompactPressureState(rawState = {}, config = {}) {
+  const current = await buildCompactPressureState(rawState, config);
+  return await buildCompactPressureState({
     ...current,
     updatedAt: Date.now(),
     sessionTokens: 0,
@@ -638,7 +641,7 @@ export async function syncCompactPressureStateWithTranscript(
   }
   return {
     state: {
-      ...resetCompactPressureState(rawState ?? {}, config),
+      ...(await resetCompactPressureState(rawState ?? {}, config)),
       lastCompactBoundaryAt: boundaryAt,
       transcriptBoundaryProbe: probe,
     },
@@ -647,7 +650,7 @@ export async function syncCompactPressureStateWithTranscript(
   };
 }
 
-function buildReleaseThresholds(thresholds = buildCompactThresholds()) {
+function buildReleaseThresholds(thresholds) {
   const softReleaseThreshold = Math.max(
     Math.min(thresholds.softThreshold, Math.round(thresholds.softThreshold * SOFT_RELEASE_RATIO)),
     1,
@@ -663,11 +666,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) {
@@ -689,7 +693,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));
@@ -821,9 +825,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) {
@@ -872,7 +876,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),
     lastCompactBoundaryAt: finiteNumber(rawState?.lastCompactBoundaryAt, 0),
@@ -888,14 +892,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;
@@ -916,7 +920,7 @@ export function registerPromptPressure(state, {
       })
     : current.recentPrompts;
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: timestamp,
     routingContext,
@@ -936,7 +940,7 @@ export function registerPromptPressure(state, {
   }, config);
 }
 
-export function registerOutputPressure(state, {
+export async function registerOutputPressure(state, {
   command = '',
   profile = 'generic',
   summary = '',
@@ -946,7 +950,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;
@@ -968,7 +972,7 @@ export function registerOutputPressure(state, {
     keyBuilder: (candidate) => `${candidate.command ?? ''}|${candidate.summary ?? ''}`,
   });
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: timestamp,
     recentOutputs,
@@ -982,8 +986,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;
   }
@@ -999,7 +1003,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
     lines: plan.lines,
   });
   if (current.latestPlan?.fingerprint === fingerprint) {
-    return buildCompactPressureState({
+    return await buildCompactPressureState({
       ...current,
       updatedAt: now,
       latestPlan: {
@@ -1017,7 +1021,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: {
@@ -1052,7 +1056,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
     ? Math.min(current.sessionTokens, decayTarget)
     : current.sessionTokens;
 
-  return buildCompactPressureState({
+  return await buildCompactPressureState({
     ...current,
     updatedAt: now,
     sessionTokens: decayedSessionTokens,
@@ -1073,7 +1077,7 @@ export function registerThresholdCompactPlan(state, plan, config = {}) {
   }, config);
 }
 
-export function buildThresholdCompactPlan({
+export async function buildThresholdCompactPlan({
   state,
   config = {},
   routeState = {},
@@ -1081,8 +1085,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 {
@@ -1205,7 +1209,7 @@ export function buildThresholdCompactPlan({
 
 export async function readCompactPressureState(projectRoot, config = {}) {
   const runtimePaths = buildRuntimePaths(projectRoot);
-  return buildCompactPressureState(await readJson(runtimePaths.compactPressurePath, null), config);
+  return await buildCompactPressureState(await readJson(runtimePaths.compactPressurePath, null), config);
 }
 
 // All compact-pressure mutations share one lock on the state file: without it,
@@ -1225,9 +1229,9 @@ async function mutateCompactPressureState(projectRoot, mutator, config = {}) {
   return withFileLock(runtimePaths.compactPressurePath, async () => {
     const sessions = readPressureDocument(await readJson(runtimePaths.compactPressurePath, null));
     const { id, record } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
-    const current = buildCompactPressureState(record, scopedConfig);
-    const next = mutator(current);
-    const normalized = buildCompactPressureState(next, scopedConfig);
+    const current = await buildCompactPressureState(record, scopedConfig);
+    const next = await mutator(current);
+    const normalized = await buildCompactPressureState(next, scopedConfig);
     sessions[id] = { ...normalized, updatedAt: Date.now() };
     await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
@@ -1240,7 +1244,7 @@ export async function writeCompactPressureState(projectRoot, state, config = {})
   return withFileLock(runtimePaths.compactPressurePath, async () => {
     const sessions = readPressureDocument(await readJson(runtimePaths.compactPressurePath, null));
     const { id } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
-    const normalized = buildCompactPressureState(state, scopedConfig);
+    const normalized = await buildCompactPressureState(state, scopedConfig);
     sessions[id] = { ...normalized, updatedAt: Date.now() };
     await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
@@ -1306,6 +1310,24 @@ function extractPrompt(payload = {}) {
 }
 
 async function runCli() {
+  // BUG-C22-15: this CLI is spawned unbounded by skill-router.sh — every read it
+  // does (config, pressure record, transcript tail, capacity record) sits on the
+  // .ukit/transcript filesystem, so a stalled mount used to hang the child forever
+  // (the shell `|| true` swallows exit codes, not time, and the host SIGKILLs
+  // silently). Arm a self-deadline so ALL invokers get a bounded, announced exit.
+  const CLI_DEADLINE_MS = Number.parseInt(process.env.UKIT_COMPACT_CLI_DEADLINE_MS || '', 10) || 4000;
+  const cliDeadline = setTimeout(() => {
+    try {
+      process.stdout.write(
+        `[ukit-skill-router] compact-threshold prompt CLI exceeded its ${CLI_DEADLINE_MS}ms deadline — `
+          + 'pressure bookkeeping skipped this pass (likely stalled filesystem). The hook continues unharmed; '
+          + 'if this repeats, check the .ukit volume or raise UKIT_COMPACT_CLI_DEADLINE_MS.\n',
+      );
+    } catch { /* stdout already gone */ }
+    process.exit(0);
+  }, CLI_DEADLINE_MS);
+  cliDeadline.unref();
+
   const mode = String(process.argv[2] ?? '').trim();
   if (!mode) {
     return;

package/templates/.claude/ukit/runtime/execution-ledger.mjs

@@ -149,17 +149,25 @@ export async function sweepExecLedgerDir(dir, {
   maxEntries = LEDGER_SWEEP_MAX_ENTRIES,
   maxRemovals = LEDGER_SWEEP_MAX_REMOVALS,
 } = {}) {
-  let names;
+  let dirents;
   try {
-    names = await fs.readdir(dir);
+    dirents = await fs.readdir(dir, { withFileTypes: true });
   } catch {
     return { scanned: 0, removed: 0 };
   }
   const cutoff = now() - maxAgeMs;
   const countCapCutoff = now() - LEDGER_COUNT_CAP_MIN_AGE_MS;
+  // BUG-C22-12: eligible count comes from the dirents (one bounded readdir, no
+  // per-name stat) so the count cap is enforceable even though
+  // maxFiles > maxEntries — capping `scanned` first made `entries.length` an
+  // under-count and `overflow` was always 0.
+  const eligibleNames = [];
+  for (const dirent of dirents) {
+    if (dirent.isFile()) eligibleNames.push(dirent.name);
+  }
   const entries = [];
   let scanned = 0;
-  for (const name of names) {
+  for (const name of eligibleNames) {
     if (scanned >= maxEntries) break;
     scanned += 1;
     try {
@@ -169,9 +177,9 @@ export async function sweepExecLedgerDir(dir, {
   }
   entries.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
   // Overflow counts eligible FILES only — foreign entries (`.lock` dirs, other
-  // state files sharing the dir) inflate `names.length` and would evict real
+  // state files sharing the dir) inflate the dir listing and would evict real
   // ledgers while the dir is actually under the cap.
-  const overflow = Math.max(0, entries.length - maxFiles);
+  const overflow = Math.max(0, eligibleNames.length - maxFiles);
   let removed = 0;
   for (const entry of entries) {
     if (removed >= maxRemovals) break;
@@ -1701,6 +1709,11 @@ function isDirectRun() {
   const selfPath = fileURLToPath(import.meta.url);
   const resolved = path.resolve(argvPath);
   if (selfPath === resolved) return true;
+  // BUG-C22-01: a stalled mount must not park the event loop during `await import`
+  // — importing this module inside an armed hook deadline used to run realpathSync
+  // here for EVERY importer. Skip fs entirely when the basename cannot match (any
+  // importer argv like reinject-context.mjs differs from execution-ledger.mjs).
+  if (path.basename(selfPath) !== path.basename(resolved)) return false;
   try {
     return fsSync.realpathSync(selfPath) === fsSync.realpathSync(resolved);
   } catch {

package/templates/.claude/ukit/runtime/hook-chain-budget.mjs

@@ -17,13 +17,20 @@
 //
 // The clamps are intentionally generous (up to 120s) because they are an
 // explicit operator/test affordance, not a default: an unconfigured chain still
-// resolves to the 10s/4s/16s defaults that keep a PreToolUse call inside omp's
-// own handler budget.
+// resolves to the 10s/12s/52s defaults documented below.
+//
+// BUG-C22-25: the child fallback MUST cover a child's own internal worst case —
+// every staged .sh hook stages stdin (UKIT_HOOK_STAGE_MS default 2000) then arms
+// a node deadline of 3000-8000ms, so a child legitimately needs up to ~10s. The
+// old 4000ms fallback killed legal hooks mid-evaluation (recorded
+// failureKind:'timeout'; on tool_call chains the killed script can be a
+// FAIL_CLOSED gate). 12000 = 2000 stage + 8000 deadline + 2000 margin. The
+// ceiling fallback scales with it: 4 chained children × 12000 + 4000 slack.
 
 export const CHAIN_BUDGET_SPECS = {
   base: { name: 'UKIT_HOOK_CHAIN_BASE_MS', fallback: 10000, min: 500, max: 60000 },
-  child: { name: 'UKIT_HOOK_CHILD_BUDGET_MS', fallback: 4000, min: 100, max: 60000 },
-  ceiling: { name: 'UKIT_HOOK_CHAIN_CEILING_MS', fallback: 16000, min: 500, max: 120000 },
+  child: { name: 'UKIT_HOOK_CHILD_BUDGET_MS', fallback: 12000, min: 100, max: 60000 },
+  ceiling: { name: 'UKIT_HOOK_CHAIN_CEILING_MS', fallback: 52000, min: 500, max: 120000 },
 };
 
 // Margin the outer timeout adds on top of the runner's own budget: enough to

package/templates/.claude/ukit/runtime/hook-telemetry.mjs

@@ -153,12 +153,16 @@ export function sweepTelemetryDir(dir, {
     return { scanned: 0, removed: 0 };
   }
   const cutoff = now() - maxAgeMs;
+  // BUG-C22-11: eligible count is computed from the full name listing (bounded
+  // by the single readdir, no per-name stat) so the count cap is enforceable
+  // even though maxFiles > maxEntries — capping `scanned` first made
+  // `entries.length` an under-count and `overflow` was always 0.
+  const eligibleNames = names.filter((name) => name.endsWith('.jsonl'));
   const entries = [];
   let scanned = 0;
-  for (const name of names) {
+  for (const name of eligibleNames) {
     if (scanned >= maxEntries) break;
     scanned += 1;
-    if (!name.endsWith('.jsonl')) continue;
     try {
       const stats = fs.statSync(path.join(dir, name));
       if (stats.isFile()) entries.push({ name, mtimeMs: stats.mtimeMs });
@@ -168,7 +172,7 @@ export function sweepTelemetryDir(dir, {
   // Overflow counts eligible FILES only — foreign entries (non-matching names,
   // dirs) inflate `names.length` and would evict real entries while the dir is
   // actually under the cap.
-  const overflow = Math.max(0, entries.length - maxFiles);
+  const overflow = Math.max(0, eligibleNames.length - maxFiles);
   let removed = 0;
   for (const entry of entries) {
     if (removed >= maxRemovals) break;

package/templates/.claude/ukit/runtime/output-compression.mjs

@@ -410,16 +410,27 @@ export async function sweepTeeCache(dir, {
   maxEntries = TEE_SWEEP_MAX_ENTRIES,
   maxRemovals = TEE_SWEEP_MAX_REMOVALS,
 } = {}) {
-  let names;
+  let dirents;
   try {
-    names = await fs.readdir(dir);
+    dirents = await fs.readdir(dir, { withFileTypes: true });
   } catch {
     return { sampled: true, scanned: 0, removed: 0 };
   }
+  // Eligible-file count comes from the dirents (one bounded readdir, no per-name
+  // stat) so the count cap is enforceable even when maxFiles > maxEntries —
+  // BUG-C22-10: capping `scanned` at maxEntries made `entries.length` an
+  // under-count and `overflow` was always 0. Expected drain: each sampled sweep
+  // removes up to maxRemovals, so a backlog of B files converges after
+  // ~ceil(B/maxRemovals) sweeps (~16x that many writes at the default 1/16
+  // sampling); the 7d age cutoff drains the rest even without new writes.
+  const eligibleNames = [];
+  for (const dirent of dirents) {
+    if (dirent.isFile()) eligibleNames.push(dirent.name);
+  }
   const cutoff = now() - maxAgeMs;
   const entries = [];
   let scanned = 0;
-  for (const name of names) {
+  for (const name of eligibleNames) {
     if (scanned >= maxEntries) break;
     scanned += 1;
     try {
@@ -429,9 +440,9 @@ export async function sweepTeeCache(dir, {
   }
   entries.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
   // Overflow counts eligible FILES only — foreign entries (non-matching names,
-  // dirs) inflate `names.length` and would evict real entries while the dir is
+  // dirs) inflate the dir listing and would evict real entries while the dir is
   // actually under the cap.
-  const overflow = Math.max(0, entries.length - maxFiles);
+  const overflow = Math.max(0, eligibleNames.length - maxFiles);
   let removed = 0;
   for (const entry of entries) {
     if (removed >= maxRemovals) break;

package/templates/.claude/ukit/runtime/reinject-context.mjs

@@ -108,7 +108,7 @@ async function main() {
   // (writeThresholdCompactPlan) re-read from disk, so they build on the zeroed state and
   // keep their own stats increments intact. Session-scoped: sibling sessions keep their
   // own records.
-  await writeCompactPressureState(projectRoot, resetCompactPressureState(pressureState, sessionConfig), sessionConfig);
+  await writeCompactPressureState(projectRoot, await resetCompactPressureState(pressureState, sessionConfig), sessionConfig);
   const anchorLines = dynamicLines.filter((line) => (
     line.startsWith('- Recent routed lane:')
     || line.startsWith('- Current approach:')
@@ -124,7 +124,7 @@ async function main() {
     || line.startsWith('- Recent delegation hint:')
   ));
   const maxTokens = Math.max(160, Math.min(320, Number(config.memory?.maxInjectionTokens) || 320));
-  const thresholdPlan = buildThresholdCompactPlan({
+  const thresholdPlan = await buildThresholdCompactPlan({
     state: pressureState,
     config,
     routeState: state,

package/templates/.claude/ukit/runtime/stop-coordinator.mjs

@@ -683,6 +683,9 @@ function isDirectRun() {
     selfUrlPath = null;
   }
   if (selfUrlPath && selfUrlPath === selfPath) return true;
+  // BUG-C22-01: skip fs entirely for non-matching importers — a stalled mount
+  // must not park the event loop during `await import` inside an armed deadline.
+  if (selfUrlPath && path.basename(selfUrlPath) !== path.basename(selfPath)) return false;
   try {
     return fsSync.realpathSync(selfUrlPath) === fsSync.realpathSync(selfPath);
   } catch {

package/templates/.claude/ukit/runtime/token-utils.mjs

@@ -175,8 +175,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-16: 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