@oisincoveney/pipeline 3.11.13 → 3.11.15

package/dist/config/schemas.d.ts

@@ -509,8 +509,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      execute: "execute";
       quick: "quick";
+      execute: "execute";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;

package/dist/model-resolver.js

@@ -1,27 +1,37 @@
 //#region src/model-resolver.ts
 const DISABLED_MODELS_ENV = "PIPELINE_DISABLED_MODELS";
-function selectNodeModel(node, options) {
-	return fallbackModelSelection(node.models ?? [], options);
-}
-function fallbackModelSelection(models, options) {
+function selectNodeModelCandidates(node, options) {
+	const models = node.models ?? [];
 	if (models.length === 0) return {
+		models: [],
 		reason: "node declares no model fallback array",
 		skipped: []
 	};
 	const disabled = disabledModels();
 	const available = options?.available;
 	const enabled = models.filter((candidate) => !disabled.has(candidate) && isAvailable(candidate, available));
-	const skipped = models.filter((candidate) => disabled.has(candidate) || !isAvailable(candidate, available));
+	const baseSkipped = models.filter((candidate) => disabled.has(candidate) || !isAvailable(candidate, available));
 	const sizing = sizingFromOptions(options);
-	if (!sizing) {
-		const model = enabled[0];
-		return {
-			model,
-			reason: selectionReason(model),
-			skipped
-		};
-	}
-	return sizedSelection(enabled, skipped, sizing);
+	if (!sizing) return {
+		models: enabled,
+		reason: selectionReason(enabled[0]),
+		skipped: baseSkipped
+	};
+	return sizedCandidates(enabled, baseSkipped, sizing);
+}
+function sizedCandidates(enabled, baseSkipped, options) {
+	const { estimatedTokens, budget } = options;
+	const required = estimatedTokens / (budget.max_context_pct / 100);
+	const fits = [];
+	const tooSmall = [];
+	for (const candidate of enabled) if ((budget.model_context_windows[candidate] ?? budget.default_context_window) >= required) fits.push(candidate);
+	else tooSmall.push(candidate);
+	const head = fits[0];
+	return {
+		models: fits,
+		reason: head ? `selected '${head}' (window ${budget.model_context_windows[head] ?? budget.default_context_window}) — holds estimated ${estimatedTokens} tokens within the ${budget.max_context_pct}% context cap` : `estimated context ${estimatedTokens} tokens exceeds ${budget.max_context_pct}% of every available model window`,
+		skipped: [...baseSkipped, ...tooSmall]
+	};
 }
 function isAvailable(candidate, available) {
 	return available ? available.has(candidate) : true;
@@ -32,24 +42,6 @@ function sizingFromOptions(options) {
 		estimatedTokens: options.estimatedTokens
 	};
 }
-function sizedSelection(enabled, disabledSkipped, options) {
-	const { estimatedTokens, budget } = options;
-	const required = estimatedTokens / (budget.max_context_pct / 100);
-	const tooSmall = [];
-	for (const candidate of enabled) {
-		const window = budget.model_context_windows[candidate] ?? budget.default_context_window;
-		if (window >= required) return {
-			model: candidate,
-			reason: `selected '${candidate}' (window ${window}) — holds estimated ${estimatedTokens} tokens within the ${budget.max_context_pct}% context cap`,
-			skipped: [...disabledSkipped, ...tooSmall]
-		};
-		tooSmall.push(candidate);
-	}
-	return {
-		reason: `estimated context ${estimatedTokens} tokens exceeds ${budget.max_context_pct}% of every available model window`,
-		skipped: [...disabledSkipped, ...tooSmall]
-	};
-}
 function selectionReason(model) {
 	if (model) return "selected first enabled model from node fallback array";
 	return `all configured node models are disabled by ${DISABLED_MODELS_ENV}`;
@@ -58,4 +50,4 @@ function disabledModels() {
 	return new Set((process.env[DISABLED_MODELS_ENV] ?? "").split(",").map((value) => value.trim()).filter(Boolean));
 }
 //#endregion
-export { selectNodeModel };
+export { selectNodeModelCandidates };

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
+  "node.finish": "node.finish";
+  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
-  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
-  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -161,8 +161,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;
@@ -207,13 +207,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{

package/dist/run-state/git-refs.js

@@ -109,6 +109,9 @@ function promoteFinalRefEffect(input) {
 function headSha(worktreePath) {
 	return Effect.map(runGit(worktreePath, ["rev-parse", "HEAD"]), (sha) => sha.trim());
 }
+function runnerCommitMessage(nodeId) {
+	return `chore(pipeline): ${nodeId}`;
+}
 function commitChangesIfNeeded(worktreePath, nodeId, committer) {
 	return Effect.gen(function* () {
 		if ((yield* runGit(worktreePath, [
@@ -121,7 +124,7 @@ function commitChangesIfNeeded(worktreePath, nodeId, committer) {
 		yield* runGit(worktreePath, [
 			"commit",
 			"-m",
-			`pipeline: ${nodeId}`
+			runnerCommitMessage(nodeId)
 		]);
 	});
 }

package/dist/runner-command-contract.d.ts

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      quick: "quick";
       full: "full";
+      quick: "quick";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;

package/dist/runner-event-schema.d.ts

@@ -11,8 +11,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   runId: z.ZodString;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
-    "workflow.start": "workflow.start";
     "workflow.planned": "workflow.planned";
+    "workflow.start": "workflow.start";
   }>;
   workflowPlan: z.ZodObject<{
     edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -58,10 +58,10 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
   }, z.core.$strip>;
   type: z.ZodEnum<{
-    "node.start": "node.start";
-    "node.finish": "node.finish";
     "agent.finish": "agent.finish";
     "agent.start": "agent.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
@@ -189,8 +189,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     runId: z.ZodString;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
-      "workflow.start": "workflow.start";
       "workflow.planned": "workflow.planned";
+      "workflow.start": "workflow.start";
     }>;
     workflowPlan: z.ZodObject<{
       edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -236,10 +236,10 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       }>;
     }, z.core.$strip>;
     type: z.ZodEnum<{
-      "node.start": "node.start";
-      "node.finish": "node.finish";
       "agent.finish": "agent.finish";
       "agent.start": "agent.start";
+      "node.finish": "node.finish";
+      "node.start": "node.start";
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;

package/dist/runtime/agent-node/agent-node.js

@@ -1,7 +1,7 @@
 import { resolvePackageAssetPath } from "../../package-assets.js";
 import { resolveFileReference } from "../../path-refs.js";
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
-import { selectNodeModel } from "../../model-resolver.js";
+import { selectNodeModelCandidates } from "../../model-resolver.js";
 import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput, runnerTextCandidates } from "../../runner-output.js";
 import { estimateTokens } from "../../token-estimator.js";
@@ -29,17 +29,72 @@ function executeAgentNodeEffect(node, context, attempt) {
 		if (decision.overBudget) return {
 			evidence: [
 				`agent boundary node=${node.id} profile=${node.profile}`,
-				`over token budget: ${decision.selection.reason}`,
-				...decision.selection.skipped.length ? [`model fallbacks skipped: ${decision.selection.skipped.join(", ")}`] : []
+				`over token budget: ${decision.reason}`,
+				...decision.skipped.length ? [`model fallbacks skipped: ${decision.skipped.join(", ")}`] : []
 			],
 			exitCode: 1,
 			output: ""
 		};
-		const modelSelection = decision.selection;
+		const profileId = node.profile;
+		const fallbackEvidence = [];
+		const lastIndex = decision.candidates.length - 1;
+		for (let index = 0; index < lastIndex; index += 1) {
+			const model = decision.candidates[index];
+			const attemptOutcome = yield* runModelAttemptEffect({
+				attempt,
+				context,
+				model,
+				node,
+				profileId,
+				prompt
+			});
+			if (attemptOutcome.result.exitCode !== 70) return yield* buildAgentAttemptResultEffect({
+				attempt,
+				context,
+				decision,
+				fallbackEvidence,
+				model,
+				node,
+				outcome: attemptOutcome,
+				profileId
+			});
+			fallbackEvidence.push(fallbackNote(model, decision.candidates[index + 1], attemptOutcome.result));
+		}
+		const lastModel = decision.candidates[lastIndex];
+		return yield* buildAgentAttemptResultEffect({
+			attempt,
+			context,
+			decision,
+			fallbackEvidence,
+			model: lastModel,
+			node,
+			outcome: yield* runModelAttemptEffect({
+				attempt,
+				context,
+				model: lastModel,
+				node,
+				profileId,
+				prompt
+			}),
+			profileId
+		});
+	});
+}
+function modelLabel(model) {
+	return model ?? "profile/default";
+}
+function fallbackNote(failed, next, result) {
+	const detail = result.stderr ? `: ${result.stderr}` : "";
+	return `model ${modelLabel(failed)} failed (infra exit ${result.exitCode}${detail}); falling back to ${modelLabel(next)}`;
+}
+function runModelAttemptEffect(inputs) {
+	return Effect.gen(function* () {
+		const { attempt, context, model, node, profileId, prompt } = inputs;
+		const service = yield* AgentNodeRuntimeService;
 		const plan = createRunnerLaunchPlan(context.config, {
-			model: modelSelection.model,
+			model,
 			nodeId: node.id,
-			profileId: node.profile,
+			profileId,
 			prompt,
 			reasoningEffort: node.reasoning_effort,
 			worktreePath: context.worktreePath
@@ -47,12 +102,22 @@ function executeAgentNodeEffect(node, context, attempt) {
 		if (node.timeoutMs) plan.timeoutMs = node.timeoutMs;
 		context.agentInvocations.push(plan);
 		emitAgentStart(context, plan, attempt);
-		const result = yield* (yield* AgentNodeRuntimeService).executeRunner(context.executor, plan, {
+		const result = yield* service.executeRunner(context.executor, plan, {
 			onOutput: agentOutputRecorder(context, node, attempt),
 			signal: context.signal
 		});
 		emitAgentFinish(context, plan, attempt, result);
 		if (result.sessionId) context.nodeStateStore.recordSessionId(node.id, result.sessionId);
+		return {
+			plan,
+			result
+		};
+	});
+}
+function buildAgentAttemptResultEffect(inputs) {
+	return Effect.gen(function* () {
+		const { attempt, context, decision, fallbackEvidence, model, node, outcome, profileId } = inputs;
+		const { plan, result } = outcome;
 		const finalized = yield* finalizeAgentOutputEffect({
 			context,
 			node,
@@ -64,10 +129,11 @@ function executeAgentNodeEffect(node, context, attempt) {
 		const handoff = yield* maybeDeriveHandoffEffect(context, node, finalized.output, attempt);
 		return withOptionalHandoff({
 			evidence: [
-				`agent boundary node=${node.id} profile=${node.profile} runner=${plan.runnerId}`,
+				`agent boundary node=${node.id} profile=${profileId} runner=${plan.runnerId}`,
 				`estimated context tokens: ${decision.estimatedTokens}`,
-				`model selection: ${modelSelection.model ?? "profile/default"} (${modelSelection.reason})`,
-				...modelSelection.skipped.length ? [`model fallbacks skipped: ${modelSelection.skipped.join(", ")}`] : [],
+				`model selection: ${modelLabel(model)} (${decision.reason})`,
+				...decision.skipped.length ? [`model fallbacks skipped: ${decision.skipped.join(", ")}`] : [],
+				...fallbackEvidence,
 				...finalized.evidence,
 				...result.stderr ? [`stderr: ${result.stderr}`] : [],
 				...result.timedOut ? ["agent timed out"] : []
@@ -151,27 +217,28 @@ function createHandoffFinalizerPlan(context, node, runner, rawOutput) {
 }
 /**
 * Pure model-routing decision for a node: estimate the assembled prompt size and
-* pick the smallest fallback model whose window holds it within the context cap.
-* A node with no fallback array keeps the legacy (size-unaware) selection. A node
-* with a fallback array but no fitting model is `overBudget` — the caller fails
-* it fast rather than truncating.
+* resolve the ordered fallback set of models whose window holds it within the
+* context cap. A node with no fallback array (or none surviving the filters)
+* falls back to the profile default (`undefined`). A node with a fallback array
+* but no fitting model under budget is `overBudget` — the caller fails it fast
+* rather than truncating.
 */
 function decideNodeModel(prompt, node, budget, availableModels) {
 	const estimatedTokens = estimateTokens(prompt);
-	if (!(budget && node.models?.length)) return {
-		estimatedTokens,
-		overBudget: false,
-		selection: selectNodeModel(node, { available: availableModels })
-	};
-	const selection = selectNodeModel(node, {
+	const candidates = selectNodeModelCandidates(node, {
 		available: availableModels,
-		budget,
-		estimatedTokens
+		...budget ? {
+			budget,
+			estimatedTokens
+		} : {}
 	});
+	const overBudget = Boolean(budget && node.models?.length) && candidates.models.length === 0;
 	return {
+		candidates: candidates.models.length ? candidates.models : [void 0],
 		estimatedTokens,
-		overBudget: !selection.model,
-		selection
+		overBudget,
+		reason: candidates.reason,
+		skipped: candidates.skipped
 	};
 }
 function finalizeAgentOutputEffect(inputs) {

package/dist/runtime/opencode-session-executor.js

@@ -7,15 +7,6 @@ function createOpencodeSessionRegistry() {
 	return { sessions: /* @__PURE__ */ new Map() };
 }
 /**
-* Distinguish infra failure (server/session error -> retry-eligible exit 70)
-* from a normal agent completion (the agent may still have produced a wrong
-* answer; gates decide that, exit 0). This mirrors the EXIT_STARTUP convention
-* in runner-command/run.ts and feeds retry.ts via the node's retry policy.
-*/
-const EXIT_OK = 0;
-const EXIT_AGENT_ERROR = 1;
-const EXIT_INFRA = 70;
-/**
 * SDK-backed replacement for the subprocess `runLaunchPlan`. Conforms to the
 * RuntimeContext.executor seam so agent-node never learns the transport.
 */
@@ -288,7 +279,7 @@ function successResult(plan, drive) {
 	};
 	return {
 		argv: plan.args,
-		exitCode: EXIT_OK,
+		exitCode: 0,
 		sessionId: drive.sessionId,
 		stdout
 	};
@@ -296,7 +287,7 @@ function successResult(plan, drive) {
 function failureResult(plan, error) {
 	return {
 		argv: plan.args,
-		exitCode: EXIT_INFRA,
+		exitCode: 70,
 		stderr: `opencode session failed: ${errorMessage(error)}`,
 		stdout: ""
 	};
@@ -309,8 +300,8 @@ function failureResult(plan, error) {
 function infraErrorExitCode(error) {
 	switch (error.name) {
 		case "MessageOutputLengthError":
-		case "MessageAbortedError": return EXIT_AGENT_ERROR;
-		default: return EXIT_INFRA;
+		case "MessageAbortedError": return 1;
+		default: return 70;
 	}
 }
 function describeMessageError(error) {

package/package.json

@@ -128,7 +128,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "3.11.13",
+  "version": "3.11.15",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",