@oisincoveney/pipeline 1.16.1 → 1.17.0

package/README.md

@@ -39,17 +39,16 @@ MCP is the Momokaya remote endpoint
 
 The default GitHub MCP registration uses GitHub's official container in
 read-only mode and reads `GITHUB_PERSONAL_ACCESS_TOKEN` from the environment.
-The Momokaya Qdrant endpoint is protected by Traefik HTTP Basic auth. Set
-`MEMORY_MCP_BASIC_AUTH` to the base64 `user:password` payload before running
-`pipe init` if you want init to register that remote server with MCPM:
+The Momokaya gateway endpoint is protected by Traefik HTTP Basic auth. Set
+`PIPELINE_MCP_GATEWAY_AUTHORIZATION` to the full HTTP `Authorization` header
+value before starting Codex or OpenCode:
 
 ```shell
-export MEMORY_MCP_BASIC_AUTH="$(printf '%s' 'user:password' | base64)"
+export PIPELINE_MCP_GATEWAY_AUTHORIZATION="Basic $(printf '%s' 'user:password' | base64)"
 ```
 
-When `MEMORY_MCP_BASIC_AUTH` is not set, `pipe init` still writes the default
-scaffold and keeps the generated `qdrant` MCP entry, but skips immediate MCPM
-registration for that private endpoint.
+`pipe init` writes project-level Codex and OpenCode config that points at the
+singleton `pipeline-gateway` MCP server.
 
 Check local prerequisites and config health:
 

package/dist/config.d.ts

@@ -239,7 +239,8 @@ declare const configSchema: z.ZodObject<{
       local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
-    token_env: z.ZodDefault<z.ZodString>;
+    authorization_env: z.ZodDefault<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
     url_env: z.ZodDefault<z.ZodString>;
   }, z.core.$strict>>;
   mcp_servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/config.js

@@ -132,7 +132,8 @@ const mcpGatewaySchema = z.object({
 	default_profile: z.string().min(1).optional(),
 	mode: z.enum(["hosted", "local"]),
 	provider: z.literal("toolhive"),
-	token_env: z.string().min(1).default("PIPELINE_MCP_GATEWAY_TOKEN"),
+	authorization_env: z.string().min(1).default("PIPELINE_MCP_GATEWAY_AUTHORIZATION"),
+	url: z.string().url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol), { message: "MCP gateway url must use http or https" }).optional(),
 	url_env: z.string().min(1).default("PIPELINE_MCP_GATEWAY_URL")
 }).strict();
 const instructionsSchema = z.object({

package/dist/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    fail: "fail";
     pass: "pass";
+    fail: "fail";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { PipelineConfigError, loadPipelineConfig, tryLoadPipelineConfig } from "./config.js";
+import { configureGatewayHosts, localGatewayStatus, renderGatewayConfig, runGatewayDoctor, startLocalGateway } from "./mcp/gateway.js";
 import { compileWorkflowPlan } from "./workflow-planner.js";
 import { formatInstallCommandsResult, installCommands, parseCommandHost } from "./install-commands.js";
-import { configureGatewayHosts, localGatewayStatus, renderGatewayConfig, runGatewayDoctor, startLocalGateway } from "./mcp/gateway.js";
 import { createOrchestratorLaunchPlan, createRunnerLaunchPlan } from "./runner.js";
 import { formatConfigError, runPipelineFromConfig } from "./pipeline-runtime.js";
 import { runKubernetesRunnerJob } from "./kubernetes-runner.js";
@@ -527,7 +527,6 @@ function formatWorkflowPlanNode(node, config, worktreePath) {
 		`kind=${node.kind}`,
 		`needs=${node.needs.join(",") || "none"}`,
 		launch ? `runner=${launch.runnerId}` : "",
-		launch ? `strategy=${launch.strategy}` : "",
 		node.gates?.length ? `gates=${node.gates.length}` : "gates=0",
 		node.artifacts?.length ? `artifacts=${node.artifacts.map((artifact) => artifact.path).join(",")}` : "artifacts=none"
 	].filter(Boolean).join(" ");
@@ -542,14 +541,12 @@ function resolveWorkflowSelection(config, workflowId, entrypointId) {
 }
 function formatOrchestratorPlan(config, worktreePath) {
 	const orchestrator = config.profiles[config.orchestrator.profile];
-	const launch = createOrchestratorLaunchPlan(config, {
-		nodeId: "orchestrator",
-		prompt: "<task>",
-		worktreePath
-	});
 	return [
-		`Orchestrator: runner=${launch.runnerId}`,
-		`strategy=${launch.strategy}`,
+		`Orchestrator: runner=${createOrchestratorLaunchPlan(config, {
+			nodeId: "orchestrator",
+			prompt: "<task>",
+			worktreePath
+		}).runnerId}`,
 		orchestrator.model ? `model=${orchestrator.model}` : "",
 		formatList("rules", orchestrator.rules),
 		formatList("skills", orchestrator.skills),

package/dist/install-commands.js

@@ -1,5 +1,6 @@
 import { resolveFileReference } from "./path-refs.js";
 import { loadPipelineConfig } from "./config.js";
+import { renderCodexGatewayConfig } from "./mcp/gateway.js";
 import { compileWorkflowPlan } from "./workflow-planner.js";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
@@ -173,6 +174,8 @@ function entrypointDispatchBlock(host, config, id, entrypoint) {
 		`Generate a schedule for entrypoint \`${id}\` and the user task.`,
 		`The schedule policy is \`${entrypoint.schedule}\`.`,
 		`Run \`pipe run --entrypoint ${id} <task description>\` to generate and execute the schedule artifact.`,
+		"The pipeline CLI runtime is the deterministic graph scheduler for scheduled entrypoints.",
+		"It launches configured Codex/OpenCode agent subprocesses as soon as their dependencies pass.",
 		"Use `pipe run --schedule <schedule.yaml>` only when rerunning an existing schedule artifact."
 	].join("\n");
 }
@@ -358,7 +361,7 @@ function codexDefinitions(config, cwd) {
 		})),
 		projectAgentsMdDefinition(cwd, "codex"),
 		...nativeCodexProfiles.map(([id, profile]) => codexTomlAgentDefinition(config, cwd, id, profile)),
-		codexProjectConfigAgentDefinition()
+		codexProjectConfigAgentDefinition(config)
 	];
 }
 function projectAgentsMdDefinition(cwd, host) {
@@ -406,6 +409,7 @@ function codexTomlAgentDefinition(config, cwd, id, profile) {
 	};
 	const skillConfig = codexSkillConfig(config, cwd, profile);
 	const agentConfig = {
+		name: id,
 		description: profile.description ?? id,
 		...profileWithResolvedModel.model ? { model: profileWithResolvedModel.model } : {},
 		...profile.filesystem?.mode ? { sandbox_mode: profile.filesystem.mode } : {},
@@ -424,16 +428,12 @@ function codexTomlAgentDefinition(config, cwd, id, profile) {
 		].join("\n"),
 		skills: { config: skillConfig }
 	};
-	const mcpConfig = "mcp_servers" in agentConfig ? agentConfig : {
-		...agentConfig,
-		mcp_servers: {}
-	};
 	return {
 		content: [
 			"# Generated by @oisincoveney/pipeline.",
 			`${OWNER_YAML_MARKER_PREFIX}host=codex`,
 			"",
-			stringify(mcpConfig).trimEnd(),
+			stringify(agentConfig).trimEnd(),
 			""
 		].join("\n"),
 		host: "codex",
@@ -470,13 +470,14 @@ function codexSkillConfig(config, cwd, profile) {
 		}];
 	});
 }
-function codexProjectConfigAgentDefinition() {
+function codexProjectConfigAgentDefinition(config) {
 	return {
 		block: {
 			end: CODEX_AGENT_CONFIG_END,
 			start: CODEX_AGENT_CONFIG_START
 		},
 		content: [
+			...config.mcp_gateway ? [renderCodexGatewayConfig(config).trimEnd(), ""] : [],
 			CODEX_AGENT_CONFIG_START,
 			stringify({ agents: { max_depth: 1 } }).trimEnd(),
 			CODEX_AGENT_CONFIG_END,

package/dist/mcp/gateway.js

@@ -5,7 +5,7 @@ import { execa } from "execa";
 //#region src/mcp/gateway.ts
 const PIPELINE_GATEWAY_SERVER_ID = "pipeline-gateway";
 const DEFAULT_LOCAL_GATEWAY_URL = "http://127.0.0.1:4483/mcp";
-const LEGACY_CODEX_MCP_RE = /\[mcp_servers\./;
+const LEGACY_CODEX_MCP_RE = /^\s*\[mcp_servers\.(?!pipeline-gateway(?:\]|\.env_http_headers\]))/m;
 const LEGACY_OPENCODE_MCP_RE = /"mcp"\s*:\s*{(?!\s*"pipeline-gateway")/s;
 const LEGACY_PIPELINE_MCP_RE = /path:\s*\.mcp\.json|uvx\s+mcpm|mcpm\s+run/;
 var PipelineMcpGatewayError = class extends Error {
@@ -25,7 +25,7 @@ function gatewayServer(config, env = process.env) {
 	const gateway = configuredGateway(config);
 	const url = gatewayUrl(gateway, env);
 	return {
-		bearer_token_env_var: gateway.token_env,
+		headers: { Authorization: gatewayAuthorizationHeader(gateway) },
 		url
 	};
 }
@@ -36,6 +36,7 @@ function configuredGateway(config) {
 function gatewayUrl(gateway, env = process.env) {
 	const url = env[gateway.url_env];
 	if (url) return url;
+	if (gateway.url) return gateway.url;
 	if (gateway.mode === "local") return DEFAULT_LOCAL_GATEWAY_URL;
 	throw new PipelineMcpGatewayError(`MCP gateway URL is required. Set ${gateway.url_env}.`);
 }
@@ -44,8 +45,9 @@ function renderGatewayConfig(config) {
 	return [
 		`provider: ${gateway.provider}`,
 		`mode: ${gateway.mode}`,
+		gateway.url ? `url: ${gateway.url}` : "",
 		`url_env: ${gateway.url_env}`,
-		`token_env: ${gateway.token_env}`,
+		`authorization_env: ${gateway.authorization_env}`,
 		gateway.default_profile ? `default_profile: ${gateway.default_profile}` : "",
 		`resolved_url: ${gatewayUrl(gateway)}`
 	].filter(Boolean).join("\n");
@@ -54,10 +56,12 @@ function renderCodexGatewayConfig(config) {
 	const gateway = configuredGateway(config);
 	return [
 		"# Generated by @oisincoveney/pipeline.",
-		"# Codex pipeline runs receive MCP gateway config through runtime launch args.",
-		"# Persistent Codex MCP config is intentionally left empty to avoid startup-time MCP fan-out.",
-		`# gateway_url = ${JSON.stringify(gatewayUrl(gateway))}`,
-		`# token_env = ${JSON.stringify(gateway.token_env)}`,
+		"",
+		`[mcp_servers.${PIPELINE_GATEWAY_SERVER_ID}]`,
+		`url = ${JSON.stringify(gatewayUrl(gateway))}`,
+		"",
+		`[mcp_servers.${PIPELINE_GATEWAY_SERVER_ID}.env_http_headers]`,
+		`Authorization = ${JSON.stringify(gateway.authorization_env)}`,
 		""
 	].join("\n");
 }
@@ -67,7 +71,7 @@ function renderOpenCodeGatewayConfig(config) {
 		$schema: "https://opencode.ai/config.json",
 		mcp: { [PIPELINE_GATEWAY_SERVER_ID]: {
 			enabled: true,
-			headers: { Authorization: `Bearer {env:${gateway.token_env}}` },
+			headers: gatewayOpenCodeHeaders(gateway),
 			type: "remote",
 			url: gatewayUrl(gateway)
 		} }
@@ -161,16 +165,22 @@ function checkGatewayUrl(gateway) {
 	}
 }
 function checkGatewayToken(gateway) {
-	return process.env[gateway.token_env] ? {
-		detail: gateway.token_env,
-		name: "gateway-token",
+	return process.env[gateway.authorization_env] ? {
+		detail: gateway.authorization_env,
+		name: "gateway-authorization",
 		passed: true
 	} : {
-		detail: `Set ${gateway.token_env}.`,
-		name: "gateway-token",
+		detail: `Set ${gateway.authorization_env}.`,
+		name: "gateway-authorization",
 		passed: false
 	};
 }
+function gatewayAuthorizationHeader(gateway) {
+	return `{env:${gateway.authorization_env}}`;
+}
+function gatewayOpenCodeHeaders(gateway) {
+	return { Authorization: gatewayAuthorizationHeader(gateway) };
+}
 async function checkThv(cwd) {
 	try {
 		await execa("thv", ["version"], {
@@ -240,11 +250,12 @@ async function checkGatewayHealth(gateway) {
 	}
 }
 async function firstHealthyGatewayResponse(url, gateway) {
+	const authorization = process.env[gateway.authorization_env];
 	for (const healthUrl of gatewayHealthUrls(url)) {
 		const response = await fetch(healthUrl, {
 			headers: {
 				Accept: "application/json, text/event-stream",
-				...process.env[gateway.token_env] ? { Authorization: `Bearer ${process.env[gateway.token_env]}` } : {}
+				...authorization ? { Authorization: authorization } : {}
 			},
 			method: "GET"
 		});
@@ -287,4 +298,4 @@ function legacyContentHit(cwd, path, pattern) {
 	return pattern.test(readFileSync(fullPath, "utf8")) ? path : void 0;
 }
 //#endregion
-export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, renderGatewayConfig, runGatewayDoctor, startLocalGateway };
+export { configureGatewayHosts, gatewayServerForProfile, localGatewayStatus, renderCodexGatewayConfig, renderGatewayConfig, runGatewayDoctor, startLocalGateway };

package/dist/pipeline-init.js

@@ -287,10 +287,11 @@ runners:
   opencode:
     type: opencode
     command: opencode
+    model: opencode/deepseek-v4-flash-free
     capabilities:
       native_subagents: true
       rules: true
-      skills: false
+      skills: true
       mcp_servers: true
       tools: [read, list, grep, glob, bash, edit, write, task]
       filesystem: [read-only, workspace-write]
@@ -353,7 +354,7 @@ mcp_gateway:
   provider: toolhive
   mode: local
   url_env: PIPELINE_MCP_GATEWAY_URL
-  token_env: PIPELINE_MCP_GATEWAY_TOKEN
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
   default_profile: default
 
 profiles:
@@ -563,6 +564,106 @@ profiles:
       repair:
         enabled: true
         max_attempts: 1
+  pipeline-opencode-researcher:
+    runner: opencode
+    description: Research the requested task and produce structured findings with OpenCode.
+    instructions:
+      path: .pipeline/prompts/researcher.md
+    rules: [test-first]
+    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
+  pipeline-opencode-test-writer:
+    runner: opencode
+    description: Add focused failing tests for the requested behavior with OpenCode.
+    instructions:
+      path: .pipeline/prompts/test-writer.md
+    rules: [test-first]
+    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: text
+  pipeline-opencode-code-writer:
+    runner: opencode
+    scheduling_roles: [implementation]
+    description: Implement production code until the failing tests pass with OpenCode.
+    instructions:
+      path: .pipeline/prompts/code-writer.md
+    rules: [test-first]
+    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: text
+  pipeline-opencode-acceptance-reviewer:
+    runner: opencode
+    scheduling_roles: [coverage]
+    description: Audit the finished change against every acceptance criterion with OpenCode.
+    instructions:
+      path: .pipeline/prompts/acceptance-reviewer.md
+    rules: [verification]
+    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
+  pipeline-opencode-verifier:
+    runner: opencode
+    scheduling_roles: [coverage]
+    description: Verify checks, implementation fit, and final evidence with OpenCode.
+    instructions:
+      path: .pipeline/prompts/verifier.md
+    rules: [verification]
+    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
 `;
 const VERDICT_SCHEMA = z.enum(["PASS", "FAIL"]);
 const STRING_ARRAY_SCHEMA = z.array(z.string());

package/dist/runner.d.ts

@@ -25,7 +25,6 @@ interface AgentRunRequest {
 interface AgentAdapter {
   run(request: AgentRunRequest): Promise<AgentResult>;
 }
-type RunnerStrategy = "native" | "subprocess";
 interface RunnerLaunchPlan {
   args: string[];
   command: string;
@@ -35,7 +34,6 @@ interface RunnerLaunchPlan {
   outputFormat: string;
   profileId?: string;
   runnerId: string;
-  strategy: RunnerStrategy;
   timeoutMs: number;
   type: RunnerType;
 }
@@ -65,4 +63,4 @@ declare function spawnAgent(harness: Harness, role: AgentRole, prompt: string, c
  */
 declare const subprocessAgentAdapter: AgentAdapter;
 //#endregion
-export { AgentAdapter, AgentResult, AgentRole, AgentRunRequest, Harness, RunnerCapabilityError, RunnerExecutionOptions, RunnerLaunchInput, RunnerLaunchPlan, RunnerStrategy, createOrchestratorLaunchPlan, createRunnerLaunchPlan, hardAgentAdapter, runLaunchPlan, spawnAgent, subprocessAgentAdapter };
+export { AgentAdapter, AgentResult, AgentRole, AgentRunRequest, Harness, RunnerCapabilityError, RunnerExecutionOptions, RunnerLaunchInput, RunnerLaunchPlan, createOrchestratorLaunchPlan, createRunnerLaunchPlan, hardAgentAdapter, runLaunchPlan, spawnAgent, subprocessAgentAdapter };

package/dist/runner.js

@@ -1,5 +1,5 @@
 import { resolveFileReference } from "./path-refs.js";
-import { buildMcpLaunchPlan, tomlValue } from "./mcp/launch-plan.js";
+import { tomlValue } from "./toml.js";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { execa } from "execa";
@@ -41,13 +41,6 @@ function optionalModelArgs(harness, runner, actor) {
 * Per-harness argv shape, excluding the leading harness binary name.
 */
 function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
-	const mcp = buildMcpLaunchPlan({
-		actor: options.actor,
-		config: options.config,
-		nodeId: options.nodeId ?? "agent",
-		runnerType: harness,
-		worktreePath
-	});
 	const skillArgs = skillArgsFor(harness, options.config, options.actor, worktreePath);
 	switch (harness) {
 		case "codex": return [
@@ -56,7 +49,7 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
 			"-C",
 			worktreePath,
 			...optionalModelArgs(harness, options.runner, options.actor),
-			...mcp.args,
+			...options.config ? ["--ignore-user-config"] : [],
 			...skillArgs,
 			"--dangerously-bypass-approvals-and-sandbox",
 			"--skip-git-repo-check",
@@ -67,7 +60,6 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
 			"--format",
 			"json",
 			...optionalModelArgs(harness, options.runner, options.actor),
-			...mcp.args,
 			...skillArgs,
 			"--dangerously-skip-permissions",
 			"--dir",
@@ -80,7 +72,6 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
 			"--format",
 			"json",
 			...optionalModelArgs(harness, options.runner, options.actor),
-			...mcp.args,
 			...skillArgs,
 			"--dangerously-skip-permissions",
 			"--dir",
@@ -145,16 +136,9 @@ function createActorLaunchPlan(config, input, actor, runnerId) {
 	if (runner.capabilities.output_formats && !runner.capabilities.output_formats.includes(outputFormat)) throw new RunnerCapabilityError(`runner '${runnerId}' does not support output format '${outputFormat}'`);
 	const command = runner.command ?? runner.type;
 	const timeoutMs = Number(process.env.PIPELINE_AGENT_TIMEOUT_MS ?? 3e5);
-	const env = buildMcpLaunchPlan({
-		actor,
-		config,
-		nodeId: input.nodeId,
-		runnerType: runner.type,
-		worktreePath: input.worktreePath
-	}).env;
 	const base = {
 		cwd: input.worktreePath,
-		env,
+		env: {},
 		nodeId: input.nodeId,
 		outputFormat,
 		profileId: input.profileId,
@@ -167,11 +151,9 @@ function createActorLaunchPlan(config, input, actor, runnerId) {
 		return {
 			...base,
 			args: renderArgv(runner.args ?? [], input.prompt, input.worktreePath),
-			command,
-			strategy: "subprocess"
+			command
 		};
 	}
-	const strategy = nativeStrategy(config, input, runnerId);
 	return {
 		...base,
 		args: harnessArgv(runner.type, input.prompt, input.worktreePath, input.contextFile ?? null, {
@@ -180,8 +162,7 @@ function createActorLaunchPlan(config, input, actor, runnerId) {
 			nodeId: input.nodeId,
 			runner
 		}),
-		command,
-		strategy
+		command
 	};
 }
 function skillArgsFor(runnerType, config, actor, worktreePath) {
@@ -199,13 +180,6 @@ function skillArgsFor(runnerType, config, actor, worktreePath) {
 	})))}`];
 	return [];
 }
-function nativeStrategy(config, input, runnerId) {
-	const runner = config.runners[runnerId];
-	const profile = input.profileId ? config.profiles[input.profileId] : void 0;
-	if (!(runner?.capabilities.native_subagents && profile)) return "subprocess";
-	if (runner.type === "command") return "subprocess";
-	return "native";
-}
 function renderArgv(args, prompt, cwd) {
 	return args.map((arg) => arg.replaceAll("{{prompt}}", prompt).replaceAll("{{cwd}}", cwd));
 }

package/dist/runtime/agent-node/agent-node.js

@@ -36,7 +36,7 @@ async function executeAgentNode(node, context, attempt) {
 	});
 	return {
 		evidence: [
-			`agent boundary node=${node.id} profile=${node.profile} runner=${plan.runnerId} strategy=${plan.strategy}`,
+			`agent boundary node=${node.id} profile=${node.profile} runner=${plan.runnerId}`,
 			...finalized.evidence,
 			...result.stderr ? [`stderr: ${result.stderr}`] : [],
 			...result.timedOut ? ["agent timed out"] : []

package/dist/schedule-planner.js

@@ -404,8 +404,20 @@ function plannerPrompt(entrypointId, task, baseline, config, planningContext) {
 	].join("\n");
 }
 function allowedProfilePromptLine(config, id) {
+	const profile = config.profiles[id];
+	const runner = config.runners[profile.runner];
 	const roles = effectiveSchedulingRoles(config, id);
-	return roles.length > 0 ? `- ${id} (scheduling_roles: ${roles.join(", ")})` : `- ${id}`;
+	const model = profile.model ?? runner?.model;
+	return `- ${id} (${[
+		`runner: ${profile.runner}`,
+		model ? `model: ${model}` : "",
+		roles.length > 0 ? `scheduling_roles: ${roles.join(", ")}` : "",
+		profile.description ? `description: ${profile.description}` : "",
+		profile.tools?.length ? `tools: ${profile.tools.join(", ")}` : "",
+		profile.filesystem?.mode ? `filesystem: ${profile.filesystem.mode}` : "",
+		profile.network?.mode ? `network: ${profile.network.mode}` : "",
+		`output: ${profile.output?.format ?? "text"}`
+	].filter(Boolean).join("; ")})`;
 }
 function effectiveSchedulingRoles(config, profileId) {
 	return [...new Set(config.profiles[profileId]?.scheduling_roles ?? [])].sort();

package/dist/toml.js

@@ -0,0 +1,12 @@
+//#region src/toml.ts
+const TOML_BARE_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
+function tomlValue(value) {
+	if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
+	if (value && typeof value === "object") return `{ ${Object.entries(value).map(([key, item]) => `${tomlKey(key)} = ${tomlValue(item)}`).join(", ")} }`;
+	return JSON.stringify(value);
+}
+function tomlKey(key) {
+	return TOML_BARE_KEY_PATTERN.test(key) ? key : JSON.stringify(key);
+}
+//#endregion
+export { tomlValue };

package/docs/config-architecture.md

@@ -150,8 +150,9 @@ MCP-enabled profiles use one gateway grant:
 mcp_gateway:
   provider: toolhive
   mode: hosted
+  url: https://pipeline-mcp.momokaya.ee/mcp/
   url_env: PIPELINE_MCP_GATEWAY_URL
-  token_env: PIPELINE_MCP_GATEWAY_TOKEN
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
   default_profile: default
 
 profiles:

package/docs/mcp-gateway.md

@@ -11,7 +11,7 @@ Playwright, Qdrant, or Neon.
 ```text
 Codex/OpenCode
         |
-        | profile-scoped MCP config
+        | project-level MCP config
         v
 pipeline MCP gateway
         |
@@ -21,9 +21,9 @@ Backlog / GitHub / Serena / Context7 / Playwright / Qdrant / Neon
 ```
 
 The gateway owns long-lived upstream connections and process lifecycle. The
-pipeline owns the host projection: profiles that need MCP declare the singleton
-`pipeline-gateway` grant, and every Codex/OpenCode session receives only that
-remote MCP server.
+pipeline owns the host projection: project host config declares only the
+singleton `pipeline-gateway` remote MCP server. Agents inherit that project
+config instead of receiving profile-scoped native MCP config.
 
 ## Folder Boundary
 
@@ -31,8 +31,6 @@ MCP-specific code belongs in `src/mcp`:
 
 - `gateway.ts`: hosted/local gateway config, diagnostics, and host config
   rewrites.
-- `launch-plan.ts`: runtime host projection for Codex and OpenCode.
-- `native-config.ts`: generated native Codex agent MCP config.
 
 The rest of the runtime should consume those functions instead of hand-rendering
 host-specific MCP config.
@@ -42,7 +40,8 @@ host-specific MCP config.
 1. Run or deploy a gateway that exposes one remote MCP endpoint.
 2. Configure the gateway with upstream servers and credentials.
 3. Configure `mcp_gateway` in `.pipeline/profiles.yaml`.
-4. Grant `pipeline-gateway` only to profiles that need MCP access.
+4. Run `pipe mcp gateway configure-host` to write the project Codex/OpenCode
+   host config.
 5. Keep high-risk upstream capabilities controlled by gateway-side policy, not
    by asking every agent host to independently start or filter servers.
 
@@ -52,8 +51,9 @@ Example profile config:
 mcp_gateway:
   provider: toolhive
   mode: hosted
+  url: https://pipeline-mcp.momokaya.ee/mcp/
   url_env: PIPELINE_MCP_GATEWAY_URL
-  token_env: PIPELINE_MCP_GATEWAY_TOKEN
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
   default_profile: default
 
 profiles:
@@ -72,10 +72,8 @@ orchestrator MCP set * subagent count * host config layers
 ```
 
 With a gateway, the runtime launches zero local upstream MCP processes for
-agents. Codex receives `--ignore-user-config` plus one
-`mcp_servers.pipeline-gateway` remote entry. OpenCode runs with isolated
-XDG/config roots and receives inline `OPENCODE_CONFIG_CONTENT` containing only
-`pipeline-gateway`.
+agents. Codex and OpenCode read the same project-level host config, which
+contains only `pipeline-gateway`.
 
 ## Candidate Gateway Implementations
 
@@ -86,6 +84,5 @@ Use an off-the-shelf aggregator when possible:
 Use `pipe mcp gateway doctor` to check required environment variables, gateway
 health, local ToolHive availability for local mode, and legacy direct MCP
 entries. Use `pipe mcp gateway configure-host` to rewrite project or global
-host config with a backup. For Codex, this removes persistent MCP entries and
-leaves gateway metadata as comments because the runtime injects the gateway
-with `--config` only for pipeline-launched agents.
+host config with a backup. For Codex and OpenCode, this removes direct
+upstream MCP entries and writes the singleton `pipeline-gateway` remote entry.

package/docs/mcp-host-isolation.md

@@ -1,15 +1,15 @@
 # MCP Host Isolation
 
-`oisin-pipeline` treats `.pipeline/profiles.yaml` as the MCP source of truth.
-Profiles that need MCP grant `pipeline-gateway`; runtime launch planning renders
-exactly one remote MCP server for the target host.
+`oisin-pipeline` treats project host config as the MCP client boundary. The
+generated Codex and OpenCode project configs declare exactly one remote MCP
+server: `pipeline-gateway`.
 
 ## Codex
 
 Codex `exec` supports `--ignore-user-config`, which skips
 `$CODEX_HOME/config.toml` while continuing to use Codex auth. Pipeline-managed
-Codex launches use that flag and pass the singleton gateway explicitly with
-`--config mcp_servers.pipeline-gateway...` entries.
+Codex launches use that flag and rely on the project `.codex/config.toml`
+gateway entry.
 
 This prevents user-config MCP fan-out for pipeline-launched Codex agents. It
 does not claim to suppress every possible system, managed, plugin, or trusted
@@ -19,23 +19,9 @@ Reference: https://developers.openai.com/codex/config-basic
 
 ## OpenCode
 
-OpenCode configuration is merged from multiple layers, so `OPENCODE_CONFIG`
-alone is not an isolation boundary. Pipeline-managed OpenCode launches create
-an isolated temporary runtime root, set `XDG_CONFIG_HOME`, `XDG_DATA_HOME`,
-`XDG_STATE_HOME`, `XDG_CACHE_HOME`, and `OPENCODE_TEST_HOME` inside it, disable
-project config with `OPENCODE_DISABLE_PROJECT_CONFIG=1`, and pass the
-`pipeline-gateway` remote server through `OPENCODE_CONFIG_CONTENT`.
-
-The generated inline config contains only `pipeline-gateway`. Direct upstream
-MCP ids are omitted rather than rendered as disabled entries, because enabled
-MCP servers can be started during OpenCode MCP service initialization before
-per-message tool filtering.
-
-Strict isolation means pipeline-managed OpenCode launches do not read the
-user's normal OpenCode account or MCP auth files. Provider credentials should be
-available through provider environment variables. Admin-managed OpenCode config
-outside the user/project config layers may still require container isolation or
-upstream host support.
+OpenCode project config is generated at `.opencode/opencode.json` with only the
+`pipeline-gateway` remote MCP server. Runtime launches do not set inline MCP
+config environment variables; agents inherit the project-level config.
 
 References:
 - https://opencode.ai/docs/config/

package/docs/operator-guide.md

@@ -378,8 +378,9 @@ Use the same client config shape for hosted and local gateways:
 mcp_gateway:
   provider: toolhive
   mode: hosted
+  url: https://pipeline-mcp.momokaya.ee/mcp/
   url_env: PIPELINE_MCP_GATEWAY_URL
-  token_env: PIPELINE_MCP_GATEWAY_TOKEN
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
   default_profile: default
 ```
 
@@ -412,17 +413,17 @@ pipe mcp gateway local-status
 pipe mcp gateway local-start
 ```
 
-`configure-host` removes persistent Codex MCP config and records the gateway
-metadata as comments. Codex pipeline runs receive the gateway through runtime
-launch arguments so ordinary Codex sessions do not start pipeline MCP clients at
-startup:
+`configure-host` removes direct upstream MCP config and writes the singleton
+gateway server into project host config. Codex receives:
 
 ```toml
 # Generated by @oisincoveney/pipeline.
-# Codex pipeline runs receive MCP gateway config through runtime launch args.
-# Persistent Codex MCP config is intentionally left empty to avoid startup-time MCP fan-out.
-# gateway_url = "https://gateway.example/mcp"
-# token_env = "PIPELINE_MCP_GATEWAY_TOKEN"
+
+[mcp_servers.pipeline-gateway]
+url = "https://gateway.example/mcp"
+
+[mcp_servers.pipeline-gateway.env_http_headers]
+Authorization = "PIPELINE_MCP_GATEWAY_AUTHORIZATION"
 ```
 
 OpenCode receives:
@@ -432,6 +433,9 @@ OpenCode receives:
   "mcp": {
     "pipeline-gateway": {
       "type": "remote",
+      "headers": {
+        "Authorization": "{env:PIPELINE_MCP_GATEWAY_AUTHORIZATION}"
+      },
       "url": "https://gateway.example/mcp"
     }
   }
@@ -526,8 +530,9 @@ singleton gateway server to profiles that need MCP.
 mcp_gateway:
   provider: toolhive
   mode: hosted
+  url: https://pipeline-mcp.momokaya.ee/mcp/
   url_env: PIPELINE_MCP_GATEWAY_URL
-  token_env: PIPELINE_MCP_GATEWAY_TOKEN
+  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
 
 profiles:
   pipeline-router:

package/package.json

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

package/dist/mcp/launch-plan.js

@@ -1,97 +0,0 @@
-import { gatewayServerForProfile } from "./gateway.js";
-import { mkdtempSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-//#region src/mcp/launch-plan.ts
-const TOML_BARE_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
-function buildMcpLaunchPlan(input) {
-	const selectedServers = selectedMcpServers(input.config, input.actor);
-	return {
-		args: mcpArgsFor(input.runnerType, selectedServers, Boolean(input.config)),
-		env: mcpEnvFor(input, selectedServers),
-		selectedServers
-	};
-}
-function selectedMcpServers(config, actor) {
-	return gatewayServerForProfile(config, actor);
-}
-function mcpArgsFor(runnerType, servers, hasPipelineConfig) {
-	if (runnerType === "codex") return [...hasPipelineConfig ? ["--ignore-user-config"] : [], ...codexMcpArgs(servers)];
-	if (Object.keys(servers).length === 0) return [];
-	return [];
-}
-function mcpEnvFor(input, servers) {
-	if (input.runnerType !== "opencode" || !input.config) return {};
-	const config = toOpenCodeMcpConfig(servers);
-	const dir = mkdtempSync(join(tmpdir(), "pipeline-opencode-runtime-"));
-	return {
-		OPENCODE_AUTH_CONTENT: void 0,
-		OPENCODE_CONFIG: void 0,
-		OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
-		OPENCODE_CONFIG_DIR: void 0,
-		OPENCODE_DISABLE_PROJECT_CONFIG: "1",
-		OPENCODE_TEST_HOME: join(dir, "home"),
-		PIPELINE_OPENCODE_RUNTIME_DIR: dir,
-		PIPELINE_WORKTREE: input.worktreePath,
-		XDG_CACHE_HOME: join(dir, "cache"),
-		XDG_CONFIG_HOME: join(dir, "config"),
-		XDG_DATA_HOME: join(dir, "data"),
-		XDG_STATE_HOME: join(dir, "state")
-	};
-}
-function isRemoteMcpServer(server) {
-	return typeof server.url === "string";
-}
-function headersWithBearerTokenEnv(server, renderTokenRef) {
-	const headers = { ...server.headers ?? {} };
-	if (server.bearer_token_env_var) headers.Authorization = `Bearer ${renderTokenRef(server.bearer_token_env_var)}`;
-	return Object.keys(headers).length > 0 ? headers : void 0;
-}
-function toOpenCodeMcpConfig(selectedServers) {
-	return {
-		$schema: "https://opencode.ai/config.json",
-		mcp: { ...Object.fromEntries(Object.entries(selectedServers).map(([id, server]) => {
-			if (isRemoteMcpServer(server)) {
-				const headers = headersWithBearerTokenEnv(server, (envVar) => `{env:${envVar}}`);
-				return [id, {
-					enabled: true,
-					...headers ? { headers } : {},
-					type: "remote",
-					url: server.url
-				}];
-			}
-			return [id, {
-				command: [server.command, ...server.args ?? []],
-				enabled: true,
-				...server.env ? { environment: server.env } : {},
-				type: "local"
-			}];
-		})) }
-	};
-}
-function codexMcpArgs(servers) {
-	return Object.entries(servers).flatMap(([id, server]) => {
-		if (isRemoteMcpServer(server)) return [
-			"--config",
-			`mcp_servers.${id}.url=${tomlValue(server.url)}`,
-			...server.headers ? ["--config", `mcp_servers.${id}.http_headers=${tomlValue(server.headers)}`] : [],
-			...server.bearer_token_env_var ? ["--config", `mcp_servers.${id}.bearer_token_env_var=${tomlValue(server.bearer_token_env_var)}`] : []
-		];
-		return [
-			"--config",
-			`mcp_servers.${id}.command=${tomlValue(server.command)}`,
-			...server.args ? ["--config", `mcp_servers.${id}.args=${tomlValue(server.args)}`] : [],
-			...server.env ? ["--config", `mcp_servers.${id}.env=${tomlValue(server.env)}`] : []
-		];
-	});
-}
-function tomlValue(value) {
-	if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
-	if (value && typeof value === "object") return `{ ${Object.entries(value).map(([key, item]) => `${tomlKey(key)} = ${tomlValue(item)}`).join(", ")} }`;
-	return JSON.stringify(value);
-}
-function tomlKey(key) {
-	return TOML_BARE_KEY_PATTERN.test(key) ? key : JSON.stringify(key);
-}
-//#endregion
-export { buildMcpLaunchPlan, tomlValue };