@ngockhoale/ukit 2.6.4 → 2.6.5

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 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

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.4",
+  "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/src/core/memory/store.js

@@ -207,15 +207,22 @@ async function readProjectMemoryForId(runtimePaths, projectId) {
   return { filePath, memory };
 }
 
-async function appendSessionArchive(runtimePaths, projectId, archivedSessions) {
+const DEFAULT_MAX_ARCHIVED_SESSIONS = 50;
+
+async function appendSessionArchive(runtimePaths, projectId, archivedSessions, maxArchivedSessions) {
   if (!archivedSessions || archivedSessions.length === 0) {
     return;
   }
 
+  // Math.max(1, …): a fractional cap in (0,1) would floor to 0 and `slice(-0)`
+  // silently disables the bound — exactly the unbounded-growth class this caps.
+  const cap = Number.isFinite(maxArchivedSessions) && maxArchivedSessions > 0
+    ? Math.max(1, Math.floor(maxArchivedSessions))
+    : DEFAULT_MAX_ARCHIVED_SESSIONS;
   const archivePath = path.join(runtimePaths.projectsDir, `${sanitizeProjectId(projectId)}.archive.json`);
   const existing = (await readMemoryJson(archivePath)) ?? { sessions: [] };
   const sessions = Array.isArray(existing.sessions) ? existing.sessions : [];
-  await writeJson(archivePath, { sessions: [...sessions, ...archivedSessions] });
+  await writeJson(archivePath, { sessions: [...sessions, ...archivedSessions].slice(-cap) });
 }
 
 async function persistProjectMemoryWithHygiene(projectRoot, runtimePaths, projectId, filePath, memory) {
@@ -228,7 +235,7 @@ async function persistProjectMemoryWithHygiene(projectRoot, runtimePaths, projec
   };
 
   const { projectMemory: hygienicMemory, archivedSessions } = runHygiene(memory, hygieneConfig);
-  await appendSessionArchive(runtimePaths, projectId, archivedSessions);
+  await appendSessionArchive(runtimePaths, projectId, archivedSessions, memoryConfig.maxArchivedSessions);
   await writeJson(filePath, hygienicMemory);
   return hygienicMemory;
 }

package/src/core/runtimeConfig.js

@@ -164,6 +164,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       maxInjectionTokens: 1000,
       archiveAfterDays: 30,
       maxSessions: 20,
+      maxArchivedSessions: 50,
       redactSecrets: true,
     },
     validation: {
@@ -362,6 +363,7 @@ export function validateRuntimeConfig(config) {
     pushPositiveNumberError(errors, config.memory.maxInjectionTokens, 'memory.maxInjectionTokens');
     pushPositiveNumberError(errors, config.memory.archiveAfterDays, 'memory.archiveAfterDays');
     pushPositiveNumberError(errors, config.memory.maxSessions, 'memory.maxSessions');
+    pushPositiveNumberError(errors, config.memory.maxArchivedSessions, 'memory.maxArchivedSessions');
     pushBooleanError(errors, config.memory.redactSecrets, 'memory.redactSecrets');
   }
 

package/templates/.claude/hooks/auto-prune-bash.sh

@@ -70,6 +70,35 @@ async function appendAudit(event, payload) {
   await fsp.appendFile(auditPath, JSON.stringify({ ts: nowUtc, event, ...payload }) + "\n");
 }
 
+// BUG-C23-12: permission-audit.log was append-only (auto-allow-bash + this hook both
+// append; only an explicit reset ever truncated it). Bound: this prune pass rewrites
+// the log keeping only lines with ts >= cutoff (same TTL window as rule pruning, so
+// the audit trail for every retained rule survives). Unparseable/missing-ts lines are
+// dropped; a missing or unreadable log is a no-op.
+async function pruneAuditLog() {
+  let raw;
+  try {
+    raw = await fsp.readFile(auditPath, "utf8");
+  } catch {
+    return;
+  }
+  const kept = raw
+    .split("\n")
+    .filter((line) => {
+      if (!line.trim()) return false;
+      let ts = NaN;
+      try {
+        ts = Date.parse(JSON.parse(line)?.ts || "");
+      } catch {
+        ts = NaN;
+      }
+      return Number.isFinite(ts) && ts >= cutoff;
+    });
+  const tempPath = `${auditPath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await fsp.writeFile(tempPath, kept.length ? kept.join("\n") + "\n" : "");
+  await fsp.rename(tempPath, auditPath);
+}
+
 // Same lock point as auto-allow-bash.sh (<usage>.lock): the two hooks serialize their
 // settings/usage rewrites against each other and against parallel invocations. Atomic
 // writes because Claude Code re-reads settings.local.json — a torn write would drop the
@@ -148,6 +177,10 @@ async function withLock(lockPath, fn) {
 }
 
 withLock(`${usagePath}.lock`, async () => {
+  // Rotate the audit log inside the same lock as the rule prune: both are
+  // read-modify-write passes on files these two hooks share.
+  await pruneAuditLog();
+
   const settings = await readJson(settingsPath);
   const usage = await readJson(usagePath);
   if (!settings || !usage) return;

package/templates/.claude/hooks/completion-gate.sh

@@ -78,8 +78,27 @@ if [ ! -f "$SCRIPT" ]; then
   exit 0
 fi
 
-OUTPUT=$(printf '%s' "$INPUT" | UKIT_HARNESS=claude-code UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-3000}" node "$SCRIPT" --evaluate-stop)
+# BUG-C23-06: bound the coordinator spawn. The coordinator's own unref'd deadline
+# cannot fire while its event loop is parked in sync fs on a stalled mount, so the
+# shell used to wait until the host's 8s SIGKILL — a silent release window for a
+# fail-closed gate. Run the spawn in the background with a background killer at
+# (coordinator deadline + margin); a forced kill lands on the existing crash-streak
+# path (non-zero STATUS) so the outcome is announced, never silently released.
+__ukit_coord_out="$(mktemp "${TMPDIR:-/tmp}/ukit-coord-out.XXXXXX")"
+printf '%s' "$INPUT" | UKIT_HARNESS=claude-code UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-3000}" node "$SCRIPT" --evaluate-stop > "$__ukit_coord_out" 2>/dev/null &
+__ukit_coord_pid=$!
+__ukit_coord_ms="${UKIT_HOOK_DEADLINE_MS:-3000}"
+case "$__ukit_coord_ms" in ''|*[!0-9]*) __ukit_coord_ms=3000 ;; esac
+__ukit_coord_ms=$((__ukit_coord_ms + 1500))
+printf -v __ukit_coord_s '%d.%03d' $((__ukit_coord_ms / 1000)) $((__ukit_coord_ms % 1000))
+( sleep "$__ukit_coord_s" 2>/dev/null; kill -9 "$__ukit_coord_pid" 2>/dev/null ) <&- >/dev/null 2>&1 &
+__ukit_killer_pid=$!
+wait "$__ukit_coord_pid" 2>/dev/null
 STATUS=$?
+kill "$__ukit_killer_pid" 2>/dev/null
+wait "$__ukit_killer_pid" 2>/dev/null
+OUTPUT="$(cat "$__ukit_coord_out" 2>/dev/null)"
+rm -f "$__ukit_coord_out"
 
 if [ "$STATUS" -ne 0 ]; then
   # BUG-C22-05: a PERSISTENT coordinator crash must not block every Stop forever.

package/templates/.claude/hooks/context-hardcap-gate.sh

@@ -402,7 +402,14 @@ async function readRunCursor() {
 })().catch((err) => {
   // A logic error here fails OPEN: this is a backstop on top of advisory nudges,
   // not a correctness gate — a broken gate must not brick every session.
+  // BUG-C23-05: fail-open still needs a user-visible signal — stderr alone leaves a
+  // persistent internal error looking exactly like a clean pass (SPEC §8(ii)).
   process.stderr.write(`context-hardcap-gate: internal error, failing open: ${err?.message ?? err}\n`);
+  try {
+    process.stdout.write(`${JSON.stringify({
+      systemMessage: `UKit context hard-cap gate: internal error (${String(err?.message ?? err).slice(0, 200)}) — the gate failed open and did NOT enforce the hard cap this call; run: ukit install to repair.`,
+    })}\n`);
+  } catch {}
   process.exit(0);
 });
 NODE

package/templates/.claude/hooks/handoff-resume.sh

@@ -87,7 +87,20 @@ const { pathToFileURL } = require('url');
 // Every read below is async on purpose: sync I/O would block the loop and this timer
 // could never fire. Keep it that way.
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10) || 3000;
-setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+setTimeout(() => {
+  // BUG-C23-04: deadline expiry abandons the configured resume hint — a
+  // degrade, and SPEC §8(ii) requires it be announced on stdout before the
+  // fail-open exit. fs.writeSync(1) because a same-tick exit can drop a
+  // buffered async write on a pipe.
+  try {
+    fs.writeSync(1, JSON.stringify({
+      systemMessage: 'UKit handoff-resume exceeded its ' + HOOK_DEADLINE_MS + 'ms deadline — '
+        + 'the resume check was skipped this session start (likely stalled filesystem). '
+        + 'If a handoff run was in flight, resume it via /ukit:handoff-fullstack.',
+    }) + '\n');
+  } catch {}
+  process.exit(0);
+}, HOOK_DEADLINE_MS).unref();
 
 const projectRoot = process.env.PROJECT_ROOT;
 const runPath = path.join(projectRoot, 'docs', 'AI_HANDOFF', 'RUN.md');

package/templates/.claude/hooks/skill-router.sh

@@ -2456,12 +2456,17 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       : null;
   }
 
-  async function withStateLock(lockPath, fn) {
+  async function withStateLock(lockPath, fn, { onUnlocked } = {}) {
     // Advisory bookkeeping: liveness over strictness — if the lock cannot be acquired
-    // within maxWaitMs the merge runs unlocked (pre-lock behaviour) rather than hanging
-    // or dropping the entry.
+    // within maxWaitMs the merge cannot run safely, so callers that must never lose
+    // data pass `onUnlocked` (an atomic append-only fallback) instead of running an
+    // unlocked read-modify-write (BUG-C23-15: the old unlocked merge was the exact
+    // lost-update race the lock exists to prevent — under I/O contention it silently
+    // dropped entries).
     const staleMs = 10000;
-    const maxWaitMs = 5000;
+    // Cap the wait below the hook self-deadline: a wait that outlives the deadline
+    // dies by process.exit before the sidecar fallback can ever stage the entry.
+    const maxWaitMs = Math.min(5000, Math.max(500, HOOK_DEADLINE_MS - 500));
     const startedAt = Date.now();
     const ownerToken = `${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
     let held = false;
@@ -2499,6 +2504,7 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         await new Promise((resolve) => setTimeout(resolve, 3 + Math.floor(Math.random() * 9)));
       }
     }
+    if (!held && onUnlocked) return onUnlocked('lock-wait-expired');
     try {
       return await fn();
     } finally {
@@ -2518,7 +2524,159 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       return;
     }
 
-    await withStateLock(`${filePath}.lock`, async () => {
+    // BUG-C23-15: the entry is STAGED to an append-only sidecar before the lock is
+    // attempted (small appendFile is atomic — no read-modify-write, so no lost
+    // updates even under full contention). Every lock holder folds all staged
+    // entries into route-audit.json inside its merge; the hook's self-deadline can
+    // kill a process mid-lock-wait, so a synchronous last-chance fold is also armed
+    // on process exit — whichever process exits last folds every staged entry. The
+    // audit entry can never be silently dropped; the unlocked path announces
+    // itself instead of silently losing data.
+    const sidecarPath = `${filePath}.unlocked.jsonl`;
+    const lockPath = `${filePath}.lock`;
+
+    function entryDedupeKey(item) {
+      return stableMachineDigest({
+        requestKey: item?.requestKey || null,
+        executionMode: item?.executionMode || null,
+        nextActionType: item?.nextActionType || null,
+        nextMilestone: item?.nextMilestone || null,
+        repeatCount: item?.repeatCount || null,
+        rescueMode: item?.rescueMode || null,
+      });
+    }
+
+    function parseSidecarLines(raw) {
+      const recovered = [];
+      for (const line of String(raw || '').split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const item = JSON.parse(line);
+          if (item && typeof item === 'object') recovered.push(item);
+        } catch {}
+      }
+      return recovered;
+    }
+
+    function mergeEntries(staged, parsed, newEntry) {
+      const dedupeKey = newEntry ? entryDedupeKey(newEntry) : null;
+      const merged = [];
+      const seen = new Set();
+      for (const item of [newEntry, ...staged, ...(Array.isArray(parsed?.entries) ? parsed.entries : [])]) {
+        if (!item || typeof item !== 'object') continue;
+        const key = entryDedupeKey(item);
+        if (dedupeKey && key === dedupeKey && item !== newEntry) continue;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        merged.push(item);
+      }
+      return merged.slice(0, 40);
+    }
+
+    // Synchronous last-chance fold for the self-deadline kill path: process.on('exit')
+    // handlers run before exit without the event loop, so sync fs is legal here.
+    // Bounded spin-retry on the mkdir lock so the LAST exiting process still folds
+    // staged entries after the previous holder releases. The sidecar is claimed by
+    // rename (atomic): appends in flight land on the claimed inode and are read,
+    // appends after the claim create a fresh sidecar for the next fold.
+    // `fsSync` aliases the SAME fs module — used ONLY by process.on('exit')
+    // handlers below (event loop is gone; async cannot run). The C21-04 guard
+    // intentionally does not match this handle so normal-path sync fs stays
+    // forbidden while the exit-fold path is legal by construction.
+    const fsSync = fs;
+    function claimSidecarSync() {
+      const claimedPath = `${sidecarPath}.claim-${process.pid}-${Date.now()}`;
+      try {
+        fsSync.renameSync(sidecarPath, claimedPath);
+      } catch {
+        return null;
+      }
+      return claimedPath;
+    }
+
+    function foldSidecarSync() {
+      const deadline = Date.now() + 300;
+      let held = false;
+      while (!held && Date.now() < deadline) {
+        try {
+          fsSync.mkdirSync(lockPath);
+          held = true;
+        } catch (error) {
+          if (!error || error.code !== 'EEXIST') return;
+          try {
+            const stat = fsSync.statSync(lockPath);
+            if (Date.now() - stat.mtimeMs > 10000) {
+              try {
+                const owner = JSON.parse(fsSync.readFileSync(path.join(lockPath, 'owner'), 'utf8'));
+                if (!owner || !Number.isInteger(owner.pid) || !isPidAlive(owner.pid)) {
+                  fsSync.rmSync(lockPath, { recursive: true, force: true });
+                  continue;
+                }
+              } catch {
+                fsSync.rmSync(lockPath, { recursive: true, force: true });
+                continue;
+              }
+            }
+          } catch {}
+          const until = Date.now() + 5;
+          while (Date.now() < until) { /* spin */ }
+        }
+      }
+      if (!held) return;
+      try {
+        const claimedPath = claimSidecarSync();
+        if (!claimedPath) return;
+        let staged = [];
+        try {
+          staged = parseSidecarLines(fsSync.readFileSync(claimedPath, 'utf8'));
+        } catch {}
+        try {
+          fsSync.rmSync(claimedPath, { force: true });
+        } catch {}
+        if (!staged.length) return;
+        let parsed = { entries: [] };
+        try {
+          parsed = JSON.parse(fsSync.readFileSync(filePath, 'utf8'));
+        } catch {}
+        const tmpPath = `${filePath}.exitfold-${process.pid}`;
+        fsSync.writeFileSync(tmpPath, JSON.stringify({
+          entries: mergeEntries(staged, parsed, null),
+        }));
+        fsSync.renameSync(tmpPath, filePath);
+      } finally {
+        try {
+          fsSync.rmSync(lockPath, { recursive: true, force: true });
+        } catch {}
+      }
+    }
+
+    try {
+      await fsp.appendFile(sidecarPath, `${JSON.stringify(entry)}\n`);
+    } catch {}
+    if (!appendRouteAuditEntry._exitFoldArmed) {
+      appendRouteAuditEntry._exitFoldArmed = true;
+      process.on('exit', foldSidecarSync);
+    }
+
+    await withStateLock(lockPath, async () => {
+      // Claim staged lines atomically inside the lock: rename detaches the inode,
+      // so lines appended during the fold land in a fresh sidecar for the next pass
+      // instead of being deleted unread.
+      const claimedPath = `${sidecarPath}.claim-${process.pid}-${Date.now()}`;
+      let claimed = false;
+      try {
+        await fsp.rename(sidecarPath, claimedPath);
+        claimed = true;
+      } catch {}
+      const sidecarEntries = claimed
+        ? parseSidecarLines(await fsp.readFile(claimedPath, 'utf8').catch(() => ''))
+        : [];
+      if (claimed) {
+        try {
+          await fsp.rm(claimedPath, { force: true });
+        } catch {}
+      }
+
       let parsed = { entries: [] };
       if (await pathExists(filePath)) {
         try {
@@ -2528,30 +2686,18 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         }
       }
 
-      const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
-      const dedupeKey = stableMachineDigest({
-        requestKey: entry.requestKey,
-        executionMode: entry.executionMode,
-        nextActionType: entry.nextActionType,
-        nextMilestone: entry.nextMilestone,
-        repeatCount: entry.repeatCount,
-        rescueMode: entry.rescueMode,
-      });
-      const filtered = entries.filter((item) => {
-        const itemKey = stableMachineDigest({
-          requestKey: item?.requestKey || null,
-          executionMode: item?.executionMode || null,
-          nextActionType: item?.nextActionType || null,
-          nextMilestone: item?.nextMilestone || null,
-          repeatCount: item?.repeatCount || null,
-          rescueMode: item?.rescueMode || null,
-        });
-        return itemKey !== dedupeKey;
-      });
-
       await writeJsonFileAtomic(filePath, JSON.stringify({
-        entries: [entry, ...filtered].slice(0, 40),
+        entries: mergeEntries(sidecarEntries, parsed, entry),
       }));
+    }, {
+      onUnlocked: async (reason) => {
+        // Already staged above — the next locked merge or the exit fold picks it up.
+        try {
+          process.stdout.write(`${JSON.stringify({
+            systemMessage: `UKit skill-router: route-audit lock ${reason} — this audit entry was staged to the append-only sidecar and will be folded into route-audit.json.`,
+          })}\n`);
+        } catch {}
+      },
     });
   }
 
@@ -3090,6 +3236,13 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
 })().catch((error) => {
   const detail = error?.message || String(error);
   process.stderr.write(`[ukit-skill-router] ${detail}\n`);
+  // BUG-C23-07: a crashed router abandons configured routing work — announce the
+  // degrade (SPEC §8(ii)); fail-open posture kept (exit 0).
+  try {
+    process.stdout.write(`${JSON.stringify({
+      systemMessage: `UKit skill-router crashed (${detail.slice(0, 200)}) — routing advice skipped this turn; the session continues unrouted.`,
+    })}\n`);
+  } catch {}
   process.exit(0);
 });
 NODE

package/templates/.claude/hooks/task-watchdog.sh

@@ -151,18 +151,37 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       stdio: ['pipe', 'pipe', 'inherit'],
     });
     let delegatedOutput = '';
+    // BUG-C23-07: spawn-error / killed-empty-output paths abandoned the delegated
+    // stop evaluation silently — announce a degrade (SPEC §8(ii)) when the child
+    // fails or is force-killed with nothing to say. Fail-open posture kept.
+    let killedByDeadline = false;
+    const emitDelegateDegrade = (reason) => {
+      try {
+        process.stdout.write(`${JSON.stringify({
+          systemMessage: `UKit task-watchdog: delegated stop evaluation ${reason} — this stop passed without coordinator review.`,
+        })}\n`);
+      } catch {}
+    };
+    // Fire marginally BEFORE the process self-deadline so the close handler still
+    // has a tick to emit the degrade after the kill lands.
     const killTimer = setTimeout(() => {
+      killedByDeadline = true;
       try { child.kill('SIGKILL'); } catch {}
-    }, HOOK_DEADLINE_MS);
+    }, Math.max(100, HOOK_DEADLINE_MS - 250));
     if (typeof killTimer.unref === 'function') killTimer.unref();
     child.stdout.on('data', (chunk) => { delegatedOutput += chunk; });
     child.stdin.on('error', () => {}); // a stub coordinator that never reads stdin must not crash us
-    child.on('error', () => {
+    child.on('error', (spawnErr) => {
+      emitDelegateDegrade(`failed to spawn (${String(spawnErr?.message ?? spawnErr).slice(0, 150)})`);
       try { process.exit(0); } catch {}
     });
     child.on('close', () => {
       try {
-        if (delegatedOutput.trim()) process.stdout.write(delegatedOutput);
+        if (delegatedOutput.trim()) {
+          process.stdout.write(delegatedOutput);
+        } else if (killedByDeadline) {
+          emitDelegateDegrade(`exceeded its ${HOOK_DEADLINE_MS}ms deadline and was killed`);
+        }
       } catch {}
       process.exit(0);
     });
@@ -228,8 +247,14 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     } catch {}
   }
   process.exit(0);
-})().catch(() => {
-  // Fail-open: never let an exception kill the hook.
+})().catch((err) => {
+  // Fail-open: never let an exception kill the hook — but BUG-C23-07: a crashed
+  // watchdog abandons configured budget evaluation, so announce it (SPEC §8(ii)).
+  try {
+    process.stdout.write(`${JSON.stringify({
+      systemMessage: `UKit task-watchdog crashed (${String(err?.message ?? err).slice(0, 200)}) — task budget evaluation skipped this pass.`,
+    })}\n`);
+  } catch {}
   try {
     process.exit(0);
   } catch {}

package/templates/.claude/hooks/vision-router.sh

@@ -305,6 +305,13 @@ async function readTextSafe(filePath) {
       // anything) plus the failure reason. Never the whole payload.
       const head = typeof out === 'string' && out ? `; output head: ${out.slice(0, 200)}` : '';
       process.stderr.write(`vision-router: extractor call skipped (${err?.message ?? err})${head}\n`);
+      // BUG-C23-07: a failed extractor call abandons the configured vision hint —
+      // announce the degrade (SPEC §8(ii)); fail-open posture kept.
+      try {
+        process.stdout.write(`${JSON.stringify({
+          systemMessage: `UKit vision-router: image extractor call failed (${String(err?.message ?? err).slice(0, 150)}) — vision routing hint skipped this turn.`,
+        })}\n`);
+      } catch {}
     }
   } catch {
     // Missing extractor is a normal fail-open condition.
@@ -457,6 +464,13 @@ async function readTextSafe(filePath) {
   process.exit(0);
 })().catch((err) => {
   process.stderr.write(`vision-router: unexpected error (${err?.message ?? err})\n`);
+  // BUG-C23-07: a crashed vision router abandons configured advisory work —
+  // announce the degrade (SPEC §8(ii)); fail-open posture kept.
+  try {
+    process.stdout.write(`${JSON.stringify({
+      systemMessage: `UKit vision-router crashed (${String(err?.message ?? err).slice(0, 200)}) — vision routing hint skipped this turn.`,
+    })}\n`);
+  } catch {}
   process.exit(0);
 });
 NODE

package/templates/.claude/ukit/index/post-edit-verify.mjs

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { analyzeTextBuffer, analyzeTextFile, publicTextProfile } from '../runtime/text-profile.mjs';
@@ -7,9 +8,27 @@ import { classifySafePatchRisk, isSafePatchAdvisoryOnly, parseJsonInput, pathExi
 // Hook-context self-deadline (2.4.1 orphan-leak class): the post-edit-verify hook passes
 // UKIT_HOOK_DEADLINE_MS so a wedged read can never orphan this process past the hook
 // budget. Non-hook usage never sets it and is never self-killed.
+// SPEC §8: stdout is the only surface the hook consumer reliably shows the
+// user (stderr reaches the model). writeSync(1) because a same-tick
+// process.exit() can discard a buffered async write on a pipe.
+function emitSystemMessage(text) {
+  try {
+    fsSync.writeSync(1, `${JSON.stringify({ systemMessage: text })}\n`);
+  } catch { /* stdout already gone */ }
+}
+
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10);
 if (Number.isFinite(HOOK_DEADLINE_MS) && HOOK_DEADLINE_MS > 0) {
-  setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+  setTimeout(() => {
+    // BUG-C23-04: deadline expiry abandons the configured post-edit verify — a
+    // degrade, and §8(ii) requires it be announced before the exit.
+    emitSystemMessage(
+      `UKit post-edit-verify exceeded its ${HOOK_DEADLINE_MS}ms hook deadline — `
+      + 'Safe Patch delta verification skipped this pass (likely stalled filesystem). '
+      + 'If this repeats, check the .ukit volume or raise UKIT_HOOK_DEADLINE_MS.',
+    );
+    process.exit(0);
+  }, HOOK_DEADLINE_MS).unref();
 }
 
 async function readStdin() {
@@ -220,6 +239,13 @@ async function main() {
       process.stderr.write('[ukit-safe-patch] advisoryOnly=true — change is already written; continue planned follow-up without stopping.\n');
       return;
     }
+    // BUG-C23-03: exit-2 blocks must pair the stderr reason with a stdout §8
+    // emission — stderr reaches the model, not reliably the user
+    // (precedent: context-hardcap-gate.sh, handoff-model-guard.sh).
+    // --json mode: the verdict JSON already written above IS the structured
+    // announcement (status+message fields); a second raw line would corrupt
+    // the machine-parseable stdout contract.
+    if (!json) emitSystemMessage(`[ukit-safe-patch] ${message}`);
     process.exit(2);
   }
 }
@@ -227,6 +253,12 @@ async function main() {
 if (process.argv[1] && path.basename(fileURLToPath(import.meta.url)) === path.basename(process.argv[1])) {
   main().catch((error) => {
     process.stderr.write(`[ukit-safe-patch] post-edit ERROR: ${error?.message || error}\n`);
+    // BUG-C23-01: stderr-only crash announces nothing to the user — §8 requires
+    // the paired stdout systemMessage before the non-zero exit.
+    emitSystemMessage(
+      `UKit post-edit-verify crashed before it could verify the edit (${error?.message || error}); `
+      + 'the Safe Patch check was skipped this pass. Run `ukit doctor` if this repeats.',
+    );
     process.exit(1);
   });
 }

package/templates/.claude/ukit/index/stale-spec-check.mjs

@@ -1,5 +1,6 @@
 import { analyzeTextFile, publicTextProfile } from '../runtime/text-profile.mjs';
 import { fileURLToPath } from 'node:url';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import {
   classifySafePatchRisk,
@@ -16,9 +17,27 @@ import {
 // Hook-context self-deadline (2.4.1 orphan-leak class): the stale-spec-guard hook passes
 // UKIT_HOOK_DEADLINE_MS so a wedged read can never orphan this process past the hook
 // budget. Non-hook usage never sets it and is never self-killed.
+// SPEC §8: stdout is the only surface the hook consumer reliably shows the
+// user (stderr reaches the model). writeSync(1) because a same-tick
+// process.exit() can discard a buffered async write on a pipe.
+function emitSystemMessage(text) {
+  try {
+    fsSync.writeSync(1, `${JSON.stringify({ systemMessage: text })}\n`);
+  } catch { /* stdout already gone */ }
+}
+
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10);
 if (Number.isFinite(HOOK_DEADLINE_MS) && HOOK_DEADLINE_MS > 0) {
-  setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+  setTimeout(() => {
+    // BUG-C23-04: deadline expiry abandons the configured stale-spec check — a
+    // degrade, and §8(ii) requires it be announced before the exit.
+    emitSystemMessage(
+      `UKit stale-spec-check exceeded its ${HOOK_DEADLINE_MS}ms hook deadline — `
+      + 'Safe Patch spec verification skipped this pass (likely stalled filesystem). '
+      + 'If this repeats, check the .ukit volume or raise UKIT_HOOK_DEADLINE_MS.',
+    );
+    process.exit(0);
+  }, HOOK_DEADLINE_MS).unref();
 }
 
 function getToolName(payload = {}) {
@@ -198,6 +217,13 @@ async function main() {
       process.stderr.write('[ukit-safe-patch] advisoryOnly=true — continue with corrected old_string; do not stop and ask the user.\n');
       return;
     }
+    // BUG-C23-03: exit-2 blocks must pair the stderr reason with a stdout §8
+    // emission — stderr reaches the model, not reliably the user
+    // (precedent: context-hardcap-gate.sh, handoff-model-guard.sh).
+    // --json mode: the verdict JSON above IS the structured announcement —
+    // a second raw line would corrupt the parseable stdout contract
+    // (sibling parity: post-edit-verify.mjs).
+    if (!args.json) emitSystemMessage(`[ukit-safe-patch] ${message}`);
     process.exit(2);
   }
 }
@@ -205,6 +231,11 @@ async function main() {
 if (process.argv[1] && path.basename(fileURLToPath(import.meta.url)) === path.basename(process.argv[1])) {
   main().catch((error) => {
     process.stderr.write(`[ukit-safe-patch] ERROR: ${error?.message || error}\n`);
+    // Same stderr-only crash class as BUG-C23-01 — pair the §8 stdout emission.
+    emitSystemMessage(
+      `UKit stale-spec-check crashed before it could verify the edit (${error?.message || error}); `
+      + 'the Safe Patch spec check was skipped this pass. Run `ukit doctor` if this repeats.',
+    );
     process.exit(1);
   });
 }

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

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import {
@@ -474,12 +475,15 @@ export async 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 async function resolveCompactCapacity(config = {}) {
-  const record = await readContextCapacityRecord(config?.projectRoot);
+export async function resolveCompactCapacity(config = {}, { record } = {}) {
+  // BUG-C23-09: callers that already read the capacity record (buildCompactThresholds)
+  // pass it in — a second serial fs.readFile on .ukit doubles the stalled-mount
+  // window on the hardcap hot path.
+  const resolvedRecord = record !== undefined ? record : await readContextCapacityRecord(config?.projectRoot);
   return resolveContextCapTokens({
     env: process.env,
     config,
-    modelMetadata: { model: record?.model },
+    modelMetadata: { model: resolvedRecord?.model },
   });
 }
 
@@ -489,7 +493,7 @@ export async function buildCompactThresholds(config = {}) {
   // 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 = await readContextCapacityRecord(config?.projectRoot);
-  const negotiated = record ? await resolveCompactCapacity(config) : null;
+  const negotiated = record ? await resolveCompactCapacity(config, { record }) : null;
   const hardCapTokens = negotiated
     ? Math.max(1, Math.min(shippedHardCap, negotiated.capTokens))
     : shippedHardCap;
@@ -1317,12 +1321,16 @@ async function runCli() {
   // 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(() => {
+    // BUG-C23-02: fsSync.writeSync(1, …), never process.stdout.write — on a pipe
+    // (this CLI is always piped) a same-tick process.exit() can discard the
+    // buffered async write, and the bare text line wasn't §8 JSON anyway.
     try {
-      process.stdout.write(
-        `[ukit-skill-router] compact-threshold prompt CLI exceeded its ${CLI_DEADLINE_MS}ms deadline — `
+      fsSync.writeSync(1, `${JSON.stringify({
+        systemMessage:
+          `[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',
-      );
+          + '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);

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

@@ -204,6 +204,23 @@ export async function sweepExecLedgerDir(dir, {
 
 // Sampled gate — by default only ~1 in 16 ledger mutations pays for a bounded
 // sweep at all. Advisory: a sweep failure must never lose a ledger event.
+// BUG-C23-10: a bare `catch {}` around the sweep swallowed every failure — a
+// persistent EACCES/ENOSPC meant silent non-convergence of the exec-ledger dir
+// bound. Announce the first failure and then every 25th, C22 rate-limit
+// posture. writeSync(1) because a same-tick exit can drop a buffered write.
+let sweepFailureCount = 0;
+export function noteSweepFailure(error) {
+  sweepFailureCount += 1;
+  if (sweepFailureCount !== 1 && sweepFailureCount % 25 !== 0) return null;
+  const message =
+    `UKit execution-ledger: dir sweep failed (${sweepFailureCount} failure(s) so far) — `
+    + `the committed event is safe but the backlog bound may lag. Cause: ${error?.message || error}`;
+  try {
+    fsSync.writeSync(1, `${JSON.stringify({ systemMessage: message })}\n`);
+  } catch { /* stdout already gone */ }
+  return message;
+}
+
 export async function maybeSweepExecLedgerDir(dir, {
   probability,
   random = Math.random,
@@ -1186,7 +1203,8 @@ export async function recordLedgerEvent(event, {
   if (outcome.ok) {
     // Sampled bounded dir sweep (BUG-C21-11): runs outside the ledger lock so a
     // contended acquisition never pays sweep latency. Advisory — never throws.
-    try { await maybeSweepExecLedgerDir(path.dirname(target)); } catch { /* advisory */ }
+    // BUG-C23-10: a persistent failure is still surfaced as a bounded degrade.
+    try { await maybeSweepExecLedgerDir(path.dirname(target)); } catch (error) { noteSweepFailure(error); }
     return outcome.value;
   }
 

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

@@ -200,6 +200,22 @@ export function maybeSweepTelemetryDir(dir, {
   return { sampled: true, ...sweepTelemetryDir(dir, options) };
 }
 
+// BUG-C23-10: a bare `catch {}` around the sweep swallowed every failure — a
+// persistent EACCES/ENOSPC meant silent non-convergence of the dir bound.
+// Announce the first failure and then every 25th, C22 rate-limit posture.
+let sweepFailureCount = 0;
+export function noteSweepFailure(error) {
+  sweepFailureCount += 1;
+  if (sweepFailureCount !== 1 && sweepFailureCount % 25 !== 0) return null;
+  const message =
+    `UKit hook-telemetry: latency dir sweep failed (${sweepFailureCount} failure(s) so far) — `
+    + `the appended row is safe but the backlog bound may lag. Cause: ${error?.message || error}`;
+  try {
+    fs.writeSync(1, `${JSON.stringify({ systemMessage: message })}\n`);
+  } catch { /* stdout already gone */ }
+  return message;
+}
+
 export function appendTelemetryRow(projectRoot, sessionId, row, options = {}) {
   try {
     if (!row || typeof row !== 'object') return false;
@@ -211,7 +227,7 @@ export function appendTelemetryRow(projectRoot, sessionId, row, options = {}) {
     fs.appendFileSync(filePath, line, 'utf8');
     // Sampled bounded dir sweep (BUG-C21-10): advisory — a sweep failure must
     // never alter the row this call just appended.
-    try { maybeSweepTelemetryDir(dir); } catch { /* advisory */ }
+    try { maybeSweepTelemetryDir(dir); } catch (error) { noteSweepFailure(error); }
     return true;
   } catch {
     // Advisory: an unwritable or corrupt telemetry target must never alter a

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

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import {
   buildCompactMachineKey,
   buildRuntimePaths,
@@ -19,9 +21,42 @@ import { updateCompactPressureFromOutput } from './compact-threshold.mjs';
 // Hook-context self-deadline (2.4.1 orphan-leak class): the compress-output hook passes
 // UKIT_HOOK_DEADLINE_MS so a wedged read can never orphan this process past the hook
 // budget. Non-hook usage never sets it and is never self-killed.
+// SPEC §8 degrade channel: stdout is the only surface the hook consumer reliably
+// shows the user; stderr is model-facing. writeSync(1) because a same-tick
+// process.exit() can discard a buffered async write on a pipe.
+function emitSystemMessage(text) {
+  try {
+    fsSync.writeSync(1, `${JSON.stringify({ systemMessage: text })}\n`);
+  } catch { /* stdout already gone */ }
+}
+
+// BUG-C23-10: bare `.catch(() => {})` swallowed every sweep failure — a
+// persistent EACCES/ENOSPC on .ukit meant silent non-convergence of the tee/
+// backlog bound (live dir observed at 2,417 files). Announce the first failure
+// and then every 25th, C22 rate-limit posture.
+let sweepFailureCount = 0;
+export function noteSweepFailure(error) {
+  sweepFailureCount += 1;
+  if (sweepFailureCount !== 1 && sweepFailureCount % 25 !== 0) return null;
+  const message =
+    `UKit output-compression: tee cache sweep failed (${sweepFailureCount} failure(s) so far) — `
+    + `the preserved output is safe but the backlog bound may lag. Cause: ${error?.message || error}`;
+  emitSystemMessage(message);
+  return message;
+}
+
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10);
 if (Number.isFinite(HOOK_DEADLINE_MS) && HOOK_DEADLINE_MS > 0) {
-  setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+  setTimeout(() => {
+    // BUG-C23-04: deadline expiry abandons configured compression work — a
+    // degrade, and §8(ii) requires it be announced before the exit.
+    emitSystemMessage(
+      `UKit output-compression exceeded its ${HOOK_DEADLINE_MS}ms hook deadline — `
+      + 'tool output passed through uncompressed this call (likely stalled filesystem). '
+      + 'If this repeats, check the .ukit volume or raise UKIT_HOOK_DEADLINE_MS.',
+    );
+    process.exit(0);
+  }, HOOK_DEADLINE_MS).unref();
 }
 
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
@@ -422,7 +457,9 @@ export async function sweepTeeCache(dir, {
   // 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.
+  // sampling); the 7d age cutoff drains the remainder only when new writes keep
+  // arriving — a stopped writer converges at ~ceil(B/maxRemovals) sweeps and no
+  // faster, since sweeps are sampled off the write path (BUG-C23-10, FR-006).
   const eligibleNames = [];
   for (const dirent of dirents) {
     if (dirent.isFile()) eligibleNames.push(dirent.name);
@@ -498,8 +535,9 @@ async function persistRawOutput(projectRoot, {
   await fs.mkdir(teeCacheDir, { recursive: true });
   await fs.writeFile(absolutePath, rawOutputText, 'utf8');
   // Bounded, sampled tee/ prune (BUG-C21-07): advisory only — a sweep failure
-  // must never lose the preserved output this call just wrote.
-  await maybeSweepTeeCache(teeCacheDir).catch(() => {});
+  // must never lose the preserved output this call just wrote. BUG-C23-10: a
+  // persistent failure (EACCES/ENOSPC) still surfaces as a bounded degrade.
+  await maybeSweepTeeCache(teeCacheDir).catch(noteSweepFailure);
 
   return {
     rawSaved: true,
@@ -1486,7 +1524,19 @@ async function main() {
   process.stdout.write(result.summary);
 }
 
-main().catch((error) => {
-  console.error('[UKit] Failed to compress tool output:', error?.message || String(error));
-  process.exitCode = 1;
-});
+// BUG-C23-13: only run main() on direct CLI invocation — an unguarded bottom
+// call executes on ANY import(), reading the importer's stdin and exiting its
+// process. Guard shape matches compact-threshold.mjs.
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : null;
+if (invokedPath && pathToFileURL(invokedPath).href === import.meta.url) {
+  main().catch((error) => {
+    console.error('[UKit] Failed to compress tool output:', error?.message || String(error));
+    // BUG-C23-01: stderr alone is invisible to the hook consumer — the §8
+    // announce contract requires a stdout systemMessage on the crash path too.
+    emitSystemMessage(
+      'UKit output-compression failed before it could compress this tool output; '
+      + 'the raw output was passed through uncompressed. Run `ukit doctor` if this repeats.',
+    );
+    process.exitCode = 1;
+  });
+}

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

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import {
   buildCompactMachineKey,
   buildRuntimePaths,
@@ -22,9 +24,27 @@ import {
 // Hook-context self-deadline (2.4.1 orphan-leak class): the reinject-context hook passes
 // UKIT_HOOK_DEADLINE_MS so a wedged read can never orphan this process past the hook
 // budget. Non-hook usage never sets it and is never self-killed.
+// SPEC §8 degrade channel: stdout is the only surface the hook consumer reliably
+// shows the user; stderr is model-facing. writeSync(1) because a same-tick
+// process.exit() can discard a buffered async write on a pipe.
+function emitSystemMessage(text) {
+  try {
+    fsSync.writeSync(1, `${JSON.stringify({ systemMessage: text })}\n`);
+  } catch { /* stdout already gone */ }
+}
+
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10);
 if (Number.isFinite(HOOK_DEADLINE_MS) && HOOK_DEADLINE_MS > 0) {
-  setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
+  setTimeout(() => {
+    // BUG-C23-04: deadline expiry abandons the configured context reinjection —
+    // a degrade, and §8(ii) requires it be announced before the exit.
+    emitSystemMessage(
+      `UKit reinject-context exceeded its ${HOOK_DEADLINE_MS}ms hook deadline — `
+      + 'post-compaction context reinjection skipped this pass (likely stalled filesystem). '
+      + 'If this repeats, check the .ukit volume or raise UKIT_HOOK_DEADLINE_MS.',
+    );
+    process.exit(0);
+  }, HOOK_DEADLINE_MS).unref();
 }
 
 const STATE_TTL_MS = 30 * 60 * 1000;
@@ -1047,7 +1067,19 @@ async function buildPreviousContextLines(projectRoot, state, config) {
   return [`- Previous context: ${rankedItems.map((item) => buildPreviousContextSnippet(item)).join(' | ')}`];
 }
 
-main().catch((error) => {
-  console.error('[UKit] Failed to build compact reinject context:', error?.message || String(error));
-  process.exitCode = 1;
-});
+// BUG-C23-13: only run main() on direct CLI invocation — an unguarded bottom
+// call executes on ANY import(), reading the importer's stdin and exiting its
+// process. Guard shape matches compact-threshold.mjs.
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : null;
+if (invokedPath && pathToFileURL(invokedPath).href === import.meta.url) {
+  main().catch((error) => {
+    console.error('[UKit] Failed to build compact reinject context:', error?.message || String(error));
+    // BUG-C23-01: stderr alone is invisible to the hook consumer — the §8
+    // announce contract requires a stdout systemMessage on the crash path too.
+    emitSystemMessage(
+      'UKit reinject-context failed before it could rebuild the compact context block; '
+      + 'the session continues without reinjected context this pass. Run `ukit doctor` if this repeats.',
+    );
+    process.exitCode = 1;
+  });
+}

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

@@ -561,7 +561,11 @@ async function alreadyCoordinatedThisStop({ projectRoot, sessionKey, now, dedupe
         return true;
       }
       await fs.mkdir(path.dirname(statePath), { recursive: true });
-      await fs.writeFile(statePath, `${JSON.stringify({ lastStop: { key: sessionKey, ts: now } }, null, 1)}\n`, 'utf8');
+      // BUG-C23-08: spread `current` — a bare { lastStop } write erased the
+      // `handoff` stall-streak slot written by bumpHandoffStallCount, which ran
+      // AFTER this dedupe write each invocation → count always read 1 and the
+      // FR-004 liveness breaker could never fire.
+      await fs.writeFile(statePath, `${JSON.stringify({ ...current, lastStop: { key: sessionKey, ts: now } }, null, 1)}\n`, 'utf8');
       return false;
     });
     return outcome.ok ? outcome.value === true : false;