@awak-app/simy-cli 0.5.60 → 0.5.62

package/src/session-supervision/association-store.js

@@ -54,7 +54,14 @@ export function createOrdinaryAssociationStore({
   const views = new Map(),
     abort = new AbortController();
   let serial = Promise.resolve(),
-    closed = false;
+    closed = false, nextBatchAt = 0, nextPriorityAt = 0, priorityTimer = null;
+  const rememberView = (taskId, view) => {
+    views.delete(taskId); views.set(taskId, view);
+    while (views.size > 500) views.delete(views.keys().next().value);
+  };
+  const presentationKey = view => JSON.stringify([view?.auth, view?.status, view?.contextRevision, view?.namespace,
+    view?.snapshot?.candidateRevision, view?.snapshot?.binding,
+    view?.snapshot?.candidates?.slice(0, 5).map(item => [item.id, item.revision, item.title])]);
   const find = candidate => readRecord(root, candidate.provider, candidate.session);
   async function ensure(candidate, known) {
     if (
@@ -106,7 +113,7 @@ export function createOrdinaryAssociationStore({
       context = sessionAssociationContext(candidate);
     let view = views.get(taskId);
     if (!auth) {
-      views.set(taskId, { auth, status: 'signed_out' });
+      rememberView(taskId, { auth, status: 'signed_out' });
       return;
     }
     if (
@@ -116,13 +123,16 @@ export function createOrdinaryAssociationStore({
       now() < view.nextRefresh
     )
       return;
+    const previous = view?.auth === auth ? view : null;
+    const sameContext = previous?.contextRevision === context.revision;
     view = {
-      auth,
-      contextRevision: context.revision,
-      status: 'loading',
-      nextRefresh: now() + 15000,
+      ...previous, auth, contextRevision: context.revision,
+      // Background renewal retains the last stable presentation. A user refresh
+      // can show progress without flashing every cached result back to loading.
+      status: force ? 'loading' : previous?.status || 'loading',
+      nextRefresh: now() + 60_000, lastAttemptAt: now(), failures: sameContext ? previous?.failures || 0 : 0,
     };
-    views.set(taskId, view);
+    rememberView(taskId, view);
     try {
       const snapshot = await api.candidates(
         { taskId, context, limit: 10 },
@@ -141,7 +151,8 @@ export function createOrdinaryAssociationStore({
         root,
         candidate.provider,
         candidate.session,
-        (latest) => {
+        async (latest) => {
+          if (closed || await api.authRevision() !== auth) throw new ActionAssociationApiError('account_changed');
           if (latest.associationTaskId !== taskId || latest.run?.managed)
             return latest;
           if (
@@ -173,6 +184,8 @@ export function createOrdinaryAssociationStore({
       Object.assign(view, {
         namespace,
         snapshot,
+        nextRefresh: now() + (snapshot.binding?.action ? 15_000 : 60_000),
+        failures: 0,
         status: snapshot.binding?.action
           ? 'bound'
           : snapshot.binding
@@ -182,6 +195,8 @@ export function createOrdinaryAssociationStore({
     } catch (error) {
       view.status = error.code || 'offline';
       view.snapshot = null;
+      view.failures = Math.min(4, view.failures + 1);
+      view.nextRefresh = now() + Math.min(120_000, 15_000 * 2 ** (view.failures - 1));
     }
   }
   return {
@@ -192,7 +207,10 @@ export function createOrdinaryAssociationStore({
           record,
         ]),
       );
-      const auth = await api.authRevision();
+      const auth = snapshot && Object.hasOwn(snapshot, 'authRevision') ? snapshot.authRevision : await api.authRevision();
+      const taskIds = new Set([...records.values()].map(record => record.run?.managed?.taskId || record.associationTaskId).filter(Boolean));
+      for (const taskId of views.keys()) if (!taskIds.has(taskId) && !inFlight.has(taskId)) views.delete(taskId);
+      const pending = [];
       for (const candidate of sessions) {
         const record = await ensure(
             candidate,
@@ -207,26 +225,29 @@ export function createOrdinaryAssociationStore({
         if (
           auth &&
           !closed &&
-          inFlight.size < 3 &&
           !inFlight.has(taskId) &&
           (!cached ||
             cached.auth !== auth ||
             cached.contextRevision !== context.revision ||
             now() >= cached.nextRefresh)
         ) {
-          const work = sync(candidate, false, record)
-            .catch(() => {})
-            .finally(() => {
-              inFlight.delete(taskId);
-              if (!closed) onChange();
-            });
-          inFlight.set(taskId, work);
+          const scopedBinding = cached?.auth === auth && cached.snapshot && record.actionAssociation?.authRevision === auth && record.actionAssociation.namespace === cached.namespace;
+          pending.push({ candidate, record, taskId, lastAttemptAt: cached?.lastAttemptAt ?? -Infinity,
+            priority: Boolean(cached?.auth === auth && cached.snapshot && cached.contextRevision !== context.revision ||
+              scopedBinding && (record.actionAssociation.binding?.action || cached.snapshot.binding?.action) && now() >= cached.nextRefresh) });
         }
         const view = views.get(taskId);
-        const snapshot = view?.auth === auth && auth ? view.snapshot : null;
-        const binding = snapshot?.binding;
+        const bindingSnapshot = view?.auth === auth && auth ? view.snapshot : null;
+        const snapshot = bindingSnapshot?.contextRevision === context.revision ? bindingSnapshot : null;
+        const local = record.actionAssociation;
+        const scoped = Boolean(bindingSnapshot && local?.authRevision === auth && local.namespace === view.namespace);
+        const newer = scoped &&
+          (local.binding?.revision || 0) > (bindingSnapshot.binding?.revision || 0);
+        // A hook/second desktop can correct or unlink a binding while the
+        // network cache remains valid. The current persisted revision wins.
+        const binding = newer ? local.binding : bindingSnapshot?.binding;
         candidate.actionAssociation = {
-          status: !auth ? 'signed_out' : view?.status || 'loading',
+          status: !auth ? 'signed_out' : newer ? local.status : view?.status || 'loading',
           binding: binding
             ? {
                 ...binding,
@@ -248,11 +269,45 @@ export function createOrdinaryAssociationStore({
             title: item.title.slice(0, 120),
           })),
           canCorrect: Boolean(snapshot),
+          canReadBinding: Boolean(scoped && binding),
           contextRevision: view?.contextRevision || null,
           candidateRevision: snapshot?.candidateRevision || null,
           truncated: (snapshot?.candidates?.length || 0) > 5,
         };
       }
+      const priority = pending.filter(item => item.priority);
+      const priorityReady = priority.length && now() >= nextPriorityAt;
+      if (pending.length && (now() >= nextBatchAt || priorityReady) && inFlight.size < 3) {
+        const onlyPriority = now() < nextBatchAt;
+        if (onlyPriority) nextPriorityAt = now() + 250;
+        else { nextBatchAt = now() + 3_000; if (priority.length) nextPriorityAt = now() + 250; }
+        // Never-checked and least-recently-checked work wins over array order,
+        // so a short retry TTL cannot indefinitely starve later conversations.
+        // Existing conversations must reflect changed user context promptly. This
+        // separately bounded lane never treats old-account or unseen history as
+        // urgent, and still shares the three workers with normal backfill.
+        const batch = (onlyPriority ? priority : pending).sort((a, b) => Number(b.priority) - Number(a.priority) || a.lastAttemptAt - b.lastAttemptAt).slice(0, 3 - inFlight.size);
+        const before = batch.map(({ taskId }) => presentationKey(views.get(taskId)));
+        const work = batch.map(({ candidate, record, taskId }) => {
+          const result = sync(candidate, false, record).catch(() => {}).finally(() => inFlight.delete(taskId));
+          inFlight.set(taskId, result);
+          return result;
+        });
+        void Promise.allSettled(work).then(() => {
+          if (!closed && batch.some(({ taskId }, index) => presentationKey(views.get(taskId)) !== before[index])) onChange();
+        });
+      }
+      const waitingPriority = priority.some(({ taskId }) => !inFlight.has(taskId));
+      if (!waitingPriority && priorityTimer) { clearTimeout(priorityTimer); priorityTimer = null; }
+      if (waitingPriority && inFlight.size < 3 && now() < nextPriorityAt && !priorityTimer) {
+        // A command may arrive between the bounded priority slots. Wake once
+        // when the slot opens rather than waiting for the 3s history heartbeat.
+        priorityTimer = setTimeout(() => { priorityTimer = null; if (!closed) onChange(); }, nextPriorityAt - now());
+        priorityTimer.unref();
+      }
+      if (!snapshot && await api.authRevision() !== auth) {
+        for (const candidate of sessions) candidate.actionAssociation = { status: 'account_changed', binding: null, candidates: [], canCorrect: false };
+      }
       return sessions;
     },
     correct(command, candidate) {
@@ -336,7 +391,8 @@ export function createOrdinaryAssociationStore({
             root,
             candidate.provider,
             candidate.session,
-            (latest) => {
+            async (latest) => {
+              if (closed || await api.authRevision() !== auth) throw new ActionAssociationApiError('account_changed');
               if (
                 latest.associationTaskId !== command.taskId ||
                 latest.run?.managed
@@ -364,6 +420,7 @@ export function createOrdinaryAssociationStore({
     },
     async close() {
       closed = true;
+      clearTimeout(priorityTimer); priorityTimer = null;
       abort.abort();
       await Promise.allSettled([serial, ...inFlight.values()]);
       views.clear();

package/src/session-supervision/automatic-continuation.js

@@ -27,6 +27,18 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
   let closed = false;
   const tick = candidates => {
     if (closed) return;
+    // Drop display/dedup state once a current observation proves it obsolete.
+    // Absence alone is insufficient: provider outages must not retry a failed
+    // enrollment with the same opt-in epoch and context when it reappears.
+    for (const candidate of candidates) {
+      const key = `${candidate.provider}:${candidate.session}`;
+      const attempt = attempted.get(key);
+      const bound = ['managed', 'pending_takeover', 'standard_loop'].includes(candidate.binding?.mode);
+      if (candidate.autoContinue !== true || bound ||
+          attempt && !attempt.startsWith(`${candidate.autoContinueEpoch}:`)) {
+        attempted.delete(key); errors.delete(key);
+      }
+    }
     for (const candidate of candidates) {
       if (pending.size >= 3) break;
       if (candidate.autoContinue !== true || !candidate.autoContinueEpoch || candidate.isRunning ||
@@ -76,6 +88,11 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
     },
     revoke(provider, session) { pending.get(`${provider}:${session}`)?.controller.abort(); },
     async whenIdle() { await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
-    async close() { closed = true; for (const entry of pending.values()) entry.controller.abort(); await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
+    async close() {
+      closed = true;
+      for (const entry of pending.values()) entry.controller.abort();
+      await Promise.allSettled([...pending.values()].map(entry => entry.job));
+      attempted.clear(); errors.clear();
+    },
   };
 }

package/src/session-supervision/claude-sessions.js

@@ -10,6 +10,24 @@ const MAX_TRANSCRIPTS = 4096;
 const MAX_PREFIX_BYTES = 256 * 1024;
 const MAX_LINES = 256;
 const MAX_FILE_BYTES = 64 * 1024 * 1024;
+// Metadata is observation only. Exact-session/context readers always open the
+// transcript again; cached values contain no conversation message bodies.
+const metadataCache = new Map();
+const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeNs, info.ctimeNs].join(':');
+function rememberMetadata(path, value) {
+  metadataCache.delete(path); metadataCache.set(path, value);
+  while (metadataCache.size > MAX_TRANSCRIPTS) metadataCache.delete(metadataCache.keys().next().value);
+}
+function candidateMetadata(id, metadata, lastActivityAt, observedAt) {
+  return {
+    provider: 'claude', session: id, cwd: metadata.cwd, title: metadata.title,
+    source: 'claude_cli', lastActivityAt,
+    observation: { source: 'claude_local_index', observedAt },
+    availability: 'unsupported', model: null,
+    capabilities: { canMonitor: true, canEnroll: false, canAutoContinue: false },
+    reason: 'Claude session ownership and safe exact-session takeover are unverified; monitoring only.',
+  };
+}
 
 function within(parent, child) {
   const path = relative(parent, child);
@@ -53,7 +71,7 @@ function metadataFromPrefix(bytes, id) {
   return found ? { cwd, title } : null;
 }
 
-async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false) {
+async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false, cacheMetadata = false) {
   const id = fileName.slice(0, -'.jsonl'.length);
   if (!UUID.test(id)) return null;
   const project = join(root, projectName);
@@ -62,8 +80,19 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
   let handle;
   try {
     const before = await lstat(path);
-    if (!before.isFile() || before.isSymbolicLink() || before.size > MAX_FILE_BYTES) return null;
-    if (!within(root, await realpath(path))) return null;
+    if (!before.isFile() || before.isSymbolicLink() || before.size > MAX_FILE_BYTES) { metadataCache.delete(path); return null; }
+    if (!within(root, await realpath(path))) { metadataCache.delete(path); return null; }
+    let key;
+    if (cacheMetadata) {
+      const info = await lstat(path, { bigint: true });
+      if (!info.isFile() || info.isSymbolicLink() || info.dev !== BigInt(before.dev) || info.ino !== BigInt(before.ino)) return null;
+      key = fingerprint(info);
+      const cached = metadataCache.get(path);
+      if (cached?.key === key) {
+        rememberMetadata(path, cached);
+        return cached.metadata ? candidateMetadata(id, cached.metadata, cached.lastActivityAt, observedAt) : null;
+      }
+    }
     handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
     const opened = await handle.stat();
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) return null;
@@ -75,22 +104,22 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
     const buffer = Buffer.allocUnsafe(Math.min(opened.size, MAX_PREFIX_BYTES));
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
     const metadata = metadataFromPrefix(buffer.subarray(0, bytesRead), id);
+    if (cacheMetadata) {
+      const [after, pathAfter] = await Promise.all([handle.stat({ bigint: true }), lstat(path, { bigint: true })]);
+      if (fingerprint(after) === key && fingerprint(pathAfter) === key && pathAfter.isFile() && !pathAfter.isSymbolicLink())
+        rememberMetadata(path, { key, metadata, lastActivityAt: opened.mtimeMs });
+      else metadataCache.delete(path);
+    }
     if (!metadata) return null;
-    const candidate = {
-      provider: 'claude', session: id, cwd: metadata.cwd, title: metadata.title,
-      source: 'claude_cli', lastActivityAt: opened.mtimeMs,
-      observation: { source: 'claude_local_index', observedAt },
-      availability: 'unsupported', model: null,
-      capabilities: { canMonitor: true, canEnroll: false, canAutoContinue: false },
-      reason: 'Claude session ownership and safe exact-session takeover are unverified; monitoring only.',
-    };
+    const candidate = candidateMetadata(id, metadata, opened.mtimeMs, observedAt);
     if (includeContext) candidate.context = await conversationFromHandle(handle, opened, id, metadata.cwd);
     return candidate;
-  } catch { return null; }
+  } catch { metadataCache.delete(path); return null; }
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, includeContext = false } = {}) {
+async function collect({ home = homedir(), limit = 100, session = null, includeContext = false, cacheMetadata = false, signal } = {}) {
+  if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
   const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, 200)) : 100;
@@ -100,16 +129,18 @@ async function collect({ home = homedir(), limit = 100, session = null, includeC
   let projects;
   try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
   for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, MAX_PROJECTS)) {
+    if (signal?.aborted) return [];
     const project = join(root, entry.name);
     let files;
     try { files = await readdir(project, { withFileTypes: true }); } catch { continue; }
     for (const file of files) {
+      if (signal?.aborted) return [];
       if (inspected >= MAX_TRANSCRIPTS) break;
       if (!file.isFile() || file.isSymbolicLink() || !UUID.test(file.name.replace(/\.jsonl$/, '')) || !file.name.endsWith('.jsonl')) continue;
       const id = file.name.slice(0, -'.jsonl'.length);
       if (session && id !== session) continue;
       inspected++;
-      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext);
+      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext, cacheMetadata);
       if (!candidate) continue;
       const key = `${candidate.session}\0${candidate.cwd}${includeContext ? `\0${entry.name}\0${file.name}` : ''}`;
       if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
@@ -120,8 +151,8 @@ async function collect({ home = homedir(), limit = 100, session = null, includeC
   return session ? sorted : sorted.slice(0, maximum);
 }
 
-export async function listClaudeSessions({ home, limit } = {}) {
-  return collect({ home, limit });
+export async function listClaudeSessions({ home, limit, signal } = {}) {
+  return collect({ home, limit, signal, cacheMetadata: true });
 }
 
 export async function readClaudeSession(session, { home } = {}) {
@@ -163,7 +194,7 @@ async function conversationFromHandle(handle, opened, session, cwd) {
 export async function readClaudeConversation(candidate, { home, signal } = {}) {
   if (signal?.aborted) return boundConversation(null);
   if (!UUID.test(candidate?.session || '') || typeof candidate?.cwd !== 'string') return boundConversation(null);
-  const matches = await collect({ home, session: candidate.session, includeContext: true });
+  const matches = await collect({ home, session: candidate.session, includeContext: true, signal });
   const selected = matches.filter(item => item.cwd === candidate.cwd);
   if (signal?.aborted || selected.length !== 1) return boundConversation(null);
   if (Number.isFinite(candidate.lastActivityAt) && selected[0].lastActivityAt !== candidate.lastActivityAt) {

package/src/session-supervision/codex-app-server.js

@@ -23,7 +23,7 @@ export class CodexAppServerError extends Error {
 }
 
 export class CodexAppServerClient {
-  constructor(child, { maxLineBytes = MAX_LINE, omitInlineAttachments = false } = {}) {
+  constructor(child, { maxLineBytes = MAX_LINE, omitInlineAttachments = false, signal } = {}) {
     this.maxLineBytes = Number.isInteger(maxLineBytes) ? Math.max(MAX_LINE, Math.min(maxLineBytes, 8 * 1024 * 1024)) : MAX_LINE;
     this.child = child;
     this.nextId = 0;
@@ -61,7 +61,12 @@ export class CodexAppServerClient {
       }
     });
     child.on('error', error => this.fail(error));
-    child.on('close', () => this.fail(new CodexAppServerError('closed', 'Codex app-server closed.')));
+    child.on('close', () => { this.childClosed = true; this.detachAbort(); this.fail(new CodexAppServerError('closed', 'Codex app-server closed.')); });
+    child.stdin?.on?.('error', error => this.fail(error));
+    this.abortSignal = signal;
+    this.cancelled = () => { this.fail(new CodexAppServerError('cancelled', 'Codex app-server was cancelled.')); void this.close(); };
+    signal?.addEventListener('abort', this.cancelled, { once: true });
+    if (signal?.aborted) this.cancelled();
     // Diagnostics can contain private data. Drain, but never retain or expose them.
     child.stderr?.resume();
   }
@@ -116,14 +121,28 @@ export class CodexAppServerClient {
 
   onNotification(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
 
-  async close() {
-    if (this.child.exitCode !== null) return;
-    this.child.stdin.end();
-    this.child.kill('SIGTERM');
-    await new Promise(resolve => {
-      const timer = setTimeout(() => { this.child.kill('SIGKILL'); resolve(); }, 2_000);
-      this.child.once('close', () => { clearTimeout(timer); resolve(); });
+  detachAbort() { this.abortSignal?.removeEventListener('abort', this.cancelled); }
+
+  close() {
+    if (this.closing) return this.closing;
+    this.detachAbort();
+    this.fail(new CodexAppServerError('closed', 'Codex app-server closed.'));
+    if (this.childClosed || this.child.exitCode != null || this.child.signalCode != null) return this.closing = Promise.resolve();
+    this.closing = new Promise(resolve => {
+      const finished = () => {
+        clearTimeout(force); clearTimeout(limit);
+        this.child.removeListener('close', finished);
+        resolve();
+      };
+      // Subscribe before ending/killing: a fast or fake child can close during
+      // kill itself. One close owns both timers and drains rejected RPCs.
+      this.child.once('close', finished);
+      const force = setTimeout(() => { this.child.kill('SIGKILL'); }, 2_000);
+      const limit = setTimeout(finished, 3_000);
+      this.child.stdin.end();
+      this.child.kill('SIGTERM');
     });
+    return this.closing;
   }
 }
 
@@ -134,9 +153,9 @@ export function supportsCodexWriterLock(version) {
   return parts[0] > 0 || parts[1] > 158 || parts[1] === 158 && parts[2] >= 0;
 }
 
-export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes, omitInlineAttachments = false } = {}) {
+export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes, omitInlineAttachments = false, cancelOnAbort = false } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
-  const inspection = await inspectExecutable('codex');
+  const inspection = await inspectExecutable('codex', cancelOnAbort ? { signal } : undefined);
   if (!inspection?.available || !inspection.executable) throw new CodexAppServerError('unavailable', 'Codex executable is unavailable.');
   if (!supportsCodexWriterLock(inspection.installed_version)) throw new CodexAppServerError('unsupported', 'Codex version does not have a verified app-server writer lock.');
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
@@ -144,12 +163,13 @@ export async function openCodexAppServer({ inspectExecutable = inspectBackendExe
   // restore a temporary read-only override. The caller's signal is checked
   // before spawn and by the turn watcher below.
   const child = spawnImpl(inspection.executable, ['app-server', '--stdio'], { stdio: ['pipe', 'pipe', 'pipe'] });
-  const client = new CodexAppServerClient(child, { maxLineBytes, omitInlineAttachments });
+  const client = new CodexAppServerClient(child, { maxLineBytes, omitInlineAttachments, signal: cancelOnAbort ? signal : undefined });
   try {
     await client.request('initialize', { clientInfo: { name: 'simy_session_supervision', title: 'SIMY Session Supervision', version: '1.0.0' } });
+    if (cancelOnAbort && signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
     client.notify('initialized');
     return client;
-  } catch (error) { await client.close(); throw error; }
+  } catch (error) { await client.close(); if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.'); throw error; }
 }
 
 export function codexThreadMetadata(thread) {
@@ -266,10 +286,11 @@ export async function readCodexSession(client, session) {
 
 export async function readCodexConversation(candidate, { openClient = openCodexAppServer, signal } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-  const client = await openClient({ signal, maxLineBytes: ANALYSIS_MAX_LINE, omitInlineAttachments: true });
+  const client = await openClient({ signal, maxLineBytes: ANALYSIS_MAX_LINE, omitInlineAttachments: true, cancelOnAbort: true });
   const cancelled = () => { void client.close(); };
   signal?.addEventListener('abort', cancelled, { once: true });
   try {
+    if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
     // Full thread history can contain tens of MiB of tool output. Analysis
     // reads only metadata and a fixed number of recent display summaries.
     const metadata = await readCodexSession(client, candidate.session);

package/src/session-supervision/index.js

@@ -1,7 +1,7 @@
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { TERMINAL as TERMINAL_RUNS, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
-import { listCodexSessions, openCodexAppServer, readCodexSession } from './codex-app-server.js';
+import { listCodexSessions, openCodexAppServer, readCodexSession, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 
@@ -32,9 +32,15 @@ function initialDiagnosisPlan(objective, contextBootstrap = false) {
   };
 }
 
-async function withClient(openClient, work) {
-  const client = await openClient();
-  try { return await work(client); } finally { await client.close(); }
+async function withClient(openClient, work, signal) {
+  if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.');
+  const client = await openClient(signal ? { signal, cancelOnAbort: true } : undefined);
+  const cancelled = () => { void client.close(); };
+  signal?.addEventListener('abort', cancelled, { once: true });
+  try {
+    if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.');
+    return await work(client);
+  } finally { signal?.removeEventListener('abort', cancelled); await client.close(); }
 }
 
 async function liveClaudeHook(record, metadata, inspectProcess) {
@@ -49,14 +55,19 @@ async function liveClaudeHook(record, metadata, inspectProcess) {
 }
 
 export async function discoverSessions({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now = Date.now() } = {}) {
+  inspectProcess = processIdentity, now = Date.now(), signal } = {}) {
+  const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
+  assertActive();
   const records = await listRecords(root);
   let discovered = [], codexError = null, claude = [], claudeError = null;
   try { discovered = await withClient(openClient, client => listCodexSessions({ client, inspectState: true,
-    prioritySessions: records.filter(record => record.provider === 'codex' && (record.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) })); }
+    prioritySessions: records.filter(record => record.provider === 'codex' && (record.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) }), signal); }
   catch (error) { codexError = error?.code === 'unavailable' ? 'Codex executable unavailable.' : error?.code === 'unsupported' ? 'This Codex version lacks a verified app-server writer lock; update before enrollment.' : 'Codex conversation discovery unavailable.'; }
-  try { claude = await listClaude(); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
+  assertActive();
+  try { claude = await listClaude({ signal }); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
+  assertActive();
   const byKey = new Map();
+  const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
   for (const item of [...discovered, ...claude]) byKey.set(`${item.provider}:${item.session}`, item);
   for (const record of records) {
     const key = `${record.provider}:${record.session}`;
@@ -67,8 +78,12 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       availability: 'unknown', model: record.admission?.model || null,
     });
   }
-  const projected = (await Promise.all([...byKey.values()].map(async item => {
-    const record = records.find(r => r.provider === item.provider && r.session === item.session);
+  // Historical sessions must not fan out hundreds of process-inspection
+  // subprocesses. Preserve input ordering while limiting live metadata probes.
+  const items = [...byKey.values()], projected = new Array(items.length);
+  let nextItem = 0;
+  const project = async item => {
+    const record = recordsByKey.get(`${item.provider}:${item.session}`);
     const run = record?.run;
     const mode = run?.managed ? run.state === 'recovery_required' && run.recoveryCause === 'session_supervision' ? 'pending_takeover' : 'managed' : run ? 'standard_loop' : record?.monitor ? 'monitor' : 'unmanaged';
     const supported = item.provider === 'codex' && item.observation.source === 'codex_app_server' && Boolean(item.model) && !codexError;
@@ -104,7 +119,16 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
           'Claude enrollment needs a live matching SIMY SessionStart hook and provider process; cold CLI takeover is unavailable.' :
         codexError || (!supported ? 'Exact model or provider metadata is unavailable.' : null),
     };
-  }))).sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
+  };
+  await Promise.all(Array.from({ length: Math.min(8, items.length) }, async () => {
+    while (nextItem < items.length) {
+      assertActive();
+      const index = nextItem++;
+      projected[index] = await project(items[index]);
+    }
+  }));
+  assertActive();
+  projected.sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
   // Keep existing bindings visible during a truncated discovery or provider
   // outage, even when newer unbound conversations fill the candidate window.
   const bound = projected.filter(item => item.autoContinue || item.binding.mode !== 'unmanaged');

package/src/sqm/command.js

@@ -1,3 +1,4 @@
+import { createSqmCheckRecorder } from "./history-store.js";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -46,54 +47,63 @@ export async function runSqmCommand(argv, { cliVersion }) {
     organizationId,
   };
 
-  if (argv[0] === "min-check") {
-    const result = await runSqmMinCheck(common);
-    const output = option(argv, "--output") || defaultMinResultPath();
-    await atomicJson(output, result);
-    if (argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
-    else printMin(result, output);
-    return result.status === "unavailable" ? 2 : result.status === "preliminary_failed" ? 1 : 0;
-  }
-
-  const minPath = option(argv, "--min-result") || defaultMinResultPath();
-  let minCheck;
+  const save = createSqmCheckRecorder({ scope: { webOrigin, accountId, organizationId },
+    phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch });
   try {
-    minCheck = JSON.parse(await readFile(minPath, "utf8"));
+    if (argv[0] === "min-check") {
+      const result = await runSqmMinCheck(common);
+      const output = option(argv, "--output") || defaultMinResultPath();
+      await atomicJson(output, result);
+      await save(result);
+      if (argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
+      else printMin(result, output);
+      return result.status === "unavailable" ? 2 : result.status === "preliminary_failed" ? 1 : 0;
+    }
+
+    const minPath = option(argv, "--min-result") || defaultMinResultPath();
+    let minCheck;
+    try {
+      minCheck = JSON.parse(await readFile(minPath, "utf8"));
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      console.warn("No min-check result was found; running the deterministic min-check first.");
+      minCheck = await runSqmMinCheck(common);
+      await atomicJson(minPath, minCheck);
+    }
+    if (minCheck.status === "unavailable") { await save(minCheck); return printUnavailable(minCheck, argv); }
+    const result = await runSqmCheck({ ...common, minCheck, deviceId, signingKeyPath: option(argv, "--signing-key") || undefined });
+    if (result.status === "unavailable") { await save(result); return printUnavailable(result, argv); }
+    const proofPath = path.resolve(option(argv, "--proof") || "proof.json");
+    const evidencePath = path.resolve(option(argv, "--signed-evidence") || `${proofPath}.signed.json`);
+    const diagnosticsPath = path.resolve(option(argv, "--diagnostics") || `${proofPath}.diagnostics.json`);
+    await Promise.all([
+      atomicJson(proofPath, result.proof),
+      atomicJson(evidencePath, result.signed_evidence),
+      atomicJson(diagnosticsPath, {
+        policy_version: "sqm-reliability.v1",
+        matcher_diagnostics: result.matcher_diagnostics,
+      }),
+    ]);
+    let upload = { uploaded: false, reason: "disabled" };
+    if (!argv.includes("--no-upload")) {
+      const evidenceEndpoint = process.env.SIMY_SQM_EVIDENCE_URL || (validSession?.api_base_url ? new URL("sqm/run-evidence", validSession.api_base_url).href : undefined);
+      upload = await uploadRunEvidence({ endpoint: evidenceEndpoint, token, proof: result.proof, signedEvidence: result.signed_evidence });
+    }
+    result.upload = upload;
+    result.artifacts = {
+      min_check: minPath,
+      proof: proofPath,
+      signed_evidence: evidencePath,
+      diagnostics: diagnosticsPath,
+    };
+    await save(result);
+    if (argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
+    else printFull(result);
+    return result.proof.outcome.status === "failed" ? 1 : 0;
   } catch (error) {
-    if (error?.code !== "ENOENT") throw error;
-    console.warn("No min-check result was found; running the deterministic min-check first.");
-    minCheck = await runSqmMinCheck(common);
-    await atomicJson(minPath, minCheck);
-  }
-  if (minCheck.status === "unavailable") return printUnavailable(minCheck, argv);
-  const result = await runSqmCheck({ ...common, minCheck, deviceId, signingKeyPath: option(argv, "--signing-key") || undefined });
-  if (result.status === "unavailable") return printUnavailable(result, argv);
-  const proofPath = path.resolve(option(argv, "--proof") || "proof.json");
-  const evidencePath = path.resolve(option(argv, "--signed-evidence") || `${proofPath}.signed.json`);
-  const diagnosticsPath = path.resolve(option(argv, "--diagnostics") || `${proofPath}.diagnostics.json`);
-  await Promise.all([
-    atomicJson(proofPath, result.proof),
-    atomicJson(evidencePath, result.signed_evidence),
-    atomicJson(diagnosticsPath, {
-      policy_version: "sqm-reliability.v1",
-      matcher_diagnostics: result.matcher_diagnostics,
-    }),
-  ]);
-  let upload = { uploaded: false, reason: "disabled" };
-  if (!argv.includes("--no-upload")) {
-    const evidenceEndpoint = process.env.SIMY_SQM_EVIDENCE_URL || (validSession?.api_base_url ? new URL("sqm/run-evidence", validSession.api_base_url).href : undefined);
-    upload = await uploadRunEvidence({ endpoint: evidenceEndpoint, token, proof: result.proof, signedEvidence: result.signed_evidence });
+    await save({ status: "failed" });
+    throw error;
   }
-  result.upload = upload;
-  result.artifacts = {
-    min_check: minPath,
-    proof: proofPath,
-    signed_evidence: evidencePath,
-    diagnostics: diagnosticsPath,
-  };
-  if (argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
-  else printFull(result);
-  return result.proof.outcome.status === "failed" ? 1 : 0;
 }
 
 function printHelp() {