@awak-app/simy-cli 0.7.43 → 0.7.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.43",
+  "version": "0.7.45",
   "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.43";
+export const CLI_VERSION = "0.7.45";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/delivery-hooks/supervisor.js

@@ -160,7 +160,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication, inspectProvider = inspectCodexAppServer, shouldYield, nativeHandoff = reconcileNativeHandoff } = {}) {
+export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, readCancellationRecords, observeTurn, observeAuthentication, inspectProvider = inspectCodexAppServer, shouldYield, nativeHandoff = reconcileNativeHandoff } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
@@ -170,7 +170,11 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
   // OFF changes the consent epoch and removes a task from a scoped activation.
   // Still reconcile its old native queue on reconnect, without admitting work
   // outside this supervisor's selected scope.
-  const cancellationOnly = readRecords ? (await listRecords(root)).filter(r => r.run?.managed?.nativeHandoff && !selectedIds.has(identity(r))) : [];
+  // Desktop callers can share their fresh metadata-validated global index.
+  // Keep it separate from the selected scope: a revoked native queue must still
+  // be cancelled, and the handoff reconciler re-reads authority before acting.
+  const cancellationOnly = readRecords ? (await (readCancellationRecords ? readCancellationRecords() : listRecords(root)))
+    .filter(r => r.run?.managed?.nativeHandoff && !selectedIds.has(identity(r))) : [];
   for (const record of [...selected, ...cancellationOnly]) {
     if (signal?.aborted || await shouldYield?.()) return;
     if ((!execute || record.run?.managed?.nativeHandoff) && await nativeHandoff({ root, record, signal, authorize: authorizeDispatch, cancelOnly: !selectedIds.has(identity(record)) })) nativeOwned.add(identity(record));

package/src/desktop-catalog-frames.js

@@ -41,6 +41,38 @@ function updateRows(previous, incoming, full, { unchanged = false, immutableInpu
   return { rows: immutableInput ? incoming : rows, payload: { count: incoming.length, changes } };
 }
 
+// A display ordering change is not a row-content change. Version 2 references
+// positions in the last delivered base; ambiguous identities are sent in full.
+const rowIdentity = row => row && typeof row.session === 'string' && row.session
+  ? JSON.stringify([row.hostId ?? 'local', row.provider ?? null, row.session]) : null;
+function updateOrderedRows(previous, incoming, full, { unchanged = false, immutableInput = false } = {}) {
+  if (full || previous === null) return updateRows(previous, incoming, true, { immutableInput });
+  if (unchanged) return { rows: previous, payload: { count: previous.length, changes: [] } };
+  const positions = new Map(), incomingCounts = new Map();
+  for (let index = 0; index < previous.length; index++) {
+    const key = rowIdentity(previous[index]);
+    if (key !== null) positions.set(key, positions.has(key) ? -1 : index);
+  }
+  for (const row of incoming) { const key = rowIdentity(row); if (key !== null) incomingCounts.set(key, (incomingCounts.get(key) || 0) + 1); }
+  const order = [], changes = [], rows = [], reused = new Set();
+  let reordered = previous.length !== incoming.length;
+  for (let index = 0; index < incoming.length; index++) {
+    const row = incoming[index], key = rowIdentity(row), source = positions.get(key);
+    const unique = key !== null && incomingCounts.get(key) === 1 && source >= 0;
+    const reuse = unique && !reused.has(source) && isDeepStrictEqual(previous[source], row) ? source
+      : !unique && index < previous.length && !reused.has(index) && isDeepStrictEqual(previous[index], row) ? index : null;
+    if (reuse !== null) {
+      rows.push(previous[reuse]); order.push(reuse); reused.add(reuse);
+      if (reuse !== index) reordered = true;
+    } else {
+      const detached = immutableInput ? row : structuredClone(row);
+      rows.push(detached); order.push(null); changes.push([index, detached]);
+    }
+  }
+  return { rows: immutableInput ? incoming : !reordered && changes.length === 0 ? previous : rows,
+    payload: { count: incoming.length, changes, ...(reordered ? { order } : {}) } };
+}
+
 // Detach mutable producer data once. Unchanged catalog rows may be shared only
 // between these owned read-only snapshots; changed rows get detached copies and
 // a new array. Older queued frames and durable writes must remain immutable.
@@ -69,7 +101,9 @@ export function createDesktopStatusSnapshot() {
 // One encoder per ordered output stream. Call only when a frame actually enters
 // that stream, after replaceable/backpressured snapshots have been coalesced.
 // This cache is transport state; it never authorizes work or provider dispatch.
-export function createDesktopCatalogEncoder({ immutableInput = false } = {}) {
+export function createDesktopCatalogEncoder({ immutableInput = false, version = 1 } = {}) {
+  if (![1, 2].includes(version)) throw new Error('Unsupported desktop catalog version.');
+  const projectRows = version === 2 ? updateOrderedRows : updateRows;
   let rows = null, candidates = null, sourceRows = null, sourceCandidates = null, scope = null, revision = 0;
   const reset = () => { rows = null; candidates = null; sourceRows = null; sourceCandidates = null; scope = null; };
   return { reset, encode(frame) {
@@ -81,16 +115,16 @@ export function createDesktopCatalogEncoder({ immutableInput = false } = {}) {
     const incoming = status.sessionSupervision.sessions;
     const identity = catalogScope(status);
     const previous = revision++;
-    const full = rows === null || scope !== identity || rows.length !== incoming.length;
-    const snapshot = updateRows(rows, incoming, full, { immutableInput, unchanged: immutableInput && sourceRows === incoming });
+    const full = rows === null || scope !== identity || version === 1 && rows.length !== incoming.length;
+    const snapshot = projectRows(rows, incoming, full, { immutableInput, unchanged: immutableInput && sourceRows === incoming });
     rows = snapshot.rows; sourceRows = incoming; scope = identity;
-    const catalog = { version: 1, revision, scope, ...(full ? {} : { baseRevision: previous }), ...snapshot.payload };
+    const catalog = { version, revision, scope, ...(full ? {} : { baseRevision: previous }), ...snapshot.payload };
     const { sessions, ...metadata } = status.sessionSupervision;
     let supervision = metadata;
     if (Array.isArray(metadata.selectionCandidates)) {
       // This is another complete directory, used by the conversation picker.
       // Do not silently retransmit it as supposedly small status metadata.
-      const snapshot = updateRows(candidates, metadata.selectionCandidates, full,
+      const snapshot = projectRows(candidates, metadata.selectionCandidates, full,
         { immutableInput, unchanged: immutableInput && sourceCandidates === metadata.selectionCandidates });
       candidates = snapshot.rows; sourceCandidates = metadata.selectionCandidates; catalog.selectionCandidates = snapshot.payload;
       const { selectionCandidates, ...small } = metadata;

package/src/desktop-host.js

@@ -2,7 +2,7 @@ import { createDesktopFrameWriter } from './desktop-frame-writer.js';
 import { createDesktopCatalogEncoder, createDesktopStatusSnapshot, copyOwnedDesktopStatus } from './desktop-catalog-frames.js';
 import { boundedDiscovery } from './session-supervision/progressive-discovery.js';
 import { createCatalogRefreshPolicy } from './session-supervision/catalog-refresh.js';
-import { supervisedSession } from './session-supervision/discovery-window.js';
+import { liveSessionWindow, supervisedSession } from './session-supervision/discovery-window.js';
 import { createClaudeDesktopArchiveController } from './session-supervision/claude-desktop-archive.js';
 import { createClaudeDesktopNativeAdapter } from './session-supervision/claude-desktop-native.js';
 import { applyControllerExecutionContext } from './session-supervision/execution-context.js';
@@ -160,8 +160,8 @@ export { createDesktopFrameWriter } from './desktop-frame-writer.js';
 
 export async function startDesktopHost({ input = process.stdin, output = process.stdout, env = process.env,
   updatePackageRoot, dependencies = {}, exit = (code) => process.exit(code) } = {}) {
-  let catalogEncoder = env.SIMY_REMOTE_CHILD !== '1' && env.SIMY_DESKTOP_CATALOG_DELTA === '1'
-    ? createDesktopCatalogEncoder({ immutableInput: true }) : null;
+  let catalogEncoder = env.SIMY_REMOTE_CHILD !== '1' && ['1', '2'].includes(env.SIMY_DESKTOP_CATALOG_DELTA)
+    ? createDesktopCatalogEncoder({ immutableInput: true, version: env.SIMY_DESKTOP_CATALOG_VERSION === '2' ? 2 : Number(env.SIMY_DESKTOP_CATALOG_DELTA) }) : null;
   // Object frames below own detached snapshots. Queue their references rather
   // than copying multi-MiB history again whenever a native reader is paused.
   const frames = createDesktopFrameWriter(output, { capture: frame => frame,
@@ -605,6 +605,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const link = await requireProviderLink({ root: deliveryRoot, provider: record.provider });
       return JSON.stringify([scope, link.epoch]);
     }, readRecords: () => recordReader.list(),
+    readCancellationRecords: () => recordReader.list(),
     readCurrentRecord: (provider, session) => readRecord(deliveryRoot, provider, session),
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
@@ -723,6 +724,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const historyTimeoutMs = dependencies.historyDiscoveryTimeoutMs ?? dependencies.discoveryTimeoutMs ?? 300_000;
       sessionRefresh = boundedDiscovery((signal, startHistory) => (dependencies.discoverSessions || discoverSessions)({
         root: deliveryRoot, signal, onDrain: trackDiscoveryDrain, includeArchived: true, includeSelectionCandidates: true, recentOnly: refresh.recentOnly,
+        recentArchiveCandidates: liveSessionWindow(sessionStatus.sessions.filter(item => item.provider === 'codex' && item.archived !== true && item.delegated !== true)),
         readRecords: () => recordReader.list(),
         connectedProviders: PROVIDER_LINKS.filter(provider => providerLinks[provider].connected),
         timeoutMs: firstPageTimeoutMs, historyTimeoutMs,
@@ -2562,7 +2564,8 @@ if (isDesktopHostEntry()) {
   try {
     const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
     if (process.env.SIMY_DESKTOP_ATTACH_OWNER === '1' && await relayToOwner({ root, webOrigin: resolveWebOrigin(null, process.env), desktopClient: true,
-      catalogDeltas: process.env.SIMY_DESKTOP_CATALOG_DELTA === '1' })) process.exit(0);
+      catalogDeltas: ['1', '2'].includes(process.env.SIMY_DESKTOP_CATALOG_DELTA)
+        ? process.env.SIMY_DESKTOP_CATALOG_VERSION === '2' ? 2 : Number(process.env.SIMY_DESKTOP_CATALOG_DELTA) : false })) process.exit(0);
     try { await adoptInstalledRuntime({ root }); }
     catch (error) {
       if (error.code === PROCESS_CONFLICT_CODE) throw error;

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

@@ -329,8 +329,13 @@ export async function listCodexSessions({ client, all = false, signal, onPage, m
 // Absence from the recent active window does not mean archived. Only the
 // provider's archived list or its exact archived rollout path proves it.
 const archiveProbeOffsets = new Map();
+// Navigation eligibility is distinct from positive archive fencing: excluded
+// worker sources may still revoke consent without replacing delegated rows.
+export function archivedCodexMetadata(metadata) {
+  return metadata && SOURCE_KINDS.includes(metadata.source) ? { ...metadata, archived: true } : null;
+}
 export async function readCodexArchiveStates(client, candidates, { budgetMs = 3000,
-  codexHome = process.env.CODEX_HOME || join(homedir(), '.codex') } = {}) {
+  codexHome = process.env.CODEX_HOME || join(homedir(), '.codex'), observedArchived } = {}) {
   const states = new Map();
   if (!candidates.length) return states;
   const deadline = Date.now() + budgetMs;
@@ -343,7 +348,13 @@ export async function readCodexArchiveStates(client, candidates, { budgetMs = 30
     if (method === 'thread/list' && params.archived === true && Array.isArray(response?.data)) {
       for (const thread of response.data.slice(0, params.limit)) {
         const metadata = codexThreadMetadata(thread);
-        if (metadata && eligible.has(metadata.session)) states.set(metadata.session, true);
+        if (metadata && eligible.has(metadata.session)) {
+          states.set(metadata.session, true);
+          if (observedArchived) {
+            const archived = archivedCodexMetadata(metadata);
+            if (archived) observedArchived.set(metadata.session, archived);
+          }
+        }
       }
     }
     return response;
@@ -363,6 +374,12 @@ export async function readCodexArchiveStates(client, candidates, { budgetMs = 30
         if (thread?.id !== candidate.session || typeof thread.path !== 'string' || !isAbsolute(thread.path)) continue;
         const state = codexArchivePathState(thread.path, candidate.session, codexHome);
         if (state !== undefined) states.set(candidate.session, state);
+        if (state === false) observedArchived?.delete(candidate.session);
+        if (state === true && observedArchived) {
+          const metadata = codexThreadMetadata(thread);
+          const archived = archivedCodexMetadata(metadata);
+          if (archived) observedArchived.set(metadata.session, archived);
+        }
       } catch { /* Unknown or missing sessions remain visible. */ }
     }
   }));

package/src/session-supervision/index.js

@@ -10,7 +10,7 @@ import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { isAbsolute } from 'node:path';
 import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, deliveryDecisionRevision, associationBlocksFollowup, canUpgradeDelivery, canExplicitlyResumeStopped, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive, ownerRenewalPending } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
-import { listCodexSessions, codexThreadMetadata, openCodexAppServer, readCodexSession, readCodexObservation, readCodexArchiveStates, CodexAppServerError } from './codex-app-server.js';
+import { listCodexSessions, codexThreadMetadata, openCodexAppServer, readCodexSession, readCodexObservation, readCodexArchiveStates, archivedCodexMetadata, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
 import { originalSessionTarget } from './original-session-target.js';
@@ -165,7 +165,7 @@ export async function discoverSessions(options = {}) {
 }
 
 async function discoverSessionCatalog({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, recentOnly = false, catalogSnapshot, recordSnapshot, archiveReconciliations = new Map(), readRecords = listRecords, onProgress } = {}) {
+  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, recentOnly = false, recentArchiveCandidates = [], catalogSnapshot, recordSnapshot, archiveReconciliations = new Map(), readRecords = listRecords, onProgress } = {}) {
   const now = requestedNow ?? Date.now();
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
@@ -195,19 +195,22 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
         const active = await listCodexSessions({ client, all: !recentOnly, signal, inspectState: true, codexHome,
           onPage: async items => { discovered = [...items]; await progress({ discovered, archivedCodex }); },
           prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) });
-        if (includeArchived) {
-          const observedArchives = new Map();
+        const observedArchives = new Map();
+        // Archived navigation belongs to the full/history refresh. A recent
+        // poll still observes missing supervised sessions below, so archival
+        // revokes their consent immediately without rewriting cold fences.
+        if (includeArchived && !recentOnly) {
           const archiveClient = { request: async (method, params) => {
             const response = await client.request(method, params);
             if (method === 'thread/list' && params.archived === true) {
               for (const thread of (response?.data || []).slice(0, params.limit)) {
-                const item = codexThreadMetadata(thread);
-                if (item && ['cli', 'vscode', 'appServer'].includes(item.source)) observedArchives.set(item.session, { ...item, archived: true });
+                const item = archivedCodexMetadata(codexThreadMetadata(thread));
+                if (item) observedArchives.set(item.session, item);
               }
             }
             return response;
           } };
-          try { await listCodexSessions({ client: archiveClient, all: !recentOnly, signal, archived: true,
+          try { await listCodexSessions({ client: archiveClient, all: true, signal, archived: true,
             onPage: async () => { archivedCodex = [...observedArchives.values()]; await progress({ discovered, archivedCodex }); } }); }
           catch (error) {
             codexError = 'Codex archive discovery incomplete. Refresh to retry.';
@@ -216,7 +219,21 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
           archivedCodex = [...observedArchives.values()];
         }
         const ids = new Set(active.map(item => item.session));
-        archiveStates = await readCodexArchiveStates(client, records.filter(record => record.provider === 'codex' && !ids.has(record.session) && (!recentOnly || supervisedSession(record))), { codexHome });
+        const archiveCandidates = new Map(records.filter(record => record.provider === 'codex' && !ids.has(record.session) && (!recentOnly || supervisedSession(record)))
+          .map(record => [record.session, record]));
+        // A recent, untracked conversation can be archived in Codex itself.
+        // Observe omissions from the previous bounded live window too; pins
+        // and historical navigation never expand this into an unbounded set.
+        if (recentOnly) for (const item of recentArchiveCandidates.slice(0, RECENT_SESSION_LIMIT)) {
+          if (item.provider === 'codex' && item.archived !== true && item.delegated !== true && !ids.has(item.session) && !archiveCandidates.has(item.session)) archiveCandidates.set(item.session, item);
+        }
+        const exactArchiveObservations = new Map();
+        archiveStates = await readCodexArchiveStates(client, [...archiveCandidates.values()],
+          { codexHome, ...(includeArchived ? { observedArchived: exactArchiveObservations } : {}) });
+        // Preserve current titles/ancestry from the already-required archive
+        // observations, including exact-read recovery during listing outages.
+        for (const [session, item] of exactArchiveObservations) if (!observedArchives.has(session)) observedArchives.set(session, item);
+        archivedCodex = [...observedArchives.values()];
         for (const item of archivedCodex) archiveStates.set(item.session, true);
         return active;
       }, signal); }

package/src/session-supervision/owner-transport.js

@@ -45,7 +45,8 @@ export async function createOwnerTransport({ root, nonce, allowedActions, dispat
         if (!authenticated) {
           if (command.nonce !== nonce) { peer.destroy(); return; }
           authenticated = true; desktopClient = allowDesktopClient && command.client === 'desktop'; controllerArchive = allowControllerArchive && command.client === 'archive-controller'; clearTimeout(timeout); peers.add(peer);
-          if (desktopClient && (command.desktopProtocol === 2 || command.catalogDeltas === 1)) catalogEncoders.set(peer, createDesktopCatalogEncoder());
+          if (desktopClient && (command.desktopProtocol === 2 || command.catalogDeltas === 1))
+            catalogEncoders.set(peer, createDesktopCatalogEncoder({ version: command.catalogVersion === 2 ? 2 : 1 }));
           if ([1, 2].includes(command.desktopProtocol) && desktopClient) send(peer, { type: 'desktop_owner_ready', version: catalogEncoders.has(peer) ? 2 : 1 });
           // One-shot controls need their result, not multi-megabyte broadcasts
           // that can fill the write queue before the result is sent.
@@ -119,7 +120,8 @@ export async function relayToOwner({ root, webOrigin, input = process.stdin, out
   } catch (error) { peer.destroy(); throw error; }
   // A protocol-1 owner replies with complete frames. New native windows accept
   // both versions, so attaching never requires replacing its execution owner.
-  peer.write(JSON.stringify({ nonce: owner.nonce, ...(desktopClient ? { client: 'desktop', desktopProtocol: 1, ...(catalogDeltas ? { catalogDeltas: 1 } : {}) } : {}) }) + '\n');
+  peer.write(JSON.stringify({ nonce: owner.nonce, ...(desktopClient ? { client: 'desktop', desktopProtocol: 1,
+    ...(catalogDeltas ? { catalogDeltas: 1, ...(catalogDeltas === 2 ? { catalogVersion: 2 } : {}) } : {}) } : {}) }) + '\n');
   // Old owners ignore unknown hello fields and expose only the restricted SSH
   // projection. Never attach a native window or forward its controls as though
   // that were a complete desktop endpoint. Keep the original owner untouched.