@awak-app/simy-cli 0.7.22 → 0.7.25

package/README.md

@@ -1,5 +1,18 @@
 # SIMY CLI
 
+**Copy connection URL / 接続用URLをコピー** copies the current SIMY authentication
+link, including its pending organization selection. It is available while waiting
+for the browser and in settings. Paste it into Chrome if automatic opening fails.
+**Copy workspace URL** continues to copy only the Web workspace address.
+This signs the desktop into SIMY; browser automation uses its own provider connection.
+
+Technical coding failures retain their task and retry after a persisted 5–30 minute
+cooldown. Automatic recovery preserves the original goal, usage limits, provider
+connection and explicit stops. Enabling automatic continuation can also adopt an
+ordinary loop waiting for an external dependency, starting with read-only inspection.
+A damaged provider-link file can be repaired by **Connect SIMY** for that provider;
+the original file is retained and the other provider stays disconnected.
+
 ### Experimental delegated approval and input bridge
 
 `simy delivery interactions proxy --policy-file /absolute/private/policy.json`
@@ -93,17 +106,15 @@ Both providers share one analysis deadline. A deterministic provider failure pau
 new claims and retains failed history until environment/settings change or **Retry
 analysis** is selected.
 
-After **6 consecutive SQM analysis failures**, this machine stops claiming new
-SQM analyses for the current Web/account/organization. Codex and Claude share the
-counter; a completed analysis resets it. Empty polls and user cancellations do
-not change it. The pause and partial failure count survive restart, sign-in and
-provider changes. A review interrupted by a host exit counts once on restart;
-graceful cancellation clears that unfinished marker without changing the count.
-Reconnecting or selecting Retry cannot clear this pause.
-Installing and running a **newer SIMY version** resets the counter and resumes
-claims automatically, subject to normal organization access and analysis settings.
-The native organization menu shows when an update is required. This pause does
-not change server analysis consent or stop ordinary implementation tasks.
+After **6 consecutive SQM analysis failures**, this machine waits before its next
+SQM claim for the current Web/account/organization. Codex and Claude share the
+counter; a completed analysis resets it. The cooldown increases from 5 to 30
+minutes and survives restart. Empty polls and reconnects do not reset failures.
+Retries resume automatically while analysis and the provider connection remain
+enabled. Authentication requiring the account holder remains a sign-in wait.
+The server's durable recovery migration requeues the same failed job and retains
+its input, history and attempt count; it is required to recover jobs previously
+held by the server's lifetime retry cap.
 
 Agentic Loop preflight accepts the task's existing requirement, acceptance
 criteria, required checks and charter context alongside the repository/provider.
@@ -1020,12 +1031,15 @@ records cannot be recovered.
 History remains visible with local analysis off and after restarting. A saved
 in-flight analysis is shown as Interrupted until this client claims it again;
 it does not contribute to the running count. The web workspace owns retry status.
-Model/provider execution failures permit one recovery claim after a five-minute
-cooldown, even when the app/account identity is unchanged. If that attempt fails
-again, the pause survives reconnects and host restarts until a newer SIMY version
-is installed. Sign-in, local installation, SIMY access, schema and persistence
-errors do not open this automatic provider recovery path. The existing six-failure
-circuit still protects other analysis failures.
+Model/provider execution failures permit a recovery claim after a five-minute
+cooldown, even when the app/account identity is unchanged. Repeated provider
+failures or six consecutive analysis failures schedule further automatic recovery
+with a persisted 5–30 minute backoff. Reconnects, restarts, empty claims and
+cancelled work do not reset the failure counters or cooldown. Only a successful
+review or a newer SIMY version clears the circuit. Authentication interaction,
+local installation, SIMY access and persistence requirements remain enforced;
+waiting does not grant permission. Turning analysis off or disconnecting its
+provider still prevents new work.
 
 Only summary metadata is retained, without analysis prompts, source inputs,
 model responses or credentials. Historical summaries are not a replacement for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.22",
+  "version": "0.7.25",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
   ],
   "scripts": {
     "start": "node ./src/index.js",
-    "test": "node --test --test-concurrency=2",
+    "test": "node --import ./test/isolate-simy-home.mjs --test --test-concurrency=2",
     "test:e2e:console": "node ./scripts/console-e2e.js",
     "test:e2e:work-activity": "node ./scripts/work-activity-e2e.js",
     "test:e2e:sqm-complete-loop": "node ./scripts/sqm-complete-loop-e2e.js",

package/src/agent.js

@@ -1,3 +1,4 @@
+import { connectionOverview, readSqmConnectionObservation } from './connection-overview.js';
 import { readLocalPhotoSource } from "./local-photos.js";
 import { resolveLocalTaskDestination, saveLocalTaskDestination } from "./local-task-destination.js";
 import { observePairedNativeIdentities } from './native-provider-identity.js';
@@ -18,6 +19,7 @@ import { createDesktopAccessPolicy, desktopAccessReady, requireDesktopAccess } f
 import { readSqmEnabled, writeSqmEnabled, readSqmSettings, writeSqmEngineFallback } from "./desktop-sqm-settings.js";
 import { createServer } from "node:http";
 import { createHash, randomBytes } from "node:crypto";
+import { canRecoverCodingRun, codingRecoveryDue, codingRecoveryLinksMatch } from './coding-run-automatic-recovery.js';
 import { createReadStream } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
@@ -35,6 +37,7 @@ import {
   prepareLocalCodingRunRecovery,
   reconcileLocalCodingRun,
   recoverCompletedLocalCodingRun,
+  recoverLocalCodingRun,
   queueLocalCodingGuidance,
   recheckLocalCodingRun,
   publishRestoredLocalCodingRun,
@@ -545,7 +548,7 @@ export async function startAgent({
     return inspection;
   };
 
-  const requireRunProvider = async (run, { backend = run.request.backend } = {}) => {
+  const requireRunProvider = async (run, { backend = run.request.backend, automatic = false } = {}) => {
     const scope = await authorizeDesktopWork();
     const inspection = await inspectReadyBackend(backend, { force: true });
     await authorizeDesktopWork(scope);
@@ -555,18 +558,19 @@ export async function startAgent({
         code: `desktop_executor_${inspection.status}`,
       });
     }
-    await bindRunAuthorization(run, scope, inspection, backend);
+    await bindRunAuthorization(run, scope, inspection, backend, !automatic);
   };
 
   const authorizeProviderDispatch = async (backend, scope, link) => {
     await authorizeDesktopWork(scope);
     await requireLinkedProvider(backend, link);
   };
-  const bindRunAuthorization = async (run, scope, inspection, backend = run.request.backend) => {
+  const bindRunAuthorization = async (run, scope, inspection, backend = run.request.backend, rememberConnection = true) => {
     const links = await readProviderLinks(sessionRoot);
     links[backend] = inspectedLinks.get(inspection);
     await authorizeProviderDispatch(backend, scope, links[backend]);
     runAuthorizations.set(run, { scope, links });
+    if (rememberConnection) run.snapshot.metadata.provider_link_epochs = Object.fromEntries(Object.entries(links).map(([provider, link]) => [provider, link.epoch]));
   };
   const providerRuntimeOptions = (task, options = {}, scope, link) => {
     const guard = () => authorizeProviderDispatch(task.backend, scope, link);
@@ -868,13 +872,29 @@ export async function startAgent({
     }
   };
 
+  const automaticCodingRecoveries = new WeakSet();
   const monitorCodingRuns = () => {
     if (!desktopWorkAllowed()) return Promise.resolve();
-    if (!daemon || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve();
+    if (!isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve();
     if (codingRunMonitorInFlight) return codingRunMonitorInFlight;
     codingRunMonitorInFlight = (async () => {
       for (const run of registry.list()) {
-        if (!["pr_ready_for_review", "merge_ready"].includes(run.status) || run.operation || run.child) continue;
+        if (canRecoverCodingRun(run) && !automaticCodingRecoveries.has(run) && (!run.snapshot.metadata?.automatic_recovery || codingRecoveryDue(run))) {
+          automaticCodingRecoveries.add(run);
+          void withUpdateWork(updateManager, async () => {
+            if (!sameRunScope(run.session, session) || run.apiOrigin !== apiOrigin) return;
+            const saved = { charter: run.snapshot.charter, metadata: { ...run.snapshot.metadata } };
+            if (!codingRecoveryLinksMatch(saved, await readProviderLinks(sessionRoot))) return;
+            await requireRunProvider(run, { automatic: true });
+            if (!codingRecoveryLinksMatch(saved, await readProviderLinks(sessionRoot))) return;
+            // Each run owns its operation promise; a slow repair must not
+            // prevent the monitor from advancing independent tasks.
+            await recoverLocalCodingRun(run, codingRuntimeOptions(run));
+          }).catch(error => reportStartupConnectionError(error, quiet))
+            .finally(() => automaticCodingRecoveries.delete(run));
+          continue;
+        }
+        if (!daemon || !["pr_ready_for_review", "merge_ready"].includes(run.status) || run.operation || run.child) continue;
         try {
           await (dependencies.recheckCodingRun || recheckAuthorizedCodingRun)(run);
         } catch (error) {
@@ -887,7 +907,7 @@ export async function startAgent({
 
   const startCodingRunMonitor = () => {
     if (!desktopWorkAllowed()) return;
-    if (!daemon || codingRunMonitorTimer) return;
+    if (codingRunMonitorTimer) return;
     codingRunMonitorTimer = setInterval(() => {
       void monitorCodingRuns().catch((error) => reportStartupConnectionError(error, quiet));
     }, dependencies.codingRunMonitorIntervalMs || CODING_RUN_MONITOR_INTERVAL_MS);
@@ -1140,6 +1160,7 @@ export async function startAgent({
       getHistoryScope: () => sqmHistoryScope(apiOrigin, session),
       getRecoveryKey: (provider) => providerRecoveryRevisions[provider] ?? 0,
       recordHistory: (scope, item) => sqmHistory.record(scope, item),
+      readHistory: scope => sqmHistory.items(scope),
       onHistoryError: () => { if (!quiet) console.error("Could not save the local SQM analysis history."); },
       getProvider: () => !desktopWorkAllowed() || availableCapabilities?.features?.sqm_local_review !== true ? null : ["codex", "claude"].find(
         (provider) => providerLinks[provider]?.connected === true && availableCapabilities?.backends?.[provider] === true &&
@@ -1197,7 +1218,7 @@ export async function startAgent({
 
       if (req.method === "GET" && url.pathname === "/v1/auth/browser") {
         if (req.headers.host !== `127.0.0.1:${port}`) { json(res, 403, { error: "Invalid local host." }); return; }
-        const page = browserHandoffPage();
+        const page = browserHandoffPage(apiOrigin);
         res.writeHead(200, page.headers).end(page.html);
         return;
       }
@@ -1496,6 +1517,7 @@ export async function startAgent({
           const previousSession = session ?? reclaimableSession;
           const authorizedSession = {
             token: String(body.token || ""),
+            email: typeof body.email === "string" && body.email.length <= 254 ? body.email : null,
             device_id: typeof body.device_id === "string" ? body.device_id : null,
             api_origin: apiOrigin,
             api_base_url: apiBaseUrl,
@@ -2353,7 +2375,7 @@ export async function startAgent({
               : [],
             required_checks: Array.isArray(body.required_checks) ? body.required_checks : [],
             independent_review_required: body.independent_review_required === true,
-            require_human_approval: body.require_human_approval !== false,
+            require_human_approval: body.require_human_approval === true,
             design_summary:
               typeof body.design_summary === "string" ? body.design_summary : "",
             design_review_approved_by:
@@ -2837,8 +2859,21 @@ export async function startAgent({
     const { codex, claude } = deferStartupSynchronization
       ? providerStatuses
       : await readProviderStatuses();
+    const overviewSession = session;
+    const overviewAccess = desktopAccess.snapshot();
+    let overviewSqm = { state: 'unknown' };
+    if (auth.state === 'signed_in' && !pendingOrganization) {
+      try { overviewSqm = await readSqmConnectionObservation({ endpoint: process.env.SIMY_SQM_BUNDLE_URL?.trim() || new URL('sqm/knowledge-bundle', resolveWebApiBaseUrl(apiOrigin, overviewSession?.api_base_url)).href,
+        accountId: overviewSession?.account_id || overviewSession?.auth_user_id || overviewSession?.device_id,
+        organizationId: overviewSession?.organization_id || overviewSession?.org_id }, { root: process.env.SIMY_SQM_CACHE_DIR || join(sessionRoot, 'sqm') }); } catch { /* A missing endpoint must not block the status frame. */ }
+    }
+    // An organization switch/sign-out while reading local metadata must not
+    // publish an old tenant's identity or SQM result in a fresh frame.
+    const overview = connectionOverview({ webOrigin: apiOrigin, session, access: session === overviewSession ? overviewAccess : null,
+      signedIn: session === overviewSession && auth.state === 'signed_in', switching: Boolean(pendingOrganization), sqm: overviewSqm });
     return {
       schemaVersion: 1,
+      connectionOverview: overview,
       sampledAt: new Date().toISOString(),
       version: CLI_VERSION,
       webOrigin: apiOrigin,
@@ -3049,7 +3084,7 @@ export async function startAgent({
           expected_tests: [],
           expected_evidence: [],
           required_checks: [],
-          require_human_approval: true,
+          require_human_approval: input.require_human_approval === true,
           must_not: [],
           attachments: await referenceLocalAttachmentPaths(input.attachmentPaths || []),
         };

package/src/auto-update.js

@@ -15,6 +15,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
+import { daemonRestartCommand } from "./web-origin.js";
 import { openExternalUrl } from "./browser.js";
 import {
   installMacosInstallerRelease,
@@ -1094,7 +1095,7 @@ export function autoUpdateHelpText({ installMode = null, webOrigin = null } = {}
   return [
     "Recommended installation (enables verified CLI auto-update):",
     `  npm install -g ${CLI_PACKAGE_NAME}`,
-    "  simy --daemon",
+    `  ${daemonRestartCommand(webOrigin)}`,
   ].join("\n");
 }
 
@@ -1131,7 +1132,7 @@ export function updateAction(version, { installMode = "global_npm", webOrigin }
   return {
     id: "install_global_cli",
     label: "Install and restart SIMY",
-    command: `npm install -g ${CLI_PACKAGE_NAME}@${version} && simy --daemon`,
+    command: `npm install -g ${CLI_PACKAGE_NAME}@${version} && ${daemonRestartCommand(webOrigin)}`,
   };
 }
 

package/src/browser-handoff.js

@@ -1,3 +1,4 @@
+import { normalizeWebOrigin } from "./web-origin.js";
 import { createDecipheriv, createHash } from "node:crypto";
 
 export const BROWSER_HANDOFF_TRANSPORT = "loopback_redirect_v1";
@@ -33,6 +34,14 @@ const copy = ja ? {
 };
 document.documentElement.lang = ja ? 'ja' : 'en';
 const title = document.getElementById('title'), message = document.getElementById('message');
+const environment = document.getElementById('environment');
+const origin = environment.dataset.origin;
+const host = new URL(origin).hostname;
+const label = origin === 'https://app.simy.one' ? (ja ? '本番' : 'Production')
+  : origin === 'https://app-dev.simy.one' ? (ja ? '開発' : 'Development')
+  : ['localhost', '127.0.0.1', '[::1]'].includes(host) ? (ja ? 'ローカル開発' : 'Local development')
+  : (ja ? 'カスタムホスト' : 'Custom host');
+environment.textContent = (ja ? '接続先環境' : 'Connection environment') + ': ' + label + ' · ' + origin;
 title.textContent = copy.title; message.textContent = copy.waiting;
 const handoff = new URLSearchParams(location.hash.slice(1)).get('handoff');
 history.replaceState(null, '', location.pathname);
@@ -54,15 +63,17 @@ history.replaceState(null, '', location.pathname);
 
 // A self-contained local page: credentials never enter the URL query, HTTP
 // request, history or third-party resources. Only the encrypted fragment does.
-const style = `:root{color-scheme:light dark;--bg:#ffffff;--card:#f6f5f4;--ink:#0d0d0d;--muted:#615d59;--line:#e6e6e6;--accent:#0075de} @media(prefers-color-scheme:dark){:root{--bg:#1a1918;--card:#252320;--ink:#f5f3f0;--muted:#b8b3ad;--line:#31302f;--accent:#3b9eff}}*{box-sizing:border-box}body{margin:0;min-height:100dvh;display:grid;place-items:center;padding:24px;background:var(--bg);color:var(--ink);font:16px/1.5 system-ui,sans-serif}main{max-width:480px;width:100%;padding:32px;border:1px solid var(--line);border-radius:12px;background:var(--card)}.brand{color:var(--accent);font-weight:600;font-size:14px}h1{font-size:24px;font-weight:600;margin:16px 0}p{color:var(--muted);margin:0}body[data-state=failed] h1{color:var(--ink)}`;
+const style = `:root{color-scheme:light dark;--bg:#ffffff;--card:#f6f5f4;--ink:#0d0d0d;--muted:#615d59;--line:#e6e6e6;--accent:#0075de} @media(prefers-color-scheme:dark){:root{--bg:#1a1918;--card:#252320;--ink:#f5f3f0;--muted:#b8b3ad;--line:#31302f;--accent:#3b9eff}}*{box-sizing:border-box}body{margin:0;min-height:100dvh;display:grid;place-items:center;padding:24px;background:var(--bg);color:var(--ink);font:16px/1.5 system-ui,sans-serif}main{max-width:480px;width:100%;padding:32px;border:1px solid var(--line);border-radius:12px;background:var(--card)}.brand{color:var(--accent);font-weight:600;font-size:14px}h1{font-size:24px;font-weight:600;margin:16px 0}p{color:var(--muted);margin:0}#environment{margin-top:16px;font-size:14px;overflow-wrap:anywhere}body[data-state=failed] h1{color:var(--ink)}`;
 const hash = value => createHash("sha256").update(value).digest("base64");
-export function browserHandoffPage() {
+export function browserHandoffPage(webOrigin) {
+  const origin = normalizeWebOrigin(webOrigin);
+  const escapedOrigin = origin.replace(/[&<>"']/g, value => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[value]);
   return {
     headers: {
       "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store",
       "Referrer-Policy": "no-referrer", "X-Content-Type-Options": "nosniff",
       "Content-Security-Policy": `default-src 'none'; script-src 'sha256-${hash(script)}'; style-src 'sha256-${hash(style)}'; connect-src 'self'; img-src data:; frame-ancestors 'none'; base-uri 'none'; form-action 'none'`,
     },
-    html: `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>SIMY connection</title><link rel="icon" href="data:,"><style>${style}</style></head><body><main aria-live="polite" aria-atomic="true"><div class="brand">SIMY</div><h1 id="title">Connecting to SIMY</h1><p id="message">Keep SIMY open while connecting.</p><noscript>JavaScript is required. Return to SIMY and reconnect using a browser with JavaScript enabled.</noscript></main><script>${script}</script></body></html>`,
+    html: `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>SIMY connection</title><link rel="icon" href="data:,"><style>${style}</style></head><body><main aria-live="polite" aria-atomic="true"><div class="brand">SIMY</div><h1 id="title">Connecting to SIMY</h1><p id="message">Keep SIMY open while connecting.</p><p id="environment" data-origin="${escapedOrigin}">Connection environment: ${escapedOrigin}</p><noscript>JavaScript is required. Return to SIMY and reconnect using a browser with JavaScript enabled.</noscript></main><script>${script}</script></body></html>`,
   };
 }

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.22";
+export const CLI_VERSION = "0.7.25";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -118,7 +118,9 @@ const text = (value, max = 4000) => typeof value === 'string' ? value.trim().sli
 const exactText = value => typeof value === 'string' && Buffer.byteLength(value, 'utf8') <= 1000 ? value : null;
 export function canUpgradeDelivery(run) {
   return Boolean(run && !run.managed && text(run.id) && text(run.objective) && Number.isFinite(run.startedAt) &&
-    Number.isSafeInteger(run.maxFailures) && run.maxFailures > 0 && ['active', 'paused', 'recovery_required'].includes(run.state));
+    Number.isSafeInteger(run.maxFailures) && run.maxFailures > 0 &&
+    (['active', 'paused', 'recovery_required'].includes(run.state) ||
+      run.state === 'blocked' && run.blocker === 'external_dependency'));
 }
 const contextText = (value, max = 500) => text(value, max).replace(/\b(?:sk|key)-[A-Za-z0-9_-]{12,}\b|\bBearer\s+\S+|\b(?:password|token|api[_-]?key)\s*[:=]\s*\S+/gi, '[redacted]');
 export function recordPath(root, provider, session) {

package/src/codex-plugins/simy/hooks/outcome-progress.mjs

@@ -17,7 +17,7 @@ function classifyBlockers(findings) {
     const kind = ["machine", "human", "external"].includes(finding.blocker_kind)
       ? finding.blocker_kind
       : finding.repairability === "external" ? "external"
-      : finding.repairability === "manual" ? "human" : "machine";
+      : "machine";
     blockers[kind].push({
       code: text(finding.code) || "OUTCOME_UNPROVEN",
       target: text(finding.target) || null,

package/src/codex-plugins/simy/hooks/update-dispatch-gate.mjs

@@ -11,9 +11,10 @@ export const detachmentRoot = () => resolve(process.env.SIMY_HOME?.trim() || joi
 export const rootFromDelivery = root => basename(resolve(root)) === 'delivery-hooks' ? dirname(resolve(root)) : resolve(root);
 const path = root => join(resolve(root), 'update-detachment', 'gate.json');
 function read(root) {
-  const state = readState(path(root), { versions: [1, 2] }) || { schemaVersion: 1, revision: 0, generation: 0, connection: 'connected', attempts: {}, receipts: {}, events: {} };
+  const state = readState(path(root), { versions: [1, 2, 3] }) || { schemaVersion: 1, revision: 0, generation: 0, connection: 'connected', attempts: {}, receipts: {}, events: {} };
   if (!Number.isSafeInteger(state.generation) || !Number.isSafeInteger(state.revision) || !CONNECTION_STATES.includes(state.connection) || !['attempts', 'receipts', 'events'].every(key => isMap(state[key])) || (state.hookOwners !== undefined && !isMap(state.hookOwners)) || !Object.values(state.attempts).every(attempt => isMap(attempt) && typeof attempt.id === 'string' && Number.isSafeInteger(attempt.generation) && ['intent','sending','sent','provider_identified','result_saved','confirmed'].includes(attempt.phase))) fail('invalid_state');
-  if ((state.schemaVersion === 2 && ![2, 3].includes(state.minimumDispatchProtocol)) || (state.minimumDispatchProtocol !== undefined && ![2, 3].includes(state.minimumDispatchProtocol))) fail('writer_protocol_incompatible');
+  if ((state.schemaVersion >= 2 && ![2, 3].includes(state.minimumDispatchProtocol)) || (state.minimumDispatchProtocol !== undefined && ![2, 3].includes(state.minimumDispatchProtocol))) fail('writer_protocol_incompatible');
+  validateRecoveryFences(state);
   validateTaskFences(state, root);
   return state;
 }
@@ -31,7 +32,7 @@ export function transitionConnection({ root = detachmentRoot(), expectedRevision
     if (state.revision !== expectedRevision) fail('revision_conflict');
     const allowed = { connected: ['detaching'], ready: ['connected', 'detaching'], detaching: ['detached', 'recovery_required'], detached: ['reconciling'], reconciling: ['ready', 'recovery_required'], recovery_required: ['reconciling', 'detaching'] };
     if (!allowed[state.connection]?.includes(connection)) fail('invalid_transition');
-    if (connection === 'detaching') { state.generation++; state.schemaVersion = 2; state.minimumDispatchProtocol = DISPATCH_PROTOCOL; }
+    if (connection === 'detaching') { state.generation++; state.schemaVersion = Math.max(2, state.schemaVersion); state.minimumDispatchProtocol = DISPATCH_PROTOCOL; }
     state.connection = connection; state.revision++;
     if (eventId) state.events[digest(eventId)] = { revision: state.revision };
     atomicSave(path(root), state); return state;
@@ -221,7 +222,7 @@ export function prepareUpgradeFence({ root = detachmentRoot(), expectedRevision,
     const state = read(root); validateWriters(state, writers);
     if (state.revision !== expectedRevision) fail('revision_conflict');
     if (!['connected', 'ready', 'recovery_required'].includes(state.connection)) fail('invalid_transition');
-    state.generation++; state.schemaVersion = 2; state.minimumDispatchProtocol = DISPATCH_PROTOCOL;
+    state.generation++; state.schemaVersion = Math.max(2, state.schemaVersion); state.minimumDispatchProtocol = DISPATCH_PROTOCOL;
     state.connection = 'detaching'; state.revision++; atomicSave(path(root), state); return state;
   });
 }
@@ -252,6 +253,12 @@ function validateTaskFences(state, root) {
   }
 }
 function assertTaskAdmissionState(state, { taskId, identity = null }) {
+  for (const item of Object.values(state.recoveryFences?.items || {})) {
+    if (item.taskHash === digest(taskId) || identity && (item.identityHash === digest(identity) ||
+      item.sessions.some(target => target.provider === identity.provider && target.session === identity.session))) {
+      fail('dispatch_history_quarantined');
+    }
+  }
   const records = state.taskFences?.records || {};
   if (!identity) {
     if (Object.values(records).some(item => item.taskId === taskId)) fail('task_admission_identity_required');
@@ -276,7 +283,9 @@ export function readTaskAdmission({ root = detachmentRoot(), identity, taskId })
   identity = storedFenceIdentity(identity, root);
   if (identity.root !== realpathSync(root)) fail('identity_root_mismatch');
   const state = read(root), record = state.taskFences?.records[fenceKey(identity, taskId)] || null;
-  return { revision: state.revision, generation: state.generation, record, canResume: ['connected', 'ready'].includes(state.connection) && (!record || record.status === 'admitted' && record.generation === state.generation && admissionWriterMatches(state, record)) };
+  let historyAdmitted = true;
+  try { assertTaskAdmissionState(state, {taskId, identity}); } catch (error) { if (error.code !== 'dispatch_history_quarantined' && error.code !== 'task_admission_blocked') throw error; historyAdmitted = false; }
+  return { revision: state.revision, generation: state.generation, record, canResume: historyAdmitted && ['connected', 'ready'].includes(state.connection) && (!record || record.status === 'admitted' && record.generation === state.generation && admissionWriterMatches(state, record)) };
 }
 function checkAdmissionOwner(state, owner, identity, taskId, expectedRevision) {
   if (!owner || owner.root !== identity.root || owner.protocol !== DISPATCH_PROTOCOL || owner.generation !== state.generation) fail('owner_fenced');
@@ -295,7 +304,7 @@ export function setTaskAdmissionFence({ owner, identity, taskId, expectedRevisio
     state.taskFences ||= { version: 1, records: {} };
     state.taskFences.records[key] = { version: 1, identity, identityHash: digest(identity), taskId, taskHash: digest(taskId), generation: state.generation, revision: (previous?.revision || 0) + 1, status: 'blocked', reason: { ...reason }, createdAt: Date.now(), admission: null };
     // v2 writers validate minimumDispatchProtocol and cannot ignore taskFences.
-    state.schemaVersion = 2; state.minimumDispatchProtocol = 3; state.revision++;
+    state.schemaVersion = Math.max(2, state.schemaVersion); state.minimumDispatchProtocol = 3; state.revision++;
     atomicSave(path(identity.root), state); return state;
   });
 }
@@ -324,3 +333,77 @@ export async function admitTaskDispatch({ owner, identity, taskId, expectedRevis
     atomicSave(path(identity.root), state); return state;
   } finally { release(); }
 }
+
+// Historical evidence without a provable result is retained, never replayed or
+// called completed. A schema fence makes every pre-recovery binary fail closed.
+function validateRecoveryFences(state) {
+  if (state.schemaVersion !== 3 && state.recoveryFences === undefined) return;
+  const recovery = state.recoveryFences;
+  if (state.schemaVersion !== 3 || !recovery || recovery.version !== 1 || !isMap(recovery.items) ||
+      typeof recovery.auditRef !== 'string' || !/^[a-f0-9]{64}$/.test(recovery.auditDigest || '')) fail('recovery_fence_invalid');
+  for (const [key, item] of Object.entries(recovery.items)) {
+    const attempt = state.attempts[key];
+    if (!attempt || item.taskHash !== attempt.taskHash || item.identityHash !== attempt.identityHash ||
+        !/^[a-f0-9]{64}$/.test(item.attemptDigest || '') || !Array.isArray(item.sessions) ||
+        item.sessions.some(target => !['codex','claude'].includes(target.provider) || typeof target.session !== 'string' || !target.session)) fail('recovery_fence_invalid');
+  }
+}
+export function unresolvedDispatchAttempts(state) {
+  return Object.entries(state.attempts).filter(([key, attempt]) => attempt.phase !== 'confirmed' &&
+    state.recoveryFences?.items?.[key]?.attemptDigest !== digest(attempt)).map(([, attempt]) => attempt);
+}
+export function reconcileDispatchHistory({root = detachmentRoot(), expectedRevision, expectedGeneration, auditRef, auditDigest}) {
+  // Exclude a live update/reconnect owner as well as simultaneous dispatches.
+  const release = acquireLock(join(root, 'update-detachment', 'coordinator'));
+  try { return withLock(path(root), () => {
+    const state = read(root);
+    if (state.revision !== expectedRevision || state.generation !== expectedGeneration) fail('revision_conflict');
+    if (state.connection !== 'recovery_required') fail('reconciliation_required');
+    const auditPath = resolve(auditRef || '');
+    if (!auditPath.startsWith(resolve(root, 'update-detachment', 'recovery') + '/') || realpathSync(auditPath) !== auditPath) fail('recovery_audit_invalid');
+    const bytes = readFileSync(auditPath);
+    if (createHash('sha256').update(bytes).digest('hex') !== auditDigest) fail('recovery_audit_changed');
+    const audit = JSON.parse(bytes);
+    if (audit.version !== 1 || audit.gateDigest !== digest(state) || !Array.isArray(audit.items) ||
+        audit.items.length !== Object.keys(state.attempts).length) fail('recovery_audit_invalid');
+    const items = {}, seen = new Set(), settled = [];
+    for (const item of audit.items) {
+      const key = digest(item.attemptId), attempt = state.attempts[key];
+      if (!attempt || seen.has(key) || item.attemptDigest !== digest(attempt)) fail('recovery_attempt_changed');
+      seen.add(key);
+      if (item.disposition === 'already_confirmed' && attempt.phase === 'confirmed') continue;
+      if (item.disposition === 'saved_terminal_result') {
+        const evidence = item.evidence;
+        if (!evidence || !attempt.provenance || evidence.ref !== attempt.provenance.recordRef ||
+            !Object.values(state.receipts).some(receipt => receipt.attemptId === attempt.id && receipt.generation === attempt.generation && receipt.resultRef === evidence.ref)) fail('recovery_result_unbound');
+        if (!resolve(evidence.ref).startsWith(resolve(root, 'direct-tasks') + '/') || realpathSync(evidence.ref) !== evidence.ref) fail('recovery_result_scope');
+        const source = readFileSync(evidence.ref);
+        if (createHash('sha256').update(source).digest('hex') !== evidence.sha256) fail('recovery_result_changed');
+        const result = JSON.parse(source), match = /^(.*):provider:([1-9][0-9]*)$/.exec(attempt.id);
+        if (!match || result.id !== match[1] || digest(result.id) !== attempt.taskHash ||
+            result.id !== attempt.provenance.taskId || result.invocation_count !== Number(match[2]) ||
+            !['succeeded','failed','stopped'].includes(result.status)) fail('recovery_result_unbound');
+        settled.push(attempt);
+      } else if (item.disposition === 'retain_blocked_unknown') {
+        const sessions = [];
+        if (attempt.provenance?.providerSession) sessions.push({provider:attempt.provenance.context.provider,session:attempt.provenance.providerSession});
+        // Recover the parent identity only from its original canonical record.
+        const ref = attempt.provenance?.recordRef;
+        if (ref?.startsWith(resolve(root, 'delivery-hooks') + '/')) {
+          try { const record = JSON.parse(readFileSync(ref));
+            if (record.run?.managed?.taskId === attempt.provenance.taskId && record.provider === attempt.provenance.context.provider &&
+                basename(ref) === createHash('sha256').update(record.provider + '\0' + record.session).digest('hex') + '.json') sessions.push({provider:record.provider,session:record.session});
+          } catch { /* Missing parent never authorizes an inferred identity. */ }
+        }
+        items[key] = {taskHash:attempt.taskHash,identityHash:attempt.identityHash,attemptDigest:digest(attempt),sessions};
+      } else fail('recovery_disposition_invalid');
+    }
+    for (const attempt of settled) attempt.phase = 'confirmed';
+    state.schemaVersion = 3; state.minimumDispatchProtocol = 3;
+    state.generation++; state.revision++;
+    state.recoveryFences = {version:1,auditRef:auditPath,auditDigest,items};
+    validateRecoveryFences(state);
+    atomicSave(path(root), state);
+    return {settled:settled.length,blocked:Object.keys(items).length,revision:state.revision,generation:state.generation,replayAttempts:false};
+  }); } finally { release(); }
+}

package/src/coding-run-automatic-recovery.js

@@ -0,0 +1,40 @@
+import { budgetState } from './orchestrator/budget.js';
+
+const BASE_DELAY = 5 * 60_000;
+const MAX_DELAY = 30 * 60_000;
+const MACHINE_STOPS = new Set(['outcome_progress_stalled', 'retry_circuit_open']);
+
+export function canRecoverCodingRun(run) {
+  const snapshot = run.snapshot;
+  return run.status === 'blocked' && !run.stopRequested &&
+    !['paused', 'stopped', 'stopping'].includes(run.controlState) &&
+    !snapshot.metadata?.local_stop_requested && !run.operation && !run.child &&
+    snapshot.final_audit?.requires_human === false &&
+    MACHINE_STOPS.has(snapshot.events?.at(-1)?.detail?.code) &&
+    !budgetState(snapshot).exhausted;
+}
+
+export function scheduleCodingRecovery(snapshot, now = Date.now()) {
+  const count = (snapshot.metadata?.automatic_recovery?.count || 0) + 1;
+  snapshot.metadata ??= {};
+  snapshot.metadata.automatic_recovery = {
+    count,
+    next_retry_at: now + Math.min(MAX_DELAY, BASE_DELAY * 2 ** Math.min(count - 1, 3)),
+  };
+}
+
+export function codingRecoveryDue(run, now = Date.now()) {
+  return canRecoverCodingRun(run) &&
+    Number.isFinite(run.snapshot.metadata?.automatic_recovery?.next_retry_at) &&
+    now >= run.snapshot.metadata.automatic_recovery.next_retry_at;
+}
+
+export function codingRecoveryLinksMatch(snapshot, links) {
+  return [snapshot.charter.backend, snapshot.charter.audit_backend].filter(Boolean).every(provider => {
+    const link = links[provider];
+    const saved = snapshot.metadata?.provider_link_epochs;
+    return link?.connected === true && (saved && Object.hasOwn(saved, provider)
+      ? saved[provider] === link.epoch
+      : link.epoch === null && link.requiresConsent === false);
+  });
+}

package/src/connection-overview.js

@@ -0,0 +1,58 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { defaultSessionRoot } from './session-store.js';
+
+const safeText = (value, limit = 160) => typeof value === 'string' ? value.replace(/[\x00-\x1f\x7f]/g, '').slice(0, limit) : null;
+const scopeKey = ({ endpoint, accountId, organizationId }) => {
+  if (!endpoint || !accountId || !organizationId) return null;
+  try { const url = new URL(endpoint); url.username = ''; url.password = ''; url.search = ''; url.hash = '';
+    return createHash('sha256').update(JSON.stringify([url.href, accountId, organizationId])).digest('hex');
+  } catch { return null; }
+};
+const observationPath = (scope, root) => { const key = scopeKey(scope); return key ? join(root, 'connection-observations', `${key}.json`) : null; };
+
+// Only metadata of an actual online bundle lookup; never credentials, rules,
+// executable checks or inferred cross-organization registrations.
+export async function recordSqmConnectionObservation(scope, result, { root = process.env.SIMY_SQM_CACHE_DIR || join(defaultSessionRoot(), 'sqm'), now = Date.now() } = {}) {
+  const target = observationPath(scope, root);
+  if (!target || !['cloud', 'cache_revalidated', 'unavailable'].includes(result?.source)) return;
+  const bundle = result.bundle;
+  const verified = bundle?.organization_id === scope.organizationId && bundle?.system_scope?.organization_id === scope.organizationId;
+  const repository = safeText(scope.repository, 200);
+  if (!repository || !/^[^/\s]+\/[^/\s]+$/.test(repository)) return;
+  const value = { version: 1, state: verified ? 'verified' : 'unavailable', repository,
+    checkedAt: new Date(now).toISOString(), expiresAt: verified ? bundle.expires_at : null };
+  const temp = `${target}.${randomUUID()}.tmp`;
+  try { await mkdir(join(root, 'connection-observations'), { recursive: true, mode: 0o700 });
+    await writeFile(temp, JSON.stringify(value), { mode: 0o600 }); await rename(temp, target);
+  } finally { await rm(temp, { force: true }); }
+}
+
+export async function readSqmConnectionObservation(scope, { root = process.env.SIMY_SQM_CACHE_DIR || join(defaultSessionRoot(), 'sqm'), now = Date.now() } = {}) {
+  const target = observationPath(scope, root);
+  if (!target) return { state: 'unknown' };
+  try {
+    const raw = await readFile(target, 'utf8'); if (raw.length > 4096) return { state: 'unknown' };
+    const v = JSON.parse(raw), at = Date.parse(v.checkedAt);
+    if (v.version !== 1 || !['verified', 'unavailable'].includes(v.state) || !Number.isFinite(at) || at > now ||
+        typeof v.repository !== 'string' || !/^[^/\s]+\/[^/\s]+$/.test(v.repository) || v.repository.length > 200) return { state: 'unknown' };
+    const current = now - at <= 5 * 60 * 1000 && (v.state !== 'verified' || Date.parse(v.expiresAt) > now);
+    return { state: current ? v.state : 'previous', repository: safeText(v.repository, 200), checkedAt: v.checkedAt };
+  } catch { return { state: 'unknown' }; }
+}
+
+export function connectionEnvironment(origin) {
+  try { const url = new URL(origin); if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== '/') return { kind: 'unknown', origin: null };
+    return { kind: url.origin === 'https://app.simy.one' ? 'production' : url.origin === 'https://app-dev.simy.one' ? 'development' : 'custom', origin: url.origin };
+  } catch { return { kind: 'unknown', origin: null }; }
+}
+
+export function connectionOverview({ webOrigin, session, access, signedIn, switching, sqm, deviceName = hostname() }) {
+  const scopeReady = signedIn && !switching && session?.organization_id && access?.organizationId === session.organization_id && access?.state === 'ready';
+  return { device: { name: safeText(deviceName) || null }, environment: connectionEnvironment(webOrigin),
+    organization: { name: signedIn && access?.organizationId === session?.organization_id ? safeText(access?.organizationName) : null,
+      state: switching ? 'switching' : scopeReady ? 'ready' : 'unknown' },
+    sqm: scopeReady ? (sqm || { state: 'unknown' }) : { state: 'unknown' } };
+}

package/src/console/app.js

@@ -1147,6 +1147,7 @@ function statusLabel(run) {
   if (run.controlState === "stopping") return "Stopping";
   if (run.controlState === "stopped" || run.status === "stopped") return "Stopped";
   if (run.status === "pr_ready_for_review") return "PR ready · Review needed";
+  if (run.status === 'blocked' && run.snapshot?.final_audit?.requires_human === false) return 'Blocked';
   if (run.controlState === "waiting_human" || run.status === "waiting_human") {
     return "Waiting for you";
   }
@@ -1181,6 +1182,10 @@ function nextActionForRun(run, repositoryMissing = false) {
       text: "Review the final evidence and merge the pull request when ready.",
     };
   }
+  const latestRecovery = [...(run.snapshot?.events || [])].reverse().find(event => event.detail?.recovery)?.detail.recovery;
+  if (run.status === "blocked" && ['machine_recovery_pending', 'machine_recovery_exhausted'].includes(latestRecovery?.reason_code) && latestRecovery.requires_user_action === false) {
+    return { tone: latestRecovery.reason_code === 'machine_recovery_pending' ? 'yellow' : 'red', text: latestRecovery.user_message };
+  }
   if (run.controlState === "waiting_human" || run.status === "waiting_human") {
     return { tone: "yellow", text: "Press i, type your guidance or approval, then press Enter." };
   }