@duckmind/dm-windows-x64 0.60.6 → 0.60.9

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

@@ -1,3 +1,835 @@
-import{spawn as g}from"node:child_process";import{spawnSync as L}from"node:child_process";import*as E from"node:path";var _={none:0,attested:1,checked:2,verified:3,reviewed:4},F=new Set(["auto","none","attested","checked","verified","reviewed"]),S=new Set(["changed-files","tests-added","commands-run","validation-output","residual-risks","no-staged-files","diff-summary","review-findings","manual-notes"]),b=new Set(["level","criteria","evidence","verify","review","stopRules","reason"]),v=new Set(["id","must","evidence","severity"]),h=new Set(["id","command","timeoutMs","cwd","env","allowFailure"]),m=new Set(["agent","focus","required"]);function s(D){return D??"auto"}function w(D){return[...new Set(D)]}function R(D){switch(D){case"none":return[];case"attested":return["manual-notes","residual-risks"];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"]}}function d(D){let H=D.agentName.toLowerCase(),J=D.task?.toLowerCase()??"",M=[],Q=/\b(?:reviewer|scout|context-builder|researcher|analyst)\b/.test(H),X=/\b(?:read[- ]only|review[- ]only|do not edit|don't edit|no edits|without edits|inspect|summari[sz]e)\b/.test(J),U=/\b(?:fix|implement|update|write|edit|modify|migrate|release|security|delete|remove|refactor|commit)\b/.test(J)||/\bworker\b/.test(H);if(Boolean(D.async&&U)||Boolean(D.dynamic)||Boolean(D.dynamicGroup)||/\b(?:release|migration|migrate|security|data[- ]loss|destructive|post-review|fix pass)\b/.test(J)){if(M.push(D.async?"async write-capable or risky run":"risky write-capable run"),D.dynamic||D.dynamicGroup)M.push("dynamic fanout context");return{level:"reviewed",reasons:M,criteria:["Implement the requested change without widening scope","Return evidence sufficient for an independent acceptance review"],evidence:R("reviewed"),review:{agent:"reviewer",required:!0}}}if(U&&!X)return M.push("write-capable worker/task"),{level:"checked",reasons:M,criteria:["Implement the requested change without widening scope"],evidence:R("checked")};if(Q||X)return M.push(Q?"read-only/reviewer-style agent":"read-only task wording"),{level:"attested",reasons:M,criteria:["Return concrete findings with file paths and severity when applicable"],evidence:["review-findings","residual-risks"]};return M.push("default lightweight attestation"),{level:"attested",reasons:M,criteria:["Return a concise result and residual risks when applicable"],evidence:["manual-notes","residual-risks"]}}function u(D){if(D===void 0||D==="auto")return{level:"auto"};if(D===!1)return{level:"none",reason:"disabled by deprecated false shorthand"};if(typeof D==="string")return{level:D};return{...D}}function l(D){return D.level==="none"&&typeof D.reason==="string"&&D.reason.trim().length>0}function UD(D,H="acceptance"){let J=[];if(D===void 0)return J;if(D===!1)return J;if(typeof D==="string"){if(!F.has(D))J.push(`${H} has invalid level '${D}'.`);return J}if(!D||typeof D!=="object"||Array.isArray(D))return J.push(`${H} must be a string level, false, or an object.`),J;let M=D;for(let Q of Object.keys(M))if(!b.has(Q))J.push(`${H}.${Q} is not supported.`);if(M.level!==void 0&&(typeof M.level!=="string"||!F.has(M.level)))J.push(`${H}.level must be one of auto, none, attested, checked, verified, reviewed.`);if(M.level==="none"&&(typeof M.reason!=="string"||!M.reason.trim()))J.push(`${H}.reason is required when level is none.`);if(M.reason!==void 0&&typeof M.reason!=="string")J.push(`${H}.reason must be a string.`);if(M.criteria!==void 0&&!Array.isArray(M.criteria))J.push(`${H}.criteria must be an array.`);if(Array.isArray(M.criteria))for(let[Q,X]of M.criteria.entries()){if(typeof X==="string")continue;let U=`${H}.criteria[${Q}]`;if(!X||typeof X!=="object"||Array.isArray(X)){J.push(`${U} must be a string or an object.`);continue}let Z=X;for(let $ of Object.keys(Z))if(!v.has($))J.push(`${U}.${$} is not supported.`);if(typeof Z.id!=="string"||!Z.id.trim())J.push(`${U}.id is required.`);if(typeof Z.must!=="string"||!Z.must.trim())J.push(`${U}.must is required.`);if(Z.evidence!==void 0&&!Array.isArray(Z.evidence))J.push(`${U}.evidence must be an array.`);if(Array.isArray(Z.evidence)){for(let[$,z]of Z.evidence.entries())if(typeof z!=="string"||!S.has(z))J.push(`${U}.evidence[${$}] is not a supported evidence kind.`)}if(Z.severity!==void 0&&Z.severity!=="required"&&Z.severity!=="recommended")J.push(`${U}.severity must be required or recommended.`)}if(Array.isArray(M.evidence)){for(let[Q,X]of M.evidence.entries())if(typeof X!=="string"||!S.has(X))J.push(`${H}.evidence[${Q}] is not a supported evidence kind.`)}else if(M.evidence!==void 0)J.push(`${H}.evidence must be an array.`);if(M.verify!==void 0&&!Array.isArray(M.verify))J.push(`${H}.verify must be an array.`);if(Array.isArray(M.verify))for(let[Q,X]of M.verify.entries()){if(!X||typeof X!=="object"||Array.isArray(X)){J.push(`${H}.verify[${Q}] must be an object.`);continue}let U=X;for(let Z of Object.keys(U))if(!h.has(Z))J.push(`${H}.verify[${Q}].${Z} is not supported.`);if(typeof U.id!=="string"||!U.id.trim())J.push(`${H}.verify[${Q}].id is required.`);if(typeof U.command!=="string"||!U.command.trim())J.push(`${H}.verify[${Q}].command is required.`);if(U.timeoutMs!==void 0&&(typeof U.timeoutMs!=="number"||!Number.isInteger(U.timeoutMs)||U.timeoutMs<1))J.push(`${H}.verify[${Q}].timeoutMs must be an integer >= 1.`);if(U.cwd!==void 0&&typeof U.cwd!=="string")J.push(`${H}.verify[${Q}].cwd must be a string.`);if(U.env!==void 0){if(!U.env||typeof U.env!=="object"||Array.isArray(U.env))J.push(`${H}.verify[${Q}].env must be an object.`);else for(let[Z,$]of Object.entries(U.env))if(typeof $!=="string")J.push(`${H}.verify[${Q}].env.${Z} must be a string.`)}if(U.allowFailure!==void 0&&typeof U.allowFailure!=="boolean")J.push(`${H}.verify[${Q}].allowFailure must be a boolean.`)}if(M.review!==void 0&&M.review!==!1)if(!M.review||typeof M.review!=="object"||Array.isArray(M.review))J.push(`${H}.review must be false or an object.`);else{let Q=M.review;for(let X of Object.keys(Q))if(!m.has(X))J.push(`${H}.review.${X} is not supported.`);if(Q.agent!==void 0&&typeof Q.agent!=="string")J.push(`${H}.review.agent must be a string.`);if(Q.focus!==void 0&&typeof Q.focus!=="string")J.push(`${H}.review.focus must be a string.`);if(Q.required!==void 0&&typeof Q.required!=="boolean")J.push(`${H}.review.required must be a boolean.`)}if(M.stopRules!==void 0&&!Array.isArray(M.stopRules))J.push(`${H}.stopRules must be an array.`);if(Array.isArray(M.stopRules)){for(let[Q,X]of M.stopRules.entries())if(typeof X!=="string")J.push(`${H}.stopRules[${Q}] must be a string.`)}return J}function n(D,H){return(D??[]).map((J,M)=>{if(typeof J==="string")return{id:`criterion-${M+1}`,must:J,evidence:H,severity:"required"};return{id:J.id?.trim()||`criterion-${M+1}`,must:J.must??"",evidence:J.evidence?.filter((Q)=>S.has(Q))??H,severity:J.severity??"required"}}).filter((J)=>J.must.trim())}function XD(D){let H=u(D.explicit),J=d(D),M=s(H.level),Q=l(H)?"none":M==="auto"?J.level:_[M]>=_[J.level]?M:J.level,X=w([...Q===J.level?J.evidence:R(Q),...H.evidence??[]]),U=n(H.criteria?.length?H.criteria:J.criteria,X),Z=H.review!==void 0?H.review:J.review;if(Q==="reviewed"&&M!=="auto"&&M!=="reviewed"&&H.review===void 0&&Z&&Z!==!1)Z={...Z,required:!1};return{level:Q,explicit:D.explicit!==void 0,inferredReason:J.reasons,criteria:U,evidence:X,verify:H.verify??[],review:Z,stopRules:H.stopRules??[],reason:H.reason}}function ZD(D){if(D.level==="none")return"";let H=["","## Acceptance Contract",`Acceptance level: ${D.level}`,"Completion is not accepted from prose alone. End with a structured acceptance report.","","Criteria:",...D.criteria.length?D.criteria.map((J)=>`- ${J.id}: ${J.must}`):["- Return the requested result."],"",`Required evidence: ${D.evidence.join(", ")||"none"}`];if(D.verify.length>0){H.push("","Runtime verification commands configured by parent:");for(let J of D.verify)H.push(`- ${J.id}: ${J.command}`)}if(D.review&&D.review!==!1){if(H.push("",`Review gate: ${D.review.required===!1?"optional":"required"}${D.review.agent?` by ${D.review.agent}`:""}.`),D.review.focus)H.push(`Review focus: ${D.review.focus}`)}if(D.stopRules.length>0)H.push("","Stop rules:",...D.stopRules.map((J)=>`- ${J}`));return H.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"}],changedFiles:["src/file.ts"],testsAddedOrUpdated:["test/file.test.ts"],commandsRun:[{command:"command",result:"passed",summary:"short result"}],validationOutput:["validation output or concise summary"],residualRisks:["none"],noStagedFiles:!0,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),"```"),H.join(`
-`)}function f(D,H){let J=0,M=!1,Q=!1;for(let X=H;X<D.length;X++){let U=D[X];if(M){if(Q)Q=!1;else if(U==="\\")Q=!0;else if(U==='"')M=!1;continue}if(U==='"'){M=!0;continue}if(U==="{")J++;if(U==="}"){if(J--,J===0)return D.slice(H,X+1)}}return}function O(D){if(!D||typeof D!=="object"||Array.isArray(D))return D;let H=D;if("acceptance"in H)return H.acceptance;if("acceptance-report"in H)return H["acceptance-report"];return D}function c(D){return Array.isArray(D)&&D.every((H)=>{if(!H||typeof H!=="object"||Array.isArray(H))return!1;let J=H;return typeof J.command==="string"&&(J.result==="passed"||J.result==="failed"||J.result==="not-run")&&typeof J.summary==="string"})}function o(D){if(!D||typeof D!=="object"||Array.isArray(D))return!1;let H=D;return"criteriaSatisfied"in H&&(Y(H.changedFiles)||Y(H.testsAddedOrUpdated)||c(H.commandsRun)||Y(H.validationOutput)||Y(H.residualRisks)||typeof H.noStagedFiles==="boolean"||typeof H.diffSummary==="string"||Y(H.reviewFindings)||typeof H.manualNotes==="string")}function k(D){let H=D.trim();try{return JSON.parse(H)}catch(J){let M=H.indexOf("{");if(M>0){let Q=f(H,M);if(Q)return JSON.parse(Q)}throw J}}function T(D,H){return[...D.matchAll(new RegExp(`\`\`\`${H}\\s*\\n([\\s\\S]*?)\`\`\``,"gi"))].map((J)=>J[1]?.trim()).filter((J)=>Boolean(J))}function y(D){if(!D||typeof D!=="object"||Array.isArray(D))return"";let H=D;if("acceptance"in H)return"acceptance";if("acceptance-report"in H)return"acceptance-report";return""}function p(D){let H=k(D),J=O(H);return C(J,y(H))}function x(D){let H=k(D),J=O(H),M=C(J);if(!M.report)return;return o(M.report)?M.report:void 0}function i(D){let H=T(D,"acceptance-report"),J=[];for(let Q of H)try{let X=p(Q);if(X.report)return{report:X.report};J.push(`Invalid acceptance-report: ${X.errors.join("; ")}`)}catch(X){J.push(X instanceof Error?X.message:String(X))}if(J.length>0)return{error:`Failed to parse acceptance-report: ${J.join("; ")}`};for(let Q of T(D,"(?:json|jsonc|json5)"))try{let X=x(Q);if(X)return{report:X}}catch{}let M=D.search(/ACCEPTANCE_REPORT\s*:/i);if(M!==-1){let Q=D.indexOf("{",M);if(Q!==-1){let X=f(D,Q);if(X)try{let U=JSON.parse(X),Z=O(U),$=C(Z,y(U));if($.report)return{report:$.report};return{error:`Failed to parse acceptance-report: Invalid acceptance-report: ${$.errors.join("; ")}`}}catch(U){return{error:U instanceof Error?U.message:String(U)}}}}return{error:"Structured acceptance report not found."}}function $D(D){let H=/\n?```(acceptance-report|json|jsonc|json5)\s*\n([\s\S]*?)```\s*/gi,J;for(let M of D.matchAll(H)){let Q=(M.index??0)+M[0].length;if(D.slice(Q).trim().length===0&&M[1]&&M[2])J={index:M.index??0,tag:M[1].toLowerCase(),body:M[2]}}if(J){if(J.tag==="acceptance-report")return D.slice(0,J.index).trimEnd();try{if(x(J.body))return D.slice(0,J.index).trimEnd()}catch{}}return D.replace(/\n?```acceptance-report\s*\n[\s\S]*?```\s*$/i,"").replace(/\n?ACCEPTANCE_REPORT\s*:\s*\{[\s\S]*\}\s*$/i,"").trimEnd()}function Y(D){return Array.isArray(D)&&D.every((H)=>typeof H==="string")}function N(D,H){return D?`${D}.${H}`:H}function a(D){if(D===void 0)return"missing";if(D===null)return"null";if(Array.isArray(D))return"array";if(typeof D==="object")return"object";if(typeof D==="string"){let H=D.length>80?`${D.slice(0,77)}...`:D;return JSON.stringify(H)}return`${typeof D} ${String(D)}`}function G(D,H,J,M){D.push(`${H}: expected ${J}; got ${a(M)}`)}function I(D,H,J){if(!Array.isArray(H)){G(D,J,"string[]",H);return}for(let[M,Q]of H.entries())if(typeof Q!=="string")G(D,`${J}[${M}]`,"string",Q)}function C(D,H=""){let J=[];if(!D||typeof D!=="object"||Array.isArray(D))return G(J,H||"acceptance-report","object",D),{errors:J};let M=D;if(M.criteriaSatisfied!==void 0)if(!Array.isArray(M.criteriaSatisfied))G(J,N(H,"criteriaSatisfied"),"array",M.criteriaSatisfied);else for(let[X,U]of M.criteriaSatisfied.entries()){let Z=`${N(H,"criteriaSatisfied")}[${X}]`;if(!U||typeof U!=="object"||Array.isArray(U)){G(J,Z,"object",U);continue}let $=U;if($.id!==void 0&&typeof $.id!=="string")G(J,`${Z}.id`,"string",$.id);if($.status!=="satisfied"&&$.status!=="not-satisfied"&&$.status!=="not-applicable")G(J,`${Z}.status`,'one of "satisfied", "not-satisfied", "not-applicable"',$.status);if(typeof $.evidence!=="string"||!$.evidence.trim())G(J,`${Z}.evidence`,"non-empty string",$.evidence)}if(M.changedFiles!==void 0)I(J,M.changedFiles,N(H,"changedFiles"));if(M.testsAddedOrUpdated!==void 0)I(J,M.testsAddedOrUpdated,N(H,"testsAddedOrUpdated"));if(M.commandsRun!==void 0)if(!Array.isArray(M.commandsRun))G(J,N(H,"commandsRun"),"array",M.commandsRun);else for(let[X,U]of M.commandsRun.entries()){let Z=`${N(H,"commandsRun")}[${X}]`;if(!U||typeof U!=="object"||Array.isArray(U)){G(J,Z,"object",U);continue}let $=U;if(typeof $.command!=="string"||!$.command.trim())G(J,`${Z}.command`,"non-empty string",$.command);if($.result!=="passed"&&$.result!=="failed"&&$.result!=="not-run")G(J,`${Z}.result`,'one of "passed", "failed", "not-run"',$.result);if(typeof $.summary!=="string")G(J,`${Z}.summary`,"string",$.summary)}if(M.validationOutput!==void 0)I(J,M.validationOutput,N(H,"validationOutput"));if(M.residualRisks!==void 0)I(J,M.residualRisks,N(H,"residualRisks"));if(M.noStagedFiles!==void 0&&typeof M.noStagedFiles!=="boolean")G(J,N(H,"noStagedFiles"),"boolean",M.noStagedFiles);if(M.diffSummary!==void 0&&typeof M.diffSummary!=="string")G(J,N(H,"diffSummary"),"string",M.diffSummary);if(M.reviewFindings!==void 0)I(J,M.reviewFindings,N(H,"reviewFindings"));if(M.manualNotes!==void 0&&typeof M.manualNotes!=="string")G(J,N(H,"manualNotes"),"string",M.manualNotes);if(M.notes!==void 0&&typeof M.notes!=="string")G(J,N(H,"notes"),"string",M.notes);if(J.length>0)return{errors:J};return M.criteriaSatisfied!==void 0||M.changedFiles!==void 0||M.testsAddedOrUpdated!==void 0||M.commandsRun!==void 0||M.validationOutput!==void 0||M.residualRisks!==void 0||M.noStagedFiles!==void 0||M.diffSummary!==void 0||M.manualNotes!==void 0||M.notes!==void 0||M.reviewFindings!==void 0?{report:M,errors:J}:{errors:[`${H||"acceptance-report"}: expected at least one acceptance report field`]}}function t(D,H){let J=new Map((H.criteriaSatisfied??[]).filter((M)=>M.id).map((M)=>[M.id,M]));return D.filter((M)=>M.severity!=="recommended").map((M)=>{let Q=J.get(M.id);if(!Q)return{id:`criterion:${M.id}`,status:"failed",message:`Required criterion '${M.id}' was not reported.`};if(Q.status!=="satisfied")return{id:`criterion:${M.id}`,status:"failed",message:`Required criterion '${M.id}' was reported as ${Q.status}.`};return{id:`criterion:${M.id}`,status:"passed",message:`Required criterion '${M.id}' satisfied.`}})}function r(D,H){switch(H){case"changed-files":return Y(D.changedFiles)&&D.changedFiles.length>0;case"tests-added":return Y(D.testsAddedOrUpdated)&&D.testsAddedOrUpdated.length>0;case"commands-run":return Array.isArray(D.commandsRun)&&D.commandsRun.length>0;case"validation-output":return Y(D.validationOutput)&&D.validationOutput.length>0;case"residual-risks":return Y(D.residualRisks);case"no-staged-files":return D.noStagedFiles===!0;case"diff-summary":return typeof D.diffSummary==="string"&&D.diffSummary.trim().length>0;case"review-findings":return Y(D.reviewFindings);case"manual-notes":return Boolean((D.manualNotes??D.notes)?.trim())}}function e(D){let H=L("git",["status","--short"],{cwd:D,encoding:"utf-8"});if(H.status!==0)return{id:"no-staged-files",status:"not-applicable",message:"git status unavailable; no staged-files check skipped"};let J=H.stdout.split(/\r?\n/).filter((M)=>M.length>=2&&M[0]!==" "&&M[0]!=="?");return J.length===0?{id:"no-staged-files",status:"passed",message:"No staged files detected."}:{id:"no-staged-files",status:"failed",message:`Staged files present: ${J.join(", ")}`}}function DD(D,H,J){let M=[];for(let Q of D.evidence){let X=r(H,Q);M.push({id:`evidence:${Q}`,status:X?"passed":"failed",message:X?`${Q} evidence present.`:`${Q} evidence missing from child report.`})}if(D.evidence.includes("no-staged-files"))M.push(e(J));return M}function K(D){let H=D.trim();if(!H)return;return H.length>12000?`${H.slice(0,12000)}
-...[truncated]`:H}function q(D){return w(D.map((H)=>H?.trim()).filter((H)=>Boolean(H)))}function GD(D){let H=D.results.map((Q)=>Q.acceptance?.childReport).filter((Q)=>Boolean(Q)),J=D.results.filter((Q)=>Q.exitCode!==0||Q.acceptance?.status==="rejected"),M=D.results.length>0&&J.length===0;return{criteriaSatisfied:[{id:"criterion-1",status:M?"satisfied":"not-satisfied",evidence:M?`All ${D.results.length} dynamic child run(s) completed without child or acceptance blockers.`:"Dynamic fanout produced no accepted child evidence."},{id:"criterion-2",status:M?"satisfied":"not-satisfied",evidence:M?"Collected child acceptance evidence for aggregate review.":"Dynamic fanout produced no aggregate review evidence."},...D.results.map((Q,X)=>({id:`child-${X+1}`,status:Q.exitCode===0&&Q.acceptance?.status!=="rejected"?"satisfied":"not-satisfied",evidence:`${Q.agent}: acceptance ${Q.acceptance?.status??"unreported"}${Q.error?` (${Q.error})`:""}`}))],changedFiles:q(H.flatMap((Q)=>Q.changedFiles??[])),testsAddedOrUpdated:q(H.flatMap((Q)=>Q.testsAddedOrUpdated??[])),commandsRun:H.flatMap((Q)=>Q.commandsRun??[]),validationOutput:q(H.flatMap((Q)=>Q.validationOutput??[])),residualRisks:q([...H.flatMap((Q)=>Q.residualRisks??[]),...J.map((Q)=>`${Q.agent}: ${Q.error??"child or acceptance gate failed"}`)]),noStagedFiles:H.length>0&&H.every((Q)=>Q.noStagedFiles===!0),reviewFindings:q(H.flatMap((Q)=>Q.reviewFindings??[])),manualNotes:D.notes??`Aggregated acceptance evidence from ${D.results.length} dynamic fanout child run(s).`,notes:D.notes}}function HD(D,H,J={}){return new Promise((M)=>{let Q=Date.now(),X=D.cwd?E.resolve(H,D.cwd):H,U="",Z="",$=!1,z=!1,j,B=g(D.command,{cwd:X,env:{...process.env,...D.env??{}},shell:!0,stdio:["ignore","pipe","pipe"],windowsHide:!0}),V=(W)=>{if(z)return;if(z=!0,clearTimeout(P),j)clearTimeout(j);J.signal?.removeEventListener("abort",A),M({id:D.id,command:D.command,cwd:X,durationMs:Date.now()-Q,...W})},A=()=>{if(z||$)return;$=!0,B.kill("SIGTERM"),j=setTimeout(()=>{B.kill("SIGKILL"),V({exitCode:null,status:"timed-out",stdout:K(U),stderr:K(Z||J.abortMessage||"Acceptance verification timed out.")})},1000),j.unref?.()},P=setTimeout(A,D.timeoutMs??120000);if(P.unref?.(),J.signal?.aborted)A();else J.signal?.addEventListener("abort",A,{once:!0});B.stdout.on("data",(W)=>{U+=W.toString()}),B.stderr.on("data",(W)=>{Z+=W.toString()}),B.on("close",(W)=>{V({exitCode:W,status:$?"timed-out":W===0&&!$?"passed":D.allowFailure?"allowed-failure":"failed",stdout:K(U),stderr:K(Z||($?J.abortMessage??"":""))})}),B.on("error",(W)=>{V({exitCode:$?null:1,status:$?"timed-out":D.allowFailure?"allowed-failure":"failed",stderr:$?K(Z||J.abortMessage||"Acceptance verification timed out."):W instanceof Error?W.message:String(W)})})})}async function ND(D){let H=D.acceptance,J={status:H.level==="none"?"not-required":"claimed",explicit:H.explicit,effectiveAcceptance:H,inferredReason:H.inferredReason,criteria:H.criteria,runtimeChecks:[],verifyRuns:[]};if(H.level==="none")return J;let M=D.report?{report:D.report}:i(D.output);if(M.report)J.childReport=M.report,J.status="attested";else return J.childReportParseError=M.error,J.runtimeChecks.push({id:"attestation",status:"failed",message:M.error??"Structured acceptance report missing."}),J.status="rejected",J;if(_[H.level]>=_.checked){if(J.runtimeChecks=[...t(H.criteria,M.report),...DD(H,M.report,D.cwd)],J.runtimeChecks.some((Q)=>Q.status==="failed"))return J.status="rejected",J;J.status="checked"}if(_[H.level]>=_.verified&&(H.level==="verified"||H.verify.length>0)){if(H.level==="verified"&&H.verify.length===0)return J.runtimeChecks.push({id:"verification-config",status:"failed",message:"verified acceptance requires runtime verify commands."}),J.status="rejected",J;J.verifyRuns=[];for(let Q of H.verify)if(J.verifyRuns.push(await HD(Q,D.cwd,{signal:D.signal,abortMessage:D.abortMessage})),D.signal?.aborted)break;if(J.verifyRuns.some((Q)=>Q.status==="failed"||Q.status==="timed-out"))return J.status="rejected",J;J.status="verified"}if(H.level==="reviewed")if(D.reviewResult)J.reviewResult=D.reviewResult,J.status=D.reviewResult.status==="no-blockers"?"reviewed":"rejected";else{let Q=H.review&&H.review!==!1&&H.review.required===!1;if(J.reviewResult={status:"needs-parent-decision",findings:[{severity:H.explicit&&!Q?"blocker":"non-blocking",issue:"Reviewed acceptance requires an independent reviewer result.",rationale:"The run cannot be marked reviewed from child evidence alone."}]},H.review===!1||H.explicit&&!Q)J.status="rejected"}return J}function WD(D){if(D.status!=="rejected")return;let H=D.runtimeChecks.find((M)=>M.status==="failed");if(H)return`Acceptance rejected: ${H.message}`;let J=D.verifyRuns.find((M)=>M.status==="failed"||M.status==="timed-out");if(J)return`Acceptance verification '${J.id}' ${J.status}.`;if(D.reviewResult?.status==="needs-parent-decision")return"Acceptance review required but no automatic reviewer result is available.";if(D.reviewResult?.status==="blockers")return"Acceptance review found blockers.";return"Acceptance rejected."}export{UD as validateAcceptanceInput,$D as stripAcceptanceReport,XD as resolveEffectiveAcceptance,i as parseAcceptanceReport,u as normalizeAcceptanceInput,ZD as formatAcceptancePrompt,ND as evaluateAcceptance,GD as aggregateAcceptanceReport,WD as acceptanceFailureMessage};
+import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
+import * as path from "node:path";
+const LEVEL_RANK = {
+  none: 0,
+  attested: 1,
+  checked: 2,
+  verified: 3,
+  reviewed: 4
+};
+const VALID_LEVELS = new Set(["auto", "none", "attested", "checked", "verified", "reviewed"]);
+const VALID_EVIDENCE = new Set([
+  "changed-files",
+  "tests-added",
+  "commands-run",
+  "validation-output",
+  "residual-risks",
+  "no-staged-files",
+  "diff-summary",
+  "review-findings",
+  "manual-notes"
+]);
+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"]);
+function normalizeLevel(level) {
+  return level ?? "auto";
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+function requiredEvidenceForLevel(level) {
+  switch (level) {
+    case "none":
+      return [];
+    case "attested":
+      return ["manual-notes", "residual-risks"];
+    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"];
+  }
+}
+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);
+  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",
+      reasons,
+      criteria: ["Implement the requested change without widening scope", "Return evidence sufficient for an independent acceptance review"],
+      evidence: requiredEvidenceForLevel("reviewed"),
+      review: { agent: "reviewer", required: true }
+    };
+  }
+  if (writeTask && !readOnlyTask) {
+    reasons.push("write-capable worker/task");
+    return {
+      level: "checked",
+      reasons,
+      criteria: ["Implement the requested change without widening scope"],
+      evidence: requiredEvidenceForLevel("checked")
+    };
+  }
+  if (readOnlyAgent || readOnlyTask) {
+    reasons.push(readOnlyAgent ? "read-only/reviewer-style agent" : "read-only task wording");
+    return {
+      level: "attested",
+      reasons,
+      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,
+    criteria: ["Return a concise result and residual risks when applicable"],
+    evidence: ["manual-notes", "residual-risks"]
+  };
+}
+export function normalizeAcceptanceInput(input) {
+  if (input === undefined || input === "auto")
+    return { level: "auto" };
+  if (input === false)
+    return { level: "none", reason: "disabled by deprecated false shorthand" };
+  if (typeof input === "string")
+    return { level: input };
+  return { ...input };
+}
+function explicitAcceptanceCanDisable(explicit) {
+  return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
+}
+export function validateAcceptanceInput(input, pathLabel = "acceptance") {
+  const errors = [];
+  if (input === undefined)
+    return errors;
+  if (input === false)
+    return errors;
+  if (typeof input === "string") {
+    if (!VALID_LEVELS.has(input))
+      errors.push(`${pathLabel} has invalid level '${input}'.`);
+    return errors;
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    errors.push(`${pathLabel} must be a string level, false, or an object.`);
+    return errors;
+  }
+  const value = input;
+  for (const key of Object.keys(value)) {
+    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 === "none" && (typeof value.reason !== "string" || !value.reason.trim())) {
+    errors.push(`${pathLabel}.reason is required when level is none.`);
+  }
+  if (value.reason !== undefined && typeof value.reason !== "string")
+    errors.push(`${pathLabel}.reason must be a string.`);
+  if (value.criteria !== undefined && !Array.isArray(value.criteria))
+    errors.push(`${pathLabel}.criteria must be an array.`);
+  if (Array.isArray(value.criteria)) {
+    for (const [index, criterion] of value.criteria.entries()) {
+      if (typeof criterion === "string")
+        continue;
+      const criterionPath = `${pathLabel}.criteria[${index}]`;
+      if (!criterion || typeof criterion !== "object" || Array.isArray(criterion)) {
+        errors.push(`${criterionPath} must be a string or an object.`);
+        continue;
+      }
+      const gate = criterion;
+      for (const key of Object.keys(gate)) {
+        if (!ACCEPTANCE_GATE_KEYS.has(key))
+          errors.push(`${criterionPath}.${key} is not supported.`);
+      }
+      if (typeof gate.id !== "string" || !gate.id.trim())
+        errors.push(`${criterionPath}.id is required.`);
+      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.`);
+      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.`);
+          }
+        }
+      }
+      if (gate.severity !== undefined && gate.severity !== "required" && gate.severity !== "recommended") {
+        errors.push(`${criterionPath}.severity must be required or recommended.`);
+      }
+    }
+  }
+  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.`);
+      }
+    }
+  } else if (value.evidence !== undefined) {
+    errors.push(`${pathLabel}.evidence must be an array.`);
+  }
+  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)) {
+        errors.push(`${pathLabel}.verify[${index}] must be an object.`);
+        continue;
+      }
+      const cmd = command;
+      for (const key of Object.keys(cmd)) {
+        if (!ACCEPTANCE_VERIFY_KEYS.has(key))
+          errors.push(`${pathLabel}.verify[${index}].${key} is not supported.`);
+      }
+      if (typeof cmd.id !== "string" || !cmd.id.trim())
+        errors.push(`${pathLabel}.verify[${index}].id is required.`);
+      if (typeof cmd.command !== "string" || !cmd.command.trim())
+        errors.push(`${pathLabel}.verify[${index}].command is required.`);
+      if (cmd.timeoutMs !== undefined && (typeof cmd.timeoutMs !== "number" || !Number.isInteger(cmd.timeoutMs) || cmd.timeoutMs < 1)) {
+        errors.push(`${pathLabel}.verify[${index}].timeoutMs must be an integer >= 1.`);
+      }
+      if (cmd.cwd !== undefined && typeof cmd.cwd !== "string")
+        errors.push(`${pathLabel}.verify[${index}].cwd must be a string.`);
+      if (cmd.env !== undefined) {
+        if (!cmd.env || typeof cmd.env !== "object" || Array.isArray(cmd.env)) {
+          errors.push(`${pathLabel}.verify[${index}].env must be an object.`);
+        } else {
+          for (const [envKey, envValue] of Object.entries(cmd.env)) {
+            if (typeof envValue !== "string")
+              errors.push(`${pathLabel}.verify[${index}].env.${envKey} must be a string.`);
+          }
+        }
+      }
+      if (cmd.allowFailure !== undefined && typeof cmd.allowFailure !== "boolean") {
+        errors.push(`${pathLabel}.verify[${index}].allowFailure must be a boolean.`);
+      }
+    }
+  }
+  if (value.review !== undefined && value.review !== false) {
+    if (!value.review || typeof value.review !== "object" || Array.isArray(value.review)) {
+      errors.push(`${pathLabel}.review must be false or an object.`);
+    } else {
+      const review = value.review;
+      for (const key of Object.keys(review)) {
+        if (!ACCEPTANCE_REVIEW_KEYS.has(key))
+          errors.push(`${pathLabel}.review.${key} is not supported.`);
+      }
+      if (review.agent !== undefined && typeof review.agent !== "string")
+        errors.push(`${pathLabel}.review.agent must be a string.`);
+      if (review.focus !== undefined && typeof review.focus !== "string")
+        errors.push(`${pathLabel}.review.focus must be a string.`);
+      if (review.required !== undefined && typeof review.required !== "boolean")
+        errors.push(`${pathLabel}.review.required must be a boolean.`);
+    }
+  }
+  if (value.stopRules !== undefined && !Array.isArray(value.stopRules))
+    errors.push(`${pathLabel}.stopRules must be an array.`);
+  if (Array.isArray(value.stopRules)) {
+    for (const [index, item] of value.stopRules.entries()) {
+      if (typeof item !== "string")
+        errors.push(`${pathLabel}.stopRules[${index}] must be a string.`);
+    }
+  }
+  return errors;
+}
+function normalizeCriteria(criteria, evidence) {
+  return (criteria ?? []).map((criterion, index) => {
+    if (typeof criterion === "string") {
+      return { id: `criterion-${index + 1}`, must: criterion, evidence, severity: "required" };
+    }
+    return {
+      id: criterion.id?.trim() || `criterion-${index + 1}`,
+      must: criterion.must ?? "",
+      evidence: criterion.evidence?.filter((item) => VALID_EVIDENCE.has(item)) ?? evidence,
+      severity: criterion.severity ?? "required"
+    };
+  }).filter((criterion) => criterion.must.trim());
+}
+export function resolveEffectiveAcceptance(input) {
+  const explicit = normalizeAcceptanceInput(input.explicit);
+  const inferred = inferLevel(input);
+  const explicitLevel = normalizeLevel(explicit.level);
+  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 };
+  }
+  return {
+    level,
+    explicit: input.explicit !== undefined,
+    inferredReason: inferred.reasons,
+    criteria,
+    evidence,
+    verify: explicit.verify ?? [],
+    review,
+    stopRules: explicit.stopRules ?? [],
+    reason: explicit.reason
+  };
+}
+export function formatAcceptancePrompt(acceptance) {
+  if (acceptance.level === "none")
+    return "";
+  const lines = [
+    "",
+    "## Acceptance Contract",
+    `Acceptance level: ${acceptance.level}`,
+    "Completion is not accepted from prose alone. End with a structured acceptance report.",
+    "",
+    "Criteria:",
+    ...acceptance.criteria.length ? acceptance.criteria.map((criterion) => `- ${criterion.id}: ${criterion.must}`) : ["- Return the requested result."],
+    "",
+    `Required evidence: ${acceptance.evidence.join(", ") || "none"}`
+  ];
+  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 && acceptance.review !== false) {
+    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}`);
+  }
+  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" }],
+    changedFiles: ["src/file.ts"],
+    testsAddedOrUpdated: ["test/file.test.ts"],
+    commandsRun: [{ command: "command", result: "passed", summary: "short result" }],
+    validationOutput: ["validation output or concise summary"],
+    residualRisks: ["none"],
+    noStagedFiles: true,
+    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), "```");
+  return lines.join(`
+`);
+}
+function extractBalancedJson(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start;i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{")
+      depth++;
+    if (char === "}") {
+      depth--;
+      if (depth === 0)
+        return text.slice(start, i + 1);
+    }
+  }
+  return;
+}
+function unwrapAcceptanceReport(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return value;
+  const record = value;
+  if ("acceptance" in record)
+    return record.acceptance;
+  if ("acceptance-report" in record)
+    return record["acceptance-report"];
+  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 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");
+}
+function parseReportJson(body) {
+  const trimmed = body.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch (error) {
+    const jsonStart = trimmed.indexOf("{");
+    if (jsonStart > 0) {
+      const json = extractBalancedJson(trimmed, jsonStart);
+      if (json)
+        return JSON.parse(json);
+    }
+    throw error;
+  }
+}
+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));
+}
+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;
+}
+export function parseAcceptanceReport(output) {
+  const fenced = fencedBlocks(output, "acceptance-report");
+  const parseErrors = [];
+  for (const body of fenced) {
+    try {
+      const validation = parseAcceptanceReportBody(body);
+      if (validation.report)
+        return { report: validation.report };
+      parseErrors.push(`Invalid acceptance-report: ${validation.errors.join("; ")}`);
+    } catch (error) {
+      parseErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (parseErrors.length > 0)
+    return { error: `Failed to parse acceptance-report: ${parseErrors.join("; ")}` };
+  for (const body of fencedBlocks(output, "(?:json|jsonc|json5)")) {
+    try {
+      const report = parseGenericJsonAcceptanceReportBody(body);
+      if (report)
+        return { report };
+    } 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) };
+        }
+      }
+    }
+  }
+  return { error: "Structured acceptance report not found." };
+}
+export function stripAcceptanceReport(output) {
+  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;
+    if (output.slice(end).trim().length === 0 && match[1] && match[2]) {
+      trailingFence = { index: match.index ?? 0, tag: match[1].toLowerCase(), body: match[2] };
+    }
+  }
+  if (trailingFence) {
+    if (trailingFence.tag === "acceptance-report")
+      return output.slice(0, trailingFence.index).trimEnd();
+    try {
+      if (parseGenericJsonAcceptanceReportBody(trailingFence.body))
+        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();
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function pathFor(base, segment) {
+  return base ? `${base}.${segment}` : segment;
+}
+function describeValidationValue(value) {
+  if (value === undefined)
+    return "missing";
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  if (typeof value === "object")
+    return "object";
+  if (typeof value === "string") {
+    const short = value.length > 80 ? `${value.slice(0, 77)}...` : value;
+    return JSON.stringify(short);
+  }
+  return `${typeof value} ${String(value)}`;
+}
+function pushTypeError(errors, pathLabel, expected, value) {
+  errors.push(`${pathLabel}: expected ${expected}; got ${describeValidationValue(value)}`);
+}
+function validateStringArrayField(errors, value, pathLabel) {
+  if (!Array.isArray(value)) {
+    pushTypeError(errors, pathLabel, "string[]", value);
+    return;
+  }
+  for (const [index, item] of value.entries()) {
+    if (typeof item !== "string")
+      pushTypeError(errors, `${pathLabel}[${index}]`, "string", item);
+  }
+}
+function validateAcceptanceReport(value, pathLabel = "") {
+  const errors = [];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    pushTypeError(errors, pathLabel || "acceptance-report", "object", value);
+    return { errors };
+  }
+  const report = value;
+  if (report.criteriaSatisfied !== undefined) {
+    if (!Array.isArray(report.criteriaSatisfied)) {
+      pushTypeError(errors, pathFor(pathLabel, "criteriaSatisfied"), "array", report.criteriaSatisfied);
+    } else {
+      for (const [index, item] of report.criteriaSatisfied.entries()) {
+        const itemPath = `${pathFor(pathLabel, "criteriaSatisfied")}[${index}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+          pushTypeError(errors, itemPath, "object", item);
+          continue;
+        }
+        const criterion = item;
+        if (criterion.id !== undefined && typeof criterion.id !== "string")
+          pushTypeError(errors, `${itemPath}.id`, "string", 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);
+        }
+        if (typeof criterion.evidence !== "string" || !criterion.evidence.trim())
+          pushTypeError(errors, `${itemPath}.evidence`, "non-empty string", criterion.evidence);
+      }
+    }
+  }
+  if (report.changedFiles !== undefined)
+    validateStringArrayField(errors, report.changedFiles, pathFor(pathLabel, "changedFiles"));
+  if (report.testsAddedOrUpdated !== undefined)
+    validateStringArrayField(errors, report.testsAddedOrUpdated, pathFor(pathLabel, "testsAddedOrUpdated"));
+  if (report.commandsRun !== undefined) {
+    if (!Array.isArray(report.commandsRun)) {
+      pushTypeError(errors, pathFor(pathLabel, "commandsRun"), "array", report.commandsRun);
+    } else {
+      for (const [index, item] of report.commandsRun.entries()) {
+        const itemPath = `${pathFor(pathLabel, "commandsRun")}[${index}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+          pushTypeError(errors, itemPath, "object", item);
+          continue;
+        }
+        const command = item;
+        if (typeof command.command !== "string" || !command.command.trim())
+          pushTypeError(errors, `${itemPath}.command`, "non-empty string", command.command);
+        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 (report.validationOutput !== undefined)
+    validateStringArrayField(errors, report.validationOutput, pathFor(pathLabel, "validationOutput"));
+  if (report.residualRisks !== undefined)
+    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.reviewFindings !== undefined)
+    validateStringArrayField(errors, report.reviewFindings, pathFor(pathLabel, "reviewFindings"));
+  if (report.manualNotes !== undefined && typeof report.manualNotes !== "string")
+    pushTypeError(errors, pathFor(pathLabel, "manualNotes"), "string", report.manualNotes);
+  if (report.notes !== undefined && typeof report.notes !== "string")
+    pushTypeError(errors, pathFor(pathLabel, "notes"), "string", report.notes);
+  if (errors.length > 0)
+    return { errors };
+  const hasReportField = report.criteriaSatisfied !== undefined || report.changedFiles !== undefined || report.testsAddedOrUpdated !== undefined || report.commandsRun !== undefined || report.validationOutput !== undefined || report.residualRisks !== undefined || report.noStagedFiles !== undefined || report.diffSummary !== undefined || report.manualNotes !== undefined || report.notes !== undefined || report.reviewFindings !== undefined;
+  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]));
+  return criteria.filter((criterion) => criterion.severity !== "recommended").map((criterion) => {
+    const item = reports.get(criterion.id);
+    if (!item)
+      return { id: `criterion:${criterion.id}`, status: "failed", message: `Required criterion '${criterion.id}' was not reported.` };
+    if (item.status !== "satisfied")
+      return { id: `criterion:${criterion.id}`, status: "failed", message: `Required criterion '${criterion.id}' was reported as ${item.status}.` };
+    return { id: `criterion:${criterion.id}`, status: "passed", message: `Required criterion '${criterion.id}' satisfied.` };
+  });
+}
+function reportEvidencePresent(report, kind) {
+  switch (kind) {
+    case "changed-files":
+      return isStringArray(report.changedFiles) && report.changedFiles.length > 0;
+    case "tests-added":
+      return isStringArray(report.testsAddedOrUpdated) && report.testsAddedOrUpdated.length > 0;
+    case "commands-run":
+      return Array.isArray(report.commandsRun) && report.commandsRun.length > 0;
+    case "validation-output":
+      return isStringArray(report.validationOutput) && report.validationOutput.length > 0;
+    case "residual-risks":
+      return isStringArray(report.residualRisks);
+    case "no-staged-files":
+      return report.noStagedFiles === true;
+    case "diff-summary":
+      return typeof report.diffSummary === "string" && report.diffSummary.trim().length > 0;
+    case "review-findings":
+      return isStringArray(report.reviewFindings);
+    case "manual-notes":
+      return Boolean((report.manualNotes ?? report.notes)?.trim());
+  }
+}
+function checkNoStagedFiles(cwd) {
+  const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+  if (result.status !== 0) {
+    return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
+  }
+  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(", ")}` };
+}
+function runStructuralChecks(acceptance, report, cwd) {
+  const checks = [];
+  for (const kind of acceptance.evidence) {
+    const present = reportEvidencePresent(report, kind);
+    checks.push({
+      id: `evidence:${kind}`,
+      status: present ? "passed" : "failed",
+      message: present ? `${kind} evidence present.` : `${kind} evidence missing from child report.`
+    });
+  }
+  if (acceptance.evidence.includes("no-staged-files"))
+    checks.push(checkNoStagedFiles(cwd));
+  return checks;
+}
+function trimOutput(value) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  return trimmed.length > 12000 ? `${trimmed.slice(0, 12000)}
+...[truncated]` : trimmed;
+}
+function uniqueStrings(items) {
+  return unique(items.map((item) => item?.trim()).filter((item) => Boolean(item)));
+}
+export function aggregateAcceptanceReport(input) {
+  const childReports = input.results.map((result) => result.acceptance?.childReport).filter((report) => Boolean(report));
+  const blockers = input.results.filter((result) => result.exitCode !== 0 || result.acceptance?.status === "rejected");
+  const successfulChildren = input.results.length > 0 && blockers.length === 0;
+  return {
+    criteriaSatisfied: [
+      { id: "criterion-1", status: successfulChildren ? "satisfied" : "not-satisfied", evidence: successfulChildren ? `All ${input.results.length} dynamic child run(s) completed without child or acceptance blockers.` : "Dynamic fanout produced no accepted child evidence." },
+      { id: "criterion-2", status: successfulChildren ? "satisfied" : "not-satisfied", evidence: successfulChildren ? "Collected child acceptance evidence for aggregate review." : "Dynamic fanout produced no aggregate review evidence." },
+      ...input.results.map((result, index) => ({
+        id: `child-${index + 1}`,
+        status: result.exitCode === 0 && result.acceptance?.status !== "rejected" ? "satisfied" : "not-satisfied",
+        evidence: `${result.agent}: acceptance ${result.acceptance?.status ?? "unreported"}${result.error ? ` (${result.error})` : ""}`
+      }))
+    ],
+    changedFiles: uniqueStrings(childReports.flatMap((report) => report.changedFiles ?? [])),
+    testsAddedOrUpdated: uniqueStrings(childReports.flatMap((report) => report.testsAddedOrUpdated ?? [])),
+    commandsRun: childReports.flatMap((report) => report.commandsRun ?? []),
+    validationOutput: uniqueStrings(childReports.flatMap((report) => report.validationOutput ?? [])),
+    residualRisks: uniqueStrings([
+      ...childReports.flatMap((report) => report.residualRisks ?? []),
+      ...blockers.map((result) => `${result.agent}: ${result.error ?? "child or acceptance gate failed"}`)
+    ]),
+    noStagedFiles: childReports.length > 0 && childReports.every((report) => report.noStagedFiles === true),
+    reviewFindings: uniqueStrings(childReports.flatMap((report) => report.reviewFindings ?? [])),
+    manualNotes: input.notes ?? `Aggregated acceptance evidence from ${input.results.length} dynamic fanout child run(s).`,
+    notes: input.notes
+  };
+}
+function runVerifyCommand(command, defaultCwd, options = {}) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const cwd = command.cwd ? path.resolve(defaultCwd, command.cwd) : defaultCwd;
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    let hardKill;
+    const child = spawn(command.command, {
+      cwd,
+      env: { ...process.env, ...command.env ?? {} },
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timeout);
+      if (hardKill)
+        clearTimeout(hardKill);
+      options.signal?.removeEventListener("abort", abortVerification);
+      resolve({
+        id: command.id,
+        command: command.command,
+        cwd,
+        durationMs: Date.now() - startedAt,
+        ...result
+      });
+    };
+    const abortVerification = () => {
+      if (settled || timedOut)
+        return;
+      timedOut = true;
+      child.kill("SIGTERM");
+      hardKill = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish({
+          exitCode: null,
+          status: "timed-out",
+          stdout: trimOutput(stdout),
+          stderr: trimOutput(stderr || options.abortMessage || "Acceptance verification timed out.")
+        });
+      }, 1000);
+      hardKill.unref?.();
+    };
+    const timeout = setTimeout(abortVerification, command.timeoutMs ?? 120000);
+    timeout.unref?.();
+    if (options.signal?.aborted)
+      abortVerification();
+    else
+      options.signal?.addEventListener("abort", abortVerification, { once: true });
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("close", (exitCode) => {
+      const passed = exitCode === 0 && !timedOut;
+      finish({
+        exitCode,
+        status: timedOut ? "timed-out" : passed ? "passed" : command.allowFailure ? "allowed-failure" : "failed",
+        stdout: trimOutput(stdout),
+        stderr: trimOutput(stderr || (timedOut ? options.abortMessage ?? "" : ""))
+      });
+    });
+    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)
+      });
+    });
+  });
+}
+export async function evaluateAcceptance(input) {
+  const acceptance = input.acceptance;
+  const ledger = {
+    status: acceptance.level === "none" ? "not-required" : "claimed",
+    explicit: acceptance.explicit,
+    effectiveAcceptance: acceptance,
+    inferredReason: acceptance.inferredReason,
+    criteria: acceptance.criteria,
+    runtimeChecks: [],
+    verifyRuns: []
+  };
+  if (acceptance.level === "none")
+    return ledger;
+  const parsed = input.report ? { report: input.report } : parseAcceptanceReport(input.output);
+  if (parsed.report) {
+    ledger.childReport = parsed.report;
+    ledger.status = "attested";
+  } else {
+    ledger.childReportParseError = parsed.error;
+    ledger.runtimeChecks.push({ id: "attestation", status: "failed", message: parsed.error ?? "Structured acceptance report missing." });
+    ledger.status = "rejected";
+    return ledger;
+  }
+  if (LEVEL_RANK[acceptance.level] >= LEVEL_RANK.checked) {
+    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;
+    }
+    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";
+      return ledger;
+    }
+    ledger.verifyRuns = [];
+    for (const command of acceptance.verify) {
+      ledger.verifyRuns.push(await runVerifyCommand(command, input.cwd, { signal: input.signal, abortMessage: input.abortMessage }));
+      if (input.signal?.aborted)
+        break;
+    }
+    if (ledger.verifyRuns.some((run) => run.status === "failed" || run.status === "timed-out")) {
+      ledger.status = "rejected";
+      return ledger;
+    }
+    ledger.status = "verified";
+  }
+  if (acceptance.level === "reviewed") {
+    if (input.reviewResult) {
+      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",
+        findings: [{
+          severity: acceptance.explicit && !optionalReview ? "blocker" : "non-blocking",
+          issue: "Reviewed acceptance requires an independent reviewer result.",
+          rationale: "The run cannot be marked reviewed from child evidence alone."
+        }]
+      };
+      if (acceptance.review === false || acceptance.explicit && !optionalReview)
+        ledger.status = "rejected";
+    }
+  }
+  return ledger;
+}
+export function acceptanceFailureMessage(ledger) {
+  if (ledger.status !== "rejected")
+    return;
+  const failedCheck = ledger.runtimeChecks.find((check) => check.status === "failed");
+  if (failedCheck)
+    return `Acceptance rejected: ${failedCheck.message}`;
+  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.";
+}