@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/runtime/events/index.js

@@ -1,2 +1,2 @@
-import { childReporter, createPublicRuntimeObservabilityEmitter, emit, emitAgentFinish, emitAgentStart, emitGateFinish, emitGateStart, emitNodeFinish, emitNodeOutputRecorded, emitNodeStart, emitWorkflowFinish, emitWorkflowPlanned, emitWorkflowStarted, runtimeNodeActorDescriptor, runtimeSystemId } from "./events.js";
-export { childReporter, createPublicRuntimeObservabilityEmitter, emit, emitAgentFinish, emitAgentStart, emitGateFinish, emitGateStart, emitNodeFinish, emitNodeOutputRecorded, emitNodeStart, emitWorkflowFinish, emitWorkflowPlanned, emitWorkflowStarted, runtimeNodeActorDescriptor, runtimeSystemId };
+import { agentFinishEvent, agentStartEvent, childReporter, createPublicRuntimeObservabilityEmitter, emit, emitAgentFinish, emitAgentStart, emitGateFinish, emitGateStart, emitNodeFinish, emitNodeOutputRecorded, emitNodeStart, emitWorkflowFinish, emitWorkflowPlanned, emitWorkflowStarted, runtimeNodeActorDescriptor, runtimeSystemId } from "./events.js";
+export { agentFinishEvent, agentStartEvent, childReporter, createPublicRuntimeObservabilityEmitter, emit, emitAgentFinish, emitAgentStart, emitGateFinish, emitGateStart, emitNodeFinish, emitNodeOutputRecorded, emitNodeStart, emitWorkflowFinish, emitWorkflowPlanned, emitWorkflowStarted, runtimeNodeActorDescriptor, runtimeSystemId };

package/dist/runtime/execution-envelope.js

@@ -0,0 +1,44 @@
+import { nonNegativeInteger, parseStrictWithSchema, positiveInteger, requiredString, struct } from "../schema-boundary.js";
+//#region src/runtime/execution-envelope.ts
+/**
+* ENG-57.6: the Engine-owned execution envelope that wraps — never modifies —
+* the yeet `Event`. yeet owns the runtime `Event` wire type (`@oisin-ee/yeet-api`)
+* and must not learn about Engine scheduling; the Engine owns the two identity
+* axes that name WHICH execution produced an event:
+*
+*  - `generation`: the semantic-execution counter (a coordinator-decided node
+*    retry increments it; it is baked into the Job identity/name).
+*  - `attempt`: the Kubernetes crash-retry index WITHIN one generation (a Job's
+*    `backoffLimit` re-runs the same execution's pod; each pod is a new attempt).
+*
+* Carrying both on every event is what makes a crash retry (same generation,
+* higher attempt) distinguishable from a semantic node retry (higher
+* generation) — see {@link classifyRetry}. The wrapped `event` is generic and
+* opaque: the envelope validates only its own meta, so the yeet Event stays a
+* verbatim, unchanged passthrough.
+*/
+const executionEnvelopeMetaSchema = struct({
+	attempt: positiveInteger,
+	generation: nonNegativeInteger,
+	nodeId: requiredString,
+	runId: requiredString
+});
+/** Validate untrusted envelope meta at a boundary (rejects attempt < 1, negative generation). */
+const parseExecutionEnvelopeMeta = (input) => parseStrictWithSchema(executionEnvelopeMetaSchema, input);
+/**
+* Wrap a runtime/yeet event in its execution envelope. The event is carried by
+* reference, unchanged; only the Engine-owned identity axes are added around it.
+*/
+const wrapExecutionEvent = (identity, attempt, event) => {
+	return {
+		...parseExecutionEnvelopeMeta({
+			attempt,
+			generation: identity.generation,
+			nodeId: identity.nodeId,
+			runId: identity.runId
+		}),
+		event
+	};
+};
+//#endregion
+export { executionEnvelopeMetaSchema, parseExecutionEnvelopeMeta, wrapExecutionEvent };

package/dist/runtime/gates/adjudication/llm-judge.js

@@ -1,3 +1,4 @@
+import { Option } from "effect";
 //#region src/runtime/gates/adjudication/llm-judge.ts
 const HONOR_POLICIES = [
 	{
@@ -14,27 +15,13 @@ const HONOR_POLICIES = [
 	}
 ];
 const TRIVIAL_REFUSAL = "trivial completion claim refused without consulting llm-judge: no non-blank claimed evidence";
-/**
-* Adjudicates the residual acceptance criteria — the un-encodable residue the
-* deterministic and structured-claim layers could not settle — against the
-* agent's {@link CompletionClaim}, anchored to deterministic evidence. Returns
-* one {@link UnmetCriterion} for every residue criterion that is refused for
-* trivial input, fails anchoring, or the judge marks unsatisfied. Honored
-* criteria are omitted. Pure given the injected `judge`.
-*/
-function llmJudgeUnmet(residue, claim, deterministicEvidence, judge) {
-	return residue.flatMap((criterion) => {
-		const failure = adjudicateCriterion(criterion, claimedEvidenceFor(criterion, claim), deterministicEvidence, judge);
-		return failure ? [failure] : [];
-	});
-}
-function adjudicateCriterion(criterion, claimedEvidence, deterministicEvidence, judge) {
+const adjudicateCriterion = (criterion, claimedEvidence, deterministicEvidence, judge) => {
 	const meaningful = claimedEvidence.filter((item) => item.trim().length > 0);
-	if (meaningful.length === 0) return {
+	if (meaningful.length === 0) return Option.some({
 		criterion: criterion.id,
 		evidence: claimedEvidence,
 		reason: TRIVIAL_REFUSAL
-	};
+	});
 	const verdict = judge({
 		claimedEvidence: meaningful,
 		criterion,
@@ -42,15 +29,25 @@ function adjudicateCriterion(criterion, claimedEvidence, deterministicEvidence,
 	});
 	const anchored = verdict.citedEvidence.filter((item) => deterministicEvidence.includes(item));
 	const broken = HONOR_POLICIES.find((policy) => policy.failed(verdict, anchored));
-	if (!broken) return;
-	return {
+	if (broken === void 0) return Option.none();
+	return Option.some({
 		criterion: criterion.id,
 		evidence: verdict.citedEvidence.length > 0 ? verdict.citedEvidence : meaningful,
 		reason: broken.reason
-	};
-}
-function claimedEvidenceFor(criterion, claim) {
-	return claim.criteria.find((entry) => entry.criterion === criterion.id)?.evidence ?? [];
-}
+	});
+};
+const claimedEvidenceFor = (criterion, claim) => claim.criteria.find((entry) => entry.criterion === criterion.id)?.evidence ?? [];
+/**
+* Adjudicates the residual acceptance criteria — the un-encodable residue the
+* deterministic and structured-claim layers could not settle — against the
+* agent's {@link CompletionClaim}, anchored to deterministic evidence. Returns
+* one {@link UnmetCriterion} for every residue criterion that is refused for
+* trivial input, fails anchoring, or the judge marks unsatisfied. Honored
+* criteria are omitted. Pure given the injected `judge`.
+*/
+const llmJudgeUnmet = (residue, claim, deterministicEvidence, judge) => residue.flatMap((criterion) => {
+	const failure = adjudicateCriterion(criterion, claimedEvidenceFor(criterion, claim), deterministicEvidence, judge);
+	return Option.isSome(failure) ? [failure.value] : [];
+});
 //#endregion
 export { llmJudgeUnmet };

package/dist/runtime/gates/adjudication/structured-claim.js

@@ -1,3 +1,4 @@
+import { Option } from "effect";
 //#region src/runtime/gates/adjudication/structured-claim.ts
 /**
 * Ordered completeness rules. Each rule is independently testable;
@@ -7,27 +8,27 @@
 const COMPLETENESS_RULES = [
 	{
 		reason: (id) => `no claim entry for criterion '${id}'`,
-		test: (entry) => entry === void 0
+		test: Option.isNone
 	},
 	{
 		reason: (id) => `empty evidence for criterion '${id}'`,
-		test: (entry) => entry !== void 0 && entry.evidence.length === 0
+		test: (entry) => Option.isSome(entry) && entry.value.evidence.length === 0
 	},
 	{
 		reason: (id) => `blank evidence for criterion '${id}'`,
-		test: (entry) => entry !== void 0 && entry.evidence.length > 0 && entry.evidence.every((s) => !s.trim())
+		test: (entry) => Option.isSome(entry) && entry.value.evidence.length > 0 && entry.value.evidence.every((s) => s.trim().length === 0)
 	}
 ];
-function criterionUnmet(criterion, claim) {
-	const entry = claim.criteria.find((e) => e.criterion === criterion.id);
+const criterionUnmet = (criterion, claim) => {
+	const entry = Option.fromUndefinedOr(claim.criteria.find((e) => e.criterion === criterion.id));
 	const rule = COMPLETENESS_RULES.find((r) => r.test(entry));
-	if (rule === void 0) return null;
-	return {
+	if (rule === void 0) return Option.none();
+	return Option.some({
 		criterion: criterion.id,
-		evidence: entry?.evidence ?? [],
+		evidence: Option.isSome(entry) ? entry.value.evidence : [],
 		reason: rule.reason(criterion.id)
-	};
-}
+	});
+};
 /**
 * Structured-claim adjudication layer (PIPE-90.7): deterministic, pure
 * check below the LLM-judge in the completion pipeline.
@@ -42,11 +43,9 @@ function criterionUnmet(criterion, claim) {
 * entry. Returns an empty array when the claim covers all declared
 * criteria. Pure — no I/O, no LLM, deterministic.
 */
-function structuredClaimUnmet(criteria, claim) {
-	return criteria.flatMap((criterion) => {
-		const unmet = criterionUnmet(criterion, claim);
-		return unmet === null ? [] : [unmet];
-	});
-}
+const structuredClaimUnmet = (criteria, claim) => criteria.flatMap((criterion) => {
+	const unmet = criterionUnmet(criterion, claim);
+	return Option.isSome(unmet) ? [unmet.value] : [];
+});
 //#endregion
 export { structuredClaimUnmet };

package/dist/runtime/gates/adjudicator/adjudicator.js

@@ -1,12 +1,33 @@
 import { evaluateGate } from "../registry.js";
 //#region src/runtime/gates/adjudicator/adjudicator.ts
 /**
+* Maps a failing deterministic gate to its structured refusal. A criterion-aware
+* gate (acceptance) already reports `unmet`; a binary gate (command, artifact,
+* ...) reports only pass/fail, so synthesize one entry per covered criterion —
+* or, when the gate covers nothing, a single entry keyed by the gate id so the
+* failure is never swallowed.
+*/
+const gateUnmet = (gate, result) => {
+	if (result.unmet && result.unmet.length > 0) return result.unmet;
+	const reason = result.reason ?? `deterministic gate '${result.gateId}' failed`;
+	if (gate.covers.length === 0) return [{
+		criterion: result.gateId,
+		evidence: result.evidence,
+		reason
+	}];
+	return gate.covers.map((id) => ({
+		criterion: id,
+		evidence: result.evidence,
+		reason
+	}));
+};
+/**
 * Runs the deterministic layer: every {@link DeterministicGate} through the
 * registry's {@link evaluateGate}. Each gate's `covers` ids are settled
 * (excluded from the residue) whether it passes or fails; passing gates feed the
 * anchor evidence pool, failing gates feed the structured refusal.
 */
-async function runDeterministicLayer(gates) {
+const runDeterministicLayer = async (gates) => {
 	const covered = /* @__PURE__ */ new Set();
 	const evidence = [];
 	const unmet = [];
@@ -21,49 +42,28 @@ async function runDeterministicLayer(gates) {
 		evidence,
 		unmet
 	};
-}
-/**
-* Maps a failing deterministic gate to its structured refusal. A criterion-aware
-* gate (acceptance) already reports `unmet`; a binary gate (command, artifact,
-* ...) reports only pass/fail, so synthesize one entry per covered criterion —
-* or, when the gate covers nothing, a single entry keyed by the gate id so the
-* failure is never swallowed.
-*/
-function gateUnmet(gate, result) {
-	if (result.unmet && result.unmet.length > 0) return result.unmet;
-	const reason = result.reason ?? `deterministic gate '${result.gateId}' failed`;
-	if (gate.covers.length === 0) return [{
-		criterion: result.gateId,
-		evidence: result.evidence,
-		reason
-	}];
-	return gate.covers.map((id) => ({
-		criterion: id,
-		evidence: result.evidence,
-		reason
-	}));
-}
+};
 /**
 * The llm-judge residue: criteria neither settled by a deterministic gate nor
 * already flagged incomplete by the structured-claim layer. Only this residue
 * reaches the judge, keeping it from re-adjudicating settled criteria.
 */
-function residueCriteria(criteria, covered, structured) {
+const residueCriteria = (criteria, covered, structured) => {
 	const structuredIds = new Set(structured.map((entry) => entry.criterion));
 	return criteria.filter((criterion) => !(covered.has(criterion.id) || structuredIds.has(criterion.id)));
-}
+};
 /**
 * Collapses the layer union to one entry per distinct failing criterion id,
 * keeping the earliest (deterministic before structured-claim before llm-judge)
 * — the most authoritative reason for that criterion.
 */
-function dedupeByCriterion(entries) {
+const dedupeByCriterion = (entries) => {
 	const seen = /* @__PURE__ */ new Set();
 	return entries.filter((entry) => {
 		if (seen.has(entry.criterion)) return false;
 		seen.add(entry.criterion);
 		return true;
 	});
-}
+};
 //#endregion
 export { dedupeByCriterion, residueCriteria, runDeterministicLayer };

package/dist/runtime/gates/adjudicator/index.js

@@ -21,7 +21,7 @@ import { dedupeByCriterion, residueCriteria, runDeterministicLayer } from "./adj
 * The union is deduped by criterion id (earliest layer wins) so every distinct
 * failing criterion appears exactly once. `passed` is true iff `unmet` is empty.
 */
-async function adjudicate(input) {
+const adjudicate = async (input) => {
 	const deterministic = await runDeterministicLayer(input.deterministicGates ?? []);
 	const structured = structuredClaimUnmet(input.criteria, input.claim);
 	const judged = llmJudgeUnmet(residueCriteria(input.criteria, deterministic.covered, structured), input.claim, deterministic.evidence, input.judge);
@@ -34,6 +34,6 @@ async function adjudicate(input) {
 		passed: unmet.length === 0,
 		unmet
 	};
-}
+};
 //#endregion
 export { adjudicate };

package/dist/runtime/gates/contract.js

@@ -5,9 +5,7 @@
 * union when `kind` is a type parameter, so this guard carries the narrowing
 * without a type assertion.
 */
-function hasKind(gate, kind) {
-	return gate.kind === kind;
-}
+const hasKind = (gate, kind) => gate.kind === kind;
 /**
 * Binds one gate kind to its narrowly-typed evaluator and adapts it to the
 * uniform {@link GateEvaluator} shape. The {@link hasKind} guard narrows the
@@ -15,11 +13,9 @@ function hasKind(gate, kind) {
 * wired to the wrong key, surfacing the bug instead of silently evaluating the
 * wrong gate.
 */
-function forKind(kind, evaluate) {
-	return (input) => {
-		if (!hasKind(input.gate, kind)) throw new Error(`gate registry mismatch: handler '${kind}' received '${input.gate.kind}'`);
-		return evaluate(input.gate, input);
-	};
-}
+const forKind = (kind, evaluate) => async (input) => {
+	if (!hasKind(input.gate, kind)) throw new Error(`gate registry mismatch: handler '${kind}' received '${input.gate.kind}'`);
+	return await evaluate(input.gate, input);
+};
 //#endregion
 export { forKind };

package/dist/runtime/gates/gates.js

@@ -2,29 +2,30 @@ import { parseJsonResult } from "../../safe-json.js";
 import { readOptionalFile } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { join } from "node:path";
+import { Option } from "effect";
 //#region src/runtime/gates/gates.ts
 /**
 * Resolves the raw JSON string for a gate that targets either the node's stdout
 * output or an artifact file. Returns `{ evidence }` on read error so callers
 * can short-circuit before parsing.
 */
-function gateJsonSource(gate, context, attempt) {
+const gateJsonSource = (gate, context, attempt) => {
 	if (gate.target === "artifact") {
-		if (!gate.path) return { evidence: "missing JSON artifact path" };
+		if (gate.path === void 0 || gate.path.length === 0) return { evidence: "missing JSON artifact path" };
 		const source = readOptionalFile(join(context.worktreePath, gate.path));
-		return source === null ? { evidence: `missing JSON artifact: ${gate.path}` } : { source };
+		return Option.isNone(source) ? { evidence: `missing JSON artifact: ${gate.path}` } : { source: source.value };
 	}
 	return { source: attempt.output };
-}
+};
 /**
 * Parses the gate JSON source to an unknown value. Returns `{ evidence }` on
 * parse error so callers can short-circuit with a failed gate result.
 */
-function parseGateJson(gate, context, attempt) {
+const parseGateJson = (gate, context, attempt) => {
 	const src = gateJsonSource(gate, context, attempt);
-	if (src.evidence) return { evidence: src.evidence };
+	if (src.evidence !== void 0 && src.evidence.length > 0) return { evidence: src.evidence };
 	const parsed = parseJsonResult(src.source ?? "", "gate JSON");
-	return parsed.error ? { evidence: parsed.error } : { value: parsed.value };
-}
+	return parsed.error !== void 0 && parsed.error.length > 0 ? { evidence: parsed.error } : { value: parsed.value };
+};
 //#endregion
 export { parseGateJson };

package/dist/runtime/gates/kinds/acceptance/acceptance.js

@@ -1,13 +1,76 @@
 import { isRecord } from "../../../../safe-json.js";
 import { parseGateJson } from "../../gates.js";
 //#region src/runtime/gates/kinds/acceptance/acceptance.ts
+const effectiveTaskContext = (node, context) => node.taskContext ?? context.taskContext;
+const acceptanceEntries = (value, key = "acceptance") => {
+	if (!isRecord(value)) return [];
+	const raw = value[key] ?? value.criteria ?? value.acceptanceCriteria;
+	return Array.isArray(raw) ? raw.filter((item) => isRecord(item)) : [];
+};
+const coverageCountUnmetCriteria = (id, count) => {
+	const unmet = [];
+	if (count === 0) unmet.push({
+		criterion: id,
+		evidence: [`criterion '${id}' absent from acceptance report`],
+		reason: `missing acceptance criterion '${id}'`
+	});
+	if (count > 1) unmet.push({
+		criterion: id,
+		evidence: [`criterion '${id}' reported ${count} times`],
+		reason: `duplicate acceptance criterion '${id}'`
+	});
+	return unmet;
+};
+const hasNonEmptyEvidence = (value) => Array.isArray(value) && value.some((item) => typeof item === "string" && item.trim().length > 0);
+const entryUnmetCriteria = (entry, expectedIds, seen) => {
+	const id = typeof entry.id === "string" ? entry.id : "";
+	if (id.length === 0) return [{
+		criterion: "",
+		evidence: ["acceptance entry has no id field"],
+		reason: "acceptance entry missing id"
+	}];
+	seen.set(id, (seen.get(id) ?? 0) + 1);
+	const unmet = [];
+	if (!expectedIds.has(id)) unmet.push({
+		criterion: id,
+		evidence: [`id '${id}' not in task acceptance context`],
+		reason: `extra acceptance criterion '${id}'`
+	});
+	const { verdict } = entry;
+	if (verdict !== "PASS") unmet.push({
+		criterion: id,
+		evidence: [`reported verdict '${String(verdict)}'`],
+		reason: `acceptance criterion '${id}' verdict '${String(verdict)}'`
+	});
+	if (verdict === "PASS" && !hasNonEmptyEvidence(entry.evidence)) unmet.push({
+		criterion: id,
+		evidence: ["verdict 'PASS' reported without supporting evidence"],
+		reason: `acceptance criterion '${id}' has no evidence`
+	});
+	return unmet;
+};
+/**
+* Structured refusal producer (PIPE-90.1): the single source of truth for which
+* acceptance criteria a node failed to satisfy. Each {@link UnmetCriterion}
+* names the criterion, a human-readable reason, and deterministic proof. The
+* acceptance gate's flat `evidence` field is the `reason` projection of this,
+* so refusal text and ordering stay in lockstep with the structured form.
+*/
+const acceptanceUnmetCriteria = (expected, entries) => {
+	const unmet = [];
+	const expectedIds = new Set(expected.map((criterion) => criterion.id));
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of entries) unmet.push(...entryUnmetCriteria(entry, expectedIds, seen));
+	for (const id of expectedIds) unmet.push(...coverageCountUnmetCriteria(id, seen.get(id) ?? 0));
+	return unmet;
+};
 /**
 * Evaluates whether the node's JSON output (or artifact) covers all acceptance
 * criteria declared in the task context. Uses
 * {@link acceptanceUnmetCriteria} as the single source of truth for which
 * criteria remain unmet, so refusal text and structured form stay in lockstep.
 */
-function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node) {
+const evaluateAcceptanceGate = (gate, gateId, nodeId, context, attempt, node) => {
 	const expected = (node ? effectiveTaskContext(node, context) : context.taskContext)?.acceptanceCriteria ?? [];
 	if (expected.length === 0) return {
 		evidence: ["no acceptance criteria in task context"],
@@ -18,7 +81,7 @@ function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node) {
 		reason: gate.required === false ? void 0 : "missing task acceptance context"
 	};
 	const parsed = parseGateJson(gate, context, attempt);
-	if (parsed.evidence) return {
+	if (parsed.evidence !== void 0 && parsed.evidence.length > 0) return {
 		evidence: [parsed.evidence],
 		gateId,
 		kind: gate.kind,
@@ -26,7 +89,8 @@ function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node) {
 		passed: false,
 		reason: "acceptance gate JSON parse failed"
 	};
-	const unmet = acceptanceUnmetCriteria(expected, acceptanceEntries(parsed.value, gate.acceptance_key));
+	const entries = acceptanceEntries(parsed.value, gate.acceptance_key);
+	const unmet = acceptanceUnmetCriteria(expected, entries);
 	const passed = unmet.length === 0;
 	return {
 		evidence: passed ? ["acceptance coverage passed"] : unmet.map((item) => item.reason),
@@ -37,73 +101,6 @@ function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node) {
 		reason: passed ? void 0 : "acceptance coverage failed",
 		unmet
 	};
-}
-function effectiveTaskContext(node, context) {
-	return node.taskContext ?? context.taskContext;
-}
-function acceptanceEntries(value, key = "acceptance") {
-	if (!isRecord(value)) return [];
-	const raw = value[key] ?? value.criteria ?? value.acceptanceCriteria;
-	return Array.isArray(raw) ? raw.filter((item) => isRecord(item)) : [];
-}
-/**
-* Structured refusal producer (PIPE-90.1): the single source of truth for which
-* acceptance criteria a node failed to satisfy. Each {@link UnmetCriterion}
-* names the criterion, a human-readable reason, and deterministic proof. The
-* acceptance gate's flat `evidence` field is the `reason` projection of this,
-* so refusal text and ordering stay in lockstep with the structured form.
-*/
-function acceptanceUnmetCriteria(expected, entries) {
-	const unmet = [];
-	const expectedIds = new Set(expected.map((criterion) => criterion.id));
-	const seen = /* @__PURE__ */ new Map();
-	for (const entry of entries) unmet.push(...entryUnmetCriteria(entry, expectedIds, seen));
-	for (const id of expectedIds) unmet.push(...coverageCountUnmetCriteria(id, seen.get(id) ?? 0));
-	return unmet;
-}
-function entryUnmetCriteria(entry, expectedIds, seen) {
-	const id = typeof entry.id === "string" ? entry.id : "";
-	if (!id) return [{
-		criterion: "",
-		evidence: ["acceptance entry has no id field"],
-		reason: "acceptance entry missing id"
-	}];
-	seen.set(id, (seen.get(id) ?? 0) + 1);
-	const unmet = [];
-	if (!expectedIds.has(id)) unmet.push({
-		criterion: id,
-		evidence: [`id '${id}' not in task acceptance context`],
-		reason: `extra acceptance criterion '${id}'`
-	});
-	const verdict = entry.verdict;
-	if (verdict !== "PASS") unmet.push({
-		criterion: id,
-		evidence: [`reported verdict '${String(verdict)}'`],
-		reason: `acceptance criterion '${id}' verdict '${String(verdict)}'`
-	});
-	if (verdict === "PASS" && !hasNonEmptyEvidence(entry.evidence)) unmet.push({
-		criterion: id,
-		evidence: ["verdict 'PASS' reported without supporting evidence"],
-		reason: `acceptance criterion '${id}' has no evidence`
-	});
-	return unmet;
-}
-function coverageCountUnmetCriteria(id, count) {
-	const unmet = [];
-	if (count === 0) unmet.push({
-		criterion: id,
-		evidence: [`criterion '${id}' absent from acceptance report`],
-		reason: `missing acceptance criterion '${id}'`
-	});
-	if (count > 1) unmet.push({
-		criterion: id,
-		evidence: [`criterion '${id}' reported ${count} times`],
-		reason: `duplicate acceptance criterion '${id}'`
-	});
-	return unmet;
-}
-function hasNonEmptyEvidence(value) {
-	return Array.isArray(value) && value.filter((item) => typeof item === "string" && item.trim()).length > 0;
-}
+};
 //#endregion
 export { acceptanceUnmetCriteria, evaluateAcceptanceGate };

package/dist/runtime/gates/kinds/acceptance/index.js

@@ -2,8 +2,8 @@ import { forKind } from "../../contract.js";
 import { evaluateAcceptanceGate } from "./acceptance.js";
 //#region src/runtime/gates/kinds/acceptance/index.ts
 const acceptanceModule = {
-	kind: "acceptance",
-	evaluate: forKind("acceptance", (gate, input) => evaluateAcceptanceGate(gate, input.gateId, input.nodeId, input.context, input.attempt, input.node))
+	evaluate: forKind("acceptance", (gate, input) => evaluateAcceptanceGate(gate, input.gateId, input.nodeId, input.context, input.attempt, input.node)),
+	kind: "acceptance"
 };
 //#endregion
 export { acceptanceModule };

package/dist/runtime/gates/kinds/artifact/artifact.js

@@ -4,9 +4,9 @@ import { artifactExists } from "../../../../gates.js";
 * Checks whether the configured artifact path exists in the node's worktree.
 * A missing path or nonexistent file fails the gate.
 */
-function evaluateArtifactGate(gate, gateId, nodeId, context) {
-	const path = gate.path ?? "";
-	const passed = Boolean(path) && artifactExists(context.worktreePath, path);
+const evaluateArtifactGate = (gate, gateId, nodeId, context) => {
+	const { path } = gate;
+	const passed = path.length > 0 && artifactExists(context.worktreePath, path);
 	return {
 		evidence: [passed ? `artifact exists: ${path}` : `missing artifact: ${path}`],
 		gateId,
@@ -15,6 +15,6 @@ function evaluateArtifactGate(gate, gateId, nodeId, context) {
 		passed,
 		reason: passed ? void 0 : `missing artifact '${path}'`
 	};
-}
+};
 //#endregion
 export { evaluateArtifactGate };

package/dist/runtime/gates/kinds/artifact/index.js

@@ -2,8 +2,8 @@ import { forKind } from "../../contract.js";
 import { evaluateArtifactGate } from "./artifact.js";
 //#region src/runtime/gates/kinds/artifact/index.ts
 const artifactModule = {
-	kind: "artifact",
-	evaluate: forKind("artifact", (gate, input) => evaluateArtifactGate(gate, input.gateId, input.nodeId, input.context))
+	evaluate: forKind("artifact", (gate, input) => evaluateArtifactGate(gate, input.gateId, input.nodeId, input.context)),
+	kind: "artifact"
 };
 //#endregion
 export { artifactModule };

package/dist/runtime/gates/kinds/builtin/builtin.js

@@ -6,16 +6,16 @@ import "../../../builtins/index.js";
 * Context must satisfy {@link RuntimeContext} since {@link executeBuiltin} uses
 * the full runtime context (cwd, signal, store, etc.).
 */
-async function evaluateBuiltinGate(gate, gateId, nodeId, context) {
-	const result = await executeBuiltin(gate.builtin ?? "", context);
+const evaluateBuiltinGate = async (gate, gateId, nodeId, context) => {
+	const result = await executeBuiltin(gate.builtin, context);
 	return {
 		evidence: result.evidence,
 		gateId,
 		kind: gate.kind,
 		nodeId,
 		passed: result.exitCode === 0,
-		reason: result.exitCode === 0 ? void 0 : `builtin '${gate.builtin ?? ""}' failed`
+		reason: result.exitCode === 0 ? void 0 : `builtin '${gate.builtin}' failed`
 	};
-}
+};
 //#endregion
 export { evaluateBuiltinGate };

package/dist/runtime/gates/kinds/builtin/index.js

@@ -2,8 +2,8 @@ import { forKind } from "../../contract.js";
 import { evaluateBuiltinGate } from "./builtin.js";
 //#region src/runtime/gates/kinds/builtin/index.ts
 const builtinModule = {
-	kind: "builtin",
-	evaluate: forKind("builtin", (gate, input) => evaluateBuiltinGate(gate, input.gateId, input.nodeId, input.context))
+	evaluate: forKind("builtin", async (gate, input) => await evaluateBuiltinGate(gate, input.gateId, input.nodeId, input.context)),
+	kind: "builtin"
 };
 //#endregion
 export { builtinModule };