substrate-ai 0.21.9 → 0.21.11

package/dist/acceptance-judge-eIZZha1C.js

@@ -0,0 +1,702 @@
+import { createLogger } from "./logger-KeHncl-f.js";
+import { join } from "node:path";
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+
+//#region src/modules/context-compiler/token-counter.ts
+/**
+* Token counter utility for the context-compiler module.
+*
+* Uses a simple heuristic: chars/4, with a 10% upward adjustment for text
+* containing fenced code blocks (triple backticks). Intentionally conservative
+* — better to under-fill a prompt than overflow.
+*/
+const CHARS_PER_TOKEN = 4;
+const CODE_BLOCK_ADJUSTMENT = 1.1;
+const CODE_BLOCK_MARKER = "```";
+/**
+* Approximate the number of tokens in `text`.
+*
+* - Base heuristic: `Math.ceil(text.length / 4)`
+* - If the text contains one or more fenced code blocks (triple backticks),
+*   apply a 10% upward multiplier and re-ceil.
+*
+* The approximation is within 15% of actual tokenizer output for typical
+* prompt content.
+*/
+function countTokens(text) {
+	if (text.length === 0) return 0;
+	const base = text.length / CHARS_PER_TOKEN;
+	const hasCodeBlock = text.includes(CODE_BLOCK_MARKER);
+	const adjusted = hasCodeBlock ? base * CODE_BLOCK_ADJUSTMENT : base;
+	return Math.ceil(adjusted);
+}
+/**
+* Truncate `text` to approximately `maxTokens` tokens.
+*
+* Returns the original text if it already fits within the budget.
+* Appends a `…` ellipsis suffix when truncation occurs to indicate content
+* was cut off.
+*
+* Note: Because the chars/4 heuristic is an approximation, the truncated
+* result may still slightly exceed or fall short of the exact token target.
+*/
+function truncateToTokens(text, maxTokens) {
+	if (maxTokens <= 0) return "";
+	if (countTokens(text) <= maxTokens) return text;
+	const hasCodeBlock = text.includes(CODE_BLOCK_MARKER);
+	const multiplier = hasCodeBlock ? CODE_BLOCK_ADJUSTMENT : 1;
+	const targetChars = Math.floor(maxTokens * CHARS_PER_TOKEN / multiplier);
+	if (targetChars <= 0) return "";
+	const roughTrunc = text.slice(0, targetChars);
+	const lastSpace = roughTrunc.lastIndexOf(" ", roughTrunc.length - 1);
+	let truncated;
+	if (lastSpace > targetChars - 50 && lastSpace > 0) truncated = roughTrunc.slice(0, lastSpace);
+	else truncated = roughTrunc;
+	return truncated + "…";
+}
+
+//#endregion
+//#region src/modules/compiled-workflows/prompt-assembler.ts
+const logger$1 = createLogger("compiled-workflows:prompt-assembler");
+/**
+* Assemble a final prompt from a template and sections map.
+*
+* Steps:
+* 1. Build a map of placeholder → content from sections array
+* 2. Replace {{placeholder}} patterns in the template
+* 3. Estimate total token count
+* 4. If over ceiling, truncate sections in reverse priority order
+* 5. Return assembled prompt with token count and truncation flag
+*
+* @param template - Prompt template with {{placeholder}} markers
+* @param sections - Named sections with content and priority
+* @param tokenCeiling - Hard token ceiling (default: 2200)
+*/
+function assemblePrompt(template, sections, tokenCeiling = 2200) {
+	const contentMap = {};
+	for (const section of sections) contentMap[section.name] = section.content;
+	let prompt = replacePlaceholders(template, contentMap);
+	let tokenCount = countTokens(prompt);
+	if (tokenCount <= tokenCeiling) return {
+		prompt,
+		tokenCount,
+		truncated: false
+	};
+	logger$1.warn({
+		tokenCount,
+		ceiling: tokenCeiling
+	}, "Prompt exceeds token ceiling — truncating optional sections");
+	const priorityOrder = ["optional", "important"];
+	let truncated = false;
+	for (const priority of priorityOrder) {
+		const sectionsAtPriority = sections.filter((s) => s.priority === priority);
+		for (const section of sectionsAtPriority) {
+			if (tokenCount <= tokenCeiling) break;
+			const overBy = tokenCount - tokenCeiling;
+			const currentSectionTokens = countTokens(section.content);
+			if (currentSectionTokens === 0) continue;
+			const targetSectionTokens = Math.max(0, currentSectionTokens - overBy);
+			if (targetSectionTokens === 0) {
+				contentMap[section.name] = "";
+				logger$1.warn({ sectionName: section.name }, "Section eliminated to fit token budget");
+			} else {
+				contentMap[section.name] = truncateToTokens(section.content, targetSectionTokens);
+				logger$1.warn({
+					sectionName: section.name,
+					targetSectionTokens
+				}, "Section truncated to fit token budget");
+			}
+			truncated = true;
+			prompt = replacePlaceholders(template, contentMap);
+			tokenCount = countTokens(prompt);
+		}
+		if (tokenCount <= tokenCeiling) break;
+	}
+	if (tokenCount > tokenCeiling) logger$1.warn({
+		tokenCount,
+		ceiling: tokenCeiling
+	}, "Required sections alone exceed token ceiling — returning over-budget prompt");
+	return {
+		prompt,
+		tokenCount,
+		truncated
+	};
+}
+/**
+* Replace {{placeholder}} patterns in template with values from contentMap.
+* Missing placeholders are replaced with an empty string.
+*/
+function replacePlaceholders(template, contentMap) {
+	return template.replace(/\{\{(\w[\w_-]*)\}\}/g, (_match, key) => {
+		return contentMap[key] ?? "";
+	});
+}
+
+//#endregion
+//#region src/modules/compiled-workflows/schemas.ts
+/**
+* Schema for the YAML output contract of the create-story sub-agent.
+* The agent must emit YAML matching this shape.
+*/
+const CreateStoryResultSchema = z.object({
+	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
+	story_file: z.string().optional(),
+	story_key: z.string().optional(),
+	story_title: z.string().optional()
+});
+/**
+* Coerce a YAML value to a plain string. Agents sometimes emit
+* `ac_failures: [AC7: explanation]` which YAML parses as a mapping
+* `{ AC7: "explanation" }` instead of a string. This flattens it.
+*/
+const coerceToString = z.preprocess((val) => {
+	if (typeof val === "string") return val;
+	if (val !== null && typeof val === "object") return Object.entries(val).map(([k, v]) => `${k}: ${String(v)}`).join(", ");
+	return String(val);
+}, z.string());
+/**
+* Schema for the YAML output contract of the dev-story sub-agent.
+* The agent must emit YAML matching this shape.
+*/
+const DevStoryResultSchema = z.object({
+	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
+	ac_met: z.array(coerceToString).default([]),
+	ac_failures: z.array(coerceToString).default([]),
+	files_modified: z.array(z.string()).default([]),
+	tests: z.preprocess((val) => {
+		if (typeof val === "string") {
+			const lower = val.toLowerCase();
+			if (lower.includes("fail")) return "fail";
+			return "pass";
+		}
+		if (val !== null && typeof val === "object") {
+			const obj = val;
+			if (typeof obj.fail === "number" && obj.fail > 0) return "fail";
+			return "pass";
+		}
+		if (typeof val === "number") return val > 0 ? "fail" : "pass";
+		return "pass";
+	}, z.enum(["pass", "fail"])),
+	notes: z.string().optional()
+});
+/**
+* Coerce a YAML value to a number. Agents sometimes emit line numbers
+* as strings (`"42"` instead of `42`). This handles the conversion.
+*/
+const coerceOptionalNumber = z.preprocess((val) => typeof val === "string" ? Number(val) : val, z.number().optional());
+const coerceNumber = z.preprocess((val) => {
+	if (typeof val === "string") return Number(val);
+	if (Array.isArray(val)) return val.length;
+	return val;
+}, z.number());
+/**
+* Schema for a single issue in the code review output.
+*/
+const CodeReviewIssueSchema = z.object({
+	severity: z.enum([
+		"blocker",
+		"major",
+		"minor"
+	]),
+	description: z.string(),
+	file: z.string().optional(),
+	line: coerceOptionalNumber
+});
+/**
+* Schema for a single entry in the AC verification checklist emitted by
+* the code-review sub-agent. Each entry maps an acceptance criterion to a
+* status determination backed by concrete evidence from the diff.
+*/
+const AcChecklistEntrySchema = z.object({
+	ac_id: z.string().default(""),
+	status: z.enum([
+		"met",
+		"not_met",
+		"partial"
+	]).default("met"),
+	evidence: z.string().default("")
+});
+/**
+* Compute the verdict from the issue list using deterministic rules.
+*
+* The agent reports issues with severities; the pipeline computes the
+* verdict. This decouples model-routing cost decisions (MAJOR_REWORK
+* triggers opus) from agent judgment, and scales naturally with story
+* size — severity classification is per-issue, not per-story.
+*
+* Rules:
+*  - Any blocker → NEEDS_MAJOR_REWORK (security, data loss, architectural breakage)
+*  - Any major or minor issues → NEEDS_MINOR_FIXES (fixable by sonnet with guidance)
+*  - No issues → SHIP_IT
+*
+* Note: LGTM_WITH_NOTES is handled in the transform (not here) because it
+* requires knowledge of the agent's original verdict.
+*/
+function computeVerdict(issueList) {
+	const hasBlocker = issueList.some((i) => i.severity === "blocker");
+	if (hasBlocker) return "NEEDS_MAJOR_REWORK";
+	if (issueList.length > 0) return "NEEDS_MINOR_FIXES";
+	return "SHIP_IT";
+}
+/**
+* Schema for the YAML output contract of the code-review sub-agent.
+*
+* The agent must emit YAML with verdict, issues count, issue_list, and
+* optionally an ac_checklist mapping each AC to its implementation status.
+* Example:
+*   verdict: NEEDS_MINOR_FIXES
+*   issues: 3
+*   issue_list:
+*     - severity: minor
+*       description: "Missing error handling in createFoo()"
+*       file: "src/modules/foo/foo.ts"
+*       line: 42
+*   ac_checklist:
+*     - ac_id: AC1
+*       status: met
+*       evidence: "Implemented in src/modules/foo/foo.ts:createFoo()"
+*     - ac_id: AC2
+*       status: not_met
+*       evidence: "No implementation found for getConstraints()"
+*   notes: "Generally clean implementation."
+*
+* The transform:
+* 1. Auto-corrects the issues count from issue_list length.
+* 2. Auto-injects a major issue for each not_met AC not already flagged.
+* 3. Recomputes the verdict from the (possibly augmented) issue list.
+* The agent's original verdict is preserved as `agentVerdict` for logging.
+*/
+const CodeReviewResultSchema = z.object({
+	verdict: z.enum([
+		"SHIP_IT",
+		"NEEDS_MINOR_FIXES",
+		"NEEDS_MAJOR_REWORK",
+		"LGTM_WITH_NOTES"
+	]),
+	issues: coerceNumber,
+	issue_list: z.array(CodeReviewIssueSchema),
+	ac_checklist: z.array(AcChecklistEntrySchema).default([]),
+	notes: z.string().optional()
+}).transform((data) => {
+	const augmentedIssueList = [...data.issue_list];
+	for (const entry of data.ac_checklist) if (entry.status === "not_met") {
+		const acIdPattern = new RegExp(`\\b${entry.ac_id}\\b`);
+		const alreadyFlagged = augmentedIssueList.some((issue) => (issue.severity === "major" || issue.severity === "blocker") && acIdPattern.test(issue.description));
+		if (!alreadyFlagged) augmentedIssueList.push({
+			severity: "major",
+			description: `${entry.ac_id} not implemented: ${entry.evidence}`,
+			file: ""
+		});
+	}
+	const computedVerdict = computeVerdict(augmentedIssueList);
+	const finalVerdict = data.verdict === "LGTM_WITH_NOTES" && computedVerdict === "SHIP_IT" ? "LGTM_WITH_NOTES" : computedVerdict;
+	return {
+		...data,
+		issue_list: augmentedIssueList,
+		issues: augmentedIssueList.length,
+		agentVerdict: data.verdict,
+		verdict: finalVerdict
+	};
+});
+/**
+* Schema for the YAML output contract of the test-plan sub-agent.
+*
+* The agent must emit YAML with result, test_files, test_categories, and coverage_notes.
+* Example:
+*   result: success
+*   test_files:
+*     - src/modules/foo/__tests__/foo.test.ts
+*   test_categories:
+*     - unit
+*     - integration
+*   coverage_notes: "AC1 covered by foo.test.ts"
+*/
+const TestPlanResultSchema = z.object({
+	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
+	test_files: z.array(z.string()).default([]),
+	test_categories: z.array(z.string()).default([]),
+	coverage_notes: z.string().default("")
+});
+/**
+* Schema for a single coverage gap identified during test expansion analysis.
+*/
+const CoverageGapSchema = z.object({
+	ac_ref: z.string(),
+	description: z.string(),
+	gap_type: z.enum([
+		"missing-e2e",
+		"missing-integration",
+		"unit-only"
+	])
+});
+/**
+* Schema for a single suggested test generated during test expansion analysis.
+*/
+const SuggestedTestSchema = z.object({
+	test_name: z.string(),
+	test_type: z.enum([
+		"e2e",
+		"integration",
+		"unit"
+	]),
+	description: z.string(),
+	target_ac: z.string().optional()
+});
+/**
+* Schema for the YAML output contract of the test-expansion sub-agent.
+*
+* The agent must emit YAML with expansion_priority, coverage_gaps, and suggested_tests.
+* Example:
+*   expansion_priority: medium
+*   coverage_gaps:
+*     - ac_ref: AC1
+*       description: "Happy path not exercised at module boundary"
+*       gap_type: missing-integration
+*   suggested_tests:
+*     - test_name: "runFoo integration happy path"
+*       test_type: integration
+*       description: "Test runFoo with real DB to verify AC1 end-to-end"
+*       target_ac: AC1
+*   notes: "Unit coverage is solid but integration layer is untested."
+*/
+const TestExpansionResultSchema = z.object({
+	expansion_priority: z.preprocess((val) => [
+		"low",
+		"medium",
+		"high"
+	].includes(val) ? val : "low", z.enum([
+		"low",
+		"medium",
+		"high"
+	])),
+	coverage_gaps: z.array(CoverageGapSchema).default([]),
+	suggested_tests: z.array(SuggestedTestSchema).default([]),
+	notes: z.string().optional()
+});
+/**
+* Inline mirror of RuntimeProbeSchema from @substrate-ai/sdlc.
+*
+* Inlined here instead of imported to avoid triggering Vitest's mock validation
+* error in orchestrator tests that mock @substrate-ai/sdlc without including
+* RuntimeProbeListSchema. The canonical definition lives in
+* packages/sdlc/src/verification/probes/types.ts — keep in sync when that
+* schema changes.
+*/
+const InlineRuntimeProbeSchema = z.object({
+	name: z.string().min(1, "probe name is required"),
+	sandbox: z.enum(["host", "twin"]),
+	command: z.string().min(1, "probe command is required"),
+	timeout_ms: z.number().int().positive().optional(),
+	description: z.string().optional(),
+	expect_stdout_no_regex: z.array(z.string().min(1)).optional(),
+	expect_stdout_regex: z.array(z.string().min(1)).optional()
+});
+const InlineRuntimeProbeListSchema = z.array(InlineRuntimeProbeSchema);
+/**
+* Schema for the YAML output contract of the probe-author sub-agent.
+*
+* The agent emits a yaml block containing result and probes list.
+* The probes field is validated against the RuntimeProbe shape from @substrate-ai/sdlc
+* (inlined to avoid module mock conflicts in orchestrator unit tests).
+*
+* Example:
+*   result: success
+*   probes:
+*     - name: my-probe
+*       sandbox: host
+*       command: echo "hello"
+*/
+const ProbeAuthorResultSchema = z.object({
+	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
+	probes: InlineRuntimeProbeListSchema
+});
+/**
+* Per-end-state verdict from the acceptance judge.
+*
+* UNREACHABLE is first-class and distinct from FAIL: the walk could not even
+* be attempted because the affordance does not exist in the rendered surface
+* — it is what the income-sources UJ-2 failure WAS. Evidence is MANDATORY:
+* a verdict that cannot cite the artifact region it grounds on is
+* schema-invalid (naive prose judging is banned by construction — the
+* documented LLM-judge biases make ungrounded verdicts worthless).
+*/
+const AcceptanceJudgeVerdictSchema = z.object({
+	end_state_id: z.string().min(1),
+	verdict: z.preprocess((val) => typeof val === "string" ? val.toUpperCase() : val, z.enum([
+		"PASS",
+		"FAIL",
+		"UNREACHABLE"
+	])),
+	evidence: z.object({
+		artifact: z.string().min(1),
+		excerpt: z.string().min(1)
+	}),
+	reasoning: z.string().optional()
+});
+/**
+* Schema for the YAML output contract of the acceptance-judge sub-agent.
+*/
+const AcceptanceJudgeResultSchema = z.object({
+	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
+	verdicts: z.array(AcceptanceJudgeVerdictSchema).default([]),
+	error: z.string().optional()
+});
+
+//#endregion
+//#region src/modules/compiled-workflows/token-ceiling.ts
+/**
+* Default token ceilings for each compiled workflow.
+* These match the hardcoded constants previously defined inline in each workflow.
+*/
+const TOKEN_CEILING_DEFAULTS = {
+	"create-story": 5e4,
+	"dev-story": 4e5,
+	"code-review": 5e5,
+	"test-plan": 1e5,
+	"test-expansion": 2e5,
+	"probe-author": 5e4,
+	"acceptance-judge": 1e5
+};
+/**
+* Resolve the effective token ceiling for a workflow type.
+*
+* Returns the ceiling from `tokenCeilings` config if present and valid,
+* otherwise falls back to the hardcoded default.
+*
+* @param workflowType - One of: 'create-story', 'dev-story', 'code-review', 'test-plan', 'test-expansion'
+* @param tokenCeilings - Optional per-workflow overrides from parsed config
+* @returns `{ ceiling: number, source: 'config' | 'default' }`
+*/
+function getTokenCeiling(workflowType, tokenCeilings) {
+	if (tokenCeilings !== void 0) {
+		const configured = tokenCeilings[workflowType];
+		if (configured !== void 0) return {
+			ceiling: configured,
+			source: "config"
+		};
+	}
+	const defaultValue = TOKEN_CEILING_DEFAULTS[workflowType] ?? 0;
+	return {
+		ceiling: defaultValue,
+		source: "default"
+	};
+}
+
+//#endregion
+//#region src/modules/compiled-workflows/acceptance-judge.ts
+const logger = createLogger("compiled-workflows:acceptance-judge");
+/** Cap per-artifact content injected into the prompt (chars). */
+const ARTIFACT_CONTENT_CAP = 16e3;
+function renderEndStates(journey) {
+	return journey.end_states.map((es) => `- id: ${es.id}\n  given: ${es.given}\n  walk: ${es.walk}\n  then: ${es.then}`).join("\n");
+}
+async function readArtifactContents(artifactsDir, artifacts) {
+	const map = new Map();
+	for (const rel of artifacts) try {
+		map.set(rel, await readFile(join(artifactsDir, rel), "utf-8"));
+	} catch {}
+	return map;
+}
+function renderArtifactContents(contents) {
+	const blocks = [];
+	for (const [rel, content] of contents) {
+		const truncated = content.length > ARTIFACT_CONTENT_CAP;
+		blocks.push(`--- ${rel}${truncated ? ` (truncated to first ${String(ARTIFACT_CONTENT_CAP)} chars)` : ""} ---\n` + content.slice(0, ARTIFACT_CONTENT_CAP));
+	}
+	return blocks.join("\n\n");
+}
+/** Validate verdict completeness: every end-state exactly once, no unknown ids. */
+function validateVerdictCoverage(journey, verdicts) {
+	const expected = new Set(journey.end_states.map((es) => es.id));
+	const seen = new Set();
+	for (const v of verdicts) {
+		if (!expected.has(v.end_state_id)) return `verdict for unknown end-state id "${v.end_state_id}"`;
+		if (seen.has(v.end_state_id)) return `duplicate verdict for end-state "${v.end_state_id}"`;
+		seen.add(v.end_state_id);
+	}
+	const missing = [...expected].filter((id) => !seen.has(id));
+	if (missing.length > 0) return `missing verdict(s) for end-state(s): ${missing.join(", ")}`;
+	return void 0;
+}
+/**
+* Normalize for substring grounding: strip HTML tags, decode a few common
+* entities, collapse whitespace, lowercase. Tag-stripping is essential — a
+* judge legitimately quotes RENDERED (visible) text, which in HTML is often
+* split across tags (e.g. `<a>Grade 1</a> <a>Grade 2</a>` reads as
+* "Grade 1 Grade 2"); without stripping, a correct PASS citation fails to
+* ground. A fabricated injection excerpt still won't appear in the
+* tag-stripped real content, so the anti-injection property holds.
+*/
+function normalizeForGrounding(s) {
+	return s.replace(/<[^>]*>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#39;/gi, "'").replace(/\s+/g, " ").trim().toLowerCase();
+}
+/**
+* A5.1 F7 (red-team): a PASS excerpt must be a VERBATIM substring of the named
+* artifact — a deterministic check (no LLM) that a hostile render cannot
+* satisfy the citation requirement by fabricating an excerpt alongside an
+* injected "PASS". Grounding is scoped to PASS ONLY: that is exactly where the
+* "mark everything PASS" injection lives, and it is the only verdict that makes
+* a POSITIVE claim ("the affordance exists — here it is") which must be
+* citable. FAIL and UNREACHABLE are NEGATIVE findings (the observable is wrong
+* or absent) whose excerpt legitimately DESCRIBES an absence rather than
+* quoting present text — requiring a verbatim substring there is a category
+* error and false-positives correct judgments. A fabricated FAIL/UNREACHABLE
+* cannot help an attacker (it blocks their own story), so leaving them
+* unground-checked costs no security.
+* Returns a problem string for the FIRST ungrounded PASS citation, or undefined.
+*/
+function validateEvidenceGrounding(verdicts, artifactContents) {
+	for (const v of verdicts) {
+		if (v.verdict !== "PASS") continue;
+		const content = artifactContents.get(v.evidence.artifact);
+		if (content === void 0) return `verdict ${v.end_state_id} cites artifact "${v.evidence.artifact}" which is not in the rendered set`;
+		const haystack = ` ${normalizeForGrounding(content)} ${content.toLowerCase().replace(/\s+/g, " ")} `;
+		const tokens = normalizeForGrounding(v.evidence.excerpt).split(" ").map((t) => t.replace(/[^a-z0-9]/g, "")).filter((t) => t.length >= 4);
+		if (tokens.length < 2) return `verdict ${v.end_state_id} cites too thin an excerpt to ground ("${v.evidence.excerpt}") — quote a substantive span (several words) of the artifact`;
+		const present = tokens.filter((t) => haystack.includes(t)).length;
+		const overlap = present / tokens.length;
+		if (overlap < .6) return `verdict ${v.end_state_id} excerpt does not appear in ${v.evidence.artifact} (only ${String(present)}/${String(tokens.length)} tokens present — fabricated citation?)`;
+	}
+	return void 0;
+}
+async function runAcceptanceJudge(deps, params) {
+	const { journey, artifactsDir, artifacts, storyKey } = params;
+	let template;
+	try {
+		template = await deps.pack.getPrompt("acceptance-judge");
+	} catch (err) {
+		return {
+			result: "failed",
+			error: `Failed to retrieve acceptance-judge prompt: ${err instanceof Error ? err.message : String(err)}`,
+			tokenUsage: {
+				input: 0,
+				output: 0
+			}
+		};
+	}
+	const artifactContentMap = await readArtifactContents(artifactsDir, artifacts);
+	const artifactContents = renderArtifactContents(artifactContentMap);
+	const buildPrompt = (correctivePreamble) => {
+		const { prompt } = assemblePrompt(template, [
+			{
+				name: "journey_id",
+				content: journey.id,
+				priority: "required"
+			},
+			{
+				name: "journey_title",
+				content: journey.title,
+				priority: "required"
+			},
+			{
+				name: "end_states",
+				content: renderEndStates(journey),
+				priority: "required"
+			},
+			{
+				name: "artifact_manifest",
+				content: artifacts.length > 0 ? artifacts.map((a) => `- ${a}`).join("\n") : "(no artifacts)",
+				priority: "required"
+			},
+			{
+				name: "artifact_contents",
+				content: artifactContents,
+				priority: "required"
+			}
+		], getTokenCeiling("acceptance-judge", deps.tokenCeilings).ceiling);
+		return correctivePreamble !== void 0 ? `${correctivePreamble}\n\n${prompt}` : prompt;
+	};
+	let totalTokens = {
+		input: 0,
+		output: 0
+	};
+	let lastProblem = "unknown";
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const prompt = attempt === 0 ? buildPrompt() : buildPrompt(`PREVIOUS ATTEMPT REJECTED: ${lastProblem}. Emit ONLY the YAML block per the Output Contract — every end-state exactly once, every verdict with evidence {artifact, excerpt}.`);
+		const handle = deps.dispatcher.dispatch({
+			prompt,
+			agent: deps.agentId ?? "claude-code",
+			taskType: "acceptance-judge",
+			outputSchema: AcceptanceJudgeResultSchema,
+			maxTurns: 30,
+			workingDirectory: artifactsDir,
+			...deps.otlpEndpoint !== void 0 ? { otlpEndpoint: deps.otlpEndpoint } : {},
+			...storyKey !== void 0 ? { storyKey } : {}
+		});
+		let dispatchResult;
+		try {
+			dispatchResult = await handle.result;
+		} catch (err) {
+			return {
+				result: "failed",
+				error: `Dispatch error: ${err instanceof Error ? err.message : String(err)}`,
+				tokenUsage: totalTokens
+			};
+		}
+		totalTokens = {
+			input: totalTokens.input + dispatchResult.tokenEstimate.input,
+			output: totalTokens.output + dispatchResult.tokenEstimate.output
+		};
+		if (dispatchResult.status === "failed" || dispatchResult.status === "timeout") return {
+			result: "failed",
+			error: `Dispatch status: ${dispatchResult.status}. ${dispatchResult.parseError ?? ""}`.trim(),
+			tokenUsage: totalTokens
+		};
+		const parsed = AcceptanceJudgeResultSchema.safeParse(dispatchResult.parsed);
+		if (!parsed.success) {
+			if (process.env.SUBSTRATE_DEBUG === "acceptance-judge") process.stderr.write(`[judge-debug] status=${dispatchResult.status} exit=${String(dispatchResult.exitCode)} parseError=${String(dispatchResult.parseError)} outputLen=${String(dispatchResult.output?.length ?? 0)}\n[judge-debug] output-tail: ${(dispatchResult.output ?? "").slice(-800)}\n`);
+			lastProblem = `output failed schema validation (${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ").slice(0, 500)})`;
+			logger.warn({
+				journeyId: journey.id,
+				storyKey,
+				attempt,
+				lastProblem
+			}, "A2.1: judge output invalid");
+			continue;
+		}
+		if (parsed.data.result === "failed") return {
+			result: "failed",
+			error: "acceptance-judge-refused",
+			details: parsed.data.error ?? "judge reported failure without a reason",
+			tokenUsage: totalTokens
+		};
+		const coverageProblem = validateVerdictCoverage(journey, parsed.data.verdicts);
+		if (coverageProblem !== void 0) {
+			lastProblem = coverageProblem;
+			logger.warn({
+				journeyId: journey.id,
+				storyKey,
+				attempt,
+				coverageProblem
+			}, "A2.1: judge verdicts incomplete");
+			continue;
+		}
+		const groundingWarning = validateEvidenceGrounding(parsed.data.verdicts, artifactContentMap);
+		if (groundingWarning !== void 0) logger.warn({
+			journeyId: journey.id,
+			storyKey,
+			groundingWarning
+		}, "A5.1 F7: judge PASS citation weakly grounded (advisory — not blocking)");
+		logger.info({
+			journeyId: journey.id,
+			storyKey,
+			verdicts: parsed.data.verdicts.map((v) => `${v.end_state_id}=${v.verdict}`)
+		}, "A2.1: acceptance judge verdicts accepted");
+		return {
+			result: "success",
+			verdicts: parsed.data.verdicts,
+			tokenUsage: totalTokens
+		};
+	}
+	return {
+		result: "failed",
+		error: "acceptance-judge-invalid",
+		details: `judge produced invalid output twice — last problem: ${lastProblem}`,
+		tokenUsage: totalTokens
+	};
+}
+
+//#endregion
+export { CodeReviewResultSchema, CreateStoryResultSchema, DevStoryResultSchema, ProbeAuthorResultSchema, TestExpansionResultSchema, TestPlanResultSchema, assemblePrompt, countTokens, getTokenCeiling, runAcceptanceJudge, truncateToTokens, validateEvidenceGrounding, validateVerdictCoverage };
+//# sourceMappingURL=acceptance-judge-eIZZha1C.js.map