@awak-app/simy-cli 0.7.34 → 0.7.36

package/README.md

@@ -276,16 +276,18 @@ Closing the window keeps the agent running. Open the app again or choose
 interrupting active tasks. The normal `simy` command remains available.
 
 The macOS **Automatic updates** switch saves this Mac's choice across restarts.
-Compatible signed installations enable it by default. Patch/minor updates wait
-for idle and verify the new runtime before handoff; failed startup restores the
-previous installed version. The app then switches to the verified new interface
-when no unfinished work or confirmation is pending. Turning the switch off keeps
+Compatible signed installations enable it by default. Patch/minor updates prepare
+and verify the new runtime before a safe handoff; failed startup restores the
+previous installed version. Choose **Update and restart** to open the verified
+new interface, or **Later** to keep using the current window. The window never
+restarts automatically. Turning the switch off keeps
 manual checks and **Download DMG** available. An explicit `SIMY_AUTO_UPDATE=0`
 remains authoritative, and major updates continue to use the DMG.
 **Stop task…** in a task
 detail asks for confirmation and terminates its local Provider process, keeping
-existing output and history. An explicit update can likewise stop active work
-after confirmation; automatic updates still wait for idle. **⌘Q** exits SIMY and
+existing output and history. Window updates preserve the same execution owner,
+pending approvals and inputs, and scoped drafts. Older services without this
+capability keep running and wait for a safe update. **⌘Q** exits SIMY and
 its background services directly, including when work is running. The window shows
 the app version, and normal app launches select the newer installed interface.
 
@@ -664,10 +666,12 @@ original argv once. A process-wide nonce/version guard prevents update loops.
 Major releases are never installed at startup: `simy update` asks for explicit
 confirmation (`simy update --yes` is available for non-interactive automation).
 
-The macOS desktop app runs from `/Applications/SIMY.app`. Its signed updater
-keeps downloaded releases in the user cache, then replaces the desktop bundle
-after the app and its executor have stopped. The previous bundle is retained
-for recovery. If permissions or verification prevent replacement, SIMY shows
+The macOS desktop app starts from `/Applications/SIMY.app`. Its signed updater
+keeps downloaded releases in the user cache. An explicit window restart opens
+the validated immutable release while retaining its execution owner. Whole-bundle
+replacement waits for processes using the bundle to exit; a busy bundle is left
+in place and the selected release opens directly. The previous bundle is retained
+for recovery. If permissions or verification prevent installation, SIMY shows
 an installer recovery action instead of reporting the desktop app as current.
 Concurrent handoffs share one exclusive installation lock. Packages before
 0.5.29 may require one system-authorized installer update because their bundle

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.34",
+  "version": "0.7.36",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

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

package/src/cli-observability.js

@@ -7,7 +7,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { webApiHeaders, webApiUrl } from './web-api.js';
 // Keep this leaf module package-safe: hooks load it before the full CLI contract.
-const CLI_VERSION = '0.7.34';
+const CLI_VERSION = '0.7.36';
 
 const STORE = 'cli-observability-state.json';
 const LEGACY_CONFIG = 'cli-observability.json';

package/src/desktop-host.js

@@ -35,6 +35,7 @@ import { repairProviderPlugin } from './sqm/provider-plugin-repair.js';
 import { openCodexAppServer, verifyCodexArchiveState } from './session-supervision/codex-app-server.js';
 import { conversationSqmChecks, conversationSqmResult } from './session-supervision/sqm-presentation.js';
 import { stopOwnedDesktopHost } from "./desktop-force-quit.js";
+import { relayToOwner } from './session-supervision/owner-transport.js';
 import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
@@ -82,9 +83,9 @@ import {
 } from "./desktop-process-lock.js";
 
 const silentLogger = { log() {}, error() {} };
-// Match the native DesktopStatusFrames limit: 200 conversation summaries can
-// exceed 128 KiB, including after a signed runtime handoff.
-const MAX_DESKTOP_FRAME_BYTES = 8 * 1024 * 1024;
+// Match the native DesktopStatusFrames limit for full retained histories,
+// including after a signed runtime handoff. Native delivery remains bounded.
+const MAX_DESKTOP_FRAME_BYTES = 64 * 1024 * 1024;
 
 async function withReadCancellation(signal, work) {
   signal.throwIfAborted();
@@ -159,7 +160,23 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const frames = createDesktopFrameWriter(output);
   const pendingRemoteReceipts = new Map();
   let operationJournal, ownerTransport;
-  const writeEvent = event => { ownerTransport?.publish(event); frames.write(`${JSON.stringify(event)}\n`, event.type === 'status'); };
+  // An explicitly requested window update releases only its viewer. The same
+  // authenticated owner, tasks and pending permissions remain alive on IPC.
+  let windowUpdatePrepared = false, viewerDetached = false, relayStatus = null;
+  const detachViewer = () => { viewerDetached = true; frames.close(); };
+  output.on('error', error => {
+    if (windowUpdatePrepared && ['EPIPE', 'ERR_STREAM_DESTROYED'].includes(error.code)) detachViewer();
+    else if (!closed) void close().then(() => exit(1));
+  });
+  const writeEvent = event => {
+    if (event.type === 'status' && event.status) {
+      relayStatus = { value: event.status, at: Date.now() };
+      if (ownerTransport) event = { ...event, status: { ...event.status, windowUpdate: { version: 1, preservesWork: Boolean(ownerTransport), prepared: windowUpdatePrepared } } };
+    }
+    ownerTransport?.publish(event);
+    if (event.type === 'status') ownerTransport?.publishDesktop?.(event);
+    if (!viewerDetached) frames.write(`${JSON.stringify(event)}\n`, event.type === 'status');
+  };
   const emit = (event) => {
     const pending = event.type === 'result' ? pendingRemoteReceipts.get(event.id) : null;
     if (pending) {
@@ -181,6 +198,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let remoteHosts;
   const emitStatus = status => {
     status = projectCatalogFrame(status);
+    status = { ...status, windowUpdate: { version: 1, preservesWork: Boolean(ownerTransport), prepared: windowUpdatePrepared } };
     const updateSettings = updater?.snapshot?.() || {};
     status = { ...status, update: { ...status.update,
       auto_update_supported: updateSettings.auto_update_supported === true,
@@ -205,13 +223,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
       void controllerPreferences.change(catalogScope, state => { state.catalog = catalog; }).catch(() => {});
     }
     if (updateProgress) status = { ...status, update: { ...status.update, ...updateProgress } };
+    ownerTransport?.publishDesktop?.({ type: 'status', status });
     const { sampledAt, ...content } = status;
     if (!lastStatus || !isDeepStrictEqual(content, lastStatus)) {
       encodedStatus = JSON.stringify(content).slice(1, -1);
       lastStatus = structuredClone(content);
     }
     const observation = sampledAt === undefined ? '' : `"sampledAt":${JSON.stringify(sampledAt)}${encodedStatus ? ',' : ''}`;
-    frames.write(`{"type":"status","status":{${observation}${encodedStatus}}}\n`, true);
+    if (!viewerDetached) frames.write(`{"type":"status","status":{${observation}${encodedStatus}}}\n`, true);
     resolveFirstStatus?.(); resolveFirstStatus = null;
   };
   const root = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
@@ -953,6 +972,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
         scope: accessScope(status.access), controllerScope: controllerScope(status), deviceSession: reportDeviceSession(),
       }) && nativeDevelopmentReportsScope === accessScope(currentAccess)
         ? { ...structuredClone(cached?.nativeDevelopmentReports || {}), ...structuredClone(nativeDevelopmentReports) } : { state: 'loading', enrollments: [] };
+      // Local consent is durable independently of the optional server read or
+      // conversation enrichment. Include it even when that full projection is
+      // blocked; otherwise the native confirmation timer reports a false error.
+      const preferenceState = preferenceScope && desktopAccessReady(status.access)
+        ? controllerPreferences.peek(preferenceScope) : null;
+      const emailPreferences = Object.values(preferenceState?.conversations || {})
+        .flatMap(row => row.emailPreference ? [{ ...row.emailPreference.request, sync: row.emailPreference.state }] : []);
+      if (emailPreferences.length || status.nativeDevelopmentReports.preferences)
+        status.nativeDevelopmentReports.preferences = emailPreferences;
       // Cached enrichment must follow the current connection preference even
       // while a full projection is waiting on records or remote metadata.
       status.deliveryHooks.runs = linkedSessions(status.deliveryHooks.runs || []);
@@ -1439,6 +1467,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
     let command; try { command = JSON.parse(line); } catch { return; }
     if (typeof command.id !== "string" || command.id.length > 128) return;
     if (relay) {
+      if (['prepare_window_update', 'cancel_window_update'].includes(command.action)) {
+        const authorized = Boolean(ownerTransport) && relayStatus && Date.now() - relayStatus.at < 10_000 && desktopAccessReady(relayStatus.value.access);
+        if (authorized) windowUpdatePrepared = command.action === 'prepare_window_update';
+        emit({ type: 'result', id: command.id, ok: Boolean(authorized) }); return;
+      }
       if (command.action === 'session_renew_claude_owner') {
         emit({ type: 'result', id: command.id, ok: false, message: 'Use the verified local conversation host for connection recovery.' }); return;
       }
@@ -1479,6 +1512,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
           emit({type:'result',id:command.id,ok:coordinator.snapshot().state==='connected' && (action!=='detach_update' || updater.snapshot().state==='updated')});
           await publish();return;
         }
+        if (action === 'prepare_window_update' || action === 'cancel_window_update') {
+          requireDesktopAccess(await accessSnapshot());
+          if (action === 'prepare_window_update' && (!ownerTransport || closed || stoppingForUpdate))
+            throw new Error('Keep using SIMY; the update will be available when this work finishes.');
+          windowUpdatePrepared = action === 'prepare_window_update';
+          emit({ type: 'result', id: command.id, ok: true });
+          await publish(); return;
+        }
         if (action === "quit") {
           if (command.forUpdate === true) {
             if (command.force !== true) throw new Error('Confirm before stopping unfinished tasks.');
@@ -2289,7 +2330,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         }
       }
     };
-    if (command.action === "quit" || command.action === "prepare_update_restart" || command.action === "update" && (command.force === true || stoppingForUpdate)) {
+    if (["prepare_window_update", "cancel_window_update"].includes(command.action) || command.action === "quit" || command.action === "prepare_update_restart" || command.action === "update" && (command.force === true || stoppingForUpdate)) {
       void execute();
     } else if (["login", "organization_select", "organization_cancel", "authorization_open", "authorization_copy"].includes(command.action)) {
       authorizationQueue = authorizationQueue.then(execute).catch(() => {});
@@ -2316,9 +2357,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
       }).catch(() => {});
     }
   });
-  commands.on("close", () => { if (!closed) void close().then(() => exit(0)); });
-  if (lock && !dependencies.startAgent) {
-    ownerTransport = await createOwnerTransport({ root, nonce: lock.nonce, allowedActions, allowControllerArchive: env.SIMY_REMOTE_CHILD !== '1', dispatch: command => commands.emit('line', JSON.stringify(command)) });
+  commands.on("close", () => { if (windowUpdatePrepared && ownerTransport && !closed) { detachViewer(); return; } if (!closed) void close().then(() => exit(0)); });
+  if (lock && (!dependencies.startAgent || dependencies.createOwnerTransport)) {
+    ownerTransport = await (dependencies.createOwnerTransport || createOwnerTransport)({ root, nonce: lock.nonce, allowedActions, allowControllerArchive: env.SIMY_REMOTE_CHILD !== '1', allowDesktopClient: env.SIMY_REMOTE_CHILD !== '1', dispatch: command => commands.emit('line', JSON.stringify(command)) });
     await publish();
   }
   // Register controls before awaiting initial presentation. A fast, authorized
@@ -2407,6 +2448,10 @@ export function isDesktopHostEntry(entry = process.argv[1]) {
 
 function desktopStartupError(error, fallbackMessage = "SIMY could not start. Check whether another SIMY window is already running, then reconnect.") {
   const conflict = error?.code === PROCESS_CONFLICT_CODE;
+  if (error?.code === 'desktop_owner_update_required') return {
+    type: 'error', code: 'desktop_owner_update_required',
+    message: 'The existing SIMY service cannot hand off its window yet. Keep using the original window. After its work finishes, quit SIMY there and reopen it to update; the running work was left untouched.',
+  };
   return {
     type: "error",
     ...(conflict ? { code: PROCESS_CONFLICT_CODE, conflicts: error.conflicts || [] } : {}),
@@ -2425,6 +2470,7 @@ export function startDesktopEntry(options = {}) {
   const diagnostics = createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"), { name: "desktop-host" });
   // stdout is the native JSONL channel; stderr is the only unstructured output
   // and the native window does not display it, so keep it for support.
+  process.stderr.on('error', error => { if (error.code !== 'EPIPE') diagnostics.write('stderr closed: ' + error.code); });
   captureRuntimeOutput(diagnostics, { stderr: process.stderr });
   applyLoginShellPath({ diagnostics }).catch(() => {}).then(() => startDesktopHost(options)).then((value) => { host = value; }).catch((error) => {
     diagnostics.write(`startup failed: ${error?.stack || error}`);
@@ -2436,6 +2482,7 @@ export function startDesktopEntry(options = {}) {
 if (isDesktopHostEntry()) {
   try {
     const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
+    if (process.env.SIMY_DESKTOP_ATTACH_OWNER === '1' && await relayToOwner({ root, webOrigin: resolveWebOrigin(null, process.env), desktopClient: true })) process.exit(0);
     try { await adoptInstalledRuntime({ root }); }
     catch (error) {
       if (error.code === PROCESS_CONFLICT_CODE) throw error;

package/src/session-supervision/owner-transport.js

@@ -12,23 +12,26 @@ export const ownerSocketPath = (root, platform = process.platform) => platform =
 const socketPath = ownerSocketPath;
 // The socket and nonce are accessible only to the local OS account. Application
 // account/provider checks still run in the owner's ordinary command handler.
-export async function createOwnerTransport({ root, nonce, allowedActions, dispatch, allowControllerArchive = false }) {
+export async function createOwnerTransport({ root, nonce, allowedActions, dispatch, allowControllerArchive = false, allowDesktopClient = false }) {
   const writers = new WeakMap();
-  const peers = new Set(), subscribers = new Set(), requests = new Map();
-  let latest;
+  const peers = new Set(), subscribers = new Set(), desktopSubscribers = new Set(), requests = new Map();
+  let latest, latestDesktop;
   const send = (peer, frame) => {
     if (peer.destroyed) return;
-    if (frame.type !== 'status' && peer.writableLength > 8 * 1024 * 1024) { peer.destroy(); return; }
+    // A valid full-history status can already occupy up to 64 MiB of the
+    // socket queue. Preserve room for bounded control receipts rather than
+    // disconnecting the viewer as soon as it requests a result behind it.
+    if (frame.type !== 'status' && peer.writableLength > (64 + 8) * 1024 * 1024) { peer.destroy(); return; }
     writers.get(peer).write(JSON.stringify(frame) + '\n', frame.type === 'status');
   };
   const server = createServer(peer => {
     peer.setEncoding('utf8');
     const writer = createDesktopFrameWriter(peer);
     writers.set(peer, writer);
-    let authenticated = false, controllerArchive = false, buffer = '';
+    let authenticated = false, controllerArchive = false, desktopClient = false, buffer = '';
     const timeout = setTimeout(() => peer.destroy(), 5000);
     peer.on('error', () => {});
-    peer.on('close', () => { writer.close(); clearTimeout(timeout); peers.delete(peer); subscribers.delete(peer); for (const [id, item] of requests) if (item.peer === peer) requests.delete(id); });
+    peer.on('close', () => { writer.close(); clearTimeout(timeout); peers.delete(peer); subscribers.delete(peer); desktopSubscribers.delete(peer); for (const [id, item] of requests) if (item.peer === peer) requests.delete(id); });
     peer.on('data', chunk => {
       buffer += chunk.toString();
       if (buffer.length > 16384) { peer.destroy(); return; }
@@ -39,16 +42,18 @@ export async function createOwnerTransport({ root, nonce, allowedActions, dispat
         if (!command || typeof command !== 'object' || Array.isArray(command)) { peer.destroy(); return; }
         if (!authenticated) {
           if (command.nonce !== nonce) { peer.destroy(); return; }
-          authenticated = true; controllerArchive = allowControllerArchive && command.client === 'archive-controller'; clearTimeout(timeout); peers.add(peer);
+          authenticated = true; desktopClient = allowDesktopClient && command.client === 'desktop'; controllerArchive = allowControllerArchive && command.client === 'archive-controller'; clearTimeout(timeout); peers.add(peer);
+          if (command.desktopProtocol === 1 && desktopClient) send(peer, { type: 'desktop_owner_ready', version: 1 });
           // One-shot controls need their result, not multi-megabyte broadcasts
           // that can fill the write queue before the result is sent.
           if (command.subscribeStatus !== false) {
-            subscribers.add(peer);
-            if (latest) send(peer, latest);
+            (desktopClient ? desktopSubscribers : subscribers).add(peer);
+            const snapshot = desktopClient ? latestDesktop : latest;
+            if (snapshot) send(peer, snapshot);
           }
           continue;
         }
-        if (!allowedActions.has(command.action) || typeof command.id !== 'string' || command.id.length > 128 || command.hostId && command.hostId !== 'local' && !(controllerArchive && ['session_archive', 'session_restore', 'session_provider_setup'].includes(command.action))) {
+        if ((!desktopClient && !allowedActions.has(command.action)) || typeof command.id !== 'string' || command.id.length > 128 || command.hostId && command.hostId !== 'local' && !desktopClient && !(controllerArchive && ['session_archive', 'session_restore', 'session_provider_setup'].includes(command.action))) {
           send(peer, { type: 'result', id: command.id, ok: false, code: 'unsupported_remote_action' }); continue;
         }
         if (requests.size >= 256) { peer.destroy(); return; }
@@ -70,15 +75,23 @@ export async function createOwnerTransport({ root, nonce, allowedActions, dispat
         if (item) { requests.delete(frame.id); send(item.peer, { ...frame, id: item.id }); }
       } else if (frame.type === 'status' || frame.type === 'notify' && (!frame.hostId || frame.hostId === 'local')) {
         for (const peer of subscribers) send(peer, frame);
+        if (frame.type === 'notify') for (const peer of desktopSubscribers) send(peer, frame);
       }
     },
+    // Local native viewers need the same complete, scoped projection as the
+    // original window. Remote observers retain their local-only catalog.
+    publishDesktop(frame) {
+      if (frame.type !== 'status') return;
+      latestDesktop = frame;
+      for (const peer of desktopSubscribers) send(peer, frame);
+    },
     async close() { for (const peer of peers) peer.destroy(); await new Promise(resolve => server.close(resolve)); },
   };
 }
 
 // Returns false only when no compatible owner endpoint exists. Never starts a
 // second owner, kills a process, or converts a disconnect into an execution retry.
-export async function relayToOwner({ root, webOrigin, input = process.stdin, output = process.stdout }) {
+export async function relayToOwner({ root, webOrigin, input = process.stdin, output = process.stdout, desktopClient = false }) {
   let owner;
   try { owner = JSON.parse(await readFile(join(root, 'desktop-app.lock', 'owner.json'), 'utf8')); }
   catch (error) { if (error.code === 'ENOENT') return false; throw error; }
@@ -94,7 +107,11 @@ export async function relayToOwner({ root, webOrigin, input = process.stdin, out
     if (webOrigin && (!owner.webOrigin || normalizeWebOrigin(owner.webOrigin) !== normalizeWebOrigin(webOrigin)))
       throw Object.assign(new Error('The existing SIMY owner belongs to another Web address. Keep its tasks and reconnect using its saved environment.'), { code: 'remote_owner_origin_mismatch' });
   } catch (error) { peer.destroy(); throw error; }
-  peer.write(JSON.stringify({ nonce: owner.nonce }) + '\n');
+  peer.write(JSON.stringify({ nonce: owner.nonce, ...(desktopClient ? { client: 'desktop', desktopProtocol: 1 } : {}) }) + '\n');
+  // Old owners ignore unknown hello fields and expose only the restricted SSH
+  // projection. Never attach a native window or forward its controls as though
+  // that were a complete desktop endpoint. Keep the original owner untouched.
+  if (desktopClient) await confirmDesktopOwner(peer);
   peer.pipe(output, { end: false });
   const lines = createInterface({ input, crlfDelay: Infinity });
   lines.on('line', line => { if (line.length <= 16384 && !peer.destroyed) peer.write(line + '\n'); });
@@ -104,6 +121,34 @@ export async function relayToOwner({ root, webOrigin, input = process.stdin, out
   return true;
 }
 
+function confirmDesktopOwner(peer) {
+  return new Promise((resolve, reject) => {
+    const incompatible = () => Object.assign(new Error('The running SIMY owner does not support desktop window handoff.'), { code: 'desktop_owner_update_required' });
+    let buffer = Buffer.alloc(0);
+    const finish = error => {
+      clearTimeout(timer);
+      peer.removeListener('data', data); peer.removeListener('close', closed); peer.removeListener('error', failed);
+      if (error) { peer.destroy(); reject(error); } else resolve();
+    };
+    const closed = () => finish(incompatible());
+    const failed = error => finish(error);
+    const data = chunk => {
+      const newline = chunk.indexOf(10);
+      const line = newline < 0 ? chunk : chunk.subarray(0, newline);
+      if (buffer.length + line.length > 16384) { finish(incompatible()); return; }
+      buffer = Buffer.concat([buffer, line]);
+      if (newline < 0) return;
+      let frame; try { frame = JSON.parse(buffer.toString('utf8')); } catch { finish(incompatible()); return; }
+      if (frame?.type !== 'desktop_owner_ready' || frame.version !== 1) { finish(incompatible()); return; }
+      peer.pause();
+      if (newline + 1 < chunk.length) peer.unshift(chunk.subarray(newline + 1));
+      finish();
+    };
+    const timer = setTimeout(closed, 5000);
+    peer.on('data', data); peer.once('close', closed); peer.once('error', failed);
+  });
+}
+
 // A terminal command attaches to the existing execution owner. It never starts
 // another supervisor or retries a mutation after a lost response.
 export async function requestOwnerArchive({ root, command, signal, timeoutMs = 55_000 }) {

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

@@ -9,7 +9,7 @@ import { compareSessionWork } from './work-state.js';
 import { manualAcceptanceCommand, matchesManualAcceptanceControls, manualAcceptanceContinuation } from './manual-acceptance-command.js';
 import { remoteHostRecovery } from './remote-host-recovery.js';
 
-const MAX_FRAME = 8 * 1024 * 1024;
+const MAX_FRAME = 64 * 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
@@ -194,10 +194,18 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
             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 => {
+            connection.statusPersistence = 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] ||= {};
+                // A lost command response is not proof of a failed save. Only
+                // this newly received, authorized host frame may resolve it;
+                // cached/offline projections and a requested value cannot.
+                const auto = saved.policy?.session_set_auto_continue;
+                if (['unknown', 'confirming'].includes(auto?.state) &&
+                    typeof row.autoContinue === 'boolean' && row.autoContinue === auto.command.enabled) {
+                  auto.state = 'applied'; delete auto.code;
+                }
                 if (['ready','partial'].includes(row.statistics?.state)) saved.statistics = { ...row.statistics, observedAt: row.statistics.observedAt || now() };
                 if (!saved.importedRemoteDisplay) {
                   saved.pinned ??= row.listPinned === true;
@@ -209,7 +217,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
               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(() => {});
+            }).then(changed).catch(() => {});
           }
           changed();
         } else if (frame.type === 'notify' && connection.ready && local && typeof frame.id === 'string' && ['finished','failed','paused','needs_decision'].includes(frame.kind)) {
@@ -508,6 +516,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
     connection.flushing = true;
     const expectedScope = preferenceScope;
     try {
+      await connection.statusPersistence;
       const state = await preferences.load(expectedScope);
       const pending = Object.entries(state.conversations).flatMap(([key, row]) => {
         if (JSON.parse(key)[0] !== connection.id) return [];
@@ -536,7 +545,9 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
         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.state = result.nextState || (result.ok
+              ? item.command.action === 'session_set_auto_continue' ? 'confirming' : 'applied'
+              : result.code === 'remote_operation_unknown' ? 'unknown' : 'failed');
             current.code = result.code;
           }
         });