@awak-app/simy-cli 0.7.20 → 0.7.21

package/src/delivery-hooks/lifecycle-recovery.js

@@ -0,0 +1,82 @@
+import { automaticContinuationAllowed, hasPendingUserStop, queuePurposeDiagnosis,
+  updateRecord, advanceDeliveryControlRevision } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { requireProviderLink } from '../provider-links.js';
+import { openCodexAppServer, readCodexObservation } from '../session-supervision/codex-app-server.js';
+
+function eligible(record) {
+  const run = record?.run, managed = run?.managed;
+  if (record?.provider !== 'codex' || record.autoContinue !== true || !automaticContinuationAllowed(record) ||
+      !managed?.purpose?.enabled || managed.resumeChannel !== 'codex_app_server' ||
+      !['active', 'recovery_required', 'blocked'].includes(run.state) || run.stopReason?.actor === 'user' ||
+      managed.resumeLease || managed.liveWorkspaceLease || managed.outcomeAudit?.lease ||
+      managed.nativeWait || managed.purpose.nativeBoundary || managed.providerWarning ||
+      managed.userQuestion || managed.understandingQuestion || managed.dependencyWait ||
+      managed.authenticationWait || managed.phase === 'understanding' || managed.usageBlocked) return false;
+  // A restart is never approval for an effect. Only a controller-generated
+  // local context-selection wait can yield to independent read diagnosis.
+  const pending = managed.pendingApproval;
+  if (pending && (pending.denied || pending.kind !== 'scope_change' || managed.decision?.assessment?.externalEffect !== 'local' ||
+      managed.decision.assessment.reversibility !== 'reversible' || managed.decision.assessment.inObjective !== true ||
+      managed.decision.assessment.userChoice !== false)) return false;
+  return true;
+}
+
+// Called once by the owning supervisor after a durable activation is loaded.
+// It preserves the same run, purpose, budgets and effect history, and queues a
+// read. An interrupted write is reconciled before any proposal to repeat it.
+export async function reconcileLifecycleRecovery({ root, records, eventId, authorize = async () => {}, sessionEndedAt }) {
+  for (const record of records) {
+    if (!eligible(record) || hasPendingUserStop(root, record)) continue;
+    try {
+      const link = await requireProviderLink({ root, provider: record.provider });
+      await authorize(record);
+      await updateRecord(root, record.provider, record.session, async current => {
+        if (!eligible(current) || hasPendingUserStop(root, current) || current.run.id !== record.run.id ||
+            current.run.revision !== record.run.revision || current.run.controlRevision !== record.run.controlRevision ||
+            current.autoContinueEpoch !== record.autoContinueEpoch || current.run.managed.lifecycleRecovery?.eventId === eventId ||
+            sessionEndedAt !== undefined && !endedSession(current, sessionEndedAt)) return current;
+        await requireProviderLink({ root, provider: record.provider, expectedEpoch: link.epoch });
+        await authorize(current);
+        const run = current.run, managed = run.managed, previousState = run.state;
+        const pending = managed.pendingApproval ? structuredClone(managed.pendingApproval) : null;
+        const queued = queuePurposeDiagnosis(run,
+          'The provider session ended or the local execution host returned after an interruption. Read the saved task and actual current artifacts first. Keep the original goal, corrections, permission ceiling, budgets and explicit stops. Reconcile unfinished or uncertain effects before proposing more work; do not replay a prior write or treat recovery as approval. Inspect the current execution context and choose useful authorized work.',
+          `lifecycle:${eventId}`, Date.now(), 'interrupted_owner');
+        if (queued) {
+          managed.lifecycleRecovery = { eventId, at: Date.now(), previousState, mode: 'read_before_continue', retainedApproval: pending };
+          advanceDeliveryControlRevision(run);
+          run.updatedAt = Date.now();
+        }
+        return current;
+      });
+    } catch (error) {
+      if (['provider_link_disconnected', 'provider_link_changed'].includes(error.code) ||
+          /^Delivery state (?:is busy; retry the command\.|lock owner is unavailable; inspect the lock before retrying\.)$/.test(error.message)) continue;
+      throw error;
+    }
+  }
+}
+
+function endedSession(record, at = record.hookEndedAt) {
+  return record.lastEvent === 'SessionEnd' && Number.isFinite(at) && at > 0 && record.hookEndedAt === at &&
+    record.run?.state === 'recovery_required' && record.run.recoveryCause === 'session_end';
+}
+
+async function observeEndedSession(record) {
+  const client = await openCodexAppServer();
+  try { return await readCodexObservation(client, record.session); }
+  finally { await client.close(); }
+}
+
+// A provider can end while the supervisor remains alive. Reconcile each such
+// event once, after confirming the original conversation has no active turn.
+export async function reconcileEndedSessions({ root, records, eventId, authorize, observe = observeEndedSession }) {
+  for (const record of records) {
+    if (!endedSession(record) || !eligible(record) || hasPendingUserStop(root, record)) continue;
+    let observation;
+    try { observation = await observe(record); } catch { continue; }
+    if (observation?.isRunning !== false) continue;
+    await reconcileLifecycleRecovery({ root, records: [record], authorize,
+      eventId: `${eventId}:session-end:${record.session}:${record.hookEndedAt}`, sessionEndedAt: record.hookEndedAt });
+  }
+}

package/src/delivery-hooks/local-supervisor.js

@@ -1,4 +1,8 @@
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
+import { listRecords } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { readSupervisorState } from './supervisor-owner.js';
+import { supervisorTargetMatches } from './supervisor-activation.js';
+import { reconcileLifecycleRecovery, reconcileEndedSessions } from './lifecycle-recovery.js';
 import { setTimeout as delay } from 'node:timers/promises';
 import { assertNoDesktopHostForOrigin } from '../desktop-process-lock.js';
 import { createManagedSupervisor } from './supervisor.js';
@@ -6,6 +10,8 @@ import { acquireSupervisorOwner } from './supervisor-owner.js';
 import { pendingSupervisorHandover, acknowledgeSupervisorDrain } from './supervisor-handover.js';
 
 export async function superviseLocalDelivery({ root, webOrigin, once = false, signal,
+  activationEpoch, readActivation = readSupervisorState, reconcileStartup = reconcileLifecycleRecovery,
+  reconcileSessionEnds = reconcileEndedSessions,
   createSupervisor = createManagedSupervisor, checkOwner = assertNoDesktopHostForOrigin, wait = delay,
   acquireOwner = acquireSupervisorOwner, pendingHandover = pendingSupervisorHandover,
   acknowledgeDrain = acknowledgeSupervisorDrain } = {}) {
@@ -16,13 +22,28 @@ export async function superviseLocalDelivery({ root, webOrigin, once = false, si
   const owner = await acquireOwner(dirname(root), { handoverVersion: 1 });
   try {
   await check();
+  const activationFile = join(dirname(root), 'supervisor-runtime/control.json');
+  const activation = activationEpoch ? await readActivation(activationFile) : null;
+  const activationCurrent = value => value?.version === 1 && value.enabled === true && value.epoch === activationEpoch;
+  if (activationEpoch && !activationCurrent(activation)) return;
+  const authorizeDispatch = async record => {
+    const current = await readActivation(activationFile);
+    if (!activationCurrent(current) || !supervisorTargetMatches(current, record)) throw new Error('Supervisor activation or target changed.');
+    return activationEpoch;
+  };
+  const readRecords = async () => (await listRecords(root)).filter(record => supervisorTargetMatches(activation, record));
+  if (activationEpoch) await reconcileStartup({ root, records: await readRecords(),
+    eventId: `${activationEpoch}:${owner.nonce}`, authorize: authorizeDispatch });
   const supervisor = createSupervisor({ root, webOrigin,
-    shouldYield: async () => Boolean(await pendingHandover(dirname(root), owner.nonce)) });
+    ...(activationEpoch ? { readRecords, authorizeDispatch } : {}),
+    shouldYield: async () => Boolean(activationEpoch && !activationCurrent(await readActivation(activationFile)) ||
+      await pendingHandover(dirname(root), owner.nonce)) });
   const stop = () => { void supervisor.close(); };
   signal?.addEventListener('abort', stop, { once: true });
   try {
     do {
       if (signal?.aborted) break;
+      if (activationEpoch && !activationCurrent(await readActivation(activationFile))) break;
       const handover = await pendingHandover(dirname(root), owner.nonce);
       if (handover) {
         await supervisor.drain();
@@ -30,6 +51,8 @@ export async function superviseLocalDelivery({ root, webOrigin, once = false, si
         break;
       }
       await check();
+      if (activationEpoch) await reconcileSessionEnds({ root, records: await readRecords(),
+        eventId: activationEpoch, authorize: authorizeDispatch });
       await supervisor.tick();
       if (once) { await supervisor.idle?.(); break; }
       try { await wait(3_000, undefined, { signal }); }

package/src/delivery-hooks/supervisor-activation.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { readRecord, automaticContinuationAllowed } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// Activation is durable OS recovery consent, separate from task permissions.
+// A scoped activation binds the existing run/consent, never a future task that
+// happens to reuse the conversation id.
+export async function supervisorTarget(root, target) {
+  if (!target || !['codex', 'claude'].includes(target.provider) || typeof target.session !== 'string' || !target.session) {
+    throw new Error('Select an exact provider and session for supervisor recovery.');
+  }
+  const record = await readRecord(join(root, 'delivery-hooks'), target.provider, target.session);
+  if (!record?.run?.managed || record.autoContinue !== true || !record.autoContinueEpoch ||
+      !automaticContinuationAllowed(record) || ['stopped', 'paused', 'completed', 'reported_done', 'budget_exhausted'].includes(record.run.state)) {
+    throw new Error('Supervisor activation requires an existing opted-in task; explicit task stops remain stopped.');
+  }
+  return { provider: record.provider, session: record.session, runId: record.run.id, autoContinueEpoch: record.autoContinueEpoch };
+}
+
+export function supervisorTargetMatches(control, record) {
+  if (!Object.hasOwn(control || {}, 'targets')) return true;
+  return Array.isArray(control.targets) && control.targets.some(target =>
+    target.provider === record.provider && target.session === record.session &&
+    typeof target.runId === 'string' && target.runId === record.run?.id &&
+    typeof target.autoContinueEpoch === 'string' && target.autoContinueEpoch === record.autoContinueEpoch);
+}

package/src/delivery-hooks/supervisor-service.js

@@ -24,12 +24,12 @@ export function supervisorServiceDefinition({ root, entry, node = process.execPa
   if (platform === 'linux') {
     const name = 'simy-delivery-supervisor.service';
     return { name, file: join(home, '.config/systemd/user', name),
-      content: `# ${marker}\n[Unit]\nDescription=SIMY Delivery supervisor recovery\n\n[Service]\nType=simple\nExecStart=${[node, ...args].map(systemdArgument).join(' ')}\nRestart=on-failure\nRestartSec=15\nKillMode=process\n\n[Install]\nWantedBy=default.target\n` };
+      content: `# ${marker}\n[Unit]\nDescription=SIMY Delivery supervisor recovery\n\n[Service]\nType=simple\nExecStart=${[node, ...args].map(systemdArgument).join(' ')}\nRestart=always\nRestartSec=15\nKillMode=process\n\n[Install]\nWantedBy=default.target\n` };
   }
   if (platform === 'darwin') {
     const name = 'com.awak.simy.delivery-supervisor';
     return { name, file: join(home, 'Library/LaunchAgents', `${name}.plist`), content:
-      `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><!-- ${marker} --><dict><key>Label</key><string>${name}</string><key>ProgramArguments</key><array>${[node, ...args].map(arg => `<string>${xml(arg)}</string>`).join('')}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>15</integer></dict></plist>` };
+      `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><!-- ${marker} --><dict><key>Label</key><string>${name}</string><key>ProgramArguments</key><array>${[node, ...args].map(arg => `<string>${xml(arg)}</string>`).join('')}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>15</integer></dict></plist>` };
   }
   if (platform === 'win32') {
     const name = 'SIMYDeliverySupervisor';

package/src/delivery-hooks/supervisor-watchdog.js

@@ -1,3 +1,4 @@
+import { supervisorTarget } from './supervisor-activation.js';
 import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -19,7 +20,9 @@ async function verifiedPin(root) {
   return { digest: pin.digest, release: pin.release };
 }
 export async function setSupervisorWatchdog({ root, enabled, webOrigin,
-  inspectPin = verifiedPin, now = Date.now(), expectedEpoch } = {}) {
+  inspectPin = verifiedPin, now = Date.now(), expectedEpoch, target } = {}) {
+  if (target && !enabled) throw new Error('A recovery target requires explicit enable.');
+  const binding = target ? await supervisorTarget(root, target) : null;
   const pin = enabled ? await inspectPin(root) : null;
   const lock = await acquireDesktopProcessLock(join(folder(root), 'control-lock'), {
     alive: supervisorProcessAlive, identity: supervisorProcessIdentity });
@@ -27,6 +30,8 @@ export async function setSupervisorWatchdog({ root, enabled, webOrigin,
   const previous = await readSupervisorState(controlPath(root));
   if (expectedEpoch !== undefined && previous?.epoch !== expectedEpoch) return previous;
   const control = { version: 1, enabled: enabled === true, epoch: randomUUID(), updatedAt: now,
+    selection: { source: 'explicit_command', action: enabled ? 'enable' : 'disable', at: now },
+    ...(binding ? { targets: [binding] } : {}),
     ...(pin ? { ...pin, webOrigin: resolveWebOrigin(webOrigin) } : {}) };
   await saveSupervisorState(controlPath(root), control);
   return control;
@@ -49,9 +54,11 @@ export function createSupervisorWatchdog({ root, inspectPin = verifiedPin, readC
     if (closed) return;
     const at = clock(), control = await readControl();
     controlEpoch = control?.epoch;
+    const wake = lastWall !== null && (at < lastWall || at - lastWall > 60_000);
+    lastWall = at;
     const previous = pendingPin || await readSupervisorState(statePath(root));
     const state = { version: 1, handoverVersion: 1, watcherNonce, at, action: 'observe', supervisor: null, lastExit,
-      lastLaunchAt: launchTime ?? previous?.lastLaunchAt ?? null, epoch: control?.epoch || null };
+      lastLaunchAt: launchTime ?? previous?.lastLaunchAt ?? null, epoch: control?.epoch || null, lifecycle: wake ? 'wake' : 'observe' };
     if (!control || control.version !== 1 || control.enabled !== true) { state.action = 'disabled'; await save(state); return state; }
     state.supervisor = await observeOwner(root, { now: at });
     if (state.supervisor.state === 'running') {
@@ -77,10 +84,8 @@ export function createSupervisorWatchdog({ root, inspectPin = verifiedPin, readC
     }
     // Resume/sleep or clock regression is an observation boundary, never proof
     // that a live provider stopped. Re-observe on the next tick first.
-    if (lastWall !== null && (at < lastWall || at - lastWall > 60_000)) {
-      lastWall = at; state.action = 'wake_reobserve'; await save(state); return state;
+    if (wake) { state.action = 'wake_reobserve'; await save(state); return state;
     }
-    lastWall = at;
     try { await checkDesktop(root, null); }
     catch (error) {
       if (error.code !== 'process_conflict') throw error;
@@ -102,7 +107,7 @@ export function createSupervisorWatchdog({ root, inspectPin = verifiedPin, readC
         !finalControl?.enabled || finalControl.epoch !== control.epoch) {
       state.action = 'launch_cancelled'; await save(state); return state;
     }
-    const args = [join(pin.release, 'src/index.js'), 'delivery', 'supervise', '--host', control.webOrigin, '--no-auto-update'];
+    const args = [join(pin.release, 'src/index.js'), 'delivery', 'supervise', '--activation-epoch', control.epoch, '--host', control.webOrigin, '--no-auto-update'];
     child = launch(process.execPath, args, { env: { ...process.env, SIMY_HOME: root, SIMY_AUTO_UPDATE: '0' },
       detached: process.platform !== 'win32', stdio: 'ignore', windowsHide: true });
     const launched = child;

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { remoteOperationFailure } from './session-supervision/remote-errors.js';
 import { createRemoteHostManager } from './session-supervision/remote-hosts.js';
 import { readDesktopAutoUpdate, writeDesktopAutoUpdate } from './desktop-update-settings.js';
 import { createUpdateRuntime } from './update-detachment/runtime.js';
@@ -25,7 +26,7 @@ import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, reco
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
-import { AutoContinueUnavailableError, answerSession, continueSession, resumeSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
+import { AutoContinueUnavailableError, answerSession, continueSession, followupSession, resumeSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
 import { createContinuationAnalysisManager } from "./session-supervision/analysis-manager.js";
 import { analyzeContinuation, readContinuationContext } from "./session-supervision/continuation-analysis.js";
 import { continueAnalyzedSession, createAutomaticContinuation } from "./session-supervision/automatic-continuation.js";
@@ -177,8 +178,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       auto_update_busy: updateSettings.auto_update_busy === true } };
     if (env.SIMY_REMOTE_CHILD === "1") status = { ...status, remoteSessionProtocol: 1 };
     if (remoteHosts) {
-      void remoteHosts.update(providerLinks.codex.connected ? status : { ...status, access: { state: "unavailable" } }).catch(() => {});
-      if (providerLinks.codex.connected) status = remoteHosts.project(status);
+      void remoteHosts.update(PROVIDER_LINKS.some(provider => providerLinks[provider].connected) ? status : { ...status, access: { state: "unavailable" } }).catch(() => {});
+      if (PROVIDER_LINKS.some(provider => providerLinks[provider].connected)) status = remoteHosts.project(status, { providerLinks });
     }
     if (updateProgress) status = { ...status, update: { ...status.update, ...updateProgress } };
     const { sampledAt, ...content } = status;
@@ -1167,7 +1168,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           commandProviderLink = await requireProviderLink({ root: deliveryRoot, provider: command.provider });
         }
         if (command.hostId && command.hostId !== 'local') {
-          if (!remoteHosts || command.provider !== 'codex') throw Object.assign(new Error('Remote host is unavailable.'), { code: 'remote_host_unavailable' });
+          if (!remoteHosts || !PROVIDER_LINKS.includes(command.provider)) throw Object.assign(new Error('Remote host is unavailable.'), { code: 'remote_host_unavailable' });
           await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
           const status = await agent.getDesktopStatus();
           // Status collection can yield while provider consent is revoked.
@@ -1529,6 +1530,19 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await (dependencies.monitorSession || monitorSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, monitor: action === "session_monitor", expectedProviderEpoch: commandProviderLink?.epoch });
           await refreshSessions(true);
+        } else if (action === "session_followup") {
+          const candidate = await selectedSession(command);
+          if (!candidate.followup?.previousRunId || command.previousRunId !== candidate.followup.previousRunId) {
+            throw new Error('The finished task changed. Refresh this conversation before starting its follow-up.');
+          }
+          if (typeof command.objective !== 'string' || !command.objective.trim() || command.objective.length > 4000) {
+            throw new Error('Enter the current goal to continue.');
+          }
+          await authorizeProvider(candidate.provider, commandScope, selectedLinkEpochs.get(candidate));
+          await (dependencies.followupSession || followupSession)({ root: join(root, 'delivery-hooks'),
+            provider: command.provider, session: command.session, previousRunId: command.previousRunId,
+            objective: command.objective, followupAutoContinue: true, expectedProviderEpoch: selectedLinkEpochs.get(candidate) });
+          await refreshSessions(true);
         } else if (action === "session_enroll") {
           await (dependencies.enrollSession || enrollSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, objective: command.objective, acceptanceCriteria: command.acceptanceCriteria,
@@ -1571,7 +1585,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             providerLinkFeedback[provider] = { state: 'error', message: desktopActionError(command.action, error) };
           }
         }
-        emit({ type: "result", id: command.id, ok: false, ...(error?.code === 'cancelled' || statisticsRequest?.controller.signal.aborted ? { code: 'cancelled' } : {}), message: ["update", "prepare_update_restart"].includes(command.action) && updateProgress ? updateProgress.message : desktopActionError(command.action, error) });
+        emit({ type: "result", id: command.id, ok: false, ...(remoteOperationFailure(error?.code).code ? { code: error.code } : {}), ...(error?.code === 'cancelled' || statisticsRequest?.controller.signal.aborted ? { code: 'cancelled' } : {}), message: ["update", "prepare_update_restart"].includes(command.action) && updateProgress ? updateProgress.message : desktopActionError(command.action, error) });
       } finally {
         // Access rejection can happen before the shared reader is constructed.
         if (statisticsRequest && !statisticsRequest.promise && activeStatisticsRead === statisticsRequest) {

package/src/index.js

@@ -149,7 +149,7 @@ async function runCommand(installMode) {
   simy sqm lint       Validate module reliability before publication
   simy sqm replay     Replay modules against labelled historical snapshots
   simy update --check Check the installed and latest stable CLI versions
-  simy sessions       Show local Codex conversations (--interactive for search/navigation)
+  simy sessions       Show local and registered remote Codex/Claude conversations (--interactive for search/navigation)
   simy update         ${installMode === "macos_installer" ? "Show Apple Silicon update status and installer action" : "Install an eligible stable CLI update"}
 
 Options:

package/src/session-supervision/claude-sessions.js

@@ -160,17 +160,17 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, includeBoundary = false, signal } = {}) {
+async function collect({ home = homedir(), all = false, limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, includeBoundary = false, signal } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
-  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, RECENT_SESSION_LIMIT)) : 100;
+  const maximum = all ? Infinity : Number.isInteger(limit) ? Math.max(1, Math.min(limit, RECENT_SESSION_LIMIT)) : 100;
   const observedAt = Date.now();
   const result = new Map();
   const descriptors = [], priorities = new Set(prioritySessions);
   let projects;
   try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
-  for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, MAX_PROJECTS)) {
+  for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, all || session ? undefined : MAX_PROJECTS)) {
     if (signal?.aborted) return [];
     const project = join(root, entry.name);
     let files;
@@ -203,11 +203,11 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
         ...(!candidate.parentSession && origin.parentSession ? { parentSession: origin.parentSession, parentSessionSource: origin.source } : {}) };
     return candidate;
   };
-  const selected = session ? descriptors : [
+  const selected = session || all ? descriptors : [
     ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived !== true), { limit: maximum, priority: item => priorities.has(item.session) }),
     ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived === true), { limit: maximum, priority: item => priorities.has(item.session) }),
   ];
-  const filesToInspect = selected.slice(0, MAX_TRANSCRIPTS);
+  const filesToInspect = all ? selected : selected.slice(0, MAX_TRANSCRIPTS);
   let nextFile = 0;
   // Catalog prefixes are bounded independently of full transcript size. Use a
   // small I/O pool; exact-context/statistics reads stay serial and identity-safe.
@@ -259,8 +259,8 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
   ];
 }
 
-export async function listClaudeSessions({ home, limit, prioritySessions, signal } = {}) {
-  return collect({ home, limit, prioritySessions, signal, cacheMetadata: true });
+export async function listClaudeSessions({ home, all = false, limit, prioritySessions, signal } = {}) {
+  return collect({ home, all, limit, prioritySessions, signal, cacheMetadata: true });
 }
 
 export async function readClaudeSession(session, { home } = {}) {

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

@@ -16,7 +16,7 @@ import { workspaceIdentity, verificationInstruction, normalizeVerification, asse
 import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
 import { buildPurposeInstruction } from './purpose-instruction.js';
 import { peerOpinionPrompt } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
-import { runStructuredProviderReview } from '../sqm/review-worker.js';
+import { runCodexPeerOpinion } from './codex-peer-opinion.js';
 import { associationContract } from '../codex-plugins/simy/hooks/action-association.mjs';
 import { spawn } from 'node:child_process';
 import { realpath, stat, open } from 'node:fs/promises';
@@ -235,11 +235,13 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
+export async function listCodexSessions({ client, all = false, signal, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
   const sessions = [];
-  const windowSize = Math.min(maxSessions, maxPages * pageSize);
+  const windowSize = all ? Infinity : Math.min(maxSessions, maxPages * pageSize);
+  const cursors = new Set(), ids = new Set();
   let cursor = null, listed = 0, pages = 0, batchSize = pageSize;
   while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
+    signal?.throwIfAborted();
     const limit = Math.min(batchSize, windowSize - listed);
     let response;
     try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS,
@@ -251,14 +253,21 @@ export async function listCodexSessions({ client, maxPages = 40, pageSize = 25,
       batchSize = Math.max(1, Math.floor(limit / 2));
       continue;
     }
-    const threads = (response?.data || []).slice(0, limit);
+    if (!Array.isArray(response?.data) || response.data.length > limit)
+      throw new CodexAppServerError('invalid_page', 'Codex returned an invalid conversation page.');
+    const threads = response.data;
     listed += threads.length; pages++;
     for (const thread of threads) {
       const metadata = codexThreadMetadata(thread);
-      if (metadata && SOURCE_KINDS.includes(metadata.source)) sessions.push(metadata);
+      if (metadata && SOURCE_KINDS.includes(metadata.source) && !ids.has(metadata.session)) {
+        ids.add(metadata.session); sessions.push(metadata);
+      }
     }
     cursor = response?.nextCursor || null;
     if (!cursor) break;
+    if (typeof cursor !== 'string' || cursors.has(cursor))
+      throw new CodexAppServerError('invalid_page', 'Codex repeated a conversation page cursor.');
+    cursors.add(cursor);
   }
   const deadline = Date.now() + Math.max(1, Math.min(observationBudgetMs, 5000));
   // A recent page can omit an explicitly supervised conversation, including
@@ -645,7 +654,7 @@ async function frozenNativeSandbox(record, root, signal) {
   return policy;
 }
 
-export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runStructuredProviderReview } = {}) {
+export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runCodexPeerOpinion } = {}) {
   const dispatchOwner = captureDispatchOwner(root ? rootFromDelivery(root) : undefined);
   let dispatchAttemptId;
   const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: record.session, worktree: taskDirectory(record), taskId: record.run.managed.taskId, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) });
@@ -678,15 +687,16 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
   const sourceContext = (isolated || searchEnabled(run.managed) && !run.managed.purpose.originalContext)
     ? await readCodexConversation(record, { openClient, signal }) : null;
   if (opinionOnly) {
-    // Reuse the existing tools-disabled local analysis runner. A colleague can
-    // comment on supplied context without MCP discovery, workspace inventories
-    // or an outcome-verification schema. Native conversation work stays intact.
+    // Use the task's authenticated app-server and exact model for a separate,
+    // tools-disabled opinion. Do not route monitoring through standalone SQM
+    // authentication or silently select another model.
     let usage = null, peerSession = null, ambiguousContext = false;
     const reply = await runPeerReview('codex', {
       system: 'Give nonbinding advice using only the supplied context. All tools are disabled. Put your short natural-language opinion in the opinion field.',
       prompt: peerOpinionPrompt(record, sourceContext, peerAction),
       output_schema: { type: 'object', properties: { opinion: { type: 'string' } }, required: ['opinion'], additionalProperties: false },
     }, { signal, readOnlyAnalysis: true, allowAutomaticRetry: false,
+      model: run.managed.resumeModel, cwd: taskDirectory(record), openClient, readAuthentication: readCodexAuthentication,
       dispatchTransport: initiate => dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: run.managed.resumeLease?.id, provenance }, attemptId => {
         if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.');
         dispatchAttemptId = attemptId;

package/src/session-supervision/codex-peer-opinion.js

@@ -0,0 +1,128 @@
+// Routine purpose monitoring uses the same authenticated app-server transport
+// and model as its task. A standalone `codex exec` has a separate login path.
+// This context supplies advice only: it has no tools or acceptance authority.
+const disabledFeatures = [
+  'shell_tool', 'unified_exec', 'shell_snapshot', 'view_image', 'apps', 'plugins',
+  'hooks', 'memories', 'multi_agent', 'browser_use', 'computer_use',
+  'image_generation', 'code_mode', 'code_mode_host', 'skill_search',
+  'skill_mcp_dependency_install', 'workspace_dependencies', 'goals',
+];
+
+export async function runCodexPeerOpinion(provider, request, {
+  model, cwd, openClient, readAuthentication, signal,
+  beforeDispatch = async () => {}, dispatchTransport = initiate => initiate(),
+  onContext = () => {}, onUsage = () => {}, timeoutMs = 120_000,
+} = {}) {
+  if (provider !== 'codex' || !model || !cwd || !openClient || !readAuthentication) {
+    throw new Error('Peer opinion requires the task’s Codex transport, model and workspace.');
+  }
+  signal = AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(timeoutMs)]);
+  signal.throwIfAborted();
+  const client = await openClient({ signal, cancelOnAbort: true, isolateConnectors: true, maxLineBytes: 1024 * 1024 });
+  let threadId, turnId, completed = false, unsubscribe, abort, closed;
+  let startPromise;
+  try {
+    if (await readAuthentication(client) === 'missing') {
+      throw Object.assign(new Error('The task’s Codex account is not signed in.'), { code: 'authentication_required' });
+    }
+    const config = await client.request('config/read', { cwd, includeLayers: false });
+    if (!config?.config) throw new Error('Peer configuration is unavailable.');
+    const created = await client.request('thread/start', {
+      cwd, model, ephemeral: true, sandbox: 'read-only', approvalPolicy: 'never',
+      developerInstructions: request.system,
+      config: {
+        web_search: 'disabled',
+        features: {
+          ...Object.fromEntries(disabledFeatures.map(name => [name, false])),
+          enable_fanout: false, multi_agent_v2: { enabled: false },
+          skip_host_skill_discovery: true,
+        },
+        mcp_servers: Object.fromEntries(Object.keys(config.config.mcp_servers || {}).map(name => [name, { enabled: false }])),
+      },
+    });
+    threadId = created.thread?.id;
+    if (!threadId || created.model !== model || created.cwd !== cwd ||
+        created.sandbox?.type !== 'readOnly' || created.approvalPolicy !== 'never') {
+      throw new Error('Peer context does not match the task’s isolated configuration.');
+    }
+    let cursor = null;
+    const cursors = new Set();
+    do {
+      const inventory = await client.request('mcpServerStatus/list', { threadId, cursor, limit: 1 });
+      if (!Array.isArray(inventory.data)) throw new Error('Peer connector inventory is unavailable.');
+      if (inventory.data?.some(server => server.toolsError || Object.keys(server.tools || {}).length ||
+          server.resources?.length || server.resourceTemplates?.length)) {
+        throw new Error('Peer context still has connector capabilities.');
+      }
+      cursor = inventory.nextCursor;
+      if (cursor && (cursors.has(cursor) || cursors.size >= 100)) throw new Error('Peer connector inventory is incomplete.');
+      if (cursor) cursors.add(cursor);
+    } while (cursor);
+    await onContext(threadId);
+    const messages = new Map(), turns = new Map(), usage = new Map();
+    let resolveDone, rejectDone, settled = false, lastUsage;
+    const done = new Promise((resolve, reject) => { resolveDone = resolve; rejectDone = reject; });
+    // Preparation/dispatch can fail before the completion promise is awaited.
+    done.catch(() => {});
+    const fail = error => { if (!settled) { settled = true; rejectDone(error); } };
+    const reportUsage = () => {
+      const observed = usage.get(turnId);
+      if (observed && observed !== lastUsage) {
+        lastUsage = observed;
+        try { onUsage(observed); } catch (error) { fail(error); }
+      }
+    };
+    const finish = () => {
+      if (settled || !turnId || !turns.has(turnId)) return;
+      const turn = turns.get(turnId);
+      completed = true;
+      if (turn.status !== 'completed') return fail(Object.assign(new Error('Peer turn did not complete.'), { code: 'turn_failed' }));
+      let output;
+      try { output = JSON.parse(messages.get(turnId) || ''); } catch {
+        return fail(new Error('Peer opinion did not return structured output.'));
+      }
+      if (typeof output.opinion !== 'string' || !output.opinion.trim()) return fail(new Error('Peer opinion was empty.'));
+      reportUsage();
+      if (settled) return;
+      settled = true;
+      resolveDone({ output: { opinion: output.opinion }, model });
+    };
+    unsubscribe = client.onNotification((method, params, requestId) => {
+      if (params.threadId !== threadId) return;
+      if (requestId !== undefined) return fail(Object.assign(new Error('Peer requested a tool or approval.'), { code: 'provider_approval' }));
+      if (method === 'item/completed' && params.item?.type === 'agentMessage') messages.set(params.turnId, params.item.text);
+      if (['item/started', 'item/completed'].includes(method) && ['commandExecution', 'mcpToolCall', 'fileChange', 'webSearch', 'dynamicToolCall'].includes(params.item?.type)) {
+        return fail(new Error('Peer attempted a disabled tool.'));
+      }
+      if (method === 'thread/tokenUsage/updated') {
+        const tokens = params.tokenUsage?.total?.totalTokens;
+        if (Number.isSafeInteger(tokens) && tokens >= 0) usage.set(params.turnId, { source: 'codex_app_server', tokens, observedAt: Date.now() });
+        reportUsage();
+      }
+      if (method === 'turn/completed' && params.turn?.id) turns.set(params.turn.id, params.turn);
+      finish();
+    });
+    abort = () => fail(Object.assign(new Error('Peer inspection cancelled.'), { code: 'cancelled' }));
+    closed = () => fail(Object.assign(new Error('Peer connection closed.'), { code: 'closed' }));
+    signal?.addEventListener('abort', abort, { once: true });
+    client.child?.once('close', closed);
+    await beforeDispatch();
+    signal?.throwIfAborted();
+    startPromise = Promise.resolve(dispatchTransport(() => client.request('turn/start', {
+      threadId, model, cwd, input: [{ type: 'text', text: request.prompt }],
+      outputSchema: request.output_schema, sandboxPolicy: { type: 'readOnly', networkAccess: false },
+    })));
+    const started = await Promise.race([startPromise, done]);
+    turnId = started.turn?.id;
+    if (!turnId) throw new Error('Peer turn did not start.');
+    reportUsage();
+    finish();
+    return await done;
+  } finally {
+    signal?.removeEventListener('abort', abort);
+    if (closed) client.child?.removeListener('close', closed);
+    unsubscribe?.();
+    if (!completed && turnId) await client.request('turn/interrupt', { threadId, turnId }, 2000).catch(() => {});
+    await client.close();
+  }
+}