@oisincoveney/pipeline 3.1.1 → 3.3.0

package/defaults/pipeline.yaml

@@ -86,7 +86,7 @@ scheduler:
         green-implementation:
           category: green
           profile: moka-code-writer
-          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models: [opencode-go/qwen3.7-max, openai/gpt-5.5-high, kimi-for-coding/k2p6]
         verification:
           category: verification
           profile: moka-verifier
@@ -109,7 +109,7 @@ scheduler:
         green-backend:
           category: green
           profile: moka-code-writer
-          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models: [opencode-go/qwen3.7-max, openai/gpt-5.5-high, kimi-for-coding/k2p6]
         green-frontend:
           category: green
           profile: moka-code-writer

package/dist/cli/program.js

@@ -1,9 +1,10 @@
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
+import { flattenNodes } from "../planning/graph.js";
 import { configureGatewayHosts, localGatewayStatus, reconcileGateway, renderGatewayConfig, runGatewayDoctor, startLocalGateway } from "../mcp/gateway.js";
 import { createOrchestratorLaunchPlan, createRunnerLaunchPlan } from "../runner.js";
 import { compileWorkflowPlan } from "../planning/compile.js";
-import { generateRuntimeRunId } from "../runtime/context/context.js";
+import { generateRuntimeRunId, resolveWorkflowSelection } from "../runtime/context/context.js";
 import "../runtime/context/index.js";
 import { runPipelineFromConfig } from "../pipeline-runtime.js";
 import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
@@ -192,7 +193,7 @@ function resolvedRunControlOptions(input) {
 function plannedRunStoreNodeIds(inputs) {
 	if (inputs.pipelineRunner) return [];
 	const workflowId = resolveWorkflowSelection(inputs.config, inputs.workflow, inputs.entrypoint);
-	return compileWorkflowPlan(inputs.config, workflowId).topologicalOrder.map((node) => node.id);
+	return flattenNodes(compileWorkflowPlan(inputs.config, workflowId).topologicalOrder, (node) => node.children).map((node) => node.id);
 }
 function formatSupervisedRunFollowUp(runId) {
 	return [
@@ -566,14 +567,6 @@ function formatWorkflowPlanNode(node, config, worktreePath) {
 		node.artifacts?.length ? `artifacts=${node.artifacts.map((artifact) => artifact.path).join(",")}` : "artifacts=none"
 	].filter(Boolean).join(" ");
 }
-function resolveWorkflowSelection(config, workflowId, entrypointId) {
-	if (workflowId) return workflowId;
-	if (!entrypointId) return;
-	const entrypoint = config.entrypoints[entrypointId];
-	if (!entrypoint) throw new Error(`Unknown pipeline entrypoint '${entrypointId}'`);
-	if ("schedule" in entrypoint) throw new Error(`Pipeline entrypoint '${entrypointId}' generates schedule '${entrypoint.schedule}'; use the entrypoint to create a schedule, then run with --schedule.`);
-	return entrypoint.workflow;
-}
 function formatOrchestratorPlan(config, worktreePath) {
 	if (!config.orchestrator) return "Orchestrator: not configured";
 	const orchestrator = config.profiles[config.orchestrator.profile];

package/dist/config/schemas.d.ts

@@ -226,8 +226,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        "trusted-only": "trusted-only";
         deny: "deny";
+        "trusted-only": "trusted-only";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -255,8 +255,8 @@ declare const configSchema: z.ZodObject<{
       global: "global";
     }>>;
     mode: z.ZodEnum<{
-      hosted: "hosted";
       local: "local";
+      hosted: "hosted";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -299,10 +299,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
+        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
-        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -371,10 +371,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
-        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -481,8 +481,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      quick: "quick";
       execute: "execute";
+      quick: "quick";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;

package/dist/model-resolver.js

@@ -9,17 +9,28 @@ function fallbackModelSelection(models, options) {
 		skipped: []
 	};
 	const disabled = disabledModels();
-	const enabled = models.filter((candidate) => !disabled.has(candidate));
-	const disabledSkipped = models.filter((candidate) => disabled.has(candidate));
-	if (!options) {
+	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 sizing = sizingFromOptions(options);
+	if (!sizing) {
 		const model = enabled[0];
 		return {
 			model,
 			reason: selectionReason(model),
-			skipped: disabledSkipped
+			skipped
 		};
 	}
-	return sizedSelection(enabled, disabledSkipped, options);
+	return sizedSelection(enabled, skipped, sizing);
+}
+function isAvailable(candidate, available) {
+	return available ? available.has(candidate) : true;
+}
+function sizingFromOptions(options) {
+	if (options?.budget && typeof options.estimatedTokens === "number") return {
+		budget: options.budget,
+		estimatedTokens: options.estimatedTokens
+	};
 }
 function sizedSelection(enabled, disabledSkipped, options) {
 	const { estimatedTokens, budget } = options;

package/dist/moka-submit.d.ts

@@ -160,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;

package/dist/pipeline-runtime.js

@@ -77,10 +77,12 @@ function runWithLeasedOpencode(options, config, worktreePath, run) {
 			...options.signal ? { signal: options.signal } : {},
 			worktreePath
 		})), (lease) => Effect.promise(() => lease.release()));
+		const availableModels = yield* Effect.promise(() => lease.availableModels());
 		return yield* run({
 			...options,
 			config,
-			executor: lease.executor
+			executor: lease.executor,
+			...availableModels ? { availableModels } : {}
 		});
 	}));
 }

package/dist/run-control/runtime-reporter.js

@@ -20,11 +20,11 @@ function createRunStoreRuntimeReporterRuntime(input) {
 	const activeHookPreviousStatuses = /* @__PURE__ */ new Map();
 	let writeChain = Promise.resolve();
 	const enqueue = (event) => {
-		const projection = projectRuntimeEvent(event, {
+		const persisted = persistRuntimeEventEffect(input, event, projectRuntimeEvent(event, {
 			activeHookPreviousStatuses,
 			observedNodeStatuses
-		});
-		writeChain = writeChain.then(() => withRunStateLock(() => Effect.runPromise(persistRuntimeEventEffect(input, event, projection, now))));
+		}), now).pipe(Effect.catchAll((error) => warnPersistSkipped(input, event, error)));
+		writeChain = writeChain.then(() => withRunStateLock(() => Effect.runPromise(persisted)));
 	};
 	const flushEffect = () => Effect.tryPromise({
 		catch: (error) => error,
@@ -184,5 +184,14 @@ function timestamp(now) {
 function assertNever(value) {
 	throw new Error(`Unhandled runtime reporter value: ${String(value)}`);
 }
+function warnPersistSkipped(input, event, error) {
+	return Effect.sync(() => {
+		const nodeId = "nodeId" in event && typeof event.nodeId === "string" ? ` node=${event.nodeId}` : "";
+		process.stderr.write(`run-control: skipped persisting ${event.type}${nodeId} for run ${input.runId}: ${errorMessage(error)}\n`);
+	});
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 export { createRunStoreRuntimeReporter };

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<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
 }, 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<{
-      full: "full";
       quick: "quick";
+      full: "full";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;

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

@@ -25,7 +25,7 @@ function executeAgentNodeEffect(node, context, attempt) {
 			output: ""
 		};
 		const prompt = yield* renderAgentPromptEffect(node, context);
-		const decision = decideNodeModel(prompt, node, context.config.token_budget);
+		const decision = decideNodeModel(prompt, node, context.config.token_budget, context.availableModels);
 		if (decision.overBudget) return {
 			evidence: [
 				`agent boundary node=${node.id} profile=${node.profile}`,
@@ -155,14 +155,15 @@ function createHandoffFinalizerPlan(context, node, runner, rawOutput) {
 * with a fallback array but no fitting model is `overBudget` — the caller fails
 * it fast rather than truncating.
 */
-function decideNodeModel(prompt, node, budget) {
+function decideNodeModel(prompt, node, budget, availableModels) {
 	const estimatedTokens = estimateTokens(prompt);
 	if (!(budget && node.models?.length)) return {
 		estimatedTokens,
 		overBudget: false,
-		selection: selectNodeModel(node)
+		selection: selectNodeModel(node, { available: availableModels })
 	};
 	const selection = selectNodeModel(node, {
+		available: availableModels,
 		budget,
 		estimatedTokens
 	});

package/dist/runtime/context/context.js

@@ -18,6 +18,7 @@ function createRuntimeContext(options) {
 	const observability = options.reporter ? createPublicRuntimeObservabilityEmitter(options.reporter, workflowId) : void 0;
 	return {
 		agentInvocations: [],
+		...options.availableModels ? { availableModels: options.availableModels } : {},
 		...runId ? { runId } : {},
 		config,
 		executor: options.executor ?? runLaunchPlan,
@@ -70,4 +71,4 @@ function generateRuntimeRunId() {
 	return `run-${randomUUID()}`;
 }
 //#endregion
-export { createRuntimeContext, generateRuntimeRunId, normalizeMaxParallelNodes, resolveWorkflowSelection };
+export { createRuntimeContext, generateRuntimeRunId, resolveWorkflowSelection };

package/dist/runtime/contracts/contracts.d.ts

@@ -248,6 +248,7 @@ type PipelineRuntimeEvent = {
  * single-node, schedule-driven execution path.
  */
 interface PipelineRuntimeOptions {
+  availableModels?: ReadonlySet<string>;
   config?: PipelineConfig;
   entrypoint?: string;
   executor?: (plan: RunnerLaunchPlan, options: RunnerExecutionOptions) => AgentResult | Promise<AgentResult>;

package/dist/runtime/events/events.js

@@ -1,3 +1,4 @@
+import { flattenNodes } from "../../planning/graph.js";
 import { isRecord } from "../../safe-json.js";
 import { runtimeActorId } from "../actor-ids.js";
 import { parseRuntimeOutput, validateJsonSchemaSource } from "../json-validation/json-validation.js";
@@ -125,7 +126,7 @@ function emitWorkflowPlanned(context) {
 }
 function emitWorkflowStarted(context) {
 	emit(context, {
-		nodeIds: context.plan.topologicalOrder.map((node) => node.id),
+		nodeIds: flattenNodes(context.plan.topologicalOrder, (node) => node.children).map((node) => node.id),
 		type: "workflow.start",
 		workflowId: context.workflowId
 	});

package/dist/runtime/opencode-runtime.js

@@ -27,6 +27,7 @@ function leaseOpencodeRuntimeEffect(input) {
 	const registry = createOpencodeSessionRegistry();
 	let handle;
 	let pending;
+	let availableModelsPending;
 	const ensureExecutor = () => {
 		pending ??= Effect.runPromise(Effect.provide(ensureExecutorEffect(input, registry), OpencodeRuntimeServerServiceLive)).then((executor) => {
 			handle = executor.handle;
@@ -34,7 +35,12 @@ function leaseOpencodeRuntimeEffect(input) {
 		});
 		return pending;
 	};
+	const resolveAvailableModels = () => {
+		availableModelsPending ??= ensureExecutor().then(() => handle ? queryAvailableOpencodeModels(handle.client) : void 0).catch(() => void 0);
+		return availableModelsPending;
+	};
 	return Effect.succeed({
+		availableModels: resolveAvailableModels,
 		executor: async (plan, options) => {
 			return await (await ensureExecutor())(plan, options);
 		},
@@ -46,6 +52,15 @@ function leaseOpencodeRuntimeEffect(input) {
 		}
 	});
 }
+/**
+* Collect every model the leased server can resolve (each authenticated
+* provider's models as `provider/model`) from the opencode `/config/providers`
+* endpoint, for availability-aware model selection.
+*/
+async function queryAvailableOpencodeModels(client) {
+	const providers = (await client.config.providers()).data?.providers ?? [];
+	return new Set(providers.flatMap((provider) => Object.keys(provider.models ?? {}).map((modelId) => `${provider.id}/${modelId}`)));
+}
 function ensureExecutorEffect(input, registry) {
 	return Effect.gen(function* () {
 		const handle = yield* (yield* OpencodeRuntimeServerService).open(input);

package/dist/schedule/passes/coverage.js

@@ -22,15 +22,11 @@ function addWorkflowImplementationCoverage(config, workflow, coverageProfileId)
 	};
 }
 function addNodeScopeImplementationCoverage(config, nodes, coverageProfileId) {
-	const scopedNodes = nodes.map((node) => node.kind === "parallel" ? {
-		...node,
-		nodes: addNodeScopeImplementationCoverage(config, node.nodes, coverageProfileId)
-	} : node);
-	const index = dependentsByNeed(scopedNodes);
-	const uncovered = scopedNodes.filter((node) => isImplementationNode(config, node)).filter((node) => !hasDownstreamCoverage(config, node.id, index));
-	if (uncovered.length === 0) return scopedNodes;
-	const coverageNodeId = uniqueGeneratedId("generated-coverage", new Set(scopedNodes.map((node) => node.id)), "generated-coverage");
-	return [...scopedNodes, {
+	const index = dependentsByNeed(nodes);
+	const uncovered = nodes.filter((node) => nodeNeedsImplementationCoverage(config, node)).filter((node) => !hasDownstreamCoverage(config, node.id, index));
+	if (uncovered.length === 0) return nodes;
+	const coverageNodeId = uniqueGeneratedId("generated-coverage", new Set(nodes.map((node) => node.id)), "generated-coverage");
+	return [...nodes, {
 		gates: generatedCoverageGates(coverageNodeId),
 		id: coverageNodeId,
 		kind: "agent",
@@ -38,6 +34,10 @@ function addNodeScopeImplementationCoverage(config, nodes, coverageProfileId) {
 		profile: coverageProfileId
 	}];
 }
+function nodeNeedsImplementationCoverage(config, node) {
+	if (isImplementationNode(config, node)) return true;
+	return node.kind === "parallel" && node.nodes.some((child) => nodeNeedsImplementationCoverage(config, child));
+}
 function generatedCoverageProfileId(config) {
 	const coverageProfiles = Object.entries(config.profiles).filter(([, profile]) => profile.scheduling_roles?.includes("coverage")).map(([id]) => id);
 	if (coverageProfiles.length === 0) return null;

package/package.json

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