@oisincoveney/pipeline 2.2.0 → 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/profiles.yaml

@@ -30,6 +30,9 @@ mcp_gateway:
       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
@@ -85,8 +88,8 @@ profiles:
   moka-orchestrator:
     runner: opencode
     description: Orchestrate the configured pipeline and enforce gates.
-    instructions: { inline: "Orchestrate the configured pipeline through package-defined entrypoints, native agents, and gates. Do not bypass configured runner subprocesses or package-configured gates." }
-    skills: [execute, quick, inspect]
+    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/**"] }

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

@@ -2,9 +2,8 @@ import { ArgoGraphCompilerError, compileArgoExecutionGraph } from "./argo-graph.
 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" });
@@ -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

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: [

package/dist/cli/program.js

@@ -2,9 +2,8 @@ import { PipelineConfigError } from "../config/schemas.js";
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
 import { createOrchestratorLaunchPlan, createRunnerLaunchPlan } from "../runner.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
-import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "../schedule/planner.js";
-import "../schedule-planner.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
+import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
 import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { defaultClusterDoctorNamespace, runClusterDoctor } from "../cluster-doctor.js";
 import { formatCodexAuthSyncResult, syncLocalCodexAuth } from "../codex-auth-sync.js";

package/dist/cli/submit-options.js

@@ -48,7 +48,6 @@ function mokaCommonSubmitOptions(input) {
 		name: input.flags.name,
 		namespace: input.flags.namespace ?? momokaya?.kubernetes.namespace,
 		opencodeAuthSecretName: momokaya?.submit.opencodeAuthSecretName,
-		queueName: input.flags.queueName ?? momokaya?.submit.queueName,
 		serviceAccountName: input.flags.serviceAccount ?? momokaya?.submit.serviceAccountName,
 		worktreePath: input.cwd
 	};
@@ -77,7 +76,7 @@ function submitMokaGraphInput(input, flags, commonOptions) {
 function addRunnerArgoOptions(command, options = {}) {
 	command.option("--name <name>", "Workflow metadata.name").option("--generate-name <prefix>", "Workflow metadata.generateName").option("--namespace <namespace>", "Workflow namespace");
 	if (options.kubeconfig) command.option("--kubeconfig <path>", "kubeconfig path");
-	return command.option("--queue-name <name>", "Kueue LocalQueue label for Workflow pods").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").addOption(new Option("--image-pull-policy <policy>", "runner image pull policy").choices([
+	return command.option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").addOption(new Option("--image-pull-policy <policy>", "runner image pull policy").choices([
 		"Always",
 		"IfNotPresent",
 		"Never"

package/dist/cluster-doctor.js

@@ -10,7 +10,6 @@ const DEFAULT_RESOURCES = {
 	githubAuthSecretName: "oisin-bot-github-auth",
 	imagePullSecretName: "ghcr-pull-secret",
 	opencodeAuthSecretName: "opencode-auth-1",
-	queueName: "pipeline-runner",
 	serviceAccountName: "pipeline-runner"
 };
 const FORBIDDEN_RE = /forbidden/i;
@@ -32,7 +31,6 @@ async function runClusterDoctor(options = {}) {
 			verb: "create",
 			...kubectlOptions
 		}),
-		checkLocalQueue(namespace, resources.queueName, kubectlOptions),
 		checkClusterResource("argo-workflow-crd", [
 			"get",
 			"crd",
@@ -63,7 +61,6 @@ function clusterResources() {
 		githubAuthSecretName: configured.githubAuthSecretName,
 		imagePullSecretName: configured.imagePullSecretName,
 		opencodeAuthSecretName: configured.opencodeAuthSecretName,
-		queueName: configured.queueName,
 		serviceAccountName: configured.serviceAccountName
 	} : DEFAULT_RESOURCES;
 }
@@ -169,15 +166,6 @@ async function checkWorkflowSubmitPermission(namespace, options) {
 		passed: false
 	};
 }
-function checkLocalQueue(namespace, queueName, kubectlOptions) {
-	return checkNamespacedResource(`localqueue/${queueName}`, [
-		"get",
-		"localqueue",
-		queueName,
-		"-n",
-		namespace
-	], `Kueue LocalQueue ${queueName} missing in ${namespace}; runner Workflow pods cannot be admitted to the expected queue.`, kubectlOptions);
-}
 async function checkClusterResource(name, args, kubectlOptions) {
 	const result = await kubectl(args, kubectlOptions);
 	return result.ok ? {

package/dist/commands/pipeline-command.js

@@ -17,7 +17,7 @@ function registerConfiguredEntrypointCommands(program, config, runEntrypoint) {
 	for (const [id, entrypoint] of Object.entries(config.entrypoints)) {
 		if (reservedCommands.has(id)) continue;
 		const command = program.command(id).description(entrypoint.description ?? `Run the ${id} workflow`).argument("<description...>", "task description");
-		if ("schedule" in entrypoint) command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--queue-name <name>", "Kueue LocalQueue label for Workflow pods").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
+		if ("schedule" in entrypoint) command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
 		command.action(async (descriptionParts, flags) => {
 			await runEntrypoint(id, descriptionParts.join(" "), flags);
 		});

package/dist/config/schemas.d.ts

@@ -220,8 +220,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";
@@ -245,8 +245,8 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     default_profile: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
-      hosted: "hosted";
       local: "local";
+      hosted: "hosted";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -289,10 +289,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>;
@@ -361,10 +361,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>;

package/dist/install-commands/opencode.js

@@ -1,7 +1,7 @@
 import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST } from "../config/defaults.js";
 import { resolvePackageAssetPath } from "../package-assets.js";
 import "../config.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
 import { mergeOpenCodeProjectConfig } from "../opencode-project-config.js";
 import { renderOpenCodeGatewayConfig } from "../mcp/gateway.js";
 import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
@@ -149,10 +149,19 @@ function scheduledEntrypointK8sNote(entrypoint) {
 	if ("workflow" in entrypoint) return;
 	return "Submit Momokaya work as Argo Workflows through `moka submit` and `moka submit --quick`.";
 }
-function orchestratorEntrypointDispatchBlock(host, config) {
-	const scheduledEntrypoints = entrypointEntries(config).filter(([, entrypoint]) => !("workflow" in entrypoint));
-	if (scheduledEntrypoints.length === 0) return dispatchBlock(host, config);
-	return scheduledEntrypoints.map(([id, entrypoint]) => entrypointDispatchBlock(host, config, id, entrypoint)).filter((block) => Boolean(block)).join("\n\n");
+function localRosterAgentIds(config) {
+	return nativeProfileEntries("opencode", config).map(([id]) => nativeAgentIdForHost("opencode", id));
+}
+function localOrchestratorDispatchBlock(config) {
+	return [
+		"Orchestrate locally. Load and follow the `orchestrate` skill.",
+		"Do not submit to Argo or run `moka submit`. Spawn the roster as native Task subagents on this machine and run nodes with satisfied dependencies in parallel.",
+		"",
+		"Roster (Task tool subagent_type):",
+		...localRosterAgentIds(config).map((id) => `- ${id}`),
+		"",
+		"Gather each subagent's structured output, enforce only package-configured gates, and report only the evidence the subagents returned."
+	].join("\n");
 }
 function nativeDispatchBlock(host, routes) {
 	if (routes.length === 0) return;
@@ -325,13 +334,13 @@ function opencodeDefinitions(config, cwd) {
 				description: "Orchestrate the configured pipeline and enforce gates.",
 				mode: "primary",
 				name: OPENCODE_ORCHESTRATOR_AGENT_ID,
-				permission: opencodePermission(orchestrator, { allowedTaskAgents: agentDispatchRoutes("opencode", config).filter((route) => route.kind !== "cli").map((route) => route.nativeAgentId).filter((id) => Boolean(id)) })
+				permission: opencodePermission(orchestrator, { allowedTaskAgents: localRosterAgentIds(config) })
 			}, compactLines([
 				header("opencode").trimEnd(),
 				"",
 				orchestratorBlock(config),
 				"",
-				orchestratorEntrypointDispatchBlock("opencode", config)
+				localOrchestratorDispatchBlock(config)
 			]).join("\n")),
 			host: "opencode",
 			invocation: invocationForHost("opencode"),
@@ -382,6 +391,7 @@ function projectAgentsMdDefinition(cwd, host) {
 			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` for OpenCode slash-command entrypoints when available.",
 			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
 			"- Prefer the package-defined pipeline profiles and generated command surfaces over ad hoc subagent prompts.",
+			"- When the user needs to run a command, copy the command into the clipboard and tell the user what needs to be returned.",
 			"",
 			"## Pipeline Memory",
 			"",

package/dist/moka-global-config.d.ts

@@ -16,7 +16,6 @@ declare const mokaGlobalConfigSchema: z.ZodObject<{
       githubAuthSecretName: z.ZodString;
       imagePullSecretName: z.ZodString;
       opencodeAuthSecretName: z.ZodString;
-      queueName: z.ZodString;
       serviceAccountName: z.ZodString;
     }, z.core.$strict>;
   }, z.core.$strict>;

package/dist/moka-global-config.js

@@ -15,7 +15,6 @@ const mokaSubmitGlobalConfigSchema = z.object({
 	githubAuthSecretName: z.string().min(1),
 	imagePullSecretName: z.string().min(1),
 	opencodeAuthSecretName: z.string().min(1),
-	queueName: z.string().min(1),
 	serviceAccountName: z.string().min(1)
 }).strict();
 const mokaKubernetesGlobalConfigSchema = z.object({

package/dist/moka-submit.d.ts

@@ -1,5 +1,5 @@
 import { PipelineConfig } from "./config/schemas.js";
-import { generateScheduleArtifact } from "./schedule/planner.js";
+import { generateScheduleArtifact } from "./planning/generate.js";
 import { z } from "zod";
 
 //#region src/moka-submit.d.ts
@@ -148,7 +148,6 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
   opencodeAuthSecretName: z.ZodOptional<z.ZodString>;
-  queueName: z.ZodOptional<z.ZodString>;
   repository: z.ZodOptional<z.ZodObject<{
     baseBranch: z.ZodString;
     sha: z.ZodOptional<z.ZodString>;
@@ -261,7 +260,6 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
   opencodeAuthSecretName: z.ZodOptional<z.ZodString>;
-  queueName: z.ZodOptional<z.ZodString>;
   repository: z.ZodOptional<z.ZodObject<{
     baseBranch: z.ZodString;
     sha: z.ZodOptional<z.ZodString>;
@@ -327,7 +325,6 @@ interface MokaWorkflowSubmitOptions {
   namespace: string;
   opencodeAuthSecretName?: string;
   payloadJson: string;
-  queueName?: string;
   scheduleYaml: string;
   serviceAccountName?: string;
 }

package/dist/moka-submit.js

@@ -1,7 +1,6 @@
 import { normalizeRunnerRepositoryForSubmit } from "./git-remote-url.js";
+import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
 import { buildRunnerCommandPayload, runnerDeliverySchema, runnerHookPolicySchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskSchema } from "./runner-command-contract.js";
-import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./schedule/planner.js";
-import "./schedule-planner.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { buildCommandScheduleYaml, submitRunnerArgoWorkflow } from "./argo-submit.js";
 import { z } from "zod";
@@ -79,7 +78,6 @@ const mokaSubmitBaseOptionsSchema = z.object({
 	name: z.string().min(1).optional(),
 	namespace: z.string().min(1).optional(),
 	opencodeAuthSecretName: z.string().min(1).optional(),
-	queueName: z.string().min(1).optional(),
 	repository: runnerRepositoryContextSchema.optional(),
 	run: runnerRunIdentitySchema.optional(),
 	serviceAccountName: z.string().min(1).optional()
@@ -293,7 +291,6 @@ function workflowSubmitOptions(options) {
 		name: options.name,
 		namespace: requireSubmitOption(options.namespace, "namespace"),
 		opencodeAuthSecretName: options.opencodeAuthSecretName,
-		queueName: options.queueName,
 		serviceAccountName: options.serviceAccountName
 	};
 }

package/dist/pipeline-runtime.d.ts

@@ -1,6 +1,15 @@
 import { PipelineConfigError } from "./config/schemas.js";
 import { AcceptanceCriterion, HookRuntimePolicy, NodeExecutionState, NodeStatus, PipelineRuntimeEvent, PipelineRuntimeObservabilityLevel, PipelineRuntimeOptions, PipelineRuntimeResult, PipelineTaskContext, RuntimeFailure, RuntimeGateResult, RuntimeNodeResult, RuntimeStructuredOutput } from "./runtime/contracts/contracts.js";
 //#region src/pipeline-runtime.d.ts
+/**
+ * Top layer of the runtime-options stack (PIPE-74 B3). Extends
+ * {@link PipelineRuntimeOptions} for the schedule-driven path that runs a
+ * SINGLE workflow node (`nodeId`) in isolation, supplying that node's upstream
+ * `dependencyOutputs`. Full stack:
+ *   RunnerExecutionOptions (src/runner.ts)
+ *     < PipelineRuntimeOptions (src/runtime/contracts/contracts.ts)
+ *     < ScheduledWorkflowTaskRuntimeOptions (this type)
+ */
 interface ScheduledWorkflowTaskRuntimeOptions extends PipelineRuntimeOptions {
   dependencyOutputs?: Map<string, string> | Record<string, string>;
   nodeId: string;

package/dist/planned-node.js

@@ -1,10 +1,7 @@
+import { findNode } from "./planning/graph.js";
 //#region src/planned-node.ts
 function findPlannedNode(nodes, nodeId) {
-	for (const node of nodes) {
-		if (node.id === nodeId) return node;
-		const child = findPlannedNode(node.children ?? [], nodeId);
-		if (child) return child;
-	}
+	return findNode(nodes, nodeId, (node) => node.children);
 }
 //#endregion
 export { findPlannedNode };

package/dist/{workflow-planner.d.ts → planning/compile.d.ts}

@@ -1,7 +1,7 @@
-import { PipelineConfig, WorkflowNodeKind } from "./config/schemas.js";
+import { PipelineConfig, WorkflowNodeKind } from "../config/schemas.js";
 import { Graph } from "@dagrejs/graphlib";
 
-//#region src/workflow-planner.d.ts
+//#region src/planning/compile.d.ts
 type WorkflowPlannerErrorCode = "WORKFLOW_CYCLE" | "WORKFLOW_DUPLICATE_NODE" | "WORKFLOW_GROUP_REFERENCE" | "WORKFLOW_MISSING_DEPENDENCY" | "WORKFLOW_MISSING_WORKFLOW";
 interface WorkflowPlannerIssue {
   message: string;

package/dist/{workflow-planner.js → planning/compile.js}

@@ -1,6 +1,7 @@
-import { uniqueStrings } from "./strings.js";
+import { uniqueStrings } from "../strings.js";
+import { findDependencyCycles } from "./graph.js";
 import { Graph } from "@dagrejs/graphlib";
-//#region src/workflow-planner.ts
+//#region src/planning/compile.ts
 var WorkflowPlannerError = class extends Error {
 	code;
 	issues;
@@ -54,7 +55,7 @@ function validateNodeGraph(workflowId, nodes) {
 		...groupIssues(workflowId, nodes, nodeIds),
 		...dependencyIssues(workflowId, nodes, nodeIds)
 	];
-	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes, nodeIds)];
+	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes)];
 	return issues;
 }
 function duplicateNodeIssues(workflowId, nodes) {
@@ -100,92 +101,14 @@ function groupChildIssues(workflowId, node, nodeIds) {
 function isGroupNode(node) {
 	return node.kind === "group";
 }
-function cycleIssues(workflowId, nodes, nodeIds) {
-	return dependencyCycles(nodes, nodeIds).map((cycle) => {
+function cycleIssues(workflowId, nodes) {
+	return findDependencyCycles(nodes).map((cycle) => {
 		return {
 			path: `workflows.${workflowId}.nodes.${cycle[0] ?? "nodes"}.needs`,
 			message: `workflow '${workflowId}' contains dependency cycle: ${cycle.join(" -> ")}`
 		};
 	});
 }
-function dependencyCycles(nodes, nodeIds) {
-	const dependentsByNeed = dependentsByNeedMap(nodes, nodeIds);
-	const state = /* @__PURE__ */ new Map();
-	const path = [];
-	const pathIndex = /* @__PURE__ */ new Map();
-	const cycles = [];
-	const cycleKeys = /* @__PURE__ */ new Set();
-	for (const node of nodes) {
-		if (state.has(node.id)) continue;
-		visitForCycles(node.id, {
-			cycleKeys,
-			cycles,
-			dependentsByNeed,
-			path,
-			pathIndex,
-			state
-		});
-	}
-	return cycles;
-}
-function visitForCycles(startId, visitState) {
-	const frames = [{
-		index: 0,
-		nodeId: startId
-	}];
-	markVisiting(startId, visitState);
-	while (frames.length > 0) {
-		const frame = frames.at(-1);
-		if (!frame) return;
-		const dependentId = (visitState.dependentsByNeed.get(frame.nodeId) ?? [])[frame.index];
-		if (!dependentId) {
-			markDone(frame.nodeId, visitState);
-			frames.pop();
-			continue;
-		}
-		frame.index += 1;
-		const dependentState = visitState.state.get(dependentId);
-		if (dependentState === "visiting") {
-			recordCycle(dependentId, visitState);
-			continue;
-		}
-		if (dependentState === "done") continue;
-		markVisiting(dependentId, visitState);
-		frames.push({
-			index: 0,
-			nodeId: dependentId
-		});
-	}
-}
-function markVisiting(nodeId, visitState) {
-	visitState.state.set(nodeId, "visiting");
-	visitState.pathIndex.set(nodeId, visitState.path.length);
-	visitState.path.push(nodeId);
-}
-function markDone(nodeId, visitState) {
-	visitState.state.set(nodeId, "done");
-	visitState.pathIndex.delete(nodeId);
-	visitState.path.pop();
-}
-function recordCycle(nodeId, visitState) {
-	const startIndex = visitState.pathIndex.get(nodeId);
-	if (startIndex === void 0) return;
-	const cycle = visitState.path.slice(startIndex);
-	const key = [...cycle].sort().join("\0");
-	if (visitState.cycleKeys.has(key)) return;
-	visitState.cycleKeys.add(key);
-	visitState.cycles.push(cycle);
-}
-function dependentsByNeedMap(nodes, nodeIds) {
-	const dependentsByNeed = /* @__PURE__ */ new Map();
-	for (const node of nodes) for (const need of uniqueStrings(node.needs ?? [])) {
-		if (!nodeIds.has(need)) continue;
-		const dependents = dependentsByNeed.get(need) ?? [];
-		dependents.push(node.id);
-		dependentsByNeed.set(need, dependents);
-	}
-	return dependentsByNeed;
-}
 function topologicalOrderForPlan(graph) {
 	const visited = /* @__PURE__ */ new Set();
 	const inStack = /* @__PURE__ */ new Set();

package/dist/{schedule/planner.d.ts → planning/generate.d.ts}

@@ -1,9 +1,9 @@
 import { PipelineConfig } from "../config/schemas.js";
-import { WorkflowExecutionPlan } from "../workflow-planner.js";
+import { WorkflowExecutionPlan } from "./compile.js";
 import { AgentResult, RunnerExecutionOptions, RunnerLaunchPlan } from "../runner.js";
 import { z } from "zod";
 
-//#region src/schedule/planner.d.ts
+//#region src/planning/generate.d.ts
 declare const scheduleArtifactSchema: z.ZodObject<{
   generated_at: z.ZodString;
   kind: z.ZodLiteral<"pipeline-schedule">;
@@ -1575,6 +1575,20 @@ interface GenerateScheduleResult {
   artifact: ScheduleArtifact;
   path: string;
 }
+interface BacklogWorkUnit {
+  acceptance_criteria: Array<{
+    id: string;
+    text: string;
+  }>;
+  dependencies?: string[];
+  description?: string;
+  id: string;
+  title?: string;
+}
+interface SchedulePlanningContext {
+  parentWorkUnits: BacklogWorkUnit[];
+  workUnits: BacklogWorkUnit[];
+}
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
 declare class ScheduleArtifactError extends Error {
   constructor(message: string);
@@ -1583,4 +1597,4 @@ declare function compileScheduleArtifact(config: PipelineConfig, artifact: Sched
 declare function generateScheduleArtifact(options: GenerateScheduleOptions): Promise<GenerateScheduleResult>;
 declare function scheduleArtifactPath(worktreePath: string, scheduleId: string): string;
 //#endregion
-export { CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };
+export { BacklogWorkUnit, CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, SchedulePlanningContext, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };