@ngockhoale/ukit 2.7.7 → 2.7.8

package/templates/.claude/ukit/index/route-task.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import fs from 'node:fs/promises';
-import { realpathSync } from 'node:fs';
+// `fsSync` aliases the SAME fs module — used ONLY by the process.on('exit')
+// audit-sidecar fold below (event loop is gone; async cannot run) and by the
+// module-bottom direct-CLI check. Normal-path fs stays async.
+import * as fsSync from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
@@ -13,6 +16,7 @@ import {
 } from './cache-utils.mjs';
 import { ROUTE_CATALOG } from './route-catalog.mjs';
 import { detectUnicGateway } from './unic-gateway.mjs';
+import { withAsyncLock } from '../runtime/async-lock.mjs';
 
 const {
   resolveContext,
@@ -946,7 +950,7 @@ async function main() {
     };
     sharedState.fingerprint = buildRouteStateFingerprint(sharedState);
     if (canPersistCachedRouteState) {
-      await writeJson(sharedStatePath, sharedState);
+      await persistSharedRouteState(sharedStatePath, sharedState);
       await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
         state: sharedState,
       }));
@@ -991,7 +995,7 @@ async function main() {
     sessionId,
   });
   if (canPersistRouteState) {
-    await writeJson(sharedStatePath, sharedState);
+    await persistSharedRouteState(sharedStatePath, sharedState);
     await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
       route,
       state: sharedState,
@@ -3816,35 +3820,241 @@ function buildRouteAuditEntry({ route = null, state = null } = {}) {
   };
 }
 
-async function appendRouteAuditEntry(filePath, entry) {
+// CX-8: the shared route-state/audit writes must obey the same protocol as the
+// claude/omp writers (skill-router.sh + token-utils withFileLock): tmp+rename
+// atomicity AND the owner-token `<file>.lock` serialization. The pre-fix bare
+// fs.writeFile raced the locked writers — a torn skill-router-state.json parses
+// as `{}` downstream and releases a premature Stop; the unlocked audit
+// read-modify-write lost entries under concurrent routers.
+export async function writeJsonAtomic(filePath, value) {
+  // tmp+rename: readers see old-or-new, never a torn/half file.
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
+  try {
+    await fs.writeFile(tempPath, JSON.stringify(value), 'utf8');
+    await fs.rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await fs.rm(tempPath, { force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+// The state write is a pure overwrite, but it must still serialize under the
+// owner-token lock so a codex writer cannot interleave with a locked claude/omp
+// writer mid-flight. Fail-closed (CX-8): a busy lock skips the write — the next
+// route recomputes and overwrites the whole document anyway, so a skipped
+// overwrite loses nothing; an unlocked one can interleave with a live holder.
+export async function persistSharedRouteState(filePath, state) {
+  const result = await withAsyncLock(filePath, {}, () => writeJsonAtomic(filePath, state));
+  if (!result.ok) {
+    console.error(`route-task: skill-router-state lock ${result.reason} after ${result.waitedMs}ms — state write skipped (fail-closed)`);
+  }
+  return result;
+}
+
+// Ported from skill-router.sh entryDedupeKey — `|| null` (not `?? null`) so
+// falsy fields like repeatCount: 0 produce the same digest in both engines and
+// cross-engine dedupe of the shared route-audit.json cannot duplicate entries.
+function routeAuditEntryDedupeKey(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,
+  });
+}
+
+// Merge order: the fresh entry first, then staged sidecar lines, then the
+// existing file. A staged/existing row with the new entry's dedupe key is
+// replaced by the fresh entry; every other key keeps its first occurrence.
+function mergeRouteAuditEntries(staged, parsed, newEntry) {
+  const dedupeKey = newEntry ? routeAuditEntryDedupeKey(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 = routeAuditEntryDedupeKey(item);
+    if (dedupeKey && key === dedupeKey && item !== newEntry) continue;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(item);
+  }
+  return merged.slice(0, 40);
+}
+
+function parseRouteAuditSidecar(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 {
+      // skip unparseable sidecar lines
+    }
+  }
+  return recovered;
+}
+
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: the process exists but belongs to another user — still alive.
+    return error?.code === 'EPERM';
+  }
+}
+
+// Synchronous last-chance fold for the process-exit path: process.on('exit')
+// handlers run without the event loop, so sync fs is legal here (fsSync alias).
+// 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.
+function foldRouteAuditSidecarSync(filePath) {
+  const sidecarPath = `${filePath}.unlocked.jsonl`;
+  const lockPath = `${filePath}.lock`;
+  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);
+        let owner = null;
+        try {
+          owner = JSON.parse(fsSync.readFileSync(path.join(lockPath, 'owner'), 'utf8'));
+        } catch {
+          // unreadable owner — treated as no owner below
+        }
+        // An exit during our own async merge abandons our lock; reclaim it. A
+        // live foreign owner stays protected; a dead/stale one is reclaimed.
+        const ownInterruptedLock = owner?.pid === process.pid;
+        if (ownInterruptedLock || Date.now() - stat.mtimeMs > 10000) {
+          if (ownInterruptedLock || !owner || !isPidAlive(owner.pid)) {
+            fsSync.rmSync(lockPath, { recursive: true, force: true });
+            continue;
+          }
+        }
+      } catch {
+        // stat failed — fall through to the bounded spin
+      }
+      const until = Date.now() + 5;
+      while (Date.now() < until) { /* bounded spin */ }
+    }
+  }
+  if (!held) return;
+  try {
+    const claimedPath = `${sidecarPath}.claim-${process.pid}-${Date.now()}`;
+    try {
+      fsSync.renameSync(sidecarPath, claimedPath);
+    } catch {
+      return; // no staged sidecar — nothing to fold
+    }
+    let staged = [];
+    try {
+      staged = parseRouteAuditSidecar(fsSync.readFileSync(claimedPath, 'utf8'));
+    } catch {
+      // unreadable claim — treated as empty below
+    }
+    try {
+      fsSync.rmSync(claimedPath, { force: true });
+    } catch {
+      // best-effort cleanup
+    }
+    if (!staged.length) return;
+    let parsed = { entries: [] };
+    try {
+      parsed = JSON.parse(fsSync.readFileSync(filePath, 'utf8'));
+    } catch {
+      parsed = { entries: [] };
+    }
+    const tmpPath = `${filePath}.exitfold-${process.pid}`;
+    fsSync.writeFileSync(tmpPath, JSON.stringify({
+      entries: mergeRouteAuditEntries(staged, parsed, null),
+    }));
+    fsSync.renameSync(tmpPath, filePath);
+  } finally {
+    try {
+      fsSync.rmSync(lockPath, { recursive: true, force: true });
+    } catch {
+      // best-effort release
+    }
+  }
+}
+
+const armedRouteAuditFolds = new Set();
+
+export async function appendRouteAuditEntry(filePath, entry) {
   if (!entry || typeof entry !== 'object') {
     return;
   }
+  // The sandbox starts without .ukit/storage/cache. Create it before the
+  // sidecar append and lock acquisition; otherwise both fail with ENOENT.
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
 
-  const existing = await readJson(filePath, { entries: [] });
-  const entries = Array.isArray(existing?.entries) ? existing.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,
+  // 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; 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.
+  const sidecarPath = `${filePath}.unlocked.jsonl`;
+  try {
+    await fs.appendFile(sidecarPath, `${JSON.stringify(entry)}\n`);
+  } catch {
+    // staging failed — still attempt the locked merge so the entry is not lost
+  }
+  if (!armedRouteAuditFolds.has(filePath)) {
+    armedRouteAuditFolds.add(filePath);
+    process.on('exit', () => foldRouteAuditSidecarSync(filePath));
+  }
+
+  const result = await withAsyncLock(filePath, {}, 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 fs.rename(sidecarPath, claimedPath);
+      claimed = true;
+    } catch {
+      // no sidecar — nothing staged
+    }
+    const sidecarEntries = claimed
+      ? parseRouteAuditSidecar(await fs.readFile(claimedPath, 'utf8').catch(() => ''))
+      : [];
+    if (claimed) {
+      try {
+        await fs.rm(claimedPath, { force: true });
+      } catch {
+        // best-effort cleanup
+      }
+    }
+
+    const parsed = await readJson(filePath, { entries: [] });
+    await writeJsonAtomic(filePath, {
+      entries: mergeRouteAuditEntries(sidecarEntries, parsed, entry),
     });
-    return itemKey !== dedupeKey;
-  });
-  await writeJson(filePath, {
-    entries: [entry, ...filtered].slice(0, 40),
   });
+  if (!result.ok) {
+    // Fail-closed on the merge (CX-8): the entry stays staged in the sidecar —
+    // the next locked merge or the exit fold picks it up.
+    console.error(`route-task: route-audit lock ${result.reason} after ${result.waitedMs}ms — audit entry staged to the append-only sidecar`);
+  }
+  return result;
 }
 
 async function readJson(filePath, fallback = null) {
@@ -3855,11 +4065,6 @@ async function readJson(filePath, fallback = null) {
   }
 }
 
-async function writeJson(filePath, value) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(value), 'utf8');
-}
-
 function normalize(text) {
   return String(text ?? '')
     .toLowerCase()
@@ -4233,7 +4438,7 @@ function isDirectCliInvocation() {
     if (import.meta.url === pathToFileURL(entry).href) {
       return true;
     }
-    return import.meta.url === pathToFileURL(realpathSync(entry)).href;
+    return import.meta.url === pathToFileURL(fsSync.realpathSync(entry)).href;
   } catch {
     return false;
   }

package/templates/.claude/ukit/runtime/async-lock.mjs

@@ -2,7 +2,10 @@
 // TASK-028: the one async lock utility for hook processes. Every hook lock used to
 // carry its own inline mkdir/owner/backoff copy (auto-allow-bash, verification-guard,
 // token-utils withFileLock, src/core/fileOps) with slightly divergent policies; this
-// module is the shared protocol-compatible implementation for hook-side callers:
+// module is now the single implementation for all of them — the two withFileLock
+// twins (token-utils.mjs and src/core/fileOps.js) delegate here, so the lock
+// protocol, pstart/recycled-pid validation, and claim+quarantine reclaim exist
+// exactly once and cannot drift between copies. For hook-side callers:
 //
 // - Acquisition is an atomic `mkdir` of `<target>.lock`; the owner is stamped into
 //   `owner` (pid + random token + ts) so stale reclaim can be validated instead of
@@ -26,6 +29,7 @@
 //   ownerless lock: a contender reads a missing owner as reclaimable after `staleMs`,
 //   so an unstamped live holder could have its lock deleted mid-critical-section.
 import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -40,6 +44,10 @@ export const LOCK_MAX_SLICE_MS = 1_200;
 const BACKOFF_MIN_MS = 3;
 const BACKOFF_SPREAD_MS = 9;
 
+// Tolerance for comparing a stamped process start time against `ps`-reported start:
+// etimes has 1s granularity and the stamp is taken a few ms after the real start.
+const PID_START_TOLERANCE_MS = 3_000;
+
 /**
  * Derive the lock acquisition budget from a hook's wall-clock deadline: the time
  * remaining before that deadline, minus a reserve for release/cleanup, capped at the
@@ -96,12 +104,66 @@ function isPidAlive(pid) {
   }
 }
 
+// Wall-clock ms when `pid` started, or null when it cannot be determined. `lstart`
+// is POSIX-portable across macOS and Linux ps (BSD ps has no `etimes`); the ctime
+// shape is parsed manually so no Date.parse implementation quirk can misread it.
+// A failed probe is treated as "unknown", never as "dead".
+const LSTART_MONTHS = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+const LSTART_RE = /^[A-Za-z]{3}\s+([A-Za-z]{3})\s+(\d{1,2})\s+(\d{1,2}):(\d{2}):(\d{2})\s+(\d{4})$/;
+function processStartMs(pid) {
+  try {
+    const result = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+      encoding: 'utf8',
+      timeout: 2_000,
+    });
+    if (result.status !== 0) return null;
+    const match = String(result.stdout || '').replace(/\s+/g, ' ').trim().match(LSTART_RE);
+    if (!match) return null;
+    const month = LSTART_MONTHS[match[1]];
+    if (month === undefined) return null;
+    const ms = new Date(
+      Number(match[6]), month, Number(match[2]),
+      Number(match[3]), Number(match[4]), Number(match[5]),
+    ).getTime();
+    return Number.isFinite(ms) ? ms : null;
+  } catch {
+    return null;
+  }
+}
+
+// This process's own start time, stamped into every owner/reclaim record so a later
+// observer can tell a recycled pid (same number, different process) from the real
+// holder. `process.kill(pid, 0)` alone cannot: a reused pid probes alive forever and
+// used to pin every stale lock unreclaimable (RC-4 PID-reuse residual).
+const PROCESS_START_MS = Date.now() - Math.floor(process.uptime() * 1000);
+
+// Provably-gone check for a recorded owner/claim { pid, token, pstart? }:
+//  - dead pid probe → gone;
+//  - live pid + stamped pstart that does not match the running process's start → the
+//    pid was recycled after the holder died → gone;
+//  - live pid with no stamp (legacy record) or an undeterminable start → alive
+//    (conservative: a live holder's lock is never stolen).
+function recordedProcessGone(owner) {
+  if (!owner) return true;
+  if (!isPidAlive(owner.pid)) return true;
+  const stamped = Number(owner.pstart);
+  if (!Number.isFinite(stamped) || stamped <= 0) return false;
+  const actual = processStartMs(owner.pid);
+  if (actual === null) return false;
+  return Math.abs(actual - stamped) > PID_START_TOLERANCE_MS;
+}
+
 async function readLockOwner(lockPath) {
   try {
     const raw = JSON.parse(await fs.readFile(path.join(lockPath, 'owner'), 'utf8'));
     const pid = Number(raw?.pid);
+    const pstart = Number(raw?.pstart);
     return Number.isInteger(pid) && pid > 0
-      ? { pid, token: typeof raw?.token === 'string' ? raw.token : null }
+      ? {
+        pid,
+        token: typeof raw?.token === 'string' ? raw.token : null,
+        pstart: Number.isFinite(pstart) && pstart > 0 ? pstart : null,
+      }
       : null;
   } catch {
     return null;
@@ -119,8 +181,13 @@ async function readReclaimOwner(lockPath) {
   try {
     const raw = JSON.parse(await fs.readFile(path.join(lockPath, RECLAIM_FILE), 'utf8'));
     const pid = Number(raw?.pid);
+    const pstart = Number(raw?.pstart);
     return Number.isInteger(pid) && pid > 0
-      ? { pid, token: typeof raw?.token === 'string' ? raw.token : null }
+      ? {
+        pid,
+        token: typeof raw?.token === 'string' ? raw.token : null,
+        pstart: Number.isFinite(pstart) && pstart > 0 ? pstart : null,
+      }
       : null;
   } catch {
     return null;
@@ -137,7 +204,7 @@ async function claimReclaim(lockPath, ownerToken, staleMs) {
     const handle = await fs.open(reclaimPath, 'wx');
     try {
       await handle.writeFile(
-        `${JSON.stringify({ pid: process.pid, token: ownerToken, ts: Date.now() })}\n`,
+        `${JSON.stringify({ pid: process.pid, token: ownerToken, ts: Date.now(), pstart: PROCESS_START_MS })}\n`,
         'utf8',
       );
     } finally {
@@ -153,7 +220,7 @@ async function claimReclaim(lockPath, ownerToken, staleMs) {
       const stat = await fs.stat(reclaimPath);
       if (Date.now() - stat.mtimeMs > staleMs) {
         const claim = await readReclaimOwner(lockPath);
-        if (!claim || !isPidAlive(claim.pid)) {
+        if (!claim || recordedProcessGone(claim)) {
           await fs.rm(reclaimPath, { force: true });
         }
       }
@@ -207,6 +274,56 @@ async function quarantineReclaim(lockPath, owner, ownerToken) {
 // a pid probe cannot prove, so the module tracks them itself (same as withFileLock).
 const inProcessLockHolders = new Map();
 
+// --- TASK-004: dropped-update journal -------------------------------------------
+// Fail-closed means a skipped mutation is LOST — the journal makes that loss
+// explicit and auditable instead of a silent unlocked write. One JSONL record per
+// drop, appended under a journal-local async lock (the main lock is unavailable —
+// that is why this path runs). Bounded: a full journal applies backpressure and
+// rejects the record rather than rewriting history, same as the ledger journal.
+// Shared by both withFileLock twins (token-utils.mjs and src/core/fileOps.js) so
+// the drop contract can never diverge between the protocol copies.
+const LOCK_DROP_JOURNAL_MAX_RECORDS = 128;
+const LOCK_DROP_JOURNAL_BUDGET_MS = 400;
+
+export function lockDropJournalPath(filePath) {
+  return `${filePath}.lock-drops.jsonl`;
+}
+
+export async function journalDroppedLockMutation(filePath, { reason, waitedMs }) {
+  const journalPath = lockDropJournalPath(filePath);
+  const record = {
+    v: 1,
+    ts: Date.now(),
+    pid: process.pid,
+    file: path.basename(filePath),
+    reason,
+    waitedMs: Math.max(0, Math.round(waitedMs)),
+  };
+  try {
+    const outcome = await withAsyncLock(
+      journalPath,
+      { deadlineMs: LOCK_DROP_JOURNAL_BUDGET_MS },
+      async () => {
+        let existing = null;
+        try {
+          existing = await fs.readFile(journalPath, 'utf8');
+        } catch (error) {
+          if (error?.code !== 'ENOENT') return false;
+        }
+        const lines = existing === null
+          ? []
+          : existing.split('\n').filter((line) => line.trim());
+        if (lines.length >= LOCK_DROP_JOURNAL_MAX_RECORDS) return false;
+        await fs.appendFile(journalPath, `${JSON.stringify(record)}\n`, 'utf8');
+        return true;
+      },
+    );
+    return outcome?.ok === true && outcome.value === true;
+  } catch {
+    return false; // journaling is best-effort; never resurrect the mutation over it
+  }
+}
+
 /**
  * Serialize a mutation of a shared state file across hook processes and concurrent
  * async flows. Protocol-compatible with token-utils withFileLock (`<file>.lock`
@@ -250,7 +367,7 @@ export async function withAsyncLock(filePath, { signal, deadlineMs = LOCK_MAX_SL
       try {
         await fs.writeFile(
           path.join(lockPath, 'owner'),
-          `${JSON.stringify({ pid: process.pid, token: ownerToken, ts: Date.now() })}\n`,
+          `${JSON.stringify({ pid: process.pid, token: ownerToken, ts: Date.now(), pstart: PROCESS_START_MS })}\n`,
           'utf8',
         );
       } catch {
@@ -281,15 +398,32 @@ export async function withAsyncLock(filePath, { signal, deadlineMs = LOCK_MAX_SL
     // Someone holds the lock. Reclaim it only after the stale threshold AND only when
     // the holder is provably gone — stealing a live holder reintroduces the exact
     // interleaved-write race this lock exists to prevent.
+    //
+    // RC-4: the effective stale threshold for a budgeted waiter is
+    // min(staleMs, its remaining budget) — a waiter that cannot outlast the full
+    // LOCK_STALE_MS still reclaims a genuinely orphaned lock instead of freezing the
+    // liveness breakers behind it. A zero/negative remaining budget keeps the full
+    // threshold (a no-wait caller never steals). A lock whose recorded owner is a
+    // LIVE process is never reclaimed early; "provably gone" includes a recycled pid
+    // (stamped pstart no longer matches the running process).
     let reclaimed = false;
     try {
       const stat = await fs.stat(lockPath);
-      if (Date.now() - stat.mtimeMs > stale) {
+      const ageMs = Date.now() - stat.mtimeMs;
+      const remainingMs = budget - (Date.now() - startedAt);
+      const effectiveStaleMs = remainingMs > 0 ? Math.min(stale, remainingMs) : stale;
+      if (ageMs > effectiveStaleMs) {
         const owner = await readLockOwner(lockPath);
         const liveInProcess = inProcessLockHolders.has(lockPath);
-        const reclaimable = !owner || owner.pid === process.pid
-          ? !liveInProcess
-          : !isPidAlive(owner.pid);
+        // An ownerless lock may be a holder mid-stamp — only the FULL stale
+        // threshold proves abandonment there. A stamped owner provably gone
+        // (dead pid, recycled pid, or a same-pid record with no live in-process
+        // holder) is reclaimable at the budgeted threshold.
+        const reclaimable = !owner
+          ? (!liveInProcess && ageMs > stale)
+          : owner.pid === process.pid
+            ? !liveInProcess
+            : recordedProcessGone(owner);
         if (reclaimable && await claimReclaim(lockPath, ownerToken, stale)) {
           // Detach and clean only the generation that was validated. The atomic rename
           // makes this safe even when another process acquires lockPath immediately

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

@@ -1398,13 +1398,16 @@ async function runCli() {
       routeSummary: routeState?.routeSummary ?? null,
     }, sessionConfig);
 
-    if (nextState.phase === 'hard') {
+    // TASK-004: withFileLock is fail-closed — a contended pressure lock skips the
+    // mutation and resolves undefined (journaled). Skip the advisory notice too;
+    // the next prompt re-evaluates pressure from the last committed state.
+    if (nextState?.phase === 'hard') {
       process.stdout.write(
         `[ukit-skill-router] Context pressure: hard (est ${nextState.estimatedTotalTokens} / soft ${nextState.softThreshold} / hard ${nextState.hardThreshold}). `
           + 'FIRST THING IN YOUR REPLY, tell the user plainly — do not stay silent: "Context sắp đầy — hãy gõ /compact ngay bây giờ (run /compact now)". '
           + 'Then hold heavy work: no new investigations, subagents, or large edits until the user has compacted.\n',
       );
-    } else if (nextState.phase === 'soft') {
+    } else if (nextState?.phase === 'soft') {
       process.stdout.write(
         `[ukit-skill-router] Context pressure: soft (est ${nextState.estimatedTotalTokens} / soft ${nextState.softThreshold} / hard ${nextState.hardThreshold}). `
           + 'Finish the current step, then tell the user to run /compact at the next natural pause instead of continuing indefinitely.\n',