@oisincoveney/pipeline 2.1.1 → 2.3.0

package/dist/install-commands/claude-code.js

@@ -0,0 +1,160 @@
+import { renderClaudeGatewayMcpServers } from "../mcp/gateway.js";
+import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
+import { mergeClaudeSettings } from "../claude-settings-config.js";
+import { CLAUDE_PROJECT_CONFIG_PATH, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost } from "./shared.js";
+import { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, projectAgentsMdDefinition, resolvedHostModel, scheduledEntrypointK8sNote } from "./opencode.js";
+//#region src/install-commands/claude-code.ts
+const CLAUDE_CODE_HOST = "claude-code";
+const CLAUDE_ALLOWED_TOOLS = "Task, Bash(opencode run *)";
+const CLAUDE_AGENT_TOOLS = "Bash, Read";
+const MOKA_PROFILE_PREFIX = "moka-";
+function claudeAgentNameForProfile(profileId) {
+	return profileId.startsWith(MOKA_PROFILE_PREFIX) ? profileId : `${MOKA_PROFILE_PREFIX}${profileId}`;
+}
+function cliRoutesForConfig(config) {
+	return entrypointEntries(config).flatMap(([, entrypoint]) => "workflow" in entrypoint ? agentDispatchRoutes(CLAUDE_CODE_HOST, config, entrypoint.workflow) : []);
+}
+function distinctCliProfiles(config) {
+	const seen = /* @__PURE__ */ new Set();
+	const profiles = [];
+	for (const route of cliRoutesForConfig(config)) {
+		if (route.kind !== "cli" || seen.has(route.profileId)) continue;
+		seen.add(route.profileId);
+		profiles.push(route);
+	}
+	return profiles.sort((a, b) => a.profileId.localeCompare(b.profileId));
+}
+function commandDispatchBody(config, id, entrypoint) {
+	if (!("workflow" in entrypoint)) return entrypointDispatchBlock(CLAUDE_CODE_HOST, config, id, entrypoint) ?? "";
+	const routes = agentDispatchRoutes(CLAUDE_CODE_HOST, config, entrypoint.workflow);
+	return [
+		`Run workflow \`${entrypoint.workflow}\` for the user task.`,
+		"",
+		"Delegate each agent node to a Claude Code `Task` subagent that wraps a local `opencode run` subprocess.",
+		"Spawn one node at a time respecting `needs`; run nodes whose dependencies are satisfied in parallel.",
+		"",
+		"Node routes:",
+		...routes.map(claudeNodeRouteLine),
+		"",
+		"For each node prompt include:",
+		"- user task",
+		`- workflow id: ${entrypoint.workflow}`,
+		"- node id",
+		"- profile id",
+		"- profile instructions reference",
+		"- profile grants",
+		"- dependency outputs",
+		"",
+		"Only package-configured gates are blocking. Do not invent RED, GREEN, full-suite, typecheck, or unrelated-drift gates.",
+		"If a node returns targeted evidence and has no configured blocking gate, advance to the next node.",
+		"The Task subagents wrap `opencode run` subprocesses; do not claim these worker nodes are Claude Code native agents."
+	].join("\n");
+}
+function claudeNodeRouteLine(route) {
+	const needs = route.needs.length > 0 ? route.needs.join(",") : "none";
+	return `- ${route.nodeId}: Task subagent_type=${claudeAgentNameForProfile(route.profileId)} runner=${route.runnerId} agent="${opencodeAgentName(route.profileId)}" needs=${needs}`;
+}
+function commandDefinitions(config) {
+	return entrypointEntries(config).map(([id, entrypoint]) => ({
+		content: markdown({
+			"argument-hint": "<task description>",
+			"allowed-tools": CLAUDE_ALLOWED_TOOLS,
+			description: entrypointDescription(id, entrypoint)
+		}, compactLines([
+			header(CLAUDE_CODE_HOST).trimEnd(),
+			"",
+			`Invoke this command with \`${invocationForHost(CLAUDE_CODE_HOST, id)}\`.`,
+			"",
+			"Load and follow the `execute` skill for the execution doctrine before dispatching work.",
+			"",
+			scheduledEntrypointK8sNote(entrypoint),
+			scheduledEntrypointK8sNote(entrypoint) ? "" : void 0,
+			commandDispatchBody(config, id, entrypoint)
+		]).join("\n")),
+		host: CLAUDE_CODE_HOST,
+		invocation: invocationForHost(CLAUDE_CODE_HOST, id),
+		path: `.claude/commands/${commandIdForHost(CLAUDE_CODE_HOST, id)}.md`
+	}));
+}
+function agentModelProjection(config, profile) {
+	const model = resolvedHostModel(config, CLAUDE_CODE_HOST, profile);
+	return model ? { model } : {};
+}
+function agentDefinitions(config) {
+	return distinctCliProfiles(config).map((route) => {
+		const profile = route.profile;
+		const agentName = claudeAgentNameForProfile(route.profileId);
+		const displayName = opencodeAgentName(route.profileId);
+		return {
+			content: markdown({
+				name: agentName,
+				description: profile.description ?? route.profileId,
+				tools: CLAUDE_AGENT_TOOLS,
+				...agentModelProjection(config, profile)
+			}, [
+				header(CLAUDE_CODE_HOST).trimEnd(),
+				"",
+				profile.description ?? route.profileId,
+				"",
+				`Run EXACTLY ONE \`opencode run --agent "${displayName}" --format json --dir "$PWD" '<node prompt>'\` subprocess for this node.`,
+				"Stay inside this node's scope and do not branch into adjacent nodes.",
+				"Do not claim completion without fresh evidence from the subprocess output.",
+				"Return only: { command, exit status, parsed evidence, touched files, blockers }.",
+				"",
+				"Configured grants:",
+				grants(profile),
+				"",
+				instructionsPointer(profile)
+			].join("\n")),
+			host: CLAUDE_CODE_HOST,
+			invocation: invocationForHost(CLAUDE_CODE_HOST),
+			path: `.claude/agents/${agentName}.md`
+		};
+	});
+}
+function settingsDefinition(config) {
+	const settings = { permissions: { allow: ["Task", "Bash(opencode run *)"] } };
+	if (config.mcp_gateway) settings.mcpServers = renderClaudeGatewayMcpServers(config);
+	return [{
+		content: `${JSON.stringify(settings, null, 2)}\n`,
+		host: CLAUDE_CODE_HOST,
+		invocation: invocationForHost(CLAUDE_CODE_HOST),
+		path: CLAUDE_PROJECT_CONFIG_PATH
+	}];
+}
+function claudeCodeDefinitions(config, cwd) {
+	return [
+		...commandDefinitions(config),
+		...agentDefinitions(config),
+		...settingsDefinition(config),
+		projectAgentsMdDefinition(cwd, CLAUDE_CODE_HOST)
+	];
+}
+/**
+* The claude-code HostAdapter. Encapsulates all Claude Code-specific command
+* generation, resource roots, and settings-merge behaviour.
+*/
+const claudeCodeAdapter = {
+	host: "claude-code",
+	resourceRoots: [".claude/commands", ".claude/agents"],
+	definitions(config, cwd) {
+		return claudeCodeDefinitions(config, cwd);
+	},
+	mergeDefinition(definition, existingContent) {
+		if (definition.path !== ".claude/settings.json") return;
+		const merged = mergeClaudeSettings(existingContent, JSON.parse(definition.content));
+		if (!merged.ok) return {
+			ok: false,
+			content: definition.content
+		};
+		return {
+			ok: true,
+			content: merged.content
+		};
+	},
+	isAlwaysForced(definition) {
+		return definition.path === CLAUDE_PROJECT_CONFIG_PATH;
+	}
+};
+//#endregion
+export { claudeCodeAdapter };

package/dist/install-commands/opencode.js

@@ -1,15 +1,16 @@
 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 { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, GENERATED_MARKER, GENERATED_TS_MARKER, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, invocationForHost } from "./shared.js";
+import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
+import { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, GENERATED_MARKER, GENERATED_TS_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost, profileEntries } from "./shared.js";
 import { readFileSync } from "node:fs";
 import { basename } from "node:path";
 import matter from "gray-matter";
 //#region src/install-commands/opencode.ts
 const OPENCODE_ORCHESTRATOR_AGENT_ID = "MoKa Orchestrator";
-const MOKA_PROFILE_PREFIX = "moka-";
 function header(host) {
 	return [
 		GENERATED_MARKER,
@@ -20,19 +21,6 @@ function header(host) {
 function markdown(data, body) {
 	return `${matter.stringify(body.trimEnd(), data).trimEnd()}\n`;
 }
-function profileEntries(config) {
-	return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b));
-}
-function entrypointEntries(config) {
-	const entries = Object.entries(config.entrypoints);
-	return entries.length > 0 ? entries : [["execute", {
-		description: "Run the configured pipeline workflow",
-		workflow: config.default_workflow
-	}]];
-}
-function entrypointDescription(id, entrypoint) {
-	return entrypoint.description ?? `Run the ${id} workflow`;
-}
 function entrypointCommandDefinitions(_host, config, makeDefinition) {
 	return entrypointEntries(config).map(([id, entrypoint]) => makeDefinition(id, entrypoint));
 }
@@ -104,14 +92,6 @@ function dispatchRouteForAgent(host, config, route) {
 function nativeAgentIdForHost(host, profileId) {
 	return host === "opencode" ? opencodeAgentName(profileId) : profileId;
 }
-function opencodeAgentName(profileId) {
-	if (!profileId.startsWith(MOKA_PROFILE_PREFIX)) return profileId;
-	return `MoKa ${profileId.slice(5).split("-").map(opencodeAgentNamePart).join(" ")}`;
-}
-function opencodeAgentNamePart(part) {
-	if (part === "opencode") return "OpenCode";
-	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
-}
 function grants(actor) {
 	return [
 		`model: ${actor.model ?? "default"}`,
@@ -169,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;
@@ -222,14 +211,14 @@ function hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes) {
 	if (cliRoutes.length > 0 && nativeRoutes.length === 0) return `Do not claim these nodes are ${hostDisplayName(host)} subagents.`;
 }
 function hostDisplayName(host) {
-	return { opencode: "OpenCode" }[host];
+	return {
+		opencode: "OpenCode",
+		"claude-code": "Claude Code"
+	}[host];
 }
 function needsSummary(needs) {
 	return needs.length > 0 ? needs.join(",") : "none";
 }
-function compactLines(lines) {
-	return lines.filter((line) => line !== void 0);
-}
 const OPENCODE_PERMISSION_TOOLS = [
 	"bash",
 	"edit",
@@ -345,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"),
@@ -402,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",
 			"",
@@ -423,9 +413,36 @@ function opencodeModelProjection(config, profile) {
 	const model = resolvedHostModel(config, "opencode", profile);
 	return model ? { model } : {};
 }
-function instructionsPointer(actor) {
-	if (actor.instructions.path) return `Instructions: ${actor.instructions.path}`;
-	return `Instructions:\n${actor.instructions.inline ?? ""}`;
-}
+/**
+* The opencode HostAdapter. Encapsulates all opencode-specific command
+* generation, resource roots, and config-merge behaviour.
+*/
+const opencodeAdapter = {
+	host: "opencode",
+	resourceRoots: [
+		".opencode/commands",
+		".opencode/agents",
+		".opencode/plugins",
+		".opencode/skills"
+	],
+	definitions(config, cwd) {
+		return opencodeDefinitions(config, cwd);
+	},
+	mergeDefinition(definition, existingContent) {
+		if (definition.path !== ".opencode/opencode.json") return;
+		const merged = mergeOpenCodeProjectConfig(existingContent, JSON.parse(definition.content));
+		if (!merged.ok) return {
+			ok: false,
+			content: definition.content
+		};
+		return {
+			ok: true,
+			content: merged.content
+		};
+	},
+	isAlwaysForced(definition) {
+		return definition.path === OPENCODE_PROJECT_CONFIG_PATH;
+	}
+};
 //#endregion
-export { opencodeDefinitions };
+export { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, opencodeAdapter, projectAgentsMdDefinition, resolvedHostModel, scheduledEntrypointK8sNote };

package/dist/install-commands/shared.js

@@ -9,15 +9,42 @@ const AGENTS_MD_START = "<!-- @oisincoveney/pipeline:agents:start -->";
 const AGENTS_MD_END = "<!-- @oisincoveney/pipeline:agents:end -->";
 const SINGLE_OPENCODE_PLUGIN_ARRAY_RE = /\n {2}"plugin": \[\n {4}("[^"]+")\n {2}\]/;
 const OPENCODE_PROJECT_CONFIG_PATH = ".opencode/opencode.json";
+const CLAUDE_PROJECT_CONFIG_PATH = ".claude/settings.json";
 const OPENCODE_COMMAND_PREFIX = "moka-";
-const ENTRYPOINT_PATH_PATTERNS = { opencode: [/^\.opencode\/commands\/(?:moka-)?([^/]+)\.md$/] };
-const COMMAND_HOSTS = ["opencode"];
+const ENTRYPOINT_PATH_PATTERNS = {
+	opencode: [/^\.opencode\/commands\/(?:moka-)?([^/]+)\.md$/],
+	"claude-code": [/^\.claude\/commands\/(?:moka-)?([^/]+)\.md$/]
+};
+const COMMAND_HOSTS = ["opencode", "claude-code"];
+function profileEntries(config) {
+	return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b));
+}
+function entrypointEntries(config) {
+	const entries = Object.entries(config.entrypoints);
+	return entries.length > 0 ? entries : [["execute", {
+		description: "Run the configured pipeline workflow",
+		workflow: config.default_workflow
+	}]];
+}
+function entrypointDescription(id, entrypoint) {
+	return entrypoint.description ?? `Run the ${id} workflow`;
+}
+function instructionsPointer(actor) {
+	if (actor.instructions.path) return `Instructions: ${actor.instructions.path}`;
+	return `Instructions:\n${actor.instructions.inline ?? ""}`;
+}
+function compactLines(lines) {
+	return lines.filter((line) => line !== void 0);
+}
 function invocationForHost(host, entrypointId = "execute") {
-	return `${{ opencode: "/" }[host]}${commandIdForHost(host, entrypointId)} <task description>`;
+	return `${{
+		opencode: "/",
+		"claude-code": "/"
+	}[host]}${commandIdForHost(host, entrypointId)} <task description>`;
 }
 function commandIdForHost(host, entrypointId) {
-	if (host === "opencode") return `${OPENCODE_COMMAND_PREFIX}${entrypointId}`;
+	if (host === "opencode" || host === "claude-code") return `${OPENCODE_COMMAND_PREFIX}${entrypointId}`;
 	return entrypointId;
 }
 //#endregion
-export { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, OWNER_YAML_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, invocationForHost };
+export { AGENTS_MD_END, AGENTS_MD_START, CLAUDE_PROJECT_CONFIG_PATH, COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, OWNER_YAML_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost, profileEntries };

package/dist/install-commands.js

@@ -1,15 +1,18 @@
 import { loadPipelineConfig } from "./config/load.js";
 import "./config.js";
-import { mergeOpenCodeProjectConfig } from "./opencode-project-config.js";
 import { COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, invocationForHost } from "./install-commands/shared.js";
-import { opencodeDefinitions } from "./install-commands/opencode.js";
+import { opencodeAdapter } from "./install-commands/opencode.js";
+import { claudeCodeAdapter } from "./install-commands/claude-code.js";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
 //#region src/install-commands.ts
+const ADAPTERS = {
+	opencode: opencodeAdapter,
+	"claude-code": claudeCodeAdapter
+};
 function definitionsFor(host, config, cwd) {
-	const definitions = { opencode: () => opencodeDefinitions(config, cwd) };
-	return dedupeDefinitionsByPath((host === "all" ? COMMAND_HOSTS : [host]).flatMap((name) => definitions[name]()));
+	return dedupeDefinitionsByPath((host === "all" ? COMMAND_HOSTS : [host]).flatMap((name) => ADAPTERS[name].definitions(config, cwd)));
 }
 function dedupeDefinitionsByPath(definitions) {
 	const lastIndexes = /* @__PURE__ */ new Map();
@@ -21,12 +24,9 @@ function dedupeDefinitionsByPath(definitions) {
 function selectedHosts(host) {
 	return host === "all" ? [...COMMAND_HOSTS] : [host];
 }
-const GENERATED_RESOURCE_ROOTS = { opencode: [
-	".opencode/commands",
-	".opencode/agents",
-	".opencode/plugins",
-	".opencode/skills"
-] };
+function resourceRootsFor(host) {
+	return ADAPTERS[host].resourceRoots;
+}
 async function listFiles(root) {
 	if (!existsSync(root)) return [];
 	if (statSync(root).isFile()) return [root];
@@ -42,7 +42,7 @@ function generatedHostFor(content) {
 }
 async function obsoleteGeneratedItems(cwd, host, wantedPaths) {
 	const hosts = new Set(selectedHosts(host));
-	const roots = selectedHosts(host).flatMap((selectedHost) => GENERATED_RESOURCE_ROOTS[selectedHost]);
+	const roots = selectedHosts(host).flatMap((selectedHost) => resourceRootsFor(selectedHost));
 	return (await Promise.all(roots.map((root) => listFiles(join(cwd, root))))).flat().flatMap((absolutePath) => {
 		const generatedHost = generatedHostFor(readFileSync(absolutePath, "utf8"));
 		if (!(generatedHost && hosts.has(generatedHost))) return [];
@@ -63,12 +63,19 @@ function entrypointIdFromGeneratedPath(host, path) {
 	}
 }
 function resolveDefinitionContent(definition, target) {
-	if (definition.path !== ".opencode/opencode.json" || !existsSync(target)) return {
+	const adapter = ADAPTERS[definition.host];
+	if (!(adapter.mergeDefinition && existsSync(target))) return {
+		conflict: false,
+		content: definition.content
+	};
+	return applyMergeDefinition(adapter.mergeDefinition.bind(adapter), definition, target);
+}
+function applyMergeDefinition(merge, definition, target) {
+	const merged = merge(definition, readFileSync(target, "utf8"));
+	if (!merged) return {
 		conflict: false,
 		content: definition.content
 	};
-	const projection = JSON.parse(definition.content);
-	const merged = mergeOpenCodeProjectConfig(readFileSync(target, "utf8"), projection);
 	if (!merged.ok) return {
 		conflict: true,
 		content: definition.content
@@ -101,9 +108,13 @@ function upsertGeneratedBlock(current, content, block) {
 	const separator = current.trimEnd().length > 0 ? "\n\n" : "";
 	return `${current.trimEnd()}${separator}${content}`;
 }
+function adapterForcesDefinition(definition) {
+	const fn = ADAPTERS[definition.host].isAlwaysForced;
+	return fn ? fn(definition) : false;
+}
 function installActionForDefinition(definition, target, resolved, force) {
 	if (resolved.conflict) return "conflict";
-	return actionFor(target, resolved.content, force || definition.path === ".opencode/opencode.json", definition.block);
+	return actionFor(target, resolved.content, force || adapterForcesDefinition(definition), definition.block);
 }
 async function writeDefinition(definition, target, content) {
 	await mkdir(dirname(target), { recursive: true });

package/dist/json-config-merge.js

@@ -0,0 +1,47 @@
+import { applyEdits, modify, parse } from "jsonc-parser";
+//#region src/json-config-merge.ts
+const JSON_FORMAT_OPTIONS = {
+	insertSpaces: true,
+	tabSize: 2
+};
+function parseJsonRecord(currentText) {
+	const errors = [];
+	const value = parse(currentText, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0 || !isRecord(value)) return {
+		errors,
+		ok: false
+	};
+	return {
+		ok: true,
+		value
+	};
+}
+function setIfMissing(content, parsed, path, value) {
+	if (value === void 0 || hasPath(parsed, path)) return content;
+	return applyJsonEdit(content, path, value);
+}
+function hasPath(value, path) {
+	let cursor = value;
+	for (const segment of path) {
+		if (!(isRecord(cursor) && segment in cursor)) return false;
+		cursor = cursor[segment];
+	}
+	return true;
+}
+function applyJsonEdit(content, path, value) {
+	return applyEdits(content, modify(content, path, value, { formattingOptions: JSON_FORMAT_OPTIONS }));
+}
+function formatJson(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+function ensureTrailingNewline(value) {
+	return value.endsWith("\n") ? value : `${value}\n`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { applyJsonEdit, ensureTrailingNewline, formatJson, isRecord, parseJsonRecord, setIfMissing };

package/dist/mcp/gateway.js

@@ -66,6 +66,14 @@ function renderOpenCodeGatewayConfig(config) {
 		} }
 	}, null, 2)}\n`;
 }
+function renderClaudeGatewayMcpServers(config) {
+	const gateway = configuredGateway(config);
+	return { [PIPELINE_GATEWAY_SERVER_ID]: {
+		headers: gatewayOpenCodeHeaders(gateway),
+		type: "http",
+		url: gatewayUrl(gateway)
+	} };
+}
 function configureGatewayHosts(config, options) {
 	return selectedGatewayHosts(options.host).map((host) => {
 		const path = gatewayHostConfigPath(options.scope, options.cwd);
@@ -422,4 +430,4 @@ function legacyContentHit(cwd, path, pattern) {
 	return pattern.test(readFileSync(fullPath, "utf8")) ? path : void 0;
 }
 //#endregion
-export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, reconcileGateway, renderGatewayConfig, renderOpenCodeGatewayConfig, runGatewayDoctor, startLocalGateway };
+export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, reconcileGateway, renderClaudeGatewayMcpServers, renderGatewayConfig, renderOpenCodeGatewayConfig, runGatewayDoctor, startLocalGateway };

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,17 +1,17 @@
 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
 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<{
@@ -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>;
@@ -161,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;
@@ -207,13 +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<{
@@ -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
 	};
 }