@awak-app/simy-cli 0.7.22 → 0.7.25

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);
+  });
+}

package/src/desktop-host.js

@@ -1,4 +1,5 @@
 import { remoteOperationFailure } from './session-supervision/remote-errors.js';
+import { copyDesktopText } from './desktop-clipboard.js';
 import { createRemoteHostManager } from './session-supervision/remote-hosts.js';
 import { readDesktopAutoUpdate, writeDesktopAutoUpdate } from './desktop-update-settings.js';
 import { createUpdateRuntime } from './update-detachment/runtime.js';
@@ -23,7 +24,7 @@ import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, recordProviderArchive, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, createRecordReader, readRecord, updateRecord, recordProviderArchive, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
@@ -105,6 +106,7 @@ function desktopActionError(action, error) {
     };
     if (messages[error?.code]) return messages[error.code];
   }
+  if (action === 'authorization_copy') return 'Could not copy the connection link. Reopen the connection page and try again.';
   if (action === 'authorization_open' || error?.code === 'desktop_browser_unavailable') return "Could not open your browser. Open the verification link again, or check your default browser.";
   if (error?.code === "desktop_access_required") return "Sign in to an organization with SQM and Developer access before using SIMY.";
   if (action === "codex_hooks" || action === "claude_hooks") return "Could not open the setup guide. Check your default browser, or use /hooks inside the provider.";
@@ -409,6 +411,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const link = await requireProviderLink({ root: deliveryRoot, provider: record.provider });
       return JSON.stringify([scope, link.epoch]);
     }, readRecords: () => recordReader.list(),
+    readCurrentRecord: (provider, session) => readRecord(deliveryRoot, provider, session),
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
   let commands;
@@ -529,7 +532,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         phase = "authorize_connect";
         await authorizeWork();
         phase = "save_connect";
-        providerLinks = await writeProviderLink(root, provider, true);
+        providerLinks = await writeProviderLink(root, provider, true, { repairInvalidSettings: true });
       }
       delete providerLinkFeedback[provider];
       try { await agent.refreshProviderStatus?.(); }
@@ -1329,6 +1332,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
         else if (action === "sqm_set_engine_fallback") await agent.setSqmEngineFallback({ enabled: command.enabled, allowedProviders: command.allowedProviders });
         else if (action === "sqm_retry_environment") await agent.retrySqmEnvironment();
         else if (action === "organization_cancel") await agent.cancelOrganizationSelection();
+        else if (action === 'authorization_copy') {
+          const url = agent.getPendingAuthorizationUrl?.() || await agent.requestDesktopLogin();
+          if (!url || new URL(url).origin !== webOrigin || new URL(url).pathname !== '/local-cli/connect') throw new Error('No valid connection link.');
+          await (dependencies.copyText || copyDesktopText)(url);
+        }
         else if (action === "login" || action === "organization_select" || action === "authorization_open") {
           if (action === "organization_select" && (typeof command.organizationId !== "string" || !command.organizationId)) throw new Error("Select an organization first.");
           const url = action === "authorization_open" ? (agent.getPendingAuthorizationUrl?.() ?? agent.retryAuthorization?.())
@@ -1655,7 +1663,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     };
     if (command.action === "quit" || command.action === "prepare_update_restart" || command.action === "update" && (command.force === true || stoppingForUpdate)) {
       void execute();
-    } else if (["login", "organization_select", "organization_cancel", "authorization_open"].includes(command.action)) {
+    } else if (["login", "organization_select", "organization_cancel", "authorization_open", "authorization_copy"].includes(command.action)) {
       authorizationQueue = authorizationQueue.then(execute).catch(() => {});
     } else if (/^(codex|claude)_login$/.test(command.action || "") || ["provider_repair", "provider_connect", "provider_disconnect"].includes(command.action)) {
       // Opening an auth terminal must not wait for an unrelated provider turn.

package/src/desktop-status.js

@@ -67,6 +67,7 @@ export function desktopAuthStatus(session, { now = Date.now(), webOrigin = null
     state: valid ? "signed_in" : exists ? "expired" : "signed_out",
     expiresAt: typeof session?.expires_at === "string" ? session.expires_at : null,
     userLabel: sessionUserLabel(session),
+    userEmail: valid ? sessionUserEmail(session) : null,
     userId: valid ? (session.account_id ?? session.auth_user_id ?? null) : null,
   };
 }
@@ -323,6 +324,14 @@ function reportPresentation(result, allowSchemaLess = false) {
   } catch { return null; }
 }
 
+function sessionUserEmail(session) {
+  for (const key of ["email", "user_label"]) {
+    const value = session?.[key];
+    if (typeof value === "string" && value.trim().length <= 254 && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim())) return value.trim();
+  }
+  return null;
+}
+
 function sessionUserLabel(session) {
   if (!session) return null;
   for (const key of ["user_label", "display_name", "email", "account_id", "auth_user_id"]) {

package/src/orchestrator/audit.js

@@ -101,11 +101,11 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
       target: check.id,
       explanation: check.detail,
       repairability:
-        check.id === "executor_succeeded" && attempt.raw_output.blocked
+        check.id === "executor_succeeded" && attempt.raw_output?.blocked && attempt.raw_output?.blocker_kind === "human"
           ? "manual"
           : check.repairability,
       auto_fix_hint:
-        check.id === "executor_succeeded" && attempt.raw_output.blocked
+        check.id === "executor_succeeded" && attempt.raw_output?.blocked && attempt.raw_output?.blocker_kind === "human"
           ? null
           : `Resolve ${check.label.toLowerCase()} and check the result.`,
     }));

package/src/orchestrator/independent-audit.js

@@ -12,7 +12,7 @@ export function buildIndependentAuditInstruction(charter, attempt) {
   return buildWorkflowReportingInstruction({ auditor: true }) + "\n" + buildAcceptedHumanGuidanceInstruction(charter) + "\n" + section("requested_review", `Review the original request and actual behavior read-only. Report concrete defects, regressions and missing user outcomes. No preparation matrix, citation package, assurance score or mandatory screenshot record is required. Do not certify unobserved results or grant permission.
 Request: ${JSON.stringify({ requirement: charter.requirement, criteria: acceptanceCriterionRows(charter), mustNot: charter.must_not, experience: charter.completion_contract?.experience })}
 Current result: ${JSON.stringify({ summary: attempt.summary ?? null, residual_risks: attempt.residual_risks, tests: attempt.tests_run, observations: attempt.criterion_evidence, current: attempt.observed_evidence })}
-Return SIMY_AUDIT_JSON: with {passed,summary,findings,criterion_results,coverage_review:{user_outcome:{passed,verification_method,observed_result}}}. Check the original requested result even if the listed criteria mention only code or tests. Each criterion result describes criterion_id,passed,verification_method,observed_result. Each finding candidate must contain passed. Only passed=false entries are findings; never report passed=true evidence as a finding. Findings describe the concrete remaining defect and necessary repair.`);
+Return SIMY_AUDIT_JSON: with {passed,summary,findings,criterion_results,coverage_review:{user_outcome:{passed,verification_method,observed_result}}}. Check the original requested result even if the listed criteria mention only code or tests. Each criterion result describes criterion_id,passed,verification_method,observed_result. Each finding candidate must contain passed. Only passed=false entries are findings; never report passed=true evidence as a finding. Findings describe the concrete remaining defect and necessary repair. Set blocker_kind to machine for technical failures, external for unavailable dependencies, and human only for actual missing authorization, authentication interaction or an explicitly user-reserved decision. A legacy repairability=manual label or missing report does not establish a human dependency.`);
 }
 
 export function buildIndependentAudit(execution, charter = null, attempt = null) {
@@ -60,11 +60,11 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       severity: cleanString(item.severity).toLowerCase() || "major",
       target: cleanString(item.target) || "pull_request",
       explanation: cleanString(item.explanation) || "Independent audit finding.",
-      repairability: item.repairability === "manual" ? "manual" : "auto",
+      repairability: item.blocker_kind === "human" ? "manual" : "auto",
       disposition: ["defer", "dismiss"].includes(item.disposition) && cleanString(item.explanation)
         ? item.disposition : "fix",
       blocker_kind: ["machine", "human", "external"].includes(item.blocker_kind)
-        ? item.blocker_kind : item.repairability === "manual" ? "human" : "machine",
+        ? item.blocker_kind : "machine",
       auto_fix_hint: cleanString(item.auto_fix_hint) || null,
     }));
   const findings = evaluations.filter((item) => item.passed === false);

package/src/orchestrator/instruction.js

@@ -13,6 +13,7 @@ export function buildCodingInstruction(
   },
 ) {
   return [
+    section("automatic_recovery", "Continue authorized work without procedural sign-off. Repair technical failures automatically. For an actual blocker, report blocker_kind=machine for technical repair, external for an unavailable dependency, or human for missing authorization, authentication interaction or an explicitly reserved decision. Preserve native permissions and explicit stops; blocked=true alone does not require human input."),
     section("role", "Complete the user's requested outcome in this repository."),
     buildWorkflowReportingInstruction(),
     buildAcceptedHumanGuidanceInstruction(charter),

package/src/orchestrator/loop.js

@@ -113,7 +113,7 @@ async function runCodingLoopOwned({
       previousAttempt,
       previousFindings,
       promptInterventions,
-    });
+    }) + (snapshot.metadata?.automatic_recovery ? '\nAutomatic recovery of the same unfinished task: inspect the current failure and previous attempts, test a different cause or reversible repair, then return to the original requested work. Do not repeat an unchanged failing operation or ask the user to certify technical correctness. Preserve existing permissions and limits.' : '');
 
     let attempt = recoveredAttempt;
     if (!attempt) {
@@ -574,7 +574,18 @@ async function handleFailedAudit({
 }) {
   snapshot.charter.thread_state.failure_count += 1;
   const diagnosticCircuit = evaluateRetryCircuit({ attempt, previousAttempt: snapshot.attempts.at(-2) ?? null, findings });
-  const technicalStall = attempt.outcome_progress?.stalled || attempt.outcome_progress?.assessment_unavailable || diagnosticCircuit.open && !attempt.outcome_progress?.has_progress;
+  // A new commit does not resolve an unchanged review failure. Criteria can all
+  // pass while a required review finding still prevents acceptance. Compare
+  // concrete details: a shared generic code does not identify the same defect.
+  const priorAttempt = snapshot.attempts.at(-2);
+  const repeatedReview = !attempt.outcome_progress?.has_progress &&
+    diagnosticCircuit.previous_fingerprint?.review_findings_sha256 === diagnosticCircuit.fingerprint.review_findings_sha256 &&
+    priorAttempt?.outcome_progress?.objective_digest === attempt.outcome_progress?.objective_digest;
+  attempt.audit_retry_streak = repeatedReview ? (priorAttempt.audit_retry_streak || 1) + 1 : 1;
+  const reviewStalled = !requiresHuman && attempt.audit?.passed === true && attempt.independent_audit?.passed === false &&
+    attempt.audit_retry_streak >= 3 && attempt.outcome_progress?.status === "assessed" &&
+    !attempt.outcome_progress?.stalled && !attempt.outcome_progress?.assessment_unavailable;
+  const technicalStall = reviewStalled || attempt.outcome_progress?.stalled || attempt.outcome_progress?.assessment_unavailable || diagnosticCircuit.open && !attempt.outcome_progress?.has_progress;
   if (technicalStall && !requiresHuman) {
     const state = snapshot.charter.thread_state;
     const key = JSON.stringify([state.objective_contract?.current_digest, attempt.outcome_progress?.unproven_ids || [], findings.filter(row => row.code !== 'AI_STRATEGY_CHANGE_REQUIRED').map(row => row.code).sort()]);
@@ -590,18 +601,18 @@ async function handleFailedAudit({
       return false;
     }
   }
-  if (attempt.outcome_progress?.stalled) {
-    const unresolved = attempt.outcome_progress.unproven_ids;
+  if (reviewStalled || attempt.outcome_progress?.stalled) {
+    const unresolved = attempt.outcome_progress?.unproven_ids || [];
     snapshot.final_audit = {
       ...(snapshot.final_audit || {}),
       passed: false,
-      summary: "Independent review found no progress on the remaining user outcomes.",
+      summary: reviewStalled ? "Automatic diagnosis did not resolve the repeated review failure." : "Independent review found no progress on the remaining user outcomes.",
       findings: [...(snapshot.final_audit?.findings || []), {
         passed: false,
-        code: "OUTCOME_PROGRESS_STALLED",
+        code: reviewStalled ? "REVIEW_PROGRESS_STALLED" : "OUTCOME_PROGRESS_STALLED",
         severity: "blocker",
         target: "acceptance_criteria",
-        explanation: `The same user outcomes remain unproven after another attempt: ${unresolved.join(", ")}. Reassess the approach against the approved objective before more work.`,
+        explanation: reviewStalled ? "The same review findings remain after automatic diagnosis and another repair attempt. Preserve the failure for machine recovery; human certification cannot resolve it." : `The same user outcomes remain unproven after another attempt: ${unresolved.join(", ")}. Reassess the approach against the approved objective before more work.`,
         repairability: "auto",
         blocker_kind: "machine",
       }],
@@ -618,11 +629,7 @@ async function handleFailedAudit({
     await publish(snapshot, "blocked", onUpdate);
     return true;
   }
-  const retryCircuit = evaluateRetryCircuit({
-    attempt,
-    previousAttempt: snapshot.attempts.at(-2) ?? null,
-    findings,
-  });
+  const retryCircuit = diagnosticCircuit;
   if (retryCircuit.open && !attempt.outcome_progress?.has_progress &&
       !(attempt.audit?.passed && attempt.outcome_progress?.status === "insufficient_evidence" &&
         !attempt.outcome_progress?.failed_ids?.length)) {

package/src/orchestrator/recovery.js

@@ -1,4 +1,4 @@
-import { suggestedProviderTokenBudget, MAX_PROVIDER_TOKEN_BUDGET } from "./budget.js";
+import { suggestedProviderTokenBudget, MAX_PROVIDER_TOKEN_BUDGET, budgetState } from "./budget.js";
 
 const RECOVERABLE_STATES = new Set(["waiting_human", "blocked", "failed"]);
 
@@ -8,13 +8,17 @@ export function recoveryContractForEvent({ snapshot, state, message, detail = {}
 
   const reasonCode = recoveryReasonCode(state, message, detail);
   const attemptNumber = positiveInteger(detail.attempt_number);
-  const actions = recoveryActions(reasonCode, detail.budget);
+  const machineStopped = state === "blocked" && snapshot?.final_audit?.requires_human === false &&
+    ["outcome_progress_stalled", "retry_circuit_open"].includes(detail.code);
+  const actions = machineStopped ? [] : recoveryActions(reasonCode, detail.budget);
+  const automaticRecovery = machineStopped && !budgetState(snapshot).exhausted;
   return {
     schema_version: 1,
     state,
-    reason_code: reasonCode,
-    user_message: isSafetyCeiling(reasonCode) ? safetyCeilingRecoveryMessage(reasonCode, detail.budget) : recoveryMessage(reasonCode),
-    primary_action_id: actions[0].id,
+    reason_code: automaticRecovery ? 'machine_recovery_pending' : machineStopped ? "machine_recovery_exhausted" : reasonCode,
+    ...(machineStopped ? { requires_user_action: false } : {}),
+    user_message: automaticRecovery ? 'The task remains unfinished. SIMY will retry this same task after a recovery cooldown while its connection is enabled. No manual confirmation is required.' : machineStopped ? "Automatic diagnosis and repair attempts could not resolve the technical failure. The task remains unfinished; failure details are retained. No human approval or success declaration is required." : isSafetyCeiling(reasonCode) ? safetyCeilingRecoveryMessage(reasonCode, detail.budget) : recoveryMessage(reasonCode),
+    primary_action_id: actions[0]?.id ?? null,
     actions,
     technical_details: {
       event_code: clean(detail.code) || null,
@@ -104,9 +108,10 @@ export function isRecoveryContract(value) {
       value.schema_version === 1 &&
       typeof value.reason_code === "string" &&
       typeof value.user_message === "string" &&
-      typeof value.primary_action_id === "string" &&
       Array.isArray(value.actions) &&
-      value.actions.length > 0,
+      (typeof value.primary_action_id === "string" && value.actions.length > 0 ||
+        value.state === "blocked" && ['machine_recovery_pending', 'machine_recovery_exhausted'].includes(value.reason_code) &&
+        value.requires_user_action === false && value.primary_action_id === null && value.actions.length === 0),
   );
 }
 

package/src/orchestrator/retry.js

@@ -39,6 +39,7 @@ export function buildRetryFingerprint(attempt, findings) {
     commit_sha: commitSha,
     finding_codes: normalizedFindings.map((finding) => finding.code),
     findings_sha256: sha256(findingPayload),
+    review_findings_sha256: sha256(stableJson(normalizeFindings(findings, true))),
     evidence_sha256: sha256(evidencePayload),
   };
 }
@@ -52,7 +53,7 @@ function findingsForAttempt(attempt) {
   ];
 }
 
-function normalizeFindings(findings) {
+function normalizeFindings(findings, includeDetails = false) {
   return (Array.isArray(findings) ? findings : [])
     .filter((finding) => finding && typeof finding === "object")
     .map((finding) => ({
@@ -62,6 +63,11 @@ function normalizeFindings(findings) {
       severity: cleanString(finding.severity).toLowerCase() || null,
       target: cleanString(finding.target) || null,
       repairability: cleanString(finding.repairability).toLowerCase() || null,
+      ...(includeDetails ? {
+        explanation: cleanString(finding.explanation) || null,
+        auto_fix_hint: cleanString(finding.auto_fix_hint) || null,
+        blocker_kind: cleanString(finding.blocker_kind) || null,
+      } : {}),
     }))
     .sort(compareStableValues);
 }

package/src/provider-links.js

@@ -14,12 +14,13 @@ async function readSettings(root) {
   let payload;
   try { payload = JSON.parse(await readFile(join(root, 'provider-links.json'), 'utf8')); }
   catch (error) { if (error.code === 'ENOENT') return defaults(); throw error; }
-  if (payload?.schemaVersion !== 1 || !payload.providers || PROVIDER_LINKS.some(provider => {
+  if (payload?.schemaVersion !== 1) throw new Error('Unsupported SIMY provider connection settings version.');
+  if (!payload.providers || PROVIDER_LINKS.some(provider => {
     const value = payload.providers[provider];
     return !value || typeof value.connected !== 'boolean' || typeof value.requiresConsent !== 'boolean' ||
       value.epoch !== null && (typeof value.epoch !== 'string' || !value.epoch || value.epoch.length > 128) ||
       value.consentEpoch !== undefined && (value.consentEpoch !== value.epoch || !value.consentEpoch || value.connected !== false || typeof value.enabled !== 'boolean');
-  })) throw new Error('Invalid SIMY provider connection settings.');
+  })) throw Object.assign(new Error('Invalid SIMY provider connection settings.'), { code: 'invalid_provider_link_settings' });
   return Object.fromEntries(PROVIDER_LINKS.map(provider => [provider, {
     connected: payload.providers[provider].consentEpoch ? payload.providers[provider].enabled : payload.providers[provider].connected,
     ...(payload.providers[provider].consentEpoch ? { consentEpoch: payload.providers[provider].consentEpoch } : {}),
@@ -52,13 +53,22 @@ export async function requireProviderLink({ root = join(defaultRoot(), 'delivery
   return link;
 }
 
-export function writeProviderLink(root = defaultRoot(), provider, connected) {
+export function writeProviderLink(root = defaultRoot(), provider, connected, { repairInvalidSettings = false } = {}) {
   validateProvider(provider);
   if (typeof connected !== 'boolean') throw new Error('Choose whether this provider is connected to SIMY.');
   const key = resolve(root);
   const previous = writeQueues.get(key) || Promise.resolve();
   const pending = previous.catch(() => {}).then(async () => {
-    const providers = await readSettings(root);
+    let providers;
+    try { providers = await readSettings(root); }
+    catch (error) {
+      if (!repairInvalidSettings || !connected || !(error instanceof SyntaxError || error.code === 'invalid_provider_link_settings')) throw error;
+      // Only an explicit Connect action restores this provider. Retain the
+      // damaged file and leave all other providers disconnected.
+      const original = await readFile(join(root, 'provider-links.json'));
+      await writeFile(join(root, `provider-links.invalid-${randomUUID()}.json`), original, { mode: 0o600, flag: 'wx' });
+      providers = disconnected();
+    }
     // Reconnection restores discovery only. Session execution consent is cleared
     // separately and must be selected again, including after a host restart.
     const epoch = randomUUID();

package/src/runner.js

@@ -59,6 +59,7 @@ import {
   assertRecoveryActor, completedWorkerResult, recoveryActorBinding, refreshRecoveryAudit, refreshRecoveryBudgetAudit,
 } from "./coding-run-recovery.js";
 import { workflowRunEnv } from "./dev-work-events.js";
+import { canRecoverCodingRun, codingRecoveryDue, scheduleCodingRecovery } from './coding-run-automatic-recovery.js';
 
 const execFileAsync = promisify(execFile);
 const MAX_LOCAL_LOG_LINES = 1_000;
@@ -321,6 +322,7 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
   run.startedAt = restoredSnapshot.created_at || null;
   run.completedAt = restoredSnapshot.updated_at || null;
   run.controlState = restoredState === "stopped" ? "stopped" : "waiting_human";
+  if (canRecoverCodingRun(run)) run.controlState = 'complete';
   run.restoredFromState = restoredFromState;
   run.restoredObjectiveUnverified = objectiveUnverified;
   run.restoredCompletedWorkerResult = Boolean(recoverableResult);
@@ -430,6 +432,23 @@ export async function continueLocalCodingRun(run, guidance, dependencies = {}) {
   return executeLocalCodingRun(run, dependencies, { humanGuidance: message, resume: true });
 }
 
+// Automated recovery is not human guidance and does not reset stop intent,
+// usage, the objective, or the existing task identity.
+export async function recoverLocalCodingRun(run, dependencies = {}, now = Date.now()) {
+  if (!canRecoverCodingRun(run)) return run.snapshot;
+  if (!run.snapshot.metadata?.automatic_recovery) {
+    scheduleCodingRecovery(run.snapshot, now);
+    if (run.localStateRoot) await saveCodingRunSnapshot(run.localStateRoot, run.snapshot);
+    return run.snapshot;
+  }
+  if (!codingRecoveryDue(run, now)) return run.snapshot;
+  assertRunCanContinue(run);
+  run.completedAt = null;
+  run.controlState = 'running';
+  run.resumeCount += 1;
+  return executeLocalCodingRun(run, dependencies, { resume: true });
+}
+
 function assertRunCanContinue(run) {
   if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
   if (!RESUMABLE_STATES.has(run.status)) {
@@ -1324,6 +1343,11 @@ async function updateRun(run, state) {
   run.snapshot.state = state;
   run.snapshot.metadata = { ...run.snapshot.metadata, pr_lifecycle_state: state };
   run.snapshot.updated_at = new Date().toISOString();
+  if (state === 'blocked' && run.snapshot.final_audit?.requires_human === false &&
+      ['outcome_progress_stalled', 'retry_circuit_open'].includes(run.snapshot.events.at(-1)?.detail?.code) &&
+      !budgetState(run.snapshot).exhausted) {
+    scheduleCodingRecovery(run.snapshot);
+  }
   run.completedAt = TERMINAL_STATES.has(state) ? run.snapshot.updated_at : null;
   if (state === "waiting_human" || state === "pr_ready_for_review") {
     run.controlState = "waiting_human";

package/src/sqm/bundle-store.js

@@ -1,3 +1,4 @@
+import { recordSqmConnectionObservation } from '../connection-overview.js';
 import { ADVISORY_GUIDANCE_CAPABILITY, isAdvisoryGuidance } from './advisory-guidance.js';
 import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createHash, createPublicKey } from "node:crypto";
@@ -25,13 +26,40 @@ export class SqmIncompatibleCliError extends Error {
 }
 
 export async function loadKnowledgeBundle({
-  repository,
-  cliVersion,
   endpoint = process.env.SIMY_SQM_BUNDLE_URL,
   token = process.env.SIMY_SQM_TOKEN || process.env.SIMY_ACCESS_TOKEN,
   accountId = process.env.SIMY_SQM_ACCOUNT_ID || (token ? `token:${createHash("sha256").update(token).digest("hex")}` : "anonymous"),
   organizationId = process.env.SIMY_SQM_ORGANIZATION_ID,
   cacheRoot = process.env.SIMY_SQM_CACHE_DIR || path.join(process.env.SIMY_HOME?.trim() || path.join(homedir(), ".simy"), "sqm"),
+  ...options
+}) {
+  const context = { ...options, endpoint, token, accountId, organizationId, cacheRoot };
+  const observe = async result => {
+    if (options.offline || !endpoint || !accountId || !organizationId) return;
+    try { await recordSqmConnectionObservation(context, result, { root: cacheRoot, now: options.now }); }
+    catch { /* Display metadata must not change SQM behavior. */ }
+  };
+  try {
+    const result = await loadKnowledgeBundleImpl(context);
+    // An online fallback retains usable knowledge, but does not confirm the
+    // current connection. Offline/cache-only reads never refresh this record.
+    await observe(result.source === 'stale_cache' ? { source: 'unavailable' } : result);
+    return result;
+  } catch (error) {
+    // Cancellation is an intentional stop, not a failed connection attempt.
+    if (!options.signal?.aborted) await observe({ source: 'unavailable' });
+    throw error;
+  }
+}
+
+async function loadKnowledgeBundleImpl({
+  repository,
+  cliVersion,
+  endpoint,
+  token,
+  accountId,
+  organizationId,
+  cacheRoot,
   ttlMs = numberEnv("SIMY_SQM_CACHE_TTL_MS", DEFAULT_TTL_MS),
   offline = false,
   refresh = false,