@awak-app/simy-cli 0.7.21 → 0.7.23

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`
@@ -60,6 +73,22 @@ Provider login is separate from model access; unverified model access remains
 files scoped to the Web/account/organization, rotate each writer's four 64 KiB
 segments, and keep lifetime failure counts after event rotation.
 
+Each AI app card separates **SIMY connection: on / stopped** from CLI, sign-in
+and plugin health. Disconnecting collapses those details and explains that SIMY
+monitoring and automatic continuation are stopped. Details can still be opened;
+reconnecting restores the item statuses. Plugin inspection failure never changes
+the connection setting or hides its disconnect action.
+
+Connection settings show **Repair automatically** beside a failed, missing or
+disabled SIMY plugin. Clicking it rechecks only that provider with a longer,
+bounded timeout; a missing or disabled managed plugin is installed or enabled,
+then its actual inventory is checked again. Success is shown only after that
+inventory confirms the plugin is enabled. Repair progress and failure reasons
+are displayed in the card; safe reason codes and elapsed times are saved in
+`$SIMY_HOME/logs/desktop-host.log`. Repair preserves SIMY connection consent,
+provider sign-in and native hook permissions. Project/managed settings and
+conflicting plugin sources require review instead of being overwritten.
+
 The desktop host continues sampling connection and access while optional
 conversation metadata is pending. It retains the last completed conversation
 metadata only within the same verified scope, clears it after access or account
@@ -77,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.
@@ -1004,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.21",
+  "version": "0.7.23",
   "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",
@@ -42,7 +42,7 @@
     "check:session-supervision-syntax": "node --check ./src/session-supervision/session-list.js && node --check ./src/console/sessions.js && node --check ./src/session-supervision/remote-hosts.js && node --check ./src/session-supervision/remote-entry.js && node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs && node --check ./src/session-supervision/purpose-instruction.js && node --check ./src/session-supervision/purpose-recovery.js && node --check ./src/session-supervision/purpose-candidate.js && node --check ./src/codex-plugins/simy/hooks/scene-reasoning.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-cycle.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-rule-review.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-search.mjs && node --check ./src/codex-plugins/simy/hooks/purpose-evidence.mjs && node --check ./src/session-supervision/purpose-observer.js && node --check ./src/session-supervision/purpose-verification.js && node --check ./src/codex-plugins/simy/hooks/purpose-workspace.mjs && node --check ./scripts/purpose-search-live-e2e.js",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
-    "check:sqm": "node --check ./src/sqm/advisory-guidance.js && node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/history-store.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
+    "check:sqm": "node --check ./src/sqm/provider-plugin-repair.js && node --check ./src/sqm/provider-plugin-status.js && node --check ./src/sqm/advisory-guidance.js && node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/history-store.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/claude-parity-runtime-e2e.js && node --check ./scripts/claude-plugin-runtime-e2e.js && node --check ./scripts/codex-plugin-runtime-e2e.js",
     "check:syntax": "node --check ./src/purpose-local-proof.js && node --check ./src/device-signing-identity.js && node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/connection-diagnostics.js && node --check ./src/launch-authorization.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/codex-plugins/simy/hooks/dev-work.mjs && node --check ./src/dev-work-events.js && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/login-shell-path.js && node --check ./src/hook-runtime.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js && node --check ./src/codex-plugins/simy/hooks/delivery-loop.mjs && node --check ./src/delivery-hooks/command.js && node --check ./src/delivery-hooks/desktop.js && node --check ./src/delivery-hooks/supervisor.js && node --check ./src/delivery-hooks/recovery.js && node --check ./src/delivery-hooks/supervisor-owner.js && node --check ./src/delivery-hooks/supervisor-watchdog.js && node --check ./src/delivery-hooks/supervisor-service.js && node --check ./scripts/supervisor-watchdog-live-e2e.js && node --check ./src/codex-plugins/simy/hooks/recovery-incident.mjs && node --check ./src/session-supervision/automatic-continuation.js && node --check ./src/session-supervision/stop-notifications.js",
     "check:package": "node ./scripts/check-package-contents.js",

package/src/agent.js

@@ -18,6 +18,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 +36,7 @@ import {
   prepareLocalCodingRunRecovery,
   reconcileLocalCodingRun,
   recoverCompletedLocalCodingRun,
+  recoverLocalCodingRun,
   queueLocalCodingGuidance,
   recheckLocalCodingRun,
   publishRestoredLocalCodingRun,
@@ -545,7 +547,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 +557,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 +871,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 +906,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 +1159,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 &&
@@ -2353,7 +2373,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:
@@ -3049,7 +3069,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/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.21";
+export const CLI_VERSION = "0.7.23";
 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/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." };
   }

package/src/delivery-hooks/command.js

@@ -45,6 +45,18 @@ function parseDeliveryOptions(args, allowed) {
 
 export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), webOrigin, input = process.stdin, output = console.log } = {}) {
   const [action, ...args] = argv;
+  if (action === 'history-recovery') {
+    const [operation,...flags] = args;
+    const options = parseDeliveryOptions(flags,new Set(['audit','digest']));
+    const recovery = await import('../update-detachment/history-recovery.js');
+    const parentRoot = dirname(root);
+    let result;
+    if (operation === 'plan') result = await recovery.planDispatchHistoryRecovery({root:parentRoot});
+    else if (operation === 'apply') result = await recovery.applyDispatchHistoryRecovery({root:parentRoot,auditRef:options.audit,auditDigest:options.digest});
+    else if (operation === 'reconnect') result = await recovery.reconnectRecoveredHistory({root:parentRoot,origin:webOrigin});
+    else throw new Error('Use simy delivery history-recovery plan|apply --audit PATH --digest SHA256|reconnect.');
+    output(JSON.stringify(result,null,2)); return 0;
+  }
   if (action === 'auto') {
     const [operation, ...flags] = args;
     if (!['on', 'off', 'status'].includes(operation)) throw new Error('Use simy delivery auto on|off|status --provider codex|claude in the project directory.');

package/src/delivery-hooks/supervisor.js

@@ -1,5 +1,5 @@
 import { captureDispatchProvenance } from '../update-detachment/provenance.js';
-import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, confirmDispatch, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
 import { bindCompletionArtifacts } from '../session-supervision/completion-artifacts.js';
 import { recoveryWorkProposal, admitRecoveryWork } from '../session-supervision/recovery-frontier.js';
 import { safeCheckpointDiagnostic } from './checkpoint-diagnostic.js';
@@ -480,7 +480,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         else await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
           checkpoint: result.checkpoint || parseAgentCheckpoint(result.output, record.session), expectedLease: leaseId, toolEvidence: result.toolEvidence || [], sourceContext: result.sourceContext, controllerEvidence: result.controllerEvidence, now: Date.now() });
         if (result.dispatchAttemptId) queueDispatchReceipt({ root: rootFromDelivery(root), attemptId: result.dispatchAttemptId, receiptId: `checkpoint:${leaseId}`, resultRef: `delivery-record:${record.provider}:${record.session}:${leaseId}` });
-        await updateRecord(root, record.provider, record.session, current => {
+        const checkpointed = await updateRecord(root, record.provider, record.session, current => {
           if (current?.run?.managed?.executionAttempt?.id !== leaseId) return current;
           current.run.managed.executionAttempt.phase = 'checkpointed';
           current.run.managed.executionAttempt.checkpointRevision = current.run.revision;
@@ -501,6 +501,14 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
           }
           return current;
         });
+        // Settle this successful native turn while its exact durable checkpoint
+        // is still current. A later worker replaces executionAttempt, so waiting
+        // until an update boundary would lose the original result association.
+        const savedAttempt = checkpointed?.run?.managed?.executionAttempt;
+        if (result.dispatchAttemptId && checkpointed?.run?.id === claimed.run.id &&
+            savedAttempt?.id === leaseId && result.dispatchAttemptId === leaseId &&
+            savedAttempt.phase === 'checkpointed' && savedAttempt.checkpointRevision === checkpointed.run.revision)
+          confirmDispatch({ root: rootFromDelivery(root), attemptId: result.dispatchAttemptId });
       } catch (error) { result = { ...result, code: -1, errorCode: 'checkpoint_rejected', diagnostic: safeCheckpointDiagnostic(error) }; }
     }
     await updateRecordAfterControl(root, record.provider, record.session, async current => {
@@ -657,8 +665,10 @@ export function createManagedSupervisor(options) {
             // A queue entry is a wakeup, not authority or a saved action. Re-read
             // consent, revisions and task identity at admission and each claim.
             const readRecords = async () => {
-              const rows = options.readRecords ? await options.readRecords()
-                : [await readRecord(options.root, record.provider, record.session)];
+              const rows = options.readCurrentRecord
+                ? [await options.readCurrentRecord(record.provider, record.session)]
+                : options.readRecords ? await options.readRecords()
+                  : [await readRecord(options.root, record.provider, record.session)];
               return rows.filter(row => row?.provider === record.provider && row.session === record.session &&
                 row.run?.id === record.run.id && row.run?.managed?.taskId === record.run.managed.taskId);
             };

package/src/desktop-access.js

@@ -7,7 +7,7 @@ export function validDesktopAccessPath(path, slug) {
   return path === expected || path === `${expected}/`;
 }
 export const desktopAccessReady = value => value?.state === 'ready';
-const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'organization_select', 'organization_cancel', 'organizations_refresh',
+const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'authorization_copy', 'organization_select', 'organization_cancel', 'organizations_refresh',
   'check_update', 'auto_update_set_enabled', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
   'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
 export function desktopActionAllowed(access, command) {

package/src/desktop-clipboard.js

@@ -0,0 +1,23 @@
+import { spawn } from 'node:child_process';
+
+// Pass private links over stdin, never in process arguments, status, or logs.
+export function copyDesktopText(text, { platform = process.platform, spawnImpl = spawn } = {}) {
+  const command = platform === 'darwin' ? ['pbcopy', []] : platform === 'win32'
+    ? ['powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '$inputText = [Console]::In.ReadToEnd(); Set-Clipboard -Value $inputText -ErrorAction Stop']]
+    : ['xclip', ['-selection', 'clipboard']];
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(command[0], command[1], { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true });
+    const timer = setTimeout(() => { child.kill(); finish(false); }, 5000);
+    let settled = false;
+    function finish(ok) {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      if (ok) resolve();
+      else { child.kill(); reject(Object.assign(new Error('Clipboard unavailable.'), { code: 'desktop_clipboard_unavailable' })); }
+    }
+    child.on('error', () => finish(false));
+    child.on('close', code => finish(code === 0));
+    child.stdin.on('error', () => finish(false));
+    child.stdin.end(text);
+  });
+}