@awak-app/simy-cli 0.7.28 → 0.7.31

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

@@ -1,6 +1,7 @@
 // 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 { relayToOwner } from './owner-transport.js';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -9,6 +10,7 @@ process.env.SIMY_REMOTE_CHILD = '1';
 process.env.SIMY_AUTO_UPDATE = '0';
 const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
 try {
+  if (await relayToOwner({ root })) process.exit(0);
   await adoptInstalledRuntime({ root });
   const selected = await pinnedWorkflowSource({ root });
   const host = await import(selected ? pathToFileURL(join(selected, 'src/desktop-host.js')).href : '../desktop-host.js');

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

@@ -1,6 +1,21 @@
 // Remote diagnostics are selected from product-owned text. Never display
 // arbitrary SSH stderr, provider exceptions, paths or remote frame messages.
 const messages = {
+  claude_desktop_platform_unsupported: 'Claude Desktop archive control requires a macOS conversation host.',
+  claude_desktop_not_installed: 'Install Claude Desktop on the conversation host and sign in to its Code tab.',
+  claude_desktop_accessibility_required: 'Enable macOS Accessibility for the app running SIMY on the conversation host. Use simy sessions provider-setup --provider claude --host ALIAS --session UUID to open that host’s setting.',
+  claude_desktop_ui_unavailable: 'Open the exact Claude Desktop Code conversation on the selected host and retry.',
+  claude_desktop_ui_changed: 'The Claude Desktop window changed or is covered. Retry when the selected conversation is visible.',
+  claude_desktop_running: 'Stop this conversation and turn off automatic continuation before organizing it.',
+  claude_desktop_unsaved_input: 'Claude Desktop contains unsent input. Preserve it on the conversation host before retrying.',
+  claude_desktop_identity_unverified: 'Claude Desktop conversation identity could not be verified. Refresh the exact conversation.',
+  claude_desktop_identity_changed: 'Claude Desktop account or conversation changed. Refresh before retrying.',
+  claude_desktop_state_unconfirmed: 'Claude Desktop has not confirmed the archive state. Refresh before retrying.',
+  claude_desktop_native_unconfirmed: 'The native Claude result is unknown. Refresh its archive state before retrying.',
+
+  remote_stop_pending: 'The stop request is awaiting confirmation. New work will remain paused until it is reconciled.',
+  remote_operation_unknown: 'The remote operation was received but its result is not yet known. Refresh its state before starting another operation.',
+  remote_operation_unsupported: 'Update SIMY on the selected host to use this operation.',
   process_conflict: 'Another SIMY service owns this remote host. Reconcile its existing service before connecting; do not stop unrelated work.',
   desktop_access_required: 'Sign in to the same SIMY account and organization on the remote host and verify its access.',
   provider_link_disconnected: 'Reconnect this AI provider to SIMY on the remote host.',

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

@@ -1,24 +1,46 @@
+import { operationDigest } from './operation-journal.js';
+import { createControllerStore, controllerScope } from './controller-store.js';
 import { remoteOperationFailure } from './remote-errors.js';
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { compareSessionWork } from './work-state.js';
+import { manualAcceptanceCommand, matchesManualAcceptanceControls, manualAcceptanceContinuation } from './manual-acceptance-command.js';
 
 const MAX_FRAME = 8 * 1024 * 1024;
 const MAX_HOSTS = 8;
 const aliasPattern = /^[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127}$/;
+// Resolve the saved alias on every connection. A user's multiplexed SSH master
+// can belong to the previous network and bypass this connection's keepalives.
+export function remoteSshArgs(alias, command) {
+  return ['-T', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes',
+    '-o', 'ConnectTimeout=5', '-o', 'ConnectionAttempts=1',
+    '-o', 'ServerAliveInterval=10', '-o', 'ServerAliveCountMax=2',
+    '-o', 'ControlMaster=no', '-o', 'ControlPath=none', '--', alias, command];
+}
 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_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
+export const allowedActions = new Set(['session_provider_setup', 'session_sync_context', 'refresh', 'task_detail', 'task_stop', 'controller_events', 'controller_pair', 'controller_provider_connect', 'session_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
+  'session_monitor', 'session_unmonitor', 'session_enroll', 'session_followup', 'session_set_auto_continue', 'session_get_status', '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', 'session_read_context', 'delivery_acceptance_decide']);
+// Protocol v1 had no advertised capabilities; retain its known released actions.
+const legacyActions = new Set(['refresh', 'session_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
   'session_monitor', 'session_unmonitor', 'session_enroll', 'session_followup', 'session_set_auto_continue', 'session_analyze', 'session_continue', 'session_answer',
   'session_deadline_decide', 'session_action_refresh', 'session_action_select', 'session_action_unlink',
   'delivery_pause', 'delivery_stop', 'delivery_reject', 'delivery_resume', 'delivery_replan', 'delivery_approve',
-  'delivery_dependency_ready', 'delivery_set_policy', 'delivery_continuation_policy', 'delivery_verify']);
+  'delivery_dependency_ready', 'delivery_set_policy', 'delivery_continuation_policy', 'delivery_verify', 'delivery_acceptance_decide']);
+const startsWork = command => ['session_followup', 'session_enroll', 'session_continue', 'delivery_resume', 'delivery_replan', 'session_track', 'session_monitor'].includes(command.action) ||
+  command.action === 'session_set_auto_continue' && command.enabled === true;
+const stopsWork = command => ['delivery_stop', 'delivery_pause', 'session_untrack', 'session_unmonitor'].includes(command.action) ||
+  command.action === 'session_set_auto_continue' && command.enabled === false;
+export const controllerPolicyActions = new Set(['session_sync_context','session_set_auto_continue','session_track','session_untrack','session_monitor','session_unmonitor','delivery_set_policy','delivery_continuation_policy','delivery_stop','delivery_pause']);
 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');
@@ -44,22 +66,28 @@ function stamp(value, host, depth = 0) {
   if (Array.isArray(value)) return value.map(item => stamp(item, host, depth + 1));
   if (!value || typeof value !== 'object') return value;
   const result = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, stamp(item, host, depth + 1)]));
+  // Includes nested conversationPresentation.target: the verified connection,
+  // never a remote frame's self-reported alias, owns this projection's host.
   if (['codex', 'claude'].includes(result.provider) && typeof result.session === 'string') result.hostId = host.id;
+  if (typeof result.notificationId === 'string' && result.notificationId) result.notificationId = `${host.id}:${result.notificationId}`;
   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,
+// The controller owns preferences and notifications. Remote hosts execute
+// provider/workspace operations and return scoped results.
+export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChange = () => {}, onNotify = () => {}, now = Date.now,
   retryMs = 15_000, requestTimeoutMs = 45_000, handshakeTimeoutMs = 15_000 } = {}) {
   const connections = new Map();
+  const metadata = new Map();
+  const preferences = store || createControllerStore(root);
+  let preferenceScope = null;
   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.')); }
+    for (const job of connection.pending.values()) { clearTimeout(job.timer); job.reject(error('Remote operation result is unknown. Check the original conversation before retrying.', 'remote_operation_unknown')); }
     connection.pending.clear();
     if (child) {
       child.stdin.end(); child.kill('SIGTERM');
@@ -67,14 +95,58 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       force.unref?.(); child.once('close', () => clearTimeout(force));
     }
   }
+  function receiveNotification(connection, frame) {
+    if (!connection.ready || typeof frame?.id !== 'string' || !['finished','failed','paused','needs_decision'].includes(frame.kind)) return;
+    if (!['codex','claude'].includes(frame.provider) || typeof frame.session !== 'string') return;
+    const expectedScope = preferenceScope;
+    if (frame.scope !== undefined && frame.scope !== expectedScope) return;
+    // Journal scope is account/organization identity. Native UI binds its own
+    // current origin/access scope after this authenticated transport check.
+    const { scope: sourceScope, ...event } = frame;
+    const id = `${connection.id}:${frame.id}`;
+    return preferences.change(expectedScope, state => {
+      if (state.events[id] || closed || preferenceScope !== expectedScope || !connection.ready) return;
+      onNotify({ ...stamp(event, connection), hostId: connection.id, id });
+      state.events[id] = now();
+    });
+  }
+  async function pullEvents(connection) {
+    if (connection.eventPull || closed || !connection.ready) return;
+    connection.eventPull = true;
+    const expectedScope = preferenceScope;
+    try {
+      const state = await preferences.load(expectedScope);
+      const after = state.eventCursors?.[connection.id] || 0;
+      const id = randomUUID();
+      const result = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { connection.pending.delete(id); reject(new Error('Event replay timed out.')); }, requestTimeoutMs);
+        connection.pending.set(id, { id, resolve, reject, timer });
+        connection.child.stdin.write(JSON.stringify({ id, action: 'controller_events', after }) + '\n');
+      });
+      if (!result.ok || !Array.isArray(result.data?.events)) return;
+      let cursor = after;
+      for (const event of result.data.events) {
+        if (closed || preferenceScope !== expectedScope || !connection.ready) return;
+        if (!Number.isSafeInteger(event.sequence) || event.sequence <= cursor) throw new Error('Invalid event sequence.');
+        if (typeof event.id !== 'string' || !event.id || !['finished','failed','paused','needs_decision'].includes(event.kind) ||
+            !['codex','claude'].includes(event.provider) || typeof event.session !== 'string' || !event.session) throw new Error('Invalid replay event.');
+        await receiveNotification(connection, event);
+        cursor = event.sequence;
+      }
+      if (closed || preferenceScope !== expectedScope) return;
+      await preferences.change(expectedScope, state => { state.eventCursors ||= {}; state.eventCursors[connection.id] = cursor; });
+    } finally { connection.eventPull = false; }
+  }
   function connect(connection) {
     if (closed || connection.enabled === false || 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 }); }
+    try { child = spawnImpl('ssh', remoteSshArgs(connection.alias, REMOTE_HOST_COMMAND), { stdio: ['pipe', 'pipe', 'pipe'], shell: false }); }
     catch { disconnect(connection, 'Could not start SSH.'); return; }
     connection.child = child;
+    // This transport identity belongs to the local manager's fenced SSH child,
+    // never the remote payload. Reconnects may be shorter than a UI heartbeat.
+    connection.transportId = randomUUID();
     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);
@@ -100,28 +172,58 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
         if (!frame || typeof frame !== 'object') continue;
         if (frame.type === 'status') {
           const status = frame.status;
+          connection.capabilities = Array.isArray(status?.remoteControl?.actions)
+            ? status.remoteControl.actions.filter(action => typeof action === 'string' && allowedActions.has(action))
+            : status?.remoteControl === undefined && status?.remoteSessionProtocol === 1 ? [...legacyActions] : [];
           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.ready = false; connection.state = 'access_required'; connection.reason = 'Use Remote connections in this CLI to sign in to this 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();
+            for (const [id, job] of connection.pending) if (!job.setup) { clearTimeout(job.timer); job.reject(error(connection.reason, 'remote_operation_unknown')); connection.pending.delete(id); }
           } 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();
+            if (status.controllerEventsVersion === 1) void pullEvents(connection).catch(() => {});
+            else for (const event of status.controllerEvents || []) void receiveNotification(connection, event)?.catch(() => {});
+            const expectedScope = preferenceScope;
+            void preferences.change(expectedScope, state => {
+              for (const row of status.sessionSupervision.sessions) {
+                const key = JSON.stringify([connection.id, row.provider, row.session]);
+                const saved = state.conversations[key] ||= {};
+                if (['ready','partial'].includes(row.statistics?.state)) saved.statistics = { ...row.statistics, observedAt: row.statistics.observedAt || now() };
+                if (!saved.importedRemoteDisplay) {
+                  saved.pinned ??= row.listPinned === true;
+                  saved.pinScopes ??= row.listPinScopes || (row.listPinned ? ['legacy'] : []);
+                  saved.hidden ??= row.listHidden === true;
+                  saved.importedRemoteDisplay = true;
+                }
+              }
+              state.hosts ||= {};
+              state.hosts[connection.id] = { sessionSupervision: status.sessionSupervision, deliveryHooks: status.deliveryHooks,
+                controllerCompletions: [...new Map([...(state.hosts[connection.id]?.controllerCompletions || []), ...(status.controllerCompletions || [])].map(item => [JSON.stringify([item.provider,item.provider_session_id,item.task_id]),item])).values()], tasks: status.tasks, sqmTasks: status.sqmTasks };
+            }).catch(() => {});
           }
           changed();
+        } else if (frame.type === 'notify' && connection.ready && local && typeof frame.id === 'string' && ['finished','failed','paused','needs_decision'].includes(frame.kind)) {
+          void receiveNotification(connection, frame)?.catch(() => {});
         } else if (frame.type === 'error') {
           disconnect(connection, remoteOperationFailure(frame.code).message); changed(); return;
+        } else if (frame.type === 'task_detail') {
+          const pending = connection.pending.get(frame.id);
+          pending?.onDetail?.({ ...frame, id: pending.id, taskKey: pending.taskKey });
         } 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 ? remoteOperationFailure(frame.code) : {}) });
+          const continuation = pending.action === 'delivery_acceptance_decide' ? manualAcceptanceContinuation(frame.continuation) : null;
+          const ok = frame.ok === true && (pending.action !== 'delivery_acceptance_decide' || continuation !== null);
+          pending.resolve({ type: 'result', id: pending.id, ok,
+            ...(ok && continuation ? { continuation } : {}),
+            ...(ok && pending.action !== 'delivery_acceptance_decide' && frame.data !== undefined ? { data: frame.data } : {}),
+            ...(ok ? {} : remoteOperationFailure(frame.code)) });
         }
       }
     });
@@ -132,10 +234,12 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     if (scope !== nextScope) {
       generation++;
       for (const c of connections.values()) disconnect(c);
-      connections.clear(); scope = nextScope;
+      connections.clear(); metadata.clear(); scope = nextScope;
     }
-    local = { auth: status?.auth, access: status?.access };
+    local = { auth: status?.auth, access: status?.access, providerLinks: status?.providerLinks };
+    preferenceScope = scope ? controllerScope(status) : null;
     if (!scope) return;
+    await preferences.load(preferenceScope);
     const observedGeneration = generation;
     let hosts;
     try { hosts = await readHosts(root); settingsError = null; }
@@ -144,7 +248,7 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     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); }
+      if (!c) { c = { ...host, pending: new Map(), retryAt: 0, ready: false, status: (await preferences.load(preferenceScope)).hosts?.[host.id] || null }; connections.set(host.id, c); }
       c.label = host.label; c.enabled = host.enabled !== false;
       if (!c.enabled) {
         if (c.child) disconnect(c);
@@ -154,6 +258,7 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       if (c.state === 'disconnected') c.retryAt = 0;
       if (c.ready && now() - c.receivedAt > 45_000) disconnect(c, 'Remote status is stale. Reconnecting.');
       connect(c);
+      if (c.ready) void flushPolicies(c).catch(() => {});
     }
   }
   async function persistHosts(change, apply) {
@@ -168,6 +273,39 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     });
     writes = work; await work;
   }
+  function remoteTask(key) {
+    let target; try { target = JSON.parse(key); } catch { return null; }
+    if (!Array.isArray(target) || target.length !== 3 || target[0] !== 'remote-task') return null;
+    return { connection: connections.get(target[1]), sourceKey: target[2] };
+  }
+  async function forwardTask(command, status, onDetail) {
+    if (closed || !usable(status) || scopeOf(status) !== scope) throw error('Controller account changed.', 'remote_host_access');
+    const target = remoteTask(command.taskKey), c = target?.connection;
+    if (!c?.ready || !c.child || now() - c.receivedAt > 45_000) throw error('Remote task connection is unavailable.');
+    const task = [...(c.status.tasks?.items || []), ...(c.status.sqmTasks?.items || [])].find(item => (item.key || item.id) === target.sourceKey);
+    if (!task || !['task_detail','task_stop'].includes(command.action) || command.action === 'task_stop' && (command.force !== true || task.canStop !== true)) throw error('Select an available task.', 'remote_host_invalid');
+    if (!c.capabilities?.includes(command.action)) throw error('Update the remote host.', 'remote_operation_unsupported');
+    const id = randomUUID();
+    return new Promise((resolve,reject) => {
+      const timer = setTimeout(() => { c.pending.delete(id); reject(error('Remote task result is unknown.', 'remote_operation_unknown')); }, requestTimeoutMs);
+      c.pending.set(id, { id: command.id, resolve, reject, timer, taskKey: command.taskKey, onDetail });
+      c.child.stdin.write(JSON.stringify({ id, action: command.action, taskKey: target.sourceKey, force: command.force }) + '\n');
+    });
+  }
+  async function configure(command, status) {
+    if (!usable(status) || scopeOf(status) !== scope) throw error('Controller sign-in changed.', 'remote_host_access');
+    const connection = connections.get(remoteHostId(command.alias));
+    if (!connection?.child || !['ready','access_required'].includes(connection.state)) throw error('Save this host and wait for its connection before configuring it.', 'remote_host_unavailable');
+    const action = command.action === 'remote_host_login' ? 'controller_pair' : 'controller_provider_connect';
+    if (!connection.capabilities?.includes(action)) throw error('Update SIMY on this host to configure it from this CLI.', 'remote_operation_unsupported');
+    if (action === 'controller_provider_connect' && (!connection.ready || !['codex','claude'].includes(command.provider))) throw error('Sign in to this host before connecting its provider.', 'remote_host_access');
+    const id = randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { connection.pending.delete(id); reject(error('Remote setup timed out.')); }, requestTimeoutMs);
+      connection.pending.set(id, { id: command.id, resolve, reject, timer, setup: true });
+      connection.child.stdin.write(JSON.stringify({ id, action, organizationId: status.access.organizationId, userId: status.auth.userId, ...(command.provider ? { provider: command.provider } : {}) }) + '\n');
+    });
+  }
   async function save(value, remove = false) {
     const host = normalizedHost(value);
     await persistHosts(hosts => [...hosts.filter(h => h.id !== host.id), ...(remove ? [] : [host])], () => {
@@ -208,32 +346,74 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     if (closed || !usable(status) || scopeOf(status) !== scope) throw error('SIMY account changed. Refresh before using the remote host.', 'remote_host_access');
     if (status.providerLinks?.[command.provider]?.connected === false) throw error('Provider is disconnected.', 'remote_host_access');
     const c = connections.get(command.hostId);
+    const stops = preferences.get(preferenceScope, command).policy || {};
+    if (startsWork(command) && ['delivery_stop','delivery_pause'].some(action => ['pending','unknown'].includes(stops[action]?.state))) throw error('The stop request must be reconciled before starting more work.', 'remote_stop_pending');
     if (!c?.ready || !c.child || now() - c.receivedAt > 45_000) throw error('The remote host is disconnected. Reconnect before using this conversation.');
     const manualAdd = command.action === 'session_add' && 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 || '');
     if ((!manualAdd && !allowedActions.has(command.action)) || !['codex', 'claude'].includes(command.provider) || typeof command.session !== 'string' ||
       (!manualAdd && !c.status?.sessionSupervision?.sessions?.some(s => s?.provider === command.provider && s.session === command.session))) throw error('Select an available remote conversation.', 'remote_host_invalid');
-    const restoreHidden = manualAdd && c.status?.sessionSupervision?.sessions?.some(row =>
-      row.provider === command.provider && row.session === command.session && row.localHidden === true);
+    const sourceAction = manualAdd ? 'session_monitor' : command.action;
+    if (!c.capabilities?.includes(sourceAction)) throw error('Update SIMY on this host to support this operation.', 'remote_operation_unsupported');
     const id = randomUUID();
-    const { hostId, ...payload } = command;
+    let { hostId, ...payload } = command;
+    if (command.action === 'delivery_acceptance_decide') {
+      let controls;
+      try { controls = manualAcceptanceCommand(command); }
+      catch { throw error('Refresh the remote acceptance controls before deciding.', 'remote_host_invalid'); }
+      // New controls require a current remote projection. Old runtimes and
+      // same-session local clones must never supply an identity fallback.
+      const run = c.status.deliveryHooks.runs.find(row => row?.provider === controls.provider && row.session === controls.session && row.taskId === controls.taskId);
+      const criterion = run?.manualAcceptance?.criteria?.find(row => row.id === controls.criterionId);
+      if (run?.manualAcceptance?.reasonCode !== null || criterion?.[controls.decision === 'accept' ? 'canAccept' : 'canNotYet'] !== true ||
+          !matchesManualAcceptanceControls(controls, criterion.controls)) throw error('Refresh the remote acceptance controls before deciding.', 'remote_host_invalid');
+      payload = { action: command.action, ...controls };
+    }
+    if (manualAdd) Object.assign(payload, { action: sourceAction, monitor: true });
+    const expectedScope = preferenceScope;
+    const digest = operationDigest(command);
+    // A new click is a new intent. Only explicit IDs and persisted queue items
+    // reuse an identity; equal command bodies are not evidence of a retry.
+    const requestId = command.requestId || randomUUID();
+    const updateOperation = state => preferences.change(expectedScope, data => {
+      const key = JSON.stringify([command.hostId, command.provider, command.session]);
+      const row = data.conversations[key] ||= {};
+      row.operations ||= {};
+      const previous = row.operations[requestId];
+      if (previous && previous.digest !== digest) throw error('Request identity conflicts with another operation.', 'remote_host_invalid');
+      row.operations[requestId] = { action: command.action, digest, requestId, state };
+    });
+    if (c.status.remoteControl?.version >= 2) {
+      await updateOperation('unknown');
+      payload.requestId = requestId;
+    } else {
+      // Old owners cannot reconcile request identities. Never imply that their
+      // unknown outcomes can safely be replayed automatically.
+      delete payload.requestId;
+    }
+    if (preferenceScope !== expectedScope || !c.ready || !c.child) throw error('Remote connection changed before dispatch.');
     const result = await 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, ...(manualAdd ? { action: 'session_monitor', monitor: true } : {}), id }) + '\n', e => {
-        if (e && c.pending.has(id)) { c.pending.delete(id); clearTimeout(timer); reject(error('Remote command could not be delivered.')); }
+      const timer = setTimeout(() => { c.pending.delete(id); reject(error('Remote operation timed out; its result is unknown. Check the original conversation before retrying.', 'remote_operation_unknown')); }, requestTimeoutMs);
+      c.pending.set(id, { id: command.id, action: command.action, resolve: result => {
+        if (c.status.remoteControl?.version >= 2 && result.code !== 'remote_operation_unknown') void updateOperation(result.ok ? 'applied' : 'failed').then(() => resolve(result), reject); else resolve(result);
+      }, 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 delivery is unknown. Check the original conversation before retrying.', 'remote_operation_unknown')); }
       });
     });
-    // Existing remote runtimes understand these two idempotent navigation
-    // operations. Monitoring alone does not clear a remote local archive.
-    // Re-enter the normal forwarding path to recheck scope and connectivity;
-    // never restore a provider archive or resume the conversation's task.
-    if (restoreHidden && result.ok === true) return forward({ ...command, action: 'session_restore', scope: 'local' }, status);
+    // Visibility belongs to this controller. A successful explicit Add clears
+    // its local hiding choice; source/provider archives and tasks stay intact.
+    if (manualAdd && result.ok === true) {
+      if (preferenceScope !== expectedScope || !c.ready || closed) throw error('Controller account or remote connection changed.', 'remote_host_access');
+      await preferences.set(expectedScope, command, { hidden: false });
+      if (preferenceScope !== expectedScope) throw error('Controller account changed.', 'remote_host_access');
+      changed();
+    }
     return result;
   }
   function project(status, { providerLinks = status.providerLinks } = {}) {
     if (!usable(status) || scopeOf(status) !== scope) return status;
     const hosts = [...connections.values()];
-    const sessions = [], runs = [], selectionCandidates = [];
+    const sessions = [], runs = [], tasks = [], sqmTasks = [], selectionCandidates = [];
     for (const c of hosts) {
       const ready = c.ready && now() - c.receivedAt <= 45_000;
       const unavailableReason = c.reason || 'Remote status is stale.';
@@ -244,8 +424,23 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       for (const row of c.status?.sessionSupervision?.sessions || []) {
         if (!row || !['codex', 'claude'].includes(row.provider) || typeof row.session !== 'string' ||
           providerLinks?.[row.provider]?.connected === false) continue;
-        const item = stamp(row, c);
-        item.remoteHost = { id: c.id, label: c.label, state: ready ? 'ready' : c.state === 'ready' ? 'unavailable' : c.state, reason: ready ? null : c.reason || 'Remote status is stale.' };
+        const item = { ...stamp(row, c), ...metadata.get(JSON.stringify([c.id, row.provider, row.session])),
+          sourceActionTaskId: row.actionAssociation?.binding?.taskId || row.taskId || row.binding?.taskId, sourceActionDeadline: row.actionDeadline };
+        const saved = preferences.get(preferenceScope, item);
+        if (saved.pinned !== undefined) item.listPinned = saved.pinned;
+        if (saved.pinScopes !== undefined) item.listPinScopes = saved.pinScopes;
+        if (saved.hidden !== undefined) { item.localHidden = item.listHidden = saved.hidden; item.archived = row.providerArchived === true || saved.hidden; }
+        if (Array.isArray(c.capabilities)) {
+          const supports = action => c.capabilities.includes(action);
+          const commands = { canMonitor: 'session_monitor', canPurposeContinue: 'session_continue', canAnalyze: 'session_analyze', canEnroll: 'session_enroll', canContinue: 'session_continue', canAutoContinue: 'session_set_auto_continue' };
+          item.capabilities = Object.fromEntries(Object.entries(item.capabilities || {}).map(([key,value]) => [key, value === true && (!commands[key] || supports(commands[key]))]));
+          if (item.followup && !supports('session_followup')) item.followup = null;
+          if (item.decisionRequest) item.decisionRequest = { ...item.decisionRequest, choices: (item.decisionRequest.choices || []).filter(choice => choice.action === 'open_original' || supports(choice.action)) };
+        }
+        item.controllerPreferences = saved;
+        item.controllerPolicy = saved.policy || null;
+        item.controllerCanSetAutoContinue = true;
+        item.remoteHost = { id: c.id, label: c.label, state: ready ? 'ready' : c.state === 'ready' ? 'unavailable' : c.state, transportId: ready ? c.transportId : null, 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 provider', verifiedOnPlatform: false,
@@ -257,17 +452,130 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
           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: [] };
+          item.statistics = saved.statistics ? { ...saved.statistics, stale: true, cached: true } : { state: 'unavailable', hours: [], activity: [] };
         }
+        if (ready && !['ready','partial'].includes(item.statistics?.state) && saved.statistics) item.statistics = { ...saved.statistics, stale: true, cached: true };
+        item.executionContextSync = saved.policy?.session_sync_context?.state || null;
+        const auto = saved.policy?.session_set_auto_continue;
+        if (auto) { item.autoContinueDesired = auto.command.enabled; item.autoContinueSync = auto.state; }
         sessions.push(item);
       }
-      if (ready) for (const run of c.status?.deliveryHooks?.runs || []) if (['codex', 'claude'].includes(run?.provider) && providerLinks?.[run.provider]?.connected !== false) runs.push({ ...stamp(run, c), originalSessionTarget: { kind: 'manual', url: null, verifiedOnPlatform: false, reason: `Select ${c.label} in ${run.provider === 'claude' ? 'Claude Code' : 'Codex'}, then find conversation ${run.session}.` } });
+      if (ready) {
+        for (const task of c.status?.tasks?.items || []) tasks.push({ ...stamp(task, c), key: JSON.stringify(['remote-task',c.id,task.key || task.id]), hostId: c.id });
+        for (const task of c.status?.sqmTasks?.items || []) sqmTasks.push({ ...stamp(task, c), key: JSON.stringify(['remote-task',c.id,task.key || task.id]), hostId: c.id });
+      }
+      if (ready) for (const run of c.status?.deliveryHooks?.runs || []) if (['codex', 'claude'].includes(run?.provider) && providerLinks?.[run.provider]?.connected !== false) {
+        const projected = { ...stamp(run, c), originalSessionTarget: { kind: 'manual', url: null, verifiedOnPlatform: false, reason: `Select ${c.label} in ${run.provider === 'claude' ? 'Claude Code' : 'Codex'}, then find conversation ${run.session}.` } };
+        if (Array.isArray(c.capabilities)) for (const [flag, action] of Object.entries({ canStop:'delivery_stop', canPause:'delivery_pause', canResume:'delivery_resume', canApprove:'delivery_approve', canReject:'delivery_reject', canReplan:'delivery_replan', canAnswer:'session_answer', canResolveDependency:'delivery_dependency_ready', canSetPolicy:'delivery_set_policy' })) {
+          if (!c.capabilities.includes(action)) projected[flag] = false;
+        }
+        runs.push(projected);
+      }
+    }
+    function aggregate(key, rows) {
+      const localItems = (status[key]?.items || []).filter(row => !row.hostId || row.hostId === 'local');
+      const priorRemote = status[key]?.remoteActiveCount || 0;
+      const remoteActiveCount = hosts.filter(c => c.ready).reduce((n,c) => n + (c.status?.[key]?.activeCount || 0), 0);
+      return { ...status[key], items: [...localItems, ...rows], localActiveCount: Math.max(0, (status[key]?.activeCount || 0) - priorRemote), activeCount: Math.max(0, (status[key]?.activeCount || 0) - priorRemote) + remoteActiveCount, remoteActiveCount, unknownHosts: hosts.filter(c => !c.ready).map(c => c.id) };
     }
-    return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, enabled: c.enabled !== false, state: c.ready && now() - c.receivedAt > 45_000 ? 'unavailable' : c.state, reason: c.reason })) },
+    return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, enabled: c.enabled !== false, state: c.ready && now() - c.receivedAt > 45_000 ? 'unavailable' : c.state, transportId: c.ready ? c.transportId : null, reason: c.reason })) },
+      tasks: aggregate('tasks', tasks), sqmTasks: aggregate('sqmTasks', sqmTasks),
       sessionSupervision: { ...status.sessionSupervision, selectionCandidates: [...(status.sessionSupervision?.selectionCandidates || []).filter(row => !row.hostId || row.hostId === 'local'), ...selectionCandidates], 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, edit, setEnabled, forward, project,
+  async function flushPolicies(connection) {
+    if (!connection || connection.flushing || closed || !connection.ready) return;
+    connection.flushing = true;
+    const expectedScope = preferenceScope;
+    try {
+      const state = await preferences.load(expectedScope);
+      const pending = Object.entries(state.conversations).flatMap(([key, row]) => {
+        if (JSON.parse(key)[0] !== connection.id) return [];
+        return Object.values(row.policy || {}).filter(item => ['pending', 'unknown'].includes(item.state)).map(item => ({ key, item }));
+      });
+      // Stops for every conversation take precedence over starts on this host.
+      pending.sort((a, b) => Number(stopsWork(b.item.command)) - Number(stopsWork(a.item.command)));
+      for (const { key, item } of pending) {
+        if (preferenceScope !== expectedScope || !connection.ready || closed) return;
+        const latest = preferences.get(expectedScope, item.command).policy?.[item.command.action];
+        if (latest?.command.id !== item.command.id) continue;
+        if (item.state === 'unknown' && !(connection.status?.remoteControl?.version >= 2)) continue;
+        const link = local.providerLinks?.[item.command.provider];
+        let result;
+        try {
+          if (startsWork(item.command) && (link?.connected === false || (item.providerEpoch ?? null) !== (link?.epoch ?? null)))
+            throw error('Provider consent changed before this queued operation.', 'remote_host_access');
+          result = await forward(item.command, local);
+        } catch (failure) {
+          // A missing conversation or unsupported action must not starve other
+          // conversations. A disconnected transport retains its queued intent.
+          const nextState = failure.code === 'remote_operation_unknown' ? 'unknown'
+            : failure.code === 'remote_host_unavailable' ? item.state : 'failed';
+          result = { ok: false, code: failure.code, nextState };
+        }
+        await preferences.change(expectedScope, data => {
+          const current = data.conversations[key]?.policy?.[item.command.action];
+          if (current?.command.id === item.command.id) {
+            current.state = result.nextState || (result.ok ? 'applied' : result.code === 'remote_operation_unknown' ? 'unknown' : 'failed');
+            current.code = result.code;
+          }
+        });
+        changed();
+        if (!connection.ready || result.code === 'remote_host_unavailable') return;
+      }
+    } finally { connection.flushing = false; }
+  }
+  async function control(command) {
+    if (!controllerPolicyActions.has(command.action) || !candidate(command) || !preferenceScope) throw error('Select a known remote conversation.', 'remote_host_invalid');
+    if (command.action === 'session_set_auto_continue' && typeof command.enabled !== 'boolean') throw error('Invalid continuation setting.', 'remote_host_invalid');
+    const expectedScope = preferenceScope;
+    await preferences.change(expectedScope, state => {
+      const key = JSON.stringify([command.hostId, command.provider, command.session]);
+      const row = state.conversations[key] ||= {}; row.policy ||= {};
+      // Opposite preferences supersede unsent earlier choices.
+      const opposite = { session_track: 'session_untrack', session_untrack: 'session_track', session_monitor: 'session_unmonitor', session_unmonitor: 'session_monitor' }[command.action];
+      if (opposite) delete row.policy[opposite];
+      if (['delivery_stop','delivery_pause'].includes(command.action) && row.policy.session_set_auto_continue?.command.enabled) delete row.policy.session_set_auto_continue;
+      row.policy[command.action] = { command: { ...command, id: randomUUID(), requestId: command.requestId || randomUUID() },
+        providerEpoch: local.providerLinks?.[command.provider]?.epoch ?? null, state: 'pending' };
+    });
+    if (preferenceScope !== expectedScope) throw error('Controller account changed.', 'remote_host_access');
+    changed(); void flushPolicies(connections.get(command.hostId)).catch(() => {});
+    return { type: 'result', id: command.id, ok: true, applied: false };
+  }
+  function candidate(command) {
+    const c = connections.get(command.hostId);
+    const row = c?.status?.sessionSupervision?.sessions?.find(row => row.provider === command.provider && row.session === command.session);
+    return row ? { ...stamp(row, c), hostId: c.id } : null;
+  }
+  async function setPreference(command) {
+    const target = candidate(command);
+    if (!target || !preferenceScope) throw error('Select a known conversation.', 'remote_host_invalid');
+    const expectedScope = preferenceScope;
+    if (command.action === 'session_set_pinned') {
+      if (typeof command.enabled !== 'boolean') throw error('Invalid preference.', 'remote_host_invalid');
+      const pinScope = command.pinScope ?? 'legacy';
+      if (typeof pinScope !== 'string' || !pinScope || pinScope.length > 512) throw error('Invalid pin scope.', 'remote_host_invalid');
+      const current = preferences.get(expectedScope, target);
+      const scopes = new Set(current.pinScopes ?? target.listPinScopes ?? (target.listPinned ? ['legacy'] : []));
+      if (command.enabled) scopes.add(pinScope); else scopes.delete(pinScope);
+      await preferences.set(expectedScope, target, { pinned: scopes.size > 0, pinScopes: [...scopes], metadata: { title: target.title, createdAt: target.createdAt, lastActivityAt: target.lastActivityAt } });
+    } else if (['session_archive','session_restore'].includes(command.action) && command.scope === 'local') {
+      await preferences.set(expectedScope, target, { hidden: command.action === 'session_archive' });
+    } else throw error('Unsupported preference.', 'remote_host_invalid');
+    if (preferenceScope !== expectedScope) throw error('Controller account changed.', 'remote_host_access');
+    changed(); return { type: 'result', id: command.id, ok: true };
+  }
+  function supportsReplay(command) {
+    const c = connections.get(command?.hostId);
+    return Boolean(command?.hostId && command.hostId !== 'local' && c?.ready && c.child && now() - c.receivedAt <= 45_000 &&
+      c.status?.remoteControl?.version >= 2 && c.capabilities?.includes(command.action) && usable(local) && scopeOf(local) === scope);
+  }
+  return { update, save, edit, setEnabled, configure, forward, forwardTask, supportsReplay, isRemoteTask: key => Boolean(remoteTask(key)), project, candidate, setPreference, control,
+    setMetadata(rows) { for (const row of rows) metadata.set(JSON.stringify([row.hostId,row.provider,row.session]), { actionAssociation: row.actionAssociation, actionDeadline: row.actionDeadline, actionTaskId: row.actionTaskId }); },
+    completions: () => [...connections.values()].flatMap(c => ((preferences.peek(preferenceScope)?.hosts?.[c.id] || c.status)?.controllerCompletions || []).filter(item =>
+      ['codex','claude'].includes(item?.provider) && typeof item.provider_session_id === 'string' && typeof item.task_id === 'string'
+    ).map(item => ({ ...item, host_id: c.id }))),
     hasSession: session => [...connections.values()].some(c => c.status?.sessionSupervision?.sessions?.some(s => ['codex', 'claude'].includes(s?.provider) && s.session === session)),
-    async close() { closed = true; for (const c of connections.values()) disconnect(c); connections.clear(); await writes.catch(() => {}); } };
+    async close() { closed = true; for (const c of connections.values()) disconnect(c); connections.clear(); await writes.catch(() => {}); await preferences.close(); } };
 }