@awak-app/simy-cli 0.5.59 → 0.5.61

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/review-worker.js

@@ -14,6 +14,8 @@ const DEFAULT_LEASE_SECONDS = 300;
 // Claim can retrieve and freeze organization-scoped Slack evidence (45s budget).
 const DEFAULT_REQUEST_TIMEOUT_MS = 75_000;
 const DEFAULT_EXECUTION_TIMEOUT_MS = 240_000;
+// Pin SQM independently of the user's interactive model and CLI defaults.
+export const SQM_CODEX_MODEL = "gpt-6.1-sol";
 
 export class SqmLocalReviewError extends Error {
   constructor(message, { status = null, code = "sqm_local_review_error" } = {}) {
@@ -244,6 +246,8 @@ export async function runStructuredProviderReview(
         ...(readOnlyAnalysis ? ["--system-prompt", request.system, "--max-turns", "1"] : []),
       ] : [
         "exec",
+        "--model",
+        SQM_CODEX_MODEL,
         "--skip-git-repo-check",
         "--sandbox",
         "read-only",
@@ -276,7 +280,7 @@ export async function runStructuredProviderReview(
     }
     return {
       output,
-      model: `${provider}-local/${inspection.installed_version || "unknown"}`,
+      model: provider === "codex" ? SQM_CODEX_MODEL : `${provider}-local/${inspection.installed_version || "unknown"}`,
     };
   } catch (error) {
     if (error instanceof SqmLocalReviewError || error?.code === 'desktop_access_required') throw error;