@awak-app/simy-cli 0.7.20 → 0.7.21

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

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

@@ -1,57 +1,112 @@
+import { readRemoteSessionLists } from './remote-session-list.js';
 import { hostname } from 'node:os';
 import { stripVTControlCharacters } from 'node:util';
 import { readProviderLinks } from '../provider-links.js';
 import { openCodexAppServer, listCodexSessions } from './codex-app-server.js';
+import { listClaudeSessions } from './claude-sessions.js';
 import { readCodexTitles } from './session-titles.js';
 import { sessionWorkState } from './work-state.js';
 
 export const terminalText = value => stripVTControlCharacters(String(value ?? '')).replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').trim();
 export function filterSessionList(sessions, query = '') {
   const needle = query.trim().toLocaleLowerCase();
-  return sessions.filter(row => !needle || [row.title, row.session, row.cwd].some(value => String(value || '').toLocaleLowerCase().includes(needle)));
+  return sessions.filter(row => !needle || [row.title, row.session, row.cwd, row.provider, row.hostLabel].some(value => String(value || '').toLocaleLowerCase().includes(needle)));
 }
 
 // List directly from the installed local provider. No agent, supervisor,
 // enrollment, archive reconciliation or provider turn is started by this view.
-export async function readLocalSessionList({ root, signal, includeArchived = false,
-  openClient = openCodexAppServer, readLinks = readProviderLinks, readTitles = readCodexTitles } = {}) {
+export async function readLocalSessionList({ root, signal, includeArchived = false, provider = 'all',
+  openClient = openCodexAppServer, listClaude = listClaudeSessions,
+  readLinks = readProviderLinks, readTitles = readCodexTitles } = {}) {
   const links = await readLinks(root);
-  if (!links.codex.connected) throw Object.assign(new Error('Codex is disconnected from SIMY. Reconnect it before listing conversations.'), { code: 'provider_link_disconnected' });
-  const client = await openClient({ signal, cancelOnAbort: true });
-  let sessions;
-  try {
-    sessions = await listCodexSessions({ client, inspectState: true });
-    if (includeArchived) sessions.push(...(await listCodexSessions({ client, archived: true })).map(row => ({ ...row, archived: true })));
-  } finally { await client.close(); }
-  const titles = await readTitles();
+  const providers = ['codex', 'claude'].filter(name => links[name]?.connected && (provider === 'all' || name === provider));
+  if (!providers.length) throw Object.assign(new Error('Codex and Claude Code are disconnected from SIMY. Reconnect a provider before listing conversations.'), { code: 'provider_link_disconnected' });
+  const results = await Promise.allSettled(providers.map(async provider => {
+    signal?.throwIfAborted();
+    if (provider === 'claude') return (await listClaude({ all: true, signal })).filter(row => includeArchived || !row.archived);
+    const client = await openClient({ signal, cancelOnAbort: true });
+    let sessions;
+    try {
+      sessions = await listCodexSessions({ client, all: true, signal, inspectState: true });
+      if (includeArchived) sessions.push(...(await listCodexSessions({ client, all: true, signal, archived: true })).map(row => ({ ...row, archived: true })));
+    } finally { await client.close(); }
+    const titles = await readTitles();
+    return sessions.map(row => ({ ...row, title: row.title || titles.get(row.session) }));
+  }));
   signal?.throwIfAborted();
   const currentLinks = await readLinks(root);
-  if (!currentLinks.codex.connected || currentLinks.codex.epoch !== links.codex.epoch) throw Object.assign(new Error('Codex connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
-  return { host: hostname(), observedAt: new Date().toISOString(), sessions: [...new Map(sessions.map(row => [row.session, row])).values()].map(row => ({
-    provider: 'codex', session: row.session, title: terminalText(row.title || titles.get(row.session) || row.session),
-    cwd: terminalText(row.cwd), archived: row.archived === true,
-    workState: sessionWorkState(row),
-  })) };
+  for (const provider of providers) {
+    if (!currentLinks[provider]?.connected || currentLinks[provider].epoch !== links[provider].epoch)
+      throw Object.assign(new Error('Provider connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
+  }
+  if (results.every(result => result.status === 'rejected')) throw results[0].reason;
+  const warnings = results.flatMap((result, index) => result.status === 'rejected'
+    ? [`${providers[index]}: ${terminalText(result.reason?.message || 'Conversation discovery unavailable')}`] : []);
+  const sessions = results.flatMap(result => result.status === 'fulfilled' ? result.value : []);
+  return { host: hostname(), observedAt: new Date().toISOString(), complete: warnings.length === 0, warnings,
+    sessions: [...new Map(sessions.map(row => [`${row.provider}:${row.session}`, row])).values()]
+      .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.provider.localeCompare(b.provider) || a.session.localeCompare(b.session))
+      .map(row => ({
+        provider: row.provider, session: row.session, title: terminalText(row.title || row.session),
+        cwd: terminalText(row.cwd), archived: row.archived === true,
+        workState: sessionWorkState(row),
+      })) };
 }
+// Aggregate only explicitly registered hosts, preserving the host/provider/ID tuple.
+export async function readSessionList({ root, signal, provider = 'all', localOnly = false, includeArchived = false,
+  readLinks = readProviderLinks, loadLocal = readLocalSessionList, loadRemote = readRemoteSessionLists } = {}) {
+  const links = await readLinks(root);
+  const providers = ['codex', 'claude'].filter(name => links[name]?.connected && (provider === 'all' || name === provider));
+  if (!providers.length) throw Object.assign(new Error('Reconnect a provider before listing conversations.'), { code: 'provider_link_disconnected' });
+  const [local, remote] = await Promise.allSettled([
+    loadLocal({ root, signal, provider, includeArchived, readLinks }),
+    localOnly ? [] : loadRemote({ root, signal, providers, includeArchived }),
+  ]);
+  signal?.throwIfAborted();
+  const current = await readLinks(root);
+  for (const name of providers) if (!current[name]?.connected || current[name].epoch !== links[name].epoch)
+    throw Object.assign(new Error('Provider connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
+  const warnings = [], sessions = [], hosts = [];
+  if (local.status === 'fulfilled') {
+    sessions.push(...local.value.sessions.map(row => ({ ...row, hostId: 'local', hostLabel: local.value.host })));
+    warnings.push(...(local.value.warnings || []));
+  } else warnings.push(`local: ${terminalText(local.reason?.message)}`);
+  if (remote.status === 'rejected') warnings.push(`remote: ${terminalText(remote.reason?.message)}`);
+  else for (const result of remote.value) {
+    hosts.push({ id: result.host.id, label: result.host.label, state: result.error ? 'unavailable' : 'ready' });
+    if (result.error) { warnings.push(`${result.host.label}: ${terminalText(result.error)}`); continue; }
+    warnings.push(...(result.catalog.warnings || []).map(warning => `${result.host.label}: ${terminalText(warning)}`));
+    if (result.catalog.complete === false && !result.catalog.warnings?.length) warnings.push(`${result.host.label}: incomplete catalog`);
+    sessions.push(...result.catalog.sessions.map(row => ({
+      provider: row.provider, session: row.session, title: terminalText(row.title || row.session), cwd: terminalText(row.cwd),
+      archived: row.archived === true, hostId: result.host.id, hostLabel: result.host.label,
+      workState: { label: terminalText(row.workState?.label || '状態未確認') },
+    })));
+  }
+  return { host: hostname(), observedAt: new Date().toISOString(), complete: warnings.length === 0, warnings, hosts,
+    sessions: [...new Map(sessions.map(row => [`${row.hostId}:${row.provider}:${row.session}`, row])).values()] };
+}
+
 export function formatSessionList(catalog, query = '') {
   const rows = filterSessionList(catalog.sessions, query);
-  return [`SIMY · Codex会話一覧 · ${terminalText(catalog.host)}`,
+  return [`SIMY · Codex / Claude Code 会話一覧 · ${terminalText(catalog.host)}`,
     `表示 ${rows.length} / ${catalog.sessions.length} 件${query ? ` · 検索: ${terminalText(query)}` : ''}`,
+    ...(catalog.warnings || []).map(warning => `取得未完了: ${terminalText(warning)}`),
     ...rows.flatMap((row, index) => [
       `${index + 1}. ${terminalText(row.title)}`,
-      `   ${terminalText(row.workState?.label || '状態未確認')} · ${row.session}`,
+      `   ${terminalText(row.hostLabel || catalog.host)} · ${row.provider === 'claude' ? 'Claude Code' : 'Codex'} · ${terminalText(row.workState?.label || '状態未確認')} · ${row.session}`,
       `   ${terminalText(row.cwd)}`,
     ]), ...(rows.length ? [] : ['一致する会話はありません。'])].join('\n') + '\n';
 }
 
 export async function runSessionListCommand(argv, { output = process.stdout, errors = process.stderr, input = process.stdin,
-  load = readLocalSessionList, renderInteractive } = {}) {
-  let query = '', json = false, interactive = false, includeArchived = false;
+  load = readSessionList, renderInteractive } = {}) {
+  let query = '', json = false, interactive = false, includeArchived = false, localOnly = false, provider = 'all';
   try {
     for (let i = 0; i < argv.length; i++) {
       const arg = argv[i];
       if (arg === '--help' || arg === '-h') {
-        output.write('simy sessions [--query TEXT] [--json | --interactive] [--include-archived]\n\nShow local Codex conversations. No task is started or resumed.\n'); return 0;
+        output.write('simy sessions [--query TEXT] [--json | --interactive] [--include-archived] [--local-only] [--provider all|codex|claude]\n\nShow available Codex and Claude Code conversations on this host and registered SSH hosts. No task is started or resumed.\n'); return 0;
       }
       if (arg === '--query') {
         if (typeof argv[i + 1] !== 'string' || argv[i + 1].startsWith('--')) throw new Error('--query requires search text.');
@@ -59,6 +114,11 @@ export async function runSessionListCommand(argv, { output = process.stdout, err
       } else if (arg === '--json') json = true;
       else if (arg === '--interactive') interactive = true;
       else if (arg === '--include-archived') includeArchived = true;
+      else if (arg === '--local-only') localOnly = true;
+      else if (arg === '--provider') {
+        provider = argv[++i];
+        if (!['all', 'codex', 'claude'].includes(provider)) throw new Error('--provider requires all, codex or claude.');
+      }
       else throw new Error(`Unknown sessions option: ${terminalText(arg)}`);
     }
     if (json && interactive) throw new Error('Choose --json or --interactive.');
@@ -67,7 +127,7 @@ export async function runSessionListCommand(argv, { output = process.stdout, err
     const cancel = () => controller.abort();
     process.once('SIGINT', cancel); process.once('SIGTERM', cancel);
     try {
-      const refresh = () => load({ includeArchived, signal: controller.signal });
+      const refresh = () => load({ includeArchived, localOnly, provider, signal: controller.signal });
       const catalog = await refresh();
       if (interactive) {
         const start = renderInteractive || (await import('../console/sessions.js')).runSessionListConsole;