@awak-app/simy-cli 0.5.54 → 0.5.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.54",
+  "version": "0.5.55",
   "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.55";
 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

@@ -157,12 +157,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);
     }

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,