@oisincoveney/pipeline 1.29.3 → 2.0.0

package/README.md

@@ -189,7 +189,7 @@ Package-owned defaults declare:
 - the singleton `pipeline-gateway` MCP connection
 - workflows, schedules, hooks, gates, artifacts, retries, and timeouts
 - generated OpenCode host resources
-- goal-loop contracts and continuation context
+- internal goal-state artifacts and goal-loop continuation context
 
 Current default entrypoints:
 

package/docs/config-architecture.md

@@ -3,7 +3,8 @@
 The v1 runtime pipeline is package-owned config. Package-owned defaults declare
 runner adapters, profiles, MCP gateway backends, the orchestrator profile,
 entrypoints, schedules, hooks, workflows, gates, artifacts, OpenCode host
-resources, and goal-loop contracts. OpenCode is the package runtime.
+resources, and internal goal-loop continuation behavior. OpenCode is the package
+runtime.
 
 Runtime code does not read `.pipeline/config.toml`, phase profiles, or hardcoded
 prompt constants.

package/package.json

@@ -86,14 +86,6 @@
       "types": "./dist/runner-command-contract.d.ts",
       "import": "./dist/runner-command-contract.js"
     },
-    "./runtime/goal-loop": {
-      "types": "./dist/runtime/goal-loop.d.ts",
-      "import": "./dist/runtime/goal-loop.js"
-    },
-    "./runtime/goal-state": {
-      "types": "./dist/runtime/goal-state.d.ts",
-      "import": "./dist/runtime/goal-state.js"
-    },
     "./runtime": {
       "types": "./dist/pipeline-runtime.d.ts",
       "import": "./dist/pipeline-runtime.js"
@@ -123,7 +115,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "1.29.3",
+  "version": "2.0.0",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/runtime/goal-loop/continuation-prompt.js

@@ -1,125 +0,0 @@
-import { goalStateNextRequirement } from "../goal-state/goal-requirement.js";
-//#region src/runtime/goal-loop/continuation-prompt.ts
-function renderContinuationPrompt(input) {
-	const currentNode = currentScheduleNode(input.state, input.currentNodeId);
-	const failedGates = input.state.gateFailures.filter((gate) => !gate.passed);
-	return compactLines([
-		"# Pipeline Continuation",
-		"",
-		"## Original Task",
-		input.state.task.original,
-		"",
-		"## Task Refs",
-		...taskRefLines(input.state.task.context),
-		"",
-		"## Schedule",
-		...scheduleLines(input.state),
-		"",
-		"## Current Schedule Node Context",
-		...nodeContextLines(currentNode),
-		"",
-		"## Failed Gates",
-		...failedGateLines(failedGates),
-		"",
-		"## Verifier Evidence",
-		...verifierLines(input.state),
-		"",
-		"## Acceptance Evidence",
-		...acceptanceLines(input.state),
-		"",
-		"## Changed Files Summary",
-		...changedFileLines(input.state),
-		"",
-		"## Prior Attempts",
-		...priorAttemptLines(input.state),
-		"",
-		"## Exact Next Requirement",
-		input.exactNextRequirement ?? exactNextRequirement(input.state),
-		"",
-		"## Discipline",
-		"- Continue from the persisted goal state; do not restart the task.",
-		"- Address the failed evidence directly and preserve completed work.",
-		"- Run the real verification path needed to prove the fix.",
-		"- Stop and report blocked if the same failure repeats without new files or evidence."
-	]);
-}
-function exactNextRequirement(state) {
-	return goalStateNextRequirement(state);
-}
-function currentScheduleNode(state, requestedNodeId) {
-	if (requestedNodeId && state.nodes[requestedNodeId]) return state.nodes[requestedNodeId];
-	return [...Object.values(state.nodes)].reverse().find((node) => node.status === "failed") ?? Object.values(state.nodes).at(-1);
-}
-function taskRefLines(context) {
-	if (!isRecord(context)) return ["- No task context recorded."];
-	return [
-		lineFor("id", context.id),
-		lineFor("title", context.title),
-		lineFor("description", context.description),
-		...acceptanceCriteriaRefLines(context.acceptanceCriteria)
-	].filter(Boolean);
-}
-function acceptanceCriteriaRefLines(value) {
-	if (!Array.isArray(value) || value.length === 0) return [];
-	return ["- acceptance_criteria:", ...value.flatMap((item) => {
-		if (!isRecord(item)) return [];
-		return [`  - ${String(item.id ?? "?")}: ${String(item.text ?? "")}`];
-	})];
-}
-function scheduleLines(state) {
-	return [
-		`- workflow_id: ${state.workflowId}`,
-		state.runId ? `- run_id: ${state.runId}` : "",
-		state.schedule?.id ? `- schedule_id: ${state.schedule.id}` : "",
-		state.schedule?.path ? `- schedule_path: ${state.schedule.path}` : ""
-	].filter(Boolean);
-}
-function nodeContextLines(node) {
-	if (!node) return ["- No schedule node has run yet."];
-	return [
-		`- node_id: ${node.nodeId}`,
-		`- status: ${node.status}`,
-		`- attempts: ${node.attempts}`,
-		node.profile ? `- profile: ${node.profile}` : "",
-		node.runnerId ? `- runner: ${node.runnerId}` : "",
-		node.changedFiles.length ? `- node_changed_files: ${node.changedFiles.join(", ")}` : "",
-		...node.gates.map((gate) => `- gate ${gate.gateId}: ${gate.passed ? "PASS" : "FAIL"}${gate.reason ? ` (${gate.reason})` : ""}`)
-	].filter(Boolean);
-}
-function failedGateLines(gates) {
-	if (gates.length === 0) return ["- No failed gates recorded."];
-	return gates.flatMap((gate) => [`- ${gate.nodeId}/${gate.gateId}: ${gate.reason ?? "failed"}`, ...gate.evidence.map((item) => `  evidence: ${item}`)]);
-}
-function verifierLines(state) {
-	const verifier = state.verifier;
-	if (!verifier.verdict && verifier.evidence.length === 0) return ["- No verifier evidence recorded."];
-	return [
-		verifier.nodeId ? `- node_id: ${verifier.nodeId}` : "",
-		verifier.verdict ? `- verdict: ${verifier.verdict}` : "",
-		verifier.reason ? `- reason: ${verifier.reason}` : "",
-		...verifier.evidence.map((item) => `- evidence: ${item}`)
-	].filter(Boolean);
-}
-function acceptanceLines(state) {
-	if (state.acceptance.length === 0) return ["- No acceptance evidence recorded."];
-	return state.acceptance.flatMap((item) => [`- ${item.id}: ${item.verdict}`, ...item.evidence.map((evidence) => `  evidence: ${evidence}`)]);
-}
-function changedFileLines(state) {
-	if (state.changedFiles.length === 0) return ["- No changed files recorded."];
-	return state.changedFiles.map((file) => `- ${file}`);
-}
-function priorAttemptLines(state) {
-	if (state.continuationAttempts.length === 0) return ["- No prior continuation attempts."];
-	return state.continuationAttempts.map((attempt) => `- #${attempt.attempt}: ${attempt.reason}${attempt.promptPath ? ` (${attempt.promptPath})` : ""}`);
-}
-function lineFor(label, value) {
-	return typeof value === "string" && value.length > 0 ? `- ${label}: ${value}` : "";
-}
-function compactLines(lines) {
-	return `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trim()}\n`;
-}
-function isRecord(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-//#endregion
-export { exactNextRequirement, renderContinuationPrompt };

package/dist/runtime/goal-loop.d.ts

@@ -1,37 +0,0 @@
-import { PipelineConfig } from "../config/schemas.js";
-import { RunnerLaunchPlan } from "../runner.js";
-import { PipelineGoalState } from "./goal-state.js";
-
-//#region src/runtime/goal-loop/goal-loop.d.ts
-type GoalLoopTerminalState = "blocked" | "cancelled" | "max_continuations_reached" | "no_progress_detected" | "passed";
-interface GoalLoopContinuationInput {
-  attempt: number;
-  prompt: string;
-  promptPath?: string;
-  state: PipelineGoalState;
-}
-interface GoalLoopOptions {
-  initialState: PipelineGoalState;
-  maxContinuations: number;
-  now?: () => Date;
-  runContinuation: (input: GoalLoopContinuationInput) => PipelineGoalState | Promise<PipelineGoalState>;
-  shouldCancel?: () => boolean;
-  writePrompt?: (attempt: number, prompt: string, state: PipelineGoalState) => string | Promise<string>;
-}
-interface GoalLoopResult {
-  attempts: number;
-  prompts: string[];
-  reason: string;
-  state: PipelineGoalState;
-  terminalState: GoalLoopTerminalState;
-}
-declare function runBoundedGoalLoop(options: GoalLoopOptions): Promise<GoalLoopResult>;
-declare function createGoalContinuationLaunchPlan(input: {
-  config: PipelineConfig;
-  nodeId?: string;
-  profileId?: string;
-  prompt: string;
-  worktreePath: string;
-}): RunnerLaunchPlan;
-//#endregion
-export { GoalLoopContinuationInput, GoalLoopOptions, GoalLoopResult, GoalLoopTerminalState, createGoalContinuationLaunchPlan, runBoundedGoalLoop };

package/dist/runtime/goal-loop.js

@@ -1,138 +0,0 @@
-import { createRunnerLaunchPlan } from "../runner.js";
-import { goalStateCompletionEvidence, goalStateFailureSignature, markGoalStateBlocked, recordGoalStateContinuationAttempt } from "./goal-state.js";
-import { exactNextRequirement, renderContinuationPrompt } from "./goal-loop/continuation-prompt.js";
-//#region src/runtime/goal-loop/goal-loop.ts
-async function runBoundedGoalLoop(options) {
-	if (!Number.isInteger(options.maxContinuations) || options.maxContinuations < 0) throw new Error("maxContinuations must be a non-negative integer");
-	let state = options.initialState;
-	const prompts = [];
-	for (;;) {
-		const terminal = terminalResult(state, prompts, options.shouldCancel);
-		if (terminal) return terminal;
-		const maxContinuations = maxContinuationsResult(state, prompts, options);
-		if (maxContinuations) return maxContinuations;
-		const beforeProgress = progressSignature(state);
-		const nextState = await runGoalContinuation(options, state, prompts);
-		const postContinuation = postContinuationResult(nextState, beforeProgress, prompts, options.shouldCancel);
-		if (postContinuation) return postContinuation;
-		state = nextState;
-	}
-}
-function maxContinuationsResult(state, prompts, options) {
-	return state.continuationAttempts.length >= options.maxContinuations ? {
-		attempts: state.continuationAttempts.length,
-		prompts,
-		reason: `maximum continuations reached: ${options.maxContinuations}`,
-		state,
-		terminalState: "max_continuations_reached"
-	} : null;
-}
-async function runGoalContinuation(options, state, prompts) {
-	const attempt = state.continuationAttempts.length + 1;
-	const prompt = renderContinuationPrompt({
-		exactNextRequirement: exactNextRequirement(state),
-		state
-	});
-	const promptPath = await options.writePrompt?.(attempt, prompt, state);
-	prompts.push(prompt);
-	return options.runContinuation({
-		attempt,
-		prompt,
-		...promptPath ? { promptPath } : {},
-		state: stateWithContinuationAttempt(state, promptPath)
-	});
-}
-function stateWithContinuationAttempt(state, promptPath) {
-	return recordGoalStateContinuationAttempt(state, {
-		...promptPath ? { promptPath } : {},
-		reason: continuationReason(state),
-		...state.verifier.nodeId ? { verifierNodeId: state.verifier.nodeId } : {}
-	});
-}
-function postContinuationResult(nextState, beforeProgress, prompts, shouldCancel) {
-	const terminal = terminalResult(nextState, prompts, shouldCancel);
-	if (terminal) return terminal;
-	return isNoProgress(beforeProgress, progressSignature(nextState)) ? noProgressResult(nextState, prompts) : null;
-}
-function noProgressResult(state, prompts) {
-	const reason = "same failure repeated without new changed files or evidence";
-	return {
-		attempts: state.continuationAttempts.length,
-		prompts,
-		reason,
-		state: markGoalStateBlocked(state, reason),
-		terminalState: "no_progress_detected"
-	};
-}
-function createGoalContinuationLaunchPlan(input) {
-	return createRunnerLaunchPlan(input.config, {
-		nodeId: input.nodeId ?? "goal-continuation",
-		profileId: input.profileId ?? "moka-code-writer",
-		prompt: input.prompt,
-		worktreePath: input.worktreePath
-	});
-}
-function terminalResult(state, prompts, shouldCancel) {
-	if (shouldCancel?.()) return {
-		attempts: state.continuationAttempts.length,
-		prompts,
-		reason: "goal loop cancelled",
-		state,
-		terminalState: "cancelled"
-	};
-	switch (state.terminalOutcome) {
-		case "PASS":
-			if (!goalStateCompletionEvidence(state).passed) return {
-				attempts: state.continuationAttempts.length,
-				prompts,
-				reason: "missing deterministic verifier or acceptance evidence",
-				state: markGoalStateBlocked(state, "missing deterministic verifier or acceptance evidence"),
-				terminalState: "blocked"
-			};
-			return {
-				attempts: state.continuationAttempts.length,
-				prompts,
-				reason: "goal passed",
-				state,
-				terminalState: "passed"
-			};
-		case "BLOCKED": return {
-			attempts: state.continuationAttempts.length,
-			prompts,
-			reason: state.blockedReasons.at(-1) ?? "goal blocked",
-			state,
-			terminalState: "blocked"
-		};
-		case "CANCELLED": return {
-			attempts: state.continuationAttempts.length,
-			prompts,
-			reason: "goal cancelled",
-			state,
-			terminalState: "cancelled"
-		};
-		default: return null;
-	}
-}
-function continuationReason(state) {
-	const latestGate = state.gateFailures.at(-1);
-	if (latestGate) return latestGate.reason ?? `failed gate ${latestGate.gateId}`;
-	if (state.verifier.verdict === "FAIL") return state.verifier.reason ?? "verifier requested remediation";
-	return "goal incomplete";
-}
-function progressSignature(state) {
-	const failedAcceptance = state.acceptance.filter((item) => item.verdict === "FAIL");
-	return {
-		changedFiles: state.changedFiles.join("\0"),
-		evidence: [
-			...state.gateFailures.flatMap((gate) => gate.evidence),
-			...state.verifier.evidence,
-			...failedAcceptance.flatMap((item) => item.evidence)
-		].join("\0"),
-		failure: goalStateFailureSignature(state)
-	};
-}
-function isNoProgress(before, after) {
-	return before.failure.length > 0 && before.failure === after.failure && before.changedFiles === after.changedFiles && before.evidence === after.evidence;
-}
-//#endregion
-export { createGoalContinuationLaunchPlan, runBoundedGoalLoop };

package/dist/runtime/goal-state/goal-requirement.js

@@ -1,11 +0,0 @@
-//#region src/runtime/goal-state/goal-requirement.ts
-function goalStateNextRequirement(state) {
-	const failedAcceptance = state.acceptance.filter((item) => item.verdict === "FAIL");
-	if (failedAcceptance.length > 0) return `Satisfy failed acceptance criteria: ${failedAcceptance.map((item) => item.id).join(", ")}.`;
-	if (state.verifier.verdict === "FAIL") return `Satisfy verifier node '${state.verifier.nodeId ?? "verify"}' and return passing evidence.`;
-	const latestGate = state.gateFailures.at(-1);
-	if (latestGate) return `Resolve failed gate '${latestGate.gateId}' on node '${latestGate.nodeId}' and rerun the required verification.`;
-	return "Complete the remaining schedule work and provide passing evidence.";
-}
-//#endregion
-export { goalStateNextRequirement };

package/dist/runtime/goal-state.d.ts

@@ -1,146 +0,0 @@
-import { PipelineRuntimeEvent, PipelineTaskContext } from "./contracts/contracts.js";
-import { z } from "zod";
-
-//#region src/runtime/goal-state/goal-state.d.ts
-declare const pipelineGoalStateSchema: z.ZodObject<{
-  acceptance: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    id: z.ZodString;
-    violations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    verdict: z.ZodEnum<{
-      FAIL: "FAIL";
-      PASS: "PASS";
-    }>;
-  }, z.core.$strict>>>;
-  blockedReasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  changedFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  continuationAttempts: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    attempt: z.ZodNumber;
-    promptPath: z.ZodOptional<z.ZodString>;
-    reason: z.ZodString;
-    verifierNodeId: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>>>;
-  gateFailures: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    gateId: z.ZodString;
-    kind: z.ZodString;
-    nodeId: z.ZodString;
-    passed: z.ZodBoolean;
-    reason: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>>>;
-  nodes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-    attempts: z.ZodNumber;
-    changedFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    exitCode: z.ZodOptional<z.ZodNumber>;
-    gates: z.ZodDefault<z.ZodArray<z.ZodObject<{
-      evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-      gateId: z.ZodString;
-      kind: z.ZodString;
-      nodeId: z.ZodString;
-      passed: z.ZodBoolean;
-      reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    nodeId: z.ZodString;
-    profile: z.ZodOptional<z.ZodString>;
-    runnerId: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-      passed: "passed";
-      failed: "failed";
-      pending: "pending";
-      running: "running";
-    }>;
-  }, z.core.$strict>>>;
-  runId: z.ZodOptional<z.ZodString>;
-  schedule: z.ZodOptional<z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>>;
-  task: z.ZodObject<{
-    context: z.ZodOptional<z.ZodUnknown>;
-    original: z.ZodString;
-  }, z.core.$strict>;
-  terminalOutcome: z.ZodOptional<z.ZodEnum<{
-    FAIL: "FAIL";
-    PASS: "PASS";
-    BLOCKED: "BLOCKED";
-    CANCELLED: "CANCELLED";
-  }>>;
-  verifier: z.ZodDefault<z.ZodObject<{
-    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    nodeId: z.ZodOptional<z.ZodString>;
-    reason: z.ZodOptional<z.ZodString>;
-    violations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    verdict: z.ZodOptional<z.ZodEnum<{
-      FAIL: "FAIL";
-      PASS: "PASS";
-    }>>;
-  }, z.core.$strict>>;
-  version: z.ZodLiteral<1>;
-  workflowId: z.ZodString;
-}, z.core.$strict>;
-type PipelineGoalState = z.infer<typeof pipelineGoalStateSchema>;
-interface CreateGoalStateOptions {
-  runId?: string;
-  scheduleId?: string;
-  schedulePath?: string;
-  task: string;
-  taskContext?: PipelineTaskContext;
-  workflowId: string;
-}
-declare function createGoalState(options: CreateGoalStateOptions): PipelineGoalState;
-declare function parseGoalState(value: unknown): PipelineGoalState;
-declare function applyGoalStateEvent(state: PipelineGoalState, event: PipelineRuntimeEvent): PipelineGoalState;
-declare function reconstructGoalStateFromEvents(options: CreateGoalStateOptions, events: PipelineRuntimeEvent[]): PipelineGoalState;
-declare function recordGoalStateChangedFiles(state: PipelineGoalState, nodeId: string, files: string[]): PipelineGoalState;
-declare function recordGoalStateContinuationAttempt(state: PipelineGoalState, attempt: {
-  promptPath?: string;
-  reason: string;
-  verifierNodeId?: string;
-}): PipelineGoalState;
-declare function markGoalStateBlocked(state: PipelineGoalState, reason: string): PipelineGoalState;
-declare function goalStateCompletionEvidence(state: PipelineGoalState): {
-  evidence: string[];
-  passed: boolean;
-};
-declare function goalStateContinuationInput(state: PipelineGoalState): {
-  acceptance: {
-    evidence: string[];
-    id: string;
-    verdict: "FAIL" | "PASS";
-    violations?: string[] | undefined;
-  }[];
-  changedFiles: string[];
-  currentNodeId: string | undefined;
-  exactNextRequirement: string;
-  failedGates: {
-    evidence: string[];
-    gateId: string;
-    kind: string;
-    nodeId: string;
-    passed: boolean;
-    reason?: string | undefined;
-  }[];
-  failureSignature: string;
-  originalTask: string;
-  priorAttempts: {
-    attempt: number;
-    reason: string;
-    promptPath?: string | undefined;
-    verifierNodeId?: string | undefined;
-  }[];
-  taskContext: unknown;
-  verifier: {
-    evidence: string[];
-    nodeId?: string | undefined;
-    reason?: string | undefined;
-    violations?: string[] | undefined;
-    verdict?: "FAIL" | "PASS" | undefined;
-  };
-};
-declare function goalStateFailureSignature(state: PipelineGoalState): string;
-declare function goalStateArtifactPath(runDirectory: string): string;
-declare function saveGoalState(state: PipelineGoalState, runDirectory: string): void;
-declare function loadGoalState(path: string): PipelineGoalState;
-declare function loadGoalStateFromRunDirectory(runDirectory: string): PipelineGoalState;
-//#endregion
-export { CreateGoalStateOptions, PipelineGoalState, applyGoalStateEvent, createGoalState, goalStateArtifactPath, goalStateCompletionEvidence, goalStateContinuationInput, goalStateFailureSignature, loadGoalState, loadGoalStateFromRunDirectory, markGoalStateBlocked, parseGoalState, pipelineGoalStateSchema, reconstructGoalStateFromEvents, recordGoalStateChangedFiles, recordGoalStateContinuationAttempt, saveGoalState };

package/dist/runtime/goal-state.js

@@ -1,339 +0,0 @@
-import { uniqueStrings } from "../strings.js";
-import { goalStateNextRequirement } from "./goal-state/goal-requirement.js";
-import { z } from "zod";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-//#region src/runtime/goal-state/goal-state.ts
-const OUTCOME_VALUES = [
-	"BLOCKED",
-	"CANCELLED",
-	"FAIL",
-	"PASS"
-];
-const NODE_STATUS_VALUES = [
-	"failed",
-	"passed",
-	"pending",
-	"running"
-];
-const VERDICT_VALUES = ["FAIL", "PASS"];
-const MAX_EVIDENCE_ITEMS = 8;
-const MAX_EVIDENCE_LENGTH = 500;
-const evidenceSchema = z.array(z.string().max(MAX_EVIDENCE_LENGTH)).max(32);
-const acceptanceCriterionVerdictSchema = z.object({
-	evidence: evidenceSchema.default([]),
-	id: z.string().min(1),
-	violations: evidenceSchema.optional(),
-	verdict: z.enum(VERDICT_VALUES)
-}).strict();
-const goalGateAttemptSchema = z.object({
-	evidence: evidenceSchema.default([]),
-	gateId: z.string().min(1),
-	kind: z.string().min(1),
-	nodeId: z.string().min(1),
-	passed: z.boolean(),
-	reason: z.string().min(1).optional()
-}).strict();
-const goalNodeStateSchema = z.object({
-	attempts: z.number().int().nonnegative(),
-	changedFiles: z.array(z.string().min(1)).default([]),
-	exitCode: z.number().int().optional(),
-	gates: z.array(goalGateAttemptSchema).default([]),
-	nodeId: z.string().min(1),
-	profile: z.string().min(1).optional(),
-	runnerId: z.string().min(1).optional(),
-	status: z.enum(NODE_STATUS_VALUES)
-}).strict();
-const continuationAttemptSchema = z.object({
-	attempt: z.number().int().positive(),
-	promptPath: z.string().min(1).optional(),
-	reason: z.string().min(1),
-	verifierNodeId: z.string().min(1).optional()
-}).strict();
-const pipelineGoalStateSchema = z.object({
-	acceptance: z.array(acceptanceCriterionVerdictSchema).default([]),
-	blockedReasons: evidenceSchema.default([]),
-	changedFiles: z.array(z.string().min(1)).default([]),
-	continuationAttempts: z.array(continuationAttemptSchema).default([]),
-	gateFailures: z.array(goalGateAttemptSchema).default([]),
-	nodes: z.record(z.string().min(1), goalNodeStateSchema).default({}),
-	runId: z.string().min(1).optional(),
-	schedule: z.object({
-		id: z.string().min(1).optional(),
-		path: z.string().min(1).optional()
-	}).strict().optional(),
-	task: z.object({
-		context: z.unknown().optional(),
-		original: z.string()
-	}).strict(),
-	terminalOutcome: z.enum(OUTCOME_VALUES).optional(),
-	verifier: z.object({
-		evidence: evidenceSchema.default([]),
-		nodeId: z.string().min(1).optional(),
-		reason: z.string().min(1).optional(),
-		violations: evidenceSchema.optional(),
-		verdict: z.enum(VERDICT_VALUES).optional()
-	}).strict().default({ evidence: [] }),
-	version: z.literal(1),
-	workflowId: z.string().min(1)
-}).strict();
-function createGoalState(options) {
-	return parseGoalState({
-		acceptance: [],
-		blockedReasons: [],
-		changedFiles: [],
-		continuationAttempts: [],
-		gateFailures: [],
-		nodes: {},
-		...options.runId ? { runId: options.runId } : {},
-		...options.scheduleId || options.schedulePath ? { schedule: {
-			...options.scheduleId ? { id: options.scheduleId } : {},
-			...options.schedulePath ? { path: options.schedulePath } : {}
-		} } : {},
-		task: {
-			...options.taskContext ? { context: options.taskContext } : {},
-			original: options.task
-		},
-		verifier: {},
-		version: 1,
-		workflowId: options.workflowId
-	});
-}
-function parseGoalState(value) {
-	return pipelineGoalStateSchema.parse(value);
-}
-function applyGoalStateEvent(state, event) {
-	const next = cloneGoalState(state);
-	switch (event.type) {
-		case "workflow.planned":
-			for (const node of event.nodes) upsertNode(next, node.id, {
-				profile: node.profile,
-				runnerId: node.runnerId,
-				status: "pending"
-			});
-			break;
-		case "node.start":
-		case "agent.start":
-			upsertNode(next, event.nodeId, {
-				attempts: event.attempt,
-				profile: event.profile,
-				runnerId: event.runnerId,
-				status: "running"
-			});
-			break;
-		case "node.finish":
-			upsertNode(next, event.nodeId, {
-				attempts: event.attempt,
-				exitCode: event.exitCode,
-				profile: event.profile,
-				runnerId: event.runnerId,
-				status: event.status === "passed" ? "passed" : "failed"
-			});
-			break;
-		case "gate.finish":
-			recordGateAttempt(next, {
-				evidence: safeEvidence(event.evidence),
-				gateId: event.gateId,
-				kind: event.kind,
-				nodeId: event.nodeId,
-				passed: event.passed,
-				...event.reason ? { reason: event.reason } : {}
-			});
-			break;
-		case "node.output.recorded":
-			recordStructuredVerdicts(next, event);
-			break;
-		case "workflow.finish":
-			next.terminalOutcome = event.outcome;
-			break;
-		default: break;
-	}
-	return parseGoalState(next);
-}
-function reconstructGoalStateFromEvents(options, events) {
-	return events.reduce(applyGoalStateEvent, createGoalState(options));
-}
-function recordGoalStateChangedFiles(state, nodeId, files) {
-	const next = cloneGoalState(state);
-	const uniqueFiles = uniqueChangedFiles(files);
-	upsertNode(next, nodeId, { changedFiles: uniqueFiles });
-	next.changedFiles = uniqueChangedFiles([...next.changedFiles, ...uniqueFiles]);
-	return parseGoalState(next);
-}
-function recordGoalStateContinuationAttempt(state, attempt) {
-	const next = cloneGoalState(state);
-	next.continuationAttempts.push({
-		attempt: next.continuationAttempts.length + 1,
-		...attempt.promptPath ? { promptPath: attempt.promptPath } : {},
-		reason: attempt.reason,
-		...attempt.verifierNodeId ? { verifierNodeId: attempt.verifierNodeId } : {}
-	});
-	return parseGoalState(next);
-}
-function markGoalStateBlocked(state, reason) {
-	const next = cloneGoalState(state);
-	next.blockedReasons = safeEvidence([...next.blockedReasons, reason]);
-	next.terminalOutcome = "BLOCKED";
-	return parseGoalState(next);
-}
-function goalStateCompletionEvidence(state) {
-	const evidence = [];
-	const verifierPassed = state.verifier.verdict === "PASS" && state.verifier.evidence.length > 0 && (state.verifier.violations?.length ?? 0) === 0;
-	evidence.push(verifierPassed ? `verifier '${state.verifier.nodeId ?? "verify"}' passed with evidence` : "missing passing verifier evidence");
-	for (const item of acceptanceCompletionEvidence(state)) evidence.push(item);
-	return {
-		evidence,
-		passed: verifierPassed && evidence.every((item) => !item.startsWith("missing ")) && evidence.every((item) => !item.includes(" failed")) && evidence.every((item) => !item.includes(" violations"))
-	};
-}
-function goalStateContinuationInput(state) {
-	return {
-		acceptance: state.acceptance,
-		changedFiles: state.changedFiles,
-		currentNodeId: currentFailedNodeId(state),
-		exactNextRequirement: goalStateNextRequirement(state),
-		failedGates: state.gateFailures.filter((gate) => !gate.passed),
-		failureSignature: goalStateFailureSignature(state),
-		originalTask: state.task.original,
-		priorAttempts: state.continuationAttempts,
-		taskContext: state.task.context,
-		verifier: state.verifier
-	};
-}
-function goalStateFailureSignature(state) {
-	return [
-		...state.gateFailures.map((gate) => [
-			gate.nodeId,
-			gate.gateId,
-			gate.reason ?? "",
-			...gate.evidence
-		].join("/")),
-		state.verifier.verdict === "FAIL" ? [
-			state.verifier.nodeId ?? "verify",
-			state.verifier.reason ?? "",
-			...state.verifier.evidence,
-			...state.verifier.violations ?? []
-		].join("/") : "",
-		...state.acceptance.filter((item) => item.verdict === "FAIL").map((item) => [
-			"acceptance",
-			item.id,
-			...item.evidence,
-			...item.violations ?? []
-		].filter(Boolean).join("/"))
-	].filter(Boolean).join("\0");
-}
-function goalStateArtifactPath(runDirectory) {
-	return join(runDirectory, "goal-state.json");
-}
-function saveGoalState(state, runDirectory) {
-	writeFileSync(goalStateArtifactPath(runDirectory), `${JSON.stringify(parseGoalState(state), null, 2)}\n`);
-}
-function loadGoalState(path) {
-	return parseGoalState(JSON.parse(readFileSync(path, "utf8")));
-}
-function loadGoalStateFromRunDirectory(runDirectory) {
-	const path = goalStateArtifactPath(runDirectory);
-	if (!existsSync(path)) throw new Error(`goal state artifact not found: ${path}`);
-	return loadGoalState(path);
-}
-function recordGateAttempt(state, gate) {
-	upsertNode(state, gate.nodeId, {});
-	state.nodes[gate.nodeId].gates.push(gate);
-	if (!gate.passed) {
-		state.gateFailures.push(gate);
-		if (isVerifierGate(gate)) state.verifier = {
-			evidence: safeEvidence([...state.verifier.evidence, ...gate.evidence]),
-			nodeId: gate.nodeId,
-			...gate.reason ? { reason: gate.reason } : {},
-			...state.verifier.violations ? { violations: state.verifier.violations } : {},
-			verdict: "FAIL"
-		};
-	}
-}
-function recordStructuredVerdicts(state, event) {
-	const output = event.output;
-	if (!isRecord(output)) return;
-	const acceptance = output.acceptance;
-	if (Array.isArray(acceptance)) state.acceptance = acceptance.flatMap((item) => {
-		if (!(isRecord(item) && isVerdict(item.verdict)) || typeof item.id !== "string") return [];
-		return [{
-			evidence: safeEvidence(Array.isArray(item.evidence) ? item.evidence : []),
-			id: item.id,
-			...optionalEvidence("violations", item.violations),
-			verdict: item.verdict
-		}];
-	});
-	if (isVerifierNode(event) && isVerdict(output.verdict)) state.verifier = {
-		evidence: safeEvidence(Array.isArray(output.evidence) ? output.evidence : []),
-		nodeId: event.nodeId,
-		...optionalEvidence("violations", output.violations),
-		verdict: output.verdict
-	};
-}
-function upsertNode(state, nodeId, patch) {
-	const current = state.nodes[nodeId] ?? {
-		attempts: 0,
-		changedFiles: [],
-		gates: [],
-		nodeId,
-		status: "pending"
-	};
-	state.nodes[nodeId] = {
-		...current,
-		...patch,
-		attempts: Math.max(current.attempts, patch.attempts ?? 0),
-		changedFiles: uniqueChangedFiles([...current.changedFiles, ...patch.changedFiles ?? []]),
-		gates: patch.gates ?? current.gates,
-		nodeId
-	};
-}
-function isVerifierGate(gate) {
-	return gate.kind === "verdict" || gate.nodeId.includes("verif");
-}
-function isVerifierNode(event) {
-	return event.nodeId.includes("verif") || Boolean(event.profile?.includes("verif")) || Boolean(event.schemaPath?.includes("verify"));
-}
-function isVerdict(value) {
-	return value === "PASS" || value === "FAIL";
-}
-function safeEvidence(value) {
-	return (value ?? []).flatMap((item) => typeof item === "string" ? [item] : []).slice(0, MAX_EVIDENCE_ITEMS).map((item) => item.slice(0, MAX_EVIDENCE_LENGTH));
-}
-function optionalEvidence(key, value) {
-	const evidence = Array.isArray(value) ? safeEvidence(value) : [];
-	return evidence.length > 0 ? { [key]: evidence } : {};
-}
-function acceptanceCompletionEvidence(state) {
-	const expected = expectedAcceptanceIds(state.task.context);
-	if (expected.length === 0) return ["acceptance criteria not required by task context"];
-	const byId = new Map(state.acceptance.map((item) => [item.id, item]));
-	return expected.map((id) => {
-		const item = byId.get(id);
-		if (!item) return `missing acceptance criterion '${id}' evidence`;
-		if (item.verdict !== "PASS") return `acceptance criterion '${id}' failed`;
-		if (item.evidence.length === 0) return `missing acceptance criterion '${id}' evidence`;
-		if ((item.violations?.length ?? 0) > 0) return `acceptance criterion '${id}' has violations`;
-		return `acceptance criterion '${id}' passed with evidence`;
-	});
-}
-function expectedAcceptanceIds(context) {
-	if (!(isRecord(context) && Array.isArray(context.acceptanceCriteria))) return [];
-	return context.acceptanceCriteria.flatMap((item) => isRecord(item) && typeof item.id === "string" ? [item.id] : []);
-}
-function currentFailedNodeId(state) {
-	return Object.values(state.nodes).filter((node) => node.status === "failed").at(-1)?.nodeId;
-}
-function uniqueChangedFiles(values) {
-	return uniqueStrings(values, {
-		filterEmpty: true,
-		sort: true
-	});
-}
-function cloneGoalState(state) {
-	return JSON.parse(JSON.stringify(state));
-}
-function isRecord(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-//#endregion
-export { applyGoalStateEvent, createGoalState, goalStateArtifactPath, goalStateCompletionEvidence, goalStateContinuationInput, goalStateFailureSignature, loadGoalState, loadGoalStateFromRunDirectory, markGoalStateBlocked, parseGoalState, pipelineGoalStateSchema, reconstructGoalStateFromEvents, recordGoalStateChangedFiles, recordGoalStateContinuationAttempt, saveGoalState };