@oisincoveney/pipeline 2.1.1 → 2.3.0

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

@@ -0,0 +1,80 @@
+---
+description: Local multi-agent orchestrator — decompose a task and fan it out to the MoKa specialist roster on the current machine instead of submitting to the remote Moka pipeline. The local twin of the MoKa Orchestrator. On Claude Code, dispatch each agent with `opencode run`; on OpenCode, spawn native Task subagents. Use when the user wants parallel specialist agents driven locally rather than as Argo/k8s jobs.
+name: orchestrate
+---
+
+# Orchestrate
+
+The **local twin of the MoKa Orchestrator**. The MoKa Orchestrator decomposes a task and submits a schedule to Argo/k8s via `moka submit`, where the runtime executes it as DAG jobs on the cluster. Orchestrate runs the **same roster, same loop, on the current machine** — no schedule, no `moka submit`, no Argo. It is the hands-on, here-and-now path for getting work done through specialist agents.
+
+Use this skill when the user wants real work driven through **parallel specialist agents locally**: a task large enough to decompose into research / test / implement / verify lanes, where you stay the controller and the agents do the labor.
+
+## When NOT to use
+
+- **Durable, reproducible, or cluster-scale runs** → use [[quick]] or [[execute]] (these submit through `moka submit`). Orchestrate is ephemeral and local; it leaves no schedule artifact.
+- **Trivial single-threaded work** → just do it inline. Spawning agents for a one-line change is pure overhead.
+- **You need package gates enforced as part of a pipeline run** → that is the remote path's job. Orchestrate still *uses* the gate agents (Verifier, Acceptance Reviewer) but does not replace pipeline-level gating.
+
+## The roster
+
+The same specialist agents the MoKa pipeline uses, mirrored locally. Each is `mode: all`, so it works both as an `opencode run --agent` subprocess and as a native Task subagent.
+
+| Role        | Agent name              | Writes        | Job |
+|-------------|-------------------------|---------------|-----|
+| Research    | `MoKa Researcher`       | `research.json` only | Read-only; map the codebase, gather context, extract acceptance criteria. |
+| Test        | `MoKa Test Writer`      | `*.test.ts` only | Write failing tests that describe the desired behaviour. |
+| Implement   | `MoKa Code Writer`      | `src/**` only | Smallest production change that makes the failing tests pass. |
+| Verify      | `MoKa Verifier`         | nothing       | Run checks, judge diff against AC, emit `PASS`/`FAIL` with evidence. |
+| Review      | `MoKa Acceptance Reviewer` | nothing    | Acceptance/quality gate before declaring done. |
+| Inspect     | `MoKa Inspector`        | nothing       | Read-only repository inspection / explanation. |
+
+Keep each agent inside its lane — never ask the Code Writer to touch tests, or the Verifier to write files. The lane boundaries are what make fan-out safe.
+
+## Dispatch by host
+
+The orchestration **doctrine below is identical on every host**. Only the spawn mechanism differs — select the branch for the host you are actually running in.
+
+### On Claude Code → `opencode run`
+
+Spawn each roster member as a headless OpenCode subprocess and read its JSON back:
+
+```sh
+opencode run --agent "MoKa Code Writer" --format json \
+  "<scoped task + acceptance criteria + paths to read>"
+```
+
+- Select the roster member with `--agent "<exact name>"` (names from the table above).
+- Use `--format json` so the agent's structured result comes back machine-readable; parse it, do not eyeball it.
+- **Parallelize independent lanes**: launch each `opencode run` as a background Bash process (one tool call per lane in the same turn), then collect. Run dependent lanes only after their inputs land.
+- Pass context by path, not by paste — agents read the worktree directly. Hand them the files/AC the Researcher produced.
+- `--model` / `--variant` only when a lane genuinely needs a different tier; otherwise inherit.
+
+### On OpenCode → native Task subagents
+
+You are already inside OpenCode — do not shell out to `opencode run`. Spawn the roster directly with the native **Task** tool, selecting the agent by the same name:
+
+- `task` → `MoKa Researcher`, `MoKa Test Writer`, `MoKa Code Writer`, `MoKa Verifier`, `MoKa Acceptance Reviewer`.
+- Issue independent Task calls together so they run concurrently; sequence dependent ones.
+- Each subagent's structured output returns to you as the controller — gather, do not re-do their work.
+
+## The loop
+
+Whichever host you are on, run the same five steps:
+
+1. **Plan** — Decompose the task into a DAG of agent lanes. Model parallelism *structurally*: independent lanes fan out together, dependents wait on their inputs (research → tests → implementation → verify). Do not invent JSON-pointer fanout; nest the work as real lanes.
+2. **Dispatch** — Fan out per the host branch above. Scope each agent tightly: one job, its lane's write boundary, explicit acceptance criteria.
+3. **Gather** — Collect each agent's structured output (`research.json`, the Verifier's verdict JSON, etc.). Treat the returned artifact as the source of truth.
+4. **Gate** — Run `MoKa Verifier`, then `MoKa Acceptance Reviewer`. Do **not** accept work on a `FAIL`. Loop the relevant lane (re-dispatch Code Writer with the failure evidence) rather than papering over it.
+5. **Synthesize** — Report only the evidence the agents actually returned: what passed, what the diff is, what the verifier proved. Never fabricate or assume an outcome an agent did not report.
+
+## 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.
+- **You are the controller, not a worker.** Decompose, dispatch, gate, synthesize. Let the specialists do the labor inside their lanes.
+- **Evidence only.** Report what agents returned. A green claim needs a Verifier `PASS` with evidence behind it — see [[verify]].
+- **Respect lane write boundaries.** Researcher/Verifier/Reviewer write nothing; Test Writer touches only tests; Code Writer touches only `src/`. Mixed lanes corrupt parallel fan-out.
+- **Local, not durable.** If the user needs a reproducible cluster run or a schedule artifact, route to [[quick]] / [[execute]] instead.
+
+## The short version
+
+Orchestrate is `moka submit` brought home: same roster, same decompose → dispatch → gather → gate → synthesize loop, run on this machine. On Claude Code each agent is an `opencode run --agent` subprocess; on OpenCode each is a native Task subagent. You stay the orchestrator — fan out the lanes, gate on real verifier evidence, and report only what the agents proved.

package/defaults/pipeline.yaml

@@ -0,0 +1,111 @@
+version: 1
+default_workflow: inspect
+orchestrator:
+  profile: moka-orchestrator
+entrypoints:
+  quick:
+    schedule: quick-schedule
+    description: Compact planner-generated pipeline for small work
+  execute:
+    schedule: execute-schedule
+    description: Full planner-generated pipeline for repository work
+  inspect:
+    workflow: inspect
+    description: Read-only repository inspection
+hooks:
+  functions:
+    generated-defaults-audit:
+      kind: command
+      command: [node, -e, "const fs=require('node:fs'); fs.writeFileSync(process.env.PIPELINE_HOOK_RESULT, JSON.stringify({status:'pass',summary:'Generated defaults audit passed'}));"]
+      trusted: true
+      timeout_ms: 5000
+      output_limit_bytes: 4096
+  on:
+    workflow.start:
+      - id: generated-defaults-audit
+        function: generated-defaults-audit
+        failure: fail
+runner_command:
+  environment:
+    setup:
+      - command: bun
+        args: [install, --frozen-lockfile]
+scheduler:
+  commands:
+    quick:
+      schedule: quick-schedule
+      catalog: quick
+    execute:
+      schedule: execute-schedule
+      catalog: execute
+  node_catalogs:
+    quick:
+      required_categories: [intake, red, green, mechanical, verification]
+      nodes:
+        backlog-intake:
+          category: intake
+          profile: moka-researcher
+          models: [openai/gpt-5.5-medium]
+        red-tests:
+          category: red
+          profile: moka-test-writer
+          models: [openai/gpt-5.5-high, kimi-for-coding/kimi-k2-thinking]
+        green-implementation:
+          category: green
+          profile: moka-code-writer
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+        verification:
+          category: verification
+          profile: moka-verifier
+          models: [openai/gpt-5.5-medium]
+    execute:
+      required_categories: [intake, research, red, green, mechanical, acceptance, verification, learn]
+      nodes:
+        backlog-intake:
+          category: intake
+          profile: moka-researcher
+          models: [openai/gpt-5.5-medium]
+        research:
+          category: research
+          profile: moka-researcher
+          models: [openai/gpt-5.5-medium, kimi-for-coding/k2p6]
+        red-tests:
+          category: red
+          profile: moka-test-writer
+          models: [openai/gpt-5.5-high, kimi-for-coding/kimi-k2-thinking]
+        green-backend:
+          category: green
+          profile: moka-code-writer
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+        green-frontend:
+          category: green
+          profile: moka-code-writer
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+        acceptance-review:
+          category: acceptance
+          profile: moka-acceptance-reviewer
+          models: [openai/gpt-5.5-medium]
+        verification:
+          category: verification
+          profile: moka-verifier
+          models: [openai/gpt-5.5-medium]
+        learn:
+          category: learn
+          profile: moka-learner
+          models: [openai/gpt-5.5-low]
+schedules:
+  quick-schedule:
+    baseline: quick
+    planner_profile: moka-schedule-planner
+    node_catalog: quick
+  execute-schedule:
+    baseline: execute
+    planner_profile: moka-schedule-planner
+    node_catalog: execute
+workflows:
+  inspect:
+    description: Read-only repository inspection workflow.
+    nodes:
+      - id: inspect
+        kind: agent
+        profile: moka-inspector

package/defaults/profiles.yaml

@@ -0,0 +1,215 @@
+version: 1
+mcp_gateway:
+  provider: toolhive
+  mode: local
+  url: https://pipeline-mcp.momokaya.ee/mcp/
+  url_env: PIPELINE_MCP_GATEWAY_URL
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
+  default_profile: default
+  backends:
+    context7:
+      locality: shared-remote
+      tool_prefixes: [context7]
+    uidotsh:
+      locality: shared-remote
+      tool_prefixes: [uidotsh]
+    qdrant:
+      locality: repo-scoped-remote
+      tool_prefixes: [qdrant]
+    fallow:
+      locality: repo-local
+      workspace_path_source: PIPELINE_TARGET_PATH
+      required: false
+      tool_prefixes: [fallow]
+    serena:
+      locality: repo-local
+      workspace_path_source: PIPELINE_TARGET_PATH
+      tool_prefixes: [serena]
+    backlog:
+      locality: repo-local
+      workspace_path_source: PIPELINE_TARGET_PATH
+      tool_prefixes: [backlog]
+skills:
+  orchestrate:
+    path: .agents/skills/orchestrate/SKILL.md
+    source_root: package
+  execute:
+    path: .agents/skills/execute/SKILL.md
+    source_root: package
+  inspect:
+    path: .agents/skills/inspect/SKILL.md
+    source_root: package
+  quick:
+    path: .agents/skills/quick/SKILL.md
+    source_root: package
+  critique:
+    path: .agents/skills/critique/SKILL.md
+    source_root: package
+  doubt:
+    path: .agents/skills/doubt/SKILL.md
+    source_root: package
+  fix:
+    path: .agents/skills/fix/SKILL.md
+    source_root: package
+  library-first-development:
+    path: .agents/skills/library-first-development/SKILL.md
+    source_root: package
+  migrate:
+    path: .agents/skills/migrate/SKILL.md
+    source_root: package
+  optimize:
+    path: .agents/skills/optimize/SKILL.md
+    source_root: package
+  research:
+    path: .agents/skills/research/SKILL.md
+    source_root: package
+  schedule-graph-shaping:
+    path: .agents/skills/schedule-graph-shaping/SKILL.md
+    source_root: package
+  scope:
+    path: .agents/skills/scope/SKILL.md
+    source_root: package
+  secure:
+    path: .agents/skills/secure/SKILL.md
+    source_root: package
+  spec:
+    path: .agents/skills/spec/SKILL.md
+    source_root: package
+  test:
+    path: .agents/skills/test/SKILL.md
+    source_root: package
+  trace:
+    path: .agents/skills/trace/SKILL.md
+    source_root: package
+  verify:
+    path: .agents/skills/verify/SKILL.md
+    source_root: package
+profiles:
+  moka-orchestrator:
+    runner: opencode
+    description: Orchestrate the configured pipeline and enforce gates.
+    instructions: { inline: "Orchestrate the configured pipeline locally. Load the `orchestrate` skill and spawn the roster as native Task subagents on this machine. Do not submit to Argo or run `moka submit`. Enforce only package-configured gates." }
+    skills: [orchestrate, execute, quick, inspect]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+  moka-researcher:
+    runner: opencode
+    description: Research the requested task and produce structured findings.
+    instructions: { inline: "Inspect first-party source, tests, docs, and task context for the current task only. Produce concise findings with file references and stop; do not perform open-ended repository exploration." }
+    timeout_ms: 900000
+    skills: [research, spec, scope]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/research.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-inspector:
+    runner: opencode
+    model: openai/gpt-5.5-low
+    description: Inspect the repository without modifying files.
+    instructions: { inline: "Inspect the repository without modifying files." }
+    skills: [research]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+  moka-schedule-planner:
+    runner: opencode
+    model: openai/gpt-5.5-xhigh
+    description: Refine a baseline schedule into a specialized approved-plan artifact.
+    instructions: { inline: "Generate exactly one workflow named root as an explicit schedule graph. Return YAML only." }
+    timeout_ms: 300000
+    skills: [schedule-graph-shaping]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+  moka-test-writer:
+    runner: opencode
+    scheduling_roles: [implementation]
+    description: Add focused failing tests for the requested behavior.
+    instructions: { inline: "Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    skills: [test]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash, edit, write]
+    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/implementation.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-code-writer:
+    runner: opencode
+    scheduling_roles: [implementation]
+    description: Implement production code until the failing tests pass.
+    instructions: { inline: "Implement the smallest production change that satisfies the failing tests. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    skills: [trace, test, fix, library-first-development]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash, edit, write]
+    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/implementation.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-acceptance-reviewer:
+    runner: opencode
+    scheduling_roles: [coverage]
+    description: Audit the finished change against every acceptance criterion.
+    instructions: { inline: 'Audit the completed change against each canonical acceptance criterion independently. Return only valid JSON with top-level "verdict", "evidence", "acceptance", and optional "violations". Each "acceptance" entry must include "id", "verdict", and non-empty "evidence". Do not use Markdown fences or prose outside the JSON object.' }
+    skills: [critique, doubt]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/acceptance.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-thermo-nuclear-reviewer:
+    runner: opencode
+    scheduling_roles: [coverage]
+    description: Perform the final thermo-nuclear code quality review of the integration branch.
+    instructions: { inline: "Perform the final code quality review of the integration branch." }
+    skills: [critique]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/review.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-verifier:
+    runner: opencode
+    scheduling_roles: [coverage]
+    description: Verify checks, implementation fit, and final evidence.
+    instructions: { inline: 'Verify checks, implementation fit, and final evidence. Return only valid JSON with top-level "verdict", "evidence", and optional "violations". Do not use Markdown fences or prose outside the JSON object.' }
+    skills: [verify, critique, secure, optimize]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/verify.schema.json
+      repair: { enabled: true, max_attempts: 1 }
+  moka-learner:
+    runner: opencode
+    model: openai/gpt-5.5-low
+    description: Store durable lessons from the completed run.
+    instructions: { inline: "Store durable lessons from the completed run when useful." }
+    skills: [migrate]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/learn.schema.json
+      repair: { enabled: true, max_attempts: 1 }

package/defaults/runners.yaml

@@ -0,0 +1,24 @@
+version: 1
+runners:
+  opencode:
+    type: opencode
+    capabilities:
+      native_subagents: true
+      rules: true
+      skills: true
+      mcp_servers: true
+      tools: [read, list, grep, glob, bash, edit, write]
+      filesystem: [read-only, workspace-write]
+      network: [inherit, disabled]
+      output_formats: [text, json, jsonl, json_schema]
+  command:
+    type: command
+    capabilities:
+      native_subagents: false
+      rules: false
+      skills: false
+      mcp_servers: false
+      tools: [bash]
+      filesystem: [read-only, workspace-write]
+      network: [inherit, disabled]
+      output_formats: [text, json]

package/dist/argo-graph.js

@@ -1,11 +1,6 @@
 import { uniqueStrings } from "./strings.js";
 import { z } from "zod";
 //#region src/argo-graph.ts
-const EXECUTABLE_NODE_KINDS = [
-	"agent",
-	"builtin",
-	"command"
-];
 const argoExecutableTaskSchema = z.object({
 	dependencies: z.array(z.string().min(1)),
 	nodeId: z.string().min(1),
@@ -18,6 +13,21 @@ const argoExecutionGraphSchema = z.object({
 	terminalTaskNames: z.array(z.string().min(1)),
 	workflowId: z.string().min(1)
 }).strict();
+/**
+* Thrown when the Argo graph compiler encounters a node kind that cannot be
+* lowered to an Argo DAG task. Callers should surface this as a validation
+* failure before attempting a cluster submission.
+*/
+var ArgoGraphCompilerError = class extends Error {
+	kind;
+	nodeId;
+	constructor(kind, nodeId) {
+		super(`Argo graph compiler: node kind '${kind}' on node '${nodeId}' cannot be lowered to an Argo DAG task`);
+		this.name = "ArgoGraphCompilerError";
+		this.kind = kind;
+		this.nodeId = nodeId;
+	}
+};
 function compileArgoExecutionGraph(plan) {
 	const compiler = new ArgoGraphCompiler(plan);
 	return argoExecutionGraphSchema.parse(compiler.compile());
@@ -47,41 +57,63 @@ var ArgoGraphCompiler = class {
 		}
 	}
 	compileNodes(nodes, inheritedNeeds) {
-		for (const node of nodes) {
-			if (isExecutableNode(node)) {
-				const dependencies = this.resolveDependencyTaskNames([...inheritedNeeds, ...node.needs]);
-				const task = argoExecutableTaskSchema.parse({
-					dependencies,
-					nodeId: node.id,
-					taskName: argoTaskName(node.id),
-					templateName: argoTemplateName(node.id)
-				});
-				this.tasks.push(task);
-				continue;
-			}
-			if (node.kind === "group") continue;
-			if (node.kind === "parallel") this.compileNodes(node.children ?? [], [...inheritedNeeds, ...node.needs]);
+		for (const node of nodes) this.compileNode(node, inheritedNeeds);
+	}
+	compileNode(node, inheritedNeeds) {
+		const kind = node.kind;
+		switch (kind) {
+			case "agent":
+			case "builtin":
+			case "command":
+				this.compileExecutableNode(node, inheritedNeeds);
+				return;
+			case "group": return;
+			case "parallel":
+				this.compileParallelNode(node, inheritedNeeds);
+				return;
+			default: throw new ArgoGraphCompilerError(String(kind), node.id);
 		}
 	}
+	compileExecutableNode(node, inheritedNeeds) {
+		const dependencies = this.resolveDependencyTaskNames([...inheritedNeeds, ...node.needs]);
+		const task = argoExecutableTaskSchema.parse({
+			dependencies,
+			nodeId: node.id,
+			taskName: argoTaskName(node.id),
+			templateName: argoTemplateName(node.id)
+		});
+		this.tasks.push(task);
+	}
+	compileParallelNode(node, inheritedNeeds) {
+		this.compileNodes(node.children ?? [], [...inheritedNeeds, ...node.needs]);
+	}
 	resolveDependencyTaskNames(nodeIds) {
 		return uniqueStrings(nodeIds.flatMap((nodeId) => this.resolveDependencyNodeIds(nodeId).map((id) => argoTaskName(id))));
 	}
 	resolveDependencyNodeIds(nodeId) {
 		const node = this.nodeById.get(nodeId);
 		if (!node) return [];
-		if (isExecutableNode(node)) return [node.id];
-		if (node.kind === "group") return uniqueStrings([...node.nodes ?? [], ...node.needs].flatMap((id) => this.resolveDependencyNodeIds(id)));
-		if (node.kind === "parallel") return uniqueStrings((node.children ?? []).flatMap((child) => this.resolveDependencyNodeIds(child.id)));
-		return [];
+		const kind = node.kind;
+		switch (kind) {
+			case "agent":
+			case "builtin":
+			case "command": return [node.id];
+			case "group": return this.resolveGroupNodeIds(node);
+			case "parallel": return this.resolveParallelNodeIds(node);
+			default: throw new ArgoGraphCompilerError(String(kind), node.id);
+		}
+	}
+	resolveGroupNodeIds(node) {
+		return uniqueStrings([...node.nodes ?? [], ...node.needs].flatMap((id) => this.resolveDependencyNodeIds(id)));
+	}
+	resolveParallelNodeIds(node) {
+		return uniqueStrings((node.children ?? []).flatMap((child) => this.resolveDependencyNodeIds(child.id)));
 	}
 	terminalTasks() {
 		const dependedOn = new Set(this.tasks.flatMap((task) => task.dependencies));
 		return this.tasks.filter((task) => !dependedOn.has(task.taskName));
 	}
 };
-function isExecutableNode(node) {
-	return EXECUTABLE_NODE_KINDS.includes(node.kind);
-}
 function argoTaskName(nodeId) {
 	return `node-${nodeId}`;
 }
@@ -89,4 +121,4 @@ function argoTemplateName(nodeId) {
 	return `task-${nodeId}`;
 }
 //#endregion
-export { compileArgoExecutionGraph };
+export { ArgoGraphCompilerError, compileArgoExecutionGraph };

package/dist/argo-submit.d.ts

@@ -22,7 +22,6 @@ declare const submitRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
   namespace: z.ZodString;
   opencodeAuthSecretName: z.ZodOptional<z.ZodString>;
   payloadJson: z.ZodString;
-  queueName: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodString;
   serviceAccountName: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/argo-submit.js

@@ -1,10 +1,9 @@
-import { compileArgoExecutionGraph } from "./argo-graph.js";
+import { ArgoGraphCompilerError, compileArgoExecutionGraph } from "./argo-graph.js";
 import { buildRunnerTaskDescriptor } from "./runner-command/task-descriptor.js";
 import { buildRunnerArgoWorkflowManifest, runnerArgoWorkflowManifestSchema } from "./argo-workflow.js";
 import { normalizeRunnerRepositoryForSubmit } from "./git-remote-url.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
 import { parseRunnerCommandPayload, runnerCommandPayloadSchema } from "./runner-command-contract.js";
-import { compileScheduleArtifact, parseScheduleArtifact } from "./schedule/planner.js";
-import "./schedule-planner.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { stringify } from "yaml";
 import { z } from "zod";
@@ -40,7 +39,6 @@ const submitRunnerArgoWorkflowOptionsSchema = z.object({
 	namespace: z.string().min(1),
 	opencodeAuthSecretName: z.string().min(1).optional(),
 	payloadJson: z.string().min(1),
-	queueName: z.string().min(1).optional(),
 	scheduleYaml: z.string().min(1),
 	serviceAccountName: z.string().min(1).optional()
 }).strict().refine((options) => options.name !== void 0 || options.generateName !== void 0, { message: "Argo submit options must declare name or generateName" });
@@ -62,7 +60,7 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 	const scheduleArtifactConfigMapName = `pipeline-schedule-${randomBytes(6).toString("hex")}`;
 	const taskDescriptorConfigMapName = `pipeline-task-descriptors-${randomBytes(6).toString("hex")}`;
 	if (payload.workflow.id !== compiled.workflowId) throw new Error(`Runner payload workflow '${payload.workflow.id}' does not match schedule workflow '${compiled.workflowId}'`);
-	const graph = compileArgoExecutionGraph(compiled.plan);
+	const graph = compileSubmitArgoGraph(compiled);
 	const labels = {
 		"pipeline.oisin.dev/project": payload.run.project,
 		"pipeline.oisin.dev/run-id": payload.run.id,
@@ -89,7 +87,6 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 		opencodeAuthSecretName: options.opencodeAuthSecretName,
 		payloadConfigMapName,
 		plan: compiled.plan,
-		queueName: options.queueName,
 		scheduleConfigMapName: scheduleArtifactConfigMapName,
 		serviceAccountName: options.serviceAccountName,
 		taskDescriptorConfigMapName
@@ -184,6 +181,14 @@ function normalizeRunnerPayloadForSubmit(input) {
 		payloadJson: JSON.stringify(payload)
 	};
 }
+function compileSubmitArgoGraph(compiled) {
+	try {
+		return compileArgoExecutionGraph(compiled.plan);
+	} catch (err) {
+		if (err instanceof ArgoGraphCompilerError) throw new Error(`Schedule '${compiled.workflowId}' cannot be submitted: ${err.message}`);
+		throw err;
+	}
+}
 function apiClients(options, dependencies) {
 	if (dependencies.coreApi && dependencies.workflowApi) return {
 		coreApi: dependencies.coreApi,

package/dist/argo-workflow.d.ts

@@ -1,4 +1,4 @@
-import { WorkflowExecutionPlan } from "./workflow-planner.js";
+import { WorkflowExecutionPlan } from "./planning/compile.js";
 import { z } from "zod";
 
 //#region src/argo-workflow.d.ts
@@ -143,7 +143,6 @@ declare const buildRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
   }, z.core.$strict>>;
   payloadConfigMapKey: z.ZodDefault<z.ZodString>;
   payloadConfigMapName: z.ZodString;
-  queueName: z.ZodOptional<z.ZodString>;
   resources: z.ZodOptional<z.ZodObject<{
     limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     requests: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/argo-workflow.js

@@ -153,7 +153,6 @@ const buildRunnerArgoWorkflowOptionsSchema = z.object({
 	}).strict().optional(),
 	payloadConfigMapKey: z.string().min(1).default("payload.json"),
 	payloadConfigMapName: kubernetesNameSchema,
-	queueName: kubernetesNameSchema.optional(),
 	resources: argoWorkflowResourceRequirementsSchema.optional(),
 	scheduleConfigMapKey: z.string().min(1).default("schedule.yaml"),
 	scheduleConfigMapName: kubernetesNameSchema,
@@ -191,7 +190,6 @@ function buildRunnerArgoWorkflowManifest(rawOptions) {
 			...options.activeDeadlineSeconds ? { activeDeadlineSeconds: options.activeDeadlineSeconds } : {},
 			entrypoint: RUNNER_WORKFLOW_ENTRYPOINT,
 			...options.imagePullSecretName ? { imagePullSecrets: [{ name: options.imagePullSecretName }] } : {},
-			...options.queueName ? { podMetadata: { labels: { "kueue.x-k8s.io/queue-name": options.queueName } } } : {},
 			onExit: "pipeline-finalizer",
 			serviceAccountName: options.serviceAccountName,
 			templates: [