@awak-app/simy-cli 0.7.42 → 0.7.44

package/package.json

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

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

@@ -79,11 +79,12 @@ function applyProviderConsent(record, link) {
       revision: (record.run.revision || 0) + 1,
       ...(record.run.managed ? { managed: { ...record.run.managed, autoRecovery: false } } : {}) } } : {}) };
 }
-async function applyArchiveFence(root, record) {
+const readArchiveFence = async file => JSON.parse(await readFile(file, 'utf8')).archived !== false;
+async function applyArchiveFence(root, record, readFence = readArchiveFence) {
   if (!record) return record;
   const file = `${recordPath(root, record.provider, record.session)}.archive-fence`;
   let archived;
-  try { archived = JSON.parse(await readFile(file, 'utf8')).archived !== false; }
+  try { archived = await readFence(file); }
   catch (error) { if (error.code === 'ENOENT') return record; archived = true; }
   if (!archived) return record;
   return { ...record, providerArchived: true, autoContinue: false, tracked: false, monitor: false,
@@ -103,7 +104,7 @@ 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) {
+async function currentProviderConsent(root, records, readFence = readArchiveFence) {
   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'))); }
@@ -111,7 +112,7 @@ async function currentProviderConsent(root, records) {
   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);
+    return applyArchiveFence(root, current, readFence);
   }));
 }
 export async function linkedProvider(root, provider) {
@@ -375,8 +376,50 @@ export function createRecordReader(root = rootDirectory(), { cacheEntries = RECO
       !Number.isSafeInteger(cacheBytes) || cacheBytes < 1 || cacheBytes > RECORD_CACHE_BYTES) throw new Error('Invalid record cache limits.');
   const cache = new Map();
   let inFlight = null, closed = false, retainedBytes = 0;
-  const discard = name => { retainedBytes -= cache.get(name)?.bytes || 0; cache.delete(name); };
+  const discard = name => {
+    const entry = cache.get(name);
+    retainedBytes -= (entry?.bytes || 0) + (entry?.fence?.bytes || 0);
+    cache.delete(name);
+  };
   const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeNs, info.ctimeNs].join(':');
+  const forgetFence = (name, entry) => {
+    if (cache.get(name) === entry) retainedBytes -= entry.fence?.bytes || 0;
+    delete entry.fence;
+  };
+  // Display consumers share a record's bounded cache entry. Each lookup still
+  // checks fresh file metadata; execution/updateRecord use the uncached reader.
+  const readCachedFence = async file => {
+    const name = basename(file).slice(0, -'.archive-fence'.length), entry = cache.get(name);
+    if (!entry) return readArchiveFence(file);
+    let before;
+    try { before = await stat(file, { bigint: true }); }
+    catch { forgetFence(name, entry); return readArchiveFence(file); }
+    if (cache.get(name) !== entry) return readArchiveFence(file);
+    const key = fingerprint(before);
+    if (entry.fence?.key === key) return entry.fence.archived;
+    // Each caller validates metadata before sharing a content read. A later
+    // caller must not join an older read when an external writer replaced it.
+    if (entry.fenceRead?.key === key) return entry.fenceRead.promise;
+    forgetFence(name, entry);
+    const load = async () => {
+      const archived = await readArchiveFence(file);
+      let after;
+      try { after = await stat(file, { bigint: true }); } catch { return archived; }
+      // Never retain a raced value or grow a second byte/entry budget. Admit
+      // fences only from spare budget; eviction still removes whole entries.
+      if (cache.get(name) === entry && fingerprint(after) === key && after.size <= BigInt(cacheBytes)) {
+        forgetFence(name, entry);
+        const bytes = Number(after.size);
+        if (retainedBytes + bytes <= cacheBytes) {
+          entry.fence = { key, archived, bytes }; retainedBytes += bytes;
+        }
+      }
+      return archived;
+    };
+    const pending = load().finally(() => { if (entry.fenceRead?.promise === pending) delete entry.fenceRead; });
+    entry.fenceRead = { key, promise: pending };
+    return pending;
+  };
   const scan = async () => {
     const names = await recordNames(root), live = new Set(names.slice(0, cacheEntries));
     for (const name of cache.keys()) if (!live.has(name)) discard(name);
@@ -406,7 +449,7 @@ 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));
+      return currentProviderConsent(root, structuredClone(await inFlight), readCachedFence);
     },
     async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); retainedBytes = 0; },
   };

package/src/desktop-catalog-frames.js

@@ -3,6 +3,23 @@ import { isDeepStrictEqual } from 'node:util';
 const catalogScope = status => JSON.stringify([status.webOrigin, status.auth?.userId, status.auth?.state,
   status.access?.organizationId, status.access?.revision, status.access?.state]);
 
+function cloneStatusMetadata(status) {
+  const supervision = status?.sessionSupervision;
+  if (!Array.isArray(supervision?.sessions)) return structuredClone(status);
+  return structuredClone({ ...status, sessionSupervision: { ...supervision,
+    sessions: [], ...(Array.isArray(supervision.selectionCandidates) ? { selectionCandidates: [] } : {}) } });
+}
+
+// Only use with an already detached, read-only desktop snapshot. Metadata is
+// independent; callers must replace row arrays/rows rather than mutate them.
+export function copyOwnedDesktopStatus(status) {
+  const detached = cloneStatusMetadata(status), supervision = status?.sessionSupervision;
+  if (!Array.isArray(supervision?.sessions)) return detached;
+  detached.sessionSupervision.sessions = supervision.sessions;
+  if (Array.isArray(supervision.selectionCandidates)) detached.sessionSupervision.selectionCandidates = supervision.selectionCandidates;
+  return detached;
+}
+
 function updateRows(previous, incoming, full, { unchanged = false, immutableInput = false, copyOnWrite = false } = {}) {
   if (full || previous === null || previous.length !== incoming.length) {
     const rows = immutableInput ? incoming : structuredClone(incoming);
@@ -38,8 +55,7 @@ export function createDesktopStatusSnapshot() {
     const nextScope = catalogScope(status);
     if (nextScope !== scope) { rows = candidates = null; scope = nextScope; }
     const hasCandidates = Array.isArray(supervision.selectionCandidates);
-    const detached = structuredClone({ ...status, sessionSupervision: { ...supervision,
-      sessions: [], ...(hasCandidates ? { selectionCandidates: [] } : {}) } });
+    const detached = cloneStatusMetadata(status);
     rows = updateRows(rows, supervision.sessions, false, { copyOnWrite: true }).rows;
     detached.sessionSupervision.sessions = rows;
     if (hasCandidates) {

package/src/desktop-host.js

@@ -1,8 +1,8 @@
 import { createDesktopFrameWriter } from './desktop-frame-writer.js';
-import { createDesktopCatalogEncoder, createDesktopStatusSnapshot } from './desktop-catalog-frames.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';
@@ -221,11 +221,19 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (remoteHosts) {
       void remoteHosts.update({ ...status, providerLinks }).catch(() => {});
       status = remoteHosts.project(status, { providerLinks });
-      for (const candidate of status.sessionSupervision?.sessions || []) {
-        if (!candidate.hostId || candidate.hostId === 'local') continue;
-        const key = teamThreadKey(agent?.getTeamThreadsScope?.() || {}, candidate);
+      const supervision = status.sessionSupervision;
+      if (supervision?.sessions?.some(candidate => candidate.hostId && candidate.hostId !== 'local')) {
+        const scope = agent?.getTeamThreadsScope?.() || {};
         const sharing = teamThreads?.snapshot();
-        candidate.teamSharing = { threadKey: key, enabled: sharing?.own?.some(row => row.threadKey === key && row.enabled) === true, pendingStop: sharing?.pendingStops?.includes(key) === true };
+        // An unusable/scoped-out remote manager may return the borrowed input.
+        // Decorate new rows rather than modifying an older published snapshot.
+        status = { ...status, sessionSupervision: { ...supervision, sessions: supervision.sessions.map(candidate => {
+          if (!candidate.hostId || candidate.hostId === 'local') return candidate;
+          const key = teamThreadKey(scope, candidate);
+          return { ...candidate, teamSharing: { threadKey: key,
+            enabled: sharing?.own?.some(row => row.threadKey === key && row.enabled) === true,
+            pendingStop: sharing?.pendingStops?.includes(key) === true } };
+        }) } };
       }
     }
     if (preferenceScope && desktopAccessReady(status.access) && status.sessionSupervision?.sessions) {
@@ -715,6 +723,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,
@@ -999,7 +1008,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       // a full projection may have advanced it while those reads were waiting.
       const sameScope = desktopAccessReady(currentAccess) &&
         accessScope(lastStatus?.access) === accessScope(currentAccess);
-      const cached = sameScope && lastStatus && controllerScope(lastStatus) === controllerScope(status) ? structuredClone(lastStatus) : null;
+      const cached = sameScope && lastStatus && controllerScope(lastStatus) === controllerScope(status) ? copyOwnedDesktopStatus(lastStatus) : null;
       // A heartbeat is a complete frame: retain optional scoped fields until
       // their replacement is ready, while fresh access/provider data wins.
       if (cached) status = { ...cached, ...status };

package/src/desktop-process-lock.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, realpath, rm, writeFile, stat } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, rm, writeFile, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { windowsProcessStart, windowsUserProcesses } from "./windows-processes.js";
 import { randomBytes } from "node:crypto";
@@ -52,12 +52,18 @@ export async function acquireDesktopProcessLock(root, { pid = process.pid, alive
     return acquireDesktopProcessLock(root, { pid, alive, identity, graceMs, webOrigin });
   }
   const nonce = randomBytes(32).toString("hex");
-  await writeFile(ownerFile, JSON.stringify({
-    pid,
-    nonce,
-    startedAt: await identity(pid),
-    webOrigin: normalizedOriginOrNull(webOrigin),
-  }), { mode: 0o600 });
+  const temporary = join(directory, `owner.${nonce}.tmp`);
+  // Relays can poll while the owner is starting. Publish complete metadata in
+  // one rename so they never parse the empty/partial file created by writeFile.
+  try {
+    await writeFile(temporary, JSON.stringify({
+      pid,
+      nonce,
+      startedAt: await identity(pid),
+      webOrigin: normalizedOriginOrNull(webOrigin),
+    }), { mode: 0o600 });
+    await rename(temporary, ownerFile);
+  } finally { await rm(temporary, { force: true }); }
   return {
     nonce,
     async release() {

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); }