@ngockhoale/ukit 2.3.7 → 2.3.8

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 All notable changes to UKit are documented here.
 
+## 2.3.8 - 2026-09-10
+
+Freeze-sweep wave 4: every fix in this release targets the "agent silently stops working"
+class — lost permission rules that turn into human-waiting prompts, a session start that
+wipes a sibling session's near-cap warnings, torn state files, and lost concurrency
+bookkeeping. All found by verified reproducers and fixed with regression coverage.
+
+**P1 — SessionStart wiped a sibling session's compact-pressure state.** The SessionStart
+reset hook deleted the whole project-wide `compact-pressure.json`, so starting a second
+session in the same project zeroed the first session's pressure history: its near-cap
+warnings stopped firing, it ran into the real context cap, and it stalled. Pressure state
+is now a session-keyed document (`{"v":2,"sessions":{<session_id>:{…}}}`) with the newest
+record's flat fields still projected at the top level for raw readers. Every writer and
+reader threads the hook payload's `session_id` (compact-threshold CLI, output-compression,
+reinject-context PreCompact, context-hardcap-gate); a brand-new session id starts clean
+and never inherits a sibling's totals; the reset hook removes only the calling session's
+record; sessions are pruned to the 8 most recent; a legacy flat file upgrades in place.
+Ships in both `src/core/compact/threshold.js` and the runtime mirror.
+
+**P1 — concurrent auto-allow invocations lost Bash permission rules.** The hook's
+read-modify-write of `settings.local.json` and `permission-usage.json` was unlocked, and
+30 concurrent invocations kept only 26/30 rules and 23/30 usage records — a lost rule
+means the next run of that command prompts for permission again, i.e. the agent sits
+waiting for a human click. Both files are now written inside one mkdir lock on
+`<permission-usage.json>.lock` (protocol-compatible with `withFileLock`, fail-open ≤5s,
+parent directory created before locking) with atomic tmp+rename writes, so Claude Code
+can never observe a torn settings file either — a torn parse would drop the entire allow
+list and prompt on every command. `auto-prune-bash.sh` now shares the same lock and
+atomic writes.
+
+**P2 — index cache writes lost entries under concurrency.** `cache-utils.mjs`
+read-modify-write cycles were unlocked: 20 concurrent writers kept 2 entries. All cache
+reads-modify-writes (write + touch paths) now run under `withFileLock` with atomic
+compact writes (cache files stay single-line JSON by contract).
+
+**P2 — verification-progress and execution-ledger counters lost concurrent updates.**
+`verification-guard.sh` now records attempts through a locked re-read + merge (sync
+`Atomics.wait` backoff so the hook's `process.exit` flow is untouched) and writes
+atomically; `execution-ledger.mjs`'s continuation/notified counters re-read inside
+`withFileLock` so parallel subagent Stop hooks cannot reset each other's budgets.
+
+Full suite: 81 files, 1,373 tests green, including two shuffled runs.
+
 ## 2.3.7 - 2026-09-10
 
 Bug-sweep wave 3: a data-loss escape in uninstall, cross-process races on shared runtime

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "2.3.7",
+  "version": "2.3.8",
   "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/compact/threshold.js

@@ -553,7 +553,72 @@ 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.
+// Mirrors templates/.claude/ukit/runtime/compact-threshold.mjs — keep in lockstep.
+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);
@@ -940,13 +1005,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 readJsonIfExists(runtimePaths.compactPressurePath), config);
+    const sessions = readPressureDocument(await readJsonIfExists(runtimePaths.compactPressurePath));
+    const { id, record } = pickPressureSession(sessions, normalizeSessionId(config?.sessionId));
+    const current = buildCompactPressureState(record, config);
     const next = mutator(current);
     const normalized = buildCompactPressureState(next, config);
-    await writeJson(runtimePaths.compactPressurePath, normalized);
+    sessions[id] = { ...normalized, updatedAt: Date.now() };
+    await writeJson(runtimePaths.compactPressurePath, projectPressureDocument(sessions));
     return normalized;
   });
 }
@@ -954,20 +1024,40 @@ 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 readJsonIfExists(runtimePaths.compactPressurePath));
+    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),
+  );
 }

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

@@ -1,6 +1,6 @@
 #!/bin/bash
 # PreToolUse hook: auto-add Bash(<binary>:*) allow rules for frequently used commands.
-# Optimized: fast-path grep to skip Node.js when rule already exists.
+# Settings/usage updates run as ONE locked, atomic read-modify-write (see node block).
 
 INPUT=$(cat)
 # jq is absent on stock macOS. Keep jq as the low-latency normal path, but fall back to
@@ -61,30 +61,22 @@ RULE="Bash(${BIN}:*)"
 NOW_UTC=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 MAX_RULES="${CLAUDE_AUTO_ALLOW_MAX_RULES:-150}"
 
-# Fast path: if rule already exists in allow list, just update usage and exit
-if [ -f "$SETTINGS_LOCAL" ] && grep -Fq -- "\"$RULE\"" "$SETTINGS_LOCAL" 2>/dev/null; then
-  # Only update usage timestamp (lighter than full Node.js logic)
-  node -e '
-    const fs = require("fs");
-    const usagePath = process.argv[1];
-    const rule = process.argv[2];
-    const nowUtc = process.argv[3];
-    if (!fs.existsSync(usagePath)) {
-      fs.mkdirSync(require("path").dirname(usagePath), { recursive: true });
-      fs.writeFileSync(usagePath, "{}");
-    }
-    try {
-      const usage = JSON.parse(fs.readFileSync(usagePath, "utf8"));
-      if (!usage.managedRules) usage.managedRules = {};
-      const prev = usage.managedRules[rule] || {};
-      usage.managedRules[rule] = { firstSeen: prev.firstSeen || nowUtc, lastSeen: nowUtc };
-      fs.writeFileSync(usagePath, JSON.stringify(usage, null, 2) + "\n");
-    } catch {}
-  ' "$USAGE_FILE" "$RULE" "$NOW_UTC" >/dev/null 2>&1 || true
-  exit 0
-fi
-
-# Slow path: rule is new, need full Node.js processing
+# Single locked read-modify-write for settings.local.json + permission-usage.json.
+#
+# Why the lock: parallel hook invocations (main session + subagents) each used to read a
+# stale snapshot and rewrite the whole file, silently dropping each other's allow rules
+# (verified: 30 concurrent invocations kept 26/30 rules and 23/30 usage records). A lost
+# rule means the NEXT invocation of that command prompts for permission again — the agent
+# stalls waiting for a human click. The lock protocol below is protocol-compatible with
+# runtime token-utils withFileLock / src/core/fileOps.js (mkdir-based `<file>.lock`),
+# with the usage file as the single serialization point for both files this hook writes.
+#
+# Why atomic writes: Claude Code re-reads settings.local.json to decide permissions.
+# A torn/partial write would fail JSON parsing and drop the ENTIRE allow list — every
+# command would prompt. tmp+rename makes readers see old-or-new, never half.
+#
+# Liveness over strictness: if the lock cannot be acquired within maxWaitMs the mutation
+# runs anyway (pre-lock behaviour) — this hook must never hang a PreToolUse chain.
 node -e '
 const fs = require("fs");
 const path = require("path");
@@ -105,66 +97,118 @@ function readJson(filePath, fallback) {
   }
 }
 
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  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;
+  }
+}
+
 function appendAudit(event, payload) {
   fs.appendFileSync(auditPath, JSON.stringify({ ts: nowUtc, event, ...payload }) + "\n");
 }
 
-const settingsDir = path.dirname(settingsPath);
-const usageDir = path.dirname(usagePath);
-fs.mkdirSync(settingsDir, { recursive: true });
-fs.mkdirSync(usageDir, { recursive: true });
-
-const settings = readJson(settingsPath, {});
-if (!settings.permissions || typeof settings.permissions !== "object") {
-  settings.permissions = {};
-}
-if (!Array.isArray(settings.permissions.allow)) {
-  settings.permissions.allow = [];
+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 usage = readJson(usagePath, {});
-if (!usage.managedRules || typeof usage.managedRules !== "object") {
-  usage.managedRules = {};
-}
+// The lock directory lives beside the usage file, so its parent must exist BEFORE the
+// lock is taken — a first-ever run in a fresh project would otherwise fail mkdir with
+// ENOENT, fail open, and race.
+fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+fs.mkdirSync(path.dirname(usagePath), { recursive: true });
 
-const allow = settings.permissions.allow;
-let changed = false;
+withLock(`${usagePath}.lock`, () => {
+  const settings = readJson(settingsPath, {});
+  if (!settings.permissions || typeof settings.permissions !== "object") {
+    settings.permissions = {};
+  }
+  if (!Array.isArray(settings.permissions.allow)) {
+    settings.permissions.allow = [];
+  }
 
-if (!allow.includes(rule)) {
-  allow.push(rule);
-  changed = true;
-  appendAudit("auto_add", { rule });
-}
+  const usage = readJson(usagePath, {});
+  if (!usage.managedRules || typeof usage.managedRules !== "object") {
+    usage.managedRules = {};
+  }
 
-const prevMeta = usage.managedRules[rule] || {};
-usage.managedRules[rule] = {
-  firstSeen: prevMeta.firstSeen || nowUtc,
-  lastSeen: nowUtc,
-};
+  const allow = settings.permissions.allow;
+  let settingsChanged = false;
 
-const managedSorted = Object.entries(usage.managedRules).sort((a, b) => {
-  const ta = Date.parse(a[1]?.lastSeen || "") || 0;
-  const tb = Date.parse(b[1]?.lastSeen || "") || 0;
-  return tb - ta;
-});
+  if (!allow.includes(rule)) {
+    allow.push(rule);
+    settingsChanged = true;
+    appendAudit("auto_add", { rule });
+  }
 
-if (managedSorted.length > maxRules) {
-  const evict = managedSorted.slice(maxRules);
-  for (const [evictRule] of evict) {
-    delete usage.managedRules[evictRule];
-    const idx = allow.indexOf(evictRule);
-    if (idx !== -1) {
-      allow.splice(idx, 1);
-      changed = true;
+  const prevMeta = usage.managedRules[rule] || {};
+  usage.managedRules[rule] = {
+    firstSeen: prevMeta.firstSeen || nowUtc,
+    lastSeen: nowUtc,
+  };
+
+  const managedSorted = Object.entries(usage.managedRules).sort((a, b) => {
+    const ta = Date.parse(a[1]?.lastSeen || "") || 0;
+    const tb = Date.parse(b[1]?.lastSeen || "") || 0;
+    return tb - ta;
+  });
+
+  if (managedSorted.length > maxRules) {
+    const evict = managedSorted.slice(maxRules);
+    for (const [evictRule] of evict) {
+      delete usage.managedRules[evictRule];
+      const idx = allow.indexOf(evictRule);
+      if (idx !== -1) {
+        allow.splice(idx, 1);
+        settingsChanged = true;
+      }
+      appendAudit("auto_prune_cap", { rule: evictRule, maxRules });
     }
-    appendAudit("auto_prune_cap", { rule: evictRule, maxRules });
   }
-}
 
-if (changed) {
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-}
-fs.writeFileSync(usagePath, JSON.stringify(usage, null, 2) + "\n");
+  if (settingsChanged) {
+    writeJsonAtomic(settingsPath, settings);
+  }
+  writeJsonAtomic(usagePath, usage);
+}).catch(() => {});
 ' "$SETTINGS_LOCAL" "$USAGE_FILE" "$AUDIT_FILE" "$RULE" "$NOW_UTC" "$MAX_RULES" >/dev/null 2>&1 || true
 
 exit 0

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

@@ -15,6 +15,7 @@ NOW_UTC=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
 node -e '
 const fs = require("fs");
+const path = require("path");
 
 const settingsPath = process.argv[1];
 const usagePath = process.argv[2];
@@ -31,45 +32,102 @@ function readJson(filePath) {
   }
 }
 
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  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;
+  }
+}
+
 function appendAudit(event, payload) {
   fs.appendFileSync(auditPath, JSON.stringify({ ts: nowUtc, event, ...payload }) + "\n");
 }
 
-const settings = readJson(settingsPath);
-const usage = readJson(usagePath);
-if (!settings || !usage) process.exit(0);
-if (!settings.permissions || typeof settings.permissions !== "object") process.exit(0);
-if (!Array.isArray(settings.permissions.allow)) process.exit(0);
-if (!usage.managedRules || typeof usage.managedRules !== "object") process.exit(0);
-
-const allow = settings.permissions.allow;
-let changedSettings = false;
-let prunedCount = 0;
-
-for (const [rule, meta] of Object.entries(usage.managedRules)) {
-  const lastSeen = Date.parse(meta?.lastSeen || "");
-  if (!Number.isFinite(lastSeen) || lastSeen >= cutoff) continue;
-
-  const idx = allow.indexOf(rule);
-  if (idx !== -1) {
-    allow.splice(idx, 1);
-    changedSettings = true;
+// 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
+// ENTIRE allow list and every command would prompt again. Fail-open after 5s: a hook
+// must never hang the chain.
+async function withLock(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;
+      await new Promise((resolve) => setTimeout(resolve, 3 + Math.floor(Math.random() * 9)));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    if (held) {
+      try {
+        fs.rmdirSync(lockPath);
+      } catch {}
+    }
   }
-  delete usage.managedRules[rule];
-  prunedCount += 1;
-  appendAudit("auto_prune_ttl", { rule, ttlDays });
 }
 
-usage.lastPruneAt = nowUtc;
+withLock(`${usagePath}.lock`, async () => {
+  const settings = readJson(settingsPath);
+  const usage = readJson(usagePath);
+  if (!settings || !usage) return;
+  if (!settings.permissions || typeof settings.permissions !== "object") return;
+  if (!Array.isArray(settings.permissions.allow)) return;
+  if (!usage.managedRules || typeof usage.managedRules !== "object") return;
 
-if (changedSettings) {
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-}
-fs.writeFileSync(usagePath, JSON.stringify(usage, null, 2) + "\n");
+  const allow = settings.permissions.allow;
+  let changedSettings = false;
+  let prunedCount = 0;
 
-if (prunedCount > 0) {
-  appendAudit("auto_prune_summary", { prunedCount, ttlDays });
-}
+  for (const [rule, meta] of Object.entries(usage.managedRules)) {
+    const lastSeen = Date.parse(meta?.lastSeen || "");
+    if (!Number.isFinite(lastSeen) || lastSeen >= cutoff) continue;
+
+    const idx = allow.indexOf(rule);
+    if (idx !== -1) {
+      allow.splice(idx, 1);
+      changedSettings = true;
+    }
+    delete usage.managedRules[rule];
+    prunedCount += 1;
+    appendAudit("auto_prune_ttl", { rule, ttlDays });
+  }
+
+  usage.lastPruneAt = nowUtc;
+
+  if (changedSettings) {
+    writeJsonAtomic(settingsPath, settings);
+  }
+  writeJsonAtomic(usagePath, usage);
+
+  if (prunedCount > 0) {
+    appendAudit("auto_prune_summary", { prunedCount, ttlDays });
+  }
+}).catch(() => {});
 ' "$SETTINGS_LOCAL" "$USAGE_FILE" "$AUDIT_FILE" "$TTL_DAYS" "$NOW_UTC" >/dev/null 2>&1 || true
 
 exit 0

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

@@ -87,6 +87,15 @@ function readRunCursor() {
 
 (async () => {
   const config = readJsonSafe(path.join(projectRoot, '.ukit', 'storage', 'config.json'), {}) || {};
+  // Session-scoped pressure bookkeeping: the gate decides for THIS session's record, so a
+  // sibling session starting (SessionStart reset) or compacting never trips or clears
+  // this gate for the wrong session.
+  const sessionConfig = {
+    ...config,
+    sessionId: typeof payload.session_id === 'string' && payload.session_id.trim()
+      ? payload.session_id.trim()
+      : undefined,
+  };
   if (config?.compact?.hardCapBlock === false) {
     process.exit(0);
     return;
@@ -111,14 +120,14 @@ function readRunCursor() {
   // bricks a healthy session at this cap. The transcript's own compact_boundary entries
   // are the reliable record of real compactions, so sync before deciding, and persist the
   // reset so it re-arms exactly once per boundary instead of disabling the gate.
-  let state = mod.buildCompactPressureState(rawState, config);
+  let state = mod.buildCompactPressureState(rawState, sessionConfig);
   try {
-    const synced = await mod.syncCompactPressureStateWithTranscript(rawState, config, payload.transcript_path);
+    const synced = await mod.syncCompactPressureStateWithTranscript(state, sessionConfig, payload.transcript_path);
     if (synced.reset) {
-      state = await mod.writeCompactPressureState(projectRoot, synced.state, config);
+      state = await mod.writeCompactPressureState(projectRoot, synced.state, sessionConfig);
     }
   } catch {
-    state = mod.buildCompactPressureState(rawState, config);
+    state = mod.buildCompactPressureState(rawState, sessionConfig);
   }
   const thresholds = mod.buildCompactThresholds(config);