@awak-app/simy-cli 0.5.60 → 0.5.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.60",
+  "version": "0.5.61",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

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.61";
 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 };

package/src/desktop-host.js

@@ -1,7 +1,7 @@
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery, verifyDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, createRecordReader } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { answerSession, continueSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
@@ -10,7 +10,7 @@ import { analyzeContinuation, readContinuationContext } from "./session-supervis
 import { continueAnalyzedSession, createAutomaticContinuation } from "./session-supervision/automatic-continuation.js";
 import { createWindowsDesktopUpdater } from "./windows-desktop-updater.js";
 import { spawn, execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { promisify, isDeepStrictEqual } from "node:util";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
@@ -59,6 +59,19 @@ function desktopActionError(action, error) {
 export async function startDesktopHost({ input = process.stdin, output = process.stdout, env = process.env,
   dependencies = {}, exit = (code) => { process.exitCode = code; } } = {}) {
   const emit = (event) => output.write(`${JSON.stringify(event)}\n`);
+  // A heartbeat remains a complete native frame. Only its observation time is
+  // volatile; reuse the encoded body after comparing freshly authorized data.
+  // Detach the comparison value because registries may mutate nested objects.
+  let encodedStatus = null, lastStatus = null;
+  const emitStatus = status => {
+    const { sampledAt, ...content } = status;
+    if (!lastStatus || !isDeepStrictEqual(content, lastStatus)) {
+      encodedStatus = JSON.stringify(content).slice(1, -1);
+      lastStatus = structuredClone(content);
+    }
+    const observation = sampledAt === undefined ? '' : `"sampledAt":${JSON.stringify(sampledAt)}${encodedStatus ? ',' : ''}`;
+    output.write(`{"type":"status","status":{${observation}${encodedStatus}}}\n`);
+  };
   const root = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
   const webOrigin = resolveWebOrigin(null, env);
   const candidate = Boolean(env.SIMY_DESKTOP_SUPERVISOR_TOKEN);
@@ -67,8 +80,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
   }
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
+  const deliveryRoot = join(root, "delivery-hooks");
+  const recordReader = createRecordReader(deliveryRoot);
   let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false, scheduledPublish = null;
-  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
+  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, list: () => recordReader.list(), onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   const accessScope = access => JSON.stringify([access?.revision ?? null, access?.organizationId ?? null]);
@@ -76,6 +91,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const previousScope = accessScope(currentAccess);
     currentAccess = access || { state: 'unavailable', organizationId: null, organizationName: null };
     if (previousScope !== accessScope(currentAccess)) {
+      discoveryController?.abort();
+      sessionRefreshAgain = Boolean(sessionRefresh) && desktopAccessReady(currentAccess);
       for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
       sessionStatus = { sessions: [], providers: {}, refreshedAt: null }; sessionRefreshedAt = 0;
       await analysisManager?.update([]);
@@ -99,28 +116,37 @@ export async function startDesktopHost({ input = process.stdin, output = process
 
   const deadlines = createActionDeadlineService({ root: join(root, "action-deadlines") });
   const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks"),
-    authorizeDispatch: authorizeWork,
+    authorizeDispatch: authorizeWork, readRecords: () => recordReader.list(),
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
   let commands;
   let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null };
-  let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false;
+  let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false, discoveryController = null, discoveryStopped = false;
+  const stopDiscovery = async ({ drain = false } = {}) => {
+    discoveryController?.abort();
+    sessionRefreshAgain = false;
+    if (drain && !dependencies.discoverSessions) await sessionRefresh;
+  };
   const refreshSessions = (force = false) => {
-    if (!desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
+    if (discoveryStopped && !closed && !relay) return sessionStatus;
+    if (closed || relay || !desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
     if (force && sessionRefresh) sessionRefreshAgain = true;
     if (!sessionRefresh && (force || Date.now() - sessionRefreshedAt >= 15_000)) {
       const requestedScope = accessScope(currentAccess);
-      sessionRefresh = Promise.resolve().then(() => (dependencies.discoverSessions || discoverSessions)({ root: join(root, "delivery-hooks") }))
+      const controller = discoveryController = new AbortController();
+      sessionRefresh = Promise.resolve().then(() => { if (controller.signal.aborted) return null; return (dependencies.discoverSessions || discoverSessions)({ root: deliveryRoot, signal: controller.signal }); })
         .then(async value => {
+          if (closed || relay || controller.signal.aborted) return;
           const latestAccess = await accessSnapshot();
+          if (closed || relay || controller.signal.aborted) return;
           if (!desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope) {
             await analysisManager.update([]);
             sessionRefreshAgain = desktopAccessReady(latestAccess);
             return;
           }
           await analysisManager.update(value.sessions); sessionStatus = value; sessionRefreshedAt = Date.now(); })
-        .catch(() => { sessionStatus = { ...sessionStatus, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
-        .finally(() => { sessionRefresh = null; if (sessionRefreshAgain) { sessionRefreshAgain = false; refreshSessions(true); }
+        .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
+        .finally(() => { if (discoveryController === controller) discoveryController = null; sessionRefresh = null; if (sessionRefreshAgain && !closed && !relay) { sessionRefreshAgain = false; refreshSessions(true); }
           if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
     }
     return sessionStatus;
@@ -171,8 +197,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (!scheduledPublish) {
       let resolve, reject;
       const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
-      scheduledPublish = { promise };
-      setTimeout(() => { scheduledPublish = null; projectStatus().then(resolve, reject); }, 75);
+      scheduledPublish = { promise, resolve, timer: setTimeout(() => { scheduledPublish = null; projectStatus().then(resolve, reject); }, 75) };
     }
     return scheduledPublish.promise;
   };
@@ -180,6 +205,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) { publishAgain = true; return publishing; }
     publishing = Promise.resolve(agent.getDesktopStatus()).then(async (status) => {
+      if (closed || relay) return;
       await setAccessSnapshot(status.access);
       status.access = currentAccess;
       const requestedScope = accessScope(currentAccess);
@@ -191,36 +217,45 @@ export async function startDesktopHost({ input = process.stdin, output = process
         status.sqmTasks = { activeCount: status.sqmTasks?.activeCount || 0, items: [] };
         status.deliveryHooks = { runs: [], providers: {} };
         status.sessionSupervision = { sessions: [], providers: {}, refreshedAt: null };
-        if (!closed && !relay) emit({ type: 'status', status });
+        if (!closed && !relay) emitStatus(status);
         return;
       }
-      status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: join(root, "delivery-hooks") }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
-      const projection = await actionAssociations.beginProjection?.();
-      await actionAssociations.decorate(status.deliveryHooks);
+      const records = await recordReader.list();
+      const projection = await actionAssociations.beginProjection?.({ records });
+      status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
+      await actionAssociations.decorate(status.deliveryHooks, projection);
       const discovery = refreshSessions();
       automaticContinuation?.tick(discovery.sessions);
       const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
       await actionAssociations.decorateSessions?.(sessions, projection);
+      const runsBySession = new Map((status.deliveryHooks.runs || []).map(run => [`${run.provider}:${run.session}`, run]));
       for (const session of sessions) {
         const context = await actionAssociations.deadlineContext?.(session, projection);
-        if (context) session.actionDeadline = await deadlines.reconcile(context);
+        if (context) session.actionDeadline = await deadlines.reconcile(context, { displayOnly: true });
         else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
-        const run = status.deliveryHooks.runs?.find(item => item.provider === session.provider && item.session === session.session);
+        const run = runsBySession.get(`${session.provider}:${session.session}`);
         if (run) run.actionDeadline = session.actionDeadline;
       }
       status.sessionSupervision = { ...discovery, sessions };
       const latestAccess = await accessSnapshot();
-      if (!desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope) { publishAgain = true; return; }
-      if (!closed && !relay) emit({ type: "status", status });
+      if (!desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
+        actionAssociations.validateProjection && !await actionAssociations.validateProjection(projection)) { publishAgain = true; return; }
+      if (!closed && !relay) emitStatus(status);
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
   };
   const stopAgent = async () => {
     clearInterval(timer);
+    discoveryStopped = true;
+    await stopDiscovery({ drain: true });
+    encodedStatus = null; lastStatus = null;
+    if (scheduledPublish) { clearTimeout(scheduledPublish.timer); scheduledPublish.resolve(); scheduledPublish = null; }
+    await publishing?.catch(() => {});
     await actionAssociations.close();
     await automaticContinuation?.close();
     await analysisManager?.close();
     await managedSupervisor.close();
+    await recordReader.close();
     await stopWorkflows();
     if (agent) await createAgentShutdown(agent)();
   };
@@ -262,6 +297,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
     updater.on?.("change", () => { void publish().catch(() => {}); });
     updater.start({ registry: agent.registry, restartDaemon: async (targetVersion, installation) => {
       if (!installation?.entryPath || !installation?.executablePath) throw new Error("Signed update runtime is unavailable.");
+      discoveryStopped = true;
+      await stopDiscovery({ drain: true });
       // The candidate shares this cache. Stop inference before it starts so a
       // signed handoff cannot create two analysis writers or duplicate calls.
       await automaticContinuation.close();
@@ -276,7 +313,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken },
         }); } catch (error) {
           actionAssociations = makeActionAssociations();
-          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); refreshSessions(true); throw error;
+          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); discoveryStopped = false; refreshSessions(true); throw error;
         }
       const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
       let accepted = false;
@@ -321,18 +358,25 @@ export async function startDesktopHost({ input = process.stdin, output = process
         lines.close(); await stopUpdateCandidate(child);
         if (!closed && !relay) {
           actionAssociations = makeActionAssociations();
-          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); refreshSessions(true);
+          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); discoveryStopped = false; refreshSessions(true);
         }
         throw error;
       }
     } });
     await refreshPlugins();
     await publish();
-    void actionAssociations.tick().then(publish).catch(() => {});
+    const maintenance = new Map();
+    const tick = worker => {
+      if (closed || relay || maintenance.has(worker)) return;
+      const pending = Promise.resolve().then(() => worker.tick()).then(() => { if (!closed && !relay) return publish(); }).catch(() => {}).finally(() => maintenance.delete(worker));
+      maintenance.set(worker, pending);
+    };
+    tick(actionAssociations);
+    tick(managedSupervisor);
     timer = setInterval(() => {
       if (desktopAccessReady(currentAccess)) {
-        void actionAssociations.tick().then(publish).catch(() => {});
-        void managedSupervisor.tick().then(publish).catch(() => {});
+        tick(actionAssociations);
+        tick(managedSupervisor);
       }
       void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." }));
     }, 3_000);

package/src/session-supervision/action-association-api.js

@@ -43,7 +43,7 @@ async function boundedJson(response) {
 // login cannot associate work in the newly selected account.
 export function createActionAssociationApi({ webOrigin, sessionRoot,
   fetchImpl = fetch, readSessionImpl = readSession, now = Date.now, timeoutMs = 10_000 } = {}) {
-  const identity = session => createHash('sha256').update(`${webOrigin}\0${session.token}`).digest('hex');
+  const identity = session => createHash('sha256').update(JSON.stringify([webOrigin, session.token, session.organization_id ?? null, session.user_id ?? null, session.account_id ?? null, session.device_id ?? null, session.api_base_url ?? null, session.expires_at])).digest('hex');
   const currentSession = async () => {
     const session = await readSessionImpl(webOrigin, sessionRoot);
     if (!isSessionValid(session, now(), webOrigin)) throw new ActionAssociationApiError('signed_out');