@awak-app/simy-cli 0.7.48 → 0.7.50

package/package.json

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

package/src/cli-contract.js

@@ -14,7 +14,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.48";
+export const CLI_VERSION = "0.7.50";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

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

@@ -87,9 +87,8 @@ function applyProviderConsent(record, link) {
       ...(record.run.managed ? { managed: { ...record.run.managed, autoRecovery: false } } : {}) } } : {}) };
 }
 const readArchiveFence = async file => JSON.parse(await readFile(file, 'utf8')).archived !== false;
-async function applyArchiveFence(root, record, readFence = readArchiveFence) {
+async function applyArchiveFence(root, record, readFence = readArchiveFence, file = record && `${recordPath(root, record.provider, record.session)}.archive-fence`) {
   if (!record) return record;
-  const file = `${recordPath(root, record.provider, record.session)}.archive-fence`;
   let archived;
   try { archived = await readFence(file); }
   catch (error) { if (error.code === 'ENOENT') return record; archived = true; }
@@ -111,15 +110,16 @@ export async function recordProviderArchive(root, provider, session, archived, o
     await rename(temporary, file);
   } finally { await rm(temporary, { force: true }); await releaseStateLock(lock, token); }
 }
-async function currentProviderConsent(root, records, readFence = readArchiveFence) {
+async function currentProviderConsent(root, records, readFence = readArchiveFence, recordNames) {
   const links = Object.fromEntries(await Promise.all(['codex', 'claude'].map(async provider => [provider, await providerLinkState(root, provider)])));
   let archiveNames;
   try { archiveNames = new Set((await readdir(root)).filter(name => name.endsWith('.archive-fence'))); }
   catch { /* A failed index read falls back to fresh per-record fencing. */ }
   return Promise.all(records.map(record => {
     const current = applyProviderConsent(record, links[record.provider] || {});
-    if (archiveNames && !archiveNames.has(`${basename(recordPath(root, record.provider, record.session))}.archive-fence`)) return current;
-    return applyArchiveFence(root, current, readFence);
+    const name = recordNames?.get(record) || basename(recordPath(root, record.provider, record.session));
+    if (archiveNames && !archiveNames.has(`${name}.archive-fence`)) return current;
+    return applyArchiveFence(root, current, readFence, join(root, `${name}.archive-fence`));
   }));
 }
 export async function linkedProvider(root, provider) {
@@ -413,7 +413,7 @@ export async function listRecords(root = rootDirectory()) {
 export function createRecordReader(root = rootDirectory(), { cacheEntries = RECORD_CACHE_LIMIT, cacheBytes = RECORD_CACHE_BYTES } = {}) {
   if (!Number.isSafeInteger(cacheEntries) || cacheEntries < 1 || cacheEntries > RECORD_CACHE_LIMIT ||
       !Number.isSafeInteger(cacheBytes) || cacheBytes < 1 || cacheBytes > RECORD_CACHE_BYTES) throw new Error('Invalid record cache limits.');
-  const cache = new Map();
+  const cache = new Map(), validatedNames = new WeakMap();
   let inFlight = null, closed = false, retainedBytes = 0;
   const discard = name => {
     const entry = cache.get(name);
@@ -469,6 +469,9 @@ export function createRecordReader(root = rootDirectory(), { cacheEntries = RECO
         const cached = cache.get(name);
         if (cached?.key === key) return cached.record;
         const record = before.size <= BigInt(MAX_STATE_BYTES) ? await readNamedRecord(root, name) : null;
+        // A private, validated identity need not be hashed again on every list.
+        // Weak keys share the existing record lifetime and cache budgets.
+        if (record) validatedNames.set(record, name);
         // Do not retain a value when a write races the read; the next list must
         // inspect it again. This also prevents malformed transient JSON sticking.
         const after = await stat(path, { bigint: true });
@@ -488,7 +491,9 @@ export function createRecordReader(root = rootDirectory(), { cacheEntries = RECO
       if (!inFlight) inFlight = scan().finally(() => { inFlight = null; });
       // Consumers can decorate/mutate their own snapshots without corrupting the
       // cached records or a simultaneous caller's view.
-      return currentProviderConsent(root, structuredClone(await inFlight), readCachedFence);
+      // Consent/fence projection never mutates private records. Detach after
+      // projection so their validated filenames survive through fresh fencing.
+      return structuredClone(await currentProviderConsent(root, await inFlight, readCachedFence, validatedNames));
     },
     async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); retainedBytes = 0; },
   };

package/src/desktop-host.js

@@ -799,12 +799,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
           for (const item of incoming || []) rows.set(`${item.provider}:${item.session}`, item);
           return [...rows.values()];
         };
+        const firstUsablePage = sessionStatus.initialLoading !== false;
         sessionStatus = { ...sessionStatus, ...value,
           sessions: linkedSessions(merge(sessionStatus.sessions, value.sessions)).sort(compareSessionWork),
           selectionCandidates: merge(sessionStatus.selectionCandidates || [], value.selectionCandidates),
           initialLoading: false, completeProviders: [...complete], discoveryAttempt: attempt, catalogRevision: ++catalogRevision };
         sessionRefreshedAt = Date.now();
-        void publish().catch(() => {});
+        void (firstUsablePage || force ? publish() : publishBackground()).catch(() => {});
         void refreshCatalogAnalysis();
       };
       const firstPageTimeoutMs = dependencies.discoveryTimeoutMs ?? 30_000;
@@ -825,9 +826,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
           refresh.complete(!failed);
           sessionStatus = { ...sessionStatus, historyLoading: false,
             discoveryAttempt: { ...attempt, state: failed ? 'failed' : 'succeeded', completedAt: Date.now() } };
-          // Publish before PR/network observation and queue maintenance. Neither
-          // operation owns the first usable catalog or the discovery promise.
-          void publish().catch(() => {});
+          // The first usable page already published without waiting for optional
+          // enrichment. Coalesce later pages/completion with background updates.
+          void (force ? publish() : publishBackground()).catch(() => {});
           const enrichment = enrichmentController = new AbortController();
           const catalog = sessionStatus;
           sessionEnrichment = boundedDiscovery(async signal => {
@@ -838,7 +839,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             if (closed || relay || signal.aborted || !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope || sessionStatus !== catalog) return;
             sessionStatus = { ...sessionStatus, sessions: linkedSessions(sessions) };
             await queue;
-            if (!signal.aborted) void publish().catch(() => {});
+            if (!signal.aborted) void (force ? publish() : publishBackground()).catch(() => {});
           }, { signal: enrichment.signal, timeoutMs: dependencies.enrichmentTimeoutMs ?? 10_000, onDrain: trackDiscoveryDrain })
             .catch(() => {}).finally(() => { if (enrichmentController === enrichment) { enrichmentController = null; sessionEnrichment = null; } });
         })
@@ -846,7 +847,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           historyLoading: false, discoveryAttempt: { ...attempt, state: 'failed', completedAt: Date.now() },
           providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
         .finally(() => { if (discoveryController === controller) discoveryController = null; sessionRefresh = null; if (sessionRefreshAgain && !closed && !relay) { sessionRefreshAgain = false; refreshSessions(true); }
-          if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
+          if (!closed) setImmediate(() => { void (force ? publish() : publishBackground()).catch(() => {}); }); });
     }
     return sessionStatus;
   };
@@ -1053,17 +1054,29 @@ export async function startDesktopHost({ input = process.stdin, output = process
       setImmediate(() => { void publish().catch(() => {}); });
     } },
   });
-  // Batch burst notifications and heartbeat/status requests into one frame. The
-  // short window leaves commands responsive and the regular heartbeat intact.
-  const publish = () => {
+  // Background producers share the normal heartbeat window. Explicit commands
+  // promote a pending background publication instead of inheriting its delay.
+  const schedulePublication = delay => {
     if (closed || relay || !agent) return Promise.resolve();
-    if (!scheduledPublish) {
+    const dueAt = Date.now() + delay;
+    if (scheduledPublish && scheduledPublish.dueAt <= dueAt) return scheduledPublish.promise;
+    let pending = scheduledPublish;
+    if (pending) clearTimeout(pending.timer);
+    else {
       let resolve, reject;
       const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
-      scheduledPublish = { promise, resolve, timer: setTimeout(() => { scheduledPublish = null; projectStatus().then(resolve, reject); }, 75) };
+      pending = { promise, resolve, reject };
     }
-    return scheduledPublish.promise;
+    pending.dueAt = dueAt;
+    pending.timer = setTimeout(() => {
+      scheduledPublish = null;
+      projectStatus().then(pending.resolve, pending.reject);
+    }, delay);
+    scheduledPublish = pending;
+    return pending.promise;
   };
+  const publish = () => schedulePublication(75);
+  const publishBackground = () => schedulePublication(3000);
   let lastDeadlineFailureAt = -Infinity;
   let connectionPublishing = null;
   let connectionRevision = 0;
@@ -1419,7 +1432,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       deferStartupSynchronization: true, enforceDesktopAccess: true,
       suspendOrganizationAnalyses, resumeOrganizationAnalyses,
       onDesktopStatusChange: () => {
-        // Let an in-progress frame finish before publishing its new snapshot.
+        // Connection/auth/task observations must not wait for background metadata.
         setImmediate(() => { void publish().catch(() => {}); });
       },
     });

package/src/update-detachment/runtime.js

@@ -36,6 +36,14 @@ export async function worktreeEvidence(worktree) {
 }
 const stopped = new Set(['stopped','paused','paused_by_user','cancelled']);
 const terminal = new Set(['completed','reported_done','failed','succeeded']);
+const terminalLocalTasks = new Set(['succeeded','failed','stopped']);
+function hasPendingExecution(task, localTask = false) {
+  // Coding runs use operation for an async handle. Local Tasks persist their
+  // operation kind (for example "read") even after completion and restoration.
+  const operation = localTask ? task.operation != null && typeof task.operation !== 'string' : task.operation;
+  return Boolean(task.child || operation || task.operation_promise || task.pendingLedgerUpdate || task.ledgerUpdateRunning ||
+    (localTask ? !terminalLocalTasks.has(task.status) : ['queued','running','dispatching','coding'].includes(task.status)));
+}
 const taskState = run => stopped.has(run.state) ? run.state : run.managed?.pendingApproval ? 'approval_wait' : ['blocked','waiting_human','recovery_required'].includes(run.state) ? 'needs_user' : 'active';
 const originalTaskId = record => record.run.managed?.taskId || record.run.id;
 const authority = record => digest([record.run?.id,record.run?.state,record.run?.managed,record.run?.deadline,record.run?.continuations,record.run?.failures,record.autoContinue,record.process,record.cwd,record.run?.executionCwd]);
@@ -167,7 +175,8 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
     if(startingGate.connection!=='detaching')return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
     retainer?.assertSupported([]);
     const c=context(), execution=[...(c.runs||[]),...(c.localTasks||[])];
-    const unowned=execution.filter(run=>run.child || run.operation || run.pendingLedgerUpdate || run.ledgerUpdateRunning || ['queued','running','dispatching','coding'].includes(run.status));
+    const unowned=[...(c.runs||[]).filter(run=>hasPendingExecution(run)),
+      ...(c.localTasks||[]).filter(task=>hasPendingExecution(task,true))];
     const workers=[];
     for(const task of c.directTasks || []) {
       if(!['queued','running','stopping'].includes(task.status)) continue;