@ngockhoale/ukit 2.3.7 → 2.3.8

package/templates/.claude/hooks/reset-compact-pressure.sh

@@ -1,25 +1,129 @@
 #!/bin/bash
-# SessionStart hook: zero the compact pressure tracker at the start of every session.
+# SessionStart hook: clear THIS session's compact pressure record at session start.
 #
-# compact-pressure.json is a single per-project file whose sessionTokens counter only ever
-# accumulates (see registerPromptPressure/registerOutputPressure in compact-threshold.mjs).
-# Without this reset it sums every prompt and every command output across the entire
-# lifetime of the project, so it eventually crosses compact.hardCapTokens and permanently
-# blocks Edit/Write/Bash in every future session -- even when actual context is tiny.
-# That is a deadlock: the gate blocks Bash, so the documented remedies (ukit install,
-# ukit doctor) cannot run, and compaction never fires because real context is small.
+# compact-pressure.json stores one record per session id (see compact-threshold.mjs).
+# sessionTokens accumulates within a record, so a record left over from a previous
+# session would keep counting against this one — eventually crossing
+# compact.hardCapTokens and blocking Edit/Write/Bash even when actual context is tiny.
+# Clearing the calling session's record at start makes the counter measure THIS session,
+# and gives the gate a guaranteed escape hatch: restarting the session always clears a
+# stuck gate, with no manual file surgery.
 #
-# Resetting here makes the counter measure THIS session only, which is what the hard cap
-# is actually trying to approximate. It also gives the gate a guaranteed escape hatch:
-# restarting the session always clears a stuck gate, with no manual file surgery.
+# Session-scoped (P1 fix): an earlier version deleted the whole file, which also erased
+# the pressure history of any OTHER live session in this project — that session silently
+# lost its near-cap warnings and could run into the real context cap. Now only the
+# calling session's record is removed; sibling records and the legacy flat file content
+# are preserved.
 #
 # Always exits 0 -- a failure here must never prevent a session from starting.
 
 PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$PWD}"
 PRESSURE_FILE="$PROJECT_ROOT/.ukit/storage/cache/compact-pressure.json"
 
-if [ -f "$PRESSURE_FILE" ]; then
-  rm -f "$PRESSURE_FILE" 2>/dev/null || true
+if [ ! -f "$PRESSURE_FILE" ]; then
+  exit 0
 fi
 
+# The lock directory lives beside the state file; its parent exists because the file does.
+node -e '
+const fs = require("fs");
+
+async function withLock(lockPath, fn) {
+  const staleMs = 10000;
+  const maxWaitMs = 5000;
+  const startedAt = Date.now();
+  let held = false;
+  while (!held) {
+    try {
+      fs.mkdirSync(lockPath);
+      held = true;
+    } catch (error) {
+      if (!error || error.code !== "EEXIST") return fn();
+      try {
+        const stat = fs.statSync(lockPath);
+        if (Date.now() - stat.mtimeMs > staleMs) {
+          try {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+            continue;
+          } catch {}
+        }
+      } catch {}
+      if (Date.now() - startedAt > maxWaitMs) break;
+      await new Promise((resolve) => setTimeout(resolve, 3 + Math.floor(Math.random() * 9)));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    if (held) {
+      try {
+        fs.rmdirSync(lockPath);
+      } catch {}
+    }
+  }
+}
+
+const chunks = [];
+process.stdin.on("data", (chunk) => chunks.push(chunk));
+process.stdin.on("end", () => {
+  const payload = (() => {
+    try {
+      return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+    } catch {
+      return {};
+    }
+  })();
+  const sessionId = typeof payload.session_id === "string" ? payload.session_id.trim() : "";
+  const pressurePath = process.argv[1];
+
+  withLock(`${pressurePath}.lock`, () => {
+    const raw = (() => {
+      try {
+        return JSON.parse(fs.readFileSync(pressurePath, "utf8"));
+      } catch {
+        return null;
+      }
+    })();
+    if (!raw || typeof raw !== "object") {
+      try {
+        fs.rmSync(pressurePath, { force: true });
+      } catch {}
+      return;
+    }
+
+    // Without a session id (unknown caller) keep the old whole-file reset: this hook is
+    // the documented escape hatch for a bricked gate, and it must stay one.
+    if (!sessionId || !raw.sessions || typeof raw.sessions !== "object") {
+      try {
+        fs.rmSync(pressurePath, { force: true });
+      } catch {}
+      return;
+    }
+
+    const sessions = { ...raw.sessions };
+    delete sessions[sessionId];
+    const newest = Object.entries(sessions)
+      .sort(([, a], [, b]) => (b?.updatedAt ?? 0) - (a?.updatedAt ?? 0))[0]?.[1] ?? null;
+    const tempPath = `${pressurePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+      fs.writeFileSync(
+        tempPath,
+        JSON.stringify({
+          ...(newest && typeof newest === "object" ? newest : {}),
+          updatedAt: newest?.updatedAt ?? Date.now(),
+          v: 2,
+          sessions,
+        }, null, 2) + "\n",
+      );
+      fs.renameSync(tempPath, pressurePath);
+    } catch (error) {
+      try {
+        fs.rmSync(tempPath, { force: true });
+      } catch {}
+      throw error;
+    }
+  }).catch(() => {});
+});
+' "$PRESSURE_FILE" >/dev/null 2>&1 || true
+
 exit 0

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

@@ -20,9 +20,64 @@ function readJson(filePath, fallback = null) {
   }
 }
 
-function writeJson(filePath, value) {
+function writeJsonAtomic(filePath, value) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(value));
+  const tempPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  try {
+    fs.writeFileSync(tempPath, JSON.stringify(value, null, 2) + '\n');
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      fs.rmSync(tempPath, { force: true });
+    } catch {}
+    throw error;
+  }
+}
+
+// Sync sleep without burning CPU — the hook's flow calls process.exit right after
+// persistAttempt, so the critical section must complete synchronously.
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(buffer), 0, 0, ms);
+}
+
+// mkdir-based lock, protocol-compatible with runtime token-utils withFileLock. Sync on
+// purpose (see sleepSync). Fail-open after 5s: this hook must never hang a PreToolUse
+// chain, and a lost progress entry only costs one repeated advisory.
+function withLockSync(lockPath, fn) {
+  const staleMs = 10000;
+  const maxWaitMs = 5000;
+  const startedAt = Date.now();
+  let held = false;
+  while (!held) {
+    try {
+      fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+      fs.mkdirSync(lockPath);
+      held = true;
+    } catch (error) {
+      if (!error || error.code !== 'EEXIST') return fn();
+      try {
+        const stat = fs.statSync(lockPath);
+        if (Date.now() - stat.mtimeMs > staleMs) {
+          try {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+            continue;
+          } catch {}
+        }
+      } catch {}
+      if (Date.now() - startedAt > maxWaitMs) break;
+      sleepSync(3 + Math.floor(Math.random() * 9));
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (held) {
+      try {
+        fs.rmdirSync(lockPath);
+      } catch {}
+    }
+  }
 }
 
 function normalizeCommand(value) {
@@ -316,23 +371,36 @@ function persistAttempt(commandText) {
   const normalizedCommandText = normalizeCommand(commandText);
   attemptedCommands.add(normalizedCommandText);
   const now = Date.now();
-  const recentAttempts = [
-    ...(progress?.recentAttempts ?? []),
-    { command: normalizedCommandText, ts: now },
-  ]
-    .map((entry) => ({
-      command: normalizeCommand(entry?.command),
-      ts: Number(entry?.ts ?? now),
-    }))
-    .filter((entry) => entry.command && Number.isFinite(entry.ts) && now - entry.ts <= STATE_FRESH_MS)
-    .filter((entry, index, list) => (
-      list.findLastIndex((candidate) => candidate.command === entry.command) === index
-    ));
-  writeJson(progressPath, {
-    fingerprint: state?.fingerprint || null,
-    updatedAt: now,
-    attemptedCommands: [...attemptedCommands],
-    recentAttempts,
+  // Locked re-read + merge: parallel subagents record attempts concurrently, and a
+  // stale-snapshot rewrite would silently drop their entries — the guard would then keep
+  // advising instead of allowing, re-litigating verification order forever.
+  withLockSync(`${progressPath}.lock`, () => {
+    const current = readJson(progressPath, {});
+    const mergedAttempts = new Set(collectAttemptedCommands(current, {
+      currentFingerprint: state?.fingerprint || null,
+      maxAgeMs: STATE_FRESH_MS,
+    }));
+    for (const command of attemptedCommands) {
+      mergedAttempts.add(command);
+    }
+    const recentAttempts = [
+      ...(current?.recentAttempts ?? []),
+      { command: normalizedCommandText, ts: now },
+    ]
+      .map((entry) => ({
+        command: normalizeCommand(entry?.command),
+        ts: Number(entry?.ts ?? now),
+      }))
+      .filter((entry) => entry.command && Number.isFinite(entry.ts) && now - entry.ts <= STATE_FRESH_MS)
+      .filter((entry, index, list) => (
+        list.findLastIndex((candidate) => candidate.command === entry.command) === index
+      ));
+    writeJsonAtomic(progressPath, {
+      fingerprint: state?.fingerprint || null,
+      updatedAt: now,
+      attemptedCommands: [...mergedAttempts],
+      recentAttempts,
+    });
   });
 }
 

package/templates/.claude/ukit/index/cache-utils.mjs

@@ -1,6 +1,30 @@
 #!/usr/bin/env node
+// Cache read-modify-write cycles run in separate node processes (query/triage/route/
+// resolve-context hooks and CLI calls can fire concurrently). They must serialize on
+// withFileLock — without it, concurrent writers each append against a stale snapshot
+// and silently drop each other's entries (verified: 20 concurrent writers kept 2).
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { readJson, withFileLock } from '../runtime/token-utils.mjs';
+
+// Cache files stay single-line compact JSON (locked by tests): they sit inside .claude/
+// and pretty-printing them would turn every cache touch into a noisy multi-line diff.
+// Atomic like token-utils writeJson (tmp + rename), only compact.
+async function writeCacheJson(cachePath, value) {
+  await fs.mkdir(path.dirname(cachePath), { recursive: true });
+  const tempPath = `${cachePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  try {
+    await fs.writeFile(tempPath, JSON.stringify(value), 'utf8');
+    await fs.rename(tempPath, cachePath);
+  } catch (error) {
+    try {
+      await fs.rm(tempPath, { force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+    throw error;
+  }
+}
 
 export const DEFAULT_RECENT_CACHE_MAX_ENTRIES = 6;
 
@@ -36,14 +60,25 @@ export async function readRecentCacheEntry(
     ...entry,
     updatedAt: Date.now(),
   };
-  const entries = [
-    touchedEntry,
-    ...cache.entries.slice(0, entryIndex),
-    ...cache.entries.slice(entryIndex + 1),
-  ].slice(0, maxEntries);
-  const document = buildCacheDocument(entries, { maxEntries });
-  await writeJson(cachePath, document);
-  return document.entries[0] ?? touchedEntry;
+  return withFileLock(cachePath, async () => {
+    const locked = await readRecentCache(cachePath, { maxEntries });
+    const lockedIndex = locked.entries.findIndex((lockedEntry) => lockedEntry.requestKey === requestKey);
+    if (lockedIndex < 0) {
+      return touchedEntry;
+    }
+    const lockedEntry = {
+      ...locked.entries[lockedIndex],
+      updatedAt: touchedEntry.updatedAt,
+    };
+    const entries = [
+      lockedEntry,
+      ...locked.entries.slice(0, lockedIndex),
+      ...locked.entries.slice(lockedIndex + 1),
+    ].slice(0, maxEntries);
+    const document = buildCacheDocument(entries, { maxEntries });
+    await writeCacheJson(cachePath, document);
+    return document.entries[0] ?? lockedEntry;
+  });
 }
 
 export async function writeRecentCacheEntry(
@@ -56,14 +91,16 @@ export async function writeRecentCacheEntry(
     return readRecentCache(cachePath, { maxEntries });
   }
 
-  const cache = await readRecentCache(cachePath, { maxEntries });
-  const entries = [
-    normalizedEntry,
-    ...cache.entries.filter((existingEntry) => existingEntry.requestKey !== normalizedEntry.requestKey),
-  ].slice(0, maxEntries);
-  const document = buildCacheDocument(entries, { maxEntries });
-  await writeJson(cachePath, document);
-  return document;
+  return withFileLock(cachePath, async () => {
+    const cache = await readRecentCache(cachePath, { maxEntries });
+    const entries = [
+      normalizedEntry,
+      ...cache.entries.filter((existingEntry) => existingEntry.requestKey !== normalizedEntry.requestKey),
+    ].slice(0, maxEntries);
+    const document = buildCacheDocument(entries, { maxEntries });
+    await writeCacheJson(cachePath, document);
+    return document;
+  });
 }
 
 function normalizeCacheDocument(raw, { maxEntries = DEFAULT_RECENT_CACHE_MAX_ENTRIES } = {}) {
@@ -125,16 +162,3 @@ function normalizeCacheEntry(entry) {
   delete normalizedEntry.entries;
   return normalizedEntry;
 }
-
-async function readJson(filePath, fallback = null) {
-  try {
-    return JSON.parse(await fs.readFile(filePath, 'utf8'));
-  } catch {
-    return fallback;
-  }
-}
-
-async function writeJson(filePath, value) {
-  await fs.mkdir(path.dirname(typeof filePath === 'string' && filePath ? filePath : '.'), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(value), 'utf8');
-}

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

@@ -668,7 +668,71 @@ export function resolveThresholdCompactBudget({
   };
 }
 
+// ---- session-scoped pressure document ---------------------------------------
+// compact-pressure.json holds ONE record per session id. A session starting must never
+// zero another live session's pressure bookkeeping (its hard-cap gate and compact
+// advisories), and a brand-new session must not inherit a sibling's totals. The newest
+// record's flat fields stay projected at the document's top level so readers that predate
+// this shape (raw JSON readers) still see a coherent state.
+const PRESSURE_SESSIONS_MAX = 8;
+
+function normalizeSessionId(value) {
+  const id = typeof value === 'string' ? value.trim() : '';
+  return id || null;
+}
+
+function readPressureDocument(raw) {
+  if (raw && typeof raw === 'object' && raw.sessions && typeof raw.sessions === 'object') {
+    const sessions = {};
+    for (const [id, record] of Object.entries(raw.sessions)) {
+      if (id && record && typeof record === 'object') {
+        sessions[id] = record;
+      }
+    }
+    return sessions;
+  }
+  // Legacy single-record file: preserve the in-flight session under a shared bucket.
+  return raw && typeof raw === 'object' ? { default: raw } : {};
+}
+
+function pickPressureSession(sessions, sessionId) {
+  if (sessionId) {
+    // A session id that has no record yet starts clean — it must not inherit another
+    // session's totals, and the other way round nothing here touches that session.
+    return { id: sessionId, record: sessions[sessionId] ?? null };
+  }
+  const entries = Object.entries(sessions);
+  if (!entries.length) {
+    return { id: 'default', record: null };
+  }
+  const newest = entries
+    .sort(([, left], [, right]) => finiteNumber(right?.updatedAt, 0) - finiteNumber(left?.updatedAt, 0))[0];
+  return { id: newest[0], record: newest[1] };
+}
+
+function resolvePressureRecord(raw, config) {
+  if (!raw || typeof raw !== 'object' || !raw.sessions || typeof raw.sessions !== 'object') {
+    return raw; // flat legacy state — normalized as-is below
+  }
+  const { record } = pickPressureSession(readPressureDocument(raw), normalizeSessionId(config?.sessionId));
+  return record;
+}
+
+function projectPressureDocument(sessions) {
+  const newestFirst = Object.entries(sessions)
+    .sort(([, left], [, right]) => finiteNumber(right?.updatedAt, 0) - finiteNumber(left?.updatedAt, 0))
+    .slice(0, PRESSURE_SESSIONS_MAX);
+  const newestRecord = newestFirst[0]?.[1] ?? null;
+  return {
+    ...(newestRecord && typeof newestRecord === 'object' ? newestRecord : {}),
+    updatedAt: finiteNumber(newestRecord?.updatedAt, Date.now()),
+    v: 2,
+    sessions: Object.fromEntries(newestFirst),
+  };
+}
+
 export function buildCompactPressureState(rawState = null, config = {}) {
+  rawState = resolvePressureRecord(rawState, config);
   const thresholds = buildCompactThresholds(config);
   const rawSoftThreshold = finiteNumber(rawState?.softThreshold, 0);
   const rawHardThreshold = finiteNumber(rawState?.hardThreshold, 0);
@@ -1056,13 +1120,18 @@ export async function readCompactPressureState(projectRoot, config = {}) {
 // All compact-pressure mutations share one lock on the state file: without it,
 // concurrent hook processes (parallel subagents) and same-process flows interleave
 // their read-modify-write cycles and silently drop each other's sessionTokens.
+// Mutations are session-scoped: only the calling session's record is rewritten;
+// sibling session records pass through untouched.
 async function mutateCompactPressureState(projectRoot, mutator, config = {}) {
   const runtimePaths = buildRuntimePaths(projectRoot);
   return withFileLock(runtimePaths.compactPressurePath, async () => {
-    const current = buildCompactPressureState(await readJson(runtimePaths.compactPressurePath, null), config);
+    const sessions = readPressureDocument(await readJson(runtimePaths.compactPressurePath, null));
+    const { id, record } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
+    const current = buildCompactPressureState(record, config);
     const next = mutator(current);
     const normalized = buildCompactPressureState(next, config);
-    await writeJson(runtimePaths.compactPressurePath, normalized);
+    sessions[id] = { ...normalized, updatedAt: Date.now() };
+    await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
   });
 }
@@ -1070,22 +1139,42 @@ async function mutateCompactPressureState(projectRoot, mutator, config = {}) {
 export async function writeCompactPressureState(projectRoot, state, config = {}) {
   const runtimePaths = buildRuntimePaths(projectRoot);
   return withFileLock(runtimePaths.compactPressurePath, async () => {
+    const sessions = readPressureDocument(await readJson(runtimePaths.compactPressurePath, null));
+    const { id } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
     const normalized = buildCompactPressureState(state, config);
-    await writeJson(runtimePaths.compactPressurePath, normalized);
+    sessions[id] = { ...normalized, updatedAt: Date.now() };
+    await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
   });
 }
 
+function pressureSessionConfig(payload = {}, config = {}) {
+  const sessionId = normalizeSessionId(payload?.sessionId) ?? normalizeSessionId(config?.sessionId);
+  return sessionId ? { ...config, sessionId } : config;
+}
+
 export async function updateCompactPressureFromPrompt(projectRoot, payload, config = {}) {
-  return mutateCompactPressureState(projectRoot, (current) => registerPromptPressure(current, payload, config), config);
+  return mutateCompactPressureState(
+    projectRoot,
+    (current) => registerPromptPressure(current, payload, config),
+    pressureSessionConfig(payload, config),
+  );
 }
 
 export async function updateCompactPressureFromOutput(projectRoot, payload, config = {}) {
-  return mutateCompactPressureState(projectRoot, (current) => registerOutputPressure(current, payload, config), config);
+  return mutateCompactPressureState(
+    projectRoot,
+    (current) => registerOutputPressure(current, payload, config),
+    pressureSessionConfig(payload, config),
+  );
 }
 
 export async function writeThresholdCompactPlan(projectRoot, plan, config = {}) {
-  return mutateCompactPressureState(projectRoot, (current) => registerThresholdCompactPlan(current, plan, config), config);
+  return mutateCompactPressureState(
+    projectRoot,
+    (current) => registerThresholdCompactPlan(current, plan, config),
+    pressureSessionConfig(plan, config),
+  );
 }
 
 async function loadRuntimeConfig(projectRoot) {
@@ -1141,6 +1230,16 @@ async function runCli() {
       return;
     }
 
+    // Session-scoped bookkeeping: every read/write in this branch targets the calling
+    // session's record, so a sibling session starting in the same project cannot zero
+    // this session's pressure history.
+    const sessionConfig = {
+      ...config,
+      sessionId: typeof payload.session_id === 'string' && payload.session_id.trim()
+        ? payload.session_id.trim()
+        : undefined,
+    };
+
     // Heal a stale counter BEFORE the phase is computed. Auto-compact paths that never
     // fire the PreCompact hook leave sessionTokens counting history that was already
     // summarised away — that phantom total is how a healthy session got hard-cap blocked.
@@ -1148,21 +1247,22 @@ async function runCli() {
     // automatic, so they are the correction signal here.
     try {
       const synced = await syncCompactPressureStateWithTranscript(
-        await readCompactPressureState(projectRoot, config),
-        config,
+        await readCompactPressureState(projectRoot, sessionConfig),
+        sessionConfig,
         payload.transcript_path,
       );
       if (synced.reset) {
-        await writeCompactPressureState(projectRoot, synced.state, config);
+        await writeCompactPressureState(projectRoot, synced.state, sessionConfig);
       }
     } catch { /* advisory healing only — never block the prompt over it */ }
 
     const nextState = await updateCompactPressureFromPrompt(projectRoot, {
       promptText,
+      sessionId: sessionConfig.sessionId,
       routingContext: routeState?.routingContext ?? {},
       previousContext: routeState?.previousContext ?? null,
       routeSummary: routeState?.routeSummary ?? null,
-    }, config);
+    }, sessionConfig);
 
     if (nextState.phase === 'hard') {
       process.stdout.write(

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

@@ -5,6 +5,7 @@ import fs from 'node:fs/promises';
 import fsSync from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { withFileLock } from './token-utils.mjs';
 
 const LEDGER_VERSION = 1;
 const RESUME_INTENT_VERSION = 1;
@@ -566,29 +567,38 @@ export function evaluateCompletion({ state = {}, ledger = {} } = {}) {
 }
 
 export async function incrementContinuation(projectRoot, payload = {}, ledger = null, requestKey = null) {
-  const current = ledger || await readExecutionLedger(projectRoot, payload) || freshLedger(payload, null, 'unknown');
-  // Mirror evaluateCompletion's staleness rule: a count minted by an earlier request must
-  // not be carried into the new request's budget, or the cap fires early (evaluate says 0,
-  // persist says 7) and the next request inherits a nearly exhausted budget.
-  const stale = requestKey
-    && current?.continuationRequestKey
-    && current.continuationRequestKey !== requestKey;
-  const next = {
-    ...current,
-    continuationCount: (stale ? 0 : Number(current.continuationCount || 0)) + 1,
-    ...(requestKey ? { continuationRequestKey: requestKey } : {}),
-    lastContinuationAt: Date.now(),
-    updatedAt: Date.now(),
-  };
-  await writeJsonAtomic(ledgerPath(projectRoot, payload), next);
-  return next;
+  const target = ledgerPath(projectRoot, payload);
+  // Locked re-read: parallel subagents firing Stop hooks share one ledger file, and a
+  // stale-snapshot rewrite would reset each other's continuationCount — the budget would
+  // never advance and the gate would keep issuing continuations.
+  return withFileLock(target, async () => {
+    const current = await readExecutionLedger(projectRoot, payload) || ledger || freshLedger(payload, null, 'unknown');
+    // Mirror evaluateCompletion's staleness rule: a count minted by an earlier request must
+    // not be carried into the new request's budget, or the cap fires early (evaluate says 0,
+    // persist says 7) and the next request inherits a nearly exhausted budget.
+    const stale = requestKey
+      && current?.continuationRequestKey
+      && current.continuationRequestKey !== requestKey;
+    const next = {
+      ...current,
+      continuationCount: (stale ? 0 : Number(current.continuationCount || 0)) + 1,
+      ...(requestKey ? { continuationRequestKey: requestKey } : {}),
+      lastContinuationAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    await writeJsonAtomic(target, next);
+    return next;
+  });
 }
 
 export async function markNotified(projectRoot, payload = {}, ledger = null) {
-  const current = ledger || await readExecutionLedger(projectRoot, payload) || freshLedger(payload, null, 'unknown');
-  const next = { ...current, notified: true, updatedAt: Date.now() };
-  await writeJsonAtomic(ledgerPath(projectRoot, payload), next);
-  return next;
+  const target = ledgerPath(projectRoot, payload);
+  return withFileLock(target, async () => {
+    const current = await readExecutionLedger(projectRoot, payload) || ledger || freshLedger(payload, null, 'unknown');
+    const next = { ...current, notified: true, updatedAt: Date.now() };
+    await writeJsonAtomic(target, next);
+    return next;
+  });
 }
 
 async function readStdin() {

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

@@ -1189,6 +1189,14 @@ async function main() {
 
   const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const config = await loadRuntimeConfig(projectRoot);
+  // Session-scoped pressure bookkeeping: output tokens must land in the calling
+  // session's record, never a sibling session's.
+  const sessionConfig = {
+    ...config,
+    sessionId: typeof payload.session_id === 'string' && payload.session_id.trim()
+      ? payload.session_id.trim()
+      : undefined,
+  };
   if (!shouldCompress(config)) {
     process.exit(0);
     return;
@@ -1247,7 +1255,7 @@ async function main() {
         tokensAfter: cached.tokensAfter ?? 0,
         savedTokens: cached.savedTokens ?? 0,
         exitCode,
-      }, config);
+      }, sessionConfig);
       process.stdout.write(String(cached.content));
       return;
     }
@@ -1345,7 +1353,7 @@ async function main() {
     tokensAfter: result.tokensAfter,
     savedTokens: result.savedTokens,
     exitCode,
-  }, config);
+  }, sessionConfig);
 
   if (config?.tokenPipeline?.promptCache) {
     await writePromptCacheEntry(projectRoot, {