@oisincoveney/pipeline 3.11.7 → 3.11.9

package/dist/argo-workflow.js

@@ -24,11 +24,11 @@ const RUNNER_OPENCODE_ENV = [{
 const DEFAULT_RUNNER_RESOURCES = {
 	limits: {
 		cpu: "4",
-		memory: "8Gi"
+		memory: "12Gi"
 	},
 	requests: {
 		cpu: "1",
-		memory: "4Gi"
+		memory: "8Gi"
 	}
 };
 const kubernetesNameSchema = z.string().min(1);

package/dist/claude-user-config.js

@@ -0,0 +1,28 @@
+import { applyJsonEdit, ensureTrailingNewline, formatJson, parseJsonRecord, setIfMissing } from "./json-config-merge.js";
+//#region src/claude-user-config.ts
+function mergeClaudeUserConfig(currentText, projection) {
+	if (currentText === void 0) return {
+		content: formatJson(projection),
+		ok: true
+	};
+	const parsed = parseJsonRecord(currentText);
+	if (!parsed.ok) return parsed;
+	return {
+		content: ensureTrailingNewline(Object.entries(projection.mcpServers ?? {}).reduce((nextContent, [name, server]) => setIfMissing(nextContent, parsed.value, ["mcpServers", name], server), currentText)),
+		ok: true
+	};
+}
+function replaceClaudeUserMcpServers(currentText, projection) {
+	if (currentText === void 0) return {
+		content: formatJson(projection),
+		ok: true
+	};
+	const parsed = parseJsonRecord(currentText);
+	if (!parsed.ok) return parsed;
+	return {
+		content: ensureTrailingNewline(applyJsonEdit(currentText, ["mcpServers"], projection.mcpServers ?? {})),
+		ok: true
+	};
+}
+//#endregion
+export { mergeClaudeUserConfig, replaceClaudeUserMcpServers };

package/dist/cli/program.js

@@ -304,7 +304,12 @@ function createCliProgram(options = {}) {
 		const config = loadPipelineConfig(process.env.PIPELINE_TARGET_PATH ?? process.cwd(), { allowMissingLintFileReferences: true });
 		console.log(renderGatewayConfig(config));
 	});
-	gatewayCommand.command("configure-host").description("Rewrite host MCP config to the singleton pipeline gateway").addOption(new Option$1("--host <host>", "host config to update").choices(["all", "opencode"]).default("all").argParser(parseGatewayHost)).addOption(new Option$1("--scope <scope>", "config scope to update").choices(["project", "global"]).default("project").argParser(parseGatewayHostScope)).action((flags) => {
+	gatewayCommand.command("configure-host").description("Rewrite host MCP config to the singleton pipeline gateway").addOption(new Option$1("--host <host>", "host config to update").choices([
+		"all",
+		"opencode",
+		"claude-code",
+		"codex"
+	]).default("all").argParser(parseGatewayHost)).addOption(new Option$1("--scope <scope>", "config scope to update").choices(["project", "global"]).default("project").argParser(parseGatewayHostScope)).action((flags) => {
 		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
 		const result = configureGatewayHosts(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), {
 			cwd,
@@ -343,7 +348,8 @@ function createCliProgram(options = {}) {
 	program.command("install-commands").description("Install generated slash-command adapters into per-machine host dirs (~/.claude, ~/.config/opencode, ~/.codex)").addOption(new Option$1("--host <host>", "host command set to install").choices([
 		"all",
 		"opencode",
-		"claude-code"
+		"claude-code",
+		"codex"
 	]).default("all").argParser(parseCommandHost)).option("--dry-run", "show planned changes without writing files").option("--check", "fail if generated command files are missing or stale").option("--force", "overwrite manually edited command files").action(async (flags) => {
 		const result = await installCommands({
 			...flags,

package/dist/codex-config.js

@@ -0,0 +1,67 @@
+import { ensureTrailingNewline } from "./json-config-merge.js";
+//#region src/codex-config.ts
+const PIPELINE_GATEWAY_SECTION_HEADERS = ["[mcp_servers.pipeline-gateway]", "[mcp_servers.pipeline-gateway.env_http_headers]"];
+const CODEX_FEATURES_SECTION_HEADER = "[features]";
+const CODEX_HOOKS_FEATURE = "hooks";
+function mergeCodexConfig(currentText, projection) {
+	return ensureTrailingNewline([enableCodexHooksFeature(removePipelineGatewaySections(currentText ?? "").trimEnd()).trimEnd(), projection.trimEnd()].filter(Boolean).join("\n\n"));
+}
+function removePipelineGatewaySections(content) {
+	return PIPELINE_GATEWAY_SECTION_HEADERS.reduce((nextContent, header) => removeTomlSection(nextContent, header), content);
+}
+function removeTomlSection(content, header) {
+	const lines = content.split("\n");
+	const kept = [];
+	let removing = false;
+	for (const line of lines) {
+		if (line.trim() === header) {
+			removing = true;
+			continue;
+		}
+		if (removing && line.startsWith("[") && line.trimEnd().endsWith("]")) removing = false;
+		if (!removing) kept.push(line);
+	}
+	return kept.join("\n");
+}
+function enableCodexHooksFeature(content) {
+	return setTomlFeature(content, CODEX_HOOKS_FEATURE, "true");
+}
+function setTomlFeature(content, key, value) {
+	const lines = content.split("\n");
+	const sectionStart = lines.findIndex((line) => line.trim() === CODEX_FEATURES_SECTION_HEADER);
+	if (sectionStart === -1) return [
+		content.trimEnd(),
+		CODEX_FEATURES_SECTION_HEADER,
+		`${key} = ${value}`
+	].filter(Boolean).join("\n");
+	const sectionEnd = nextTomlSectionIndex(lines, sectionStart + 1);
+	const beforeSection = lines.slice(0, sectionStart + 1);
+	const featureLines = lines.slice(sectionStart + 1, sectionEnd);
+	const afterSection = lines.slice(sectionEnd);
+	let replaced = false;
+	const mergedFeatureLines = featureLines.flatMap((line) => {
+		if (!tomlKeyPattern(key).test(line)) return [line];
+		if (replaced) return [];
+		replaced = true;
+		return [`${key} = ${value}`];
+	});
+	if (!replaced) mergedFeatureLines.push(`${key} = ${value}`);
+	return [
+		...beforeSection,
+		...mergedFeatureLines,
+		...afterSection
+	].join("\n");
+}
+function nextTomlSectionIndex(lines, startIndex) {
+	const nextIndex = lines.findIndex((line, index) => index >= startIndex && isTomlSectionHeader(line));
+	return nextIndex === -1 ? lines.length : nextIndex;
+}
+function isTomlSectionHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function tomlKeyPattern(key) {
+	return new RegExp(`^\\s*${key}\\s*=`);
+}
+//#endregion
+export { mergeCodexConfig };

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

@@ -1,4 +1,3 @@
-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";
@@ -83,11 +82,9 @@ function agentDefinitions(config) {
 		};
 	});
 }
-function settingsDefinition(config) {
-	const settings = { permissions: { allow: ["Bash(moka run *)"] } };
-	if (config.mcp_gateway) settings.mcpServers = renderClaudeGatewayMcpServers(config);
+function settingsDefinition() {
 	return [{
-		content: `${JSON.stringify(settings, null, 2)}\n`,
+		content: `${JSON.stringify({ permissions: { allow: ["Bash(moka run *)"] } }, null, 2)}\n`,
 		host: CLAUDE_CODE_HOST,
 		invocation: invocationForHost(CLAUDE_CODE_HOST),
 		path: CLAUDE_PROJECT_CONFIG_PATH
@@ -97,7 +94,7 @@ function claudeCodeDefinitions(config, cwd) {
 	return [
 		...commandDefinitions(config),
 		...agentDefinitions(config),
-		...settingsDefinition(config),
+		...settingsDefinition(),
 		projectAgentsMdDefinition(cwd, CLAUDE_CODE_HOST)
 	];
 }

package/dist/install-commands/shared.js

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 //#region src/install-commands/shared.ts
 const GENERATED_MARKER = "<!-- Generated by @oisincoveney/pipeline. -->";
@@ -12,12 +12,19 @@ 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 CLAUDE_USER_CONFIG_PATH = ".claude.json";
+const CODEX_CONFIG_PATH = ".codex/config.toml";
 const OPENCODE_COMMAND_PREFIX = "moka-";
 const ENTRYPOINT_PATH_PATTERNS = {
 	opencode: [/^\.opencode\/commands\/(?:moka-)?([^/]+)\.md$/],
 	"claude-code": [/^\.claude\/commands\/(?:moka-)?([^/]+)\.md$/]
 };
 const COMMAND_HOSTS = ["opencode", "claude-code"];
+const INSTALL_HOSTS = [
+	"opencode",
+	"claude-code",
+	"codex"
+];
 /**
 * The per-machine host config dirs. Each honors the same env var the host tool
 * itself uses to relocate its config (so containers/CI can redirect, and so
@@ -51,6 +58,7 @@ function stripPrefix(value, prefix) {
 */
 function resolveHarnessTarget(relPath) {
 	const normalized = relPath.replaceAll("\\", "/");
+	if (normalized === ".claude.json") return join(dirname(claudeGlobalConfigDir()), CLAUDE_USER_CONFIG_PATH);
 	if (normalized === ".claude" || normalized.startsWith(".claude/")) return join(claudeGlobalConfigDir(), stripPrefix(normalized, ".claude"));
 	if (normalized === ".codex" || normalized.startsWith(".codex/")) return join(codexGlobalConfigDir(), stripPrefix(normalized, ".codex"));
 	if (normalized === ".gemini" || normalized.startsWith(".gemini/")) return join(geminiGlobalConfigDir(), stripPrefix(normalized, ".gemini"));
@@ -87,4 +95,4 @@ function commandIdForHost(host, entrypointId) {
 	return entrypointId;
 }
 //#endregion
-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, resolveHarnessTarget };
+export { AGENTS_MD_END, AGENTS_MD_START, CLAUDE_PROJECT_CONFIG_PATH, CLAUDE_USER_CONFIG_PATH, CODEX_CONFIG_PATH, COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, INSTALL_HOSTS, 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, resolveHarnessTarget };

package/dist/install-commands.js

@@ -1,6 +1,10 @@
 import { loadPipelineConfig } from "./config/load.js";
 import "./config.js";
-import { COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, invocationForHost, resolveHarnessTarget } from "./install-commands/shared.js";
+import { isRecord } from "./json-config-merge.js";
+import { mergeClaudeUserConfig } from "./claude-user-config.js";
+import { mergeCodexConfig } from "./codex-config.js";
+import { renderClaudeGatewayUserConfig, renderCodexGatewayConfig } from "./mcp/gateway.js";
+import { CLAUDE_USER_CONFIG_PATH, CODEX_CONFIG_PATH, COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, INSTALL_HOSTS, invocationForHost, resolveHarnessTarget } from "./install-commands/shared.js";
 import { opencodeAdapter } from "./install-commands/opencode.js";
 import { claudeCodeAdapter } from "./install-commands/claude-code.js";
 import { existsSync, readFileSync, statSync } from "node:fs";
@@ -12,7 +16,7 @@ const ADAPTERS = {
 	"claude-code": claudeCodeAdapter
 };
 function definitionsFor(host, config, cwd) {
-	return dedupeDefinitionsByPath((host === "all" ? COMMAND_HOSTS : [host]).flatMap((name) => ADAPTERS[name].definitions(config, cwd)));
+	return dedupeDefinitionsByPath([...selectedCommandHosts(host).flatMap((name) => ADAPTERS[name].definitions(config, cwd)), ...gatewayHostConfigDefinitions(host, config)]);
 }
 function dedupeDefinitionsByPath(definitions) {
 	const lastIndexes = /* @__PURE__ */ new Map();
@@ -21,8 +25,17 @@ function dedupeDefinitionsByPath(definitions) {
 	});
 	return definitions.filter((definition, index) => lastIndexes.get(definition.path) === index);
 }
-function selectedHosts(host) {
-	return host === "all" ? [...COMMAND_HOSTS] : [host];
+function selectedInstallHosts(host) {
+	return host === "all" ? [...INSTALL_HOSTS] : [host];
+}
+function isActiveCommandHost(host) {
+	return host === "opencode" || host === "claude-code";
+}
+function isInstallHost(host) {
+	return INSTALL_HOSTS.some((candidate) => candidate === host);
+}
+function selectedCommandHosts(host) {
+	return selectedInstallHosts(host).filter(isActiveCommandHost);
 }
 function resourceRootsFor(host) {
 	return ADAPTERS[host].resourceRoots;
@@ -41,8 +54,8 @@ function generatedHostFor(content) {
 	return COMMAND_HOSTS.find((host) => content.includes(`<!-- @oisincoveney/pipeline:host=${host} -->`) || content.includes(`// @oisincoveney/pipeline:host=${host}`) || content.includes(`# @oisincoveney/pipeline:host=${host}`));
 }
 async function obsoleteGeneratedItems(host, wantedPaths) {
-	const hosts = new Set(selectedHosts(host));
-	const roots = selectedHosts(host).flatMap((selectedHost) => resourceRootsFor(selectedHost));
+	const hosts = new Set(selectedCommandHosts(host));
+	const roots = selectedCommandHosts(host).flatMap((selectedHost) => resourceRootsFor(selectedHost));
 	return (await Promise.all(roots.map(async (root) => {
 		const absRoot = resolveHarnessTarget(root);
 		return (await listFiles(absRoot)).map((absolutePath) => ({
@@ -73,14 +86,43 @@ function entrypointIdFromGeneratedPath(host, path) {
 		if (match) return match[1];
 	}
 }
+const CONFIG_MERGES = {
+	[CLAUDE_USER_CONFIG_PATH]: (existingContent, projectionContent) => {
+		const projection = JSON.parse(projectionContent);
+		if (!isRecord(projection)) return {
+			conflict: true,
+			content: projectionContent
+		};
+		const merged = mergeClaudeUserConfig(existingContent, projection);
+		return merged.ok ? {
+			conflict: false,
+			content: merged.content
+		} : {
+			conflict: true,
+			content: projectionContent
+		};
+	},
+	[CODEX_CONFIG_PATH]: (existingContent, projectionContent) => ({
+		conflict: false,
+		content: mergeCodexConfig(existingContent, projectionContent)
+	})
+};
 function resolveDefinitionContent(definition, target) {
-	const adapter = ADAPTERS[definition.host];
+	const configMerge = CONFIG_MERGES[definition.path];
+	if (configMerge) return configMerge(existsSync(target) ? readFileSync(target, "utf8") : void 0, definition.content);
+	const adapter = adapterForDefinition(definition);
 	if (!(adapter?.mergeDefinition && existsSync(target))) return {
 		conflict: false,
 		content: definition.content
 	};
 	return applyMergeDefinition(adapter.mergeDefinition.bind(adapter), definition, target);
 }
+function adapterForDefinition(definition) {
+	return isActiveDefinitionHost(definition.host) ? ADAPTERS[definition.host] : void 0;
+}
+function isActiveDefinitionHost(host) {
+	return host === "opencode" || host === "claude-code";
+}
 function applyMergeDefinition(merge, definition, target) {
 	const merged = merge(definition, readFileSync(target, "utf8"));
 	if (!merged) return {
@@ -96,6 +138,27 @@ function applyMergeDefinition(merge, definition, target) {
 		content: merged.content
 	};
 }
+function gatewayHostConfigDefinitions(host, config) {
+	if (!config.mcp_gateway) return [];
+	return selectedInstallHosts(host).flatMap(gatewayHostConfigDefinition(config));
+}
+function gatewayHostConfigDefinition(config) {
+	return (host) => {
+		if (host === "claude-code") return [{
+			content: renderClaudeGatewayUserConfig(config),
+			host,
+			invocation: invocationForHost(host),
+			path: CLAUDE_USER_CONFIG_PATH
+		}];
+		if (host === "codex") return [{
+			content: renderCodexGatewayConfig(config),
+			host,
+			invocation: "codex",
+			path: CODEX_CONFIG_PATH
+		}];
+		return [];
+	};
+}
 function actionFor(path, content, force, block) {
 	if (!existsSync(path)) return "create";
 	const current = readFileSync(path, "utf8");
@@ -120,7 +183,8 @@ function upsertGeneratedBlock(current, content, block) {
 	return `${current.trimEnd()}${separator}${content}`;
 }
 function adapterForcesDefinition(definition) {
-	const fn = ADAPTERS[definition.host]?.isAlwaysForced;
+	if (definition.path in CONFIG_MERGES) return true;
+	const fn = adapterForDefinition(definition)?.isAlwaysForced;
 	return fn ? fn(definition) : false;
 }
 function installActionForDefinition(definition, target, resolved, force) {
@@ -212,8 +276,9 @@ async function installCommands(options = {}) {
 }
 function parseCommandHost(value) {
 	const host = value ?? "all";
-	if (host === "all" || COMMAND_HOSTS.includes(host)) return host;
-	throw new Error(`Unsupported host "${host}". Supported values: all, ${COMMAND_HOSTS.join(", ")}.`);
+	if (host === "all") return host;
+	if (isInstallHost(host)) return host;
+	throw new Error(`Unsupported host "${host}". Supported values: all, ${INSTALL_HOSTS.join(", ")}.`);
 }
 function formatInstallCommandsResult(result) {
 	return result.items.map((item) => `${item.action} ${item.host}: ${item.path} (${item.invocation})`).join("\n");

package/dist/install-hooks.js

@@ -125,11 +125,7 @@ function isRecord(value) {
 function normalizeManifest(value) {
 	const files = {};
 	const manifestFiles = isRecord(value) ? value.files : void 0;
-	if (!isRecord(manifestFiles)) return {
-		files,
-		repository: DEFAULT_HOOK_INSTALL_SOURCE,
-		version: 1
-	};
+	if (!isRecord(manifestFiles)) return emptyManifest();
 	for (const [path, entry] of Object.entries(manifestFiles)) if (isRecord(entry) && typeof entry.hash === "string") files[path] = { hash: entry.hash };
 	return {
 		files,

package/dist/install-rules.js

@@ -1,20 +1,16 @@
 import { execa } from "execa";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 //#region src/install-rules.ts
 const DEFAULT_RULES_INSTALL_SOURCE = "oisin-ee/rules";
+const RULESYNC_PACKAGE = "rulesync@8.30.1";
 const RULESYNC_TARGETS = [
 	"claudecode",
 	"codexcli",
 	"geminicli",
 	"opencode"
 ];
-function packageRoot() {
-	return join(dirname(fileURLToPath(import.meta.url)), "..");
-}
-const PACKAGE_ROOT = packageRoot();
 async function cloneRulesRepository(targetDir) {
 	await execa("gh", [
 		"repo",
@@ -41,11 +37,13 @@ async function withRulesSource(sourceOverride, useSource) {
 }
 async function defaultRulesyncRunner(args, opts) {
 	try {
-		await execa("rulesync", args, {
+		await execa("npx", [
+			"--yes",
+			RULESYNC_PACKAGE,
+			...args
+		], {
 			cwd: opts.cwd,
 			env: opts.env,
-			localDir: PACKAGE_ROOT,
-			preferLocal: true,
 			stdio: "inherit"
 		});
 	} catch (error) {

package/dist/mcp/gateway.js

@@ -1,3 +1,5 @@
+import { replaceClaudeUserMcpServers } from "../claude-user-config.js";
+import { mergeCodexConfig } from "../codex-config.js";
 import { PipelineMcpGatewayError } from "./gateway-error.js";
 import { McpGatewayService, McpGatewayServiceLive } from "../runtime/services/mcp-gateway-service.js";
 import { resolveRepoLocalBackendSpecs } from "./repo-local-backends.js";
@@ -68,15 +70,31 @@ function renderOpenCodeGatewayConfig(config) {
 function renderClaudeGatewayMcpServers(config) {
 	const gateway = configuredGateway(config);
 	return { [PIPELINE_GATEWAY_SERVER_ID]: {
-		headers: gatewayOpenCodeHeaders(gateway),
+		headers: gatewayClaudeHeaders(gateway),
 		type: "http",
 		url: gatewayUrl(gateway)
 	} };
 }
+function renderClaudeGatewayUserConfig(config) {
+	return `${JSON.stringify({ mcpServers: renderClaudeGatewayMcpServers(config) }, null, 2)}\n`;
+}
+function renderCodexGatewayConfig(config) {
+	const gateway = configuredGateway(config);
+	return [
+		`[mcp_servers.${PIPELINE_GATEWAY_SERVER_ID}]`,
+		`url = ${tomlString(gatewayUrl(gateway))}`,
+		"",
+		`[mcp_servers.${PIPELINE_GATEWAY_SERVER_ID}.env_http_headers]`,
+		`Authorization = ${tomlString(gateway.authorization_env)}`,
+		""
+	].join("\n");
+}
 function configureGatewayHosts(config, options) {
 	return selectedGatewayHosts(options.host).map((host) => {
-		const path = gatewayHostConfigPath(options.scope, options.cwd);
-		const content = renderOpenCodeGatewayConfig(config);
+		const adapter = GATEWAY_HOST_CONFIGS[host];
+		const path = adapter.path(options.scope, options.cwd);
+		const current = existsSync(path) ? readFileSync(path, "utf8") : void 0;
+		const content = adapter.configureContent(config, current);
 		const backupPath = backupIfExists(path);
 		mkdirSync(dirname(path), { recursive: true });
 		writeFileSync(path, content);
@@ -211,12 +229,42 @@ function callGatewayRpc(gateway, url, body) {
 	});
 }
 function selectedGatewayHosts(host) {
-	return host === "all" ? ["opencode"] : [host];
-}
-function gatewayHostConfigPath(scope, cwd) {
+	return host === "all" ? [
+		"opencode",
+		"claude-code",
+		"codex"
+	] : [host];
+}
+const GATEWAY_HOST_CONFIGS = {
+	"claude-code": {
+		configureContent: (config, current) => {
+			const merged = replaceClaudeUserMcpServers(current, { mcpServers: renderClaudeGatewayMcpServers(config) });
+			if (!merged.ok) throw new PipelineMcpGatewayError("Cannot parse Claude Code user config.");
+			return merged.content;
+		},
+		path: claudeGatewayConfigPath
+	},
+	codex: {
+		configureContent: (config, current) => mergeCodexConfig(current, renderCodexGatewayConfig(config)),
+		path: codexGatewayConfigPath
+	},
+	opencode: {
+		configureContent: (config) => renderOpenCodeGatewayConfig(config),
+		path: opencodeGatewayConfigPath
+	}
+};
+function opencodeGatewayConfigPath(scope, cwd) {
 	if (scope === "project") return join(cwd, ".opencode", "opencode.json");
 	return join(process.env.OPENCODE_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode"), "opencode.json");
 }
+function claudeGatewayConfigPath(scope, cwd) {
+	if (scope === "project") return join(cwd, ".mcp.json");
+	return join(dirname(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")), ".claude.json");
+}
+function codexGatewayConfigPath(scope, cwd) {
+	if (scope === "project") return join(cwd, ".codex", "config.toml");
+	return join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "config.toml");
+}
 function backupIfExists(path) {
 	if (!existsSync(path)) return;
 	const backupPath = `${path}.bak-${Date.now()}`;
@@ -255,6 +303,12 @@ function gatewayAuthorizationHeader(gateway) {
 function gatewayOpenCodeHeaders(gateway) {
 	return { Authorization: gatewayAuthorizationHeader(gateway) };
 }
+function gatewayClaudeHeaders(gateway) {
+	return { Authorization: `\${${gateway.authorization_env}}` };
+}
+function tomlString(value) {
+	return JSON.stringify(value);
+}
 function checkThv(cwd) {
 	return Effect.gen(function* () {
 		yield* (yield* McpGatewayService).runToolHiveVersion(cwd);
@@ -329,4 +383,4 @@ function legacyContentHit(cwd, path, pattern) {
 	return pattern.test(readFileSync(fullPath, "utf8")) ? path : void 0;
 }
 //#endregion
-export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, reconcileGateway, renderClaudeGatewayMcpServers, renderGatewayConfig, renderOpenCodeGatewayConfig, runGatewayDoctor, startLocalGateway };
+export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, reconcileGateway, renderClaudeGatewayUserConfig, renderCodexGatewayConfig, renderGatewayConfig, renderOpenCodeGatewayConfig, runGatewayDoctor, startLocalGateway };

package/package.json

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