@awak-app/simy-cli 0.7.29 → 0.7.32

package/src/session-supervision/index.js

@@ -7,7 +7,7 @@ import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/accepta
 import { purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, deliveryDecisionRevision, associationBlocksFollowup, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, deliveryDecisionRevision, associationBlocksFollowup, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive, ownerRenewalPending } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { listCodexSessions, codexThreadMetadata, openCodexAppServer, readCodexSession, readCodexArchiveStates, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
@@ -16,6 +16,7 @@ import { readCodexChildSessions } from './codex-children.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
 import { recentSessionWindow, retainedSession } from './discovery-window.js';
 import { requireProviderLink } from '../provider-links.js';
+import { readDispatchGate, rootFromDelivery, sessionDispatchReadiness } from '../codex-plugins/simy/hooks/update-dispatch-gate.mjs';
 
 // Only product-authored eligibility messages may pass through the desktop
 // error sanitizer; native provider errors never acquire this type.
@@ -46,14 +47,26 @@ function codexContinuationChannel(source, model, issue = null) {
   return { ready: true, code: 'ready', reason: null };
 }
 
-function autoContinueState(record, isRunning, availability) {
+// The saved ON preference is consent, not execution readiness. Each blocker
+// names its own recovery route instead of reading as provider activity.
+const DISPATCH_BLOCKERS = {
+  update_recovery_required: 'Auto-continue is saved, but SIMY is recovering from an interrupted update and cannot send work. Open Settings > App & updates and choose Try again.',
+  writer_reconnect_required: 'Auto-continue is saved, but this conversation was opened before SIMY recovered from an update. Send one message in the original conversation so SIMY can verify the same process and reconnect it.',
+  dispatch_history_quarantined: 'Earlier unconfirmed work in this conversation was quarantined during update recovery and will not be resent. Review the original conversation and start the next request yourself.',
+  task_admission_blocked: 'This task needs fresh verified provider permissions before SIMY can send work. Continue it once in the original conversation.',
+};
+function autoContinueState(record, isRunning, availability, readiness = null) {
   if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
   const state = record.run?.state;
+  if (readiness?.state === 'blocked' && !TERMINAL_RUNS.has(state)) return { autoContinueStatus: 'needs_user',
+    autoContinueReason: DISPATCH_BLOCKERS[readiness.code] || 'Auto-continue is saved, but SIMY cannot send work for this conversation yet.' };
   if (state === 'budget_exhausted') return { autoContinueStatus: 'needs_user', autoContinueReason: 'Local execution limits have been removed. Resume this same conversation to continue.' };
   if (completionClaimUnbound(record)) return { autoContinueStatus: 'watching', autoContinueReason: 'Verification of the recorded completion remains pending.' };
-  if (['completed', 'reported_done'].includes(state)) return { autoContinueStatus: 'finished', autoContinueReason: 'Continuation finished for this conversation.' };
+  if (state === 'reported_done') return { autoContinueStatus: 'watching', autoContinueReason: 'The provider reported completion; the actual result has not yet been confirmed.' };
+  if (state === 'completed') return { autoContinueStatus: 'finished', autoContinueReason: 'Continuation finished for this conversation.' };
   const managed = record.run?.managed;
   const recoverableCause = record.run?.recoveryCause === 'process_exit' || managed?.resumeChannel === 'codex_app_server' && ['session_supervision', 'approved_action'].includes(record.run?.recoveryCause);
+  if (state === 'blocked' && managed?.controllerDecisionWait && !managed.nativeWait && !managed.userQuestion && !managed.understandingQuestion) return { autoContinueStatus: 'watching', autoContinueReason: 'Investigating existing authority and permitted next steps; no operation has been approved.' };
   if (managed?.pendingApproval) return { autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention: review the pending approval in the original conversation before continuing.' };
   if (state === 'recovery_required' && (!managed?.autoRecovery || !recoverableCause)) {
     const recoveryReason = {
@@ -209,6 +222,12 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   assertActive();
   const byKey = new Map();
   const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
+  // One ledger read per discovery; an unreadable ledger blocks dispatch display.
+  let dispatchGate = null, dispatchGateError = null;
+  try { dispatchGate = readDispatchGate(rootFromDelivery(root)); } catch (error) { dispatchGateError = error.code || 'dispatch_gate_unreadable'; }
+  const readinessFor = (record, provider, session) => !record || record.autoContinue !== true && !record.run ? null
+    : dispatchGateError ? { state: 'blocked', code: dispatchGateError }
+    : sessionDispatchReadiness(dispatchGate, { provider, session, taskIds: [record.run?.managed?.taskId, record.run?.id].filter(Boolean) });
   for (const item of [...discovered, ...claude, ...archivedCodex]) {
     if (includeArchived && item.archived === true) { byKey.set(`${item.provider}:${item.session}`, item); continue; }
     if (item.archived !== true && (item.provider !== 'codex' || archiveStates.get(item.session) !== true) && recordsByKey.get(`${item.provider}:${item.session}`)?.providerArchived !== true) byKey.set(`${item.provider}:${item.session}`, item);
@@ -286,6 +305,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     const record = recordsByKey.get(`${item.provider}:${item.session}`);
     const run = record?.run;
     const archived = item.archived === true || record?.providerArchived === true;
+    const readiness = readinessFor(record, item.provider, item.session);
     const mode = run?.managed ? run.state === 'recovery_required' && run.recoveryCause === 'session_supervision' ? 'pending_takeover' : 'managed' : run ? 'standard_loop' : record?.monitor ? 'monitor' : 'unmanaged';
     const codexChannel = codexContinuationChannel(item.observation.source, item.model, codexError ? { code: codexReasonCode, reason: codexError } : null);
     const supported = item.provider === 'codex' && codexChannel.ready;
@@ -326,6 +346,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,
+      listPinned: record?.listPinned === true, listPinScopes: record?.listPinScopes || [],
       providerArchived: archived, localHidden: record?.listHidden === true,
       archived,
       pullRequests: normalizePullRequests(item.pullRequests),
@@ -338,7 +359,9 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
         run?.state === 'reported_done' && !run.managed && run.id && !record.automaticStartBlocked &&
         !associationBlocksFollowup(record) && !(record.autoContinue === false && record.autoContinueEpoch)
         ? { previousRunId: run.id } : null,
-      ...autoContinueState(record, isRunning, availability),
+      ...(readiness ? { dispatchReadiness: readiness } : {}),
+      ...(record?.writerReconnect ? { writerReconnect: record.writerReconnect } : {}),
+      ...autoContinueState(record, isRunning, availability, readiness),
       lastActivityAt: item.lastActivityAt, createdAt: item.createdAt ?? null, observation, availability: item.availability,
       taskId: run?.managed?.taskId || record?.associationTaskId || null,
       binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null,
@@ -382,13 +405,18 @@ function hasAutoContinueAdmission(record, provider, session) {
     (provider !== 'codex' || typeof admission.model === 'string' && admission.model.trim());
 }
 function requireAutoContinueTask(record) {
+  if (ownerRenewalPending(record)) throw new AutoContinueUnavailableError({ reasonCode: 'owner_renewal_pending', reason: 'Finish the original conversation connection recovery before enabling Auto Continue.' });
   if (record?.run?.state === 'stopped') throw new AutoContinueUnavailableError({ reasonCode: 'task_stopped', reason: 'This task was stopped. Review the original conversation and explicitly request resumption before continuing.' });
   if (record?.run && !record.run.managed && !canUpgradeDelivery(record.run)) throw Object.assign(new Error('This conversation already has a Delivery Loop. Use its existing controls.'), { code: 'existing_loop' });
   if (TERMINAL_RUNS.has(record?.run?.state)) throw new AutoContinueUnavailableError({ reason: 'This supervised task has settled. Review its existing status before continuing.', reasonCode: 'task_settled' });
 }
 
 // Explicit execution authority: legacy monitor/tracked records stay read-only.
-export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, ...options }) {
+// `continuationPolicy` explicitly changes the policy and is rejected for an
+// existing task. Desktop switches send `initialContinuationPolicy`: a default
+// for first enrollment only, decided under the record lock so a stale catalog
+// can neither fail ON for an ordinary loop nor change its policy or budgets.
+export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, initialContinuationPolicy, ...options }) {
   if (!['codex', 'claude'].includes(provider) || typeof enabled !== 'boolean') throw new Error('Unsupported automatic continuation request.');
   const link = enabled ? await requireProviderLink({ root, provider, expectedEpoch: options.expectedProviderEpoch }) : null;
   let discoveredAdmission;
@@ -438,8 +466,9 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
     // Settings persisted by older versions may carry removed time, turn and
     // token caps; only the fields that still govern a task are forwarded.
     const { autonomyPolicy, maxFailures, continuationPolicy: savedPolicy } = sessionLoopOptions({ ...previous.autoContinueSettings, provider });
+    const requestedPolicy = continuationPolicy ?? (previous.run ? undefined : initialContinuationPolicy);
     const settings = { autonomyPolicy, ...(maxFailures === undefined ? {} : { maxFailures }), ...(provider === 'codex' ? { purposeDriven: true } : {}),
-      ...(continuationPolicy ?? savedPolicy) === undefined ? {} : { continuationPolicy: continuationPolicy ?? savedPolicy } };
+      ...(requestedPolicy ?? savedPolicy) === undefined ? {} : { continuationPolicy: requestedPolicy ?? savedPolicy } };
     if (settings.continuationPolicy !== undefined && !['bounded', 'progress'].includes(settings.continuationPolicy)) throw new Error('Choose a continuation policy.');
     if (previous.run && continuationPolicy !== undefined) throw new Error('Change an existing task through its explicit continuation controls.');
     const next = { ...previous, ...(enabled && link.consentEpoch ? { providerConsentEpoch: link.consentEpoch } : {}), autoContinue: enabled, autoContinueEpoch: epoch,
@@ -593,7 +622,7 @@ export async function continueSession(options) {
     // rather than enrolling the generic context-bootstrap goal as a new run.
     return enrollSession({ ...options, objective: record.run.objective, upgradeRunId: record.run.id,
       maxFailures: record.run.maxFailures, contextBootstrap: false,
-      acceptanceCriteria: [{ id: 'original-goal', description: record.run.objective.slice(0, 500), check: { type: options.purposeDriven ? 'semantic' : 'manual' } }] });
+      acceptanceCriteria: [{ id: 'original-goal', description: record.run.objective.slice(0, 500), check: { type: 'semantic' } }] });
   }
   return enrollSession({ ...options, objective: 'Understand and continue the selected conversation’s current user request.',
     acceptanceCriteria: [], contextBootstrap: true });

package/src/session-supervision/manual-acceptance-command.js

@@ -0,0 +1,30 @@
+// Native and remote callers send the same frozen criterion controls. Never
+// forward a caller's approval, objective, or permission fields with feedback.
+const identityFields = ['provider', 'session', 'taskId', 'expectedRunId', 'expectedRevision', 'expectedWorkspace', 'criterionId', 'expectedCriterionDigest'];
+const boundedText = (value, limit) => typeof value === 'string' && value.trim().length > 0 && value.length <= limit && !/[\x00-\x1f\x7f]/.test(value);
+export function manualAcceptanceCommand(command) {
+  if (!['codex', 'claude'].includes(command?.provider) || !['accept', 'not_yet'].includes(command?.decision) ||
+      !['session', 'taskId', 'expectedRunId', 'criterionId'].every(key => boundedText(command[key], 200)) ||
+      !boundedText(command.expectedWorkspace, 4000) || !Number.isSafeInteger(command.expectedRevision) || command.expectedRevision < 0 ||
+      !/^[a-f0-9]{64}$/.test(command.expectedCriterionDigest || '') ||
+      command.decision === 'not_yet' && (typeof command.reason !== 'string' || !command.reason.trim() || command.reason.length > 1000 || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(command.reason))) {
+    throw new Error('Refresh the manual acceptance controls before deciding.');
+  }
+  return { ...Object.fromEntries(identityFields.map(key => [key, command[key]])), decision: command.decision,
+    ...(command.decision === 'not_yet' ? { reason: command.reason.trim() } : {}) };
+}
+
+export function matchesManualAcceptanceControls(command, controls) {
+  return Boolean(controls && identityFields.every(key => controls[key] === command[key]));
+}
+
+const continuationReasons = {
+  none: [null],
+  queued: ['original_read_diagnosis_queued'],
+  original_turn_required: ['passive_hook_channel'],
+  deferred: ['existing_execution_or_authority_boundary', 'current_work_kept', 'explicit_resume_required', 'existing_task_state_kept'],
+};
+export function manualAcceptanceContinuation(value) {
+  return Object.hasOwn(continuationReasons, value?.state) && continuationReasons[value.state].includes(value.reasonCode)
+    ? { state: value.state, reasonCode: value.reasonCode } : null;
+}

package/src/session-supervision/notification-authority.js

@@ -0,0 +1,9 @@
+// Read-only attention binding. This is not execution authority or a consent store.
+// Use the current repair receipt's real requestId/status; legacy guesses stay unknown.
+export function repairNotificationAuthority(run) {
+  const receipt = run?.managed?.repairRequest;
+  if (typeof receipt?.requestId !== 'string' || !receipt.requestId.trim() || receipt.requestId.length > 200 ||
+    /[\u0000-\u001f\u007f]/u.test(receipt.requestId) || receipt.revokedAt !== undefined ||
+    !['running', 'resolved', 'unresolved', 'needs_human'].includes(receipt.status)) return null;
+  return { kind: 'repair', id: receipt.requestId };
+}

package/src/session-supervision/notification-journal.js

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+// Stable notification IDs let controllers recover events after a disconnected
+// observation. This is internal delivery state, never user-supplied evidence.
+export function createNotificationJournal(root) {
+  const path = join(root, 'controller-notifications.json');
+  const cursors = new Map();
+  let events = [], queue = readFile(path, 'utf8').then(text => {
+    const value = JSON.parse(text);
+    if (!Array.isArray(value)) throw new Error('Invalid notification journal.');
+    events = value;
+  }).catch(error => { if (error.code !== 'ENOENT') throw error; });
+  return {
+    append(event) {
+      const work = queue.then(async () => {
+        if (events.some(item => item.id === event.id && item.scope === event.scope)) return;
+        const next = [...events, event];
+        await mkdir(root, { recursive: true, mode: 0o700 });
+        const temp = `${path}.${randomUUID()}.tmp`;
+        await writeFile(temp, JSON.stringify(next), { mode: 0o600 });
+        await rename(temp, path); events = next;
+      });
+      queue = work; return work;
+    },
+    async snapshot(scope, after) {
+      await queue;
+      if (after !== undefined) {
+        if (!Number.isSafeInteger(after) || after < 0) throw new Error('Invalid event cursor.');
+        return structuredClone(events.map((event, index) => ({ ...event, sequence: index + 1 })).filter(event => event.scope === scope && event.sequence > after).slice(0, 512));
+      }
+      const rows = scope === undefined ? events : events.filter(event => event.scope === scope);
+      const offset = cursors.get(scope) || 0;
+      const batch = rows.slice(offset, offset + 512);
+      cursors.set(scope, offset + batch.length >= rows.length ? 0 : offset + batch.length);
+      return structuredClone(batch);
+    },
+  };
+}

package/src/session-supervision/operation-journal.js

@@ -0,0 +1,42 @@
+import { createHash } from 'node:crypto';
+import { createControllerStore } from './controller-store.js';
+export const operationDigest = command => {
+  const { id, requestId, ...body } = command;
+  return createHash('sha256').update(JSON.stringify(Object.fromEntries(Object.entries(body).sort(([a],[b]) => a.localeCompare(b))))).digest('hex');
+};
+export function createOperationJournal(root) {
+  const store = createControllerStore(root);
+  return {
+    begin(scope, command, { reconcileReceived = false } = {}) {
+      if (typeof command.requestId !== 'string' || !/^[a-zA-Z0-9_-]{1,128}$/.test(command.requestId)) throw new Error('Invalid remote request identity.');
+      return store.change(scope, state => {
+        state.operations ||= {};
+        const key = command.requestId, digest = operationDigest(command), previous = state.operations[key];
+        if (previous && previous.digest !== digest) throw new Error('Request identity conflicts with another operation.');
+        if (previous) {
+          // Only a controller forwarding to a v2 owner may reconcile the same
+          // intent. The execution owner must never rerun an unsettled command.
+          const unknown = !previous.result || previous.result.ok === false &&
+            ['remote_operation_unknown', 'remote_host_unavailable'].includes(previous.result.code);
+          if (reconcileReceived && unknown) {
+            delete previous.result;
+            previous.state = 'received';
+            return null;
+          }
+          return previous.result || { ok: false, code: 'remote_operation_unknown', message: 'The operation was received; its final result has not been reconciled.' };
+        }
+        state.operations[key] = { digest, state: 'received', protocolVersion: 2, requestId: key, receivedAt: Date.now(),
+          target: { hostId: command.hostId || 'local', provider: command.provider, session: command.session, action: command.action, taskId: command.taskId, expectedRevision: command.expectedRevision } }; return null;
+      });
+    },
+    finish(scope, command, result) {
+      return store.change(scope, state => {
+        const item = state.operations?.[command.requestId];
+        if (!item || item.digest !== operationDigest(command)) throw new Error('Unknown remote request.');
+        if (result.ok === false && result.code === 'remote_operation_unknown') return;
+        const { id, ...value } = result; item.result = value; item.state = 'settled'; item.settledAt = Date.now();
+      });
+    },
+    close: () => store.close(),
+  };
+}

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

@@ -0,0 +1,146 @@
+import { createServer, createConnection } from 'node:net';
+import { chmod, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID, createHash } from 'node:crypto';
+import { createInterface } from 'node:readline';
+
+export const ownerSocketPath = (root, platform = process.platform) => platform === 'win32'
+  ? '\\\\.\\pipe\\simy-controller-' + createHash('sha256').update(root).digest('hex').slice(0, 32)
+  : join(root, 'desktop-app.lock', 'controller.sock');
+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 }) {
+  const peers = new Set(), requests = new Map();
+  let latest;
+  const send = (peer, frame) => {
+    if (peer.destroyed) return;
+    if (peer.writableLength > 8 * 1024 * 1024) { peer.destroy(); return; }
+    peer.write(JSON.stringify(frame) + '\n');
+  };
+  const server = createServer(peer => {
+    peer.setEncoding('utf8');
+    let authenticated = false, controllerArchive = false, buffer = '';
+    const timeout = setTimeout(() => peer.destroy(), 5000);
+    peer.on('error', () => {});
+    peer.on('close', () => { clearTimeout(timeout); peers.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; }
+      let end;
+      while ((end = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+        let command; try { command = JSON.parse(line); } catch { peer.destroy(); return; }
+        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);
+          if (latest) send(peer, latest);
+          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))) {
+          send(peer, { type: 'result', id: command.id, ok: false, code: 'unsupported_remote_action' }); continue;
+        }
+        if (requests.size >= 256) { peer.destroy(); return; }
+        const id = randomUUID(); requests.set(id, { peer, id: command.id });
+        dispatch({ ...command, id });
+      }
+    });
+  });
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(socketPath(root), resolve); });
+  if (process.platform !== 'win32') await chmod(socketPath(root), 0o600);
+  return {
+    publish(frame) {
+      if (frame.type === 'status') latest = frame;
+      if (frame.type === 'task_detail') {
+        const item = requests.get(frame.id);
+        if (item) send(item.peer, { ...frame, id: item.id });
+      } else if (frame.type === 'result') {
+        const item = requests.get(frame.id);
+        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 peers) 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, input = process.stdin, output = process.stdout }) {
+  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; }
+  const peer = createConnection(socketPath(root));
+  const connected = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { peer.destroy(); reject(new Error('Owner connection timed out.')); }, 5000);
+    peer.once('connect', () => { clearTimeout(timer); resolve(true); });
+    peer.once('error', error => { clearTimeout(timer); if (['ENOENT','ECONNREFUSED'].includes(error.code)) resolve(false); else reject(error); });
+  });
+  if (!connected) return false;
+  peer.write(JSON.stringify({ nonce: owner.nonce }) + '\n');
+  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'); });
+  lines.on('close', () => peer.end());
+  await new Promise((resolve, reject) => { peer.once('close', resolve); peer.once('error', reject); });
+  lines.close(); input.pause();
+  return true;
+}
+
+// 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 }) {
+  if (!['session_archive', 'session_restore', 'session_provider_setup'].includes(command?.action)) throw new Error('Unsupported archive command.');
+  return requestOwnerCommand({ root, command, signal, timeoutMs, client: 'archive-controller' });
+}
+
+// Use the authenticated owner and controls already used by the app. Chat
+// delegation is local; never fall back to a different host or execution owner.
+export async function requestOwnerContinuation({ root, command, signal, timeoutMs = 55_000 }) {
+  if (!['session_set_auto_continue', 'session_get_status'].includes(command?.action) || command.hostId !== 'local')
+    throw new Error('Unsupported continuation command.');
+  return requestOwnerCommand({ root, command, signal, timeoutMs });
+}
+
+async function requestOwnerCommand({ root, command, signal, timeoutMs, client }) {
+  signal?.throwIfAborted();
+  const unavailable = () => Object.assign(new Error('Start or update the SIMY app on this computer, then retry.'), { code: 'desktop_owner_unavailable' });
+  const denied = () => Object.assign(new Error('The current provider permissions cannot access the local SIMY controller. Check the provider’s native permission request; do not change the original task or start another controller.'), { code: 'desktop_owner_access_denied' });
+  const connectionFailure = error => ['EACCES', 'EPERM'].includes(error?.code) ? denied() : unavailable();
+  let owner;
+  try { owner = JSON.parse(await readFile(join(root, 'desktop-app.lock', 'owner.json'), 'utf8')); } catch (error) { throw connectionFailure(error); }
+  if (typeof owner?.nonce !== 'string' || !owner.nonce) throw unavailable();
+  return new Promise((resolve, reject) => {
+    const peer = createConnection(socketPath(root));
+    let buffer = '', settled = false, sent = false;
+    const unknown = () => Object.assign(new Error('SIMY has not confirmed the result. Refresh the conversation before retrying.'), { code: 'remote_operation_unknown' });
+    const finish = (error, result) => {
+      if (settled) return; settled = true;
+      clearTimeout(timer); signal?.removeEventListener('abort', abort); peer.destroy();
+      if (error) reject(error); else resolve(result);
+    };
+    const abort = () => finish(signal.reason);
+    const timer = setTimeout(() => finish(unknown()), timeoutMs);
+    signal?.addEventListener('abort', abort, { once: true });
+    peer.setEncoding('utf8');
+    peer.on('connect', () => {
+      if (signal?.aborted) { abort(); return; }
+      sent = true;
+      peer.write(JSON.stringify({ nonce: owner.nonce, ...(client ? { client } : {}) }) + '\n' + JSON.stringify(command) + '\n');
+    });
+    peer.on('error', error => finish(sent ? unknown() : connectionFailure(error)));
+    peer.on('close', () => finish(Object.assign(new Error('SIMY disconnected before confirming the result. Refresh before retrying.'), { code: 'remote_operation_unknown' })));
+    peer.on('data', chunk => {
+      buffer += chunk;
+      if (buffer.length > 8 * 1024 * 1024) { finish(new Error('SIMY response exceeded its supported size.')); return; }
+      let end;
+      while ((end = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+        let frame; try { frame = JSON.parse(line); } catch { finish(new Error('SIMY returned an invalid response.')); return; }
+        if (frame?.type === 'result' && frame.id === command.id) { finish(null, frame); return; }
+      }
+    });
+  });
+}

package/src/session-supervision/purpose-recovery.js

@@ -4,7 +4,7 @@ import { finalResponseRecoveryInstruction } from './final-response-recovery.js';
 import { requireProviderLink } from '../provider-links.js';
 import { searchEnabled, purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { createHash } from 'node:crypto';
-import { listRecords, readRecord, updateRecord, automaticContinuationAllowed, canResearchReplan, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { listRecords, readRecord, updateRecord, automaticContinuationAllowed, canResearchReplan, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason, controllerApprovalDiagnosisEligible, diagnoseControllerApproval } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { openCodexAppServer, readCodexSession, observeCodexAuthentication } from './codex-app-server.js';
 import { realpath } from 'node:fs/promises';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
@@ -64,8 +64,16 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
     if (record.run?.managed?.nativeHandoff) continue;
     try {
     let run = record.run;
+    if (run?.state === 'blocked' && run.managed?.controllerDecisionWait && !controllerApprovalDiagnosisEligible(record, now)) {
+      record = await writeRecord(root, record.provider, record.session, current => {
+        if (current?.run?.id === run.id && current.run.revision === run.revision && current.run.state === 'blocked' &&
+            current.run.managed?.controllerDecisionWait && !controllerApprovalDiagnosisEligible(current, now)) diagnoseControllerApproval(current, now);
+        return current;
+      });
+      run = record.run;
+    }
     if (run?.managed?.providerCapabilityWait) continue;
-    if (upgradeEligible(record) && (policyAdoptionPending(record) || run.managed.purpose?.enabled !== true || run.managed.purpose?.version !== 2 || run.managed.purpose?.decisionPolicy !== 'llm-first-hc102' || run.managed.controllerContractVersion !== 2 || run.state === 'paused' || run.state === 'verification_pending')) {
+    if (upgradeEligible(record) && (run.state === 'blocked' && controllerApprovalDiagnosisEligible(record, now) || policyAdoptionPending(record) || run.managed.purpose?.enabled !== true || run.managed.purpose?.version !== 2 || run.managed.purpose?.decisionPolicy !== 'llm-first-hc102' || run.managed.controllerContractVersion !== 2 || run.state === 'paused' || run.state === 'verification_pending')) {
       let metadata, migrationLink;
       try { migrationLink = await requireProviderLink({ root, provider: record.provider }); metadata = await observeMetadata(record); }
       catch { metadata = null; }

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

@@ -23,7 +23,7 @@ export function createControl({ authorize, select, set, followup, save, revoke,
     if (command.enabled && (candidate.autoContinueAvailability?.canEnable ?? candidate.capabilities?.canAutoContinue) !== true) throw Object.assign(new Error(candidate.autoContinueAvailability?.reason || 'Continuation unavailable'), {code:candidate.autoContinueAvailability?.reasonCode});
     await authorize(scope);
     await set({root, provider:'codex',session:command.session,enabled:command.enabled,
-      continuationPolicy:command.continuationPolicy, admission:candidate.continuationAdmission,expectedProviderEpoch:scope.providerEpoch});
+      initialContinuationPolicy:command.continuationPolicy, admission:candidate.continuationAdmission,expectedProviderEpoch:scope.providerEpoch});
     if (!command.enabled) revoke('codex',command.session);
     await save(command,scope);
   };

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.',