@awak-app/simy-cli 0.7.25 → 0.7.27

package/src/console/app.js

@@ -8,6 +8,7 @@ import { Box, Spacer, Text, useApp, useInput, useStdout } from "ink";
 import { consoleHelpLines, parseConsoleCommand } from "./commands.js";
 import { summarizeCodingLoopEvent } from "../orchestrator/presentation.js";
 import { isLocalRepositoryApprovalPending } from "../runner.js";
+import { connectionStartupHint, connectionGuideLines } from '../remote-connection-guide.js';
 
 const TERMINAL_STATES = new Set([
   "merge_ready",
@@ -19,7 +20,7 @@ const TERMINAL_STATES = new Set([
 ]);
 const NEW_TASK = "__new_task__";
 
-export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
+export function AgenticLoopConsole({ agent, onQuit = () => {}, remoteConnections = { hosts: [], warnings: [] } }) {
   const { exit } = useApp();
   const { stdout } = useStdout();
   const [terminal, setTerminal] = useState(() => terminalSize(stdout));
@@ -29,7 +30,10 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
   const [inputMode, setInputMode] = useState(() => runs.length === 0);
   const [input, setInput] = useState("");
   const [busy, setBusy] = useState(false);
-  const [notice, setNotice] = useState("");
+  const [notice, setNotice] = useState(() => connectionStartupHint(remoteConnections));
+  const [connectionsOpen, setConnectionsOpen] = useState(false);
+  const [connectionIndex, setConnectionIndex] = useState(0);
+  const [connectionScroll, setConnectionScroll] = useState(0);
   const [showHelp, setShowHelp] = useState(false);
   const [confirmStop, setConfirmStop] = useState(false);
   const [detailOpen, setDetailOpen] = useState(false);
@@ -71,12 +75,16 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
   const hasNextAction = Boolean(
     selectedRun && nextActionForRun(selectedRun, isRepositoryMissing(selectedRun)),
   );
+  const effectiveNotice = connectionsOpen ? '' : notice;
   const actionRows =
     1 +
     (hasNextAction ? 1 : 0) +
-    (notice || busy ? 1 : 0) +
+    (effectiveNotice || busy ? wrapTerminalText(`STATUS  ${effectiveNotice || 'Please wait…'}`, terminal.columns).length : 0) +
     (visibleUpdateNotice(cliUpdate) ? 1 : 0);
   const mainHeight = Math.max(8, terminal.rows - 5 - actionRows);
+  const connectionRows = remoteConnectionRows(remoteConnections, connectionIndex, terminal.columns);
+  const connectionPageSize = Math.max(1, mainHeight - 4);
+  const connectionMaxScroll = Math.max(0, connectionRows.length - connectionPageSize);
   const detailInnerWidth = Math.max(20, terminal.columns - 4);
   const detailRows = useMemo(
     () => buildRunDetailRows(selectedRun, detailInnerWidth),
@@ -117,6 +125,12 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
       setShowHelp(true);
       return;
     }
+    if (command.type === 'connections') {
+      setConnectionsOpen(true);
+      setConnectionScroll(0);
+      setShowHelp(false);
+      return;
+    }
     if (command.type === "new") {
       setSelectedId(NEW_TASK);
       setDetailOpen(false);
@@ -336,6 +350,17 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
 
   const inputHandlerRef = useRef(() => {});
   inputHandlerRef.current = (character, key) => {
+    if (connectionsOpen) {
+      if (key.escape || (key.ctrl && character === 'c')) {
+        setConnectionsOpen(false);
+        if (!selectedRun) setInputMode(true);
+      } else if (key.upArrow || key.downArrow) {
+        setConnectionIndex(current => Math.max(0, Math.min(Math.max(0, remoteConnections.hosts.length - 1), current + (key.upArrow ? -1 : 1))));
+        setConnectionScroll(0);
+      } else if (key.pageDown) setConnectionScroll(current => Math.min(connectionMaxScroll, current + connectionPageSize));
+      else if (key.pageUp) setConnectionScroll(current => Math.max(0, current - connectionPageSize));
+      return;
+    }
     if (scanPrompt) {
       if (key.escape || String(character).toLowerCase() === "n") {
         setScanPrompt(null);
@@ -505,7 +530,9 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
       jsx(Box, {
         marginTop: 1,
         height: mainHeight,
-        children: showHelp
+        children: connectionsOpen
+          ? jsx(RemoteConnectionsGuide, { rows: connectionRows, scroll: Math.min(connectionScroll, connectionMaxScroll), pageSize: connectionPageSize, width: terminal.columns })
+          : showHelp
           ? jsx(Help, { width: terminal.columns })
           : scanPrompt
             ? jsx(RepositoryScanConsent, {
@@ -548,10 +575,10 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
         inputMode,
         input,
         busy,
-        notice,
+        notice: effectiveNotice,
         confirmStop,
         repositoryMissing: isRepositoryMissing(selectedRun),
-        modalOpen: Boolean(scanPrompt || repositoryPicker),
+        modalOpen: Boolean(scanPrompt || repositoryPicker || connectionsOpen),
         cliUpdate,
         width: terminal.columns,
       }),
@@ -830,6 +857,7 @@ function Help({ width }) {
   const groups = [
     ["TASK", consoleHelpLines().slice(0, 8)],
     ["RUN", consoleHelpLines().slice(8, 15)],
+    ["CONNECTION", consoleHelpLines().filter(line => line.startsWith('/connections'))],
   ];
   return jsxs(Box, {
     width,
@@ -848,6 +876,32 @@ function Help({ width }) {
   });
 }
 
+function remoteConnectionRows(discovery, selected, width) {
+  const host = discovery.hosts[selected];
+  const start = Math.max(0, selected - 2);
+  return [
+    '保存されているパソコン（まだ接続できるかは未確認）',
+    'SIMYがつながらないときは、別のターミナルで simy connections recover を実行してください。',
+    ...discovery.hosts.slice(start, start + 5).map((item, index) =>
+      `${start + index === selected ? '›' : ' '} ${item.label} (${item.alias})${item.enabled ? '' : ' · 接続解除済み'}`),
+    ...discovery.warnings,
+    '',
+    ...(host ? connectionGuideLines(host.alias) : [
+      '保存されているパソコンがありません。接続設定をした人に接続先名を確認してください。',
+      '一覧: simy connections',
+      'このパソコンで simy connections を実行すると、使い方が表示されます。',
+    ]),
+  ].flatMap(line => wrapTerminalText(line, width - 4));
+}
+
+function RemoteConnectionsGuide({ rows, scroll, pageSize, width }) {
+  return jsxs(Box, { width, borderStyle: 'single', borderColor: 'cyan', paddingX: 1, flexDirection: 'column', children: [
+    jsx(Text, { bold: true, color: 'cyan', children: '別のパソコンのSIMYにつなぐ' }),
+    ...rows.slice(scroll, scroll + pageSize).map((line, index) => jsx(Text, { children: line }, `guide-${index}`)),
+    jsx(Text, { dimColor: true, children: '↑/↓でパソコンを選択 · PgUp/PgDnで前後を表示 · Escで戻る' }),
+  ] });
+}
+
 function ActionBar({
   run,
   detailOpen,

package/src/console/commands.js

@@ -16,6 +16,7 @@ const HELP_LINES = [
   "/resume               Resume a paused executor process",
   "/stop                 Stop the selected run",
   "/update               Open the available installer download",
+  "/connections          別のパソコンへの接続方法を見る",
 ];
 
 export function parseConsoleCommand(value) {
@@ -29,6 +30,8 @@ export function parseConsoleCommand(value) {
   switch (command) {
     case "/new":
       return { type: "new" };
+    case "/connections":
+      return { type: "connections" };
     case "/repos":
       return { type: "repositories" };
     case "/scan":

package/src/console/index.js

@@ -8,6 +8,7 @@ export async function runAgenticLoopConsole(agent, options = {}) {
     jsx(AgenticLoopConsole, {
       agent,
       onQuit: options.onQuit,
+      remoteConnections: options.remoteConnections,
     }),
     {
       stdin: options.stdin ?? process.stdin,

package/src/delivery-hooks/command.js

@@ -20,6 +20,7 @@ import { routeLegacyHooks } from './legacy-hook-routing.js';
 import { activateLocalDesktop, watchLocalRuntime, installRuntimeWatchdog } from './runtime-watchdog.js';
 import { desktopRuntimeStatus, installLocalDesktop } from './desktop-runtime.js';
 import { consistencyMonitorStatus, consistencyFindings } from './consistency-monitor.js';
+import { observabilityStatus } from '../cli-observability.js';
 
 async function readCheckpointInput(input) {
   const chunks = [];
@@ -45,6 +46,12 @@ function parseDeliveryOptions(args, allowed) {
 
 export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), webOrigin, input = process.stdin, output = console.log } = {}) {
   const [action, ...args] = argv;
+  if (action === 'observability') {
+    const [operation, ...flags] = args;
+    if (operation !== 'status' || flags.length) throw new Error('Use simy delivery observability status. Change the single device-consent checkbox in SIMY settings.');
+    const sessionRoot = dirname(root);
+    output(JSON.stringify(await observabilityStatus(sessionRoot), null, 2)); return 0;
+  }
   if (action === 'history-recovery') {
     const [operation,...flags] = args;
     const options = parseDeliveryOptions(flags,new Set(['audit','digest']));
@@ -211,6 +218,7 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
   }
   if (action === 'activity') return runActivityCommand(args, { root, output });
   if (!action || action === '--help') {
+    output('simy delivery observability status — show the state-only telemetry status for this device. The single default-OFF consent checkbox is in SIMY settings; disabling it stops uploads and discards pending telemetry. It never enables Auto-continue or starts a task.');
     output('simy delivery followup --provider codex --session ID --previous-run-id ID --objective TEXT — explicitly supervise the current goal after an exact finished run. A new goal archives the prior run; the same ordinary reported_done goal retains its identity and budgets for read-only reconciliation. Uses the existing supervisor; never reopens stopped, failed or budget-exhausted work.');
     output('simy delivery auto on|off|status --provider codex|claude — inspect or override CLI automatic start for this project directory (on by default). The next nonempty prompt in a conversation without a loop starts checkpoint tracking. Existing loops are preserved; provider hooks must already be enabled.');
     output('simy delivery redelegate-native --provider codex --session ID --task-id ID --consent-ref REF — explicitly delegate current native local edit/test permissions to an exact legacy task. Preserves enrollment, history, budgets and stops; does not resume or grant external actions.');

package/src/delivery-hooks/legacy-hook-routing.js

@@ -63,6 +63,29 @@ export function pinnedCliEntry(root) {
   return loader + "\nif (!await selectRuntime()) { process.stderr.write('SIMY selected runtime unavailable.\\n'); process.exitCode = 1; }\n";
 }
 
+// Older SSH clients resolve the remote entry beside the real CLI executable.
+// A shell launcher lives in bin rather than src, so expose a compatible entry
+// there while retaining the same verified pin and normal remote startup.
+export function pinnedRemoteEntry(root) {
+  const loader = pinnedCliEntry(root).replace('src/index.js', 'src/session-supervision/remote-entry.js');
+  // CommonJS-compatible .js works on Node 20 without a surrounding package.json.
+  const url = 'data:text/javascript,' + encodeURIComponent(loader);
+  return `// SIMY managed remote runtime route.\nvoid import(${JSON.stringify(url)}).catch(() => { process.stderr.write('SIMY remote runtime unavailable.\\n'); process.exitCode = 1; });\n`;
+}
+
+export async function installPinnedRemoteEntry(root) {
+  // Like the service entry, this only writes a loader. The loader validates
+  // the pin and full source fingerprint every time it is actually executed.
+  const directory = join(root, 'bin/session-supervision');
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const entry = join(directory, 'remote-entry.js'), temporary = `${entry}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, pinnedRemoteEntry(resolve(root)), { mode: 0o600 });
+    await rename(temporary, entry);
+  } finally { await rm(temporary, { force: true }); }
+  return entry;
+}
+
 export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOME || join(homedir(), '.codex') } = {}) {
   await pinnedWorkflowSource({ root });
   const folder = join(codexHome, 'plugins/cache/personal/simy');
@@ -93,6 +116,7 @@ export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOM
 // Also used during service installation after a handover performed by an older
 // watcher which did not know this launcher. Atomic replacement keeps startup safe.
 export async function installPinnedCliEntry(root) {
+  await installPinnedRemoteEntry(root);
   const entry = join(root, 'bin/simy-runtime.mjs');
   await mkdir(join(root, 'bin'), { recursive: true, mode: 0o700 });
   const temporary = `${entry}.${randomUUID()}.tmp`;

package/src/delivery-hooks/supervisor.js

@@ -1,5 +1,5 @@
 import { captureDispatchProvenance } from '../update-detachment/provenance.js';
-import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, confirmDispatch, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, confirmDispatch, flushDispatchIntake, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
 import { bindCompletionArtifacts } from '../session-supervision/completion-artifacts.js';
 import { recoveryWorkProposal, admitRecoveryWork } from '../session-supervision/recovery-frontier.js';
 import { safeCheckpointDiagnostic } from './checkpoint-diagnostic.js';
@@ -11,9 +11,7 @@ import { workspaceIdentity, reviewWorkspaceIdentity } from '../session-supervisi
 import { searchEnabled, failureLimitReached } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { reconcilePurposeTasks } from '../session-supervision/purpose-recovery.js';
 import { recordRecoveryIncident, recordRecoveryStage, settleRecoveryIncidents, resolveRecoveryReceipt } from '../codex-plugins/simy/hooks/recovery-incident.mjs';
-import { runConsistencyMonitor } from './consistency-monitor.js';
-import { desktopRuntimeStatus } from './desktop-runtime.js';
-import { auditConsistencyTask, recoverOutcomeAuditLease } from '../session-supervision/consistency-auditor.js';
+import { recoverOutcomeAuditLease } from '../session-supervision/consistency-auditor.js';
 import { minimalSufficientChangeInstruction } from '../codex-plugins/simy/hooks/minimal-sufficient.mjs';
 import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
@@ -28,7 +26,9 @@ import { createTaskPool } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 
 const MAX_OUTPUT = 64 * 1024;
 const SAFE_PROVIDER_CODES = new Set(['authentication_required', 'identity', 'permission_narrowed', 'permission_restore', 'turn_failed', 'checkpoint',
-  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval', 'provider_question', 'usage_unavailable']);
+  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval', 'provider_question', 'usage_unavailable',
+  'state_busy', 'dispatch_detached', 'owner_fenced', 'task_admission_blocked', 'task_admission_identity_required',
+  'task_identity_conflict', 'attempt_already_recorded', 'identity_unavailable']);
 function safeProviderCode(code) { return SAFE_PROVIDER_CODES.has(code) ? code : 'provider_error'; }
 function providerFailureReason(code) {
   if (code === 'permission_restore') return 'Codex sandbox restoration could not be confirmed; inspect the original conversation before resuming.';
@@ -36,6 +36,8 @@ function providerFailureReason(code) {
   if (code === 'identity') return 'Codex session identity, workspace, or model changed; inspect before resuming.';
   if (code === 'checkpoint' || code === 'checkpoint_rejected') return 'Codex returned an invalid managed checkpoint; inspect its plan before resuming.';
   if (code === 'turn_failed') return 'The Codex turn did not complete; inspect the original conversation.';
+  if (code === 'state_busy') return 'The local dispatch state is busy; reconcile its lock before another attempt.';
+  if (['dispatch_detached', 'owner_fenced', 'task_admission_blocked', 'task_admission_identity_required', 'task_identity_conflict', 'identity_unavailable'].includes(code)) return `Local dispatch admission requires reconciliation (${code}); preserve the existing task and provider authority.`;
   return 'Codex recovery process failed; inspect its checkpoint and original session before the next bounded recovery.';
 }
 // One fresh lease read at a time; stopping the watch also fences late reads so
@@ -642,19 +644,17 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
 }
 
 export function createManagedSupervisor(options) {
-  let running = null, auditing = null, closed = false;
+  let running = null, closed = false;
   const controller = new AbortController();
   const workers = createTaskPool({ concurrency: options.concurrency ?? 4 });
   const readCandidates = options.readRecords || (() => listRecords(options.root));
   return {
     tick() {
       if (closed) return Promise.resolve();
-      if (!auditing) auditing = (async () => {
-        const runtime = await desktopRuntimeStatus({ root: dirname(options.root) }).catch(() => ({ state: 'runtime_observation_failed' }));
-        await runConsistencyMonitor({ root: options.root, runtime, readRecords: options.readRecords || (() => listRecords(options.root)),
-          onAudit: async (record, findings, request) => closed || await options.shouldYield?.() ? undefined : auditConsistencyTask(record, findings, request, {
-            root: options.root, signal: controller.signal, authorize: options.authorizeDispatch || (async () => {}) }) });
-      })().catch(() => {}).finally(() => { auditing = null; });
+      try { flushDispatchIntake(rootFromDelivery(options.root)); }
+      catch (error) { if (error.code !== 'state_busy') return Promise.reject(error); }
+      // Continue actual task work and its result checks. Starting an unrelated
+      // periodic audit here could acquire a lease that prevents that work.
       if (!running) running = (async () => {
         for (const record of await readCandidates()) {
           if (closed || await options.shouldYield?.()) break;
@@ -680,8 +680,8 @@ export function createManagedSupervisor(options) {
     },
     status() { return workers.snapshot(); },
     async idle() { await running; await workers.idle(); },
-    async drain() { closed = true; await Promise.allSettled([running, auditing, workers.stop()]); },
-    async close() { closed = true; controller.abort(); await Promise.allSettled([running, auditing, workers.stop()]); },
+    async drain() { closed = true; await Promise.allSettled([running, workers.stop()]); },
+    async close() { closed = true; controller.abort(); await Promise.allSettled([running, workers.stop()]); },
   };
 }
 

package/src/desktop-host.js

@@ -457,7 +457,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (!sessionRefresh && (force || Date.now() - sessionRefreshedAt >= 15_000)) {
       const requestedScope = accessScope(currentAccess);
       const controller = discoveryController = new AbortController();
-      sessionRefresh = Promise.resolve().then(() => { if (controller.signal.aborted) return null; return (dependencies.discoverSessions || discoverSessions)({ root: deliveryRoot, signal: controller.signal, includeArchived: true, connectedProviders: PROVIDER_LINKS.filter(provider => providerLinks[provider].connected) }); })
+      const attempt = { id: randomUUID(), requestedAt: Date.now(), state: 'pending' };
+      sessionStatus = { ...sessionStatus, discoveryAttempt: attempt };
+      sessionRefresh = Promise.resolve().then(() => { if (controller.signal.aborted) return null; return (dependencies.discoverSessions || discoverSessions)({ root: deliveryRoot, signal: controller.signal, includeArchived: true, includeSelectionCandidates: true, connectedProviders: PROVIDER_LINKS.filter(provider => providerLinks[provider].connected) }); })
         .then(async value => {
           if (closed || relay || controller.signal.aborted) return;
           const latestAccess = await accessSnapshot();
@@ -474,8 +476,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
           }
           if (coordinator.acceptsNewWork()) await analysisManager.update(analysisSessions(sessions));
           if (controller.signal.aborted) return;
-          sessionStatus = { ...value, sessions, initialLoading: false }; sessionRefreshedAt = Date.now(); })
-        .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, initialLoading: false, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
+          sessionStatus = { ...value, sessions, initialLoading: false,
+            discoveryAttempt: { ...attempt, state: 'succeeded', completedAt: Date.now() } }; sessionRefreshedAt = Date.now(); })
+        .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, initialLoading: false,
+          discoveryAttempt: { ...attempt, state: 'failed', completedAt: Date.now() },
+          providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
         .finally(() => { if (discoveryController === controller) discoveryController = null; sessionRefresh = null; if (sessionRefreshAgain && !closed && !relay) { sessionRefreshAgain = false; refreshSessions(true); }
           if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
     }
@@ -758,7 +763,6 @@ export async function startDesktopHost({ input = process.stdin, output = process
         scope: requestedScope,
         deviceSession: localCliApiSession(),
       });
-      stopNotifier.observe(records);
       const projection = await actionAssociations.beginProjection?.({ records });
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks, projection);
@@ -771,7 +775,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
       for (const session of sessions) {
         const key = `${session.provider}:${session.session}`;
         session.statistics = activeStatisticsRead?.key === key && !activeStatisticsRead.controller.signal.aborted
-          ? { state: 'loading', hours: [], activity: [] }
+          ? statisticsCache.has(key)
+            ? { ...statisticsCache.get(key), refreshing: true }
+            : { state: 'loading', hours: [], activity: [] }
           : statisticsCache.get(key) || unavailableStatistics();
         session.sqmActivity = conversationSqmChecks(session, [...(status.sqmChecks?.items || []), ...(status.sqmTasks?.items || [])]);
         session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
@@ -815,7 +821,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
         status = { ...structuredClone(latestConnectionStatus), deliveryHooks: status.deliveryHooks, sessionSupervision: status.sessionSupervision };
       }
       status.teamThreads = teamThreads?.snapshot();
-      if (!closed && !relay) emitStatus(status);
+      if (!closed && !relay) {
+        // Native stop admission waits for this authorized projection, so an old
+        // running frame cannot suppress a newly stopped conversation.
+        stopNotifier.observe(records);
+        emitStatus(status);
+      }
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
   };
@@ -1202,11 +1213,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
         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 (['remote_host_save', 'remote_host_edit', 'remote_host_connect', 'remote_host_disconnect', 'remote_host_remove'].includes(action)) {
           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);
+          if (action === 'remote_host_save' || action === 'remote_host_connect' || action === 'remote_host_edit' && command.previousAlias !== command.alias) await authorizeProvider(PROVIDER_LINKS.find(provider => providerLinks[provider]?.connected) || 'codex', commandScope);
           else await authorizeWork(commandScope);
-          await remoteHosts.save({ alias: command.alias, label: command.label }, action === 'remote_host_remove');
+          if (action === 'remote_host_edit') await remoteHosts.edit({ previousAlias: command.previousAlias, alias: command.alias, label: command.label });
+          else if (action === 'remote_host_connect' || action === 'remote_host_disconnect') await remoteHosts.setEnabled(command.alias, action === 'remote_host_connect');
+          else 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_repair') {
@@ -1284,8 +1297,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
             await authorizeProvider(candidate.provider, commandScope, selectedLinkEpochs.get(candidate));
             signal.throwIfAborted();
             if (activeStatisticsRead !== request) throw Object.assign(new Error('Conversation activity request cancelled.'), { code: 'cancelled' });
+            const previous = statisticsCache.get(request.key);
+            if (statistics.state === 'unavailable' && ['ready', 'partial'].includes(previous?.state)) statistics = { ...previous, refreshFailed: true };
             statisticsCache.clear(); // Only the selected conversation needs chart data.
             statisticsCache.set(request.key, statistics);
+          }).catch(error => {
+            const previous = statisticsCache.get(request.key);
+            if (activeStatisticsRead === request && !signal.aborted && ['ready', 'partial'].includes(previous?.state)) {
+              statisticsCache.set(request.key, { ...previous, refreshFailed: true });
+            }
+            throw error;
           }).finally(() => {
             if (activeStatisticsRead === request) activeStatisticsRead = null;
             if (!closed) void publish().catch(() => {});
@@ -1311,6 +1332,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
         }
         if (action === 'desktop_access_refresh') {
           await agent.refreshDesktopAccess?.();
+        } else if (action === 'desktop_sqm_settings') {
+          const verified = await agent.refreshDesktopAccess?.();
+          await authorizeWork(commandScope);
+          if (!desktopAccessReady(verified) || verified.organizationId !== access.organizationId ||
+              !validDesktopAccessPath(verified.settingsPath, verified.organizationSlug)) throw new Error('Organization settings are unavailable; refresh access first.');
+          const url = new URL(`/org/${encodeURIComponent(verified.organizationSlug)}/quality-monitor`, webOrigin);
+          const result = await (dependencies.openLogin || openAuthorizationUrl)(url.toString(), { logger: silentLogger });
+          if (!result.opened) throw new Error('Could not open SQM settings.');
         } else if (action === 'desktop_access_settings' || action === 'desktop_access_members') {
           const verified = await agent.refreshDesktopAccess?.();
           const path = verified?.[action === 'desktop_access_settings' ? 'settingsPath' : 'membersPath'];
@@ -1340,7 +1369,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
         else if (action === "login" || action === "organization_select" || action === "authorization_open") {
           if (action === "organization_select" && (typeof command.organizationId !== "string" || !command.organizationId)) throw new Error("Select an organization first.");
           const url = action === "authorization_open" ? (agent.getPendingAuthorizationUrl?.() ?? agent.retryAuthorization?.())
-            : await agent.requestDesktopLogin(action === "organization_select" ? command.organizationId : null);
+            : await agent.requestDesktopLogin(action === "organization_select" ? command.organizationId : null,
+              { reauthorize: action === 'login' && command.reauthorize === true });
           if (action === 'authorization_open' && !url) throw new Error('No pending authorization.');
           if (url) {
             if (new URL(url).origin !== webOrigin) throw new Error("Invalid login origin.");
@@ -1593,6 +1623,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await (dependencies.trackSession || trackSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, tracked: action === "session_track", expectedProviderEpoch: selectedLinkEpochs.get(candidate) });
           await refreshSessions(true);
+        } else if (action === "session_add") {
+          if (command.provider !== 'codex' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(command.session || '')) throw new Error('Choose a Codex conversation or enter its exact conversation ID.');
+          await authorizeWork(commandScope);
+          await (dependencies.monitorSession || monitorSession)({ root: deliveryRoot, provider: command.provider,
+            session: command.session, monitor: true, expectedProviderEpoch: commandProviderLink?.epoch,
+            openClient: dependencies.openCodexAppServer || openCodexAppServer });
+          await authorizeProvider(command.provider, commandScope, commandProviderLink?.epoch);
+          await updateRecord(deliveryRoot, command.provider, command.session, previous => ({ ...previous, listHidden: false }));
+          await refreshSessions(true);
         } else if (action === "session_monitor" || action === "session_unmonitor") {
           await (dependencies.monitorSession || monitorSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, monitor: action === "session_monitor", expectedProviderEpoch: commandProviderLink?.epoch });

package/src/direct-executor.js

@@ -108,7 +108,7 @@ export async function startDirectTask(
       task.error = "Worker launch outcome could not be confirmed. Reconcile saved evidence before retrying.";
       return task;
     }
-    if (task.stop_requested) await owner.stop(task.worker_handle);
+    if (task.stop_requested) await stopDirectWorker(task);
     return await reconcileDirectWorker(task);
   }
 
@@ -229,6 +229,12 @@ export async function reconcileDirectWorker(task, { worker = task.worker || crea
   }
 }
 
+// Launch acknowledgement and a user stop may settle together. Both paths
+// share one owned stop RPC, including when it closes the owner's IPC socket.
+function stopDirectWorker(task) {
+  return task.workerStopPromise ||= task.worker.stop(task.worker_handle);
+}
+
 // Only the child captured by this task may be signalled, including its owned tools.
 export function stopDirectTask(task) {
   if (!task) return Promise.resolve(task);
@@ -241,7 +247,7 @@ async function stopOwnedDirectTask(task) {
   if (task.worker_handle) {
     // Launch uncertainty does not prevent stopping a separately confirmed owner.
     await task.worker_start?.catch(() => {});
-    await task.worker.stop(task.worker_handle);
+    await stopDirectWorker(task);
     return reconcileDirectWorker(task);
   }
   const child = task.child;

package/src/doctor.js

@@ -46,6 +46,7 @@ export async function collectDiagnostics({ webOrigin, cliVersion, root = default
     providers, failures, host_exit: await readHostExitDiagnostics(root),
     purpose_verification: await purposeVerificationCapability(purposeSigningKeyPath(root)).then(value => ({ state: value ? "available" : "not_initialized", key_id: value?.key_id || null, execution: "explicit_frozen_recipes_only" })).catch(() => ({ state: "unavailable", key_id: null, execution: "explicit_frozen_recipes_only" })),
     actions: [
+      { id: "connection_recovery", command: "simy connections recover simy", instruction: "つながらない原因を確認し、表示される対処方法を選んで、もう一度確認します。" },
       ...Object.entries(providers).filter(([, provider]) => provider.connection === "disconnected")
         .map(([provider]) => ({ id: `connect_${provider}`, action: "provider_connect", provider,
           instruction: `Open SIMY settings and connect ${provider}. Provider login and SIMY connection are separate; existing tasks remain stopped.` })),

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 = ["delivery", "sessions"].includes(deliveryArgv[0]) ? deliveryArgv : commandArgv;
+const dispatchArgv = ["delivery", "sessions", "connections"].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";
@@ -65,6 +65,11 @@ if (!configuredWebOrigin) {
 } 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] === "connections") {
+  try {
+    const { runRemoteConnectionsCommand } = await import("./remote-connection-guide.js");
+    process.exitCode = await runRemoteConnectionsCommand(dispatchArgv.slice(1), { webOrigin: configuredWebOrigin });
+  } catch (error) { console.error(error.message); process.exitCode = 2; }
 } else if (dispatchArgv[0] === "doctor") {
   const { runDoctor } = await import("./doctor.js");
   process.exitCode = await runDoctor({ webOrigin: configuredWebOrigin, cliVersion: packageInfo.version });
@@ -140,6 +145,7 @@ async function runCommand(installMode) {
     console.log(`Usage:
   simy            Start the local SIMY agent
   simy --version  Print the installed version without starting or updating
+  simy connections  別のパソコンへの接続や、つながらないときの手順を表示
   simy doctor     Read-only version, connection, provider and failure diagnostics
   simy --daemon   Start it in the background
   simy --no-tui   Start the foreground HTTP agent without the interactive console
@@ -177,6 +183,10 @@ async function runLocalAgent() {
   const port = readPort(argv);
   const webOrigin = configuredWebOrigin;
   const sessionRoot = process.env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+  const { discoverRemoteConnections, connectionStartupHint } = await import("./remote-connection-guide.js");
+  const remoteConnections = !daemon ? await discoverRemoteConnections({ root: sessionRoot }) : { hosts: [], warnings: [] };
+  const remoteHint = connectionStartupHint(remoteConnections);
+  if (remoteHint) console.log(remoteHint);
 
   try {
     const existing = await findReusableConnection({ webOrigin, sessionRoot, cliVersion: packageInfo.version,
@@ -277,7 +287,7 @@ async function runLocalAgent() {
   if (interactive) {
     const { runAgenticLoopConsole } = await import("./console/index.js");
     try {
-      await runAgenticLoopConsole(agent);
+      await runAgenticLoopConsole(agent, { remoteConnections });
     } finally {
       await shutdownAgent();
     }