@awak-app/simy-cli 0.7.12 → 0.7.14

package/README.md

@@ -1193,3 +1193,29 @@ Diagnostics do not reconnect providers or enable existing tasks. Explicit refres
 waits for a fresh probe when a pre-login check is already running. macOS login
 terminals preserve an explicitly configured `CODEX_HOME` or `CLAUDE_CONFIG_DIR`,
 without copying credentials.
+
+### Remote Codex conversations on Mac
+
+Connect an existing NVIDIA/SSH machine from **Remote connections…** in the
+conversation sidebar. SIMY merges its conversations and sends operations to the
+original machine. See [setup, access requirements and recovery](docs/remote-codex-sessions.md).
+
+### Local conversation list on NVIDIA / Linux
+
+Run `simy sessions` directly on the machine where Codex is running. It reads
+that machine's actual Codex conversation metadata without starting the agent,
+updater, analysis worker or a Delivery Loop. No Mac or SSH bridge is needed.
+
+```sh
+simy sessions --query NVIDIA
+simy sessions --interactive
+simy sessions --json
+```
+
+In the interactive list, use Up/Down to select a conversation, `/` to search its
+title, folder or ID, Enter to finish searching, Esc to clear the filter, `r` to
+refresh and `q` to quit. The selected conversation shows its exact ID and folder.
+Search covers the current recent window (up to 200 active conversations and,
+with `--include-archived`, up to 200 archived conversations); older entries outside
+that window are not searched. This view respects the saved
+Codex provider connection setting and never enables automatic continuation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -39,7 +39,7 @@
     "test:e2e:console:real-provider": "node ./scripts/real-provider-console-e2e.js",
     "test:e2e:console:fullstack": "node ./scripts/fullstack-cli-smoke.js",
     "check": "npm run check:auto-update && node --check ./src/desktop-executor.js && node --check ./src/local-task.js && node --check ./scripts/desktop-executor-e2e.js && node --check ./scripts/pre-guardrail-e2e.js && node --check ./scripts/fixtures/fake-desktop-provider.js && npm run check:syntax && npm run check:session-supervision-syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
-    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs && node --check ./src/session-supervision/purpose-instruction.js && node --check ./src/session-supervision/purpose-recovery.js && node --check ./src/session-supervision/purpose-candidate.js && node --check ./src/codex-plugins/simy/hooks/scene-reasoning.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-cycle.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-rule-review.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-search.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-evidence.mjs && node --check ./src/session-supervision/purpose-observer.js && node --check ./src/session-supervision/purpose-verification.js && node --check ./src/codex-plugins/simy/hooks/purpose-workspace.mjs && node --check ./scripts/purpose-search-live-e2e.js",
+    "check:session-supervision-syntax": "node --check ./src/session-supervision/session-list.js && node --check ./src/console/sessions.js && node --check ./src/session-supervision/remote-hosts.js && node --check ./src/session-supervision/remote-entry.js && node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs && node --check ./src/session-supervision/purpose-instruction.js && node --check ./src/session-supervision/purpose-recovery.js && node --check ./src/session-supervision/purpose-candidate.js && node --check ./src/codex-plugins/simy/hooks/scene-reasoning.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-cycle.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-rule-review.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-search.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-evidence.mjs && node --check ./src/session-supervision/purpose-observer.js && node --check ./src/session-supervision/purpose-verification.js && node --check ./src/codex-plugins/simy/hooks/purpose-workspace.mjs && node --check ./scripts/purpose-search-live-e2e.js",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
     "check:sqm": "node --check ./src/sqm/advisory-guidance.js && node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/history-store.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",

package/src/agent.js

@@ -650,7 +650,9 @@ export async function startAgent({
       if (!isSessionValid(session, Date.now(), apiOrigin)) throw new Error("Sign in before switching organizations.");
       if (organizationState !== "ready" || !organizationItems.some(org => org.id === organizationId)) throw new Error("Refresh the organization list before selecting an organization.");
       const choice = organizationItems.find(org => org.id === organizationId);
-      if (choice.desktopAccess && choice.desktopAccess !== "ready") throw new Error("This organization does not have SIMY Developer access.");
+      // Selecting an authenticated membership is separate from permission to run.
+      // The new session still requires a fresh server entitlement before work.
+      if (choice.desktopAccess === "unavailable") throw new Error("Refresh organizations before switching; access could not be verified.");
       organizationSlug = choice.slug;
       if (!organizationSlug) throw new Error('Refresh organizations before switching; its verified slug is unavailable.');
       authNonce = randomBytes(16).toString("base64url");

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.12";
+export const CLI_VERSION = "0.7.14";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/console/sessions.js

@@ -0,0 +1,58 @@
+import { useEffect, useState } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Box, Text, render, useApp, useInput, useStdout } from 'ink';
+import { filterSessionList, terminalText } from '../session-supervision/session-list.js';
+
+export function SessionListConsole({ catalog: initial, query: initialQuery = '', refresh }) {
+  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 [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)));
+  const pageSize = Math.max(1, height - 10), offset = Math.floor(selected / pageSize) * pageSize;
+  useInput((text, key) => {
+    if (key.ctrl && text === 'c' || !searching && text === 'q') { exit(); return; }
+    if (key.escape) { setSearching(false); setQuery(''); setIndex(0); return; }
+    if (searching) {
+      if (key.return) setSearching(false);
+      else if (key.backspace || key.delete) { setQuery(q => [...q].slice(0, -1).join('')); setIndex(0); }
+      else if (text && !key.ctrl && !key.meta && !key.upArrow && !key.downArrow) { setQuery(q => q + (text === ' ' ? ' ' : terminalText(text))); setIndex(0); }
+      return;
+    }
+    if (text === '/') { setSearching(true); return; }
+    if (key.upArrow) setIndex(Math.max(0, selected - 1));
+    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 => {
+        if (['provider_link_disconnected', 'provider_link_changed'].includes(error.code)) {
+          setCatalog(current => ({ ...current, sessions: [] })); setIndex(0);
+        }
+        setNotice(terminalText(error.message));
+      }).finally(() => setBusy(false));
+    }
+  });
+  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, { 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)),
+    ...(!rows.length ? [jsx(Text, { children: '一致する会話はありません。' }, 'empty')] : []),
+    jsx(Text, { dimColor: true, children: current ? `${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 終了') }),
+  ] });
+}
+export async function runSessionListConsole({ input, output, signal, ...props }) {
+  const app = render(jsx(SessionListConsole, props), { stdin: input, stdout: output, exitOnCtrlC: false, patchConsole: false });
+  const abort = () => app.unmount();
+  signal?.addEventListener('abort', abort, { once: true });
+  if (signal?.aborted) abort();
+  try { await app.waitUntilExit(); } finally { signal?.removeEventListener('abort', abort); app.unmount(); }
+}

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { createRemoteHostManager } from './session-supervision/remote-hosts.js';
 import { createUpdateRuntime } from './update-detachment/runtime.js';
 import { createCoordinatorReconciler } from "./update-detachment/reconciliation-adapter.js";
 import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adapter.js";
@@ -75,6 +76,7 @@ async function withReadCancellation(signal, work) {
 }
 
 function desktopActionError(action, error) {
+  if (String(error?.code).startsWith("remote_host_")) return error.message;
   if (error?.code === "provider_link_changed") return "SIMY connection changed. Refresh and select the conversation again.";
   if (error?.code === "provider_link_disconnected") return "Reconnect this provider to SIMY before using it.";
   if (["provider_connect", "provider_disconnect"].includes(action)) {
@@ -163,7 +165,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
   // volatile; reuse the encoded body after comparing freshly authorized data.
   // Detach the comparison value because registries may mutate nested objects.
   let encodedStatus = null, lastStatus = null, updateProgress = null;
+  let remoteHosts;
   const emitStatus = status => {
+    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);
+    }
     if (updateProgress) status = { ...status, update: { ...status.update, ...updateProgress } };
     const { sampledAt, ...content } = status;
     if (!lastStatus || !isDeepStrictEqual(content, lastStatus)) {
@@ -212,6 +220,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let activeStatisticsRead = null;
   let statisticsSelection = { key: null, generation: 0 };
   const stopNotifier = createStopNotifier({ emit: event => { if (!closed && !relay) emit(event); } });
+  if (env.SIMY_REMOTE_CHILD !== "1" && process.platform !== "win32") remoteHosts = (dependencies.createRemoteHostManager || createRemoteHostManager)({ root, onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); } });
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   let nativeDevelopmentReports = { state: 'loading', enrollments: [] };
   let nativeDevelopmentReportsScope = null;
@@ -785,7 +794,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     // reader must never postpone cancellation of an owned Provider process.
     const results = await Promise.allSettled([stopDiscovery({ drain: true }), publishing, connectionPublishing,
       pluginInspection,
-      actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
+      remoteHosts?.close(), actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
       managedSupervisor.close(), recordReader.close(), stopWorkflows(),
       agent ? createAgentShutdown(agent)() : undefined]);
     const failure = results.find(result => result.status === "rejected");
@@ -1108,6 +1117,27 @@ export async function startDesktopHost({ input = process.stdin, output = process
           !(action === "session_set_auto_continue" && command.enabled === false)) {
           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' });
+          await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
+          const status = await agent.getDesktopStatus();
+          // Status collection can yield while provider consent is revoked.
+          // Reject before writing SSH bytes, not only after its result arrives.
+          await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
+          const result = await remoteHosts.forward(command, status);
+          await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
+          emit(result); void publish().catch(() => {}); return;
+        }
+        if (!command.hostId && command.session && remoteHosts?.hasSession(command.session)) {
+          throw Object.assign(new Error('Select the host for this conversation before continuing.'), { code: 'remote_host_invalid' });
+        }
+        if (action === 'remote_host_save' || action === 'remote_host_remove') {
+          if (!remoteHosts) throw Object.assign(new Error('Nested remote connections are unavailable.'), { code: 'remote_host_invalid' });
+          if (action === 'remote_host_save') await authorizeProvider('codex', commandScope);
+          else await authorizeWork(commandScope);
+          await remoteHosts.save({ alias: command.alias, label: command.label }, action === 'remote_host_remove');
+          emit({ type: 'result', id: command.id, ok: true }); await publish(); return;
+        }
         if (action === "provider_connect" || action === "provider_disconnect") {
           await changeProviderLink(command.provider, action === "provider_connect");
           emit({ type: "result", id: command.id, ok: true });
@@ -1594,6 +1624,7 @@ function desktopStartupError(error, fallbackMessage = "SIMY could not start. Che
 
 // Immutable pins predate this option; their launcher must keep the old update fence.
 export const supportsDesktopUpdatePackageRoot = true;
+export const remoteSessionProtocol = 1;
 
 export function startDesktopEntry(options = {}) {
   let host;

package/src/index.js

@@ -38,7 +38,7 @@ const commandArgv = argv.filter((value) => value !== "--no-auto-update");
 // Delivery receives the resolved origin separately; global --host is not one
 // of its command-specific options, regardless of its position on the CLI.
 const deliveryArgv = commandArgv.filter((value, index) => value !== "--host" && commandArgv[index - 1] !== "--host");
-const dispatchArgv = deliveryArgv[0] === "delivery" ? deliveryArgv : commandArgv;
+const dispatchArgv = ["delivery", "sessions"].includes(deliveryArgv[0]) ? deliveryArgv : commandArgv;
 const entryPath = fileURLToPath(import.meta.url);
 const packageInfo = await readCliPackageInfo();
 const updatesDisabled = args.has("--no-auto-update") || process.env.SIMY_AUTO_UPDATE === "0";
@@ -62,6 +62,9 @@ if (!configuredWebOrigin) {
   // Invalid host input is reported above before update discovery or startup.
 } else if (args.has("--version") || args.has("-v")) {
   console.log(packageInfo.version);
+} else if (dispatchArgv[0] === "sessions") {
+  const { runSessionListCommand } = await import("./session-supervision/session-list.js");
+  process.exitCode = await runSessionListCommand(dispatchArgv.slice(1));
 } else if (dispatchArgv[0] === "doctor") {
   const { runDoctor } = await import("./doctor.js");
   process.exitCode = await runDoctor({ webOrigin: configuredWebOrigin, cliVersion: packageInfo.version });
@@ -146,6 +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 update         ${installMode === "macos_installer" ? "Show Apple Silicon update status and installer action" : "Install an eligible stable CLI update"}
 
 Options:

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

@@ -0,0 +1,20 @@
+// SSH-only entry point. Keep the normal signed/runtime-pinned desktop startup,
+// account/organization checks, provider consent and native execution boundaries.
+// No device credential is relayed from the Mac and hosts cannot recurse.
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { adoptInstalledRuntime, pinnedWorkflowSource } from '../delivery-hooks/local-runtime.js';
+process.env.SIMY_REMOTE_CHILD = '1';
+process.env.SIMY_AUTO_UPDATE = '0';
+const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
+try {
+  await adoptInstalledRuntime({ root });
+  const selected = await pinnedWorkflowSource({ root });
+  const host = await import(selected ? pathToFileURL(join(selected, 'src/desktop-host.js')).href : '../desktop-host.js');
+  if (host.remoteSessionProtocol !== 1) throw new Error('Update the remote SIMY runtime.');
+  host.startDesktopEntry();
+} catch {
+  process.stdout.write(JSON.stringify({ type: 'error', message: 'Remote SIMY could not start. Update its runtime and check its existing desktop connection.' }) + '\n');
+  process.exitCode = 1;
+}

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

@@ -0,0 +1,218 @@
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compareSessionWork } from './work-state.js';
+
+const MAX_FRAME = 8 * 1024 * 1024;
+const MAX_HOSTS = 8;
+const aliasPattern = /^[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127}$/;
+export const remoteHostId = alias => `remote-ssh-discovered:${alias}`;
+// Resolve the installed SIMY executable on the remote login PATH. No local
+// credential, command payload, or user-supplied shell text enters this script.
+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_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_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']);
+const error = (message, code = 'remote_host_unavailable') => Object.assign(new Error(message), { code });
+function normalizedHost(value) {
+  if (!value || typeof value.alias !== 'string' || !aliasPattern.test(value.alias)) throw error('Enter an SSH host alias, for example nvidia-workstation.', 'remote_host_invalid');
+  const label = typeof value.label === 'string' ? value.label.trim() : '';
+  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) {
+  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'); }
+  if (value?.schemaVersion !== 1 || !Array.isArray(value.hosts) || value.hosts.length > MAX_HOSTS) throw error('Remote host settings are invalid.', 'remote_host_settings');
+  const hosts = value.hosts.map(normalizedHost);
+  if (new Set(hosts.map(h => h.id)).size !== hosts.length) throw error('Duplicate remote hosts.', 'remote_host_settings');
+  return hosts;
+}
+const scopeOf = status => JSON.stringify([status?.auth?.userId, status?.access?.organizationId, status?.access?.revision]);
+const usable = status => status?.auth?.state === 'signed_in' && typeof status.auth.userId === 'string' && status.auth.userId &&
+  status.access?.state === 'ready' && typeof status.access.organizationId === 'string' && status.access.organizationId;
+function stamp(value, host, depth = 0) {
+  if (depth > 40) return null;
+  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;
+  return result;
+}
+
+// Each remote host owns its records, controller, provider calls and workspace.
+// The Mac only projects status and forwards explicit, host-scoped commands.
+export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = () => {}, now = Date.now,
+  retryMs = 15_000, requestTimeoutMs = 45_000, handshakeTimeoutMs = 15_000 } = {}) {
+  const connections = new Map();
+  let scope = null, local = null, closed = false, settingsError = null, writes = Promise.resolve(), generation = 0;
+  const changed = () => { if (!closed) onChange(); };
+  function disconnect(connection, reason = 'Remote connection closed.') {
+    const child = connection.child;
+    connection.child = null; connection.ready = false; connection.reason = reason; connection.state = 'unavailable'; connection.retryAt = now() + retryMs;
+    clearTimeout(connection.handshake);
+    for (const job of connection.pending.values()) { clearTimeout(job.timer); job.reject(error('Remote connection lost. Check the original conversation before retrying this operation.')); }
+    connection.pending.clear();
+    if (child) {
+      child.stdin.end(); child.kill('SIGTERM');
+      const force = setTimeout(() => { if (child.exitCode === null && child.signalCode == null) child.kill('SIGKILL'); }, 2000);
+      force.unref?.(); child.once('close', () => clearTimeout(force));
+    }
+  }
+  function connect(connection) {
+    if (closed || connection.child || now() < connection.retryAt) return;
+    connection.state = 'connecting'; connection.reason = null;
+    let child;
+    try { child = spawnImpl('ssh', ['-T', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes', '-o', 'ConnectTimeout=5',
+      '-o', 'ServerAliveInterval=10', '-o', 'ServerAliveCountMax=2', '--', connection.alias, REMOTE_HOST_COMMAND], { stdio: ['pipe', 'pipe', 'pipe'], shell: false }); }
+    catch { disconnect(connection, 'Could not start SSH.'); return; }
+    connection.child = child;
+    connection.handshake = setTimeout(() => {
+      if (connection.child === child) { disconnect(connection, 'Remote SIMY did not respond. Check SSH and update SIMY on the remote host.'); changed(); }
+    }, handshakeTimeoutMs);
+    connection.handshake.unref?.();
+    let buffer = Buffer.alloc(0);
+    const failed = () => {
+      if (connection.child !== child) return;
+      disconnect(connection, 'SSH disconnected. Check the saved host alias, SSH key, known host and remote SIMY installation.'); changed();
+    };
+    child.stderr.resume();
+    child.on('error', failed); child.on('close', failed); child.stdin.on('error', failed);
+    child.stdout.on('data', chunk => {
+      if (connection.child !== child) return;
+      let offset = 0;
+      while (offset < chunk.length) {
+        const newline = chunk.indexOf(10, offset), end = newline < 0 ? chunk.length : newline;
+        const piece = chunk.subarray(offset, end);
+        if (buffer.length + piece.length > MAX_FRAME) { disconnect(connection, 'Remote status exceeded the supported size.'); changed(); return; }
+        buffer = buffer.length ? Buffer.concat([buffer, piece]) : piece;
+        if (newline < 0) break;
+        const line = buffer.toString('utf8'); buffer = Buffer.alloc(0); offset = newline + 1;
+        let frame; try { frame = JSON.parse(line); } catch { continue; }
+        if (!frame || typeof frame !== 'object') continue;
+        if (frame.type === 'status') {
+          const status = frame.status;
+          if (status?.remoteSessionProtocol !== 1) { disconnect(connection, 'Update SIMY on the remote host to use remote sessions.'); changed(); return; }
+          if (!usable(status) || status.auth.userId !== local?.auth?.userId || status.access.organizationId !== local?.access?.organizationId) {
+            clearTimeout(connection.handshake);
+            connection.ready = false; connection.state = 'access_required'; connection.reason = 'Sign in to the same SIMY account and organization on the remote host.';
+            connection.status = null;
+            for (const job of connection.pending.values()) { clearTimeout(job.timer); job.reject(error(connection.reason, 'remote_host_access')); }
+            connection.pending.clear();
+          } else if (!Array.isArray(status.sessionSupervision?.sessions) || !Array.isArray(status.deliveryHooks?.runs)) {
+            connection.ready = false; connection.state = 'connecting'; connection.reason = 'Waiting for remote conversation status.';
+          } else {
+            clearTimeout(connection.handshake);
+            connection.status = status; connection.ready = true; connection.state = 'ready'; connection.reason = null; connection.receivedAt = now();
+          }
+          changed();
+        } else if (frame.type === 'error') {
+          disconnect(connection, 'Remote SIMY could not start. Check its installation, login and existing desktop connection.'); 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.' } : {}) });
+        }
+      }
+    });
+  }
+  async function update(status) {
+    if (closed) return;
+    const nextScope = usable(status) ? scopeOf(status) : null;
+    if (scope !== nextScope) {
+      generation++;
+      for (const c of connections.values()) disconnect(c);
+      connections.clear(); scope = nextScope;
+    }
+    local = { auth: status?.auth, access: status?.access };
+    if (!scope) return;
+    const observedGeneration = generation;
+    let hosts;
+    try { hosts = await readHosts(root); settingsError = null; }
+    catch (e) { settingsError = e.message; hosts = []; }
+    if (closed || scope !== nextScope || generation !== observedGeneration) return;
+    for (const [id, c] of connections) if (!hosts.some(h => h.id === id)) { disconnect(c); connections.delete(id); }
+    for (const host of hosts) {
+      let c = connections.get(host.id);
+      if (!c) { c = { ...host, pending: new Map(), retryAt: 0, ready: false, status: null }; connections.set(host.id, c); }
+      c.label = host.label;
+      if (c.ready && now() - c.receivedAt > 45_000) disconnect(c, 'Remote status is stale. Reconnecting.');
+      connect(c);
+    }
+  }
+  async function save(value, remove = false) {
+    const host = normalizedHost(value);
+    const work = writes.catch(() => {}).then(async () => {
+      const hosts = (await readHosts(root)).filter(h => h.id !== host.id);
+      if (!remove) hosts.push(host);
+      if (hosts.length > MAX_HOSTS) throw error('At most eight remote hosts can be connected.', 'remote_host_invalid');
+      await mkdir(root, { recursive: true, mode: 0o700 });
+      const path = join(root, 'remote-hosts.json'), temporary = `${path}.${randomUUID()}.tmp`;
+      try { await writeFile(temporary, JSON.stringify({ schemaVersion: 1, hosts }) + '\n', { mode: 0o600 }); await rename(temporary, path); }
+      finally { await rm(temporary, { force: true }); }
+      generation++;
+      const c = connections.get(host.id);
+      if (c) { disconnect(c); if (remove) connections.delete(host.id); else c.retryAt = 0; }
+      changed();
+    });
+    writes = work; await work;
+  }
+  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');
+    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');
+    const id = randomUUID();
+    const { hostId, ...payload } = command;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { c.pending.delete(id); reject(error('Remote operation timed out. Check its result in the original conversation before retrying.')); }, requestTimeoutMs);
+      c.pending.set(id, { id: command.id, resolve, reject, timer });
+      c.child.stdin.write(JSON.stringify({ ...payload, id }) + '\n', e => {
+        if (e && c.pending.has(id)) { c.pending.delete(id); clearTimeout(timer); reject(error('Remote command could not be delivered.')); }
+      });
+    });
+  }
+  function project(status) {
+    if (!usable(status) || scopeOf(status) !== scope) return status;
+    const hosts = [...connections.values()];
+    const sessions = [], runs = [];
+    for (const c of hosts) {
+      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;
+        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}.` };
+        if (!ready) {
+          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;
+          item.isRunning = false; item.availability = 'unknown'; item.reason = unavailableReason; item.decisionRequest = null;
+          item.workState = { state: 'unknown', label: '接続先を確認できません', reason: unavailableReason, stale: true, fetchFailed: true, checkedAt: c.receivedAt, needsAttention: false };
+          item.statistics = { state: 'unavailable', hours: [], activity: [] };
+        }
+        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}.` } });
+    }
+    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)),
+    async close() { closed = true; for (const c of connections.values()) disconnect(c); connections.clear(); await writes.catch(() => {}); } };
+}

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

@@ -0,0 +1,79 @@
+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 { 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)));
+}
+
+// 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 } = {}) {
+  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();
+  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),
+  })) };
+}
+export function formatSessionList(catalog, query = '') {
+  const rows = filterSessionList(catalog.sessions, query);
+  return [`SIMY · Codex会話一覧 · ${terminalText(catalog.host)}`,
+    `表示 ${rows.length} / ${catalog.sessions.length} 件${query ? ` · 検索: ${terminalText(query)}` : ''}`,
+    ...rows.flatMap((row, index) => [
+      `${index + 1}. ${terminalText(row.title)}`,
+      `   ${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;
+  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;
+      }
+      if (arg === '--query') {
+        if (typeof argv[i + 1] !== 'string' || argv[i + 1].startsWith('--')) throw new Error('--query requires search text.');
+        query = argv[++i];
+      } else if (arg === '--json') json = true;
+      else if (arg === '--interactive') interactive = true;
+      else if (arg === '--include-archived') includeArchived = true;
+      else throw new Error(`Unknown sessions option: ${terminalText(arg)}`);
+    }
+    if (json && interactive) throw new Error('Choose --json or --interactive.');
+    if (interactive && !input.isTTY) throw new Error('--interactive requires a terminal. Use simy sessions for plain output.');
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.once('SIGINT', cancel); process.once('SIGTERM', cancel);
+    try {
+      const refresh = () => load({ includeArchived, signal: controller.signal });
+      const catalog = await refresh();
+      if (interactive) {
+        const start = renderInteractive || (await import('../console/sessions.js')).runSessionListConsole;
+        await start({ catalog, query, refresh, input, output, signal: controller.signal });
+      } else output.write(json ? JSON.stringify({ ...catalog, sessions: filterSessionList(catalog.sessions, query) }, null, 2) + '\n' : formatSessionList(catalog, query));
+    } finally { controller.abort(); process.removeListener('SIGINT', cancel); process.removeListener('SIGTERM', cancel); }
+    return 0;
+  } catch (error) { errors.write(`SIMY: ${terminalText(error.message)}\n`); return 1; }
+}