@awak-app/simy-cli 0.7.19 → 0.7.21

package/src/console/sessions.js

@@ -7,7 +7,7 @@ export function SessionListConsole({ catalog: initial, query: initialQuery = '',
   const { exit } = useApp(), { stdout } = useStdout();
   const [catalog, setCatalog] = useState(initial), [query, setQuery] = useState(initialQuery);
   const [searching, setSearching] = useState(false), [index, setIndex] = useState(0);
-  const [busy, setBusy] = useState(false), [notice, setNotice] = useState('');
+  const [busy, setBusy] = useState(false), [notice, setNotice] = useState((initial.warnings || []).join('; '));
   const [height, setHeight] = useState(stdout.rows || 24);
   useEffect(() => { const resize = () => setHeight(stdout.rows || 24); stdout.on('resize', resize); return () => stdout.off('resize', resize); }, [stdout]);
   const rows = filterSessionList(catalog.sessions, query), selected = Math.max(0, Math.min(index, Math.max(0, rows.length - 1)));
@@ -26,7 +26,7 @@ export function SessionListConsole({ catalog: initial, query: initialQuery = '',
     if (key.downArrow) setIndex(Math.max(0, Math.min(rows.length - 1, selected + 1)));
     if (text === 'r' && !busy) {
       setBusy(true); setNotice('');
-      void refresh().then(next => { setCatalog(next); setIndex(0); }, error => {
+      void refresh().then(next => { setCatalog(next); setNotice((next.warnings || []).join('; ')); setIndex(0); }, error => {
         if (['provider_link_disconnected', 'provider_link_changed'].includes(error.code)) {
           setCatalog(current => ({ ...current, sessions: [] })); setIndex(0);
         }
@@ -36,15 +36,15 @@ export function SessionListConsole({ catalog: initial, query: initialQuery = '',
   });
   const current = rows[selected];
   return jsxs(Box, { flexDirection: 'column', children: [
-    jsx(Text, { bold: true, color: 'cyan', children: `SIMY · Codex会話一覧 · ${terminalText(catalog.host)}` }),
-    jsx(Text, { children: `表示 ${rows.length} / ${catalog.sessions.length} 件 · この端末の実会話` }),
+    jsx(Text, { bold: true, color: 'cyan', children: `SIMY · Codex / Claude Code 会話一覧 · ${terminalText(catalog.host)}` }),
+    jsx(Text, { children: `表示 ${rows.length} / ${catalog.sessions.length} 件 · 接続先の実会話` }),
     jsx(Text, { color: searching ? 'yellow' : undefined, children: `検索: ${query}${searching ? '▏' : ''}` }),
     ...rows.slice(offset, offset + pageSize).map((row, i) => jsx(Text, {
       color: offset + i === selected ? 'green' : undefined, wrap: 'truncate-end',
       children: `${offset + i === selected ? '›' : ' '} ${terminalText(row.title)}`,
-    }, row.session)),
+    }, `${row.hostId || 'local'}:${row.provider}:${row.session}`)),
     ...(!rows.length ? [jsx(Text, { children: '一致する会話はありません。' }, 'empty')] : []),
-    jsx(Text, { dimColor: true, children: current ? `${terminalText(current.workState?.label)} · ${current.session}` : '' }),
+    jsx(Text, { dimColor: true, children: current ? `${terminalText(current.hostLabel || catalog.host)} · ${current.provider === 'claude' ? 'Claude Code' : 'Codex'} · ${terminalText(current.workState?.label)} · ${current.session}` : '' }),
     jsx(Text, { dimColor: true, wrap: 'truncate-end', children: terminalText(current?.cwd) }),
     jsx(Text, { color: notice ? 'red' : undefined, children: notice || (busy ? '更新中…' : '↑↓ 選択  / 検索  Esc 解除  r 更新  q 終了') }),
   ] });

package/src/delivery-hooks/command.js

@@ -144,19 +144,20 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
       output(JSON.stringify(result, null, 2)); return result.status === 'not_requested' ? 2 : 0;
     }
     if (['supervisor-enable', 'supervisor-disable', 'supervisor-watch', 'supervisor-status', 'supervisor-watchdog-install'].includes(args[0])) {
-      const options = parseDeliveryOptions(args.slice(1), new Set(['root']));
+      const options = parseDeliveryOptions(args.slice(1), new Set(['root', ...(args[0] === 'supervisor-enable' ? ['provider', 'session'] : [])]));
       const supervisorRoot = options.root || dirname(root);
       if (!isAbsolute(supervisorRoot)) throw new Error('Supervisor root must be absolute.');
       if (args[0] === 'supervisor-watch') {
         const controller = new AbortController(), interrupt = () => controller.abort('user_interrupt'), terminate = () => controller.abort('service_termination');
-        process.once('SIGINT', interrupt); process.once('SIGTERM', terminate);
+        process.once('SIGINT', interrupt); process.once('SIGTERM', terminate); process.once('SIGHUP', terminate);
         try { await watchSupervisor({ root: supervisorRoot, signal: controller.signal }); }
-        finally { process.removeListener('SIGINT', interrupt); process.removeListener('SIGTERM', terminate); }
+        finally { process.removeListener('SIGINT', interrupt); process.removeListener('SIGTERM', terminate); process.removeListener('SIGHUP', terminate); }
         return 0;
       }
       const result = args[0] === 'supervisor-status' ? await supervisorWatchdogStatus({ root: supervisorRoot })
         : args[0] === 'supervisor-watchdog-install' ? await installSupervisorService({ root: supervisorRoot })
-        : await setSupervisorWatchdog({ root: supervisorRoot, enabled: args[0] === 'supervisor-enable', webOrigin });
+        : await setSupervisorWatchdog({ root: supervisorRoot, enabled: args[0] === 'supervisor-enable', webOrigin,
+          ...((options.provider || options.session) ? { target: { provider: options.provider, session: options.session } } : {}) });
       output(JSON.stringify(result, null, 2)); return 0;
     }
     if (args[0] === 'policy-adopt') {
@@ -187,11 +188,12 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
     return 0;
   }
   if (action === 'supervise') {
-    if (args.length > 1 || args.length === 1 && args[0] !== '--once') throw new Error('Use simy delivery supervise [--once].');
+    const once = args.includes('--once');
+    const options = parseDeliveryOptions(args.filter(arg => arg !== '--once'), new Set(['activation-epoch']));
     const controller = new AbortController();
     const stop = () => controller.abort();
     process.once('SIGINT', stop); process.once('SIGTERM', stop);
-    try { await superviseLocalDelivery({ root, webOrigin, once: args[0] === '--once', signal: controller.signal }); }
+    try { await superviseLocalDelivery({ root, webOrigin, once, activationEpoch: options['activation-epoch'], signal: controller.signal }); }
     finally { process.removeListener('SIGINT', stop); process.removeListener('SIGTERM', stop); }
     return 0;
   }

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-access.js

@@ -8,7 +8,7 @@ export function validDesktopAccessPath(path, slug) {
 }
 export const desktopAccessReady = value => value?.state === 'ready';
 const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'organization_select', 'organization_cancel', 'organizations_refresh',
-  'check_update', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
+  'check_update', 'auto_update_set_enabled', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
   'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
 export function desktopActionAllowed(access, command) {
   return desktopAccessReady(access) || recoveryActions.has(command?.action) ||

package/src/desktop-host.js

@@ -1,4 +1,6 @@
+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';
 import { createCoordinatorReconciler } from "./update-detachment/reconciliation-adapter.js";
 import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adapter.js";
@@ -24,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";
@@ -169,10 +171,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let encodedStatus = null, lastStatus = null, updateProgress = null;
   let remoteHosts;
   const emitStatus = status => {
+    const updateSettings = updater?.snapshot?.() || {};
+    status = { ...status, update: { ...status.update,
+      auto_update_supported: updateSettings.auto_update_supported === true,
+      auto_update_enabled: updateSettings.auto_update_enabled === true,
+      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;
@@ -644,8 +651,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
-      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
-      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(sampledAccess)});
       const requestedLinks = await decorateProviderSettings(status);
       const sameScope = desktopAccessReady(currentAccess) &&
         accessScope(lastStatus?.access) === accessScope(currentAccess);
@@ -694,8 +700,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
-      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
-      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(sampledAccess)});
       const requestedScope = accessScope(currentAccess);
       const requestedLinks = await decorateProviderSettings(status);
       const allRecords = await recordReader.list();
@@ -841,6 +846,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     updater = await (dependencies.createUpdater || (process.platform === "win32" ? (() => createWindowsDesktopUpdater({ version: packageInfo.version, disabled: env.SIMY_AUTO_UPDATE === "0" })) : createCliAutoUpdater))({
       daemon: true, interactive: true, webOrigin,
       disabled: env.SIMY_AUTO_UPDATE === "0",
+      autoUpdatesEnabled: readDesktopAutoUpdate(root),
       ...(updatePackageRoot ? { packageRoot: updatePackageRoot } : {}),
       dependencies: { packageInfo: updatePackageRoot ? await readCliPackageInfo(updatePackageRoot) : packageInfo,
         logger: message => diagnostics.write(`update: ${message}`) },
@@ -1055,7 +1061,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       return;
     }
     if(command.action==='cancel_detach_update') {
-      try {updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.());coordinator.cancel();emit({type:'result',id:command.id,ok:true});}
+      try {updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(currentAccess)});coordinator.cancel();emit({type:'result',id:command.id,ok:true});}
       catch {emit({type:'result',id:command.id,ok:false,message:'This update operation changed. Refresh its status.'});}
       return;
     }
@@ -1124,7 +1130,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
-        const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) ||
+        const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) || action === 'auto_update_set_enabled' && command.enabled === false ||
           ['session_set_auto_continue', 'session_set_email_reports', 'team_thread_share'].includes(action) && command.enabled === false;
         if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
         else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
@@ -1162,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.
@@ -1278,6 +1284,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
               if (!result.opened) throw new Error('Browser unavailable.');
             } catch { throw Object.assign(new Error('Browser unavailable.'), { code: 'desktop_browser_unavailable' }); }
           }
+        } else if (action === 'auto_update_set_enabled') {
+          if (typeof command.enabled !== 'boolean' || typeof updater.setAutomaticUpdates !== 'function') throw new Error('Automatic updates are unavailable.');
+          const previous = updater.snapshot().auto_update_enabled === true;
+          updater.setAutomaticUpdates(command.enabled);
+          try { writeDesktopAutoUpdate(root, command.enabled); }
+          catch (error) { updater.setAutomaticUpdates(previous); throw error; }
+          emit({ type: 'result', id: command.id, ok: true });
+          await publish();
+          if (command.enabled) setImmediate(() => { if (!closed && !relay) void updater.checkNow().catch(() => {}); });
+          return;
         } else if (action === "check_update") await updater.checkNow();
         else if (action === "update") {
           const status = await agent.getDesktopStatus();
@@ -1514,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,
@@ -1556,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/desktop-update-settings.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { readState, atomicSave } from './update-detachment/state-store.js';
+
+export function readDesktopAutoUpdate(root) {
+  try {
+    const settings = readState(join(root, 'desktop-update-settings.json'));
+    return settings === null ? true : settings.enabled === true;
+  }
+  catch { return false; }
+}
+
+export function writeDesktopAutoUpdate(root, enabled) {
+  if (typeof enabled !== 'boolean') throw new Error('Choose whether automatic updates are enabled.');
+  atomicSave(join(root, 'desktop-update-settings.json'), { schemaVersion: 1, enabled });
+}

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 } = {}) {