@awak-app/simy-cli 0.5.10 → 0.5.12

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/state-and-receipts.md

@@ -9,6 +9,8 @@ Persist one controller-owned snapshot with at least:
 
 - `run_id`, `state`, monotonic `revision`, and terminal disposition;
 - immutable explicit conditions and their stable digest;
+- frozen experience-contract identities, their mapping to acceptance rows, and
+  the current readable local-experience table path and digest;
 - acceptance-source identities and digests, architecture boundaries, applicable
   rule decisions, risk tier, requested/effective delivery levels, the safety
   ceiling reason, and chat-confirmation receipt;
@@ -135,6 +137,7 @@ For the full delivery mode:
 done =
   reproduction_verified
   && acceptance_evidence_complete
+  && minimum_functional_evidence_verified
   && locally_verified
   && pr_ci_green
   && integration_verified
@@ -155,3 +158,8 @@ with current context and the required user/system layers. After each evaluated
 action, refresh the JSON matrix and its readable table; append a receipt for the
 update. Keep the frozen charter distinct from mutable results. A charter patch
 supersedes the old digest only after the controller verifies its authority.
+For `user_like_local_verified`, the current table must cover the frozen experience
+contract from real trigger to usable outcome for the exact local candidate. A
+collection of narrower passing rows does not waive a missing end-to-end row.
+
+The CLI records minimum evidence in observed_evidence.minimum_completion, independently of executor status. The independent audit is bound to its matrix digest. Legacy v2 histories remain readable, but missing minimum evidence cannot be reused as passing evidence on resume/recheck. Missing or unsupported charters require a refresh; they do not disable verification.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs

@@ -25,7 +25,15 @@ function requireValue(condition, message) {
 }
 
 function validateCharter(charter) {
-  requireValue(object(charter) && charter.schema_version === 1 && text(charter.run_id), "Invalid charter header");
+  requireValue(object(charter) && [1, 2].includes(charter.schema_version) && text(charter.run_id), "Invalid charter header");
+  if (charter.schema_version === 2) {
+    requireValue(object(charter.experience), "Experience contract required");
+    for (const field of ["beneficiary", "situation", "goal", "usable_outcome", "recovery"])
+      requireValue(text(charter.experience[field]), `Experience contract needs ${field}`);
+    requireValue(Array.isArray(charter.experience.forbidden_experiences) &&
+      charter.experience.forbidden_experiences.length > 0 &&
+      charter.experience.forbidden_experiences.every(text), "Experience contract needs forbidden experiences");
+  }
   requireValue(Array.isArray(charter.criteria) && charter.criteria.length > 0, "Charter requires criteria");
   const ids = new Set();
   for (const criterion of charter.criteria) {
@@ -60,7 +68,7 @@ function validateContext(context, runId) {
   }
 }
 
-async function checkArtifact(root, artifact) {
+export async function readEvidenceArtifact(root, artifact) {
   requireValue(object(artifact) && text(artifact.path) && hashPattern.test(artifact.sha256), "Invalid artifact reference");
   // Explicit bundle-relative paths only; never fetch URLs or execute evidence.
   const segments = artifact.path.split("/");
@@ -77,7 +85,9 @@ async function checkArtifact(root, artifact) {
   try {
     const stat = await handle.stat();
     requireValue(stat.isFile() && stat.size > 0 && stat.size <= 16 * 1024 * 1024, "Artifact must be a nonempty regular file of at most 16 MiB");
-    requireValue(sha256(await handle.readFile()) === artifact.sha256, "Artifact digest mismatch");
+    const bytes = await handle.readFile();
+    requireValue(sha256(bytes) === artifact.sha256, "Artifact digest mismatch");
+    return bytes;
   } finally {
     await handle.close();
   }
@@ -86,15 +96,24 @@ async function checkArtifact(root, artifact) {
 const tableText = (value) => String(value ?? "").replaceAll("|", "\\|").replace(/[\r\n]+/g, " ");
 
 export function renderChecklist(report) {
+  const experienceContext = report.experience
+    ? `${report.experience.beneficiary} / ${report.experience.situation}`
+    : "Legacy charter: persona and situation not recorded";
   const header = [
-    "| Criterion / outcome | Layer / method | Status | Observation | Evidence | Unmet reason / next action |",
-    "| --- | --- | --- | --- | --- | --- |",
+    "| Experience criterion / expected outcome | Persona / situation | Layer / method | Status | Actual observation | Evidence | Unmet reason / next repair |",
+    "| --- | --- | --- | --- | --- | --- | --- |",
   ];
   const rows = report.checks.map((row) => "| " + [
-    `${row.id}: ${row.outcome}`, `${row.layer}: ${row.method}`, row.status,
+    `${row.id}: ${row.outcome}`, experienceContext,
+    `${row.layer}: ${row.method}`, row.status,
     row.observation, row.evidence.join(", "), [row.reason, row.next_action].filter(Boolean).join(" / "),
   ].map(tableText).join(" | ") + " |");
+  const context = report.context;
+  const candidate = context
+    ? `Candidate context: stage=${tableText(context.stage)}; environment=${tableText(context.environment)}; fixture=${tableText(context.fixture_id)}; input_sha256=${tableText(context.input_sha256)}; source_revisions=${tableText(JSON.stringify(context.source_revisions))}`
+    : "Candidate context: unavailable";
   return [...header, ...rows, "", `Validator: ${report.status}`,
+    candidate,
     ...report.errors.map((error) => `- ${tableText(error)}`)].join("\n") + "\n";
 }
 
@@ -109,7 +128,8 @@ export async function checkAcceptance({ charterBytes, matrix, expectedCharterSha
   requireValue(contextDigest(matrix.context) === expectedContextSha256, "Current context digest mismatch");
   requireValue(Array.isArray(matrix.results), "Matrix requires results");
   const root = await realpath(evidenceRoot);
-  const report = { status: "evidence_incomplete", checks: [], errors: [] };
+  const report = { status: "evidence_incomplete", experience: charter.experience ?? null,
+    context: matrix.context, checks: [], errors: [] };
   const results = new Map();
   const expectedIds = new Set(charter.criteria.map((criterion) => criterion.id));
   for (const row of matrix.results) {
@@ -150,7 +170,7 @@ export async function checkAcceptance({ charterBytes, matrix, expectedCharterSha
             requireValue(text(cell.observed_at) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(cell.observed_at) &&
               Number.isFinite(Date.parse(cell.observed_at)) && Date.parse(cell.observed_at) <= Date.now(), "Invalid or future observation timestamp");
             requireValue(Array.isArray(cell.evidence) && cell.evidence.length > 0, "Passed result needs evidence");
-            for (const artifact of cell.evidence) await checkArtifact(root, artifact);
+            for (const artifact of cell.evidence) await readEvidenceArtifact(root, artifact);
             row.status = "passed";
           } catch {
             row.reason = "Invalid, missing, empty, unsafe, or changed evidence; check action, observation, timestamp and artifact hashes";

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// Record/observation checks, not authentication of the collector or host completion.
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import {
+  checkAcceptance,
+  contextDigest,
+  readEvidenceArtifact,
+  sha256,
+} from "./check-acceptance.mjs";
+
+const text = (value) => typeof value === "string" && value.trim().length > 0;
+const object = (value) =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+export const MINIMUM_COMPLETION_VERSION = 1;
+
+export function minimumCharter(charter) {
+  if (
+    charter?.completion_contract?.version !== 2 ||
+    !text(charter.id) ||
+    !text(charter.requirement) ||
+    !Array.isArray(charter.acceptance_criteria) ||
+    !charter.acceptance_criteria.length ||
+    !charter.acceptance_criteria.every(text)
+  ) {
+    throw new Error("Current completion charter required");
+  }
+  const source = {
+    original_request:
+      charter.thread_state?.original_request || charter.requirement,
+    requirement: charter.requirement,
+    minimum_scope:
+      charter.completion_contract.minimum_scope || charter.acceptance_criteria,
+    non_goals: charter.completion_contract.non_goals || [],
+  };
+  const ids = criterionIds(
+    charter.completion_contract.criterion_ids,
+    charter.acceptance_criteria.length,
+  );
+  const experience = minimumExperience(
+    charter.completion_contract.experience,
+    charter.completion_contract.user_outcome || charter.requirement,
+  );
+  return {
+    schema_version: 2,
+    minimum_completion_version: MINIMUM_COMPLETION_VERSION,
+    run_id: charter.id,
+    source,
+    experience,
+    criteria: charter.acceptance_criteria.map((outcome, index) => ({
+      id: ids[index],
+      outcome,
+      acceptance_source: `request:${contextDigest(source)}`,
+      layers: {
+        user: {
+          applicability: "required",
+          method:
+            "Exercise the actual operation and observe its result; reopen/reload when persistence is required.",
+        },
+        system: {
+          applicability: "required",
+          method:
+            "Independently inspect the final postcondition and necessary integration; persisted values and ownership when saving.",
+        },
+      },
+    })),
+  };
+}
+
+function criterionIds(value, count) {
+  if (value === undefined || value === null)
+    return Array.from({ length: count }, (_, index) => `AC-${index + 1}`);
+  if (!Array.isArray(value)) throw new Error("Invalid acceptance criterion IDs");
+  const ids = value.map((id) => (text(id) ? id.trim() : ""));
+  if (
+    ids.length !== count ||
+    new Set(ids).size !== ids.length ||
+    ids.some(
+      (id) => !/^[A-Za-z][A-Za-z0-9]*(?:[-_.][A-Za-z0-9]+)*$/.test(id),
+    )
+  )
+    throw new Error("Invalid acceptance criterion IDs");
+  return ids;
+}
+
+function minimumExperience(value, userOutcome) {
+  const source = object(value) ? value : {};
+  return {
+    beneficiary: text(source.beneficiary)
+      ? source.beneficiary.trim()
+      : "The requester",
+    situation: text(source.situation)
+      ? source.situation.trim()
+      : "Using the requested changed behavior",
+    goal: text(source.goal) ? source.goal.trim() : userOutcome,
+    usable_outcome: text(source.usable_outcome)
+      ? source.usable_outcome.trim()
+      : userOutcome,
+    recovery: text(source.recovery)
+      ? source.recovery.trim()
+      : "Unmet acceptance rows remain visible with the next repair.",
+    forbidden_experiences:
+      Array.isArray(source.forbidden_experiences) &&
+      source.forbidden_experiences.length > 0 &&
+      source.forbidden_experiences.every(text)
+        ? source.forbidden_experiences.map((item) => item.trim())
+        : [
+            "Reporting completion from components or commands without the end-to-end outcome",
+          ],
+  };
+}
+
+export function minimumContext(charter, headSha) {
+  const frozen = minimumCharter(charter);
+  return {
+    run_id: charter.id,
+    stage: "locally_verified",
+    environment: "local",
+    fixture_id: charter.id,
+    input_sha256: contextDigest(frozen.source),
+    source_revisions: { [charter.repository]: headSha },
+  };
+}
+
+export async function loadMinimumJson(file) {
+  const stat = await lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+    throw new Error("Invalid minimum evidence input");
+  return JSON.parse(await readFile(file, "utf8"));
+}
+
+export async function checkMinimumCompletion({
+  charter,
+  matrix,
+  context,
+  evidenceRoot,
+}) {
+  const frozen = minimumCharter(charter);
+  const charterBytes = Buffer.from(JSON.stringify(frozen));
+  const charterSha = sha256(charterBytes);
+  const contextSha = contextDigest(context);
+  const report = await checkAcceptance({
+    charterBytes,
+    matrix,
+    expectedCharterSha256: charterSha,
+    expectedContextSha256: contextSha,
+    evidenceRoot,
+  });
+  report.minimum_completion_version = MINIMUM_COMPLETION_VERSION;
+  report.charter_sha256 = charterSha;
+  report.context_sha256 = contextSha;
+  report.matrix_sha256 = contextDigest(matrix);
+  report.head_sha = context.source_revisions[charter.repository];
+  const fail = (id, reason) => report.errors.push(`${id}: ${reason}`);
+  for (const criterion of frozen.criteria) {
+    const row = matrix.results.find((result) => result.id === criterion.id);
+    if (
+      !Array.isArray(row?.implementation_refs) ||
+      !row.implementation_refs.length ||
+      !row.implementation_refs.every(
+        (ref) =>
+          text(ref) &&
+          !path.isAbsolute(ref) &&
+          !ref.includes("\\") &&
+          ref
+            .split("/")
+            .every(
+              (segment) =>
+                segment &&
+                segment !== ".." &&
+                segment !== "." &&
+                !segment.includes(":"),
+            ),
+      )
+    ) {
+      fail(
+        criterion.id,
+        "Missing or unsafe requirement-to-implementation mapping",
+      );
+    }
+    for (const [layer, names] of Object.entries({
+      user: ["operation", "result"],
+      system: ["postcondition", "integration"],
+    })) {
+      const cell = row?.layers?.[layer];
+      if (cell?.status !== "passed") continue;
+      try {
+        // The first artifact is a structured observation; further artifacts may be images/logs.
+        const observation = JSON.parse(
+          (
+            await readEvidenceArtifact(
+              await realpath(evidenceRoot),
+              cell.evidence[0],
+            )
+          ).toString(),
+        );
+        if (
+          observation.criterion_id !== criterion.id ||
+          observation.context_sha256 !== contextSha ||
+          !object(observation.checks)
+        )
+          throw new Error("Wrong observation context");
+        for (const name of names) {
+          const check = observation.checks[name];
+          if (
+            !object(check) ||
+            !text(check.subject) ||
+            check.expected === null ||
+            check.expected === undefined ||
+            (name === "operation" && check.expected !== true) ||
+            !isDeepStrictEqual(check.expected, check.actual)
+          ) {
+            fail(
+              `${criterion.id}/${layer}/${name}`,
+              "Missing observation or expected/actual mismatch",
+            );
+          }
+        }
+      } catch {
+        fail(
+          `${criterion.id}/${layer}`,
+          "Missing, altered or invalid structured observation",
+        );
+      }
+    }
+  }
+  report.status = report.errors.length
+    ? "evidence_incomplete"
+    : "evidence_complete";
+  // Additional floor failures must be visible in the human-readable record too.
+  report.markdown += `\nMinimum completion: ${report.status}\n${report.errors.map((error) => `- ${error}`).join("\n")}\n`;
+  return report;
+}
+
+const entry = process.argv[1]
+  ? await realpath(process.argv[1]).catch(() => null)
+  : null;
+if (entry === fileURLToPath(import.meta.url)) {
+  try {
+    const [
+      charterPath,
+      matrixPath,
+      contextPath,
+      expectedCharter,
+      expectedContext,
+      ...extra
+    ] = process.argv.slice(2);
+    if (!expectedContext || extra.length) throw new Error("Invalid arguments");
+    const charter = await loadMinimumJson(charterPath);
+    const context = await loadMinimumJson(contextPath);
+    if (
+      sha256(Buffer.from(JSON.stringify(minimumCharter(charter)))) !==
+        expectedCharter ||
+      contextDigest(context) !== expectedContext
+    )
+      throw new Error("Trusted digest mismatch");
+    const report = await checkMinimumCompletion({
+      charter,
+      context,
+      matrix: await loadMinimumJson(matrixPath),
+      evidenceRoot: path.dirname(path.resolve(matrixPath)),
+    });
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    process.exitCode = report.status === "evidence_complete" ? 0 : 1;
+  } catch {
+    process.stderr.write(
+      "Minimum completion unavailable. Supply charter.json matrix.json context.json trusted-charter-sha256 trusted-context-sha256.\n",
+    );
+    process.exitCode = 2;
+  }
+}

package/src/orchestrator/audit.js

@@ -1,3 +1,4 @@
+import { minimumCompletionCheck } from "./minimum-completion.js";
 import { open, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 
@@ -131,7 +132,7 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
   }
   attempt.retry_problem_solving = retryProblemSolving;
 
-  for (const check of completionEvidenceChecks(charter, attempt)) {
+  for (const check of [...completionEvidenceChecks(charter, attempt), minimumCompletionCheck(charter, attempt)]) {
     addCheck(
       check.id,
       check.label,
@@ -143,6 +144,13 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
     );
   }
 
+  if (attempt.independent_audit) {
+    addCheck("minimum_review_current", "Independent review covers the current evidence",
+      Boolean(attempt.independent_audit.minimum_matrix_sha256 &&
+        attempt.independent_audit.minimum_matrix_sha256 === attempt.observed_evidence?.minimum_completion?.matrix_sha256),
+      "Changed minimum evidence requires a fresh independent review.");
+  }
+
   const evidenceRequired = charter.expected_evidence.includes("ui_evidence_path");
   const evidenceArtifact = await inspectEvidence(charter, attempt.ui_evidence_path);
   if (evidenceRequired || attempt.ui_evidence_path) {
@@ -305,7 +313,12 @@ export function evaluatePrReadiness(charter, attempt) {
   const github = attempt.observed_evidence?.github || {};
   const local = attempt.observed_evidence?.local || {};
   const independentAudit = attempt.independent_audit;
+  const minimum = minimumCompletionCheck(charter, attempt);
   const checks = [
+    readinessCheck(minimum.id, minimum.passed, minimum.detail),
+    readinessCheck("minimum_independent_binding",
+      Boolean(independentAudit?.minimum_matrix_sha256 && independentAudit.minimum_matrix_sha256 === attempt.observed_evidence?.minimum_completion?.matrix_sha256),
+      "Independent review must cover the current minimum evidence matrix."),
     readinessCheck("implementation_gate", attempt.audit?.passed === true, "Implementation gate must pass."),
     readinessCheck(
       "independent_ai_audit",
@@ -372,7 +385,9 @@ export function evaluatePrReadiness(charter, attempt) {
     state: ready ? "merge_ready" : "pr_ready_for_review",
     summary: ready
       ? "PR has independently verified evidence, passing checks, and required approval."
-      : "Implementation is complete, but the PR is not merge-ready.",
+      : attempt.audit?.passed && minimum.passed
+        ? "Implementation is verified, but the PR is not merge-ready."
+        : "Implementation verification is incomplete; resolve the pending evidence before promotion.",
     checks,
     pending_reasons: checks.filter((check) => !check.passed).map((check) => check.detail),
   };

package/src/orchestrator/completion-contract.js

@@ -1,6 +1,7 @@
 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 buildCompletionContract({
   inherited,
@@ -12,11 +13,15 @@ export function buildCompletionContract({
   const source = record(inherited);
   const minimumScope = stringArray(source.minimum_scope);
   const proofRequired = stringArray(source.proof_required);
+  const criteria = stringArray(acceptanceCriteria);
+  const userOutcome = cleanString(source.user_outcome) || cleanString(requirement);
   return {
     version: COMPLETION_CONTRACT_VERSION,
-    user_outcome: cleanString(source.user_outcome) || cleanString(requirement),
+    user_outcome: userOutcome,
     minimum_scope:
-      minimumScope.length > 0 ? minimumScope : stringArray(acceptanceCriteria),
+      minimumScope.length > 0 ? minimumScope : criteria,
+    criterion_ids: criterionIds(source.criterion_ids, criteria.length),
+    experience: normalizeExperience(source.experience, userOutcome),
     non_goals: stringArray(nonGoals),
     proof_required: uniqueStrings([
       "criterion_evidence",
@@ -29,12 +34,53 @@ export function buildCompletionContract({
 }
 
 export function acceptanceCriterionRows(charter) {
-  return stringArray(charter?.acceptance_criteria).map((statement, index) => ({
-    id: `AC-${index + 1}`,
+  const statements = stringArray(charter?.acceptance_criteria);
+  const ids = criterionIds(
+    record(charter?.completion_contract).criterion_ids,
+    statements.length,
+  );
+  return statements.map((statement, index) => ({
+    id: ids[index],
     statement,
   }));
 }
 
+function criterionIds(value, count) {
+  if (value === undefined || value === null) {
+    return Array.from({ length: count }, (_, index) => `AC-${index + 1}`);
+  }
+  if (!Array.isArray(value)) throw new Error("Invalid acceptance criterion IDs");
+  const ids = value.map(cleanString);
+  if (
+    ids.length !== count ||
+    new Set(ids).size !== ids.length ||
+    ids.some((id) => !criterionIdPattern.test(id))
+  ) {
+    throw new Error("Invalid acceptance criterion IDs");
+  }
+  return ids;
+}
+
+function normalizeExperience(value, userOutcome) {
+  const source = record(value);
+  return {
+    beneficiary: cleanString(source.beneficiary) || "The requester",
+    situation:
+      cleanString(source.situation) || "Using the requested changed behavior",
+    goal: cleanString(source.goal) || userOutcome,
+    usable_outcome: cleanString(source.usable_outcome) || userOutcome,
+    recovery:
+      cleanString(source.recovery) ||
+      "Unmet acceptance rows remain visible with the next repair.",
+    forbidden_experiences:
+      stringArray(source.forbidden_experiences).length > 0
+        ? stringArray(source.forbidden_experiences)
+        : [
+            "Reporting completion from components or commands without the end-to-end outcome",
+          ],
+  };
+}
+
 export function normalizeUncertaintyVerification(value) {
   const source = record(value);
   return {
@@ -76,7 +122,7 @@ export function normalizeVisualReview(value) {
 
 export function completionEvidenceChecks(charter, attempt) {
   const contract = record(charter?.completion_contract);
-  if (contract.version !== COMPLETION_CONTRACT_VERSION) return [];
+  if (contract.version !== COMPLETION_CONTRACT_VERSION) return [check("completion_contract_version", "Supported completion contract required", false, "Missing or unsupported completion contract; re-charter and verify before promotion.")];
 
   const uncertainty = normalizeUncertaintyVerification(attempt?.uncertainty_verification);
   const rows = acceptanceCriterionRows(charter);

package/src/orchestrator/contract.js

@@ -65,6 +65,7 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
   const inheritedArtifacts = stringArray(charterContext.artifacts_required);
   const inheritedAssumptions = stringArray(charterContext.assumptions);
   const inheritedCompletionContract = record(charterContext.completion_contract);
+  const inheritedExperienceContract = record(charterContext.experience_contract);
   const finalAcceptanceCriteria =
     acceptanceCriteria.length > 0
       ? acceptanceCriteria
@@ -157,7 +158,17 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
         visual_review_required: browserEvidenceRequired,
       },
       completion_contract: buildCompletionContract({
-        inherited: inheritedCompletionContract,
+        inherited: {
+          ...inheritedCompletionContract,
+          ...(Object.keys(inheritedExperienceContract).length > 0
+            ? {
+                experience: inheritedExperienceContract,
+                criterion_ids:
+                  inheritedExperienceContract.criterion_ids ??
+                  inheritedCompletionContract.criterion_ids,
+              }
+            : {}),
+        },
         requirement: cleanString(charterContext.user_goal) || cleanString(request.requirement),
         acceptanceCriteria: finalAcceptanceCriteria,
         nonGoals: finalNonGoals,

package/src/orchestrator/evidence.js

@@ -1,3 +1,4 @@
+import { collectMinimumCompletion } from "./minimum-completion.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
@@ -25,9 +26,16 @@ export async function collectPrEvidence({
     runCommand,
   });
   const github = await collectGitHubEvidence({ charter, attempt, repositoryPath, runCommand });
+  const minimumCompletion = await collectMinimumCompletion({ charter, attempt, repositoryPath, local });
+  const latest = await collectLocalGitEvidence({ baseBranch: charter.base_branch, repositoryPath, runCommand });
+  if (!latest.available || latest.head_sha !== local.head_sha || !latest.working_tree_clean) {
+    minimumCompletion.status = "evidence_incomplete";
+    minimumCompletion.errors = ["Checkout changed while collecting minimum evidence; verify again."];
+  }
   return {
+    minimum_completion: minimumCompletion,
     collected_at: new Date().toISOString(),
-    local,
+    local: latest,
     github,
   };
 }

package/src/orchestrator/independent-audit.js

@@ -26,7 +26,9 @@ export function buildIndependentAuditInstruction(charter, attempt) {
       "audit_target",
       [
         `Requirement: ${charter.requirement}`,
-        `Acceptance criteria:\n${bullets(charter.acceptance_criteria)}`,
+        `Original request: ${charter.thread_state?.original_request || charter.requirement}`,
+        `Acceptance criteria:\n${bullets(acceptanceCriterionRows(charter).map(row => `${row.id}: ${row.statement}`))}`,
+        `Frozen experience (controller-owned): ${JSON.stringify(charter.completion_contract?.experience ?? null)}`,
         `User-visible outcome: ${charter.completion_contract?.user_outcome || charter.requirement}`,
         `Minimum scope:\n${bullets(charter.completion_contract?.minimum_scope || charter.acceptance_criteria)}`,
         `Risk level: ${charter.risk.level}`,
@@ -43,6 +45,8 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         `Reported tests:\n${bullets(attempt.tests_run || [])}`,
         `Executor uncertainty verification: ${JSON.stringify(attempt.uncertainty_verification || {})}`,
         `Executor criterion evidence: ${JSON.stringify(attempt.criterion_evidence || [])}`,
+        `Minimum evidence matrix: ${attempt.observed_evidence?.minimum_completion?.evidence_path || "missing"}`,
+        `Minimum evidence digest: ${attempt.observed_evidence?.minimum_completion?.matrix_sha256 || "missing"}`,
         `Executor visual review: ${JSON.stringify(attempt.visual_review || {})}`,
         `Observed local branch: ${localEvidence.branch_name || "unknown"}`,
         `Observed local HEAD: ${localEvidence.head_sha || "unknown"}`,
@@ -59,7 +63,8 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         "Inspect the final diff and related code directly from the repository.",
         "Look for unmet acceptance criteria, regressions, security issues, data and concurrency risks, missing tests, and unrelated changes.",
         "Treat executor claims as untrusted until supported by repository evidence.",
-        "For every AC-N criterion, return a criterion_results entry only after directly checking its cited proof and observed outcome.",
+        "Compare the original request and frozen experience to the complete stable criterion-ID list and implementation mapping. Report forgotten features, dead controls, unsaved results and broken integration. Open the raw minimum evidence, verify its oracle and actual runtime observations; matching expected/actual JSON and hashes alone do not prove truth. Check reload/session return and persisted values/ownership when saving is required.",
+        "For every stable criterion ID, return a criterion_results entry only after directly checking its cited proof and observed outcome.",
         charter.evidence_policy?.browser_required
           ? "Open and inspect the actual local screenshots or videos. Return visual_review.inspected=true only after checking their visible content against the acceptance criteria."
           : "Do not require visual evidence when the Charter does not require browser evidence.",
@@ -70,9 +75,10 @@ export function buildIndependentAuditInstruction(charter, attempt) {
       "result_contract",
       [
         "Finish with exactly one line beginning SIMY_AUDIT_JSON: followed by one JSON object.",
-        "Required keys: passed, summary, findings, criterion_results, visual_review.",
+        "Required keys: passed, summary, findings, criterion_results, visual_review, coverage_review.",
+        "coverage_review must contain requirements_complete (boolean), unmapped_requirements (array), and observation explaining the comparison of the original request, frozen experience, stable criterion-ID list, implementation and raw user/system proof. Use false and list gaps when anything is missing or unverified.",
         "Each finding candidate must contain passed, code, severity, target, explanation, and repairability.",
-        "criterion_results must contain one entry per AC-N with criterion_id, passed, verification_method, evidence_refs, and observed_result.",
+        "criterion_results must contain one entry per stable criterion ID with criterion_id, passed, verification_method, evidence_refs, and observed_result.",
         "visual_review must contain inspected, artifacts, and acceptance_observations.",
         "Only passed=false entries are findings. Omit passing checks, and never report passed=true evidence as a finding.",
         "Use passed=false when a blocker or major finding remains, or when evidence is unavailable.",
@@ -195,12 +201,19 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       auto_fix_hint: null,
     });
   }
+  const coverage = result.coverage_review;
+  if (attempt && !(coverage?.requirements_complete === true &&
+      Array.isArray(coverage.unmapped_requirements) && coverage.unmapped_requirements.length === 0 && cleanString(coverage.observation))) {
+    findings.push({ passed: false, code: "MINIMUM_REQUIREMENT_COVERAGE_UNPROVEN", severity: "blocker",
+      target: "coverage_review", explanation: "Original request coverage and raw minimum evidence were not independently verified.", repairability: "auto" });
+  }
   const requiresHuman = findings.some((item) => item.repairability === "manual");
   return {
     passed: result.passed === true && findings.length === 0,
     summary: cleanString(result.summary) || "Independent audit completed.",
     findings,
     criterion_results: criterionResults,
+    coverage_review: coverage || null,
     visual_review: visualReview,
     requires_human: requiresHuman,
   };