@awak-app/simy-cli 0.5.29 → 0.5.30

package/README.md

@@ -342,6 +342,14 @@ SQM deliberately has two identity-bound stages:
    state transitions, invariants, stress/strength expectations, and scenarios,
    writes `proof.json`, and signs that proof with the local device identity.
 
+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.
+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
+and writes no new proof; any older artifact is not evidence for that attempt.
+
 Normal runs do not require a separate sync command: the CLI
 uses a verified local cache and revalidates it with TTL and ETag semantics.
 The Agentic Loop runs min-check after each code modification and the full check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.29",
+  "version": "0.5.30",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -40,7 +40,7 @@
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/claude-parity-runtime-e2e.js && node --check ./scripts/claude-plugin-runtime-e2e.js",
-    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js",
+    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js",
     "check:package": "node ./scripts/check-package-contents.js",
     "build:macos-installer:dev": "bash packaging/build-macos-arm64.sh --unsigned-dev",
     "build:macos-installer": "bash packaging/build-macos-arm64.sh --production",

package/src/agent.js

@@ -10,6 +10,7 @@ import {
   createRun,
   increaseLocalCodingRunProviderTokenBudget,
   LocalRunRegistry,
+  markCodingRunMonitorFailure,
   isLocalRepositoryApprovalPending,
   pauseLocalCodingRun,
   queueLocalCodingGuidance,
@@ -19,10 +20,12 @@ import {
   restoreRun,
   resumeLocalCodingRun,
   startLocalCodingRun,
+  syncLocalCodingRun,
   stopLocalCodingRun,
   toCompatibleCodingLoopState,
   toLedgerSnapshot,
 } from "./runner.js";
+import { codingRunsRoot, loadCodingRunSnapshots, saveCodingRunSnapshot } from "./coding-run-store.js";
 import {
   expiresAtFromNow,
   isSessionValid,
@@ -134,6 +137,7 @@ import {
 } from "./connection-discovery.js";
 
 const DEVICE_HEARTBEAT_INTERVAL_MS = 20_000;
+const CODING_RUN_MONITOR_INTERVAL_MS = 5 * 60_000;
 
 export async function startAgent({
   requestedPort = 0,
@@ -148,6 +152,7 @@ export async function startAgent({
 } = {}) {
   const apiOrigin = resolveWebOrigin(webOrigin);
   const registry = new LocalRunRegistry();
+  const codingRunStateRoot = codingRunsRoot(sessionRoot);
   const directRegistry = new DirectTaskRegistry();
   const localTaskRegistry = new LocalTaskRegistry();
   const taskStorageRoot = localTasksRoot(
@@ -217,6 +222,8 @@ export async function startAgent({
   let port = requestedPort;
   let heartbeatTimer = null;
   let heartbeatInFlight = null;
+  let codingRunMonitorTimer = null;
+  let codingRunMonitorInFlight = null;
   let shuttingDown = false;
   const notifyDesktopStatusChange = () => {
     if (shuttingDown) return;
@@ -296,6 +303,14 @@ export async function startAgent({
     return loginUrl.toString();
   };
 
+  const publishOrSyncRestoredRun = async (run) => {
+    if (run.restoredFromState || run.restoredObjectiveUnverified) {
+      await publishRestoredLocalCodingRun(run);
+    } else {
+      syncLocalCodingRun(run);
+    }
+  };
+
   const restoreRemoteRuns = async () => {
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
     const snapshots = dependencies.listRemoteRuns
@@ -309,24 +324,113 @@ export async function startAgent({
           apiBaseUrl: session.api_base_url,
           token: session.token,
         });
+    const remoteIds = new Set();
     let restored = false;
     for (const snapshot of snapshots) {
       if (shuttingDown) return;
-      if (!snapshot?.id || registry.has(snapshot.id)) continue;
+      if (!snapshot?.id) continue;
+      remoteIds.add(snapshot.id);
+      if (registry.has(snapshot.id)) {
+        const localRun = registry.get(snapshot.id);
+        localRun.session = session;
+        localRun.apiOrigin = apiOrigin;
+        const remoteTime = Date.parse(snapshot.updated_at || "") || 0;
+        const localTime = Date.parse(localRun.snapshot.updated_at || "") || 0;
+        if (remoteTime > localTime) {
+          const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
+          const remoteRun = restoreRun({
+            snapshot, session, apiOrigin,
+            localPath: repository?.local_path || null,
+            localStateRoot: codingRunStateRoot,
+          });
+          Object.assign(localRun, {
+            request: remoteRun.request,
+            status: remoteRun.status,
+            snapshot: remoteRun.snapshot,
+            controlState: remoteRun.controlState,
+            completedAt: remoteRun.completedAt,
+            restoredFromState: remoteRun.restoredFromState,
+            restoredObjectiveUnverified: remoteRun.restoredObjectiveUnverified,
+          });
+          await saveCodingRunSnapshot(codingRunStateRoot, localRun.snapshot);
+          await publishRestoredLocalCodingRun(localRun);
+        } else {
+          await publishOrSyncRestoredRun(localRun);
+        }
+        continue;
+      }
       const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
       const restoredRun = restoreRun({
         snapshot,
         session,
         apiOrigin,
         localPath: repository?.local_path || null,
+        localStateRoot: codingRunStateRoot,
       });
       registry.create(restoredRun);
       restored = true;
       await publishRestoredLocalCodingRun(restoredRun);
     }
+    for (const localRun of registry.list()) {
+      if (!remoteIds.has(localRun.id)) await publishOrSyncRestoredRun(localRun);
+    }
     if (restored) notifyDesktopStatusChange();
   };
 
+  const restoreLocalCodingRuns = async () => {
+    const { snapshots, errors } = await loadCodingRunSnapshots(codingRunStateRoot);
+    for (const error of errors) {
+      reportStartupConnectionError(new Error(`Coding run ${error.id}: ${error.message}`), quiet);
+    }
+    for (const snapshot of snapshots) {
+      const boundDevice = snapshot?.metadata?.execution_device_id;
+      if (boundDevice && boundDevice !== session?.device_id) continue;
+      if (registry.has(snapshot.id)) {
+        const existing = registry.get(snapshot.id);
+        existing.session = session;
+        existing.apiOrigin = apiOrigin;
+        continue;
+      }
+      try {
+        const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
+        const run = restoreRun({
+          snapshot, session, apiOrigin,
+          localPath: repository?.local_path || null,
+          localStateRoot: codingRunStateRoot,
+        });
+        // Keep the persisted timestamp until the Web ledger has been compared.
+        // Publishing recovery here would make an older local record look newest.
+        registry.create(run);
+      } catch (error) {
+        reportStartupConnectionError(error, quiet);
+      }
+    }
+  };
+
+  const monitorCodingRuns = () => {
+    if (!daemon || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve();
+    if (codingRunMonitorInFlight) return codingRunMonitorInFlight;
+    codingRunMonitorInFlight = (async () => {
+      for (const run of registry.list()) {
+        if (!["pr_ready_for_review", "merge_ready"].includes(run.status) || run.operation || run.child) continue;
+        try {
+          await (dependencies.recheckCodingRun || recheckLocalCodingRun)(run);
+        } catch (error) {
+          await markCodingRunMonitorFailure(run, error);
+        }
+      }
+    })().finally(() => { codingRunMonitorInFlight = null; });
+    return codingRunMonitorInFlight;
+  };
+
+  const startCodingRunMonitor = () => {
+    if (!daemon || codingRunMonitorTimer) return;
+    codingRunMonitorTimer = setInterval(() => {
+      void monitorCodingRuns().catch((error) => reportStartupConnectionError(error, quiet));
+    }, dependencies.codingRunMonitorIntervalMs || CODING_RUN_MONITOR_INTERVAL_MS);
+    codingRunMonitorTimer.unref();
+  };
+
   const heartbeat = () => {
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve(false);
     if (heartbeatInFlight) return heartbeatInFlight;
@@ -406,7 +510,9 @@ export async function startAgent({
       reportHeartbeatError(error, quiet);
     }
     try {
+      await restoreLocalCodingRuns();
       await restoreRemoteRuns();
+      startCodingRunMonitor();
     } catch (error) {
       reportStartupConnectionError(error, quiet);
     }
@@ -1389,8 +1495,10 @@ export async function startAgent({
           },
           session,
           apiOrigin,
+          localStateRoot: codingRunStateRoot,
         });
         try {
+          await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
           registry.create(run);
         } catch (error) {
           await cleanupRunAttachments(stagedAttachments);
@@ -1678,8 +1786,10 @@ export async function startAgent({
       await refreshAuthorizedRepositoryInventory();
       if (shuttingDown) return;
       await heartbeat();
+      await restoreLocalCodingRuns();
       if (shuttingDown) return;
       await restoreRemoteRuns();
+      startCodingRunMonitor();
     } catch (error) {
       reportStartupConnectionError(error, quiet);
     }
@@ -1703,6 +1813,8 @@ export async function startAgent({
     shuttingDown = true;
     shutdownPromise = (async () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
+      if (codingRunMonitorTimer) clearInterval(codingRunMonitorTimer);
+      if (codingRunMonitorInFlight) await codingRunMonitorInFlight;
       updateManager?.stop?.();
       await sqmLocalReviewWorker?.close?.();
       await durableLocalTaskWorker?.close?.();
@@ -1824,7 +1936,8 @@ export async function startAgent({
             });
         const runId = String(remoteRun?.id || "");
         if (!runId) throw new Error("SIMY Web did not return an Agentic Loop run id.");
-        const run = createRun({ runId, request, session, apiOrigin });
+        const run = createRun({ runId, request, session, apiOrigin, localStateRoot: codingRunStateRoot });
+        await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
         registry.create(run);
         void startLocalCodingRun(run, runOptions);
         return run;

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.29";
+export const CLI_VERSION = "0.5.30";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/skills/sqm-loop/SKILL.md

@@ -14,7 +14,9 @@ Treat the current Codex thread, its attachments, and the active repository as th
 3. Run `simy sqm min-check` from the repository root.
 4. Run `simy sqm check --proof proof.json --signed-evidence proof.json.signed.json`.
 5. Read `proof.json` and require `outcome.status` to be `passed` before reporting success or proposing a pull request.
-6. Report the checked repository/revision, proof paths, outcome, blockers, and any evidence gap.
+6. Verify the proof's repository, base, HEAD and working-tree/diff identity against the candidate, and verify its bound signature with SQM tooling. Use separate artifact paths outside the diff; do not edit between min-check and check or reuse stale proof after a candidate change.
+7. Report outcome reasons, matched modules, evaluated rules and scenario statuses from `executions`, separating blocking and advisory results. `passed` with `no_applicable_rules`, zero scenario evaluations, or advisory-only checks is not feature or incident coverage. Scenario statuses are deterministic evaluations, not evidence that a browser, provider or deployed journey ran. Record relevant uncovered review findings and their concrete regression evidence or remaining gap.
+8. Report the checked repository/revision, proof paths, outcome, blockers, and any evidence gap. Keep delivery acceptance pending for unverified applicable paths even when SQM passes.
 
 If implementation is required before the check can pass, obtain or confirm the user's change authorization and make the smallest relevant repair. A request to run SQM alone does not authorize unrelated edits, a PR, merge, deployment, or external messages.
 

package/src/coding-run-store.js

@@ -0,0 +1,69 @@
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { redactExecutionValue } from "./orchestrator/execution-io.js";
+
+const RUN_ID = /^[A-Za-z0-9_-]{1,160}$/;
+const writes = new Map();
+
+export function codingRunsRoot(sessionRoot) {
+  return path.resolve(sessionRoot || path.join(homedir(), ".simy"), "coding-runs");
+}
+
+export async function saveCodingRunSnapshot(root, snapshot) {
+  const id = String(snapshot?.id || "");
+  if (!RUN_ID.test(id)) throw new Error("Invalid coding run ID for durable storage.");
+  // Capture at enqueue time: later mutations must not rewrite a queued version.
+  snapshot = redactExecutionValue(snapshot);
+  const directory = path.resolve(root);
+  const key = path.join(directory, id);
+  const previous = writes.get(key) || Promise.resolve();
+  const current = previous.catch(() => undefined).then(async () => {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const body = JSON.stringify(snapshot);
+    const document = JSON.stringify({
+      version: 1,
+      sha256: createHash("sha256").update(body).digest("hex"),
+      snapshot,
+    });
+    const target = `${key}.json`;
+    const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${document}\n`, { mode: 0o600 });
+    await rename(temporary, target);
+  });
+  writes.set(key, current);
+  try { await current; } finally {
+    if (writes.get(key) === current) writes.delete(key);
+  }
+}
+
+export async function loadCodingRunSnapshots(root) {
+  let files;
+  try {
+    files = await readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return { snapshots: [], errors: [] };
+    throw error;
+  }
+  const snapshots = [];
+  const errors = [];
+  for (const file of files) {
+    if (!file.isFile() || !file.name.endsWith(".json")) continue;
+    const id = file.name.slice(0, -5);
+    if (!RUN_ID.test(id)) continue;
+    try {
+      const document = JSON.parse(await readFile(path.join(root, file.name), "utf8"));
+      const body = JSON.stringify(document.snapshot);
+      const hash = createHash("sha256").update(body).digest("hex");
+      if (document.version !== 1 || document.sha256 !== hash || document.snapshot?.id !== id) {
+        throw new Error("Coding run record failed integrity check.");
+      }
+      snapshots.push(document.snapshot);
+    } catch (error) {
+      errors.push({ id, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { snapshots, errors };
+}

package/src/local-task.js

@@ -1,3 +1,4 @@
+import { buildWorkflowReportingInstruction } from "./workflow-reporting.js";
 import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { EventEmitter, once } from "node:events";
@@ -957,6 +958,7 @@ function localTaskProviderInstruction(task) {
     : null;
   return [
     "You are the local executor for a SIMY Local Task, not an Agentic Loop.",
+    buildWorkflowReportingInstruction(),
     "Complete this bounded task once. Do not create Git branches, commits, pull requests, audits, or automatic retries.",
     `Permission mode: ${task.permission_mode}.`,
     `Task workspace: ${task.workspace_path}`,

package/src/orchestrator/audit.js

@@ -16,6 +16,7 @@ import {
 } from "./pr-preparation.js";
 import {
   completionEvidenceChecks,
+  hasUserOutcomeProof,
   normalizeVisualReview,
 } from "./completion-contract.js";
 
@@ -340,6 +341,8 @@ export function evaluatePrReadiness(charter, attempt) {
     readinessCheck("minimum_independent_binding",
       Boolean(independentAudit?.evidence_identity_sha256 && independentAudit.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt)),
       "Independent review must cover the current head, base, CI, skips, preparation rows, companion revisions, and minimum evidence."),
+    readinessCheck("user_outcome_proven", hasUserOutcomeProof(independentAudit?.coverage_review),
+      "Independent review must observe the original user outcome and cite its evidence."),
     readinessCheck("implementation_gate", attempt.audit?.passed === true, "Implementation gate must pass."),
     readinessCheck("pr_preparation_gate", preparation.passed, preparation.detail),
     readinessCheck(

package/src/orchestrator/checklist-continuation.js

@@ -8,12 +8,12 @@ export const ACCEPTANCE_EVIDENCE_PATH = fileURLToPath(
 export function buildChecklistContinuationInstruction({ auditor = false } = {}) {
   return section("checklist_continuation_contract", [
     `The table is a progress checkpoint, not the deliverable or a stopping condition. Read: ${ACCEPTANCE_EVIDENCE_PATH}`,
-    "Show the complete 依頼チェックリスト with columns #, ご依頼, 現状, 判定 after chartering, each evaluated attempt, and in the final receipt. Preserve stable criterion IDs, all rows and both applicable evidence layers. ✅ requires current valid passing evidence for every applicable layer; ❌ means an observed failure; 🟡 means pending, missing, stale, blocked or unverifiable evidence. Show counts and highest proven state.",
-    "After presenting any non-green row, classify its cause and immediately take the next safe authorized action: implement missing behavior, repair a failure, exercise an untested path, collect missing evidence, or rerun stale verification. Re-observe the same criterion against the current candidate, run the validator, update the table, and repeat until every applicable requested outcome and gate for the authorized endpoint is verified. A next-action list without performing feasible actions is not completion. Never require another continue request merely because a table was shown.",
+    "Maintain the complete 依頼チェックリスト with columns #, ご依頼, 現状, 判定 in the evidence record after chartering, each evaluated attempt, and in the final receipt. User-facing reporting follows workflow_reporting_contract; show the full table only when requested or when it is the most useful requested answer, never as mandatory commentary. Preserve stable criterion IDs, all rows and both applicable evidence layers. ✅ requires current valid passing evidence for every applicable layer; ❌ means an observed failure; 🟡 means pending, missing, stale, blocked or unverifiable evidence. Retain counts and highest proven state in that record.",
+    "After observing any non-green row, classify its cause and immediately take the next safe authorized action: implement missing behavior, repair a failure, exercise an untested path, collect missing evidence, or rerun stale verification. Re-observe the same criterion against the current candidate, run the validator, update the table, and repeat until every applicable requested outcome and gate for the authorized endpoint is verified. A next-action list without performing feasible actions is not completion. Never require another continue request merely because a table was shown.",
     "For CI or other in-progress dependencies, use the available bounded wait/recheck or approved monitoring mechanism and maintain progress communication. Unchanged external state is not itself a blocker. Do not start duplicate jobs or busy-poll. Recheck current revision/results, repair authorized failures, and keep waiting only within the existing time, attempt and cost limits. If waiting cannot continue, report the concrete limit and explicit resumption condition; do not silently abandon it or promise an unscheduled follow-up.",
     "If a row genuinely requires new authority, credentials, a user/product decision, an unavailable dependency or an exhausted safety budget, retain it as non-green and record affected IDs, evidence of the blocker, safe alternatives attempted, exact missing input, owner and resumption trigger. Continue independent in-scope work. Stop with blocked, best_available, failed or cancelled as appropriate, explicitly unfinished, not verified_complete. Never raise budgets, bypass a stop, or expand authority to force green.",
     "Do not end successfully while a safe authorized repair, verification or bounded wait remains. All-green applies to the frozen authorized endpoint: PR-only work does not authorize merge/deploy, but a PR URL, an improvement PR, an issue, a narrower test or a future plan does not satisfy an unmet outcome. Never drop/merge away rows, weaken criteria, relabel applicable checks as not_applicable, recolor unknowns, or copy new digests onto old evidence to force green. Do not change the requested endpoint to match the work already completed.",
-    "Before the final response, independently reconcile the original request with all criterion IDs and current evidence, check remaining endpoint gates, and display the full table and explicit disposition. Distinguish a partial artifact from verified completion and state both yellow/red counts and what remains. A pr_ready_for_review or blocked controller state is not proof of overall completion. These instructions strengthen continuation and reporting; they do not add a background scheduler or remove controller limits.",
+    "Before the final response, independently reconcile the original request with all criterion IDs and current evidence, check remaining endpoint gates, and preserve the full table and explicit disposition in the evidence record. Distinguish a partial artifact from verified completion and disclose material remaining outcomes in the requested response format; keep yellow/red counts in the record. A pr_ready_for_review or blocked controller state is not proof of overall completion. These instructions strengthen continuation and reporting; they do not add a background scheduler or remove controller limits.",
     auditor
       ? "Remain read-only. Check that the executor performed feasible follow-up actions after non-green tables. Report premature stopping, omitted rows, unsupported green claims, or a blocker without evidence as findings, alongside exact criterion IDs and the necessary next action. Do not approve from a table's colors or the executor's completion wording."
       : "Execute the continuation within this attempt instead of merely returning a yellow table or delegating feasible remaining work to the requester. Return control honestly at a genuine boundary; never fabricate completion evidence.",

package/src/orchestrator/completion-contract.js

@@ -4,6 +4,13 @@ import { cleanString, stringArray } from "./shared.js";
 export const COMPLETION_CONTRACT_VERSION = 2;
 const criterionIdPattern = /^[A-Za-z][A-Za-z0-9]*(?:[-_.][A-Za-z0-9]+)*$/;
 
+export function hasUserOutcomeProof(coverage) {
+  const proof = coverage?.user_outcome;
+  return proof?.passed === true && Boolean(cleanString(proof.verification_method)) &&
+    Boolean(cleanString(proof.observed_result)) && Array.isArray(proof.evidence_refs) &&
+    proof.evidence_refs.some((ref) => Boolean(cleanString(ref)));
+}
+
 export function buildCompletionContract({
   inherited,
   requirement,

package/src/orchestrator/contract.js

@@ -10,6 +10,7 @@ import {
 import { budgetState, resolveRunBudgets } from "./budget.js";
 import { classifyRisk } from "./risk.js";
 import { buildCompletionContract } from "./completion-contract.js";
+import { freezeObjective } from "./outcome-monitor.js";
 import { defaultPrPreparationContract } from "./pr-preparation.js";
 import {
   DESKTOP_EXECUTION_TARGET,
@@ -56,11 +57,11 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
     cleanString(charterContext.acceptance_criteria_source) === "explicit"
       ? "explicit"
       : acceptanceCriteria.length > 0 &&
-          cleanString(charterContext.acceptance_criteria_source) === "default"
-        ? "default"
+          cleanString(charterContext.acceptance_criteria_source) === "request"
+        ? "request"
         : acceptanceCriteria.length > 0
           ? "explicit"
-          : "default";
+          : "request";
   const inheritedRequiredChecks = stringArray(charterContext.required_checks);
   const inheritedNonGoals = stringArray(charterContext.non_goals);
   const inheritedArtifacts = stringArray(charterContext.artifacts_required);
@@ -71,7 +72,7 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
     acceptanceCriteria.length > 0
       ? acceptanceCriteria
       : [
-          "The requested change is implemented without unrelated scope.",
+          cleanString(request.requirement),
           "Relevant tests pass and are recorded.",
           `A pull request targets ${baseBranch}.`,
         ];
@@ -216,6 +217,7 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
     updated_at: now,
   };
   snapshot.budget = budgetState(snapshot);
+  freezeObjective(snapshot.charter);
   return snapshot;
 }
 

package/src/orchestrator/delivery/WORKFLOW.md

@@ -30,6 +30,28 @@ deployment, exact-revision verification, and cleanup gates in this workflow. Do
 push these development-only gates into every personal workflow merely because
 they are required here.
 
+## Report outcomes in the requested form
+
+Apply the common [outcome reporting contract](../../workflow-reporting.md) to
+executor progress, user-facing summaries and independent review. The runtime
+injects the same instruction into Coding execution/audit and non-coding Local
+Tasks; this is a model instruction, not a semantic output filter or a new gate.
+Keep the outcome contract, execution evidence and response contract distinct.
+Reporting-only corrections do not waive acceptance, change the goal or grant
+new authority. Preserve requested questions/order/omissions on retry and resume.
+Respond to the user's decisions and outcomes; keep routine diagnostics and
+unchanged waits in the existing evidence record. Follow requested cadence and
+host-required liveness updates without inventing progress.
+
+## Confirm asynchronous handoffs and recover safely
+
+Apply the common asynchronous handoff contract in [outcome reporting](../../workflow-reporting.md).
+Submission accepted is not execution started. Keep the original operation identity,
+resolve the canonical resource and verify the requested start/outcome boundary.
+Missing list entries are inconclusive. Reconcile before resubmitting; use supported
+idempotent recovery and bounded waits, and report an actual blocker when recovery
+cannot proceed. A promise to investigate does not satisfy the recovery obligation.
+
 ## Confirm the delivery level in chat
 
 Before material implementation, read [delivery levels](references/delivery-levels.md),
@@ -147,11 +169,12 @@ checklists held only in chat or the model's memory are insufficient.
 Update the matrix and table after every evaluated test, repair, review, or scope,
 revision, or environment change. Preserve prior snapshots/receipts and reset
 invalidated rows to pending; never delete a failed criterion to make the table
-green. Report the new highest proven state and the remaining rows.
+green. Record the new highest proven state and the remaining rows internally;
+user-facing updates follow the response contract.
 
-Use the compact request checklist as the loop's default visible progress surface.
+Use the compact request checklist as the evidence record's status surface.
 After freezing the charter, after each evaluated attempt, and in the final
-receipt, show a Markdown table in chat headed `依頼チェックリスト` with exactly
+evidence receipt, maintain a Markdown table headed `依頼チェックリスト` with
 these columns: `#`, `ご依頼`, `現状`, `判定`. Render one numbered row per frozen
 criterion, combining its user and system verification layers into one honest
 status:
@@ -176,7 +199,10 @@ make the presentation green.
 
 ### Continue after the table; do not stop at yellow
 
-The table is an intermediate checkpoint. Immediately classify each non-green row
+The evidence table is an intermediate checkpoint, not mandatory chat output.
+Show it when requested or when it best answers the request; a specified response
+format takes precedence. Otherwise report the outcome and material gaps concisely.
+Immediately classify each non-green row
 and perform the next safe authorized action: implementation or repair for missing
 or failed behavior, execution/evidence collection for untested paths, and fresh
 verification for stale results. Re-observe the same criterion, run the validator,
@@ -201,8 +227,10 @@ non-green. All-green targets only the authorized endpoint, not unrequested merge
 or deployment. Never weaken criteria or raise budgets to force green.
 
 Before the final response, reconcile original requirements, all IDs, current
-evidence and endpoint gates; display the full table, counts, highest proven state
-and disposition. Independent audit checks premature stopping as well as evidence.
+evidence and endpoint gates; retain the full table, counts, highest proven state
+and disposition in the evidence receipt. The user-facing answer follows the response
+contract and discloses material unmet outcomes. Independent audit checks premature
+stopping, answer relevance and hidden limitations as well as evidence.
 
 For user-facing outcomes, require both goal-driven user interaction and technical
 invariant checks against the same run and context. For saving, test save/reload/
@@ -395,6 +423,65 @@ from an earlier one. In particular:
 
 ## Run one controlled loop
 
+The controller freezes the original user goal, outcome, minimum scope, proof
+requirements, non-goals, finish line, and stable acceptance IDs in the persisted
+charter. If explicit acceptance criteria are absent, the user's goal itself is
+the first acceptance criterion; tests and PR creation cannot replace that
+outcome. Direct human changes create a successor version with the old contract
+preserved. An unrecorded edit blocks execution and PR recheck. An approved
+revision invalidates the previous independent outcome assessment; do not reuse
+old evidence to claim the revised goal was met.
+Even when a caller supplies its own acceptance list, independent review must
+separately prove the original user goal with an observed operation and
+postcondition. A process-only acceptance list cannot waive that goal.
+
+After each attempt the controller records which acceptance IDs were positively
+supported by the independent auditor. If no independent review occurred, report
+insufficient evidence. When a further reviewed attempt leaves the same user
+outcomes unproven without adding any independently supported outcome, stop
+automatic retries and require a revised approach against the approved objective.
+Changed code, passing tests, and additional review comments do not themselves
+count as outcome progress. Each state transition is written to a private local
+run record before it is published; failed Web ledger updates are retried. On
+restart, an unverifiable objective cannot retain completion status. An
+authenticated SIMY CLI daemon rechecks PR-ready runs every five minutes,
+including after the chat ends. It revokes a completion claim when current
+verification is unavailable. Monitoring requires the daemon and host to remain
+running; it does not monitor unrelated Codex Desktop tasks or execute repairs
+without an authorized run.
+
+For a Codex Desktop task whose requested outcome must be checked after the
+conversation ends, register a Codex app heartbeat against that task before
+claiming it is monitored. Preserve the original outcome, acceptance evidence,
+the exact task or operation identity, the requested completion boundary, and
+the response preferences, cadence, time/attempt/cost limits, and stop or
+ask-user conditions in the heartbeat prompt. Verify that the automation
+is active and bound to the intended task. On each run, use the Codex app's
+supported task status and wait/read operations to distinguish a queued creation
+ID, a resolved task ID, execution start, and the actual result. An absent list
+entry or an idle label alone is not a terminal result. Reconcile the exact
+operation before any retry; do not create a replacement while its fate is
+unknown. Report an actionable blocker if identity, access, or evidence cannot
+be resolved. Stay quiet on unchanged non-actionable state, and stop the
+heartbeat when the accepted outcome is proved or monitoring is explicitly
+cancelled. On authoritative failure, exhausted limits, or an unresolved
+terminal identity/access blocker, report the evidence and pause or stop the
+heartbeat pending a human decision. This is a separately registered,
+task-scoped Codex app monitor;
+the CLI daemon does not automatically register it or cover every Desktop task.
+For a delegated implementation task, compare monitoring cadence with actual
+execution. If its canonical task is idle and authorized acceptance work remains,
+record a stall rather than a quiet unchanged status. With explicit recovery
+authority and supported task tools, wake the same task once and verify its
+execution starts; keep the outcome open
+until independent acceptance evidence changes. A read-only monitor reports the
+stall and owner instead. If a task is active but acceptance evidence has not
+advanced over the agreed window, inspect its work and external waits before
+calling it stalled. Never describe monitoring or an attempted wake as delivery.
+Use the [Desktop task monitoring triggers](references/desktop-monitor-triggers.md)
+when choosing an observation cadence, stall threshold, resume action, notification,
+and duplicate-prevention rule for a Codex app heartbeat.
+
 For each attempt:
 
 1. **Observe:** load the current snapshot and revision-bound evidence.

package/src/orchestrator/delivery/references/acceptance-evidence.md

@@ -110,11 +110,15 @@ Show green/yellow/red counts, the highest proven state, and validator status
 immediately below the compact table. In a terminal receipt,
 the controller also prints its disposition there.
 
-The compact table is the default progress view shown in chat after the charter is
-frozen, after every evaluated attempt, and in the final receipt. `checklist.md`
-also retains the detailed layer table so evidence, methods, and repairs remain
-reviewable. Chat output may link to that detail instead of duplicating it, but it
-must not omit non-green compact rows. Do not turn `pr_ci_green`, a healthy service,
+The compact table is maintained in the evidence record after the charter is
+frozen, after every evaluated attempt, and in the final evidence receipt.
+`checklist.md` also retains the detailed layer table so evidence, methods, and
+repairs remain reviewable. User-facing reporting follows the common
+[outcome reporting contract](../../../workflow-reporting.md). Show the table when
+requested or when it best answers the request, not after every internal step.
+An A/B-only or no-test-detail instruction takes precedence over the default table.
+Keep every non-green row internally and disclose any material effect on the
+requested answers or completion claim; brevity cannot hide incomplete delivery. Do not turn `pr_ci_green`, a healthy service,
 or a passing narrow check into a green request row unless every applicable layer
 for that criterion passed against the current charter and context.