@awak-app/simy-cli 0.7.22 → 0.7.25

package/src/sqm/failure-circuit.js

@@ -6,6 +6,10 @@ import { CLI_VERSION } from "../cli-contract.js";
 import { defaultSessionRoot } from "../session-store.js";
 
 export const SQM_FAILURE_PAUSE_THRESHOLD = 6;
+export const SQM_RECOVERY_DELAY_MS = 5 * 60_000;
+const MAX_RECOVERY_DELAY_MS = 30 * 60_000;
+const exhausted = state => state.failures >= SQM_FAILURE_PAUSE_THRESHOLD || (state.providerFailures || 0) >= 2;
+const recoveryDelay = state => Math.min(MAX_RECOVERY_DELAY_MS, SQM_RECOVERY_DELAY_MS * 2 ** Math.min(state.recoveryAttempts || 0, 3));
 const scopeKey = scope => JSON.stringify([scope?.webOrigin, scope?.accountId, scope?.organizationId]);
 const validVersion = value => typeof value === "string" && /^\d+\.\d+\.\d+$/.test(value);
 
@@ -21,6 +25,9 @@ export function createSqmFailureCircuitStore({ root = defaultSessionRoot() } = {
         const state = JSON.parse(await readFile(path(scope), "utf8"));
         if (!validVersion(state.version) || !Number.isInteger(state.failures) || state.failures < 0 || state.failures > SQM_FAILURE_PAUSE_THRESHOLD || (state.inFlight !== undefined && typeof state.inFlight !== "boolean") || (state.providerFailures !== undefined && (!Number.isInteger(state.providerFailures) || state.providerFailures < 0 || state.providerFailures > 2)) || (state.providerRetryAt !== undefined && (!Number.isFinite(state.providerRetryAt) || state.providerRetryAt < 0)))
           throw new Error("Invalid saved SQM failure state.");
+        if (state.recoveryAt !== undefined && (!Number.isFinite(state.recoveryAt) || state.recoveryAt < 0) ||
+            state.recoveryAttempts !== undefined && (!Number.isSafeInteger(state.recoveryAttempts) || state.recoveryAttempts < 0))
+          throw new Error("Invalid saved SQM recovery state.");
         return state;
       } catch (error) { if (error.code === "ENOENT") return null; throw error; }
     },
@@ -37,12 +44,17 @@ export function createSqmFailureCircuitStore({ root = defaultSessionRoot() } = {
 
 // One counter per organization on this machine, shared by both local engines.
 // Neither reconnecting nor an empty claim demonstrates successful analysis.
-export function createSqmFailureCircuit({ version = CLI_VERSION, store = null } = {}) {
+export function createSqmFailureCircuit({ version = CLI_VERSION, store = null, now = Date.now } = {}) {
   if (!validVersion(version)) throw new Error("SQM failure circuit requires a SIMY version.");
   const states = new Map();
   const unreadableScopes = new Set();
+  const scheduleRecovery = state => {
+    if (!exhausted(state) || state.recoveryAt > now()) return false;
+    state.recoveryAt = Math.max(state.providerRetryAt || 0, now() + recoveryDelay(state));
+    return true;
+  };
   const save = async (scope, state) => {
-    try { await store?.write(scope, { version: state.version, failures: state.failures, inFlight: state.inFlight === true, ...(state.providerFailures ? { providerFailures: state.providerFailures, providerRetryAt: state.providerRetryAt } : {}) }); state.storageError = false; }
+    try { await store?.write(scope, { version: state.version, failures: state.failures, inFlight: state.inFlight === true, ...(state.recoveryAt !== undefined ? { recoveryAt: state.recoveryAt, recoveryAttempts: state.recoveryAttempts || 0 } : {}), ...(state.providerFailures ? { providerFailures: state.providerFailures, providerRetryAt: state.providerRetryAt } : {}) }); state.storageError = false; }
     catch (error) { state.storageError = true; throw error; }
   };
   const load = async scope => {
@@ -52,7 +64,7 @@ export function createSqmFailureCircuit({ version = CLI_VERSION, store = null }
       let saved;
       try { saved = await store?.read(scope); unreadableScopes.delete(key); }
       catch (error) { unreadableScopes.add(key); throw error; }
-      state = saved ? { version: saved.version, failures: saved.failures, inFlight: saved.inFlight === true, providerFailures: saved.providerFailures || 0, providerRetryAt: saved.providerRetryAt || 0 } : { version, failures: 0, inFlight: false };
+      state = saved ? { version: saved.version, failures: saved.failures, inFlight: saved.inFlight === true, providerFailures: saved.providerFailures || 0, providerRetryAt: saved.providerRetryAt || 0, ...(saved.recoveryAt !== undefined ? { recoveryAt: saved.recoveryAt, recoveryAttempts: saved.recoveryAttempts || 0 } : {}) } : { version, failures: 0, inFlight: false };
       states.set(key, state);
       // An unfinished review from this same version means the last host exited
       // without a result or graceful cancellation. Count it once on restart.
@@ -60,6 +72,7 @@ export function createSqmFailureCircuit({ version = CLI_VERSION, store = null }
         state.failures = Math.min(SQM_FAILURE_PAUSE_THRESHOLD, state.failures + 1);
         if (state.providerFailures === 1) state.providerFailures = 2;
         state.inFlight = false;
+        scheduleRecovery(state);
         await save(scope, state);
       }
     }
@@ -67,20 +80,35 @@ export function createSqmFailureCircuit({ version = CLI_VERSION, store = null }
       state.version = version;
       state.providerFailures = 0; state.providerRetryAt = 0;
       state.failures = 0;
+      delete state.recoveryAt; delete state.recoveryAttempts;
       state.inFlight = false;
       await save(scope, state);
     } else if (state.storageError) await save(scope, state);
+    // Migrate a legacy update-only pause once, retaining counters and scope.
+    if (exhausted(state) && state.recoveryAt === undefined) {
+      scheduleRecovery(state); await save(scope, state);
+    }
     return state;
   };
   return {
-    async canClaim(scope, now = Date.now()) {
+    async canClaim(scope, time = now()) {
       const state = await load(scope);
-      return state.failures < SQM_FAILURE_PAUSE_THRESHOLD && (state.providerFailures || 0) < 2 && now >= (state.providerRetryAt || 0);
+      if (time < (state.providerRetryAt || 0) || state.inFlight) return false;
+      if (!exhausted(state)) return true;
+      if (time < state.recoveryAt) return false;
+      // Reserve the next cooldown before claiming. Empty claims, reconnects and
+      // cancelled work never reset failures or allow a burst of recovery turns.
+      state.recoveryAttempts = Math.min((state.recoveryAttempts || 0) + 1, 3);
+      state.recoveryAt = time + recoveryDelay(state);
+      await save(scope, state);
+      return true;
     },
     async providerFailure(scope, retryAt, retryAttempt = 0) {
       const state = await load(scope);
       state.providerFailures = retryAttempt === 1 ? 2 : Math.min(2, (state.providerFailures || 0) + 1);
       state.providerRetryAt = retryAt;
+      scheduleRecovery(state);
+      if (state.recoveryAt !== undefined) state.recoveryAt = Math.max(state.recoveryAt, retryAt);
       await save(scope, state);
     },
     async providerRetryUsed(scope) {
@@ -104,12 +132,14 @@ export function createSqmFailureCircuit({ version = CLI_VERSION, store = null }
       state.failures = Math.min(SQM_FAILURE_PAUSE_THRESHOLD, state.failures + 1);
       if (state.inFlight && state.providerFailures === 1) state.providerFailures = 2;
       state.inFlight = false;
+      scheduleRecovery(state);
       await save(scope, state);
     },
     async success(scope) {
       const state = await load(scope);
       state.failures = 0;
       state.providerFailures = 0; state.providerRetryAt = 0;
+      delete state.recoveryAt; delete state.recoveryAttempts;
       state.inFlight = false;
       await save(scope, state);
     },
@@ -117,10 +147,12 @@ export function createSqmFailureCircuit({ version = CLI_VERSION, store = null }
       const state = states.get(scopeKey(scope));
       const paused = (state?.failures || 0) >= SQM_FAILURE_PAUSE_THRESHOLD || (state?.providerFailures || 0) >= 2;
       return { consecutive_failures: state?.failures || 0,
-        paused_until_update: paused,
+        paused_until_update: false,
+        recovery_pending: paused && state?.inFlight !== true,
+        next_retry_at: paused ? state.recoveryAt ?? null : null,
         provider_retry_exhausted: (state?.providerFailures || 0) >= 2,
         provider_recovery_pending: state?.providerFailures === 1,
-        paused_at_version: paused ? state.version : null,
+        paused_at_version: null,
         storage_unavailable: state?.storageError === true || unreadableScopes.has(scopeKey(scope)) };
     },
   };

package/src/sqm/provider-plugin-status.js

@@ -1,9 +1,22 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { resolveBackendExecutable } from '../backend-executable.js';
 import { runProviderCommand } from './provider-command.js';
 import { CLAUDE_PLUGIN_SELECTOR } from './claude-plugin.js';
 
+// The managed marketplace selects the inventory scope, never installation or
+// enablement evidence. Those still come from the provider's actual response.
+async function managedCodexMarketplace({ home, signal }) {
+  try {
+    const bytes = await readFile(join(home, '.agents', 'plugins', 'marketplace.json'), { encoding: 'utf8', signal });
+    if (Buffer.byteLength(bytes) > 64 * 1024) return null;
+    const manifest = JSON.parse(bytes);
+    return /^[A-Za-z0-9_-]+$/.test(manifest?.name || '') && Array.isArray(manifest.plugins) &&
+      manifest.plugins.some(entry => entry?.name === 'simy') ? manifest.name : null;
+  } catch { return null; }
+}
+
 export const unavailablePluginStatus = () => ({ state: 'unknown', installed: null, enabled: null });
 
 // Provider inventories describe the actual installation and enablement. Managed
@@ -15,7 +28,7 @@ export async function inspectProviderPlugins({ home = homedir(),
   claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
   resolveExecutable = resolveBackendExecutable, run = runProviderCommand,
   timeoutMs = 5_000, signal, providers = ['codex', 'claude'], details = false,
-  onDiagnostic = () => {},
+  onDiagnostic = () => {}, readCodexMarketplace = managedCodexMarketplace,
 } = {}) {
   if (providers.some(provider => !['codex', 'claude'].includes(provider))) throw new Error('Unsupported provider.');
   const inspect = async provider => {
@@ -30,7 +43,12 @@ export async function inspectProviderPlugins({ home = homedir(),
       const executable = await resolveExecutable(provider, { signal, timeoutMs });
       if (signal?.aborted) return unavailable('cancelled');
       if (!executable) return unavailable('cli_missing');
-      const { stdout } = await run(executable, ['plugin', 'list', '--json'], {
+      const marketplace = provider === 'codex' ? await readCodexMarketplace({ home, signal }) : null;
+      if (signal?.aborted) return unavailable('cancelled');
+      // A global inventory may contact unrelated remote marketplaces. Query the
+      // configured SIMY source so their network delays cannot hide local state.
+      const args = ['plugin', 'list', '--json', ...(marketplace ? ['--marketplace', marketplace] : [])];
+      const { stdout } = await run(executable, args, {
         timeout: timeoutMs, maxBuffer: 1024 * 1024, signal, cwd: home,
         env: { ...process.env, HOME: home,
           ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) },
@@ -39,7 +57,7 @@ export async function inspectProviderPlugins({ home = homedir(),
       const entries = provider === 'codex' ? payload?.installed : payload;
       if (!Array.isArray(entries)) return unavailable('invalid_inventory');
       const matches = entries.filter(entry => provider === 'codex'
-        ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId)
+        ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId) && (!marketplace || entry.pluginId === `simy@${marketplace}`)
         : entry?.id === CLAUDE_PLUGIN_SELECTOR);
       // Prefer the account installation; report a project-only install explicitly
       // rather than silently treating it as an installation for every project.

package/src/sqm/review-worker.js

@@ -115,11 +115,12 @@ export function createSqmLocalReviewWorker({
   getHistoryScope = () => null,
   getWorkspaceUrl = () => null,
   recordHistory = async () => {},
+  readHistory = async () => [],
   onHistoryError = () => {},
   now = () => Date.now(),
   providerFailureCooldownMs = 5 * 60_000,
   getRecoveryKey = () => null,
-  failureCircuit = createSqmFailureCircuit(),
+  failureCircuit = createSqmFailureCircuit({ now }),
 } = {}) {
   if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
   let activeJobId = null;
@@ -158,6 +159,7 @@ export function createSqmLocalReviewWorker({
       item.state = state; item.finishedAt = new Date().toISOString();
       item.result = state === "completed" ? "SQM review submitted." : "";
       item.error = state === "failed" ? formatFailure(failure, failureReported) : "";
+      if (state === 'completed') for (const field of ['errorCode', 'errorStage', 'httpStatus', 'providerDiagnostic']) delete item[field];
       if (failure) { item.phase = failure.stage; item.errorStage = failure.stage; item.errorCode = failure.code; item.httpStatus = failure.status; item.providerDiagnostic = failure.providerDiagnostic; }
       await persist(scope, item);
     }
@@ -273,20 +275,22 @@ export function createSqmLocalReviewWorker({
     snapshot() {
       const pause = currentPause();
       const circuit = failureCircuit.snapshot(getHistoryScope());
+      const requiresInteraction = pause && !pause.recoverable && pause.recoveryKey === getRecoveryKey(getProvider());
+      const waitingForRecovery = circuit.recovery_pending && !requiresInteraction && !activeJobId;
       return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, suspended,
-        paused: pausedEnvironment !== null || circuit.paused_until_update || circuit.storage_unavailable,
-        pause_reason: circuit.provider_retry_exhausted ? "provider_retry_failed_until_update" : circuit.paused_until_update ? "consecutive_failures_until_update" : circuit.storage_unavailable ? "failure_state_unavailable" : pauseReason,
+        paused: !activeJobId && (pausedEnvironment !== null || circuit.recovery_pending || circuit.storage_unavailable),
+        pause_reason: activeJobId ? null : requiresInteraction ? pause.code : waitingForRecovery ? "automatic_recovery_pending" : circuit.storage_unavailable ? "failure_state_unavailable" : pauseReason,
         ...circuit, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
-        ...(pause ? { provider_pause: { code: pause.code, status: pause.status,
-          retry_at: circuit.provider_retry_exhausted ? null : new Date(pause.retryAt).toISOString(),
-          message: circuit.provider_retry_exhausted ? "The provider retry failed. New SQM reviews are paused until SIMY is updated." : pause.message } } : {}) };
+        ...(pause && !activeJobId ? { provider_pause: { code: pause.code, status: pause.status,
+          retry_at: new Date(Math.max(pause.retryAt, circuit.next_retry_at || 0)).toISOString(),
+          message: waitingForRecovery ? "SIMY will automatically retry after the recovery cooldown. No update or manual confirmation is required." : pause.message } } : {}) };
     },
     desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item, canStop: item.id === activeJobId })) }; },
     desktopTaskDetail(key) {
       const item = visibleHistory().find(item => item.key === key);
       return item ? { key, instruction: `SQM local review · ${item.provider}`, result: item.state === "completed" ? "SQM review submitted." : "", error: item.error || "", links: item.webUrl ? [{ label: "Analysis details", url: item.webUrl }] : [] } : null;
     },
-    retry() { if (closed || suspended || pollPromise || failureCircuit.snapshot(getHistoryScope()).paused_until_update) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
+    retry() { if (closed || suspended || pollPromise || failureCircuit.snapshot(getHistoryScope()).recovery_pending) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
     resetHistory() { if (!pollPromise) { history.splice(0); issue = null; pausedEnvironment = null; pauseReason = null; } },
     poll() {
       if (closed || suspended || pollPromise) return pollPromise || Promise.resolve(null);
@@ -295,7 +299,8 @@ export function createSqmLocalReviewWorker({
         const pause = currentPause();
         // Known provider failures already have a bounded cooldown. Do not let
         // the environment gate suppress their recovery probe indefinitely.
-        if (!pause?.recoverable || (pause.recoveryKey === getRecoveryKey(getProvider()) && now() < pause.retryAt)) return Promise.resolve(null);
+        if (pause?.recoveryKey === getRecoveryKey(getProvider()) &&
+            (!pause.recoverable || now() < pause.retryAt)) return Promise.resolve(null);
         pausedEnvironment = null; pauseReason = null;
       } else if (pausedEnvironment !== null) {
         pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null;
@@ -323,6 +328,23 @@ export function createSqmLocalReviewWorker({
           lease_seconds: leaseSeconds,
         }, { signal: reviewController.signal });
         if (issue) { issue = null; onChange(); }
+        if (claim?.recovered === true && claim.completed === true && typeof claim.job_id === 'string') {
+          // The server completed this exact saved result without re-running a
+          // provider. Reflect the original job's completion locally as well.
+          if (!history.some(item => item.id === claim.job_id)) {
+            let saved;
+            try { saved = (await readHistory(historyScope)).find(item => item.key === `sqm:${claim.job_id}`); }
+            catch { onHistoryError(); }
+            const item = { ...saved, id: claim.job_id, key: `sqm:${claim.job_id}`, kind: 'analysis',
+              label: saved?.label || `SQM · ${claim.job_id.slice(0, 8)}`, provider: saved?.provider || provider,
+              startedAt: saved?.startedAt || new Date().toISOString(), webUrl: saved?.webUrl || analysisTaskUrl(workspaceUrl, claim.job_id) };
+            history.unshift(item); historyScopes.set(item, JSON.stringify(historyScope)); history.splice(50);
+          }
+          await updateTask(claim.job_id, 'completed', historyScope);
+          await failureCircuit.success(historyScope);
+          pauses.delete(key);
+          return claim;
+        }
         if (!claim?.claimed) {
           // A successful empty claim proves SIMY access recovered, but it says
           // nothing about a local provider that has not executed again yet.

package/src/update-detachment/history-recovery.js

@@ -0,0 +1,51 @@
+import {readFile,writeFile,mkdir,realpath} from 'node:fs/promises';
+import {join,resolve} from 'node:path';
+import {createHash,randomUUID} from 'node:crypto';
+import {digest} from './state-store.js';
+import {readDispatchGate,reconcileDispatchHistory} from './dispatch-gate.js';
+import {createUpdateRuntime} from './runtime.js';
+import {createUpdateCoordinator} from './coordinator.js';
+import {readSession,isSessionValid} from '../session-store.js';
+import {webApiUrl,webApiHeaders} from '../web-api.js';
+import {acquireDesktopProcessLock} from '../desktop-process-lock.js';
+import {listRecords} from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function planDispatchHistoryRecovery({root}) {
+ root=await realpath(root);const state=readDispatchGate(root),items=[];
+ for(const attempt of Object.values(state.attempts)) {
+  const item={attemptId:attempt.id,attemptDigest:digest(attempt),disposition:attempt.phase==='confirmed'?'already_confirmed':'retain_blocked_unknown'};
+  const ref=attempt.provenance?.recordRef;
+  if(attempt.phase==='result_saved' && ref?.startsWith(resolve(root,'direct-tasks')+'/')) {
+   try {
+    const bytes=await readFile(ref),result=JSON.parse(bytes),match=/^(.*):provider:([1-9][0-9]*)$/.exec(attempt.id);
+    if(await realpath(ref)===ref && match && result.id===match[1] && result.id===attempt.provenance.taskId && digest(result.id)===attempt.taskHash &&
+      result.invocation_count===Number(match[2]) && ['succeeded','failed','stopped'].includes(result.status) && Object.values(state.receipts).some(r=>r.attemptId===attempt.id && r.generation===attempt.generation && r.resultRef===ref)) {
+     item.disposition='saved_terminal_result';item.evidence={ref,sha256:sha(bytes),status:result.status};
+    }
+   } catch { /* Unknown effects remain blocked, including removed test output. */ }
+  }
+  items.push(item);
+ }
+ const audit={version:1,gateDigest:digest(state),expectedRevision:state.revision,expectedGeneration:state.generation,items};
+ const directory=join(root,'update-detachment','recovery');await mkdir(directory,{recursive:true,mode:0o700});
+ const auditRef=join(directory,randomUUID()+'.json'),bytes=JSON.stringify(audit,null,2)+'\n';await writeFile(auditRef,bytes,{flag:'wx',mode:0o600});
+ return {auditRef,auditDigest:sha(bytes),revision:state.revision,generation:state.generation,results:items.filter(i=>i.disposition==='saved_terminal_result').length,blocked:items.filter(i=>i.disposition==='retain_blocked_unknown').length,replayAttempts:false};
+}
+export async function applyDispatchHistoryRecovery({root,auditRef,auditDigest}) {
+ root=await realpath(root);const lock=await acquireDesktopProcessLock(root);
+ try {const audit=JSON.parse(await readFile(auditRef,'utf8'));return reconcileDispatchHistory({root,auditRef,auditDigest,expectedRevision:audit.expectedRevision,expectedGeneration:audit.expectedGeneration});}
+ finally {await lock.release();}
+}
+export async function reconnectRecoveredHistory({root,origin='https://app.simy.one'}) {
+ root=await realpath(root);const lock=await acquireDesktopProcessLock(root);
+ try {
+  const session=await readSession(origin,root);if(!isSessionValid(session,Date.now(),origin))throw Error('Existing device sign-in required.');
+  const response=await fetch(webApiUrl('desktop-access',{webOrigin:origin,apiBaseUrl:session.api_base_url}),{headers:webApiHeaders(session),signal:AbortSignal.timeout(10000)});
+  const access=await response.json();if(!response.ok || access.state!=='ready' || access.organizationId!==session.organization_id)throw Error('Current server entitlement required.');
+  const runtime=createUpdateRuntime({root,origin,readContext:()=>({actor:{account:session.account_id,device:session.device_id,origin},runs:[],directTasks:[],localTasks:[]}),listRecords:()=>listRecords(join(root,'delivery-hooks'))});
+  // Reconciliation reads exact results or retained fences. It never resumes a task.
+  const coordinator=createUpdateCoordinator({store:runtime.store,gate:runtime.gate,boundary:runtime.boundary,reconcile:runtime.reconcile,initialState:'recovery_required'});
+  if(digest(await readSession(origin,root))!==digest(session))throw Error('Device connection changed.');
+  return await coordinator.reconnect();
+ } finally {await lock.release();}
+}

package/src/update-detachment/runtime.js

@@ -6,7 +6,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { readFile, lstat, readlink, realpath } from 'node:fs/promises';
 import { atomicSave, readState, digest, withLock } from './state-store.js';
-import { readDispatchGate, adoptHookOwner, DISPATCH_PROTOCOL, confirmDispatch, flushDispatchIntake, readTaskAdmission } from './dispatch-gate.js';
+import { readDispatchGate, unresolvedDispatchAttempts, adoptHookOwner, DISPATCH_PROTOCOL, confirmDispatch, flushDispatchIntake, readTaskAdmission } from './dispatch-gate.js';
 import { createLedgerCoordinatorAdapters } from './ledger-adapter.js';
 import { listDispatchRegistrations, normalizeDispatchIdentity } from './provenance.js';
 import { reconcileSession } from './reconcile.js';
@@ -182,7 +182,7 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
       confirmDispatch({root,attemptId:attempt.id});
     }
     ledger=readDispatchGate(root);
-    const unresolved=Object.values(ledger.attempts).filter(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id && attempt.taskHash===digest(task.taskId) && attempt.identityHash===digest(task.identity) && attempt.generation===task.generation));
+    const unresolved=unresolvedDispatchAttempts(ledger).filter(attempt=> !workers.some(task=>task.handle.attemptId===attempt.id && attempt.taskHash===digest(task.taskId) && attempt.identityHash===digest(task.identity) && attempt.generation===task.generation));
     if(unresolved.length)return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
     const currentGate=readDispatchGate(root);
     if(currentGate.connection!=='detaching' || currentGate.generation!==startingGate.generation)throw failure('boundary_owner_changed');
@@ -194,7 +194,7 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
   const reconcile=async()=> {
     const actor=context().actor, assessments=[];
     const workers=(transaction?.tasks || []).filter(task=>task.handle);
-    if(Object.values(readDispatchGate(root).attempts).some(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id)))return {verified:false,unresolvedAttempts:1};
+    if(unresolvedDispatchAttempts(readDispatchGate(root)).some(attempt=> !workers.some(task=>task.handle.attemptId===attempt.id)))return {verified:false,unresolvedAttempts:1};
     for (const task of transaction?.tasks || []) {
       if(task.handle) {
         if(actor?.account!==task.identity.account || actor?.origin!==task.identity.origin || actor?.device!==task.identity.device || task.identity.root!==root)return {verified:false,unresolvedAttempts:1};

package/src/web-origin.js

@@ -44,3 +44,10 @@ export function isRequestOriginAllowed(requestOrigin, webOrigin) {
     return false;
   }
 }
+
+// Explicitly retain the resolved host when a command is copied to a fresh shell.
+export function daemonRestartCommand(webOrigin) {
+  const origin = resolveWebOrigin(webOrigin);
+  const quotedOrigin = '"' + origin.replace(/["\\$`]/g, "\\$&") + '"';
+  return `simy --daemon --host ${quotedOrigin}`;
+}