@awak-app/simy-cli 0.7.43 → 0.7.44

package/package.json

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

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';
@@ -723,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,

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