@awak-app/simy-cli 0.5.54 → 0.5.56

package/package.json

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

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.54";
+export const CLI_VERSION = "0.5.56";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

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

@@ -121,6 +121,13 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
     return next;
   } finally { if (temporary) await rm(temporary, { force: true }); await releaseStateLock(lock, lockToken); }
 }
+export async function readRecord(root = rootDirectory(), provider, session) {
+  const path = recordPath(root, provider, session);
+  try {
+    const record = await read(path);
+    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 => {

package/src/delivery-hooks/supervisor.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, listRecords, managedBudgetReason, notifyState, processIdentity, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { resolveBackendExecutable } from '../backend-executable.js';
 import { executeCodexAppServer } from '../session-supervision/codex-app-server.js';
 import { acquireWorkspaceLease, leaseOwnerDead } from '../session-supervision/workspace-lease.js';
@@ -20,7 +20,7 @@ function providerFailureReason(code) {
 }
 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 listRecords(root)).find(item => item.provider === provider && item.session === session);
+  const current = await readRecord(root, provider, session);
   if (signal?.aborted || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) {
     throw new Error('Managed recovery lease changed before provider dispatch.');
   }
@@ -95,8 +95,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     };
     signal?.addEventListener('abort', terminate, { once: true });
     const watch = setInterval(() => {
-      void listRecords(root).then(records => {
-        const current = records.find(item => item.provider === record.provider && item.session === record.session);
+      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);
@@ -123,9 +122,8 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
-  await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}) });
+  const records = await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}) });
   if (signal?.aborted) return;
-  const records = await listRecords(root);
   for (let record of records) {
     if (signal?.aborted) break;
     const claimNow = currentTime();
@@ -212,8 +210,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     else signal?.addEventListener('abort', abort, { once: true });
     const timeout = setTimeout(abort, Math.max(1, claimed.run.deadline - currentTime()));
     const watch = setInterval(() => {
-      void listRecords(root).then(records => {
-        const current = records.find(item => item.provider === record.provider && item.session === record.session);
+      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());

package/src/desktop-host.js

@@ -181,13 +181,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
         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 discovery = refreshSessions();
       automaticContinuation?.tick(discovery.sessions);
       const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
-      await actionAssociations.decorateSessions?.(sessions);
+      await actionAssociations.decorateSessions?.(sessions, projection);
       for (const session of sessions) {
-        const context = await actionAssociations.deadlineContext?.(session);
+        const context = await actionAssociations.deadlineContext?.(session, projection);
         if (context) session.actionDeadline = await deadlines.reconcile(context);
         else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
         const run = status.deliveryHooks.runs?.find(item => item.provider === session.provider && item.session === session.session);

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

@@ -1,5 +1,5 @@
 import { createOrdinaryAssociationStore } from './association-store.js';
-import { listRecords, updateRecord, TERMINAL, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { listRecords, readRecord, updateRecord, TERMINAL, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { createActionAssociationApi, ActionAssociationApiError } from './action-association-api.js';
 import { actionCandidateRequest, prepareActionAssociation, importActionBinding,
   settleActionAssociation, cancelActionAssociation } from './action-association.js';
@@ -28,7 +28,7 @@ const deadlineBlocker = (record, candidate) => {
 // Association is optional metadata. Network failures never control the task's
 // work state; provider turns and their budgets remain owned by the supervisor.
 export function createActionAssociationHost({ root, sessionRoot, webOrigin, api = createActionAssociationApi({ webOrigin, sessionRoot }),
-  now = Date.now, refreshMs = 60_000, list = listRecords, onChange = () => {} } = {}) {
+  now = Date.now, refreshMs = 60_000, list = listRecords, read = readRecord, onChange = () => {} } = {}) {
   const abort = new AbortController(), views = new Map();
   const ordinary = createOrdinaryAssociationStore({ root, api, webOrigin, now, onChange });
   let auth = null, closed = false, running = null, serial = Promise.resolve();
@@ -52,7 +52,10 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     }
     return next;
   };
-  const fresh = async target => (await list(root)).find(record => eligible(record) && record.provider === target.provider && record.session === target.session && record.run.managed.taskId === target.taskId);
+  const fresh = async target => {
+    const record = await read(root, target.provider, target.session);
+    return eligible(record || {}) && record.run.managed.taskId === target.taskId ? record : null;
+  };
   const valid = async expected => !closed && expected && await current() === expected;
   const importEnvelope = async (record, envelope, expected, userCorrection = false) => {
     if (!await valid(expected)) throw new ActionAssociationApiError('account_changed');
@@ -159,19 +162,28 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     }));
   }
   return {
-    async decorateSessions(sessions) {
-      await ordinary.decorate(sessions);
+    // A projection is private to one desktop frame. Mutations and deadline
+    // validation still reread the exact record and current authentication.
+    async beginProjection() {
+      await current();
       const records = await list(root);
-      const status = { runs: sessions.filter(item => records.some(record => record.provider === item.provider && record.session === item.session && record.run?.managed)).map(item => {
-        const record = records.find(record => record.provider === item.provider && record.session === item.session);
+      return { records, byKey: new Map(records.map(record => [`${record.provider}:${record.session}`, record])) };
+    },
+    async decorateSessions(sessions, projection) {
+      await ordinary.decorate(sessions, projection);
+      const records = projection?.byKey || new Map((await list(root)).map(record => [`${record.provider}:${record.session}`, record]));
+      const status = { runs: sessions.filter(item => records.get(`${item.provider}:${item.session}`)?.run?.managed).map(item => {
+        const record = records.get(`${item.provider}:${item.session}`);
         return { managed: true, taskId: record.run.managed.taskId, actionAssociation: record.run.managed.actionAssociation, candidate: item };
       }) };
       await this.decorate(status);
       for (const run of status.runs) run.candidate.actionAssociation = run.actionAssociation;
       return sessions;
     },
-    async deadlineContext(candidate) {
-      const expected = await current(), record = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+    async deadlineContext(candidate, projection) {
+      const expected = await current(), record = projection
+        ? projection.byKey.get(`${candidate.provider}:${candidate.session}`)
+        : await read(root, candidate.provider, candidate.session);
       const local = record?.run?.managed?.actionAssociation || record?.actionAssociation;
       if (!expected || local?.authRevision !== expected || !candidate.actionAssociation?.canCorrect) return null;
       const binding = candidate.actionAssociation.binding;
@@ -181,7 +193,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         plan: record.run?.managed?.plan || candidate.analysis?.plan || null, blocker: deadlineBlocker(record, candidate), online: true,
         validate: async () => {
           if (!await valid(expected)) return false;
-          const latest = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+          const latest = await read(root, candidate.provider, candidate.session);
           const scoped = latest?.run?.managed?.actionAssociation || latest?.actionAssociation;
           return (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
         } };

package/src/session-supervision/action-deadline-store.js

@@ -47,10 +47,11 @@ export function createActionDeadlineStore({ root }) {
         }
         return next === undefined ? previous : next;
       });
-      queues.set(
-        path,
-        result.catch(() => {}),
-      );
+      const tail = result.catch(() => {}).finally(() => {
+        // A newer transaction owns the queue until it too has settled.
+        if (queues.get(path) === tail) queues.delete(path);
+      });
+      queues.set(path, tail);
       return result;
     },
   };

package/src/session-supervision/action-deadline.js

@@ -153,7 +153,6 @@ export function createActionDeadlineService({
   async function reconcile(context) {
     const key = identity(context),
       action = context.binding?.action;
-    const dueInstant = actionDueInstant(action?.dueAt, action?.timeZone);
     const bindingRevision =
       context.binding?.revision ?? context.bindingRevision ?? null;
     const fingerprint = hash([
@@ -176,6 +175,10 @@ export function createActionDeadlineService({
           : previous.bindingRevision > bindingRevision)
       )
         return previous;
+      // An unchanged valid deadline already stores its exact due instant.
+      // Avoid rebuilding Intl formatters and repeating the timezone search.
+      if (previous?.fingerprint === fingerprint && previous.status !== 'unavailable') return previous;
+      const dueInstant = actionDueInstant(action?.dueAt, action?.timeZone);
       // A pre-JST cache may mark the same date-only value unavailable. Repair
       // that entry once without invalidating already valid saved decisions.
       if (previous?.fingerprint === fingerprint && !(previous.status === "unavailable" && dueInstant !== null)) return previous;

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

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import {
   listRecords,
+  readRecord,
   updateRecord,
 } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { associationRevision } from './action-association.js';
@@ -54,12 +55,7 @@ export function createOrdinaryAssociationStore({
     abort = new AbortController();
   let serial = Promise.resolve(),
     closed = false;
-  const find = async (candidate) =>
-    (await listRecords(root)).find(
-      (item) =>
-        item.provider === candidate.provider &&
-        item.session === candidate.session,
-    );
+  const find = candidate => readRecord(root, candidate.provider, candidate.session);
   async function ensure(candidate, known) {
     if (
       !['codex', 'claude'].includes(candidate.provider) ||
@@ -189,9 +185,9 @@ export function createOrdinaryAssociationStore({
     }
   }
   return {
-    async decorate(sessions) {
+    async decorate(sessions, snapshot) {
       const records = new Map(
-        (await listRecords(root)).map((record) => [
+        (snapshot?.records || await listRecords(root)).map((record) => [
           `${record.provider}:${record.session}`,
           record,
         ]),

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

@@ -4,12 +4,14 @@ import { realpath } from 'node:fs/promises';
 import { inspectBackendExecutable } from '../backend-executable.js';
 import { assessedCheckpointContract, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { boundConversation, boundProviderGoal, textContent } from './conversation-context.js';
+import { JsonDataUrlFilter } from './json-data-url-filter.js';
 
 const REQUEST_TIMEOUT = 15_000;
 const MAX_LINE = 256 * 1024;
 const ANALYSIS_MAX_LINE = 1024 * 1024;
 const ANALYSIS_MAX_TURNS = 16;
 const ANALYSIS_PAGE_SIZE = 6;
+const ANALYSIS_MAX_WIRE_LINE = 8 * 1024 * 1024;
 const SOURCE_KINDS = ['cli', 'vscode', 'exec', 'appServer', 'unknown'];
 
 export class CodexAppServerError extends Error {
@@ -21,7 +23,7 @@ export class CodexAppServerError extends Error {
 }
 
 export class CodexAppServerClient {
-  constructor(child, { maxLineBytes = MAX_LINE } = {}) {
+  constructor(child, { maxLineBytes = MAX_LINE, omitInlineAttachments = false } = {}) {
     this.maxLineBytes = Number.isInteger(maxLineBytes) ? Math.max(MAX_LINE, Math.min(maxLineBytes, 8 * 1024 * 1024)) : MAX_LINE;
     this.child = child;
     this.nextId = 0;
@@ -30,15 +32,21 @@ export class CodexAppServerClient {
     this.closed = false;
     // Provider output can include private text. Hold only one bounded JSON-RPC
     // line at a time, and discard overlong lines before parsing them.
-    let pending = Buffer.alloc(0), discard = false;
+    let pending = Buffer.alloc(0), discard = false, wireBytes = 0;
+    let filter = omitInlineAttachments ? new JsonDataUrlFilter() : null;
     child.stdout.on('data', chunk => {
       let offset = 0;
       while (offset < chunk.length) {
         const newline = chunk.indexOf(10, offset);
         const end = newline < 0 ? chunk.length : newline;
-        const piece = chunk.subarray(offset, end);
+        let piece = chunk.subarray(offset, end);
         if (!discard) {
-          if (pending.length + piece.length > this.maxLineBytes) {
+          wireBytes += piece.length;
+          // Analysis does not use attachment bytes. Remove inline data URLs
+          // before its retained-byte limit, with a separate finite wire cap.
+          const wireLimit = omitInlineAttachments ? ANALYSIS_MAX_WIRE_LINE : this.maxLineBytes;
+          if (wireBytes <= wireLimit && filter) piece = filter.push(piece);
+          if (wireBytes > wireLimit || pending.length + piece.length > this.maxLineBytes) {
             pending = Buffer.alloc(0); discard = true;
             this.rejectPending(new CodexAppServerError('response_too_large', 'Codex response exceeded the bounded context limit.'));
           }
@@ -46,7 +54,9 @@ export class CodexAppServerClient {
         }
         if (newline >= 0) {
           if (!discard && pending.length) this.consume(pending.toString('utf8'));
-          pending = Buffer.alloc(0); discard = false; offset = newline + 1;
+          pending = Buffer.alloc(0); discard = false; wireBytes = 0;
+          filter = omitInlineAttachments ? new JsonDataUrlFilter() : null;
+          offset = newline + 1;
         } else offset = end;
       }
     });
@@ -124,7 +134,7 @@ 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 } = {}) {
+export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes, omitInlineAttachments = false } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
   const inspection = await inspectExecutable('codex');
   if (!inspection?.available || !inspection.executable) throw new CodexAppServerError('unavailable', 'Codex executable is unavailable.');
@@ -134,7 +144,7 @@ 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 });
+  const client = new CodexAppServerClient(child, { maxLineBytes, omitInlineAttachments });
   try {
     await client.request('initialize', { clientInfo: { name: 'simy_session_supervision', title: 'SIMY Session Supervision', version: '1.0.0' } });
     client.notify('initialized');
@@ -157,12 +167,24 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, maxPages = 40, pageSize = 5, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
+export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = 200, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
   const sessions = [];
-  let cursor = null;
-  for (let page = 0; page < maxPages; page++) {
-    const response = await client.request('thread/list', { cursor, limit: pageSize, sourceKinds: SOURCE_KINDS, archived: false });
-    for (const thread of response?.data || []) {
+  const windowSize = Math.min(maxSessions, maxPages * pageSize);
+  let cursor = null, listed = 0, pages = 0, batchSize = pageSize;
+  while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
+    const limit = Math.min(batchSize, windowSize - listed);
+    let response;
+    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS, archived: false }); }
+    catch (error) {
+      // Keep the transport's byte limit. Retry the same cursor in smaller
+      // batches rather than dropping discovery for large metadata envelopes.
+      if (error?.code !== 'response_too_large' || limit <= 1) throw error;
+      batchSize = Math.max(1, Math.floor(limit / 2));
+      continue;
+    }
+    const threads = (response?.data || []).slice(0, limit);
+    listed += threads.length; pages++;
+    for (const thread of threads) {
       const metadata = codexThreadMetadata(thread);
       if (metadata) sessions.push(metadata);
     }
@@ -244,7 +266,7 @@ 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 });
+  const client = await openClient({ signal, maxLineBytes: ANALYSIS_MAX_LINE, omitInlineAttachments: true });
   const cancelled = () => { void client.close(); };
   signal?.addEventListener('abort', cancelled, { once: true });
   try {
@@ -257,22 +279,28 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     const terminal = turn => ['completed', 'interrupted', 'failed'].includes(turn?.status);
     const turns = [];
     const turnIds = new Set(), cursors = new Set();
+    let pageSize = ANALYSIS_PAGE_SIZE;
+    const readPage = async (cursor, maximum = ANALYSIS_PAGE_SIZE) => {
+      let limit = Math.min(pageSize, maximum);
+      for (;;) {
+        if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
+        try {
+          const page = await client.request('thread/turns/list', { threadId: candidate.session, cursor, limit, sortDirection: 'desc', itemsView: 'summary' });
+          if (!Array.isArray(page?.data) || page.data.length > limit || page.nextCursor != null && (typeof page.nextCursor !== 'string' || !page.nextCursor || page.nextCursor.length > 2048)) {
+            throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid bounded conversation page.');
+          }
+          return page;
+        } catch (error) {
+          if (unsupportedMethod(error)) throw new CodexAppServerError('unsupported', 'This Codex version does not support bounded conversation history.');
+          if (error?.code !== 'response_too_large' || limit <= 1) throw error;
+          pageSize = limit = Math.max(1, Math.floor(limit / 2));
+        }
+      }
+    };
     let cursor = null;
     do {
       if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-      const limit = Math.min(ANALYSIS_PAGE_SIZE, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
-      let page;
-      try {
-        page = await client.request('thread/turns/list', { threadId: candidate.session, cursor, limit, sortDirection: 'desc', itemsView: 'summary' });
-      } catch (error) {
-        if (String(error?.code) === '-32601' || /unknown method|method.*not found|unrecognized method/i.test(String(error?.message || ''))) {
-          throw new CodexAppServerError('unsupported', 'This Codex version does not support bounded conversation history.');
-        }
-        throw error;
-      }
-      if (!Array.isArray(page?.data) || page.data.length > limit || page.nextCursor != null && (typeof page.nextCursor !== 'string' || !page.nextCursor || page.nextCursor.length > 2048)) {
-        throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid bounded conversation page.');
-      }
+      const page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
       for (const turn of page.data) {
         if (typeof turn?.id !== 'string' || !turn.id || turnIds.has(turn.id)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous conversation pagination.');
         turnIds.add(turn.id); turns.push(turn);
@@ -286,13 +314,18 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // to this read-only snapshot, but a newly settled turn must invalidate it.
     const settled = turns.filter(terminal).slice(0, ANALYSIS_MAX_TURNS);
     const boundary = settled[0];
-    const verification = await client.request('thread/turns/list', {
-      threadId: candidate.session, cursor: null, limit: ANALYSIS_PAGE_SIZE, sortDirection: 'desc', itemsView: 'summary',
-    });
-    if (!Array.isArray(verification?.data) || verification.data.length > ANALYSIS_PAGE_SIZE) {
-      throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid snapshot check.');
+    let verification = await readPage(null);
+    const verificationTurns = [...verification.data];
+    const verificationCursors = new Set();
+    // A reduced first page may contain only the running turn. Follow bounded
+    // pages to the terminal boundary rather than mistaking it for a new one.
+    while (!verificationTurns.some(terminal) && verification.nextCursor && verificationTurns.length < ANALYSIS_MAX_TURNS + ANALYSIS_PAGE_SIZE) {
+      if (!verification.data.length || verificationCursors.has(verification.nextCursor)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous snapshot pagination.');
+      verificationCursors.add(verification.nextCursor);
+      verification = await readPage(verification.nextCursor);
+      verificationTurns.push(...verification.data);
     }
-    const latestBoundary = verification.data.find(terminal);
+    const latestBoundary = verificationTurns.find(terminal);
     // Compare the immutable settled summary, never the running turn's prose.
     if (JSON.stringify(boundary) !== JSON.stringify(latestBoundary)) {
       throw new CodexAppServerError('turn_settling', 'The latest turn settled during the snapshot read.');
@@ -310,7 +343,7 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // A display summary omits intermediate reasoning/tool context even when
     // every turn fits. Never represent it as the complete conversation; the
     // classifier must establish a self-contained objective from retained text.
-    const awaitingTurn = latestMetadata.isRunning === true || [...turns, ...verification.data].some(turn => ['inProgress', 'in_progress'].includes(turn?.status));
+    const awaitingTurn = latestMetadata.isRunning === true || [...turns, ...verificationTurns].some(turn => ['inProgress', 'in_progress'].includes(turn?.status));
     let incomplete = !settled.length || turns.some(turn => !terminal(turn) && !['inProgress', 'in_progress'].includes(turn?.status)), truncated = true;
     for (const [index, turn] of settled.toReversed().entries()) {
       if (turn.itemsView === 'notLoaded') { truncated = true; if (turn === boundary) incomplete = true; continue; }

package/src/session-supervision/index.js

@@ -1,6 +1,6 @@
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { TERMINAL as TERMINAL_RUNS, controlDelivery, listRecords, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+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 { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
@@ -133,7 +133,7 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
 }
 
 export async function readSessionAutoContinue({ root, provider, session }) {
-  const record = (await listRecords(root)).find(item => item.provider === provider && item.session === session);
+  const record = await readRecord(root, provider, session);
   return { enabled: record?.autoContinue === true, epoch: record?.autoContinueEpoch || null,
     settings: record?.autoContinueSettings, hasRun: Boolean(record?.run) };
 }
@@ -190,14 +190,14 @@ export async function enrollSession({ root, provider, session, objective, accept
   let metadata;
   if (provider === 'claude') {
     metadata = await readClaude(session);
-    const record = (await listRecords(root)).find(item => item.provider === provider && item.session === session);
+    const record = await readRecord(root, provider, session);
     if (!await liveClaudeHook(record, metadata, inspectProcess)) throw new Error('Claude needs a live matching SIMY SessionStart hook; cold CLI takeover is unavailable.');
     if (record.run) throw new Error('This session already has a Delivery Loop.');
     await monitorSession({ root, provider, session, monitor: true, readClaude: async () => metadata, now });
     // A second check narrows the time between metadata admission and the
     // original provider's next Stop boundary. Process exit still remains a
     // manual recovery condition; SIMY never starts claude -r.
-    if (!await liveClaudeHook((await listRecords(root)).find(item => item.provider === provider && item.session === session), metadata, inspectProcess)) throw new Error('Claude provider process exited before enrollment.');
+    if (!await liveClaudeHook(await readRecord(root, provider, session), metadata, inspectProcess)) throw new Error('Claude provider process exited before enrollment.');
   } else {
     metadata = await monitorSession({ root, provider, session, monitor: true, openClient, now });
     if (!metadata.model) throw new Error('Codex did not expose this conversation’s model; automatic continuation is unavailable.');
@@ -205,7 +205,7 @@ export async function enrollSession({ root, provider, session, objective, accept
   const cwd = await realpath(metadata.cwd);
   const initialPlan = initialDiagnosisPlan(objective.trim(), contextBootstrap);
   const admission = provider === 'codex' ? { source: 'codex_app_server', provider, session, cwd, model: metadata.model } : undefined;
-  const liveRecord = provider === 'claude' ? (await listRecords(root)).find(item => item.provider === provider && item.session === session) : null;
+  const liveRecord = provider === 'claude' ? await readRecord(root, provider, session) : null;
   const run = await startDelivery({ root, provider, session, cwd, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
     maxMinutes, maxContinuations, maxFailures, now, admission, inspectProcess, autoContinueEpoch,
     liveHookAdmission: liveRecord ? { hookStartedAt: liveRecord.hookStartedAt, pid: liveRecord.process.pid, identity: liveRecord.process.identity } : undefined,

package/src/session-supervision/json-data-url-filter.js

@@ -0,0 +1,66 @@
+// JSON remains validated by JSON.parse after this lexical filter. Only inline
+// URL values are removed; prose, identities, cursors and escaped quotes retain
+// their original bytes. Latin-1 here preserves split UTF-8 sequences verbatim.
+export class JsonDataUrlFilter {
+  constructor() {
+    this.inString = false;
+    this.escaped = false;
+    this.token = '';
+    this.lastString = null;
+    this.valueKey = null;
+    this.probe = null;
+    this.dropping = false;
+  }
+
+  push(bytes) {
+    let output = '';
+    for (const char of bytes.toString('latin1')) {
+      if (!this.inString) {
+        output += char;
+        if (char === '"') {
+          this.inString = true;
+          this.token = '';
+          this.escaped = false;
+          this.probe = ['url', 'imageUrl', 'image_url'].includes(this.valueKey) ? '' : null;
+          this.dropping = false;
+          this.valueKey = null;
+        } else if (char === ':') {
+          this.valueKey = this.lastString;
+          this.lastString = null;
+        } else if (!/\s/.test(char)) {
+          this.lastString = null;
+          this.valueKey = null;
+        }
+        continue;
+      }
+      const closing = char === '"' && !this.escaped;
+      if (closing) {
+        if (this.probe !== null) output += this.probe;
+        output += char;
+        this.inString = false;
+        this.lastString = null;
+        if (this.token !== null && !this.dropping) {
+          try { this.lastString = JSON.parse(Buffer.from(`"${this.token}"`, 'latin1').toString('utf8')); } catch { /* Final JSON validation rejects malformed input. */ }
+        }
+        this.probe = null;
+        this.dropping = false;
+        continue;
+      }
+      if (this.token !== null) this.token = this.token.length < 128 ? this.token + char : null;
+      if (this.escaped) this.escaped = false;
+      else if (char === '\\') this.escaped = true;
+      if (this.dropping) continue;
+      if (this.probe !== null) {
+        this.probe += char;
+        if (!'data:'.startsWith(this.probe)) {
+          output += this.probe;
+          this.probe = null;
+        } else if (this.probe === 'data:') {
+          this.dropping = true;
+          this.probe = null;
+        }
+      } else output += char;
+    }
+    return Buffer.from(output, 'latin1');
+  }
+}