@awak-app/simy-cli 0.5.71 → 0.5.72

package/README.md

@@ -30,9 +30,20 @@ current analysis finishes and submits its result. The toggle does not grant SQM
 subscription or organization permissions. First-time repository history discovery
 still starts from the web workspace.
 
-**SQM Tasks** shows local SQM reviews from the current agent session, separately
-from ordinary **Tasks**. Up to 50 recent reviews are shown; changing organization
-clears the local view. The web SQM workspace retains the authoritative history.
+**Quality checks** shows local analysis and check history separately from ordinary
+**Tasks**. Recent records survive restart and are scoped to the Web environment,
+account, and organization. Failed checks retain safe diagnostic codes, stages,
+HTTP status, and request identifiers when available. The web SQM workspace
+retains the authoritative analysis history. Persistent provider login, model or
+access errors pause new local claims with a visible recovery hint; refreshing
+after reconnecting permits another probe, with bounded automatic cooldowns.
+
+Detached daemon and desktop-host diagnostics are saved to
+`$SIMY_HOME/logs/daemon.log` and `$SIMY_HOME/logs/desktop-host.log`
+(`SIMY_HOME` defaults to `~/.simy`). Each log is limited to 1 MiB plus two
+backups; credentials, Cookie headers and URL queries are redacted. Installer
+handoff diagnostics remain in `~/.simy/installer/desktop-update.log`.
+`simy --version` or `simy -v` prints the package version without starting work.
 
 Closing the window keeps the agent running. Open the app again or choose
 **Show SIMY** from its menu bar icon to return. **Quit SIMY** asks before
@@ -411,6 +422,9 @@ SQM deliberately has two identity-bound stages:
 The full-check summary reports applicable modules, evaluated rules, scenario
 statuses and blocking/advisory scope. `passed` with `no_applicable_rules` or zero
 scenario evaluations does not establish feature or historical incident coverage.
+An empty system/repository bundle adds `no_system_knowledge` and an explicit
+zero-case warning; knowledge that exists but does not match this change uses a
+separate warning. Both retain the existing `passed` outcome.
 Scenario statuses come from deterministic rule evaluation, not browser/provider
 execution. Keep concrete regression and delivery acceptance evidence separately.
 If knowledge is unavailable, the command returns exit 2 with the service cause

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.71",
+  "version": "0.5.72",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -246,6 +246,7 @@ export async function startAgent({
   );
   let availableCapabilities;
   let providerStatuses = { codex: { state: "unknown" }, claude: { state: "unknown" } };
+  const providerRecoveryRevisions = { codex: 0, claude: 0 };
   const refreshAvailableCapabilities = () => {
     const features = contractSourceCapabilities.features;
     availableCapabilities = withCliContract({
@@ -423,6 +424,7 @@ export async function startAgent({
         providerStatuses = { ...providerStatuses, [provider]: next };
         refreshAvailableCapabilities();
         if (previous[provider]?.version !== next.version || previous[provider]?.state !== next.state) {
+          providerRecoveryRevisions[provider] += 1;
           notifyDesktopStatusChange();
         }
       }));
@@ -883,6 +885,7 @@ export async function startAgent({
         return slug ? new URL(`/org/${encodeURIComponent(slug)}/quality-monitor/`, apiOrigin).toString() : null;
       },
       getHistoryScope: () => sqmHistoryScope(apiOrigin, session),
+      getRecoveryKey: (provider) => providerRecoveryRevisions[provider] ?? 0,
       recordHistory: (scope, item) => sqmHistory.record(scope, item),
       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(
@@ -2330,6 +2333,7 @@ export async function startAgent({
       sqm: { enabled: sqmEnabled, canEnable: auth.state === "signed_in" && Boolean(session?.account_id && session?.organization_id) && !pendingOrganization && desktopWorkAllowed(),
         activeJobId: sqmLocalReviewWorker?.snapshot?.().active_job_id ?? null,
         issue: sqmLocalReviewWorker?.snapshot?.().issue ?? null,
+        providerPause: sqmLocalReviewWorker?.snapshot?.().provider_pause ?? null,
         providerReady: [codex, claude].some(provider => provider?.state === "ready") },
       ...projectSqmHistory(await historyForCurrentScope(), sqmLocalReviewWorker?.desktopTasks?.()),
       update: updateManager?.snapshot?.() ?? null,
@@ -2400,7 +2404,16 @@ export async function startAgent({
       return getDesktopStatus();
     },
     refreshCodexStatus: () => codexStatus({ force: true }),
-    refreshProviderStatus: () => readProviderStatuses({ force: true }),
+    refreshProviderStatus: async () => {
+      const statuses = await readProviderStatuses({ force: true });
+      // Explicit reconnect/refresh permits one recovery attempt. Routine status
+      // polling must not defeat the worker's persistent-failure cooldown.
+      for (const provider of ["codex", "claude"]) {
+        if (statuses[provider]?.state === "ready") providerRecoveryRevisions[provider] += 1;
+      }
+      notifyDesktopStatusChange();
+      return statuses;
+    },
     workspace,
     repositoryScanRoot,
     get capabilities() {

package/src/backend-executable.js

@@ -1,5 +1,6 @@
 import spawn from "cross-spawn";
 import os from "node:os";
+import { readdirSync, statSync } from "node:fs";
 import path from "node:path";
 
 const MACOS_CODEX_BINARY = "/Applications/ChatGPT.app/Contents/Resources/codex";
@@ -85,7 +86,7 @@ export function backendCandidates(backend, {
       "claude",
       // Desktop launch environments may predate the installer's PATH update.
       paths.join(userHome, ".local", "bin", platform === "win32" ? "claude.exe" : "claude"),
-      ...(platform === "darwin" ? ["/opt/homebrew/bin/claude", "/usr/local/bin/claude"] : []),
+      ...(platform === "darwin" ? ["/opt/homebrew/bin/claude", "/usr/local/bin/claude", ...claudeDesktopCandidates(userHome)] : []),
     ];
   }
   return [
@@ -95,6 +96,28 @@ export function backendCandidates(backend, {
   ];
 }
 
+// Desktop installs use either <version>/claude.app or <version>/<hash>/claude.app.
+// Only inspect these two known levels; never recurse through arbitrary home paths
+// or descend through version/hash directory symlinks. Existing explicit/PATH installs retain priority.
+function claudeDesktopCandidates(home) {
+  const root = path.join(home, "Library", "Application Support", "Claude", "claude-code");
+  const directories = directory => {
+    try { return readdirSync(directory, { withFileTypes: true }).filter(entry => entry.isDirectory()).map(entry => entry.name); }
+    catch { return []; }
+  };
+  return directories(root).filter(name => /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(name))
+    .sort((left, right) => compareVersions(right, left)).slice(0, 32)
+    .flatMap(version => {
+      const versionRoot = path.join(root, version);
+      const bundle = directory => path.join(directory, "claude.app", "Contents", "MacOS", "claude");
+      return [bundle(versionRoot), ...directories(versionRoot)
+        .filter(name => /^[a-zA-Z0-9_-]{8,128}$/.test(name)).sort().slice(0, 8)
+        .map(hash => bundle(path.join(versionRoot, hash)))];
+    }).filter(candidate => {
+      try { return statSync(candidate).isFile(); } catch { return false; }
+    });
+}
+
 export function parseBackendVersion(output) {
   const match = String(output || "").match(/(?:^|\s|v)(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?=\s|$|\))/);
   return match?.[1] ?? null;

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.71";
+export const CLI_VERSION = "0.5.72";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

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

@@ -743,9 +743,13 @@ export function prepareRecoveryDiagnosis(run, now = Date.now()) {
   return decision;
 }
 export function managedBudgetReason(run, now = Date.now()) {
-  if (now >= run.deadline || run.continuations >= run.maxContinuations || run.failures >= run.maxFailures) return 'Original delivery time, continuation, or failure budget exhausted.';
+  const checkpointDetail = run.checkpoint ? '' : ' No progress checkpoint was recorded.';
+  if (now >= run.deadline) return `Delivery time limit exhausted.${checkpointDetail}`;
+  if (run.continuations >= run.maxContinuations) return `Delivery continuation limit exhausted (${run.continuations}/${run.maxContinuations}).${checkpointDetail}`;
+  if (run.failures >= run.maxFailures) return `Delivery failure limit exhausted (${run.failures}/${run.maxFailures}).${checkpointDetail}`;
   const managed = run.managed;
-  if (managed?.usageBlocked || managed?.maxTokens && managed.tokensUsed >= managed.maxTokens) return 'Provider token budget exhausted or reliable usage unavailable.';
+  if (managed?.usageBlocked) return `Reliable provider token usage is unavailable; budgeted continuation is blocked.${checkpointDetail}`;
+  if (managed?.maxTokens && managed.tokensUsed >= managed.maxTokens) return `Provider token budget exhausted (${managed.tokensUsed}/${managed.maxTokens}).${checkpointDetail}`;
   if (managed && now - (managed.lastVerifiedProgressAt ?? run.startedAt) >= (managed.maxNoProgressMinutes ?? 30) * 60_000) return 'No verified acceptance progress within the configured time limit.';
   if (managed && managed.noProgress >= managed.maxNoProgress) return 'No verified acceptance progress within the configured continuation limit.';
   return null;

package/src/delivery-hooks/supervisor.js

@@ -193,8 +193,9 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(live.managed.decision.action?.kind) &&
         live.managed.approvedAction?.id === live.managed.decision.id && !live.managed.approvedAction.dispatchedAt;
       if (!live?.managed?.autoRecovery || live.state !== 'recovery_required' || !allowedCause || live.managed.pendingApproval || live.managed.autonomyPolicy && (!live.managed.decision || live.managed.decision.outcome === 'wait' && !approved) || appChannel && live.managed.nextAttemptAt > currentTime()) return current;
-      if (managedBudgetReason(live, currentTime()) || currentTime() >= live.deadline || live.continuations >= live.maxContinuations || live.failures >= live.maxFailures) {
-        live.state = 'budget_exhausted'; live.reason = 'Original managed continuation budget exhausted.'; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
+      const budgetReason = managedBudgetReason(live, currentTime());
+      if (budgetReason) {
+        live.state = 'budget_exhausted'; live.reason = budgetReason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
       }
       live.state = 'auto_resuming'; live.managed.resumeLease = { id: leaseId, claimedAt: currentTime(), checkpointRevision: live.revision, decisionId: live.managed.decision?.id || null,
         owner: { pid: process.pid, identity: ownerIdentity } };

package/src/desktop-host.js

@@ -18,6 +18,7 @@ import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { startAgent } from "./agent.js";
+import { createRuntimeDiagnostics } from "./runtime-diagnostics.js";
 import { createCliAutoUpdater, readCliPackageInfo } from "./auto-update.js";
 import { createAgentShutdown } from "./shutdown.js";
 import { resolveWebOrigin } from "./web-origin.js";
@@ -74,6 +75,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     output.write(`{"type":"status","status":{${observation}${encodedStatus}}}\n`);
   };
   const root = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+  const diagnostics = createRuntimeDiagnostics(root, { name: "desktop-host" });
   const webOrigin = resolveWebOrigin(null, env);
   const candidate = Boolean(env.SIMY_DESKTOP_SUPERVISOR_TOKEN);
   if (candidate && !await validateDesktopSupervisor(root, env.SIMY_DESKTOP_SUPERVISOR_TOKEN)) {
@@ -189,6 +191,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     } catch { pluginSetup = { state: "error" }; }
   };
   const packageInfo = dependencies.packageInfo || await readCliPackageInfo();
+  diagnostics.write(`desktop starting version=${packageInfo.version} pid=${process.pid} role=${candidate ? "update-candidate" : "supervisor"}`);
   const makeAnalysisManager = () => (dependencies.createAnalysisManager || createContinuationAnalysisManager)({
     root: join(root, 'session-analysis'), analyze: async (...args) => {
       const scope = await authorizeWork();
@@ -291,7 +294,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     updater = await (dependencies.createUpdater || (process.platform === "win32" ? (() => createWindowsDesktopUpdater({ version: packageInfo.version, disabled: env.SIMY_AUTO_UPDATE === "0" })) : createCliAutoUpdater))({
       daemon: true, interactive: true, webOrigin,
       disabled: env.SIMY_AUTO_UPDATE === "0",
-      dependencies: { packageInfo, logger() {} },
+      dependencies: { packageInfo, logger: message => diagnostics.write(`update: ${message}`) },
     });
     agent = await (dependencies.startAgent || startAgent)({
       daemon: true, webOrigin, sessionRoot: root, quiet: true, updateManager: updater,
@@ -317,12 +320,17 @@ export async function startDesktopHost({ input = process.stdin, output = process
       let child;
       try { child = (dependencies.spawn || spawn)(installation.executablePath,
         [join(dirname(installation.entryPath), "desktop-host.js")], {
-          stdio: ["pipe", "pipe", "ignore"],
+          stdio: ["pipe", "pipe", "pipe"],
           env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken },
         }); } catch (error) {
           actionAssociations = makeActionAssociations();
           analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); discoveryStopped = false; refreshSessions(true); throw error;
         }
+      const stderr = diagnostics.stream("updated-runtime stderr");
+      child.stderr?.on("data", stderr.write);
+      child.stderr?.on("end", stderr.flush);
+      child.once("error", error => diagnostics.write(`updated-runtime error: ${error.code || "unknown"} ${error.message}`));
+      child.once("exit", (code, signal) => { stderr.flush(); diagnostics.write(`updated-runtime exit: code=${code} signal=${signal || "none"}`); });
       const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
       let accepted = false;
       child.stdin.on("error", () => {
@@ -668,6 +676,7 @@ if (isDesktopHostEntry()) {
   const stop = () => { void host?.close().finally(() => process.exit(0)); };
   process.once("SIGTERM", stop); process.once("SIGINT", stop);
   startDesktopHost().then((value) => { host = value; }).catch((error) => {
+    createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"), { name: "desktop-host" }).write(`startup failed: ${error?.stack || error}`);
     const conflict = error?.code === PROCESS_CONFLICT_CODE;
     process.stdout.write(`${JSON.stringify({
       type: "error",

package/src/index.js

@@ -7,6 +7,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { startAgent } from "./agent.js";
+import { createRuntimeDiagnostics, captureRuntimeOutput } from "./runtime-diagnostics.js";
 import {
   autoUpdateHelpText,
   createCliAutoUpdater,
@@ -34,8 +35,16 @@ const entryPath = fileURLToPath(import.meta.url);
 const packageInfo = await readCliPackageInfo();
 const updatesDisabled = args.has("--no-auto-update") || process.env.SIMY_AUTO_UPDATE === "0";
 let configuredWebOrigin;
+const versionOnly = dispatchArgv.length === 1 && ["--version", "-v"].includes(dispatchArgv[0]);
+if (versionOnly) {
+  console.log(packageInfo.version);
+} else if (process.env.SIMY_DAEMON_CHILD === "1" && (args.has("--daemon") || args.has("--deamon"))) {
+  const diagnostics = createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"));
+  captureRuntimeOutput(diagnostics);
+  diagnostics.write(`daemon starting version=${packageInfo.version} pid=${process.pid}`);
+}
 try {
-  configuredWebOrigin = resolveWebOrigin(readOption(argv, "--host"));
+  if (!versionOnly) configuredWebOrigin = resolveWebOrigin(readOption(argv, "--host"));
 } catch (error) {
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 2;
@@ -121,6 +130,7 @@ async function runCommand(installMode) {
   simy update         ${installMode === "macos_installer" ? "Show Apple Silicon update status and installer action" : "Install an eligible stable CLI update"}
 
 Options:
+  --version, -v       Print the installed CLI version and exit
   --daemon, --deamon  Run detached in the background
   --no-tui            Disable the interactive Agentic Loop console
   --no-open           Do not open the browser when authorization is required

package/src/orchestrator/evidence.js

@@ -26,7 +26,7 @@ export async function collectPrEvidence({
   const baseRefresh = await command(
     runCommand,
     "git",
-    ["fetch", "--no-tags", "origin", charter.base_branch],
+    ["fetch", "--no-tags", "origin", charter.base_branch.replace(/^(?:refs\/remotes\/)?origin\//, "")],
     repositoryPath,
   );
   const local = await collectLocalGitEvidence({
@@ -42,7 +42,8 @@ export async function collectPrEvidence({
   const latest = await collectLocalGitEvidence({ baseBranch: charter.base_branch, repositoryPath, runCommand });
   latest.base_ref_refreshed = baseRefresh.ok;
   latest.base_ref_error = baseRefresh.ok ? null : baseRefresh.error;
-  if (!latest.available || latest.head_sha !== local.head_sha || !latest.working_tree_clean) {
+  if (!latest.available || latest.head_sha !== local.head_sha || latest.base_sha !== local.base_sha ||
+      latest.base_ref !== local.base_ref || !latest.working_tree_clean) {
     minimumCompletion.status = "evidence_incomplete";
     minimumCompletion.errors = ["Checkout changed while collecting minimum evidence; verify again."];
   }
@@ -90,16 +91,17 @@ function observedEvidenceRef(ref, local, github) {
 }
 
 async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand }) {
-  const baseRef = `origin/${baseBranch}`;
-  const [head, branch, headline, status, changed, base, mergeBase, baseAncestor] = await Promise.all([
+  const base = await resolveBaseRef(runCommand, baseBranch, repositoryPath);
+  // Pin all comparisons to the same commit, even if another process moves the ref.
+  const baseCommit = base.ok ? base.stdout : null;
+  const [head, branch, headline, status, changed, mergeBase, baseAncestor] = await Promise.all([
     command(runCommand, "git", ["rev-parse", "HEAD"], repositoryPath),
     command(runCommand, "git", ["branch", "--show-current"], repositoryPath),
     command(runCommand, "git", ["log", "-1", "--pretty=%s"], repositoryPath),
     command(runCommand, "git", ["status", "--porcelain"], repositoryPath),
-    changedFiles(runCommand, baseBranch, repositoryPath),
-    command(runCommand, "git", ["rev-parse", baseRef], repositoryPath),
-    command(runCommand, "git", ["merge-base", baseRef, "HEAD"], repositoryPath),
-    command(runCommand, "git", ["merge-base", "--is-ancestor", baseRef, "HEAD"], repositoryPath),
+    base.ok ? command(runCommand, "git", ["diff", "--name-only", "--diff-filter=ACMR", `${baseCommit}...HEAD`], repositoryPath) : base,
+    base.ok ? command(runCommand, "git", ["merge-base", baseCommit, "HEAD"], repositoryPath) : base,
+    base.ok ? command(runCommand, "git", ["merge-base", "--is-ancestor", baseCommit, "HEAD"], repositoryPath) : base,
   ]);
   const statusLines = lines(status.stdout);
   return {
@@ -110,7 +112,8 @@ async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand
     working_tree_clean: status.ok && statusLines.length === 0,
     status_lines: statusLines,
     changed_files: lines(changed.stdout),
-    base_sha: cleanString(base.stdout) || null,
+    base_ref: base.ref || null,
+    base_sha: baseCommit,
     merge_base_sha: cleanString(mergeBase.stdout) || null,
     base_is_ancestor: baseAncestor.ok,
     errors: [head, branch, headline, status, changed, base, mergeBase]
@@ -119,18 +122,16 @@ async function collectLocalGitEvidence({ baseBranch, repositoryPath, runCommand
   };
 }
 
-async function changedFiles(runCommand, baseBranch, repositoryPath) {
-  const refs = [`origin/${baseBranch}`, baseBranch];
+async function resolveBaseRef(runCommand, baseBranch, repositoryPath) {
+  const refs = baseBranch.startsWith("refs/") ? [baseBranch] :
+    baseBranch.startsWith("origin/") ? [`refs/remotes/${baseBranch}`] :
+      [`refs/remotes/origin/${baseBranch}`, `refs/heads/${baseBranch}`];
   for (const ref of refs) {
-    const result = await command(
-      runCommand,
-      "git",
-      ["diff", "--name-only", "--diff-filter=ACMR", `${ref}...HEAD`],
-      repositoryPath,
-    );
-    if (result.ok) return result;
+    const result = await command(runCommand, "git",
+      ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], repositoryPath);
+    if (result.ok) return { ...result, ref };
   }
-  return { ok: false, stdout: "", error: `Could not diff against ${baseBranch}.` };
+  return { ok: false, stdout: "", error: `Could not resolve base branch ${baseBranch}.` };
 }
 
 async function collectGitHubEvidence({ charter, attempt, repositoryPath, runCommand }) {

package/src/orchestrator/loop.js

@@ -183,7 +183,7 @@ async function runCodingLoopOwned({
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
     snapshot.attempts.push(attempt);
-    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt);
+    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt, { resetUnavailableCount: resume && attemptNumber === firstAttempt });
     attempt.budget = refreshBudgetState(snapshot);
 
     if (snapshot.budget.token_exhausted) {
@@ -265,7 +265,7 @@ async function runCodingLoopOwned({
     });
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
-    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt);
+    assessOutcomeProgress(snapshot.charter, attempt, previousAttempt, { resetUnavailableCount: resume && attemptNumber === firstAttempt });
 
     const independentFindings = attempt.independent_audit.findings || [];
     if (!attempt.audit.passed || !attempt.independent_audit.passed) {
@@ -555,6 +555,34 @@ async function handleFailedAudit({
     });
     return true;
   }
+  if (attempt.outcome_progress?.assessment_unavailable) {
+    const progress = attempt.outcome_progress;
+    snapshot.final_audit = {
+      ...(snapshot.final_audit || {}),
+      passed: false,
+      summary: "Outcome progress could not be assessed across consecutive attempts.",
+      findings: [...(snapshot.final_audit?.findings || []), {
+        passed: false,
+        code: "OUTCOME_ASSESSMENT_UNAVAILABLE",
+        severity: "blocker",
+        target: "outcome_monitor",
+        explanation: "Two consecutive attempts could not establish an independent outcome assessment. Resolve the recorded verification failures and continue this run; this does not prove the work has stalled.",
+        repairability: "manual",
+      }],
+      auto_repairable: false,
+      requires_human: true,
+    };
+    appendEvent(snapshot, "waiting_human", "Outcome assessment needs recovery before further automatic work.", {
+      code: "outcome_assessment_unavailable",
+      finding_codes: ["OUTCOME_ASSESSMENT_UNAVAILABLE"],
+      attempt_number: attemptNumber,
+      consecutive_unassessed_attempts: progress.consecutive_unassessed_attempts,
+      unavailable_reason: progress.unavailable_reason,
+      unproven_ids: progress.unproven_ids,
+    });
+    await publish(snapshot, "waiting_human", onUpdate);
+    return true;
+  }
   if (requiresHuman) {
     appendEvent(snapshot, "waiting_human", "PR audit requires human input.", {
       finding_codes: findings.map((finding) => finding.code),

package/src/orchestrator/outcome-monitor.js

@@ -17,17 +17,30 @@ function objective(charter) {
   };
 }
 
-function digest(value) {
-  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const CANONICAL_DIGEST = "sha256-canonical-json-v1";
+
+function canonicalValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+  }
+  return value;
+}
+
+function digest(value, algorithm) {
+  return createHash("sha256").update(JSON.stringify(
+    algorithm === CANONICAL_DIGEST ? canonicalValue(value) : value,
+  )).digest("hex");
 }
 
 export function freezeObjective(charter) {
   const value = objective(charter);
   charter.thread_state.objective_contract = {
     version: 1,
+    digest_algorithm: CANONICAL_DIGEST,
     baseline: structuredClone(value),
     current: structuredClone(value),
-    current_digest: digest(value),
+    current_digest: digest(value, CANONICAL_DIGEST),
     revisions: [],
   };
 }
@@ -36,7 +49,7 @@ export function reviseObjective(charter, source) {
   const contract = charter.thread_state.objective_contract;
   if (!contract) return;
   const next = objective(charter);
-  const nextDigest = digest(next);
+  const nextDigest = digest(next, contract.digest_algorithm);
   if (nextDigest === contract.current_digest) return;
   contract.revisions.push({
     version: contract.version + 1,
@@ -55,6 +68,10 @@ export function verifyObjective(charter) {
   const contract = charter.thread_state?.objective_contract;
   if (!contract) return { valid: true, legacy: true };
   try {
+    if (contract.digest_algorithm && contract.digest_algorithm !== CANONICAL_DIGEST) {
+      return { valid: false, legacy: false, digest: null };
+    }
+    const contractDigest = (value) => digest(value, contract.digest_algorithm);
     const current = objective(charter);
     const revisions = contract.revisions;
     const valid = Boolean(
@@ -62,15 +79,15 @@ export function verifyObjective(charter) {
       contract.baseline &&
       Array.isArray(revisions) &&
       revisions.length === contract.version - 1 &&
-      digest(contract.current) === contract.current_digest &&
-      digest(current) === contract.current_digest &&
+      contractDigest(contract.current) === contract.current_digest &&
+      contractDigest(current) === contract.current_digest &&
       revisions.every((revision, index) =>
         revision.version === index + 2 &&
-        revision.previous_digest === digest(revision.previous) &&
-        revision.next_digest === digest(revision.next) &&
-        (index === 0 ? revision.previous_digest === digest(contract.baseline) :
+        revision.previous_digest === contractDigest(revision.previous) &&
+        revision.next_digest === contractDigest(revision.next) &&
+        (index === 0 ? revision.previous_digest === contractDigest(contract.baseline) :
           revision.previous_digest === revisions[index - 1].next_digest)) &&
-      (revisions.length === 0 ? digest(contract.baseline) === contract.current_digest :
+      (revisions.length === 0 ? contractDigest(contract.baseline) === contract.current_digest :
         revisions.at(-1).next_digest === contract.current_digest)
     );
     return { valid, legacy: false, digest: contract.current_digest };
@@ -81,7 +98,7 @@ export function verifyObjective(charter) {
 
 // The monitor reads independent criterion assessments, not executor test counts.
 // It records insufficient evidence when the independent review was not reached.
-export function assessOutcomeProgress(charter, attempt, previousAttempt = null) {
+export function assessOutcomeProgress(charter, attempt, previousAttempt = null, { resetUnavailableCount = false } = {}) {
   const criteria = acceptanceCriterionRows(charter);
   const assessment = attempt.independent_audit;
   const results = Array.isArray(assessment?.criterion_results)
@@ -111,6 +128,20 @@ export function assessOutcomeProgress(charter, attempt, previousAttempt = null)
     stalled: false,
   };
   const previous = previousAttempt?.outcome_progress;
+  const sameObjective = previous?.objective_digest === result.objective_digest;
+  const previousUnavailableCount = !resetUnavailableCount && sameObjective && previous?.status === "insufficient_evidence"
+    ? previous.consecutive_unassessed_attempts || 1 : 0;
+  result.consecutive_unassessed_attempts = completeAssessment ? 0 : previousUnavailableCount + 1;
+  result.unavailable_reason = completeAssessment ? null : attempt.audit?.passed !== true
+    ? "local_verification_incomplete" : "independent_assessment_incomplete";
+  const previousMissingAssessments = !resetUnavailableCount && sameObjective &&
+    previous?.unavailable_reason === "independent_assessment_incomplete"
+    ? previous.consecutive_unavailable_assessments || 1 : 0;
+  result.consecutive_unavailable_assessments = result.unavailable_reason === "independent_assessment_incomplete"
+    ? previousMissingAssessments + 1 : 0;
+  // Local repair can improve without reaching independent review. Only a repeatedly
+  // missing independent assessment after local readiness opens this recovery gate.
+  result.assessment_unavailable = result.consecutive_unavailable_assessments >= 2;
   result.stalled = Boolean(
     completeAssessment && previous?.status === "assessed" &&
     previous.objective_digest === result.objective_digest &&

package/src/orchestrator/recovery.js

@@ -114,6 +114,7 @@ function recoveryReasonCode(state, message, detail) {
   if (code === "retry_circuit_open" || detail.reason === "identical_commit_and_findings") {
     return "retry_strategy_unchanged";
   }
+  if (code === "outcome_assessment_unavailable") return "outcome_assessment_unavailable";
   if (code === "token_budget_exhausted") return "token_budget_exhausted";
   if (code === "retry_budget_exhausted") return "retry_budget_exhausted";
   const findings = strings(detail.finding_codes);
@@ -148,6 +149,8 @@ function recoveryMessage(reasonCode) {
     requirements_incomplete:
       "SIMY needs the missing requirement or approval before implementation can start.",
     human_input_required: "SIMY needs your decision or clarification before it can continue.",
+    outcome_assessment_unavailable:
+      "SIMY could not assess outcome progress across consecutive attempts. Repair the recorded verification failure and continue this run.",
     token_budget_exhausted:
       "This run reached its Provider token safety limit. Provider tokens are not billed by SIMY. Increase the limit to continue this run.",
     retry_budget_exhausted:

package/src/runner.js

@@ -354,6 +354,25 @@ export async function increaseLocalCodingRunProviderTokenBudget(run, value) {
   const previousBudget = currentBudget.token_budget;
   const budget = increaseProviderTokenBudget(run.snapshot, value);
   run.request.token_budget = budget.token_budget;
+  // A budget change resolves only this blocker; retain the previous audit as evidence.
+  const previousAudit = run.snapshot.final_audit;
+  const resolvedBudgetAudit = previousAudit?.findings?.some(
+    (finding) => finding.code === "TOKEN_BUDGET_EXHAUSTED",
+  ) ? structuredClone(previousAudit) : null;
+  if (resolvedBudgetAudit) {
+    const findings = previousAudit.findings.filter((finding) => finding.code !== "TOKEN_BUDGET_EXHAUSTED");
+    run.snapshot.final_audit = {
+      ...previousAudit,
+      passed: false,
+      summary: findings.length > 0
+        ? "Provider token budget increased; other verification findings remain."
+        : "Provider token budget increased; continue this run to verify completion.",
+      findings,
+      budget,
+      auto_repairable: findings.length > 0 && findings.every((finding) => finding.repairability === "auto"),
+      requires_human: findings.some((finding) => finding.repairability !== "auto"),
+    };
+  }
   appendEvent(
     run.snapshot,
     "waiting_human",
@@ -361,6 +380,7 @@ export async function increaseLocalCodingRunProviderTokenBudget(run, value) {
     {
       code: "provider_token_budget_increased",
       previous_provider_token_budget: previousBudget,
+      ...(resolvedBudgetAudit ? { previous_final_audit: resolvedBudgetAudit } : {}),
       provider_token_budget: budget.token_budget,
       budget,
     },

package/src/runtime-diagnostics.js

@@ -0,0 +1,77 @@
+import { appendFileSync, chmodSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { redactExecutionText } from './orchestrator/execution-io.js';
+
+// Local diagnostics are deliberately bounded and private. Use the same credential
+// policy as execution history, with URL queries removed (login nonces live there).
+export function createRuntimeDiagnostics(root, { name = 'daemon', maxBytes = 1024 * 1024, backups = 2 } = {}) {
+  const directory = join(root, 'logs');
+  const file = join(directory, `${name}.log`);
+  const write = value => {
+    try {
+      mkdirSync(directory, { recursive: true, mode: 0o700 });
+      const text = redactExecutionText(String(value)
+        .replace(/(\b(?:set-cookie|cookie)\s*:\s*)[^\r\n]*/gi, '$1[REDACTED]')
+        .replace(/(https?:\/\/[^\s?#]+)[?#][^\s]*/g, '$1?[REDACTED]'), { maxChars: 8192 }).text;
+      // Do not retain fragments of PEM keys, whose boundaries may span writes.
+      const safe = /PRIVATE KEY|^[A-Za-z0-9+/=]{64,}$/.test(text.trim()) ? '[REDACTED KEY MATERIAL]' : text;
+      const record = Buffer.from(`${new Date().toISOString()} ${safe.replace(/[\r\n]+/g, ' ')}\n`);
+      const bounded = record.subarray(0, maxBytes);
+      let size = 0;
+      try { size = statSync(file).size; } catch {}
+      if (size + bounded.length > maxBytes) {
+        rmSync(`${file}.${backups}`, { force: true });
+        for (let index = backups - 1; index >= 1; index--) {
+          try { renameSync(`${file}.${index}`, `${file}.${index + 1}`); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+        }
+        try { renameSync(file, `${file}.1`); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      }
+      appendFileSync(file, bounded, { mode: 0o600 });
+      chmodSync(file, 0o600);
+    } catch {
+      // Diagnostics must never prevent startup/recovery or recurse via stderr.
+    }
+  };
+  const stream = label => {
+    const decoder = new StringDecoder('utf8');
+    let pending = '', dropping = false, privateKey = false;
+    const writeChunk = chunk => {
+      const text = decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      for (const part of text.split(/(?<=\n)/)) {
+        const end = part.endsWith('\n');
+        if (!dropping) {
+          pending += part;
+          if (pending.length > 8192) {
+            // Drop the whole oversized line, rather than persisting an unredacted
+            // partial credential split across chunks or the truncation boundary.
+            write(`${label}: [oversized diagnostic line omitted]`);
+            pending = ''; dropping = !end;
+          } else if (end) {
+            if (/-----BEGIN .*PRIVATE KEY-----/.test(pending)) privateKey = true;
+            write(`${label}: ${privateKey ? '[REDACTED KEY MATERIAL]' : pending.trimEnd()}`);
+            if (/-----END .*PRIVATE KEY-----/.test(pending)) privateKey = false;
+            pending = '';
+          }
+        } else if (end) dropping = false;
+      }
+    };
+    return { write: writeChunk, flush() { if (pending && !dropping) write(`${label}: ${privateKey ? '[REDACTED KEY MATERIAL]' : pending}`); pending = ''; dropping = false; } };
+  };
+  return { file, write, stream };
+}
+
+export function captureRuntimeOutput(diagnostics, streams = { stdout: process.stdout, stderr: process.stderr }) {
+  const restores = [];
+  for (const [label, target] of Object.entries(streams)) {
+    const sink = diagnostics.stream(label);
+    const original = target.write;
+    target.write = function (chunk, ...args) { sink.write(chunk); return original.call(this, chunk, ...args); };
+    restores.push(() => { target.write = original; sink.flush(); });
+  }
+  const fatal = error => diagnostics.write(`uncaught: ${error?.stack || error}`);
+  process.on('uncaughtExceptionMonitor', fatal);
+  const restore = () => { for (const callback of restores) callback(); process.removeListener('uncaughtExceptionMonitor', fatal); process.removeListener('exit', restore); };
+  process.once('exit', restore);
+  return restore;
+}

package/src/sqm/bundle-store.js

@@ -1,3 +1,4 @@
+import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createHash, createPublicKey } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -83,7 +84,7 @@ export async function loadKnowledgeBundle({
     } catch (error) {
       if (error?.code === "incompatible_cli") throw error;
       if (error?.fallbackAllowed !== false && cached && !cached.bundle.system_scope && Date.parse(cached.bundle.expires_at) > now) return result(cached.bundle, [`SQM Cloud unavailable; using last verified bundle: ${message(error)}`], "stale_cache");
-      return result(null, [`SQM knowledge could not be used; shadow checks were skipped: ${message(error)}`], "unavailable");
+      return { ...result(null, [`SQM knowledge could not be used; shadow checks were skipped: ${message(error)}`], "unavailable"), diagnostic: safeSqmDiagnostic(error, "knowledge_bundle", "knowledge_bundle_unavailable") };
     }
   }
   if (cached) {
@@ -200,6 +201,8 @@ async function fetchBundle({ endpoint, repository, cliVersion, token, organizati
       );
     }
     const error = new Error(`SQM Cloud returned HTTP ${response.status}${body ? `: ${body.slice(0, 300)}` : ""}.`);
+    Object.assign(error, safeSqmDiagnostic({ status: response.status, code: parsed?.error?.code || parsed?.detail?.code,
+      requestId: response.headers?.get?.("x-request-id") }, "knowledge_bundle", "knowledge_bundle_http_error"));
     error.fallbackAllowed = response.status >= 500 && response.status <= 599;
     throw error;
   }

package/src/sqm/command.js

@@ -1,3 +1,4 @@
+import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createSqmCheckRecorder } from "./history-store.js";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -49,6 +50,7 @@ export async function runSqmCommand(argv, { cliVersion }) {
 
   const save = createSqmCheckRecorder({ scope: { webOrigin, accountId, organizationId },
     phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch });
+  let stage = "min_check";
   try {
     if (argv[0] === "min-check") {
       const result = await runSqmMinCheck(common);
@@ -60,6 +62,7 @@ export async function runSqmCommand(argv, { cliVersion }) {
       return result.status === "unavailable" ? 2 : result.status === "preliminary_failed" ? 1 : 0;
     }
 
+    stage = "min_result_read";
     const minPath = option(argv, "--min-result") || defaultMinResultPath();
     let minCheck;
     try {
@@ -71,11 +74,13 @@ export async function runSqmCommand(argv, { cliVersion }) {
       await atomicJson(minPath, minCheck);
     }
     if (minCheck.status === "unavailable") { await save(minCheck); return printUnavailable(minCheck, argv); }
+    stage = "full_check";
     const result = await runSqmCheck({ ...common, minCheck, deviceId, signingKeyPath: option(argv, "--signing-key") || undefined });
     if (result.status === "unavailable") { await save(result); return printUnavailable(result, argv); }
     const proofPath = path.resolve(option(argv, "--proof") || "proof.json");
     const evidencePath = path.resolve(option(argv, "--signed-evidence") || `${proofPath}.signed.json`);
     const diagnosticsPath = path.resolve(option(argv, "--diagnostics") || `${proofPath}.diagnostics.json`);
+    stage = "artifact_write";
     await Promise.all([
       atomicJson(proofPath, result.proof),
       atomicJson(evidencePath, result.signed_evidence),
@@ -87,6 +92,7 @@ export async function runSqmCommand(argv, { cliVersion }) {
     let upload = { uploaded: false, reason: "disabled" };
     if (!argv.includes("--no-upload")) {
       const evidenceEndpoint = process.env.SIMY_SQM_EVIDENCE_URL || (validSession?.api_base_url ? new URL("sqm/run-evidence", validSession.api_base_url).href : undefined);
+      stage = "evidence_upload";
       upload = await uploadRunEvidence({ endpoint: evidenceEndpoint, token, proof: result.proof, signedEvidence: result.signed_evidence });
     }
     result.upload = upload;
@@ -101,7 +107,7 @@ export async function runSqmCommand(argv, { cliVersion }) {
     else printFull(result);
     return result.proof.outcome.status === "failed" ? 1 : 0;
   } catch (error) {
-    await save({ status: "failed" });
+    await save({ status: "failed", diagnostic: safeSqmDiagnostic(error, stage) });
     throw error;
   }
 }

package/src/sqm/diagnostics.js

@@ -0,0 +1,23 @@
+// Persist machine diagnostics only. Provider/server response text can contain
+// repository content or credentials and must never enter durable check history.
+export function safeSqmDiagnostic(error, stage = "check", code = "sqm_check_failed") {
+  const value = error?.diagnostic || (error?.error && typeof error.error === "object" ? error.error : error) || {};
+  const machine = (candidate, fallback) => typeof candidate === "string" && /^[a-zA-Z][a-zA-Z0-9_]{0,79}$/.test(candidate) ? candidate : fallback;
+  const status = [value.status, value.errorStatus, value.httpStatus, value.error_status].find(candidate => Number.isInteger(candidate) && candidate >= 400 && candidate <= 599);
+  const requestId = value.requestId ?? value.request_id;
+  return {
+    stage: machine(value.stage ?? value.errorStage ?? value.error_stage, stage),
+    code: machine(value.code ?? value.errorCode ?? value.error_code, code),
+    ...(Number.isInteger(status) && status >= 400 && status <= 599 ? { status } : {}),
+    ...(typeof requestId === "string" && /^(?:[a-f0-9]{16,64}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i.test(requestId) ? { requestId } : {}),
+  };
+}
+
+export function formatSqmDiagnostic(value) {
+  const hint = value.status === 401 ? "Reconnect your SIMY session."
+    : value.status === 403 ? "Check access to SQM in the selected organization."
+    : value.code === "repository_scope_unresolved" ? "Connect this repository to a system in SIMY."
+    : value.code === "knowledge_bundle_changed" || value.code === "repository_identity_changed" ? "Run min-check again for the current repository and knowledge version."
+    : "Inspect the command diagnostics for this stage before retrying.";
+  return `${value.stage} · ${value.code}${value.status ? ` · HTTP ${value.status}` : ""}${value.requestId ? ` · Request ${value.requestId}` : ""}\n${hint}`;
+}

package/src/sqm/evidence-client.js

@@ -1,3 +1,4 @@
+import { safeSqmDiagnostic } from "./diagnostics.js";
 export async function uploadRunEvidence({ endpoint, token, proof, signedEvidence, fetchImpl = globalThis.fetch }) {
   if (!endpoint || !token) return { uploaded: false, reason: "authenticated_cloud_session_unavailable" };
   const response = await fetchImpl(endpoint, {
@@ -7,6 +8,6 @@ export async function uploadRunEvidence({ endpoint, token, proof, signedEvidence
     signal: AbortSignal.timeout(10_000),
   });
   const payload = await response.json().catch(() => null);
-  if (!response.ok) throw new Error(`SQM run evidence upload failed with HTTP ${response.status}${payload?.error ? `: ${typeof payload.error === "string" ? payload.error : payload.error.message || "unknown error"}` : ""}.`);
+  if (!response.ok) throw Object.assign(new Error(`SQM run evidence upload failed with HTTP ${response.status}${payload?.error ? `: ${typeof payload.error === "string" ? payload.error : payload.error.message || "unknown error"}` : ""}.`), safeSqmDiagnostic({ status: response.status, code: payload?.error?.code, requestId: response.headers?.get?.("x-request-id") }, "evidence_upload", "evidence_upload_failed"));
   return { uploaded: true, ...payload };
 }

package/src/sqm/history-store.js

@@ -1,7 +1,8 @@
+import { safeSqmDiagnostic, formatSqmDiagnostic } from "./diagnostics.js";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
-import { formatSqmCoverage } from "./report.js";
+import { formatSqmCoverage, sqmCoverageWarnings } from "./report.js";
 import { defaultSessionRoot } from "../session-store.js";
 
 const LIMIT = 100;
@@ -69,9 +70,10 @@ function metadata(entry) {
   if (!entry || !["analysis", "check"].includes(entry.kind) || typeof entry.key !== "string" || !entry.key.startsWith(entry.kind === "analysis" ? "sqm:" : "sqm-check:")) return null;
   if (!["running", "completed", "failed", "unavailable", "interrupted", "verification_pending"].includes(entry.state) || !Number.isFinite(Date.parse(entry.startedAt))) return null;
   const item = {};
-  for (const name of ["key", "id", "kind", "label", "state", "provider", "phase", "repository", "startedAt", "finishedAt", "instruction", "result", "error", "errorCode", "webUrl"]) {
+  for (const name of ["key", "id", "kind", "label", "state", "provider", "phase", "repository", "startedAt", "finishedAt", "instruction", "result", "error", "errorCode", "errorStage", "requestId", "webUrl"]) {
     if (typeof entry[name] === "string") item[name] = entry[name].slice(0, ["instruction", "result", "error"].includes(name) ? 4096 : 512);
   }
+  if (Number.isInteger(entry.errorStatus) && entry.errorStatus >= 400 && entry.errorStatus <= 599) item.errorStatus = entry.errorStatus;
   return item;
 }
 
@@ -94,15 +96,25 @@ export function createSqmCheckRecorder({ root, scope, phase, cwd, baseBranch, on
     const repository = identity?.repository || result.repository;
     const outcome = proof?.outcome.status || result.min_check?.status || result.status;
     const state = outcome === "unavailable" ? "unavailable" : ["failed", "preliminary_failed"].includes(outcome) ? "failed" : ["requires_human", "requires_post_deploy"].includes(outcome) ? "verification_pending" : "completed";
+    const failure = result.upload?.diagnostic ? safeSqmDiagnostic(result.upload.diagnostic, "evidence_upload", "evidence_upload_failed") : ["failed", "unavailable"].includes(state) && (result.diagnostic || result.error || result.errorCode || !identity)
+      ? safeSqmDiagnostic(result, phase, state === "unavailable" ? "sqm_check_unavailable" : "sqm_check_failed") : null;
+    const minCheck = result.min_check || result;
+    const minWarnings = !proof && Array.isArray(minCheck.matched_modules)
+      ? sqmCoverageWarnings({ moduleCount: minCheck.matched_modules.length,
+        scenarioCount: Array.isArray(minCheck.full_check_plan) ? minCheck.full_check_plan.length :
+          minCheck.matched_modules.reduce((total, module) => total + (module.scenario_ids?.length || 0), 0),
+        noSystemKnowledge: minCheck.matched_modules.length === 0 && minCheck.coverage_reasons?.includes("no_system_knowledge") === true,
+        outcomeStatus: minCheck.status }) : [];
     const summary = proof ? [`Full check: ${proof.outcome.status}`, formatSqmCoverage(proof), `Evidence upload: ${result.upload?.uploaded ? "uploaded" : "kept locally"}`].join("\n")
-      : state === "unavailable" ? "SQM could not obtain a verified result. Retry the command to see current diagnostics."
-      : state === "failed" && !identity ? "The command did not finish. Retry it to see current diagnostics."
+      : state === "unavailable" ? "SQM could not obtain a verified result. See the recorded diagnostics below."
+      : state === "failed" && !identity ? "The command did not finish. See the recorded diagnostics below."
       : `Min-check: ${result.min_check?.status || result.status} · ${(result.preliminary_findings || result.min_check?.preliminary_findings)?.length || 0} preliminary finding(s) · ${(result.matched_modules || result.min_check?.matched_modules)?.length || 0} matched module(s).\nThis is a preflight; run the full check for signed verification.`;
     try {
       await history.record(scope, { key, id: key, kind: "check", phase, state, startedAt, finishedAt: new Date().toISOString(), repository,
         label: `${phase === "min" ? "Min-check" : "Check"} · ${repository || basename(cwd)}`,
         instruction: [repository || basename(cwd), `Base: ${identity?.base_ref || baseBranch}`, identity?.head_commit ? `Head: ${identity.head_commit}` : ""].filter(Boolean).join("\n"),
-        result: summary });
+        result: [summary, ...minWarnings].join("\n"),
+        ...(failure ? { error: formatSqmDiagnostic(failure), errorCode: failure.code, errorStage: failure.stage, errorStatus: failure.status, requestId: failure.requestId } : {}) });
     } catch { onError(); }
   };
 }

package/src/sqm/index.js

@@ -1,3 +1,5 @@
+import { sqmCoverageWarnings } from "./report.js";
+import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createSqmCheckRecorder } from "./history-store.js";
 import { evaluateKnowledgeBundle } from "./checkers.js";
 import { loadKnowledgeBundle } from "./bundle-store.js";
@@ -35,7 +37,7 @@ export function createSqmChecker({
     try {
       repository = await inspectRepositoryImpl(cwd, { baseBranch, runCommand: dependencies.runCommand });
     } catch (error) {
-      return unavailable(`SQM repository inspection failed: ${message(error)}`);
+      return { ...unavailable(`SQM repository inspection failed: ${message(error)}`), diagnostic: safeSqmDiagnostic(error, "repository", "repository_inspection_failed") };
     }
     if (pinnedRepository && pinnedRepository !== repository.repository) return unavailable(`SQM repository changed during a pinned run (${pinnedRepository} to ${repository.repository}).`, repository.repository);
     if (!pinnedLoad) {
@@ -43,7 +45,7 @@ export function createSqmChecker({
       pinnedLoad = loadKnowledgeBundleImpl({ repository: repository.repository, cliVersion, offline, refresh, token, endpoint, accountId, organizationId, ...dependencies });
     }
     const loaded = await pinnedLoad;
-    if (!loaded.bundle) return { ...unavailable(loaded.warnings[0], repository.repository), warnings: loaded.warnings };
+    if (!loaded.bundle) return { ...unavailable(loaded.warnings[0], repository.repository), warnings: loaded.warnings, diagnostic: loaded.diagnostic };
     try {
       const evaluate = executeKnowledgeBundleImpl
         ? async (bundle, currentRepository) => ({ findings: await executeKnowledgeBundleImpl(bundle, currentRepository), modules: [] })
@@ -56,7 +58,7 @@ export function createSqmChecker({
         try {
           full.upload = await uploadRunEvidenceImpl({ endpoint: evidenceEndpoint, token, proof: full.proof, signedEvidence: full.signed_evidence });
         } catch (error) {
-          full.upload = { uploaded: false, reason: `upload_failed: ${message(error)}` };
+          full.upload = { uploaded: false, reason: `upload_failed: ${message(error)}`, diagnostic: safeSqmDiagnostic(error, "evidence_upload", "evidence_upload_failed") };
           full.warnings.push(`SQM signed evidence remains local because Cloud upload failed: ${message(error)}`);
         }
         return full;
@@ -64,7 +66,7 @@ export function createSqmChecker({
       latestMinCheck = await buildMinCheck({ repository, bundle: loaded.bundle, evaluation: await evaluate(loaded.bundle, repository), organizationId: organizationId || loaded.bundle.organization_id, cliVersion });
       return toLegacyCheck(latestMinCheck, loaded);
     } catch (error) {
-      return { ...unavailable(`SQM ${phase} execution failed: ${message(error)}`, repository.repository), bundle: bundleIdentity(loaded.bundle), warnings: [...loaded.warnings, `SQM ${phase} execution failed: ${message(error)}`] };
+      return { ...unavailable(`SQM ${phase} execution failed: ${message(error)}`, repository.repository), bundle: bundleIdentity(loaded.bundle), diagnostic: safeSqmDiagnostic(error, phase, "sqm_execution_failed"), warnings: [...loaded.warnings, `SQM ${phase} execution failed: ${message(error)}`] };
     }
   };
   return async (attempt, options = {}) => {
@@ -72,23 +74,23 @@ export function createSqmChecker({
     try {
       const result = await checkCurrentRepository(attempt, options);
       await save(result); return result;
-    } catch (error) { await save({ status: "failed" }); throw error; }
+    } catch (error) { await save({ status: "failed", diagnostic: safeSqmDiagnostic(error, options.phase || "min") }); throw error; }
   };
 }
 
 export async function runSqmMinCheck(options) {
   const context = await loadContext(options);
-  if (!context.loaded.bundle) return { ...unavailable(context.loaded.warnings[0], context.repository.repository), warnings: context.loaded.warnings };
+  if (!context.loaded.bundle) return { ...unavailable(context.loaded.warnings[0], context.repository.repository), warnings: context.loaded.warnings, diagnostic: context.loaded.diagnostic };
   const evaluation = await (options.evaluateKnowledgeBundleImpl || evaluateKnowledgeBundle)(context.loaded.bundle, context.repository);
   return buildMinCheck({ repository: context.repository, bundle: context.loaded.bundle, evaluation, organizationId: options.organizationId, cliVersion: options.cliVersion });
 }
 
 export async function runSqmCheck(options) {
   const context = await loadContext(options);
-  if (!context.loaded.bundle) return { ...unavailable(context.loaded.warnings[0], context.repository.repository), warnings: context.loaded.warnings };
+  if (!context.loaded.bundle) return { ...unavailable(context.loaded.warnings[0], context.repository.repository), warnings: context.loaded.warnings, diagnostic: context.loaded.diagnostic };
   verifyMinCheck(options.minCheck);
-  if (!sameRepositoryIdentity(options.minCheck.repository_identity, repositoryIdentity(context.repository))) throw new Error("Repository identity changed after min-check; run `simy sqm min-check` again.");
-  if (options.minCheck.knowledge_bundle.digest !== context.loaded.bundle.integrity.digest) throw new Error("Knowledge bundle changed after min-check; run `simy sqm min-check` again so both phases use one pinned bundle.");
+  if (!sameRepositoryIdentity(options.minCheck.repository_identity, repositoryIdentity(context.repository))) throw Object.assign(new Error("Repository identity changed after min-check; run `simy sqm min-check` again."), { code: "repository_identity_changed", stage: "identity_validation" });
+  if (options.minCheck.knowledge_bundle.digest !== context.loaded.bundle.integrity.digest) throw Object.assign(new Error("Knowledge bundle changed after min-check; run `simy sqm min-check` again so both phases use one pinned bundle."), { code: "knowledge_bundle_changed", stage: "identity_validation" });
   const evaluation = await (options.evaluateKnowledgeBundleImpl || evaluateKnowledgeBundle)(context.loaded.bundle, context.repository);
   return buildFullCheck({ repository: context.repository, bundle: context.loaded.bundle, minCheck: options.minCheck, evaluation, organizationId: options.organizationId, cliVersion: options.cliVersion, deviceId: options.deviceId, accountId: options.accountId, signingKeyPath: options.signingKeyPath });
 }
@@ -113,6 +115,13 @@ async function buildMinCheck({ repository, bundle, evaluation, organizationId, c
     preliminary_findings: evaluation.findings,
     matched_modules: evaluation.modules.map((module) => ({ module_id: module.module_id, module_version: module.module_version, state_model_ids: module.state_models.map((model) => model.id), transition_ids: module.state_models.flatMap((model) => model.transitions.map((transition) => transition.id)), stressor_ids: module.stressors.map((stressor) => stressor.id), scenario_ids: module.scenarios.map((scenario) => scenario.id) })),
     full_check_plan: plan,
+    coverage_reasons: [
+      ...(evaluation.modules.length === 0 ? ["no_applicable_rules"] : []),
+      ...(bundle.modules?.length === 0 ? ["no_system_knowledge"] : []),
+    ],
+    warnings: sqmCoverageWarnings({ moduleCount: evaluation.modules.length, scenarioCount: plan.length,
+      noSystemKnowledge: bundle.modules?.length === 0,
+      outcomeStatus: evaluation.findings.some(finding => finding.enforcement === "blocking") ? "preliminary_failed" : "passed" }),
   });
 }
 
@@ -133,12 +142,12 @@ async function buildFullCheck({ repository, bundle, minCheck, evaluation, organi
     proof,
     signed_evidence: signedEvidence,
     signature_verification: verification,
-    warnings: [],
+    warnings: sqmCoverageWarnings({ moduleCount: evaluation.modules.length, scenarioCount: evaluation.modules.reduce((count, module) => count + module.scenarios.length, 0), noSystemKnowledge: bundle.modules?.length === 0, outcomeStatus: proof.outcome.status }),
   };
 }
 
 function toLegacyCheck(minCheck, loaded) {
-  return { status: "checked", mode: "min", repository: minCheck.repository_identity.repository, base_ref: minCheck.repository_identity.base_ref, source: loaded.source, warnings: loaded.warnings, bundle: minCheck.knowledge_bundle, findings: minCheck.preliminary_findings, min_check: minCheck };
+  return { status: "checked", mode: "min", repository: minCheck.repository_identity.repository, base_ref: minCheck.repository_identity.base_ref, source: loaded.source, warnings: [...loaded.warnings, ...(minCheck.warnings || [])], bundle: minCheck.knowledge_bundle, findings: minCheck.preliminary_findings, min_check: minCheck };
 }
 
 function bundleIdentity(bundle) {

package/src/sqm/proof.js

@@ -73,6 +73,7 @@ export function buildProof({ organizationId, repository, bundle, minCheck, evalu
         ...(hasFailure ? ["one_or_more_blocking_checks_failed"] : []),
         ...(advisoryFindingCount > 0 ? ["advisory_findings_observed"] : []),
         ...(evaluation.modules.length === 0 ? ["no_applicable_rules"] : []),
+        ...(bundle.modules?.length === 0 ? ["no_system_knowledge"] : []),
         ...(requiresHuman ? ["human_evidence_required"] : []),
         ...(requiresPostDeploy ? ["post_deploy_evidence_required"] : []),
       ],

package/src/sqm/report.js

@@ -15,9 +15,16 @@ export function formatSqmCoverage(proof) {
   ];
   if (scenarios.length) lines.push(`Scenario evaluations: ${[...statusCounts].map(([status, count]) => `${status}=${count}`).join(" · ")}`);
   if (proof.outcome.reasons.length) lines.push(`Outcome reasons: ${proof.outcome.reasons.join(", ")}`);
-  if (!modules.length) lines.push("No applicable rules: this result does not establish feature or historical incident coverage.");
-  else if (!scenarios.length) lines.push("No scenario evaluations: rule results alone do not establish scenario coverage.");
+  lines.push(...sqmCoverageWarnings({ moduleCount: modules.length, scenarioCount: scenarios.length,
+    noSystemKnowledge: proof.outcome.reasons.includes("no_system_knowledge"), outcomeStatus: proof.outcome.status }));
   if (modules.length && !blocking) lines.push("Advisory-only scope: findings do not block this outcome.");
   lines.push("Scenario evaluations are deterministic checks, not browser/provider/deployed journey evidence. Record incident coverage and delivery acceptance separately.");
   return lines.join("\n");
 }
+
+export function sqmCoverageWarnings({ moduleCount, scenarioCount, noSystemKnowledge, outcomeStatus = "passed" }) {
+  if (noSystemKnowledge) return [`Warning: the selected system/repository's downloaded SQM knowledge bundle has no published knowledge. ${outcomeStatus === "passed" ? "This is a pass with 0 evaluated cases" : "This result has 0 evaluated cases"}; it does not establish feature or historical incident coverage.`];
+  if (!moduleCount) return ["Warning: no applicable rules matched this change (0 evaluated cases). This result does not establish feature or historical incident coverage; it does not mean the system has no past knowledge."];
+  if (!scenarioCount) return ["Warning: No scenario evaluations: rule results alone do not establish scenario coverage."];
+  return [];
+}

package/src/sqm/review-worker.js

@@ -96,12 +96,30 @@ export function createSqmLocalReviewWorker({
   getWorkspaceUrl = () => null,
   recordHistory = async () => {},
   onHistoryError = () => {},
+  now = () => Date.now(),
+  providerFailureCooldownMs = 5 * 60_000,
+  getRecoveryKey = () => null,
 } = {}) {
   if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
   let activeJobId = null;
   let pollPromise = null;
   let closed = false;
   let issue = null;
+  let issueContext = null;
+  const failureDetails = new WeakMap();
+  const pauses = new Map();
+  const contextKey = (provider, scope) => JSON.stringify([scope?.webOrigin, scope?.accountId, scope?.organizationId, provider]);
+  const currentPause = () => pauses.get(contextKey(getProvider(), getHistoryScope()));
+  const pauseForFailure = (error, provider, scope, recoveryKey) => {
+    const failure = failureDetails.get(error) || reviewFailure(error, "claim", provider);
+    if (!["provider_sign_in_required", "provider_model_unsupported", "codex_local_unavailable", "claude_local_unavailable", "desktop_access_required"].includes(failure.code) && ![401, 403].includes(failure.status)) return;
+    const key = contextKey(provider, scope);
+    const failures = Math.min((pauses.get(key)?.failures || 0) + 1, 4);
+    const delay = Math.min(30 * 60_000, Math.max(1000, providerFailureCooldownMs) * 2 ** (failures - 1));
+    pauses.set(key, { code: failure.code, stage: failure.stage, status: failure.status, failures, recoveryKey,
+      retryAt: now() + delay, message: `${formatFailure(failure)}\nNew SQM claims are paused. After fixing this cause, refresh the local AI connection or wait for the next recovery attempt.` });
+    if (pauses.size > 32) pauses.delete(pauses.keys().next().value);
+  };
   const history = [];
   const historyScopes = new WeakMap();
   const visibleHistory = () => history.filter(item => historyScopes.get(item) === JSON.stringify(getHistoryScope()));
@@ -168,7 +186,7 @@ export function createSqmLocalReviewWorker({
         ...leaseBody(claim, provider),
         analysis_output: analysis.output,
         executor_model: analysis.model,
-      }), submitting => { stage = submitting ? "advance" : "analysis"; });
+      }), submitting => { stage = submitting ? "advance" : "analysis"; if (submitting) pauses.delete(contextKey(provider, historyScope)); });
       if (advanced.completed) { await updateTask(claim.job_id, "completed", historyScope); return advanced; }
       stage = "adjudication";
       const { response: completed } = await validatedReview(advanced.request, provider, "invalid_sqm_adjudication_output", adjudication => api.request({
@@ -177,11 +195,12 @@ export function createSqmLocalReviewWorker({
         analysis_output: analysis.output,
         adjudication_output: adjudication.output,
         executor_model: adjudication.model || analysis.model,
-      }), submitting => { stage = submitting ? "complete" : "adjudication"; });
+      }), submitting => { stage = submitting ? "complete" : "adjudication"; if (submitting) pauses.delete(contextKey(provider, historyScope)); });
       await updateTask(claim.job_id, "completed", historyScope);
       return completed;
     } catch (error) {
       const failure = reviewFailure(error, stage, provider);
+      if (error && typeof error === "object") failureDetails.set(error, failure);
       let failureReported = error.failureRecorded === true;
       if (!failureReported) {
         try {
@@ -201,7 +220,9 @@ export function createSqmLocalReviewWorker({
 
   return {
     snapshot() {
-      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, issue };
+      const pause = currentPause();
+      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
+        ...(pause ? { provider_pause: { code: pause.code, status: pause.status, retry_at: new Date(pause.retryAt).toISOString(), message: pause.message } } : {}) };
     },
     desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item })) }; },
     desktopTaskDetail(key) {
@@ -214,9 +235,14 @@ export function createSqmLocalReviewWorker({
       const provider = getProvider();
       if (provider == null) return Promise.resolve(null);
       assertProvider(provider);
+      const historyScope = getHistoryScope();
+      const key = contextKey(provider, historyScope);
+      const recoveryKey = getRecoveryKey(provider);
+      const pause = pauses.get(key);
+      if (pause && pause.recoveryKey === recoveryKey && now() < pause.retryAt) return Promise.resolve(null);
+      if (pause && pause.recoveryKey !== recoveryKey) pauses.delete(key);
       const releaseWork = beginWork?.();
       if (!releaseWork) return Promise.resolve(null);
-      const historyScope = getHistoryScope();
       const workspaceUrl = getWorkspaceUrl();
       pollPromise = (async () => {
         const claim = await api.request({
@@ -226,10 +252,18 @@ export function createSqmLocalReviewWorker({
           lease_seconds: leaseSeconds,
         });
         if (issue) { issue = null; onChange(); }
-        if (!claim?.claimed) return null;
-        return processClaim(claim, provider, historyScope, workspaceUrl);
+        if (!claim?.claimed) {
+          // A successful empty claim proves SIMY access recovered, but it says
+          // nothing about a local provider that has not executed again yet.
+          if (pause?.stage === "claim") pauses.delete(key);
+          return null;
+        }
+        const result = await processClaim(claim, provider, historyScope, workspaceUrl);
+        pauses.delete(key);
+        return result;
       })()
         .catch(async (error) => {
+          pauseForFailure(error, provider, historyScope, recoveryKey);
           if (error.jobId && /^[a-f0-9-]{36}$/i.test(error.jobId) && !history.some(item => item.id === error.jobId)) {
             const scope = historyScope;
             const failure = reviewFailure(error, "claim", provider);
@@ -239,6 +273,7 @@ export function createSqmLocalReviewWorker({
             history.unshift(item); historyScopes.set(item, JSON.stringify(scope)); history.splice(50);
             await persist(scope, item);
           }
+          issueContext = key;
           issue = error.status === 403 ? "forbidden" : error.status === 401 ? "signed_out" : "unavailable";
           onError(error);
           return null;