@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/acceptance.js

@@ -1,15 +1,18 @@
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
 import * as path from "node:path";
+import { isAgentContractV1 } from "./agent-contract.js";
+import { classifyTaskMutationIntent, stripSeverityCompounds, taskMayMutate } from "./task-intent.js";
 const LEVEL_RANK = {
   none: 0,
   attested: 1,
   checked: 2,
-  verified: 3,
-  reviewed: 4
+  verified: 3
 };
-const VALID_LEVELS = new Set(["auto", "none", "attested", "checked", "verified", "reviewed"]);
-const VALID_EVIDENCE = new Set([
+const VALID_LEVELS = new Set(["auto", "none", "attested", "checked", "verified"]);
+const VALID_EVIDENCE_KINDS = [
   "changed-files",
   "tests-added",
   "commands-run",
@@ -19,11 +22,15 @@ const VALID_EVIDENCE = new Set([
   "diff-summary",
   "review-findings",
   "manual-notes"
-]);
+];
+const VALID_EVIDENCE = new Set(VALID_EVIDENCE_KINDS);
+const ACCEPTANCE_EVIDENCE_HELP = `Supported evidence kinds: ${VALID_EVIDENCE_KINDS.join(", ")}. Example: { level: "checked", evidence: ["commands-run", "changed-files"] }.`;
+const ACCEPTANCE_OBJECT_EXAMPLE = 'Example: { level: "checked", evidence: ["commands-run", "changed-files"] }.';
 const ACCEPTANCE_CONFIG_KEYS = new Set(["level", "criteria", "evidence", "verify", "review", "stopRules", "reason"]);
 const ACCEPTANCE_GATE_KEYS = new Set(["id", "must", "evidence", "severity"]);
 const ACCEPTANCE_VERIFY_KEYS = new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure"]);
 const ACCEPTANCE_REVIEW_KEYS = new Set(["agent", "focus", "required"]);
+const EXPLICIT_REVIEWED_UNAVAILABLE = "is an achieved status, not a requestable acceptance level. For a read-only reviewer call, omit acceptance. To require independent review of a writer result, use acceptance.review.required and orchestrate the reviewer separately.";
 function normalizeLevel(level) {
   return level ?? "auto";
 }
@@ -39,7 +46,6 @@ function requiredEvidenceForLevel(level) {
     case "checked":
       return ["changed-files", "tests-added", "commands-run", "residual-risks", "no-staged-files"];
     case "verified":
-    case "reviewed":
       return ["changed-files", "tests-added", "commands-run", "validation-output", "residual-risks", "no-staged-files"];
   }
 }
@@ -47,24 +53,30 @@ function inferLevel(input) {
   const agent = input.agentName.toLowerCase();
   const task = input.task?.toLowerCase() ?? "";
   const reasons = [];
-  const readOnlyAgent = /\b(?:reviewer|scout|context-builder|researcher|analyst)\b/.test(agent);
-  const readOnlyTask = /\b(?:read[- ]only|review[- ]only|do not edit|don't edit|no edits|without edits|inspect|summari[sz]e)\b/.test(task);
-  const writeTask = /\b(?:fix|implement|update|write|edit|modify|migrate|release|security|delete|remove|refactor|commit)\b/.test(task) || /\bworker\b/.test(agent);
-  const risky = Boolean(input.async && writeTask) || Boolean(input.dynamic) || Boolean(input.dynamicGroup) || /\b(?:release|migration|migrate|security|data[- ]loss|destructive|post-review|fix pass)\b/.test(task);
+  const intent = classifyTaskMutationIntent(input.acceptanceRole ? "worker" : input.agentName, input.task ?? "");
+  const readOnlyTask = intent.kind === "read-only" || intent.kind === "unknown" && /\b(?:read[- ]only|review[- ]only|no edits|without edits|inspect|summari[sz]e)\b/.test(task);
+  const rolePatchTask = input.acceptanceRole !== undefined && intent.kind !== "read-only" && !/\b(?:do not|don't|must not)\s+patch\b/.test(task) && /\bpatch\s+(?:(?:\.{0,2}[\\/])?(?:[\w.-]+[\\/])+[\w.-]+|[\w.-]+\.[a-z0-9]+\b|(?:the\s+)?parser\b)/.test(stripSeverityCompounds(task));
+  const taskMayWrite = readOnlyTask ? false : taskMayMutate(input.task ?? "") || intent.kind === "implementation" || rolePatchTask;
+  const readOnlyAgent = input.acceptanceRole === "read-only" || input.acceptanceRole === undefined && /\b(?:reviewer|oracle|scout|researcher|analyst)\b/.test(agent);
+  const writeTask = taskMayWrite || input.acceptanceRole === "writer" && !readOnlyTask || input.acceptanceRole === undefined && /\bworker\b/.test(agent) && !readOnlyTask;
+  const inferredReadOnly = readOnlyTask || input.acceptanceRole === "read-only" && !taskMayWrite;
+  const roleResolvesReadOnly = input.acceptanceRole !== undefined && inferredReadOnly;
+  const keywordRiskReadOnly = input.acceptanceRole === undefined ? intent.kind === "read-only" : inferredReadOnly;
+  const risky = Boolean(input.async && writeTask) || Boolean(input.dynamic) && !roleResolvesReadOnly || Boolean(input.dynamicGroup) && !roleResolvesReadOnly || !keywordRiskReadOnly && /\b(?:release|migration|migrate|security|data[- ]loss|destructive|post-review|fix pass)\b/.test(task);
   if (risky) {
     reasons.push(input.async ? "async write-capable or risky run" : "risky write-capable run");
     if (input.dynamic || input.dynamicGroup)
       reasons.push("dynamic fanout context");
     return {
-      level: "reviewed",
+      level: "checked",
       reasons,
       criteria: ["Implement the requested change without widening scope", "Return evidence sufficient for an independent acceptance review"],
-      evidence: requiredEvidenceForLevel("reviewed"),
+      evidence: requiredEvidenceForLevel("checked"),
       review: { agent: "reviewer", required: true }
     };
   }
   if (writeTask && !readOnlyTask) {
-    reasons.push("write-capable worker/task");
+    reasons.push(input.acceptanceRole === "writer" && !taskMayWrite ? "declared writer acceptance role" : "write-capable worker/task");
     return {
       level: "checked",
       reasons,
@@ -73,7 +85,7 @@ function inferLevel(input) {
     };
   }
   if (readOnlyAgent || readOnlyTask) {
-    reasons.push(readOnlyAgent ? "read-only/reviewer-style agent" : "read-only task wording");
+    reasons.push(input.acceptanceRole === "read-only" && !readOnlyTask ? "declared read-only acceptance role" : readOnlyAgent ? "read-only/reviewer-style agent" : "read-only task wording");
     return {
       level: "attested",
       reasons,
@@ -98,9 +110,22 @@ export function normalizeAcceptanceInput(input) {
     return { level: input };
   return { ...input };
 }
+export function normalizeGateAcceptance(gate, acceptance) {
+  if (gate === undefined)
+    return acceptance === undefined ? { ok: true } : { ok: true, acceptance };
+  if (typeof gate !== "string" || !gate.trim())
+    return { ok: false, error: "gate must be a non-empty command string." };
+  if (acceptance !== undefined)
+    return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." };
+  return { ok: true, acceptance: { level: "verified", verify: [{ id: "gate", command: gate.trim() }] } };
+}
 function explicitAcceptanceCanDisable(explicit) {
   return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
 }
+function unsupportedEvidenceKindMessage(pathLabel, item) {
+  const value = typeof item === "string" ? ` "${item}"` : "";
+  return `${pathLabel}${value} is not a supported evidence kind. ${ACCEPTANCE_EVIDENCE_HELP}`;
+}
 export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   const errors = [];
   if (input === undefined)
@@ -108,12 +133,18 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   if (input === false)
     return errors;
   if (typeof input === "string") {
-    if (!VALID_LEVELS.has(input))
+    if (input === "reviewed")
+      errors.push(`${pathLabel} ${EXPLICIT_REVIEWED_UNAVAILABLE}`);
+    else if (!VALID_LEVELS.has(input))
       errors.push(`${pathLabel} has invalid level '${input}'.`);
+    else if (input === "none")
+      errors.push(`${pathLabel} level "none" requires a reason; use { level: "none", reason: "..." }.`);
+    else if (input === "verified")
+      errors.push(`${pathLabel} level "verified" requires object form with at least one runtime verify command. Use level "checked" or provide a non-empty acceptance.verify array.`);
     return errors;
   }
   if (!input || typeof input !== "object" || Array.isArray(input)) {
-    errors.push(`${pathLabel} must be a string level, false, or an object.`);
+    errors.push(`${pathLabel} must be a string level, false, or an object. ${ACCEPTANCE_OBJECT_EXAMPLE}`);
     return errors;
   }
   const value = input;
@@ -121,8 +152,10 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
     if (!ACCEPTANCE_CONFIG_KEYS.has(key))
       errors.push(`${pathLabel}.${key} is not supported.`);
   }
-  if (value.level !== undefined && (typeof value.level !== "string" || !VALID_LEVELS.has(value.level))) {
-    errors.push(`${pathLabel}.level must be one of auto, none, attested, checked, verified, reviewed.`);
+  if (value.level === "reviewed") {
+    errors.push(`${pathLabel}.level ${EXPLICIT_REVIEWED_UNAVAILABLE}`);
+  } else if (value.level !== undefined && (typeof value.level !== "string" || !VALID_LEVELS.has(value.level))) {
+    errors.push(`${pathLabel}.level must be one of auto, none, attested, checked, verified.`);
   }
   if (value.level === "none" && (typeof value.reason !== "string" || !value.reason.trim())) {
     errors.push(`${pathLabel}.reason is required when level is none.`);
@@ -132,6 +165,7 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   if (value.criteria !== undefined && !Array.isArray(value.criteria))
     errors.push(`${pathLabel}.criteria must be an array.`);
   if (Array.isArray(value.criteria)) {
+    const criterionIds = new Set;
     for (const [index, criterion] of value.criteria.entries()) {
       if (typeof criterion === "string")
         continue;
@@ -145,16 +179,22 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
         if (!ACCEPTANCE_GATE_KEYS.has(key))
           errors.push(`${criterionPath}.${key} is not supported.`);
       }
-      if (typeof gate.id !== "string" || !gate.id.trim())
+      if (typeof gate.id !== "string" || !gate.id.trim()) {
         errors.push(`${criterionPath}.id is required.`);
+      } else {
+        const normalizedId = normalizedToken(gate.id);
+        if (criterionIds.has(normalizedId))
+          errors.push(`${criterionPath}.id duplicates normalized criterion id '${normalizedId}'.`);
+        criterionIds.add(normalizedId);
+      }
       if (typeof gate.must !== "string" || !gate.must.trim())
         errors.push(`${criterionPath}.must is required.`);
       if (gate.evidence !== undefined && !Array.isArray(gate.evidence))
-        errors.push(`${criterionPath}.evidence must be an array.`);
+        errors.push(`${criterionPath}.evidence must be an array. ${ACCEPTANCE_EVIDENCE_HELP}`);
       if (Array.isArray(gate.evidence)) {
         for (const [evidenceIndex, item] of gate.evidence.entries()) {
           if (typeof item !== "string" || !VALID_EVIDENCE.has(item)) {
-            errors.push(`${criterionPath}.evidence[${evidenceIndex}] is not a supported evidence kind.`);
+            errors.push(unsupportedEvidenceKindMessage(`${criterionPath}.evidence[${evidenceIndex}]`, item));
           }
         }
       }
@@ -166,14 +206,17 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   if (Array.isArray(value.evidence)) {
     for (const [index, item] of value.evidence.entries()) {
       if (typeof item !== "string" || !VALID_EVIDENCE.has(item)) {
-        errors.push(`${pathLabel}.evidence[${index}] is not a supported evidence kind.`);
+        errors.push(unsupportedEvidenceKindMessage(`${pathLabel}.evidence[${index}]`, item));
       }
     }
   } else if (value.evidence !== undefined) {
-    errors.push(`${pathLabel}.evidence must be an array.`);
+    errors.push(`${pathLabel}.evidence must be an array. ${ACCEPTANCE_EVIDENCE_HELP}`);
   }
-  if (value.verify !== undefined && !Array.isArray(value.verify))
+  if (value.level === "verified" && (!Array.isArray(value.verify) || value.verify.length === 0)) {
+    errors.push(`${pathLabel}.verify must contain at least one runtime command when level is verified. Use level "checked" or provide a non-empty acceptance.verify array.`);
+  } else if (value.verify !== undefined && !Array.isArray(value.verify)) {
     errors.push(`${pathLabel}.verify must be an array.`);
+  }
   if (Array.isArray(value.verify)) {
     for (const [index, command] of value.verify.entries()) {
       if (!command || typeof command !== "object" || Array.isArray(command)) {
@@ -236,6 +279,23 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   }
   return errors;
 }
+export function validateExecutionAcceptance(input) {
+  const errors = validateAcceptanceInput(input.acceptance, "acceptance");
+  for (const [index, task] of (input.tasks ?? []).entries()) {
+    errors.push(...validateAcceptanceInput(task.acceptance, `tasks[${index}].acceptance`));
+  }
+  for (const [stepIndex, step] of (input.chain ?? []).entries()) {
+    errors.push(...validateAcceptanceInput(step.acceptance, `chain[${stepIndex}].acceptance`));
+    if (Array.isArray(step.parallel)) {
+      for (const [taskIndex, task] of step.parallel.entries()) {
+        errors.push(...validateAcceptanceInput(task.acceptance, `chain[${stepIndex}].parallel[${taskIndex}].acceptance`));
+      }
+    } else if (step.parallel) {
+      errors.push(...validateAcceptanceInput(step.parallel.acceptance, `chain[${stepIndex}].parallel.acceptance`));
+    }
+  }
+  return errors;
+}
 function normalizeCriteria(criteria, evidence) {
   return (criteria ?? []).map((criterion, index) => {
     if (typeof criterion === "string") {
@@ -251,15 +311,28 @@ function normalizeCriteria(criteria, evidence) {
 }
 export function resolveEffectiveAcceptance(input) {
   const explicit = normalizeAcceptanceInput(input.explicit);
-  const inferred = inferLevel(input);
   const explicitLevel = normalizeLevel(explicit.level);
+  if (isAgentContractV1(input.agentContract)) {
+    const level = explicitAcceptanceCanDisable(explicit) || explicitLevel === "auto" ? "none" : explicitLevel;
+    const evidence = unique(explicit.evidence ?? []);
+    const criteria = normalizeCriteria(explicit.criteria, evidence);
+    return {
+      level,
+      explicit: input.explicit !== undefined,
+      inferredReason: [],
+      criteria,
+      evidence,
+      verify: explicit.verify ?? [],
+      review: explicit.review,
+      stopRules: explicit.stopRules ?? [],
+      reason: explicit.reason
+    };
+  }
+  const inferred = inferLevel(input);
   const level = explicitAcceptanceCanDisable(explicit) ? "none" : explicitLevel === "auto" ? inferred.level : LEVEL_RANK[explicitLevel] >= LEVEL_RANK[inferred.level] ? explicitLevel : inferred.level;
   const evidence = unique([...level === inferred.level ? inferred.evidence : requiredEvidenceForLevel(level), ...explicit.evidence ?? []]);
   const criteria = normalizeCriteria(explicit.criteria?.length ? explicit.criteria : inferred.criteria, evidence);
-  let review = explicit.review !== undefined ? explicit.review : inferred.review;
-  if (level === "reviewed" && explicitLevel !== "auto" && explicitLevel !== "reviewed" && explicit.review === undefined && review && review !== false) {
-    review = { ...review, required: false };
-  }
+  const review = explicit.review !== undefined ? explicit.review : inferred.review;
   return {
     level,
     explicit: input.explicit !== undefined,
@@ -272,9 +345,14 @@ export function resolveEffectiveAcceptance(input) {
     reason: explicit.reason
   };
 }
-export function formatAcceptancePrompt(acceptance) {
+function acceptanceRequiresChildReport(acceptance) {
+  return acceptance.criteria.length > 0 || acceptance.evidence.length > 0;
+}
+export function formatAcceptancePrompt(acceptance, options = {}) {
   if (acceptance.level === "none")
     return "";
+  if (options.reportOptional && !acceptanceRequiresChildReport(acceptance))
+    return "";
   const lines = [
     "",
     "## Acceptance Contract",
@@ -291,7 +369,7 @@ export function formatAcceptancePrompt(acceptance) {
     for (const command of acceptance.verify)
       lines.push(`- ${command.id}: ${command.command}`);
   }
-  if (acceptance.review && acceptance.review !== false) {
+  if (acceptance.review) {
     lines.push("", `Review gate: ${acceptance.review.required === false ? "optional" : "required"}${acceptance.review.agent ? ` by ${acceptance.review.agent}` : ""}.`);
     if (acceptance.review.focus)
       lines.push(`Review focus: ${acceptance.review.focus}`);
@@ -299,8 +377,8 @@ export function formatAcceptancePrompt(acceptance) {
   if (acceptance.stopRules.length > 0) {
     lines.push("", "Stop rules:", ...acceptance.stopRules.map((rule) => `- ${rule}`));
   }
-  lines.push("", "Finish with a fenced JSON block tagged `acceptance-report` in this shape:", "Use empty arrays when no items apply; array fields contain strings unless object entries are shown.", "```acceptance-report", JSON.stringify({
-    criteriaSatisfied: [{ id: "criterion-1", status: "satisfied", evidence: "specific proof" }],
+  lines.push("", options.structuredOutput ? "Include an `acceptanceReport` object in your final `structured_output` tool call in this shape:" : "Finish with a fenced JSON block tagged `acceptance-report` in this shape:", "Use empty arrays when no items apply; array fields contain strings unless object entries are shown.", 'Empty-string entries (`[""]`) are ignored; use `[]` when nothing applies.', "`criteriaSatisfied[].status` must be exactly one of: satisfied, not-satisfied, not-applicable.", "`commandsRun[].result` must be exactly one of: passed, failed, not-run.", "`manualNotes` and `notes` are optional strings; an empty string means no note and does not satisfy `manual-notes` evidence.", ...options.structuredOutput ? [] : ["```acceptance-report"], JSON.stringify({
+    criteriaSatisfied: acceptance.criteria.filter((criterion) => criterion.severity !== "recommended").map((criterion) => ({ id: criterion.id, status: "satisfied", evidence: "specific proof" })),
     changedFiles: ["src/file.ts"],
     testsAddedOrUpdated: ["test/file.test.ts"],
     commandsRun: [{ command: "command", result: "passed", summary: "short result" }],
@@ -310,7 +388,7 @@ export function formatAcceptancePrompt(acceptance) {
     diffSummary: "short description of the diff",
     reviewFindings: ["blocker: file.ts:12 - issue found, or no blockers"],
     manualNotes: "anything else the parent should know"
-  }, null, 2), "```");
+  }, null, 2), ...options.structuredOutput ? [] : ["```"]);
   return lines.join(`
 `);
 }
@@ -343,29 +421,164 @@ function extractBalancedJson(text, start) {
   }
   return;
 }
-function unwrapAcceptanceReport(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
+const ACCEPTANCE_REPORT_WRAPPERS = new Set(["acceptance", "acceptance-report", "acceptance_report", "acceptanceReport"]);
+const ACCEPTANCE_REPORT_FIELDS = {
+  criteriaSatisfied: "criteriaSatisfied",
+  criteria_satisfied: "criteriaSatisfied",
+  changedFiles: "changedFiles",
+  changed_files: "changedFiles",
+  testsAddedOrUpdated: "testsAddedOrUpdated",
+  tests_added_or_updated: "testsAddedOrUpdated",
+  commandsRun: "commandsRun",
+  commands_run: "commandsRun",
+  validationOutput: "validationOutput",
+  validation_output: "validationOutput",
+  residualRisks: "residualRisks",
+  residual_risks: "residualRisks",
+  noStagedFiles: "noStagedFiles",
+  no_staged_files: "noStagedFiles",
+  diffSummary: "diffSummary",
+  diff_summary: "diffSummary",
+  reviewFindings: "reviewFindings",
+  review_findings: "reviewFindings",
+  manualNotes: "manualNotes",
+  manual_notes: "manualNotes",
+  notes: "notes"
+};
+const CRITERION_REPORT_FIELDS = new Set(["id", "status", "evidence"]);
+const COMMAND_REPORT_FIELDS = new Set(["command", "result", "summary"]);
+function normalizedToken(value) {
+  return value.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/-+/g, "-");
+}
+function normalizeCriterionStatus(value) {
+  if (typeof value !== "string")
     return value;
-  const record = value;
-  if ("acceptance" in record)
-    return record.acceptance;
-  if ("acceptance-report" in record)
-    return record["acceptance-report"];
+  const token = normalizedToken(value);
+  if (["satisfied", "met", "complete", "completed", "done", "pass", "passed", "success", "succeeded"].includes(token))
+    return "satisfied";
+  if (["not-satisfied", "not-met", "unmet", "incomplete", "fail", "failed"].includes(token))
+    return "not-satisfied";
+  if (["not-applicable", "n-a", "na", "skip", "skipped"].includes(token))
+    return "not-applicable";
   return value;
 }
-function isCommandsRunArray(value) {
-  return Array.isArray(value) && value.every((item) => {
-    if (!item || typeof item !== "object" || Array.isArray(item))
-      return false;
-    const command = item;
-    return typeof command.command === "string" && (command.result === "passed" || command.result === "failed" || command.result === "not-run") && typeof command.summary === "string";
-  });
+function normalizeCommandResult(value) {
+  if (typeof value !== "string")
+    return value;
+  const token = normalizedToken(value);
+  if (["passed", "pass", "success", "successful", "succeeded", "ok"].includes(token))
+    return "passed";
+  if (["failed", "fail", "failure", "error"].includes(token))
+    return "failed";
+  if (["not-run", "not-executed", "skip", "skipped"].includes(token))
+    return "not-run";
+  return value;
+}
+function normalizeCriterionReport(value, pathLabel, errors) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return value;
+  const normalized = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (!CRITERION_REPORT_FIELDS.has(key)) {
+      errors.push(`${pathLabel}.${key}: unsupported acceptance criterion field`);
+      continue;
+    }
+    normalized[key] = key === "id" && typeof fieldValue === "string" ? normalizedToken(fieldValue) : key === "status" ? normalizeCriterionStatus(fieldValue) : fieldValue;
+  }
+  return normalized;
+}
+function normalizeCommandReport(value, pathLabel, errors) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return value;
+  const normalized = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (!COMMAND_REPORT_FIELDS.has(key)) {
+      errors.push(`${pathLabel}.${key}: unsupported acceptance command field`);
+      continue;
+    }
+    normalized[key] = key === "result" ? normalizeCommandResult(fieldValue) : fieldValue;
+  }
+  return normalized;
+}
+function normalizeAcceptanceReportValue(value, pathLabel = "") {
+  const errors = [];
+  let reportValue = value;
+  let reportPath = pathLabel;
+  if (reportValue && typeof reportValue === "object" && !Array.isArray(reportValue)) {
+    const record = reportValue;
+    const wrapperKeys = Object.keys(record).filter((key) => ACCEPTANCE_REPORT_WRAPPERS.has(key));
+    if (wrapperKeys.length > 0) {
+      const wrapperKey = wrapperKeys[0];
+      if (wrapperKeys.length > 1)
+        errors.push(`${pathLabel || "acceptance-report"}: multiple acceptance report wrappers are ambiguous`);
+      for (const key of Object.keys(record)) {
+        if (key !== wrapperKey)
+          errors.push(`${pathFor(pathLabel, key)}: unsupported alongside acceptance report wrapper '${wrapperKey}'`);
+      }
+      reportValue = record[wrapperKey];
+      reportPath = pathFor(pathLabel, wrapperKey);
+    }
+  }
+  if (!reportValue || typeof reportValue !== "object" || Array.isArray(reportValue))
+    return { value: reportValue, pathLabel: reportPath, errors };
+  const normalized = {};
+  for (const [key, fieldValue] of Object.entries(reportValue)) {
+    const canonical = ACCEPTANCE_REPORT_FIELDS[key];
+    if (!canonical) {
+      errors.push(`${pathFor(reportPath, key)}: unsupported acceptance report field`);
+      continue;
+    }
+    if (Object.hasOwn(normalized, canonical)) {
+      errors.push(`${pathFor(reportPath, key)}: duplicates normalized field '${canonical}'`);
+      continue;
+    }
+    const fieldPath = pathFor(reportPath, canonical);
+    switch (canonical) {
+      case "criteriaSatisfied": {
+        const items = Array.isArray(fieldValue) ? fieldValue : fieldValue && typeof fieldValue === "object" ? [fieldValue] : fieldValue;
+        normalized[canonical] = Array.isArray(items) ? items.map((item, index) => normalizeCriterionReport(item, `${fieldPath}[${index}]`, errors)) : items;
+        break;
+      }
+      case "commandsRun": {
+        const items = Array.isArray(fieldValue) ? fieldValue : fieldValue && typeof fieldValue === "object" ? [fieldValue] : fieldValue;
+        normalized[canonical] = Array.isArray(items) ? items.map((item, index) => normalizeCommandReport(item, `${fieldPath}[${index}]`, errors)) : items;
+        break;
+      }
+      case "changedFiles":
+      case "testsAddedOrUpdated":
+      case "validationOutput":
+      case "residualRisks":
+      case "reviewFindings": {
+        const items = typeof fieldValue === "string" ? [fieldValue] : fieldValue;
+        normalized[canonical] = Array.isArray(items) ? items.filter((item) => typeof item !== "string" || item.trim().length > 0) : items;
+        break;
+      }
+      case "noStagedFiles": {
+        const token = typeof fieldValue === "string" ? fieldValue.trim().toLowerCase() : undefined;
+        normalized[canonical] = token === "true" ? true : token === "false" ? false : fieldValue;
+        break;
+      }
+      default:
+        normalized[canonical] = fieldValue;
+    }
+  }
+  return { value: normalized, pathLabel: reportPath, errors };
 }
 function hasGenericAcceptanceReportSignal(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
   const record = value;
-  return "criteriaSatisfied" in record && (isStringArray(record.changedFiles) || isStringArray(record.testsAddedOrUpdated) || isCommandsRunArray(record.commandsRun) || isStringArray(record.validationOutput) || isStringArray(record.residualRisks) || typeof record.noStagedFiles === "boolean" || typeof record.diffSummary === "string" || isStringArray(record.reviewFindings) || typeof record.manualNotes === "string");
+  return "criteriaSatisfied" in record && [
+    "changedFiles",
+    "testsAddedOrUpdated",
+    "commandsRun",
+    "validationOutput",
+    "residualRisks",
+    "noStagedFiles",
+    "diffSummary",
+    "reviewFindings",
+    "manualNotes"
+  ].some((key) => (key in record));
 }
 function parseReportJson(body) {
   const trimmed = body.trim();
@@ -384,31 +597,36 @@ function parseReportJson(body) {
 function fencedBlocks(output, tag) {
   return [...output.matchAll(new RegExp(`\`\`\`${tag}\\s*\\n([\\s\\S]*?)\`\`\``, "gi"))].map((match) => match[1]?.trim()).filter((value) => Boolean(value));
 }
-function validationPathLabelForWrapper(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return "";
-  const record = value;
-  if ("acceptance" in record)
-    return "acceptance";
-  if ("acceptance-report" in record)
-    return "acceptance-report";
-  return "";
-}
 function parseAcceptanceReportBody(body) {
-  const parsed = parseReportJson(body);
-  const report = unwrapAcceptanceReport(parsed);
-  return validateAcceptanceReport(report, validationPathLabelForWrapper(parsed));
+  return validateAcceptanceReport(parseReportJson(body));
+}
+function parseUnterminatedAcceptanceReportFence(output) {
+  const opener = /```acceptance[-_]report\b[^\n]*\n/gi.exec(output);
+  if (!opener)
+    return {};
+  const bodyStart = opener.index + opener[0].length;
+  if (output.indexOf("```", bodyStart) !== -1)
+    return {};
+  try {
+    const validation = validateAcceptanceReport(JSON.parse(output.slice(bodyStart).trim()));
+    return validation.report ? { report: validation.report } : { error: `Failed to parse acceptance-report: Invalid acceptance-report: ${validation.errors.join("; ")}`, malformed: true };
+  } catch (error) {
+    return { error: `Failed to parse acceptance-report: ${error instanceof Error ? error.message : String(error)}`, malformed: true };
+  }
 }
 function parseGenericJsonAcceptanceReportBody(body) {
   const parsed = parseReportJson(body);
-  const report = unwrapAcceptanceReport(parsed);
-  const validation = validateAcceptanceReport(report);
-  if (!validation.report)
-    return;
-  return hasGenericAcceptanceReportSignal(validation.report) ? validation.report : undefined;
+  const normalized = normalizeAcceptanceReportValue(parsed);
+  const hasCriteriaMarker = normalized.value !== null && typeof normalized.value === "object" && !Array.isArray(normalized.value) && "criteriaSatisfied" in normalized.value;
+  if (!hasGenericAcceptanceReportSignal(normalized.value) && !(hasCriteriaMarker && normalized.errors.length > 0))
+    return {};
+  const validation = validateAcceptanceReport(parsed);
+  return validation.report ? { report: validation.report } : { error: `Invalid acceptance-report: ${validation.errors.join("; ")}`, malformed: true };
 }
+export const ACCEPTANCE_REPORT_NOT_FOUND = "Structured acceptance report not found.";
 export function parseAcceptanceReport(output) {
-  const fenced = fencedBlocks(output, "acceptance-report");
+  const explicitFencePresent = /```acceptance[-_]report\b/i.test(output);
+  const fenced = fencedBlocks(output, "acceptance[-_]report");
   const parseErrors = [];
   for (const body of fenced) {
     try {
@@ -421,37 +639,65 @@ export function parseAcceptanceReport(output) {
     }
   }
   if (parseErrors.length > 0)
-    return { error: `Failed to parse acceptance-report: ${parseErrors.join("; ")}` };
+    return { error: `Failed to parse acceptance-report: ${parseErrors.join("; ")}`, malformed: true };
+  if (explicitFencePresent) {
+    const recovered = parseUnterminatedAcceptanceReportFence(output);
+    if (recovered.report || recovered.error)
+      return recovered;
+    return { error: "Failed to parse acceptance-report: Empty or unterminated acceptance-report fence.", malformed: true };
+  }
   for (const body of fencedBlocks(output, "(?:json|jsonc|json5)")) {
     try {
-      const report = parseGenericJsonAcceptanceReportBody(body);
-      if (report)
-        return { report };
+      const parsed = parseGenericJsonAcceptanceReportBody(body);
+      if (parsed.report)
+        return { report: parsed.report };
+      if (parsed.error)
+        return { error: `Failed to parse acceptance-report: ${parsed.error}`, malformed: parsed.malformed };
     } catch {}
   }
   const markerIndex = output.search(/ACCEPTANCE_REPORT\s*:/i);
   if (markerIndex !== -1) {
     const jsonStart = output.indexOf("{", markerIndex);
-    if (jsonStart !== -1) {
-      const json = extractBalancedJson(output, jsonStart);
-      if (json) {
-        try {
-          const parsed = JSON.parse(json);
-          const report = unwrapAcceptanceReport(parsed);
-          const validation = validateAcceptanceReport(report, validationPathLabelForWrapper(parsed));
-          if (validation.report)
-            return { report: validation.report };
-          return { error: `Failed to parse acceptance-report: Invalid acceptance-report: ${validation.errors.join("; ")}` };
-        } catch (error) {
-          return { error: error instanceof Error ? error.message : String(error) };
-        }
-      }
+    if (jsonStart === -1) {
+      return { error: "Failed to parse acceptance-report: Expected a JSON object after ACCEPTANCE_REPORT:.", malformed: true };
+    }
+    const json = extractBalancedJson(output, jsonStart);
+    if (!json) {
+      return { error: "Failed to parse acceptance-report: Unterminated JSON object after ACCEPTANCE_REPORT:.", malformed: true };
+    }
+    try {
+      const parsed = JSON.parse(json);
+      const validation = validateAcceptanceReport(parsed);
+      if (validation.report)
+        return { report: validation.report };
+      return { error: `Failed to parse acceptance-report: Invalid acceptance-report: ${validation.errors.join("; ")}`, malformed: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { error: `Failed to parse acceptance-report: ${message}`, malformed: true };
     }
   }
-  return { error: "Structured acceptance report not found." };
+  return { error: ACCEPTANCE_REPORT_NOT_FOUND };
+}
+function parseAcceptanceReportSources(output, fileOutput) {
+  const fromText = () => parseAcceptanceReport(output);
+  const fromFile = () => {
+    if (!fileOutput)
+      return { error: ACCEPTANCE_REPORT_NOT_FOUND };
+    const parsed = parseAcceptanceReport(fileOutput.content);
+    return parsed.report || parsed.error === ACCEPTANCE_REPORT_NOT_FOUND ? parsed : {
+      ...parsed,
+      error: `${parsed.error} (in configured output ${fileOutput.path})`,
+      sourcePath: fileOutput.path
+    };
+  };
+  const [primary, secondary] = fileOutput?.authoritative ? [fromFile, fromText] : [fromText, fromFile];
+  const first = primary();
+  if (first.report || first.error !== ACCEPTANCE_REPORT_NOT_FOUND)
+    return first;
+  return secondary();
 }
 export function stripAcceptanceReport(output) {
-  const trailingFencePattern = /\n?```(acceptance-report|json|jsonc|json5)\s*\n([\s\S]*?)```\s*/gi;
+  const trailingFencePattern = /\n?```(acceptance[-_]report|json|jsonc|json5)\s*\n([\s\S]*?)```\s*/gi;
   let trailingFence;
   for (const match of output.matchAll(trailingFencePattern)) {
     const end = (match.index ?? 0) + match[0].length;
@@ -460,14 +706,14 @@ export function stripAcceptanceReport(output) {
     }
   }
   if (trailingFence) {
-    if (trailingFence.tag === "acceptance-report")
+    if (trailingFence.tag === "acceptance-report" || trailingFence.tag === "acceptance_report")
       return output.slice(0, trailingFence.index).trimEnd();
     try {
-      if (parseGenericJsonAcceptanceReportBody(trailingFence.body))
+      if (parseGenericJsonAcceptanceReportBody(trailingFence.body).report)
         return output.slice(0, trailingFence.index).trimEnd();
     } catch {}
   }
-  return output.replace(/\n?```acceptance-report\s*\n[\s\S]*?```\s*$/i, "").replace(/\n?ACCEPTANCE_REPORT\s*:\s*\{[\s\S]*\}\s*$/i, "").trimEnd();
+  return output.replace(/\n?```acceptance[-_]report\s*\n[\s\S]*?```\s*$/i, "").replace(/\n?ACCEPTANCE_REPORT\s*:\s*\{[\s\S]*\}\s*$/i, "").trimEnd();
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
@@ -499,12 +745,15 @@ function validateStringArrayField(errors, value, pathLabel) {
     return;
   }
   for (const [index, item] of value.entries()) {
-    if (typeof item !== "string")
-      pushTypeError(errors, `${pathLabel}[${index}]`, "string", item);
+    if (typeof item !== "string" || !item.trim())
+      pushTypeError(errors, `${pathLabel}[${index}]`, "non-empty string", item);
   }
 }
 function validateAcceptanceReport(value, pathLabel = "") {
-  const errors = [];
+  const normalized = normalizeAcceptanceReportValue(value, pathLabel);
+  value = normalized.value;
+  pathLabel = normalized.pathLabel;
+  const errors = normalized.errors;
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     pushTypeError(errors, pathLabel || "acceptance-report", "object", value);
     return { errors };
@@ -514,6 +763,7 @@ function validateAcceptanceReport(value, pathLabel = "") {
     if (!Array.isArray(report.criteriaSatisfied)) {
       pushTypeError(errors, pathFor(pathLabel, "criteriaSatisfied"), "array", report.criteriaSatisfied);
     } else {
+      const criterionIds = new Set;
       for (const [index, item] of report.criteriaSatisfied.entries()) {
         const itemPath = `${pathFor(pathLabel, "criteriaSatisfied")}[${index}]`;
         if (!item || typeof item !== "object" || Array.isArray(item)) {
@@ -521,8 +771,13 @@ function validateAcceptanceReport(value, pathLabel = "") {
           continue;
         }
         const criterion = item;
-        if (criterion.id !== undefined && typeof criterion.id !== "string")
+        if (criterion.id !== undefined && typeof criterion.id !== "string") {
           pushTypeError(errors, `${itemPath}.id`, "string", criterion.id);
+        } else if (typeof criterion.id === "string" && criterion.id) {
+          if (criterionIds.has(criterion.id))
+            errors.push(`${itemPath}.id: duplicate normalized criterion id '${criterion.id}'`);
+          criterionIds.add(criterion.id);
+        }
         if (criterion.status !== "satisfied" && criterion.status !== "not-satisfied" && criterion.status !== "not-applicable") {
           pushTypeError(errors, `${itemPath}.status`, 'one of "satisfied", "not-satisfied", "not-applicable"', criterion.status);
         }
@@ -551,8 +806,8 @@ function validateAcceptanceReport(value, pathLabel = "") {
         if (command.result !== "passed" && command.result !== "failed" && command.result !== "not-run") {
           pushTypeError(errors, `${itemPath}.result`, 'one of "passed", "failed", "not-run"', command.result);
         }
-        if (typeof command.summary !== "string")
-          pushTypeError(errors, `${itemPath}.summary`, "string", command.summary);
+        if (typeof command.summary !== "string" || !command.summary.trim())
+          pushTypeError(errors, `${itemPath}.summary`, "non-empty string", command.summary);
       }
     }
   }
@@ -562,8 +817,8 @@ function validateAcceptanceReport(value, pathLabel = "") {
     validateStringArrayField(errors, report.residualRisks, pathFor(pathLabel, "residualRisks"));
   if (report.noStagedFiles !== undefined && typeof report.noStagedFiles !== "boolean")
     pushTypeError(errors, pathFor(pathLabel, "noStagedFiles"), "boolean", report.noStagedFiles);
-  if (report.diffSummary !== undefined && typeof report.diffSummary !== "string")
-    pushTypeError(errors, pathFor(pathLabel, "diffSummary"), "string", report.diffSummary);
+  if (report.diffSummary !== undefined && (typeof report.diffSummary !== "string" || !report.diffSummary.trim()))
+    pushTypeError(errors, pathFor(pathLabel, "diffSummary"), "non-empty string", report.diffSummary);
   if (report.reviewFindings !== undefined)
     validateStringArrayField(errors, report.reviewFindings, pathFor(pathLabel, "reviewFindings"));
   if (report.manualNotes !== undefined && typeof report.manualNotes !== "string")
@@ -576,9 +831,9 @@ function validateAcceptanceReport(value, pathLabel = "") {
   return hasReportField ? { report, errors } : { errors: [`${pathLabel || "acceptance-report"}: expected at least one acceptance report field`] };
 }
 function checkCriteriaSatisfied(criteria, report) {
-  const reports = new Map((report.criteriaSatisfied ?? []).filter((item) => item.id).map((item) => [item.id, item]));
+  const reports = new Map((report.criteriaSatisfied ?? []).filter((item) => item.id).map((item) => [normalizedToken(item.id), item]));
   return criteria.filter((criterion) => criterion.severity !== "recommended").map((criterion) => {
-    const item = reports.get(criterion.id);
+    const item = reports.get(normalizedToken(criterion.id));
     if (!item)
       return { id: `criterion:${criterion.id}`, status: "failed", message: `Required criterion '${criterion.id}' was not reported.` };
     if (item.status !== "satisfied")
@@ -586,30 +841,34 @@ function checkCriteriaSatisfied(criteria, report) {
     return { id: `criterion:${criterion.id}`, status: "passed", message: `Required criterion '${criterion.id}' satisfied.` };
   });
 }
-function reportEvidencePresent(report, kind) {
+function reportEvidenceStatus(report, kind) {
   switch (kind) {
     case "changed-files":
-      return isStringArray(report.changedFiles) && report.changedFiles.length > 0;
+      if (!isStringArray(report.changedFiles))
+        return "failed";
+      return report.changedFiles.length === 0 ? "not-applicable" : "passed";
     case "tests-added":
-      return isStringArray(report.testsAddedOrUpdated) && report.testsAddedOrUpdated.length > 0;
+      if (!isStringArray(report.testsAddedOrUpdated))
+        return "failed";
+      return report.testsAddedOrUpdated.length === 0 ? "not-applicable" : "passed";
     case "commands-run":
-      return Array.isArray(report.commandsRun) && report.commandsRun.length > 0;
+      return Array.isArray(report.commandsRun) && report.commandsRun.length > 0 ? "passed" : "failed";
     case "validation-output":
-      return isStringArray(report.validationOutput) && report.validationOutput.length > 0;
+      return isStringArray(report.validationOutput) && report.validationOutput.length > 0 ? "passed" : "failed";
     case "residual-risks":
-      return isStringArray(report.residualRisks);
+      return isStringArray(report.residualRisks) ? "passed" : "failed";
     case "no-staged-files":
-      return report.noStagedFiles === true;
+      return report.noStagedFiles === true ? "passed" : "failed";
     case "diff-summary":
-      return typeof report.diffSummary === "string" && report.diffSummary.trim().length > 0;
+      return typeof report.diffSummary === "string" && report.diffSummary.trim().length > 0 ? "passed" : "failed";
     case "review-findings":
-      return isStringArray(report.reviewFindings);
+      return isStringArray(report.reviewFindings) ? "passed" : "failed";
     case "manual-notes":
-      return Boolean((report.manualNotes ?? report.notes)?.trim());
+      return Boolean((report.manualNotes ?? report.notes)?.trim()) ? "passed" : "failed";
   }
 }
 function checkNoStagedFiles(cwd) {
-  const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+  const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8", windowsHide: true });
   if (result.status !== 0) {
     return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
   }
@@ -619,11 +878,13 @@ function checkNoStagedFiles(cwd) {
 function runStructuralChecks(acceptance, report, cwd) {
   const checks = [];
   for (const kind of acceptance.evidence) {
-    const present = reportEvidencePresent(report, kind);
+    if (kind === "no-staged-files" && report.noStagedFiles === undefined)
+      continue;
+    const status = reportEvidenceStatus(report, kind);
     checks.push({
       id: `evidence:${kind}`,
-      status: present ? "passed" : "failed",
-      message: present ? `${kind} evidence present.` : `${kind} evidence missing from child report.`
+      status,
+      message: status === "passed" ? `${kind} evidence present.` : status === "not-applicable" ? `${kind} evidence explicitly reported as not applicable.` : `${kind} evidence missing from child report.`
     });
   }
   if (acceptance.evidence.includes("no-staged-files"))
@@ -637,6 +898,25 @@ function trimOutput(value) {
   return trimmed.length > 12000 ? `${trimmed.slice(0, 12000)}
 ...[truncated]` : trimmed;
 }
+const SENSITIVE_ENV_KEY_PATTERN = /(?:^|_)(?:TOKEN|SECRET|PASSWORD|PASS|AUTH|CREDENTIAL|COOKIE|SESSION|PRIVATE|API_KEY|ACCESS_KEY)(?:_|$)/i;
+function effectiveVerifyEnv(env) {
+  const inherited = Object.fromEntries(Object.entries(process.env).flatMap(([key, value]) => {
+    return typeof value === "string" ? [[key, value]] : [];
+  }));
+  return { ...inherited, ...env ?? {} };
+}
+function verifyRedactionEnv(env) {
+  return Object.fromEntries(Object.entries(effectiveVerifyEnv(env)).filter(([key, value]) => {
+    return value.length >= 4 && SENSITIVE_ENV_KEY_PATTERN.test(key);
+  }));
+}
+function redactVerifyEnv(value, env) {
+  let redacted = value;
+  const secrets = [...new Set(Object.values(verifyRedactionEnv(env)).filter(Boolean))].sort((left, right) => right.length - left.length);
+  for (const secret of secrets)
+    redacted = redacted.replaceAll(secret, "[REDACTED]");
+  return redacted;
+}
 function uniqueStrings(items) {
   return unique(items.map((item) => item?.trim()).filter((item) => Boolean(item)));
 }
@@ -668,6 +948,119 @@ export function aggregateAcceptanceReport(input) {
     notes: input.notes
   };
 }
+const DEFAULT_VERIFY_TIMEOUT_MS = 120000;
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function readVerifyWorkspaceState(cwd) {
+  const repo = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf-8", windowsHide: true });
+  if (repo.status !== 0 || !repo.stdout.trim())
+    return;
+  const repoRoot = fs.realpathSync(repo.stdout.trim());
+  const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf-8", windowsHide: true });
+  const diff = spawnSync("git", ["diff", "--binary", "--full-index", "HEAD", "--"], { cwd: repoRoot, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, windowsHide: true });
+  if (head.status !== 0 || diff.status !== 0 || !head.stdout.trim())
+    return;
+  return {
+    kind: "git-tracked",
+    repoRoot,
+    cwdRelative: path.relative(repoRoot, fs.realpathSync(cwd)) || ".",
+    head: head.stdout.trim(),
+    diffHash: hash(diff.stdout)
+  };
+}
+function isCachedVerifyResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const result = value;
+  return typeof result.id === "string" && typeof result.command === "string" && (typeof result.exitCode === "number" || result.exitCode === null) && (result.status === "passed" || result.status === "failed" || result.status === "timed-out" || result.status === "allowed-failure") && typeof result.durationMs === "number";
+}
+async function runMemoizedVerifyCommand(command, defaultCwd, options = {}) {
+  const cwd = command.cwd ? path.resolve(defaultCwd, command.cwd) : defaultCwd;
+  let workspaceState;
+  try {
+    workspaceState = readVerifyWorkspaceState(cwd);
+  } catch {
+    workspaceState = undefined;
+  }
+  if (!workspaceState || !options.artifactsDir || !options.runId) {
+    return runVerifyCommand(command, defaultCwd, options);
+  }
+  const envKeys = Object.keys(command.env ?? {}).sort();
+  const envHash = hash(JSON.stringify(Object.fromEntries(Object.entries(effectiveVerifyEnv(command.env)).sort(([left], [right]) => left.localeCompare(right)))));
+  const timeoutMs = command.timeoutMs ?? DEFAULT_VERIFY_TIMEOUT_MS;
+  const cacheKey = hash(JSON.stringify({
+    version: 1,
+    command: command.command,
+    cwdRelative: workspaceState.cwdRelative,
+    envKeys,
+    envHash,
+    timeoutMs,
+    allowFailure: command.allowFailure === true,
+    head: workspaceState.head,
+    diffHash: workspaceState.diffHash
+  }));
+  const artifactPath = path.join(options.artifactsDir, "acceptance", "verify", options.runId, `${cacheKey}.json`);
+  try {
+    const cached = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+    if (cached.cacheKey === cacheKey && isCachedVerifyResult(cached.result)) {
+      return { ...cached.result, id: command.id, command: command.command, cwd, artifactPath, cacheKey, memoized: true, envKeys, envHash, workspaceState };
+    }
+  } catch {}
+  const result = await runVerifyCommand(command, defaultCwd, options);
+  const evidenced = { ...result, artifactPath, cacheKey, memoized: false, envKeys, envHash, workspaceState };
+  try {
+    fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+    fs.writeFileSync(artifactPath, JSON.stringify({
+      version: 1,
+      cacheKey,
+      command: command.command,
+      cwdRelative: workspaceState.cwdRelative,
+      envKeys,
+      envHash,
+      timeoutMs,
+      allowFailure: command.allowFailure === true,
+      workspaceState,
+      result: evidenced
+    }, null, 2), "utf-8");
+  } catch (error) {
+    evidenced.artifactError = error instanceof Error ? error.message : String(error);
+    delete evidenced.artifactPath;
+  }
+  return evidenced;
+}
+export function quoteExecutableForShell(command, platform = process.platform) {
+  if (platform !== "win32")
+    return command;
+  const trimmed = command.trimStart();
+  if (trimmed.startsWith('"'))
+    return command;
+  const firstToken = trimmed.match(/^\S+/)?.[0];
+  if (/\.(?:exe|bat|cmd|com|ps1)$/i.test(firstToken ?? ""))
+    return command;
+  const match = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?\\[^"<>|&*?\r\n]*?\.(?:exe|bat|cmd|com|ps1))(?=\s|$)/i);
+  const executable = match?.[1];
+  if (executable && /\s/.test(executable) && !/[A-Za-z]:\\/.test(executable.slice(3))) {
+    const rest = trimmed.slice(executable.length);
+    const leading = command.slice(0, command.length - trimmed.length);
+    return `${leading}"${executable}"${rest}`;
+  }
+  const extensionlessSpacedFilenameMatch = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?)(?=\s+--|$)/i);
+  const extensionlessSpacedFilename = extensionlessSpacedFilenameMatch?.[1];
+  if (extensionlessSpacedFilename && /\s/.test(extensionlessSpacedFilename.slice(0, extensionlessSpacedFilename.lastIndexOf("\\"))) && !/[A-Za-z]:\\/.test(extensionlessSpacedFilename.slice(3))) {
+    const rest = trimmed.slice(extensionlessSpacedFilename.length);
+    const leading = command.slice(0, command.length - trimmed.length);
+    return `${leading}"${extensionlessSpacedFilename}"${rest}`;
+  }
+  const extensionlessMatch = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?\\[^"<>|&*?\s\r\n]+)(?=\s|$)/i);
+  const extensionlessExecutable = extensionlessMatch?.[1];
+  if (extensionlessExecutable && /\s/.test(extensionlessExecutable) && !/[A-Za-z]:\\/.test(extensionlessExecutable.slice(3)) && !/\s/.test(extensionlessExecutable.slice(extensionlessExecutable.lastIndexOf("\\") + 1))) {
+    const rest = trimmed.slice(extensionlessExecutable.length);
+    const leading = command.slice(0, command.length - trimmed.length);
+    return `${leading}"${extensionlessExecutable}"${rest}`;
+  }
+  return command;
+}
 function runVerifyCommand(command, defaultCwd, options = {}) {
   return new Promise((resolve) => {
     const startedAt = Date.now();
@@ -677,9 +1070,9 @@ function runVerifyCommand(command, defaultCwd, options = {}) {
     let timedOut = false;
     let settled = false;
     let hardKill;
-    const child = spawn(command.command, {
+    const child = spawn(quoteExecutableForShell(command.command), {
       cwd,
-      env: { ...process.env, ...command.env ?? {} },
+      env: effectiveVerifyEnv(command.env),
       shell: true,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
@@ -710,13 +1103,13 @@ function runVerifyCommand(command, defaultCwd, options = {}) {
         finish({
           exitCode: null,
           status: "timed-out",
-          stdout: trimOutput(stdout),
-          stderr: trimOutput(stderr || options.abortMessage || "Acceptance verification timed out.")
+          stdout: trimOutput(redactVerifyEnv(stdout, command.env)),
+          stderr: trimOutput(redactVerifyEnv(stderr || options.abortMessage || "Acceptance verification timed out.", command.env))
         });
       }, 1000);
       hardKill.unref?.();
     };
-    const timeout = setTimeout(abortVerification, command.timeoutMs ?? 120000);
+    const timeout = setTimeout(abortVerification, command.timeoutMs ?? DEFAULT_VERIFY_TIMEOUT_MS);
     timeout.unref?.();
     if (options.signal?.aborted)
       abortVerification();
@@ -733,23 +1126,25 @@ function runVerifyCommand(command, defaultCwd, options = {}) {
       finish({
         exitCode,
         status: timedOut ? "timed-out" : passed ? "passed" : command.allowFailure ? "allowed-failure" : "failed",
-        stdout: trimOutput(stdout),
-        stderr: trimOutput(stderr || (timedOut ? options.abortMessage ?? "" : ""))
+        stdout: trimOutput(redactVerifyEnv(stdout, command.env)),
+        stderr: trimOutput(redactVerifyEnv(stderr || (timedOut ? options.abortMessage ?? "" : ""), command.env))
       });
     });
     child.on("error", (error) => {
       finish({
         exitCode: timedOut ? null : 1,
         status: timedOut ? "timed-out" : command.allowFailure ? "allowed-failure" : "failed",
-        stderr: timedOut ? trimOutput(stderr || options.abortMessage || "Acceptance verification timed out.") : error instanceof Error ? error.message : String(error)
+        stderr: timedOut ? trimOutput(redactVerifyEnv(stderr || options.abortMessage || "Acceptance verification timed out.", command.env)) : redactVerifyEnv(error instanceof Error ? error.message : String(error), command.env)
       });
     });
   });
 }
 export async function evaluateAcceptance(input) {
   const acceptance = input.acceptance;
+  const initialStatus = acceptance.level === "none" ? "not-required" : "claimed";
   const ledger = {
-    status: acceptance.level === "none" ? "not-required" : "claimed",
+    status: initialStatus,
+    evidenceStatus: initialStatus,
     explicit: acceptance.explicit,
     effectiveAcceptance: acceptance,
     inferredReason: acceptance.inferredReason,
@@ -759,65 +1154,121 @@ export async function evaluateAcceptance(input) {
   };
   if (acceptance.level === "none")
     return ledger;
-  const parsed = input.report ? { report: input.report } : parseAcceptanceReport(input.output);
+  const parsed = input.reportError ? { error: input.reportError } : input.report ? (() => {
+    const validation = validateAcceptanceReport(input.report);
+    return validation.report ? { report: validation.report } : { error: `Failed to parse acceptance-report: Invalid acceptance-report: ${validation.errors.join("; ")}`, malformed: true };
+  })() : parseAcceptanceReportSources(input.output, input.fileOutput);
+  const durableFileOutput = input.fileOutput?.authoritative && input.fileOutput.durable ? input.fileOutput : undefined;
+  if (parsed.malformed && parsed.sourcePath && durableFileOutput) {
+    ledger.recovery = {
+      status: "available-for-review",
+      reason: "acceptance-metadata-rejected",
+      reportPath: parsed.sourcePath,
+      reportHash: hash(durableFileOutput.content)
+    };
+  }
+  const needsReport = acceptanceRequiresChildReport(acceptance);
   if (parsed.report) {
     ledger.childReport = parsed.report;
     ledger.status = "attested";
-  } else {
+    ledger.evidenceStatus = "attested";
+  } else if (!input.reportOptional || needsReport || parsed.error !== ACCEPTANCE_REPORT_NOT_FOUND) {
     ledger.childReportParseError = parsed.error;
     ledger.runtimeChecks.push({ id: "attestation", status: "failed", message: parsed.error ?? "Structured acceptance report missing." });
-    ledger.status = "rejected";
-    return ledger;
+    if (ledger.recovery) {
+      ledger.status = "rejected";
+      ledger.evidenceStatus = "rejected";
+    }
+    if (!input.reportOptional) {
+      ledger.status = "rejected";
+      ledger.evidenceStatus = "rejected";
+      return ledger;
+    }
+  } else {
+    ledger.childReportParseError = parsed.error;
   }
-  if (LEVEL_RANK[acceptance.level] >= LEVEL_RANK.checked) {
+  if (parsed.report && LEVEL_RANK[acceptance.level] >= LEVEL_RANK.checked) {
     ledger.runtimeChecks = [
+      ...ledger.runtimeChecks,
       ...checkCriteriaSatisfied(acceptance.criteria, parsed.report),
       ...runStructuralChecks(acceptance, parsed.report, input.cwd)
     ];
-    if (ledger.runtimeChecks.some((check) => check.status === "failed")) {
-      ledger.status = "rejected";
-      return ledger;
+    if (!ledger.runtimeChecks.some((check) => check.status === "failed")) {
+      ledger.status = "checked";
+      ledger.evidenceStatus = "checked";
     }
-    ledger.status = "checked";
   }
   if (LEVEL_RANK[acceptance.level] >= LEVEL_RANK.verified && (acceptance.level === "verified" || acceptance.verify.length > 0)) {
     if (acceptance.level === "verified" && acceptance.verify.length === 0) {
       ledger.runtimeChecks.push({ id: "verification-config", status: "failed", message: "verified acceptance requires runtime verify commands." });
       ledger.status = "rejected";
+      ledger.evidenceStatus = "rejected";
       return ledger;
     }
     ledger.verifyRuns = [];
     for (const command of acceptance.verify) {
-      ledger.verifyRuns.push(await runVerifyCommand(command, input.cwd, { signal: input.signal, abortMessage: input.abortMessage }));
+      ledger.verifyRuns.push(await runMemoizedVerifyCommand(command, input.cwd, {
+        signal: input.signal,
+        abortMessage: input.abortMessage,
+        artifactsDir: input.artifactsDir,
+        runId: input.runId
+      }));
       if (input.signal?.aborted)
         break;
     }
     if (ledger.verifyRuns.some((run) => run.status === "failed" || run.status === "timed-out")) {
       ledger.status = "rejected";
+      ledger.evidenceStatus = "rejected";
       return ledger;
     }
-    ledger.status = "verified";
+    if (!ledger.runtimeChecks.some((check) => check.status === "failed")) {
+      ledger.status = "verified";
+      ledger.evidenceStatus = "verified";
+    }
+  }
+  if (ledger.runtimeChecks.some((check) => check.status === "failed")) {
+    ledger.status = "rejected";
+    ledger.evidenceStatus = "rejected";
+    return ledger;
   }
-  if (acceptance.level === "reviewed") {
-    if (input.reviewResult) {
+  if (ledger.status === "claimed") {
+    ledger.status = acceptance.level === "verified" ? "verified" : acceptance.level;
+    ledger.evidenceStatus = ledger.status;
+  }
+  if (acceptance.review) {
+    if (input.reviewResult?.status === "reviewed") {
       ledger.reviewResult = input.reviewResult;
-      ledger.status = input.reviewResult.status === "no-blockers" ? "reviewed" : "rejected";
-    } else {
-      const optionalReview = acceptance.review && acceptance.review !== false && acceptance.review.required === false;
-      ledger.reviewResult = {
-        status: "needs-parent-decision",
+      ledger.status = "reviewed";
+    } else if (input.reviewResult?.status === "blockers") {
+      ledger.reviewResult = input.reviewResult;
+      ledger.status = "rejected";
+    } else if (acceptance.review.required !== false) {
+      ledger.reviewResult = input.reviewResult ?? {
+        status: "review-required",
         findings: [{
-          severity: acceptance.explicit && !optionalReview ? "blocker" : "non-blocking",
-          issue: "Reviewed acceptance requires an independent reviewer result.",
+          severity: "non-blocking",
+          issue: "Independent review has not been supplied.",
           rationale: "The run cannot be marked reviewed from child evidence alone."
         }]
       };
-      if (acceptance.review === false || acceptance.explicit && !optionalReview)
-        ledger.status = "rejected";
+      ledger.status = "review-required";
     }
   }
   return ledger;
 }
+export function buildSkippedAcceptanceLedger(acceptance, input) {
+  const status = acceptance.level === "none" ? "not-required" : "rejected";
+  return {
+    status,
+    evidenceStatus: status,
+    explicit: acceptance.explicit,
+    effectiveAcceptance: acceptance,
+    inferredReason: acceptance.inferredReason,
+    criteria: acceptance.criteria,
+    runtimeChecks: acceptance.level === "none" ? [] : [{ id: input.id, status: "failed", message: input.message }],
+    verifyRuns: []
+  };
+}
 export function acceptanceFailureMessage(ledger) {
   if (ledger.status !== "rejected")
     return;
@@ -827,8 +1278,6 @@ export function acceptanceFailureMessage(ledger) {
   const failedVerify = ledger.verifyRuns.find((run) => run.status === "failed" || run.status === "timed-out");
   if (failedVerify)
     return `Acceptance verification '${failedVerify.id}' ${failedVerify.status}.`;
-  if (ledger.reviewResult?.status === "needs-parent-decision")
-    return "Acceptance review required but no automatic reviewer result is available.";
   if (ledger.reviewResult?.status === "blockers")
     return "Acceptance review found blockers.";
   return "Acceptance rejected.";