@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -3,8 +3,9 @@ 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";
+import { unresolvedChildWatchdogBlockers } from "../../watchdog/child-status.js";
+import { isAgentContract } from "./agent-contract.js";
+import { validateStructuredOutputValue } from "./structured-output.js";
 const LEVEL_RANK = {
   none: 0,
   attested: 1,
@@ -26,9 +27,9 @@ const VALID_EVIDENCE_KINDS = [
 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_CONFIG_KEYS = new Set(["level", "report", "preserveStagedIndex", "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_VERIFY_KEYS = new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure", "output", "schema"]);
 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) {
@@ -50,21 +51,8 @@ function requiredEvidenceForLevel(level) {
   }
 }
 function inferLevel(input) {
-  const agent = input.agentName.toLowerCase();
-  const task = input.task?.toLowerCase() ?? "";
-  const reasons = [];
-  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.acceptanceRole === "writer" && (input.async || input.dynamic || input.dynamicGroup)) {
+    const reasons = [input.async ? "async declared writer" : "dynamic declared writer"];
     if (input.dynamic || input.dynamicGroup)
       reasons.push("dynamic fanout context");
     return {
@@ -75,33 +63,55 @@ function inferLevel(input) {
       review: { agent: "reviewer", required: true }
     };
   }
-  if (writeTask && !readOnlyTask) {
-    reasons.push(input.acceptanceRole === "writer" && !taskMayWrite ? "declared writer acceptance role" : "write-capable worker/task");
+  if (input.acceptanceRole === "writer") {
     return {
       level: "checked",
-      reasons,
+      reasons: ["declared writer acceptance role"],
       criteria: ["Implement the requested change without widening scope"],
       evidence: requiredEvidenceForLevel("checked")
     };
   }
-  if (readOnlyAgent || readOnlyTask) {
-    reasons.push(input.acceptanceRole === "read-only" && !readOnlyTask ? "declared read-only acceptance role" : readOnlyAgent ? "read-only/reviewer-style agent" : "read-only task wording");
+  if (input.acceptanceRole === "read-only") {
     return {
-      level: "attested",
-      reasons,
+      level: "none",
+      reasons: ["declared read-only acceptance role"],
       criteria: ["Return concrete findings with file paths and severity when applicable"],
       evidence: ["review-findings", "residual-risks"]
     };
   }
-  reasons.push("default lightweight attestation");
   return {
     level: "attested",
-    reasons,
+    reasons: ["default lightweight attestation"],
     criteria: ["Return a concise result and residual risks when applicable"],
     evidence: ["manual-notes", "residual-risks"]
   };
 }
+function normalizeAcceptanceValue(input, pathLabel = "acceptance") {
+  if (typeof input !== "string")
+    return { value: input };
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+    return { value: input };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    return {
+      value: input,
+      error: `${pathLabel} JSON string must encode a valid acceptance object: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    const kind = parsed === null ? "null" : Array.isArray(parsed) ? "an array" : typeof parsed;
+    return { value: input, error: `${pathLabel} JSON string must encode an object; got ${kind}.` };
+  }
+  return { value: parsed };
+}
 export function normalizeAcceptanceInput(input) {
+  const normalized = normalizeAcceptanceValue(input);
+  if (normalized.error)
+    throw new Error(normalized.error);
+  input = normalized.value;
   if (input === undefined || input === "auto")
     return { level: "auto" };
   if (input === false)
@@ -110,18 +120,86 @@ export function normalizeAcceptanceInput(input) {
     return { level: input };
   return { ...input };
 }
+export function resolveAcceptanceReportMode(input) {
+  const normalized = normalizeAcceptanceValue(input);
+  if (normalized.error)
+    throw new Error(normalized.error);
+  const value = normalized.value;
+  const report = value && typeof value === "object" && !Array.isArray(value) ? value.report : undefined;
+  return value === false || report === "off" ? "off" : report === "on" ? "required" : "optional";
+}
+const GATE_OBJECT_KEYS = new Set(["command", "output", "schema", "timeoutMs"]);
+export const GATE_INPUT_ERROR = 'gate must be a non-empty command string or { command, output?: "json", schema?, timeoutMs? }.';
+export function parseGateInput(gate) {
+  if (typeof gate === "string") {
+    return gate.trim() ? { ok: true, gate: { command: gate.trim() } } : { ok: false, error: GATE_INPUT_ERROR };
+  }
+  if (!gate || typeof gate !== "object" || Array.isArray(gate))
+    return { ok: false, error: GATE_INPUT_ERROR };
+  const value = gate;
+  for (const key of Object.keys(value)) {
+    if (!GATE_OBJECT_KEYS.has(key))
+      return { ok: false, error: `gate.${key} is not supported.` };
+  }
+  if (typeof value.command !== "string" || !value.command.trim())
+    return { ok: false, error: GATE_INPUT_ERROR };
+  if (value.output !== undefined && value.output !== "json")
+    return { ok: false, error: 'gate.output must be "json" when present.' };
+  if (value.schema !== undefined) {
+    if (value.output !== "json")
+      return { ok: false, error: 'gate.schema requires gate.output: "json".' };
+    if (!value.schema || typeof value.schema !== "object" || Array.isArray(value.schema))
+      return { ok: false, error: "gate.schema must be a JSON Schema object." };
+  }
+  if (value.timeoutMs !== undefined && (!Number.isInteger(value.timeoutMs) || value.timeoutMs < 1))
+    return { ok: false, error: "gate.timeoutMs must be an integer >= 1." };
+  const parsed = { command: value.command.trim() };
+  if (value.output === "json")
+    parsed.output = "json";
+  if (value.schema !== undefined)
+    parsed.schema = value.schema;
+  if (value.timeoutMs !== undefined)
+    parsed.timeoutMs = value.timeoutMs;
+  return { ok: true, gate: parsed };
+}
+export function acceptanceHasTypedVerify(acceptance) {
+  if (!acceptance || typeof acceptance !== "object")
+    return false;
+  return Array.isArray(acceptance.verify) && acceptance.verify.some((command) => command && typeof command === "object" && command.output === "json");
+}
+export const TYPED_VERIFY_OUTPUT_SCHEMA_CONFLICT = 'a typed verify command (output: "json") cannot be combined with outputSchema; the child would have two structured-output sources.';
 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() }] } };
+  if (gate === undefined) {
+    if (acceptance === undefined)
+      return { ok: true };
+    const normalized = normalizeAcceptanceValue(acceptance);
+    return normalized.error ? { ok: false, error: normalized.error } : { ok: true, acceptance: normalized.value };
+  }
+  const parsed = parseGateInput(gate);
+  if (!parsed.ok)
+    return { ok: false, error: parsed.error };
+  if (acceptance !== undefined && acceptance !== false)
+    return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." + describeGateAcceptanceConflict(gate, acceptance) };
+  return { ok: true, acceptance: { level: "verified", verify: [{ id: "gate", ...parsed.gate }] } };
+}
+export function describeGateAcceptanceConflict(gate, acceptance) {
+  const render = (value) => {
+    let encoded;
+    try {
+      encoded = JSON.stringify(value) ?? String(value);
+    } catch {
+      encoded = String(value);
+    }
+    return encoded.length > 120 ? `${encoded.slice(0, 120)}...` : encoded;
+  };
+  return ` Both fields were present: gate=${render(gate)} acceptance=${render(acceptance)}.`;
 }
 function explicitAcceptanceCanDisable(explicit) {
   return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
 }
+function explicitAcceptanceRequestsPolicy(explicit) {
+  return explicit.level !== undefined && explicit.level !== "auto" || Object.keys(explicit).some((key) => key !== "level");
+}
 function unsupportedEvidenceKindMessage(pathLabel, item) {
   const value = typeof item === "string" ? ` "${item}"` : "";
   return `${pathLabel}${value} is not a supported evidence kind. ${ACCEPTANCE_EVIDENCE_HELP}`;
@@ -132,6 +210,10 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
     return errors;
   if (input === false)
     return errors;
+  const normalized = normalizeAcceptanceValue(input, pathLabel);
+  if (normalized.error)
+    return [normalized.error];
+  input = normalized.value;
   if (typeof input === "string") {
     if (input === "reviewed")
       errors.push(`${pathLabel} ${EXPLICIT_REVIEWED_UNAVAILABLE}`);
@@ -157,6 +239,15 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   } 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.report !== undefined && value.report !== "on" && value.report !== "off") {
+    errors.push(`${pathLabel}.report must be on or off.`);
+  }
+  if (value.preserveStagedIndex !== undefined && value.preserveStagedIndex !== true) {
+    errors.push(`${pathLabel}.preserveStagedIndex must be true when provided.`);
+  }
+  if (value.preserveStagedIndex === true && value.level !== "checked" && value.level !== "verified") {
+    errors.push(`${pathLabel}.preserveStagedIndex requires level checked or verified.`);
+  }
   if (value.level === "none" && (typeof value.reason !== "string" || !value.reason.trim())) {
     errors.push(`${pathLabel}.reason is required when level is none.`);
   }
@@ -250,6 +341,14 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
       if (cmd.allowFailure !== undefined && typeof cmd.allowFailure !== "boolean") {
         errors.push(`${pathLabel}.verify[${index}].allowFailure must be a boolean.`);
       }
+      if (cmd.output !== undefined && cmd.output !== "json")
+        errors.push(`${pathLabel}.verify[${index}].output must be "json" when present.`);
+      if (cmd.schema !== undefined) {
+        if (cmd.output !== "json")
+          errors.push(`${pathLabel}.verify[${index}].schema requires output: "json".`);
+        if (!cmd.schema || typeof cmd.schema !== "object" || Array.isArray(cmd.schema))
+          errors.push(`${pathLabel}.verify[${index}].schema must be a JSON Schema object.`);
+      }
     }
   }
   if (value.review !== undefined && value.review !== false) {
@@ -279,7 +378,7 @@ export function validateAcceptanceInput(input, pathLabel = "acceptance") {
   }
   return errors;
 }
-export function validateExecutionAcceptance(input) {
+export function validateExecutionAcceptancePolicy(input) {
   const errors = validateAcceptanceInput(input.acceptance, "acceptance");
   for (const [index, task] of (input.tasks ?? []).entries()) {
     errors.push(...validateAcceptanceInput(task.acceptance, `tasks[${index}].acceptance`));
@@ -296,6 +395,35 @@ export function validateExecutionAcceptance(input) {
   }
   return errors;
 }
+export function validateExecutionAcceptance(input) {
+  const errors = validateExecutionAcceptancePolicy(input);
+  errors.push(...validateAcceptanceReportMode(input.acceptance, input.outputSchema, "acceptance"));
+  for (const [index, task] of (input.tasks ?? []).entries()) {
+    errors.push(...validateAcceptanceReportMode(task.acceptance, task.outputSchema, `tasks[${index}].acceptance`));
+  }
+  for (const [stepIndex, step] of (input.chain ?? []).entries()) {
+    errors.push(...validateAcceptanceReportMode(step.acceptance, step.outputSchema, `chain[${stepIndex}].acceptance`));
+    if (Array.isArray(step.parallel)) {
+      for (const [taskIndex, task] of step.parallel.entries()) {
+        errors.push(...validateAcceptanceReportMode(task.acceptance, task.outputSchema, `chain[${stepIndex}].parallel[${taskIndex}].acceptance`));
+      }
+    } else if (step.parallel) {
+      errors.push(...validateAcceptanceReportMode(step.parallel.acceptance, step.parallel.outputSchema, `chain[${stepIndex}].parallel.acceptance`));
+    }
+  }
+  return errors;
+}
+function validateAcceptanceReportMode(acceptance, outputSchema, pathLabel) {
+  const normalized = normalizeAcceptanceValue(acceptance, pathLabel);
+  if (normalized.error)
+    return [];
+  acceptance = normalized.value;
+  if (!acceptance || typeof acceptance !== "object" || Array.isArray(acceptance))
+    return [];
+  if (!("report" in acceptance))
+    return [];
+  return outputSchema === undefined || outputSchema === false ? [`${pathLabel}.report requires outputSchema.`] : [];
+}
 function normalizeCriteria(criteria, evidence) {
   return (criteria ?? []).map((criterion, index) => {
     if (typeof criterion === "string") {
@@ -312,7 +440,7 @@ function normalizeCriteria(criteria, evidence) {
 export function resolveEffectiveAcceptance(input) {
   const explicit = normalizeAcceptanceInput(input.explicit);
   const explicitLevel = normalizeLevel(explicit.level);
-  if (isAgentContractV1(input.agentContract)) {
+  if (isAgentContract(input.agentContract)) {
     const level = explicitAcceptanceCanDisable(explicit) || explicitLevel === "auto" ? "none" : explicitLevel;
     const evidence = unique(explicit.evidence ?? []);
     const criteria = normalizeCriteria(explicit.criteria, evidence);
@@ -322,6 +450,7 @@ export function resolveEffectiveAcceptance(input) {
       inferredReason: [],
       criteria,
       evidence,
+      preserveStagedIndex: explicit.preserveStagedIndex,
       verify: explicit.verify ?? [],
       review: explicit.review,
       stopRules: explicit.stopRules ?? [],
@@ -329,16 +458,18 @@ export function resolveEffectiveAcceptance(input) {
     };
   }
   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 inferredLevel = inferred.level === "none" && explicitAcceptanceRequestsPolicy(explicit) ? "attested" : inferred.level;
+  const level = explicitAcceptanceCanDisable(explicit) ? "none" : explicitLevel === "auto" ? inferredLevel : LEVEL_RANK[explicitLevel] >= LEVEL_RANK[inferredLevel] ? explicitLevel : inferredLevel;
+  const evidence = unique([...level === inferredLevel ? inferred.evidence : requiredEvidenceForLevel(level), ...explicit.evidence ?? []]);
   const criteria = normalizeCriteria(explicit.criteria?.length ? explicit.criteria : inferred.criteria, evidence);
   const review = explicit.review !== undefined ? explicit.review : inferred.review;
   return {
     level,
     explicit: input.explicit !== undefined,
     inferredReason: inferred.reasons,
-    criteria,
-    evidence,
+    criteria: level === "none" ? [] : criteria,
+    evidence: level === "none" ? [] : evidence,
+    preserveStagedIndex: explicit.preserveStagedIndex,
     verify: explicit.verify ?? [],
     review,
     stopRules: explicit.stopRules ?? [],
@@ -348,6 +479,10 @@ export function resolveEffectiveAcceptance(input) {
 function acceptanceRequiresChildReport(acceptance) {
   return acceptance.criteria.length > 0 || acceptance.evidence.length > 0;
 }
+export function formatReviewGateLabel(review) {
+  const status = review.required === false ? "optional" : "required";
+  return review.agent ? `${status} by ${review.agent}` : status;
+}
 export function formatAcceptancePrompt(acceptance, options = {}) {
   if (acceptance.level === "none")
     return "";
@@ -364,13 +499,16 @@ export function formatAcceptancePrompt(acceptance, options = {}) {
     "",
     `Required evidence: ${acceptance.evidence.join(", ") || "none"}`
   ];
+  if (acceptance.preserveStagedIndex) {
+    lines.push("The host will verify that the staged index is unchanged from launch; report noStagedFiles truthfully even when the preserved index is non-empty.");
+  }
   if (acceptance.verify.length > 0) {
     lines.push("", "Runtime verification commands configured by parent:");
     for (const command of acceptance.verify)
       lines.push(`- ${command.id}: ${command.command}`);
   }
   if (acceptance.review) {
-    lines.push("", `Review gate: ${acceptance.review.required === false ? "optional" : "required"}${acceptance.review.agent ? ` by ${acceptance.review.agent}` : ""}.`);
+    lines.push("", `Review gate: ${formatReviewGateLabel(acceptance.review)}.`);
     if (acceptance.review.focus)
       lines.push(`Review focus: ${acceptance.review.focus}`);
   }
@@ -749,7 +887,7 @@ function validateStringArrayField(errors, value, pathLabel) {
       pushTypeError(errors, `${pathLabel}[${index}]`, "non-empty string", item);
   }
 }
-function validateAcceptanceReport(value, pathLabel = "") {
+export function validateAcceptanceReport(value, pathLabel = "") {
   const normalized = normalizeAcceptanceReportValue(value, pathLabel);
   value = normalized.value;
   pathLabel = normalized.pathLabel;
@@ -875,9 +1013,28 @@ function checkNoStagedFiles(cwd) {
   const staged = result.stdout.split(/\r?\n/).filter((line) => line.length >= 2 && line[0] !== " " && line[0] !== "?");
   return staged.length === 0 ? { id: "no-staged-files", status: "passed", message: "No staged files detected." } : { id: "no-staged-files", status: "failed", message: `Staged files present: ${staged.join(", ")}` };
 }
+export function captureStagedIndexBaseline(cwd) {
+  const result = spawnSync("git", ["write-tree"], { cwd, encoding: "utf-8", windowsHide: true });
+  const oid = result.stdout.trim();
+  if (result.status !== 0 || !oid) {
+    const detail = result.stderr.trim();
+    throw new Error(`Unable to capture staged index baseline${detail ? `: ${detail}` : "."}`);
+  }
+  return oid;
+}
+function checkStagedIndexUnchanged(cwd, baseline) {
+  try {
+    const terminal = captureStagedIndexBaseline(cwd);
+    return terminal === baseline ? { id: "staged-index-unchanged", status: "passed", message: "Staged index matches the launch baseline." } : { id: "staged-index-unchanged", status: "failed", message: "Staged index changed after launch." };
+  } catch (error) {
+    return { id: "staged-index-unchanged", status: "failed", message: error instanceof Error ? error.message : String(error) };
+  }
+}
 function runStructuralChecks(acceptance, report, cwd) {
   const checks = [];
   for (const kind of acceptance.evidence) {
+    if (kind === "no-staged-files" && acceptance.preserveStagedIndex)
+      continue;
     if (kind === "no-staged-files" && report.noStagedFiles === undefined)
       continue;
     const status = reportEvidenceStatus(report, kind);
@@ -887,7 +1044,7 @@ function runStructuralChecks(acceptance, report, cwd) {
       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"))
+  if (!acceptance.preserveStagedIndex && acceptance.evidence.includes("no-staged-files"))
     checks.push(checkNoStagedFiles(cwd));
   return checks;
 }
@@ -975,6 +1132,36 @@ function isCachedVerifyResult(value) {
   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";
 }
+const TYPED_VERIFY_OUTPUT_MAX_BYTES = 12000;
+async function applyTypedVerifyOutput(command, run) {
+  if (run.status !== "passed")
+    return;
+  const stdout = run.stdout ?? "";
+  const fail = (message) => {
+    run.status = "failed";
+    run.structuredOutputError = message;
+  };
+  if (!stdout.trim())
+    return fail('output: "json" command printed nothing on stdout.');
+  if (stdout.endsWith("...[truncated]"))
+    return fail(`output: "json" stdout exceeded ${TYPED_VERIFY_OUTPUT_MAX_BYTES} characters and was truncated.`);
+  let value;
+  try {
+    value = JSON.parse(stdout);
+  } catch (error) {
+    return fail(`output: "json" stdout is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (command.schema) {
+    const validation = await validateStructuredOutputValue(command.schema, value);
+    if (validation.status === "invalid")
+      return fail(`output: "json" stdout does not match gate.schema: ${validation.message}`);
+  }
+  run.structuredOutput = value;
+}
+export function typedVerifyOutput(ledger) {
+  const run = ledger?.verifyRuns?.find((entry) => entry.structuredOutput !== undefined);
+  return run ? { value: run.structuredOutput } : undefined;
+}
 async function runMemoizedVerifyCommand(command, defaultCwd, options = {}) {
   const cwd = command.cwd ? path.resolve(defaultCwd, command.cwd) : defaultCwd;
   let workspaceState;
@@ -983,7 +1170,7 @@ async function runMemoizedVerifyCommand(command, defaultCwd, options = {}) {
   } catch {
     workspaceState = undefined;
   }
-  if (!workspaceState || !options.artifactsDir || !options.runId) {
+  if (!workspaceState || !options.artifactsDir || !options.runId || command.output === "json") {
     return runVerifyCommand(command, defaultCwd, options);
   }
   const envKeys = Object.keys(command.env ?? {}).sort();
@@ -1154,7 +1341,11 @@ export async function evaluateAcceptance(input) {
   };
   if (acceptance.level === "none")
     return ledger;
-  const parsed = input.reportError ? { error: input.reportError } : input.report ? (() => {
+  if (input.watchdog) {
+    const unresolved = unresolvedChildWatchdogBlockers(input.watchdog);
+    ledger.runtimeChecks.push(unresolved.length ? { id: "watchdog-blocker", status: "failed", message: "Unresolved watchdog blocker (details are available in child watchdog status)." } : { id: "watchdog-blocker", status: "passed", message: "No unresolved watchdog blockers." });
+  }
+  const parsed = input.reportError ? { error: input.reportError } : input.report !== undefined ? (() => {
     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);
@@ -1203,30 +1394,34 @@ export async function evaluateAcceptance(input) {
       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 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;
-    }
-    if (!ledger.runtimeChecks.some((check) => check.status === "failed")) {
-      ledger.status = "verified";
-      ledger.evidenceStatus = "verified";
+    } else {
+      ledger.verifyRuns = [];
+      for (const command of acceptance.verify) {
+        const run = await runMemoizedVerifyCommand(command, input.cwd, {
+          signal: input.signal,
+          abortMessage: input.abortMessage,
+          artifactsDir: input.artifactsDir,
+          runId: input.runId
+        });
+        if (command.output === "json")
+          await applyTypedVerifyOutput(command, run);
+        ledger.verifyRuns.push(run);
+        if (input.signal?.aborted)
+          break;
+      }
+      if (ledger.verifyRuns.some((run) => run.status === "failed" || run.status === "timed-out")) {
+        ledger.status = "rejected";
+        ledger.evidenceStatus = "rejected";
+      } else if (!ledger.runtimeChecks.some((check) => check.status === "failed")) {
+        ledger.status = "verified";
+        ledger.evidenceStatus = "verified";
+      }
     }
   }
-  if (ledger.runtimeChecks.some((check) => check.status === "failed")) {
+  if (acceptance.preserveStagedIndex) {
+    ledger.runtimeChecks.push(input.stagedIndexBaseline ? checkStagedIndexUnchanged(input.cwd, input.stagedIndexBaseline) : { id: "staged-index-unchanged", status: "failed", message: "Staged index launch baseline is unavailable." });
+  }
+  if (ledger.status === "rejected" || ledger.runtimeChecks.some((check) => check.status === "failed")) {
     ledger.status = "rejected";
     ledger.evidenceStatus = "rejected";
     return ledger;
@@ -1276,6 +1471,8 @@ export function acceptanceFailureMessage(ledger) {
   if (failedCheck)
     return `Acceptance rejected: ${failedCheck.message}`;
   const failedVerify = ledger.verifyRuns.find((run) => run.status === "failed" || run.status === "timed-out");
+  if (failedVerify?.structuredOutputError)
+    return `Acceptance verification '${failedVerify.id}' failed: ${failedVerify.structuredOutputError}`;
   if (failedVerify)
     return `Acceptance verification '${failedVerify.id}' ${failedVerify.status}.`;
   if (ledger.reviewResult?.status === "blockers")

package/extensions/dm-subagents/src/runs/shared/agent-contract.js

@@ -1,4 +1,4 @@
-export function isAgentContractV1(contract) {
+export function isAgentContract(contract) {
   return contract?.version === 1;
 }
 export function buildExecutionProjection(result) {