@awak-app/simy-cli 0.7.19 → 0.7.21

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

package/src/session-supervision/index.js

@@ -14,7 +14,7 @@ import { loadPurposeRuleSet } from './purpose-instruction.js';
 import { originalSessionTarget } from './original-session-target.js';
 import { readCodexChildSessions } from './codex-children.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
-import { RECENT_SESSION_LIMIT, recentSessionWindow, retainedSession } from './discovery-window.js';
+import { recentSessionWindow, retainedSession } from './discovery-window.js';
 import { requireProviderLink } from '../provider-links.js';
 
 // Only product-authored eligibility messages may pass through the desktop
@@ -29,7 +29,8 @@ export class AutoContinueUnavailableError extends Error {
 // Opt-in is independent of a busy provider turn. Dispatch still requires a
 // settled context and the original provider's execution boundary.
 function autoContinueAvailability(run, channel) {
-  const issue = !channel.ready ? channel : run && !run.managed && !canUpgradeDelivery(run)
+  const issue = !channel.ready ? channel : run?.state === 'stopped'
+    ? { code: 'task_stopped', reason: 'This task was stopped. Review the original conversation and explicitly request resumption before continuing.' } : run && !run.managed && !canUpgradeDelivery(run)
     ? { code: 'existing_loop', reason: 'This conversation already has a Delivery Loop. Use its existing controls.' }
     : TERMINAL_RUNS.has(run?.state)
       ? { code: 'task_settled', reason: 'This supervised task has settled. Review its existing status before continuing.' } : null;
@@ -139,7 +140,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   await Promise.all([
     (async () => {
       try { if (connected.has('codex')) discovered = await withClient(openClient, async client => {
-        const active = await listCodexSessions({ client, inspectState: true, maxSessions: RECENT_SESSION_LIMIT, codexHome,
+        const active = await listCodexSessions({ client, all: true, signal, inspectState: true, codexHome,
           prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) });
         if (includeArchived) {
           const observedArchives = new Map();
@@ -153,7 +154,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
             }
             return response;
           } };
-          try { await listCodexSessions({ client: archiveClient, archived: true, maxSessions: RECENT_SESSION_LIMIT }); }
+          try { await listCodexSessions({ client: archiveClient, all: true, signal, archived: true }); }
           catch { /* Keep positive archive pages even if a later page fails. */ }
           archivedCodex = [...observedArchives.values()];
         }
@@ -168,7 +169,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       }
     })(),
     (async () => {
-      try { if (connected.has('claude')) claude = await listClaude({ signal, limit: RECENT_SESSION_LIMIT,
+      try { if (connected.has('claude')) claude = await listClaude({ signal, all: true,
         prioritySessions: priorities.filter(record => record.provider === 'claude').map(record => record.session) }); }
       catch { claudeError = 'Claude conversation discovery unavailable.'; }
     })(),
@@ -237,16 +238,17 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       availability: 'unknown', model: record.admission?.model || null,
     });
   }
-  // Select recent history before live probes, keeping explicit supervision
-  // visible even during a truncated discovery or provider outage.
+  // Catalog visibility is complete; only live process probes use a recent window.
   const catalog = [...byKey.values()].map(item => {
     const record = recordsByKey.get(`${item.provider}:${item.session}`);
     const parentSession = navigationParent(item, record);
     return { ...item, localHidden: record?.listHidden === true, ...(parentSession ? { parentSession } : {}) };
   });
-  const items = [...recentSessionWindow(catalog.filter(item => item.archived !== true && !item.localHidden), {
+  const liveItems = [...recentSessionWindow(catalog.filter(item => item.archived !== true && !item.localHidden), {
     priority: item => retainedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
   }), ...recentSessionWindow(catalog.filter(item => item.archived === true || item.localHidden), { priority: item => item.localHidden })];
+  const liveKeys = new Set(liveItems.map(item => `${item.provider}:${item.session}`));
+  const items = [...catalog];
   // Include archived ancestors of active rows even when archive visibility is off.
   const catalogByKey = new Map(catalog.map(item => [`${item.provider}:${item.session}`, item]));
   const includedKeys = new Set(items.map(item => `${item.provider}:${item.session}`));
@@ -285,7 +287,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     const supported = item.provider === 'codex' && codexChannel.ready;
     const claudeChannel = item.provider === 'claude' ? claudeError
       ? { ready: false, code: 'session_metadata_unavailable', reason: claudeError }
-      : await liveClaudeChannel(record, item, inspectProcess) : null;
+      : await liveClaudeChannel(record, item, liveKeys.has(`${item.provider}:${item.session}`) ? inspectProcess : async () => null) : null;
     const liveHook = claudeChannel?.ready === true;
     let continuationAdmission;
     if (supported || liveHook) {
@@ -308,7 +310,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
         // A hook newer than the persisted provider activity may describe a
         // new turn. Require its same live process; older hooks cannot override
         // a more recent completed provider turn.
-        if (record.runtime.isRunning && await inspectProcess(record.runtime.process.pid) === record.runtime.process.identity) { isRunning = true; observation = { ...item.observation, observedAt: record.runtime.observedAt }; }
+        if (liveKeys.has(`${item.provider}:${item.session}`) && record.runtime.isRunning && await inspectProcess(record.runtime.process.pid) === record.runtime.process.identity) { isRunning = true; observation = { ...item.observation, observedAt: record.runtime.observedAt }; }
         else if (isRunning === undefined && !record.runtime.isRunning) isRunning = false;
       } catch { /* Unverified process leaves runtime status unknown. */ }
     }
@@ -326,6 +328,12 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       autoContinue: !archived && record?.autoContinue === true,
       autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
       autoContinueAvailability: availability,
+      // A finished ordinary report needs an explicit current goal, not an
+      // implicit reset through the auto-continue preference.
+      followup: !archived && supported && item.provider === 'codex' &&
+        run?.state === 'reported_done' && !run.managed && run.id && !record.automaticStartBlocked &&
+        !record.associationTaskId && !(record.autoContinue === false && record.autoContinueEpoch)
+        ? { previousRunId: run.id } : null,
       ...autoContinueState(record, isRunning, availability),
       lastActivityAt: item.lastActivityAt, createdAt: item.createdAt ?? null, observation, availability: item.availability,
       taskId: run?.managed?.taskId || record?.associationTaskId || null,
@@ -369,6 +377,7 @@ function hasAutoContinueAdmission(record, provider, session) {
     (provider !== 'codex' || typeof admission.model === 'string' && admission.model.trim());
 }
 function requireAutoContinueTask(record) {
+  if (record?.run?.state === 'stopped') throw new AutoContinueUnavailableError({ reasonCode: 'task_stopped', reason: 'This task was stopped. Review the original conversation and explicitly request resumption before continuing.' });
   if (record?.run && !record.run.managed && !canUpgradeDelivery(record.run)) throw Object.assign(new Error('This conversation already has a Delivery Loop. Use its existing controls.'), { code: 'existing_loop' });
   if (TERMINAL_RUNS.has(record?.run?.state)) throw new AutoContinueUnavailableError({ reason: 'This supervised task has settled. Review its existing status before continuing.', reasonCode: 'task_settled' });
 }
@@ -513,7 +522,7 @@ export async function monitorSession({ root, provider, session, monitor = true,
 
 export async function enrollSession(options) {
   const { root, provider, session, objective, acceptanceCriteria, contextBootstrap = false, autonomyPolicy,
-  maxMinutes, maxContinuations, maxTokens, purposeDriven, purposeVersion, maxFailures, maxNoProgressMinutes, continuationPolicy, autoContinueEpoch, executionCwd, upgradeRunId, previousRunId, reconcileRunId, expectedProviderEpoch, openClient = openCodexAppServer,
+  maxMinutes, maxContinuations, maxTokens, purposeDriven, purposeVersion, maxFailures, maxNoProgressMinutes, continuationPolicy, autoContinueEpoch, executionCwd, upgradeRunId, previousRunId, reconcileRunId, followupAutoContinue, expectedProviderEpoch, openClient = openCodexAppServer,
   readClaude = readClaudeSession, inspectProcess = processIdentity, now = Date.now() } = sessionLoopOptions(options);
   if (!['codex', 'claude'].includes(provider)) throw new Error('This provider does not have a verified exact-session enrollment channel.');
   const link = await requireProviderLink({ root, provider, expectedEpoch: expectedProviderEpoch });
@@ -541,7 +550,7 @@ export async function enrollSession(options) {
   const liveRecord = provider === 'claude' ? await readRecord(root, provider, session) : null;
   await requireProviderLink({ root, provider, expectedEpoch: link.epoch });
   const rules = purposeDriven ? await loadPurposeRuleSet() : null;
-  const run = await startDelivery({ root, provider, session, cwd, executionCwd, upgradeRunId, previousRunId, reconcileRunId, providerLinkEpoch: link.epoch, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
+  const run = await startDelivery({ root, provider, session, cwd, executionCwd, upgradeRunId, previousRunId, reconcileRunId, followupAutoContinue, providerLinkEpoch: link.epoch, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
     maxMinutes, maxContinuations, maxFailures, continuationPolicy, now, admission, inspectProcess, autoContinueEpoch,
     liveHookAdmission: liveRecord ? { hookStartedAt: liveRecord.hookStartedAt, pid: liveRecord.process.pid, identity: liveRecord.process.identity } : undefined,
     managed: { ...(rules ? { purpose: { enabled: true, version: purposeVersion, ...(purposeVersion === 2 ? { decisionPolicy: 'llm-first-hc102' } : {}), failureBudgetMode: maxFailures === undefined ? 'strategy' : 'hard', ruleDigest: rules.digest, ruleIds: rules.rules.map(rule => rule.id), recoveries: [] } } : {}), maxTokens, acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, approvalScopes: ['task'], approvalPolicy: 'wait',

package/src/session-supervision/remote-control.js

@@ -0,0 +1,27 @@
+// Only host-discovered admission may reach the native mutation API.
+export function createControl({ authorize, select, set, followup, save, revoke, root }) {
+  return async command => {
+    const isFollowup = command?.action === 'session_followup';
+    if (!['session_set_auto_continue', 'session_followup'].includes(command?.action) || command.provider !== 'codex' ||
+        typeof command.session !== 'string' || !/^[a-f0-9-]{36}$/.test(command.session) ||
+        (!isFollowup && typeof command.enabled !== 'boolean') ||
+        (isFollowup && (typeof command.objective !== 'string' || !command.objective.trim() || command.objective.length > 4000)) ||
+        command.continuationPolicy !== undefined && !['bounded','progress'].includes(command.continuationPolicy)) throw new Error('Unsupported remote command');
+    const scope = await authorize();
+    const candidate = await select(command);
+    if (!candidate || candidate.provider !== 'codex' || candidate.session !== command.session) throw new Error('Select a known conversation');
+    if (isFollowup) {
+      if (typeof followup !== 'function' || !candidate.followup?.previousRunId || command.previousRunId !== candidate.followup.previousRunId) throw new Error('Refresh the finished conversation before requesting follow-up.');
+      await authorize(scope);
+      await followup({root,provider:'codex',session:command.session,previousRunId:command.previousRunId,objective:command.objective,followupAutoContinue:true,expectedProviderEpoch:scope.providerEpoch});
+      await save({...command,enabled:true},scope);
+      return;
+    }
+    if (command.enabled && (candidate.autoContinueAvailability?.canEnable ?? candidate.capabilities?.canAutoContinue) !== true) throw Object.assign(new Error(candidate.autoContinueAvailability?.reason || 'Continuation unavailable'), {code:candidate.autoContinueAvailability?.reasonCode});
+    await authorize(scope);
+    await set({root, provider:'codex',session:command.session,enabled:command.enabled,
+      continuationPolicy:command.continuationPolicy, admission:candidate.continuationAdmission,expectedProviderEpoch:scope.providerEpoch});
+    if (!command.enabled) revoke('codex',command.session);
+    await save(command,scope);
+  };
+}

package/src/session-supervision/remote-errors.js

@@ -0,0 +1,22 @@
+// Remote diagnostics are selected from product-owned text. Never display
+// arbitrary SSH stderr, provider exceptions, paths or remote frame messages.
+const messages = {
+  process_conflict: 'Another SIMY service owns this remote host. Reconcile its existing service before connecting; do not stop unrelated work.',
+  desktop_access_required: 'Sign in to the same SIMY account and organization on the remote host and verify its access.',
+  provider_link_disconnected: 'Reconnect this AI provider to SIMY on the remote host.',
+  provider_link_changed: 'The remote provider connection changed. Refresh and select the conversation again.',
+  session_metadata_unavailable: 'Refresh the remote conversation list; its exact session metadata is unavailable.',
+  session_model_unavailable: 'Select a model in the original remote conversation, then refresh.',
+  model_metadata_unavailable: 'Select a model in the original remote conversation, then refresh.',
+  session_workspace_changed: 'The remote workspace changed. Refresh and select the conversation again.',
+  session_archived: 'Restore the original remote conversation before enabling Auto-continue.',
+  existing_loop: 'Use this remote conversation’s existing task controls.',
+  task_stopped: 'This remote task was stopped. Review the original conversation and explicitly request resumption.',
+  task_settled: 'The remote task has finished. Refresh and select its explicit follow-up controls.',
+  cancelled: 'The remote operation was cancelled.',
+};
+export function remoteOperationFailure(code) {
+  return typeof code === 'string' && Object.hasOwn(messages, code)
+    ? { code, message: messages[code] }
+    : { message: 'Remote operation could not finish. Check the original conversation and refresh before retrying.' };
+}

package/src/session-supervision/remote-hosts.js

@@ -1,3 +1,4 @@
+import { remoteOperationFailure } from './remote-errors.js';
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
@@ -14,7 +15,7 @@ const shellQuote = value => "'" + value.replaceAll("'", "'\\''") + "'";
 const bootstrap = 'import { realpathSync } from "node:fs"; import { dirname, join } from "node:path"; import { pathToFileURL } from "node:url"; const entry = join(dirname(realpathSync(process.argv[1])), "session-supervision", "remote-entry.js"); await import(pathToFileURL(entry).href);';
 export const REMOTE_HOST_COMMAND = `exec sh -lc ${shellQuote(`exec env SIMY_REMOTE_CHILD=1 SIMY_AUTO_UPDATE=0 node --input-type=module -e ${shellQuote(bootstrap)} "$(command -v simy)"`)}`;
 const allowedActions = new Set(['refresh', 'session_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
-  'session_monitor', 'session_unmonitor', 'session_enroll', 'session_set_auto_continue', 'session_analyze', 'session_continue', 'session_answer',
+  'session_monitor', 'session_unmonitor', 'session_enroll', 'session_followup', 'session_set_auto_continue', 'session_analyze', 'session_continue', 'session_answer',
   'session_deadline_decide', 'session_action_refresh', 'session_action_select', 'session_action_unlink',
   'delivery_pause', 'delivery_stop', 'delivery_reject', 'delivery_resume', 'delivery_replan', 'delivery_approve',
   'delivery_dependency_ready', 'delivery_set_policy', 'delivery_continuation_policy', 'delivery_verify']);
@@ -25,7 +26,7 @@ function normalizedHost(value) {
   if (label.length > 80 || /[\x00-\x1f\x7f]/.test(label)) throw error('Choose a shorter host name.', 'remote_host_invalid');
   return { alias: value.alias, label: label || value.alias, id: remoteHostId(value.alias) };
 }
-async function readHosts(root) {
+export async function readHosts(root) {
   let value;
   try { value = JSON.parse(await readFile(join(root, 'remote-hosts.json'), 'utf8')); }
   catch (e) { if (e.code === 'ENOENT') return []; throw error('Remote host settings could not be read.', 'remote_host_settings'); }
@@ -42,7 +43,7 @@ function stamp(value, host, depth = 0) {
   if (Array.isArray(value)) return value.map(item => stamp(item, host, depth + 1));
   if (!value || typeof value !== 'object') return value;
   const result = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, stamp(item, host, depth + 1)]));
-  if (result.provider === 'codex' && typeof result.session === 'string') result.hostId = host.id;
+  if (['codex', 'claude'].includes(result.provider) && typeof result.session === 'string') result.hostId = host.id;
   return result;
 }
 
@@ -113,13 +114,13 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
           }
           changed();
         } else if (frame.type === 'error') {
-          disconnect(connection, 'Remote SIMY could not start. Check its installation, login and existing desktop connection.'); changed(); return;
+          disconnect(connection, remoteOperationFailure(frame.code).message); changed(); return;
         } else if (frame.type === 'result') {
           const pending = connection.pending.get(frame.id);
           if (!pending) continue;
           connection.pending.delete(frame.id); clearTimeout(pending.timer);
           pending.resolve({ type: 'result', id: pending.id, ok: frame.ok === true,
-            ...(frame.ok !== true ? { message: 'Remote operation could not finish. Check the original conversation and refresh before retrying.' } : {}) });
+            ...(frame.ok !== true ? remoteOperationFailure(frame.code) : {}) });
         }
       }
     });
@@ -167,10 +168,11 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
   }
   async function forward(command, status) {
     if (closed || !usable(status) || scopeOf(status) !== scope) throw error('SIMY account changed. Refresh before using the remote host.', 'remote_host_access');
+    if (status.providerLinks?.[command.provider]?.connected === false) throw error('Provider is disconnected.', 'remote_host_access');
     const c = connections.get(command.hostId);
     if (!c?.ready || !c.child || now() - c.receivedAt > 45_000) throw error('The remote host is disconnected. Reconnect before using this conversation.');
-    if (!allowedActions.has(command.action) || command.provider !== 'codex' || typeof command.session !== 'string' ||
-      !c.status?.sessionSupervision?.sessions?.some(s => s?.provider === 'codex' && s.session === command.session)) throw error('Select an available remote Codex conversation.', 'remote_host_invalid');
+    if (!allowedActions.has(command.action) || !['codex', 'claude'].includes(command.provider) || typeof command.session !== 'string' ||
+      !c.status?.sessionSupervision?.sessions?.some(s => s?.provider === command.provider && s.session === command.session)) throw error('Select an available remote conversation.', 'remote_host_invalid');
     const id = randomUUID();
     const { hostId, ...payload } = command;
     return new Promise((resolve, reject) => {
@@ -181,7 +183,7 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       });
     });
   }
-  function project(status) {
+  function project(status, { providerLinks = status.providerLinks } = {}) {
     if (!usable(status) || scopeOf(status) !== scope) return status;
     const hosts = [...connections.values()];
     const sessions = [], runs = [];
@@ -189,14 +191,16 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       const ready = c.ready && now() - c.receivedAt <= 45_000;
       const unavailableReason = c.reason || 'Remote status is stale.';
       for (const row of c.status?.sessionSupervision?.sessions || []) {
-        if (!row || row.provider !== 'codex' || typeof row.session !== 'string') continue;
+        if (!row || !['codex', 'claude'].includes(row.provider) || typeof row.session !== 'string' ||
+          providerLinks?.[row.provider]?.connected === false) continue;
         const item = stamp(row, c);
         item.remoteHost = { id: c.id, label: c.label, state: ready ? 'ready' : c.state === 'ready' ? 'unavailable' : c.state, reason: ready ? null : c.reason || 'Remote status is stale.' };
         // Codex's host-specific deep link contract is unverified. Preserve exact
         // navigation context instead of silently opening a cloned local UUID.
-        item.originalSessionTarget = { kind: 'manual', url: null, label: 'Find in remote Codex', verifiedOnPlatform: false,
-          reason: `Select ${c.label} in Codex, then find conversation ${row.session}.` };
+        item.originalSessionTarget = { kind: 'manual', url: null, label: 'Find in remote provider', verifiedOnPlatform: false,
+          reason: `Select ${c.label} in ${row.provider === 'claude' ? 'Claude Code' : 'Codex'}, then find conversation ${row.session}.` };
         if (!ready) {
+          item.followup = null;
           item.capabilities = Object.fromEntries(Object.keys(item.capabilities || {}).map(key => [key, false]));
           item.autoContinueAvailability = { canEnable: false, reasonCode: 'remote_host_unavailable', reason: unavailableReason };
           item.autoContinueStatus = 'unavailable'; item.autoContinueReason = unavailableReason;
@@ -206,13 +210,13 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
         }
         sessions.push(item);
       }
-      if (ready) for (const run of c.status?.deliveryHooks?.runs || []) if (run?.provider === 'codex') runs.push({ ...stamp(run, c), originalSessionTarget: { kind: 'manual', url: null, verifiedOnPlatform: false, reason: `Select ${c.label} in Codex, then find conversation ${run.session}.` } });
+      if (ready) for (const run of c.status?.deliveryHooks?.runs || []) if (['codex', 'claude'].includes(run?.provider) && providerLinks?.[run.provider]?.connected !== false) runs.push({ ...stamp(run, c), originalSessionTarget: { kind: 'manual', url: null, verifiedOnPlatform: false, reason: `Select ${c.label} in ${run.provider === 'claude' ? 'Claude Code' : 'Codex'}, then find conversation ${run.session}.` } });
     }
     return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, state: c.state, reason: c.reason })) },
       sessionSupervision: { ...status.sessionSupervision, sessions: [...(status.sessionSupervision?.sessions || []).filter(row => !row.hostId || row.hostId === 'local'), ...sessions].sort(compareSessionWork) },
       deliveryHooks: { ...status.deliveryHooks, runs: [...(status.deliveryHooks?.runs || []).filter(row => !row.hostId || row.hostId === 'local'), ...runs] } };
   }
   return { update, save, forward, project,
-    hasSession: session => [...connections.values()].some(c => c.status?.sessionSupervision?.sessions?.some(s => s?.provider === 'codex' && s.session === session)),
+    hasSession: session => [...connections.values()].some(c => c.status?.sessionSupervision?.sessions?.some(s => ['codex', 'claude'].includes(s?.provider) && s.session === session)),
     async close() { closed = true; for (const c of connections.values()) disconnect(c); connections.clear(); await writes.catch(() => {}); } };
 }

package/src/session-supervision/remote-session-list.js

@@ -0,0 +1,56 @@
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readHosts } from './remote-hosts.js';
+
+// This read-only command never boots a remote desktop host or supervisor.
+export async function readRemoteSessionLists({ root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy'),
+  providers, includeArchived = false, signal, spawnImpl = spawn, timeoutMs = 30_000 } = {}) {
+  const hosts = await readHosts(root);
+  return Promise.all(hosts.map(async host => {
+    try {
+      signal?.throwIfAborted();
+      const provider = providers.length === 2 ? 'all' : providers[0];
+      if (!['all', 'codex', 'claude'].includes(provider)) throw new Error('No connected provider.');
+      const command = `exec sh -lc 'exec simy sessions --json --local-only --provider ${provider}${includeArchived ? ' --include-archived' : ''}'`;
+      const catalog = await new Promise((resolve, reject) => {
+        const child = spawnImpl('ssh', ['-T', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes',
+          '-o', 'ConnectTimeout=5', '-o', 'ServerAliveInterval=10', '-o', 'ServerAliveCountMax=2',
+          '--', host.alias, command], { stdio: ['ignore', 'pipe', 'pipe'], shell: false });
+        let chunks = [], size = 0, done = false;
+        const finish = (error, value) => {
+          if (done) return; done = true;
+          clearTimeout(timer); signal?.removeEventListener('abort', abort);
+          if (error) { child.kill('SIGTERM'); reject(error); } else resolve(value);
+        };
+        const abort = () => finish(new Error('Remote listing cancelled.'));
+        const timer = setTimeout(() => finish(new Error('Remote listing timed out.')), timeoutMs);
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) abort();
+        child.stderr.resume();
+        child.on('error', () => finish(new Error('Could not start SSH.')));
+        child.stdout.on('data', chunk => {
+          if (done) return;
+          size += chunk.length;
+          if (size > 16 * 1024 * 1024) return finish(new Error('Remote catalog exceeds the supported response size.'));
+          chunks.push(chunk);
+        });
+        child.on('close', code => {
+          if (done) return;
+          if (code !== 0) return finish(new Error('Remote listing failed. Check SSH and update SIMY on this host.'));
+          try {
+            const value = JSON.parse(Buffer.concat(chunks).toString('utf8')); chunks = [];
+            if (!Array.isArray(value.sessions) || value.sessions.some(row => !row ||
+              !providers.includes(row.provider) || typeof row.session !== 'string' || !row.session ||
+              typeof row.cwd !== 'string' || row.hostId && row.hostId !== 'local')) throw new Error();
+            finish(null, value);
+          } catch { finish(new Error('Remote SIMY returned an invalid conversation catalog.')); }
+        });
+      });
+      return { host, catalog };
+    } catch (error) {
+      signal?.throwIfAborted();
+      return { host, error: error.message };
+    }
+  }));
+}