@oisincoveney/pipeline 2.3.1 → 2.5.0

package/.agents/skills/orchestrate/SKILL.md

@@ -70,6 +70,18 @@ Whichever host you are on, run the same six steps:
 5. **Learn** — Once the gates pass, run `MoKa Learner` to store durable lessons from the run (qdrant memory) when there is something worth reusing. This mirrors the canonical pipeline's LEARN phase; skip it only when the run produced nothing reusable.
 6. **Synthesize** — Report only the evidence the agents actually returned: what passed, what the diff is, what the reviewers proved. Never fabricate or assume an outcome an agent did not report.
 
+## Task sizing, reliability & token budget
+
+Token usage is the dominant cost and quality lever — it explains the bulk of agent performance variance, and context degrades well before a model's window fills. But the first job of sizing is **reliable completion**: a lane an agent can't finish is worthless however cheap. Size the work accordingly:
+
+- **Size for reliable completion first.** Each lane must be small enough that a single agent session finishes it cleanly. If an agent times out, stalls, or returns having only *planned* without producing its artifact, the lane was **too big** — split it into smaller lanes (one file, section, or concern each); do **not** just raise the timeout, that re-runs the same flake. **Slow is fine; flaky is not** — many small lanes that each reliably complete beat one big lane that gambles. Lanes that share a file run sequentially; only truly independent lanes fan out. Treat repeated stalls as a decomposition bug, not bad luck.
+- **Under-timeouts and permission walls are the real flake sources — not a step cap.** Per opencode's docs, an agent with no `steps`/`maxSteps` set "will continue to iterate until the model chooses to stop or the user interrupts the session" — i.e. **no hard step budget by default** (the MoKa agents set none). So a Code Writer that returns having only *planned* was not hitting a step limit; it was killed by too short a dispatch timeout or blocked on a denied read (e.g. `external_directory: deny`). Fixes: give long multi-file authoring runs **generous wall-clock** (do not kill them early — they are slow, not capped); scope lanes so they don't need denied/external reads; and only if you must *bound* a runaway agent, set `steps` in its config. Smaller lanes still help (less work = faster, fewer surprises), but "multi-file authoring can't be delegated" is a timeout/scoping issue, not an opencode limit.
+- **Scale fan-out to complexity, not ambition.** A trivial change is one agent (or just do it inline); a bounded change is 1–3 lanes; only go wide for genuinely independent breadth. Code parallelizes poorly — keep writer lanes narrow (the pipeline caps `green`/code fan-out at 2 for exactly this reason).
+- **Keep each agent's context small and high-signal.** Pass context by path and hand over the distilled `research.json`, never raw repo dumps. A lane that needs half the repo in its context is mis-scoped — split it.
+- **Distilled returns.** Expect each sub-agent to return a ~1–2k-token summary of its result, not its full transcript. Gather the summary; don't re-read the work.
+- **Re-dispatch once, with evidence.** On a gate `FAIL`, re-dispatch the failing lane a *single* time with concentrated failure evidence — do not thrash. Each fresh `opencode run` re-pays the full cold-start context tax (~35k tokens of standup before any work), so a retry loop is expensive; fix the input, not the dice.
+- **Smallest roster that covers the work.** Every extra lane is another cold standup. Default to the fewest specialists that close the task; add a lane only when it genuinely runs independently.
+
 ## Rules
 
 - **Doctrine is host-neutral; only the Dispatch section is host-specific.** Do not leak `opencode run` syntax into an OpenCode run or Task-tool talk into a Claude run.

package/defaults/pipeline.yaml

@@ -2,6 +2,13 @@ version: 1
 default_workflow: inspect
 orchestrator:
   profile: moka-orchestrator
+token_budget:
+  default_context_window: 200000
+  max_context_pct: 50
+  fan_out_width:
+    default: 4
+    by_category:
+      green: 2
 entrypoints:
   quick:
     schedule: quick-schedule

package/dist/config/load.js

@@ -51,6 +51,7 @@ function parsePipelineConfigParts(sources, projectRoot, sourcePaths = {
 		schedules: pipeline.schedules,
 		skills: profiles.skills,
 		...pipeline.task_context ? { task_context: pipeline.task_context } : {},
+		token_budget: pipeline.token_budget,
 		version: 1,
 		workflows: pipeline.workflows
 	}, projectRoot, options);

package/dist/config/schemas.d.ts

@@ -116,6 +116,7 @@ declare const workflowNodeBaseSchema: z.ZodObject<{
 }, z.core.$strip>;
 type WorkflowNodeBase = z.infer<typeof workflowNodeBaseSchema>;
 type AgentWorkflowNode = WorkflowNodeBase & {
+  category?: string;
   kind: "agent";
   profile: string;
 };
@@ -220,8 +221,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -245,8 +246,8 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     default_profile: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -289,10 +290,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>;
@@ -310,7 +311,6 @@ declare const configSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-      task: "task";
       read: "read";
       list: "list";
       grep: "grep";
@@ -318,6 +318,7 @@ declare const configSchema: z.ZodObject<{
       bash: "bash";
       edit: "edit";
       write: "write";
+      task: "task";
     }>>>;
   }, z.core.$strict>>>;
   runner_command: z.ZodDefault<z.ZodObject<{
@@ -343,8 +344,8 @@ declare const configSchema: z.ZodObject<{
   rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      project: "project";
       package: "package";
+      project: "project";
     }>>;
   }, z.core.$strict>>>;
   runners: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -361,15 +362,14 @@ 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>;
       tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        task: "task";
         read: "read";
         list: "list";
         grep: "grep";
@@ -377,6 +377,7 @@ declare const configSchema: z.ZodObject<{
         bash: "bash";
         edit: "edit";
         write: "write";
+        task: "task";
       }>>>;
     }, z.core.$strict>;
     command: z.ZodOptional<z.ZodString>;
@@ -471,8 +472,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>;
@@ -484,13 +485,34 @@ declare const configSchema: z.ZodObject<{
   skills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      project: "project";
       package: "package";
+      project: "project";
     }>>;
   }, z.core.$strict>>>;
   task_context: z.ZodOptional<z.ZodObject<{
     type: z.ZodString;
   }, z.core.$loose>>;
+  best_of_n: z.ZodOptional<z.ZodObject<{
+    categories: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    n: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>>;
+  context_handoff: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    model: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  parallel_worktrees: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  token_budget: z.ZodDefault<z.ZodObject<{
+    default_context_window: z.ZodDefault<z.ZodNumber>;
+    max_context_pct: z.ZodDefault<z.ZodNumber>;
+    model_context_windows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    fan_out_width: z.ZodDefault<z.ZodObject<{
+      default: z.ZodDefault<z.ZodNumber>;
+      by_category: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
   version: z.ZodLiteral<1>;
   workflows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;

package/dist/config/schemas.js

@@ -380,6 +380,7 @@ const workflowNodeBaseSchema = z.object({
 });
 const workflowNodeSchema = z.lazy(() => z.discriminatedUnion("kind", [
 	workflowNodeBaseSchema.extend({
+		category: z.string().min(1).optional(),
 		kind: z.literal("agent"),
 		profile: z.string()
 	}).strict(),
@@ -438,6 +439,38 @@ const profilesFileSchema = z.object({
 	skills: strictRecord(pathRefSchema).default({}),
 	version: z.literal(1)
 }).strict();
+const fanOutWidthSchema = z.object({
+	default: z.number().int().positive().default(4),
+	by_category: strictRecord(z.number().int().positive()).default({})
+}).strict();
+const tokenBudgetSchema = z.object({
+	default_context_window: z.number().int().positive().default(2e5),
+	max_context_pct: z.number().positive().max(100).default(50),
+	model_context_windows: strictRecord(z.number().int().positive()).default({}),
+	fan_out_width: fanOutWidthSchema.default({
+		default: 4,
+		by_category: {}
+	})
+}).strict();
+const DEFAULT_TOKEN_BUDGET = {
+	default_context_window: 2e5,
+	max_context_pct: 50,
+	model_context_windows: {},
+	fan_out_width: {
+		default: 4,
+		by_category: {}
+	}
+};
+const contextHandoffSchema = z.object({
+	enabled: z.boolean().default(false),
+	model: z.string().optional()
+}).strict();
+const parallelWorktreesSchema = z.object({ enabled: z.boolean().default(false) }).strict();
+const bestOfNSchema = z.object({
+	categories: z.array(z.string()).default(["green"]),
+	enabled: z.boolean().default(false),
+	n: z.number().int().positive().default(1)
+}).strict();
 const pipelineFileSchema = z.object({
 	default_workflow: z.string(),
 	entrypoints: strictRecord(entrypointSchema).default({}),
@@ -459,6 +492,10 @@ const pipelineFileSchema = z.object({
 	}),
 	schedules: strictRecord(schedulePolicySchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
+	best_of_n: bestOfNSchema.optional(),
+	context_handoff: contextHandoffSchema.optional(),
+	parallel_worktrees: parallelWorktreesSchema.optional(),
+	token_budget: tokenBudgetSchema.default(DEFAULT_TOKEN_BUDGET),
 	workflows: strictRecord(workflowSchema).default({}),
 	version: z.literal(1)
 }).strict();
@@ -489,6 +526,10 @@ const configSchema = z.object({
 	schedules: strictRecord(schedulePolicySchema).default({}),
 	skills: strictRecord(pathRefSchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
+	best_of_n: bestOfNSchema.optional(),
+	context_handoff: contextHandoffSchema.optional(),
+	parallel_worktrees: parallelWorktreesSchema.optional(),
+	token_budget: tokenBudgetSchema.default(DEFAULT_TOKEN_BUDGET),
 	version: z.literal(1),
 	workflows: strictRecord(workflowSchema).default({})
 }).strict().superRefine(validateConfigReferences);

package/dist/config/validate.js

@@ -35,12 +35,28 @@ function validatePipelineConfig(rawConfig, projectRoot, options = {}) {
 		validateProfile(profileId, profile, runner, config, issues, projectRoot, options);
 	}
 	validateHookConfig(config, issues, projectRoot, options);
+	validateTokenBudget(config, issues);
 	for (const [ruleId, rule] of Object.entries(config.rules)) validatePath(`rules.${ruleId}.path`, rule, projectRoot, issues, options);
 	for (const [skillId, skill] of Object.entries(config.skills)) validatePath(`skills.${skillId}.path`, skill, projectRoot, issues, options);
 	for (const [workflowId, workflow] of Object.entries(config.workflows)) validateWorkflow(workflowId, workflow, config, issues, projectRoot, options);
 	if (issues.length > 0) throw validationError(issues);
 	return config;
 }
+function knownNodeCategories(config) {
+	const categories = /* @__PURE__ */ new Set();
+	for (const catalog of Object.values(config.scheduler.node_catalogs)) {
+		for (const category of catalog.required_categories) categories.add(category);
+		for (const node of Object.values(catalog.nodes)) categories.add(node.category);
+	}
+	return categories;
+}
+function validateTokenBudget(config, issues) {
+	const known = knownNodeCategories(config);
+	for (const category of Object.keys(config.token_budget.fan_out_width.by_category)) if (!known.has(category)) issues.push({
+		path: `token_budget.fan_out_width.by_category.${category}`,
+		message: `fan-out width cap references unknown node category '${category}'`
+	});
+}
 function validateRegistryIds(name, registry, issues) {
 	for (const id of Object.keys(registry)) if (!ID_RE.test(id)) issues.push({
 		path: `${name}.${id}`,

package/dist/model-resolver.js

@@ -1,21 +1,42 @@
 //#region src/model-resolver.ts
 const DISABLED_MODELS_ENV = "PIPELINE_DISABLED_MODELS";
-function selectNodeModel(node) {
-	return fallbackModelSelection(node.models ?? []);
+function selectNodeModel(node, options) {
+	return fallbackModelSelection(node.models ?? [], options);
 }
-function fallbackModelSelection(models) {
+function fallbackModelSelection(models, options) {
 	if (models.length === 0) return {
 		reason: "node declares no model fallback array",
 		skipped: []
 	};
-	return enabledModelSelection(models, disabledModels());
+	const disabled = disabledModels();
+	const enabled = models.filter((candidate) => !disabled.has(candidate));
+	const disabledSkipped = models.filter((candidate) => disabled.has(candidate));
+	if (!options) {
+		const model = enabled[0];
+		return {
+			model,
+			reason: selectionReason(model),
+			skipped: disabledSkipped
+		};
+	}
+	return sizedSelection(enabled, disabledSkipped, options);
 }
-function enabledModelSelection(models, disabled) {
-	const model = models.find((candidate) => !disabled.has(candidate));
+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 {
-		model,
-		reason: selectionReason(model),
-		skipped: models.filter((candidate) => disabled.has(candidate))
+		reason: `estimated context ${estimatedTokens} tokens exceeds ${budget.max_context_pct}% of every available model window`,
+		skipped: [...disabledSkipped, ...tooSmall]
 	};
 }
 function selectionReason(model) {

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<{
@@ -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>;
@@ -206,13 +206,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/pipeline-runtime.js

@@ -628,6 +628,7 @@ async function executeNodeAttemptCycle(node, context, attempt, previous) {
 	const beforeSnapshot = context.nodeStateStore.getSnapshot(node.id);
 	if (beforeSnapshot) context.nodeStateStore.setSnapshot(node.id, diffChangedFiles(beforeSnapshot, afterSnapshot, context.worktreePath));
 	context.nodeStateStore.recordOutput(node.id, last.output);
+	context.nodeStateStore.recordHandoff(node.id, last.handoff);
 	emitNodeOutputRecorded(context, node, attempt, last.output);
 	recordNodeEvent(context, node.id, {
 		at: now(),

package/dist/planning/compile.d.ts

@@ -15,6 +15,7 @@ declare class WorkflowPlannerError extends Error {
 interface PlannedWorkflowNode {
   artifacts?: WorkflowNode["artifacts"];
   builtin?: string;
+  category?: string;
   children?: PlannedWorkflowNode[];
   command?: string[];
   dependents: string[];

package/dist/planning/compile.js

@@ -185,10 +185,14 @@ function createWorkflowGraph(nodes, nodeIds = new Set(nodes.map((node) => node.i
 function uniqueExistingNeeds(node, nodeIds) {
 	return uniqueStrings(node.needs.filter((need) => nodeIds.has(need)));
 }
+function agentNodeCategory(node) {
+	return node.kind === "agent" ? node.category : void 0;
+}
 function toPlannedNode(node, index) {
 	const planned = {
 		artifacts: node.artifacts,
 		builtin: "builtin" in node ? node.builtin : void 0,
+		category: agentNodeCategory(node),
 		command: "command" in node ? node.command : void 0,
 		children: node.kind === "parallel" ? node.nodes.map((child, childIndex) => toPlannedNode(child, childIndex)) : void 0,
 		dependents: [],

package/dist/planning/generate.d.ts

@@ -94,6 +94,7 @@ declare const scheduleArtifactSchema: z.ZodObject<{
       } | undefined;
       timeout_ms?: number | undefined;
     } & {
+      category?: string;
       kind: "agent";
       profile: string;
     }) | ({
@@ -478,6 +479,7 @@ declare const scheduleArtifactSchema: z.ZodObject<{
         } | undefined;
         timeout_ms?: number | undefined;
       } & {
+        category?: string;
         kind: "agent";
         profile: string;
       }) | ({
@@ -861,6 +863,7 @@ declare const scheduleArtifactSchema: z.ZodObject<{
       } | undefined;
       timeout_ms?: number | undefined;
     } & {
+      category?: string;
       kind: "agent";
       profile: string;
     }) | ({
@@ -1245,6 +1248,7 @@ declare const scheduleArtifactSchema: z.ZodObject<{
         } | undefined;
         timeout_ms?: number | undefined;
       } & {
+        category?: string;
         kind: "agent";
         profile: string;
       }) | ({

package/dist/planning/generate.js

@@ -5,6 +5,7 @@ import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
 import { loadBacklogPlanningContext } from "../schedule/backlog-context.js";
 import { baselineScheduleArtifact } from "../schedule/baseline.js";
+import { expandBestOfNCandidates } from "../schedule/passes/candidates.js";
 import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
 import { isCoverageNode, isImplementationNode } from "../schedule/scheduling-roles.js";
 import { addGeneratedImplementationCoverage } from "../schedule/passes/coverage.js";
@@ -91,7 +92,7 @@ async function generateScheduleArtifact(options) {
 	const planningContext = { ...loadBacklogPlanningContext(options.task, options.worktreePath) };
 	const generatedArtifact = await planScheduleArtifact(baseline, policy.planner_profile, options, planningContext);
 	assertSchedulePassOrder();
-	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, addGeneratedImplementationCoverage(options.config, generatedArtifact))), planningContext);
+	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, expandBestOfNCandidates(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact)))), planningContext);
 	validateScheduleArtifact(options.config, artifact, planningContext);
 	compileScheduleArtifact(options.config, artifact, options.worktreePath);
 	return {
@@ -102,6 +103,7 @@ async function generateScheduleArtifact(options) {
 function assertSchedulePassOrder() {
 	if (SCHEDULE_PASS_ORDER.join("\0") !== [
 		"coverage",
+		"candidates",
 		"models",
 		"ids",
 		"references"

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/runner-event-schema.d.ts

@@ -10,8 +10,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<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<{
@@ -55,10 +55,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>;
@@ -180,8 +180,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     at: z.ZodOptional<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<{
@@ -225,10 +225,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>;