@awak-app/simy-cli 0.5.60 → 0.5.62

package/README.md

@@ -631,3 +631,20 @@ cross-view consistency. The workflow requires independent design, implementation
 To-Be and PR reviews, plus explicitly opted-in SQM before and after PR creation.
 The [workflow reference](src/orchestrator/delivery/references/shared-system-specifications.md)
 explains baseline updates, historical regression coverage and evidence limits.
+
+
+### Desktop SQM history
+
+SQM Tasks has separate **Analysis** and **Checks** lists on macOS and Windows.
+Analysis retains local review summaries; Checks retains both `simy sqm min-check`
+and `simy sqm check` outcomes, including checks run by the Delivery Loop.
+Each list keeps the latest 100 runs under `SIMY_HOME/sqm-history` (default
+`~/.simy/sqm-history`), isolated by web origin, account and organization.
+History remains visible with local analysis off and after restarting. A saved
+in-flight analysis is shown as Interrupted until this client claims it again;
+it does not contribute to the running count. The web workspace owns retry status.
+
+Only summary metadata is retained, without analysis prompts, source inputs,
+model responses or credentials. Historical summaries are not a replacement for
+signed proof files or delivery acceptance. Records from versions that kept
+analysis only in memory cannot be recovered after that process exits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.60",
+  "version": "0.5.62",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -40,7 +40,7 @@
     "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
-    "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
+    "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/history-store.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/claude-parity-runtime-e2e.js && node --check ./scripts/claude-plugin-runtime-e2e.js",
     "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/codex-plugins/simy/hooks/dev-work.mjs && node --check ./src/dev-work-events.js && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js && node --check ./src/codex-plugins/simy/hooks/delivery-loop.mjs && node --check ./src/delivery-hooks/command.js && node --check ./src/delivery-hooks/desktop.js && node --check ./src/delivery-hooks/supervisor.js && node --check ./src/session-supervision/automatic-continuation.js",
     "check:package": "node ./scripts/check-package-contents.js",

package/src/agent.js

@@ -1,3 +1,4 @@
+import { createSqmHistoryStore, projectSqmHistory, sqmHistoryScope } from "./sqm/history-store.js";
 import { createDesktopAccessPolicy, desktopAccessReady, requireDesktopAccess } from './desktop-access.js';
 import { readSqmEnabled, writeSqmEnabled } from "./desktop-sqm-settings.js";
 import { createServer } from "node:http";
@@ -287,6 +288,7 @@ export async function startAgent({
   };
   refreshAvailableCapabilities();
   let durableLocalTaskWorker = null;
+  const sqmHistory = createSqmHistoryStore({ root: sessionRoot });
   let sqmLocalReviewWorker = null;
   let codexWorkPatternSync = null;
   let codexWorkPatternSyncInFlight = null;
@@ -541,7 +543,7 @@ export async function startAgent({
           const remoteRun = restoreRun({
             snapshot, session, apiOrigin,
             localPath: repository?.local_path || null,
-            localStateRoot: codingRunStateRoot,
+            localStateRoot: codingRunStateRoot, sqmHistoryRoot: sessionRoot,
           });
           Object.assign(localRun, {
             request: remoteRun.request,
@@ -565,7 +567,7 @@ export async function startAgent({
         session,
         apiOrigin,
         localPath: repository?.local_path || null,
-        localStateRoot: codingRunStateRoot,
+        localStateRoot: codingRunStateRoot, sqmHistoryRoot: sessionRoot,
       });
       registry.create(restoredRun);
       restored = true;
@@ -597,7 +599,7 @@ export async function startAgent({
         const run = restoreRun({
           snapshot, session, apiOrigin,
           localPath: repository?.local_path || null,
-          localStateRoot: codingRunStateRoot,
+          localStateRoot: codingRunStateRoot, sqmHistoryRoot: sessionRoot,
         });
         // Keep the persisted timestamp until the Web ledger has been compared.
         // Publishing recovery here would make an older local record look newest.
@@ -836,6 +838,9 @@ export async function startAgent({
         return (dependencies.runSqmLocalReview || ((value, selected, options) => runStructuredProviderReview(selected, value, options)))(request, provider, { beforeDispatch });
       },
       onChange: notifyDesktopStatusChange,
+      getHistoryScope: () => sqmHistoryScope(apiOrigin, session),
+      recordHistory: (scope, item) => sqmHistory.record(scope, item),
+      onHistoryError: () => { if (!quiet) console.error("Could not save the local SQM analysis history."); },
       getProvider: () => !desktopWorkAllowed() || availableCapabilities?.features?.sqm_local_review !== true ? null : ["codex", "claude"].find(
         (provider) => availableCapabilities?.backends?.[provider] === true &&
           providerStatuses[provider]?.state === "ready",
@@ -1869,7 +1874,7 @@ export async function startAgent({
           },
           session,
           apiOrigin,
-          localStateRoot: codingRunStateRoot,
+          localStateRoot: codingRunStateRoot, sqmHistoryRoot: sessionRoot,
         });
         try {
           await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
@@ -2213,6 +2218,12 @@ export async function startAgent({
   server.on("close", () => {
     void shutdown().catch((error) => reportDurableLocalTaskError(error, quiet));
   });
+  const currentHistoryScope = () => isSessionValid(session, Date.now(), apiOrigin) ? sqmHistoryScope(apiOrigin, session) : null;
+  const historyForCurrentScope = async () => {
+    const scope = currentHistoryScope();
+    const items = await sqmHistory.items(scope).catch(() => []);
+    return JSON.stringify(scope) === JSON.stringify(currentHistoryScope()) ? items : [];
+  };
   const getDesktopStatus = async () => {
     const auth = desktopAuthStatus(session, { webOrigin: apiOrigin });
     if (auth.state === "signed_in" && organizationState === "unknown") void refreshOrganizations();
@@ -2240,7 +2251,7 @@ export async function startAgent({
         activeJobId: sqmLocalReviewWorker?.snapshot?.().active_job_id ?? null,
         issue: sqmLocalReviewWorker?.snapshot?.().issue ?? null,
         providerReady: [codex, claude].some(provider => provider?.state === "ready") },
-      sqmTasks: sqmLocalReviewWorker?.desktopTasks?.() ?? { activeCount: 0, items: [] },
+      ...projectSqmHistory(await historyForCurrentScope(), sqmLocalReviewWorker?.desktopTasks?.()),
       update: updateManager?.snapshot?.() ?? null,
       codex,
       claude,
@@ -2286,7 +2297,16 @@ export async function startAgent({
       void heartbeat().catch(error => reportHeartbeatError(error, quiet));
     },
     getDesktopStatus,
-    getDesktopTask: (key) => sqmLocalReviewWorker?.desktopTaskDetail?.(key) ?? desktopTaskDetail([registry, directRegistry, localTaskRegistry], key),
+    getDesktopTask: async (key) => {
+      if (key?.startsWith("sqm:") || key?.startsWith("sqm-check:")) {
+        const scope = currentHistoryScope();
+        if (!scope) return null;
+        const detail = await sqmHistory.detail(scope, key).catch(() => null);
+        if (JSON.stringify(scope) !== JSON.stringify(currentHistoryScope())) return null;
+        return sqmLocalReviewWorker?.desktopTaskDetail?.(key) ?? detail;
+      }
+      return desktopTaskDetail([registry, directRegistry, localTaskRegistry], key);
+    },
     async refreshDesktopStatus() {
       if (isSessionValid(session, Date.now(), apiOrigin)) {
         await heartbeat().catch((error) => reportHeartbeatError(error, quiet));
@@ -2350,7 +2370,7 @@ export async function startAgent({
             });
         const runId = String(remoteRun?.id || "");
         if (!runId) throw new Error("SIMY Web did not return an Agentic Loop run id.");
-        const run = createRun({ runId, request, session, apiOrigin, localStateRoot: codingRunStateRoot });
+        const run = createRun({ runId, request, session, apiOrigin, localStateRoot: codingRunStateRoot, sqmHistoryRoot: sessionRoot });
         await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
         registry.create(run);
         await authorizeDesktopWork(scope);

package/src/backend-executable.js

@@ -25,11 +25,15 @@ export async function resolveBackendExecutable(backend, options = {}) {
 
 export async function inspectBackendExecutable(
   backend,
-  { spawnImpl = spawn, candidates = backendCandidates(backend), timeoutMs = 5_000 } = {},
+  { spawnImpl = spawn, candidates = backendCandidates(backend), timeoutMs = 5_000, signal } = {},
 ) {
+  const assertActive = () => { if (signal?.aborted) throw Object.assign(new Error('Backend inspection was cancelled.'), { code: 'cancelled' }); };
+  assertActive();
   const policy = versionPolicy(backend);
   for (const candidate of [...new Set(candidates.filter(Boolean))]) {
-    const probe = await probeExecutable(candidate, { spawnImpl, timeoutMs });
+    assertActive();
+    const probe = await probeExecutable(candidate, { spawnImpl, timeoutMs, signal });
+    assertActive();
     if (!probe.available) continue;
     const installedVersion = parseBackendVersion(probe.output);
     if (!installedVersion) {
@@ -115,31 +119,42 @@ function numericVersionParts(value) {
   return match.slice(1).map(Number);
 }
 
-function probeExecutable(command, { spawnImpl, timeoutMs }) {
+function probeExecutable(command, { spawnImpl, timeoutMs, signal }) {
   return new Promise((resolve) => {
-    let settled = false;
-    let timeout;
-    let output = "";
+    let settled = false, terminating = false;
+    let timeout, force, limit;
+    let output = Buffer.alloc(0);
     const child = spawnImpl(command, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.setEncoding?.("utf8");
-    child.stderr?.setEncoding?.("utf8");
-    child.stdout?.on?.("data", (chunk) => {
-      output += chunk;
-    });
-    child.stderr?.on?.("data", (chunk) => {
-      output += chunk;
-    });
-    const finish = (available) => {
+    const capture = chunk => {
+      // Version probes need a tiny prefix. Drain noisy executables without
+      // retaining unbounded stdout/stderr in the desktop background process.
+      const remaining = 64 * 1024 - output.length;
+      if (remaining > 0) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk).slice(0, remaining));
+        output = Buffer.concat([output, bytes.subarray(0, remaining)]);
+      }
+    };
+    const finish = available => {
       if (settled) return;
       settled = true;
-      if (timeout) clearTimeout(timeout);
-      resolve({ available, output: output.trim() });
+      clearTimeout(timeout); clearTimeout(force); clearTimeout(limit);
+      signal?.removeEventListener('abort', cancel);
+      resolve({ available: available && !terminating, output: output.toString('utf8').trim() });
     };
-    timeout = setTimeout(() => {
+    const cancel = () => {
+      if (settled || terminating) return;
+      terminating = true; clearTimeout(timeout);
+      // Install timers before kill because a fake/fast child may close inline.
+      force = setTimeout(() => { child.kill?.("SIGKILL"); }, 2_000);
+      limit = setTimeout(() => finish(false), 3_000);
       child.kill?.("SIGTERM");
-      finish(false);
-    }, timeoutMs);
+    };
+    child.stdout?.on?.("data", capture);
+    child.stderr?.on?.("data", capture);
     child.on("error", () => finish(false));
-    child.on("close", (code) => finish(code === 0));
+    child.on("close", code => finish(code === 0));
+    timeout = setTimeout(cancel, timeoutMs);
+    signal?.addEventListener('abort', cancel, { once: true });
+    if (signal?.aborted) cancel();
   });
 }

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.60";
+export const CLI_VERSION = "0.5.62";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Standalone by design: this exact module is shipped to both provider plugins.
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { execFile } from 'node:child_process';
@@ -28,8 +28,22 @@ export function recordPath(root, provider, session) {
   return join(root, `${digest(`${provider}\0${session}`)}.json`);
 }
 async function read(file) {
-  try { const raw = await readFile(file, 'utf8'); if (Buffer.byteLength(raw) > MAX_BYTES) throw new Error('State exceeds limit.'); return JSON.parse(raw); }
-  catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+  let handle;
+  try {
+    handle = await open(file, 'r');
+    // Read a bounded allocation even when an external writer supplies a huge
+    // file. The extra byte distinguishes the limit from a truncated document.
+    const bytes = Buffer.alloc(MAX_BYTES + 1);
+    let size = 0;
+    while (size < bytes.length) {
+      const result = await handle.read(bytes, size, bytes.length - size, null);
+      if (!result.bytesRead) break;
+      size += result.bytesRead;
+    }
+    if (size > MAX_BYTES) throw new Error('State exceeds limit.');
+    return JSON.parse(bytes.subarray(0, size).toString('utf8'));
+  } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  finally { await handle?.close(); }
 }
 async function lockOwner(lock) {
   try {
@@ -51,8 +65,20 @@ async function ownerDefinitelyDead(owner, inspectProcess) {
 async function releaseStateLock(lock, token) {
   if ((await lockOwner(lock))?.token === token) await rm(lock, { recursive: true, force: true });
 }
+let ownProcessIdentity = null, ownProcessProbe = null;
+async function stateWriterIdentity(inspectProcess) {
+  if (inspectProcess !== processIdentity) return inspectProcess(process.pid);
+  if (ownProcessIdentity) return ownProcessIdentity;
+  if (!ownProcessProbe) ownProcessProbe = processIdentity(process.pid).then(identity => {
+    // Only this running process's positive lifetime identity is immutable.
+    // Unknown results and every external/lock-owner inspection remain fresh.
+    if (identity) ownProcessIdentity = identity;
+    return identity;
+  }).finally(() => { ownProcessProbe = null; });
+  return ownProcessProbe;
+}
 async function acquireStateLock(lock, inspectProcess, depth = 0) {
-  const owner = { pid: process.pid, identity: await inspectProcess(process.pid), token: randomUUID() };
+  const owner = { pid: process.pid, identity: await stateWriterIdentity(inspectProcess), token: randomUUID() };
   const create = async (reclaiming = false) => {
     await mkdir(lock, { mode: 0o700 });
     try { await writeFile(join(lock, 'owner.json'), JSON.stringify(owner), { mode: 0o600, flag: 'wx' }); }
@@ -102,7 +128,9 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
   const lockToken = await acquireStateLock(lock, inspectProcess);
   let temporary;
   try {
-    const next = await mutate(await read(file));
+    const previous = await read(file);
+    const previousBytes = previous === null ? null : JSON.stringify(previous);
+    const next = await mutate(previous);
     if (next) {
       // Older file_equals drafts used `path`, which an older verifier could
       // mistake for file_exists. Persist only the distinct exactPath field.
@@ -112,9 +140,10 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
           delete criterion.check.path;
         }
       }
-      temporary = `${file}.${randomUUID()}.tmp`;
       const serialized = JSON.stringify(next);
       if (Buffer.byteLength(serialized) > MAX_BYTES) throw new Error('Delivery state exceeds 64 KiB; reduce task details.');
+      if (serialized === previousBytes) return next;
+      temporary = `${file}.${randomUUID()}.tmp`;
       await writeFile(temporary, serialized, { mode: 0o600 });
       await rename(temporary, file);
     }
@@ -128,13 +157,68 @@ export async function readRecord(root = rootDirectory(), provider, session) {
     return record?.schemaVersion === 1 && record.provider === provider && record.session === session ? record : null;
   } catch { return null; } // Match listRecords' treatment of unreadable records.
 }
-export async function listRecords(root = rootDirectory()) {
-  let names; try { names = await readdir(root); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
-  const results = await Promise.all(names.filter(n => /^[a-f0-9]{64}\.json$/.test(n)).slice(0, 500).map(async n => {
-    try { const r = await read(join(root, n)); return r?.schemaVersion === 1 && recordPath(root, r.provider, r.session) === join(root, n) ? r : null; } catch { return null; }
+const RECORD_NAME = /^[a-f0-9]{64}\.json$/;
+const RECORD_CACHE_LIMIT = 500;
+const READ_CONCURRENCY = 8;
+async function recordNames(root) {
+  try { return (await readdir(root)).filter(name => RECORD_NAME.test(name)).sort(); }
+  catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+}
+async function mapRecordNames(names, visit) {
+  const results = new Array(names.length);
+  let cursor = 0;
+  await Promise.all(Array.from({ length: Math.min(READ_CONCURRENCY, names.length) }, async () => {
+    while (cursor < names.length) { const index = cursor++; results[index] = await visit(names[index]); }
   }));
   return results.filter(Boolean);
 }
+async function readNamedRecord(root, name) {
+  try {
+    const path = join(root, name), record = await read(path);
+    return record?.schemaVersion === 1 && recordPath(root, record.provider, record.session) === path ? record : null;
+  } catch { return null; }
+}
+export async function listRecords(root = rootDirectory()) {
+  return mapRecordNames(await recordNames(root), name => readNamedRecord(root, name));
+}
+
+// A shared candidate/display index, never mutation authority. Every list checks
+// metadata so external hooks, removals and direct writes invalidate cached JSON.
+// Fresh execution reads and updateRecord locks remain independent of this index.
+export function createRecordReader(root = rootDirectory()) {
+  const cache = new Map();
+  let inFlight = null, closed = false;
+  const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeNs, info.ctimeNs].join(':');
+  const scan = async () => {
+    const names = await recordNames(root), live = new Set(names.slice(0, RECORD_CACHE_LIMIT));
+    for (const name of cache.keys()) if (!live.has(name)) cache.delete(name);
+    return mapRecordNames(names, async name => {
+      const path = join(root, name);
+      try {
+        const before = await stat(path, { bigint: true }), key = fingerprint(before);
+        const cached = cache.get(name);
+        if (cached?.key === key) return cached.record;
+        const record = before.size <= BigInt(MAX_BYTES) ? await readNamedRecord(root, name) : null;
+        // Do not retain a value when a write races the read; the next list must
+        // inspect it again. This also prevents malformed transient JSON sticking.
+        const after = await stat(path, { bigint: true });
+        if (live.has(name) && fingerprint(after) === key) cache.set(name, { key, record });
+        else cache.delete(name);
+        return record;
+      } catch { cache.delete(name); return null; }
+    });
+  };
+  return {
+    async list() {
+      if (closed) return [];
+      if (!inFlight) inFlight = scan().finally(() => { inFlight = null; });
+      // Consumers can decorate/mutate their own snapshots without corrupting the
+      // cached records or a simultaneous caller's view.
+      return structuredClone(await inFlight);
+    },
+    async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); },
+  };
+}
 function positive(value, fallback, max) {
   if (value === undefined) return fallback;
   if (!Number.isSafeInteger(value) || value < 1 || value > max) throw new Error('Invalid delivery budget.');
@@ -1064,12 +1148,16 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
     }
   }
 }
-export async function reconcileRecords({ root = rootDirectory(), now = Date.now(), inspectProcess = processIdentity } = {}) {
-  const records = await listRecords(root);
+export async function reconcileRecords({ root = rootDirectory(), now = Date.now(), inspectProcess = processIdentity, records: suppliedRecords } = {}) {
+  const records = suppliedRecords || await listRecords(root);
+  const reconciled = [];
   for (const record of records) {
-    if (!record.run || TERMINAL.has(record.run.state)) continue;
+    // Paused runs have no reconciliation transition: budget enforcement excludes
+    // them, process-exit checks only apply to active runs, and no notification
+    // is generated. Resume/control still reread and validate the exact record.
+    if (!record.run || TERMINAL.has(record.run.state) || record.run.state === 'paused') { reconciled.push(record); continue; }
     const observed = record.process ? await inspectProcess(record.process.pid) : null;
-    await updateRecord(root, record.provider, record.session, async current => {
+    const next = await updateRecord(root, record.provider, record.session, async current => {
       if (!current?.run || TERMINAL.has(current.run.state)) return current;
       const run = current.run;
       if (run.state === 'verification_pending' && run.managed) {
@@ -1084,9 +1172,10 @@ export async function reconcileRecords({ root = rootDirectory(), now = Date.now(
       }
       notifyState(run, now);
       return current;
-    }).catch(() => {});
+    }).catch(() => readRecord(root, record.provider, record.session));
+    if (next) reconciled.push(next);
   }
-  return listRecords(root);
+  return reconciled;
 }
 export async function main(provider) {
   let raw = '';

package/src/delivery-hooks/desktop.js

@@ -19,8 +19,10 @@ function associationStatus(association) {
         projectId: binding.action.projectId, projectName: binding.action.projectName } : null } : null };
 }
 
-export async function deliveryHookStatus({ root = rootDirectory(), now = Date.now() } = {}) {
-  const records = await reconcileRecords({ root, now });
+export async function deliveryHookStatus({ root = rootDirectory(), now = Date.now(), records: suppliedRecords } = {}) {
+  // Display callers can reuse the host frame snapshot. Execution maintenance
+  // owns reconciliation; the standalone status command retains its fresh path.
+  const records = suppliedRecords ?? await reconcileRecords({ root, now });
   return {
     providers: Object.fromEntries(['codex', 'claude'].map(provider => {
       const latest = records.filter(r => r.provider === provider && Number.isFinite(r.observedAt)).sort((a, b) => b.observedAt - a.observedAt)[0];

package/src/delivery-hooks/supervisor.js

@@ -18,6 +18,20 @@ function providerFailureReason(code) {
   if (code === 'turn_failed') return 'The Codex turn did not complete; inspect the original conversation.';
   return 'Codex recovery process failed; inspect its checkpoint and original session before manual resume.';
 }
+// One fresh lease read at a time; stopping the watch also fences late reads so
+// a completed provider result cannot be changed by an old watchdog callback.
+function watchLease(root, provider, session, inspect, onFailure) {
+  let reading = false, stopped = false;
+  const timer = setInterval(() => {
+    if (reading || stopped) return;
+    reading = true;
+    void readRecord(root, provider, session).then(record => {
+      if (!stopped) inspect(record);
+    }).catch(() => { if (!stopped) onFailure(); }).finally(() => { reading = false; });
+  }, 500);
+  timer.unref();
+  return () => { stopped = true; clearInterval(timer); };
+}
 async function assertActiveLease(root, provider, session, leaseId, signal, currentTime = Date.now) {
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
   const current = await readRecord(root, provider, session);
@@ -54,7 +68,7 @@ export function parseAgentCheckpoint(output, expectedSession) {
 
 // The provider CLI is a new process. It is used only for an exact Codex UUID
 // enrolled for this recovery channel after a corroborated process exit.
-export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now, onActivity = () => {}, beforeDispatch = async () => {} } = {}) {
+export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now, onActivity = () => {}, beforeDispatch = async () => {}, leaseMonitored = false } = {}) {
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
   const binary = await executable('codex');
   if (!binary) throw new Error('Codex executable unavailable.');
@@ -94,12 +108,9 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
       forceKill.unref();
     };
     signal?.addEventListener('abort', terminate, { once: true });
-    const watch = setInterval(() => {
-      void readRecord(root, record.provider, record.session).then(current => {
-        if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) terminate();
-      }).catch(terminate);
-    }, 500);
-    watch.unref();
+    const stopWatch = leaseMonitored ? () => {} : watchLease(root, record.provider, record.session, current => {
+      if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) terminate();
+    }, terminate);
     child.stdout.on('data', chunk => {
       onActivity();
       const lines = (pending + chunk).split('\n');
@@ -107,7 +118,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
       for (const line of lines) consumeLine(line);
     });
     child.stderr.on('data', chunk => { error = (error + chunk).slice(-MAX_OUTPUT); });
-    const cleanup = () => { clearInterval(watch); clearTimeout(forceKill); signal?.removeEventListener('abort', terminate); };
+    const cleanup = () => { stopWatch(); clearTimeout(forceKill); signal?.removeEventListener('abort', terminate); };
     child.once('error', failure => { spawnError = failure; terminate(); });
     child.once('close', code => {
       cleanup(); if (pending) consumeLine(pending);
@@ -118,11 +129,12 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch } = {}) {
+export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
-  const records = await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}) });
+  const records = await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}),
+    ...(readRecords ? { records: await readRecords() } : {}) });
   if (signal?.aborted) return;
   for (let record of records) {
     if (signal?.aborted) break;
@@ -209,13 +221,10 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     if (signal?.aborted) controller.abort();
     else signal?.addEventListener('abort', abort, { once: true });
     const timeout = setTimeout(abort, Math.max(1, claimed.run.deadline - currentTime()));
-    const watch = setInterval(() => {
-      void readRecord(root, record.provider, record.session).then(current => {
-        if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId ||
-          managedBudgetReason(current.run, currentTime()) || !waitingForTool && currentTime() - lastActivityAt >= 5 * 60_000) controller.abort();
-      }).catch(() => controller.abort());
-    }, 500);
-    watch.unref();
+    const stopWatch = watchLease(root, record.provider, record.session, current => {
+      if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId ||
+        managedBudgetReason(current.run, currentTime()) || !waitingForTool && currentTime() - lastActivityAt >= 5 * 60_000) controller.abort();
+    }, () => controller.abort());
     try {
       if (!controller.signal.aborted) await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
       if (controller.signal.aborted) result = { code: -2, cancelled: true };
@@ -249,7 +258,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         if (!result) {
         await authorizeClaim();
         const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
-        result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime,
+        result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime, leaseMonitored: true,
           onActivity: observation => { lastActivityAt = currentTime(); waitingForTool = observation?.waitingForTool === true; },
           onUsage: observed => {
             usage = observed;
@@ -287,7 +296,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       ? { code: -3, busy: true, accessDenied: true }
       : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
         errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
-    finally { clearTimeout(timeout); clearInterval(watch); signal?.removeEventListener('abort', abort); }
+    finally { clearTimeout(timeout); stopWatch(); signal?.removeEventListener('abort', abort); }
     if (controller.signal.aborted) result = { ...result, code: -2, cancelled: true };
     if (claimed.run.managed.maxTokens && !usage && !result.busy && dispatched) {
       result = { ...result, usageUnavailable: true };