@ngockhoale/ukit 2.3.7 → 2.3.9

package/CHANGELOG.md

@@ -2,6 +2,77 @@
 
 All notable changes to UKit are documented here.
 
+## 2.3.9 - 2026-09-10
+
+Freeze-sweep wave 5: fixes for completion-gate loops, worker-agent dead ends, and malformed
+context-cap configuration that could otherwise halt all mutation progress.
+
+**P1 — clean `find-cause` audits were forced into a Stop-hook loop.** A recommend-only
+investigation that found no actionable bug still required write and verification evidence, so
+the completion gate blocked the honest outcome and demanded a fabricated edit. The execution
+ledger now permits that narrow clean-audit outcome while retaining normal recovery blocks after
+a failed verification or incomplete mutation.
+
+**P1 — routed workers could wait for a user they cannot contact.** The Claude Code and omp
+`bug-debugger` / `feature-implementer` agents instructed workers to “ask the user” on unclear
+or non-reproducible work. They now perform one bounded next diagnostic step and return a
+structured `STATUS: BLOCKED` report with the exact missing artifact or decision to the parent
+agent, which owns user communication.
+
+**P1 — malformed context-cap configuration could brick mutations.** Invalid
+`compact.hardCapTokens` could collapse the cap to one token, invalid
+`hardCapGraceCalls` could eliminate the landing window, and wrong-shaped present
+`hardCapBlock` values could unexpectedly leave the hard gate enabled. The shared source/runtime
+threshold logic and Claude hook now accept only positive integer budgets, while malformed
+non-boolean `hardCapBlock` values fail open; the documented absent-key default remains enabled.
+The context-window advisory uses the same hard-cap validation. Regression coverage includes
+negative/zero/fraction/string/boolean/null budgets and malformed toggle values.
+
+Full suite: 81 files, 1,396 tests green.
+
+## 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.9",
   "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

@@ -35,6 +35,15 @@ function finiteNumber(value, fallback = 0) {
   return Number.isFinite(number) ? number : fallback;
 }
 
+// A malformed hard cap must fail back to a safe ceiling, never collapse to one token and
+// brick every Edit/Write/Bash call. Unlike token estimates, configuration is an operator
+// contract: accept only whole positive token counts.
+function positiveInteger(value, fallback) {
+  return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0
+    ? value
+    : fallback;
+}
+
 function uniqueStrings(values) {
   const seen = new Set();
   const unique = [];
@@ -434,11 +443,15 @@ export function buildCompactThresholds(config = {}) {
   );
   const hardThreshold = Math.max(softThreshold + 1, Math.round(softThreshold * 1.6));
   const baselineTokens = Math.max(120, Math.min(18_000, Math.round(softThreshold * 0.18)));
+  // Keep the source mirror's config contract aligned with the installed runtime: malformed
+  // caps fall back to a safe ceiling rather than turning every mutation into an over-cap call.
+  const hardCapTokens = positiveInteger(config?.compact?.hardCapTokens, loadShippedCompactBudget().hardCapTokens);
 
   return {
     softThreshold,
     hardThreshold,
     baselineTokens,
+    hardCapTokens,
   };
 }
 
@@ -553,7 +566,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 +1018,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 +1037,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/agents/bug-debugger.md

@@ -18,7 +18,7 @@ Systematic debugging — understand before fixing.
 
 - Run the failing command/action.
 - Capture exact error message and stack trace.
-- If not reproducible → document conditions and ask user.
+- If not reproducible → document conditions, run the next most-discriminating bounded repro, then report any exact missing user-only artifact/permission to the parent agent. Never wait for or ask a user directly — you are a worker.
 
 ### 2. Trace Root Cause
 
@@ -83,4 +83,4 @@ Daily mode: skip. Handoff mode: set task status `pending_review` in `INDEX.md`;
   - non-trivial bug: `docs/MEMORY.md` + `docs/PROJECT.md` + `docs/CODE_MAP.md`
   - read `docs/WORKLOG.md` only recent relevant entries
 - Keep fix scope minimal — no drive-by refactors.
-- If root cause is unclear after 5 minutes of tracing → ask user for more context.
+- If root cause is unclear after 5 minutes of tracing → try one bounded alternative hypothesis/repro, then report precise evidence plus the smallest needed missing context to the parent agent. Never wait for or ask a user directly — the parent owns user communication.

package/templates/.claude/agents/feature-implementer.md

@@ -12,7 +12,9 @@ Implement requested behavior with minimal scope drift.
 - **Daily/ad-hoc mode** (DEFAULT): task didn't come from `docs/AI_HANDOFF/` → use the original lightweight workflow. Tests only when touched code already has coverage. No reviewer trigger.
 - **Handoff mode**: task file is `docs/AI_HANDOFF/tasks/TASK-xxx.md` OR user explicitly invokes handoff (e.g. "execute task TASK-001") → activate full Quality Gate: test-first → green → reviewer.
 
-If unsure which mode applies, ask the user. Don't apply Handoff mode rules to a quick one-off fix.
+If unsure which mode applies, default to Daily/ad-hoc mode unless the task path or prompt
+explicitly selects Handoff. Do not ask a user — you are a worker; report the ambiguity and
+reasoning to the parent agent so it can decide whether to re-route.
 
 **In Handoff mode you are running unattended — ask nothing.** You were spawned by an
 orchestrator driving a pipeline; there is no human in your conversation to answer, and a
@@ -33,7 +35,7 @@ and even then, report it, don't ask about it.
   - non-trivial: `docs/MEMORY.md` + `docs/PROJECT.md` + `docs/CODE_MAP.md`
 - Identify target files and existing patterns.
 - If task came from handoff, read `tasks/TASK-xxx.md` and locate its **Test Plan** + **Verification Commands**.
-- Daily mode: if confidence is low or risk is high, ask one short clarifying question before deeper analysis. Handoff mode: do not ask — decide and record the decision (see above).
+- Daily mode: if confidence is low or risk is high, inspect the next bounded source/context signal and hand back a concise `STATUS: BLOCKED` report with the exact missing decision or artifact if confidence remains low. Do not ask a user directly. Handoff mode: do not ask — decide and record the decision (see above).
 
 ### 2. Plan Approach (< 1 minute)
 
@@ -44,7 +46,7 @@ and even then, report it, don't ask about it.
 
 - Write the test(s) from §2 / from task Test Plan.
 - Run them: must FAIL for the expected reason. Capture output.
-- If test passes immediately → test is wrong or behavior already exists. Fix the test or stop and report.
+- If test passes immediately → test is wrong or behavior already exists. Fix the test; if the intended behavior cannot be inferred, hand back `STATUS: BLOCKED` with the observed behavior and the smallest decision the parent must resolve. Never silently stop.
 - **Daily mode**: skip this step unless touched code already has tests (then follow original rule).
 
 

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