@oisincoveney/pipeline 1.5.1 → 1.5.3

package/README.md

@@ -152,22 +152,36 @@ Generate native host files from the YAML config:
 pipe install-commands --host all
 ```
 
-Generated resources are projections of the three config files; they are not
-separate sources of truth. The pipeline `orchestrator.profile` configures the
-host orchestrator surface, while workflow node `profile` values configure
-delegated agent boundaries.
-
-| Host | Generated files | Invocation |
-| --- | --- | --- |
-| Claude Code | `.claude/commands/pipe.md`, `.claude/agents/*.md` | `/pipe <task>` |
-| Codex | `.agents/skills/pipe/SKILL.md`, `.codex/agents/*.toml` | `$pipe <task>` |
-| OpenCode | `.opencode/commands/pipe.md`, `.opencode/agents/*.md` | `/pipe <task>` |
-| Kimi | `.kimi/commands/pipe.md`, `.kimi/agents/*.md` | `/pipe <task>` |
-| Pi | `.pi/extensions/pipe.ts`, `.pi/prompts/pipe.md` | `/pipe <task>` |
+Generated resources are derived from the three config files; they are not
+separate sources of truth. Host resources use exact native agents when the node
+runner matches the host. Cross-runner nodes use host-native execution only when
+the host can run the requested model explicitly, such as OpenCode subagents with
+a resolved `model:`; otherwise generated instructions dispatch to that runner's
+CLI instead of doing instruction-only translation.
+
+| Host        | Generated files                                        | Invocation           |
+| ----------- | ------------------------------------------------------ | -------------------- |
+| Claude Code | `.claude/commands/pipe.md`, `.claude/agents/*.md`      | `/pipe <task>`       |
+| Codex       | `.agents/skills/pipe/SKILL.md`, `.codex/agents/*.toml` | `$pipe <task>`       |
+| OpenCode    | `.opencode/commands/pipe.md`, `.opencode/agents/*.md`  | `/pipe <task>`       |
+| Kimi        | `.kimi/skills/pipe/SKILL.md`, `.kimi/agents/*.yaml`    | `/skill:pipe <task>` |
+| Pi          | `.pi/prompts/pipe.md`, `.pi/extensions/pipe.ts`        | `/pipe <task>`       |
 
 The installer is idempotent, supports `--check` and `--dry-run`, and refuses to
 overwrite manually edited files unless `--force` is supplied.
 
+Runner `model` is the canonical model id. Optional
+`host_models.<host>` entries are only needed when a host uses a different model
+identifier:
+
+```yaml
+runners:
+  kimi:
+    type: kimi
+    command: kimi
+    model: moonshot/kimi-k2.6
+```
+
 ## Runtime Guarantees
 
 - `pipe run` fails without `.pipeline/pipeline.yaml`,
@@ -189,9 +203,16 @@ External apps can import the stable config, planner, and runtime surfaces
 without deep-importing private source paths:
 
 ```ts
-import { loadPipelineConfig, parsePipelineConfigParts } from "@oisincoveney/pipeline/config";
+import {
+  loadPipelineConfig,
+  parsePipelineConfigParts,
+} from "@oisincoveney/pipeline/config";
 import { compileWorkflowPlan } from "@oisincoveney/pipeline/planner";
-import { runPipelineFromConfig, type PipelineRuntimeResult, type PipelineTaskContext } from "@oisincoveney/pipeline/runtime";
+import {
+  runPipelineFromConfig,
+  type PipelineRuntimeResult,
+  type PipelineTaskContext,
+} from "@oisincoveney/pipeline/runtime";
 ```
 
 ## Verification

package/dist/config.d.ts

@@ -74,6 +74,7 @@ declare const configSchema: z.ZodObject<{
                 "workspace-write": "workspace-write";
             }>;
         }, z.core.$strict>>;
+        host_models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         instructions: z.ZodObject<{
             inline: z.ZodOptional<z.ZodString>;
             path: z.ZodOptional<z.ZodString>;
@@ -150,6 +151,7 @@ declare const configSchema: z.ZodObject<{
             }>>>;
         }, z.core.$strict>;
         command: z.ZodOptional<z.ZodString>;
+        host_models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         model: z.ZodOptional<z.ZodString>;
         type: z.ZodEnum<{
             claude: "claude";

package/dist/config.js

@@ -21357,6 +21357,7 @@ var runnerSchema = exports_external.object({
   args: exports_external.array(exports_external.string()).optional(),
   capabilities: runnerCapabilitiesSchema,
   command: exports_external.string().optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   model: exports_external.string().optional(),
   type: exports_external.enum(RUNNER_TYPES)
 }).strict();
@@ -21422,6 +21423,7 @@ var retriesSchema = exports_external.object({
 var profileSchema = exports_external.object({
   description: exports_external.string().optional(),
   filesystem: filesystemSchema.optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   instructions: instructionsSchema,
   mcp_servers: exports_external.array(exports_external.string()).optional(),
   model: exports_external.string().optional(),

package/dist/index.js

@@ -27430,6 +27430,7 @@ var runnerSchema = exports_external.object({
   args: exports_external.array(exports_external.string()).optional(),
   capabilities: runnerCapabilitiesSchema,
   command: exports_external.string().optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   model: exports_external.string().optional(),
   type: exports_external.enum(RUNNER_TYPES)
 }).strict();
@@ -27495,6 +27496,7 @@ var retriesSchema = exports_external.object({
 var profileSchema = exports_external.object({
   description: exports_external.string().optional(),
   filesystem: filesystemSchema.optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   instructions: instructionsSchema,
   mcp_servers: exports_external.array(exports_external.string()).optional(),
   model: exports_external.string().optional(),
@@ -27938,8 +27940,8 @@ function validationError(issues) {
 // src/install-commands.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
+import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join as join2, relative } from "node:path";
 
 // node_modules/smol-toml/dist/error.js
 /*!
@@ -28663,8 +28665,10 @@ function codeForIssue(message) {
 // src/install-commands.ts
 var GENERATED_MARKER = "<!-- Generated by @oisincoveney/pipeline. -->";
 var GENERATED_TS_MARKER = "// Generated by @oisincoveney/pipeline.";
+var GENERATED_YAML_MARKER = "# Generated by @oisincoveney/pipeline.";
 var OWNER_MARKER_PREFIX = "<!-- @oisincoveney/pipeline:";
 var OWNER_TS_MARKER_PREFIX = "// @oisincoveney/pipeline:";
+var OWNER_YAML_MARKER_PREFIX = "# @oisincoveney/pipeline:";
 var COMMAND_HOSTS = [
   "claude",
   "opencode",
@@ -28676,14 +28680,17 @@ function header(host) {
   return [GENERATED_MARKER, `${OWNER_MARKER_PREFIX}host=${host} -->`, ""].join(`
 `);
 }
-function tsHeader(host) {
+function yamlHeader(host) {
   return [
-    GENERATED_TS_MARKER,
-    `${OWNER_TS_MARKER_PREFIX}host=${host}`,
+    GENERATED_YAML_MARKER,
+    `${OWNER_YAML_MARKER_PREFIX}host=${host}`,
     ""
   ].join(`
 `);
 }
+function hashHeader(host) {
+  return yamlHeader(host);
+}
 function markdown(data, body) {
   return `${import_gray_matter.default.stringify(body.trimEnd(), data).trimEnd()}
 `;
@@ -28699,11 +28706,8 @@ function profileEntries(config2) {
   }
   return [...profileIds].sort((a, b) => a.localeCompare(b)).map((id) => [id, config2.profiles[id]]);
 }
-function hasAgentWorkflowNodes(config2) {
-  return compileWorkflowPlan(config2).topologicalOrder.some((node) => node.kind === "agent");
-}
-function profileNames(config2) {
-  return profileEntries(config2).map(([name]) => `\`${name}\``).join(", ");
+function nativeProfileEntries(host, config2) {
+  return profileEntries(config2).filter(([_, profile]) => canRunNatively(host, config2, profile));
 }
 function orchestratorProfile(config2) {
   const profile = config2.profiles[config2.orchestrator.profile];
@@ -28715,34 +28719,69 @@ function orchestratorProfile(config2) {
     hooks: config2.orchestrator.hooks
   };
 }
-function workflowSummary(config2) {
+function resolvedHostModel(config2, host, profile) {
+  const runner = config2.runners[profile.runner];
+  return profile.host_models?.[host] ?? runner?.host_models?.[host] ?? profile.model ?? runner?.model;
+}
+function canRunNatively(host, config2, profile) {
+  if (host === "pi") {
+    return false;
+  }
+  if (profile.runner === host) {
+    return true;
+  }
+  return host === "opencode" && isModelRunner(profile.runner) && resolvedHostModel(config2, host, profile) !== undefined;
+}
+function isModelRunner(runnerId) {
+  return COMMAND_HOSTS.some((host) => host === runnerId);
+}
+function agentDispatchRoutes(host, config2) {
   const plan = compileWorkflowPlan(config2);
-  return [
-    `Workflow: ${plan.workflowId}`,
-    entrypointSummary(config2),
-    "",
-    ...plan.topologicalOrder.map((node) => {
-      const parts = [
-        `- ${node.id}`,
-        `kind=${node.kind}`,
-        node.profile ? `profile=${node.profile}` : "",
-        node.needs.length ? `needs=${node.needs.join(",")}` : "needs=none"
-      ].filter(Boolean);
-      return parts.join(" ");
-    })
-  ].join(`
-`);
+  return plan.topologicalOrder.flatMap((node) => {
+    if (!(node.kind === "agent" && node.profile)) {
+      return [];
+    }
+    const profile = config2.profiles[node.profile];
+    if (!profile) {
+      return [];
+    }
+    return [
+      dispatchRouteForAgent(host, config2, {
+        needs: node.needs,
+        nodeId: node.id,
+        profile,
+        profileId: node.profile
+      })
+    ];
+  });
 }
-function entrypointSummary(config2) {
-  const entries = Object.entries(config2.entrypoints);
-  if (entries.length === 0) {
-    return "Entrypoints: none";
+function dispatchRouteForAgent(host, config2, route) {
+  const runnerId = route.profile.runner;
+  if (host !== "pi" && runnerId === host) {
+    return {
+      ...route,
+      kind: "native-named-agent",
+      nativeAgentId: route.profileId,
+      runnerId
+    };
   }
-  return [
-    "Entrypoints:",
-    ...entries.map(([id, entrypoint]) => `- ${id} -> ${entrypoint.workflow}${entrypoint.description ? ` (${entrypoint.description})` : ""}`)
-  ].join(`
-`);
+  if (host === "opencode" && isModelRunner(runnerId)) {
+    const model = resolvedHostModel(config2, host, route.profile);
+    if (model) {
+      return {
+        ...route,
+        kind: "native-model-agent",
+        model,
+        nativeAgentId: route.profileId,
+        runnerId
+      };
+    }
+  }
+  return {
+    ...route,
+    kind: "cli",
+    runnerId
+  };
 }
 function grants(actor) {
   return [
@@ -28767,14 +28806,126 @@ function orchestratorBlock(config2) {
   ].join(`
 `);
 }
-function nativeDelegationInstruction(host, config2) {
-  if (!hasAgentWorkflowNodes(config2)) {
+function dispatchBlock(host, config2) {
+  const routes = agentDispatchRoutes(host, config2);
+  if (routes.length === 0) {
     return;
   }
+  const plan = compileWorkflowPlan(config2);
+  const nativeRoutes = routes.filter((route) => route.kind !== "cli");
+  const cliRoutes = routes.filter((route) => route.kind === "cli");
+  return [
+    `Run workflow \`${plan.workflowId}\` for the user task.`,
+    "",
+    nativeDispatchBlock(host, nativeRoutes),
+    cliDispatchBlock(host, cliRoutes),
+    nodePromptContract(plan.workflowId, routes),
+    "Do not use `pipe`, `oisin-pipeline`, or package scripts to execute workflow nodes.",
+    hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes)
+  ].filter((line) => Boolean(line)).join(`
+`);
+}
+function nativeDispatchBlock(host, routes) {
+  if (routes.length === 0) {
+    return;
+  }
+  return [
+    `${hostDisplayName(host)} native routes:`,
+    ...routes.map((route) => nativeDispatchLine(host, route)),
+    ""
+  ].join(`
+`);
+}
+function nativeDispatchLine(host, route) {
+  const needs = needsSummary(route.needs);
+  if (host === "codex") {
+    return `- ${route.nodeId}: spawn_agent agent_type=${route.nativeAgentId} runner=${route.runnerId} needs=${needs}`;
+  }
+  if (host === "claude") {
+    return `- ${route.nodeId}: Agent tool subagent_type=${route.nativeAgentId} runner=${route.runnerId} needs=${needs}`;
+  }
+  if (host === "kimi") {
+    return `- ${route.nodeId}: Agent tool subagent_type=${route.nativeAgentId} runner=${route.runnerId} needs=${needs}`;
+  }
   if (host === "opencode") {
-    return "Use OpenCode's task tool to delegate each agent workflow node to its configured profile. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+    const model = route.model ? ` model=${route.model}` : "";
+    return `- ${route.nodeId}: Task tool subagent_type=${route.nativeAgentId}${model} runner=${route.runnerId} needs=${needs}`;
+  }
+  return `- ${route.nodeId}: native agent ${route.nativeAgentId} runner=${route.runnerId} needs=${needs}`;
+}
+function cliDispatchBlock(host, routes) {
+  if (routes.length === 0) {
+    return;
+  }
+  const nativeNotice = host === "pi" ? "Pi native dispatch is not enabled for this generated workflow." : `These nodes are not ${hostDisplayName(host)} native routes.`;
+  return [nativeNotice, "CLI routes:", ...routes.map(cliDispatchLine), ""].join(`
+`);
+}
+function cliDispatchLine(route) {
+  return `- ${route.nodeId}: ${route.runnerId} CLI profile=${route.profileId} command=\`${runnerCliCommand(route)}\` needs=${needsSummary(route.needs)}`;
+}
+function runnerCliCommand(route) {
+  if (route.runnerId === "codex") {
+    return `codex exec --json -C <repo-root> --sandbox ${codexSandbox(route.profile)} --skip-git-repo-check <node prompt>`;
+  }
+  if (route.runnerId === "kimi") {
+    return `kimi --print --agent-file .kimi/agents/${route.profileId}.yaml --work-dir <repo-root> --final-message-only --prompt <node prompt>`;
+  }
+  if (route.runnerId === "opencode") {
+    return `opencode run --agent ${route.profileId} --format json --dir <repo-root> <node prompt>`;
+  }
+  if (route.runnerId === "claude") {
+    return `claude --agent ${route.profileId} --print -p <node prompt>`;
+  }
+  if (route.runnerId === "pi") {
+    return "pi --print --no-session <node prompt>";
   }
-  return "Use this host's native subagent mechanism for agent workflow nodes. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+  return `${route.runnerId} <node prompt>`;
+}
+function codexSandbox(profile) {
+  return profile.filesystem?.mode === "workspace-write" ? "workspace-write" : "read-only";
+}
+function nodePromptContract(workflowId, routes) {
+  const hasCliRoutes = routes.some((route) => route.kind === "cli");
+  const lead = hasCliRoutes ? "For each CLI node prompt include:" : "For each native node prompt include:";
+  return [
+    lead,
+    "- user task",
+    `- workflow id: ${workflowId}`,
+    "- node id",
+    "- profile id",
+    "- runner id",
+    "- profile instructions reference",
+    "- profile grants",
+    "- dependency outputs",
+    ""
+  ].join(`
+`);
+}
+function hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes) {
+  if (host === "codex" && nativeRoutes.length > 0) {
+    return "Do not substitute the generic Codex worker for configured profiles.";
+  }
+  if (cliRoutes.length > 0 && nativeRoutes.length > 0) {
+    return `Do not claim CLI routes are ${hostDisplayName(host)} native routes.`;
+  }
+  if (cliRoutes.length > 0 && nativeRoutes.length === 0 && host !== "pi") {
+    return `Do not claim these nodes are ${hostDisplayName(host)} subagents.`;
+  }
+  return;
+}
+function hostDisplayName(host) {
+  const names = {
+    claude: "Claude",
+    codex: "Codex",
+    kimi: "Kimi",
+    opencode: "OpenCode",
+    pi: "Pi"
+  };
+  return names[host];
+}
+function needsSummary(needs) {
+  return needs.length > 0 ? needs.join(",") : "none";
 }
 function compactLines(lines) {
   return lines.filter((line) => line !== undefined);
@@ -28803,20 +28954,16 @@ function claudeDefinitions(config2) {
       }, compactLines([
         header("claude").trimEnd(),
         "",
-        workflowSummary(config2),
-        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("claude", config2),
-        "",
-        `Delegate work only to configured profiles: ${profileNames(config2)}.`
+        dispatchBlock("claude", config2)
       ]).join(`
 `)),
       host: "claude",
       invocation: "/pipe <task description>",
       path: ".claude/commands/pipe.md"
     },
-    ...profileEntries(config2).map(([id, profile]) => ({
+    ...nativeProfileEntries("claude", config2).map(([id, profile]) => ({
       content: markdown({
         description: profile.description ?? id,
         name: id,
@@ -28856,18 +29003,13 @@ function opencodeDefinitions(config2) {
     {
       content: markdown({
         agent: "pipeline-orchestrator",
-        description: "Run the configured pipeline workflow",
-        subtask: true
+        description: "Run the configured pipeline workflow"
       }, compactLines([
         header("opencode").trimEnd(),
         "",
-        workflowSummary(config2),
-        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("opencode", config2),
-        "",
-        `Delegate work only to configured profiles: ${profileNames(config2)}.`
+        dispatchBlock("opencode", config2)
       ]).join(`
 `)),
       host: "opencode",
@@ -28879,24 +29021,25 @@ function opencodeDefinitions(config2) {
         description: "Orchestrate the configured pipeline and enforce gates.",
         mode: "primary",
         permission: opencodePermission(orchestratorProfile(config2), {
-          forceTask: hasAgentWorkflowNodes(config2)
+          forceTask: agentDispatchRoutes("opencode", config2).some((route) => route.kind !== "cli")
         })
       }, compactLines([
         header("opencode").trimEnd(),
         "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("opencode", config2)
+        dispatchBlock("opencode", config2)
       ]).join(`
 `)),
       host: "opencode",
       invocation: "/pipe <task description>",
       path: ".opencode/agents/pipeline-orchestrator.md"
     },
-    ...profileEntries(config2).map(([id, profile]) => ({
+    ...nativeProfileEntries("opencode", config2).map(([id, profile]) => ({
       content: markdown({
         description: profile.description ?? id,
         mode: "subagent",
+        ...opencodeModelProjection(config2, profile),
         permission: opencodePermission(profile)
       }, [
         header("opencode").trimEnd(),
@@ -28926,21 +29069,17 @@ function codexDefinitions(config2) {
         "",
         "Invoke this skill with `$pipe <task description>`.",
         "",
-        workflowSummary(config2),
-        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("codex", config2),
-        "",
-        `Use separate configured profiles: ${profileNames(config2)}.`
+        dispatchBlock("codex", config2)
       ]).join(`
 `)),
       host: "codex",
       invocation: "$pipe <task description>",
       path: ".agents/skills/pipe/SKILL.md"
     },
-    ...profileEntries(config2).map(([id, profile]) => ({
-      content: `${stringify({
+    ...nativeProfileEntries("codex", config2).map(([id, profile]) => ({
+      content: `${hashHeader("codex")}${stringify({
         description: profile.description ?? id,
         developer_instructions: [
           profile.description ?? id,
@@ -28963,39 +29102,153 @@ function kimiDefinitions(config2) {
   return [
     {
       content: markdown({
+        name: "pipe",
         description: "Run the configured pipeline workflow with Kimi agents"
       }, compactLines([
         header("kimi").trimEnd(),
         "",
-        workflowSummary(config2),
-        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("kimi", config2),
-        "",
-        `Use separate configured profiles: ${profileNames(config2)}.`
+        dispatchBlock("kimi", config2)
       ]).join(`
 `)),
       host: "kimi",
-      invocation: "/pipe <task description>",
-      path: ".kimi/commands/pipe.md"
+      invocation: "/skill:pipe <task description>",
+      path: ".kimi/skills/pipe/SKILL.md"
     },
-    ...profileEntries(config2).map(([id, profile]) => ({
-      content: markdown({ description: profile.description ?? id, name: id }, [
+    ...kimiOrchestratorAgentDefinitions(config2),
+    ...nativeProfileEntries("kimi", config2).flatMap(([id, profile]) => kimiAgentDefinitions(id, profile))
+  ];
+}
+function opencodeModelProjection(config2, profile) {
+  const model = resolvedHostModel(config2, "opencode", profile);
+  return model ? { model } : {};
+}
+function kimiAgentDefinitions(id, profile) {
+  const agentPath = `.kimi/agents/${id}.yaml`;
+  const promptPath = `.kimi/agents/${id}.prompt.md`;
+  const promptDefinitions = profile.instructions.inline ? [
+    {
+      content: [
         header("kimi").trimEnd(),
         "",
-        profile.description ?? id,
+        profile.instructions.inline,
+        ""
+      ].join(`
+`),
+      host: "kimi",
+      invocation: "/skill:pipe <task description>",
+      path: promptPath
+    }
+  ] : [];
+  const systemPromptPath = profile.instructions.path ? relative(dirname(agentPath), profile.instructions.path).replaceAll("\\", "/") : `./${id}.prompt.md`;
+  return [
+    {
+      content: [
+        yamlHeader("kimi").trimEnd(),
         "",
-        "Configured grants:",
-        grants(profile),
+        $stringify({
+          version: 1,
+          agent: {
+            allowed_tools: kimiAllowedTools(profile),
+            extend: "default",
+            name: id,
+            system_prompt_path: systemPromptPath
+          }
+        }).trimEnd(),
+        ""
+      ].join(`
+`),
+      host: "kimi",
+      invocation: "/skill:pipe <task description>",
+      path: agentPath
+    },
+    ...promptDefinitions
+  ];
+}
+function kimiOrchestratorAgentDefinitions(config2) {
+  if (agentDispatchRoutes("kimi", config2).every((route) => route.kind !== "native-named-agent")) {
+    return [];
+  }
+  const agentPath = ".kimi/agents/pipeline-orchestrator.yaml";
+  const promptPath = ".kimi/agents/pipeline-orchestrator.prompt.md";
+  const nativeKimiProfiles = nativeProfileEntries("kimi", config2);
+  const subagents = Object.fromEntries(nativeKimiProfiles.map(([id, profile]) => [
+    id,
+    {
+      description: profile.description ?? id,
+      path: `./${id}.yaml`
+    }
+  ]));
+  const plan = compileWorkflowPlan(config2);
+  const hasKimiNodes = plan.topologicalOrder.some((node) => {
+    if (!(node.kind === "agent" && node.profile)) {
+      return false;
+    }
+    return config2.profiles[node.profile]?.runner === "kimi";
+  });
+  const hasNonKimiNodes = plan.topologicalOrder.some((node) => {
+    if (!(node.kind === "agent" && node.profile)) {
+      return false;
+    }
+    return config2.profiles[node.profile]?.runner !== "kimi";
+  });
+  const allowedTools = [
+    ...hasKimiNodes ? ["kimi_cli.tools.agent:Agent"] : [],
+    ...hasNonKimiNodes ? ["kimi_cli.tools.shell:Shell"] : []
+  ];
+  return [
+    {
+      content: [
+        yamlHeader("kimi").trimEnd(),
         "",
-        instructionsPointer(profile)
+        $stringify({
+          version: 1,
+          agent: {
+            allowed_tools: allowedTools,
+            extend: "default",
+            name: "pipeline-orchestrator",
+            ...Object.keys(subagents).length > 0 ? { subagents } : {},
+            system_prompt_path: "./pipeline-orchestrator.prompt.md"
+          }
+        }).trimEnd(),
+        ""
       ].join(`
-`)),
+`),
       host: "kimi",
-      invocation: "/pipe <task description>",
-      path: `.kimi/agents/${id}.md`
-    }))
+      invocation: 'kimi --agent-file .kimi/agents/pipeline-orchestrator.yaml --work-dir <repo-root> --prompt "/skill:pipe <task description>"',
+      path: agentPath
+    },
+    {
+      content: compactLines([
+        header("kimi").trimEnd(),
+        "",
+        orchestratorBlock(config2),
+        "",
+        dispatchBlock("kimi", config2),
+        "",
+        "This agent file is the Kimi-native orchestrator surface. Launch Kimi with `--agent-file .kimi/agents/pipeline-orchestrator.yaml` before using `/skill:pipe` when you want Kimi runner nodes to run through Kimi's native Agent tool."
+      ]).join(`
+`),
+      host: "kimi",
+      invocation: 'kimi --agent-file .kimi/agents/pipeline-orchestrator.yaml --work-dir <repo-root> --prompt "/skill:pipe <task description>"',
+      path: promptPath
+    }
+  ];
+}
+function kimiAllowedTools(profile) {
+  const mapped = new Map([
+    ["bash", "kimi_cli.tools.shell:Shell"],
+    ["edit", "kimi_cli.tools.file:StrReplaceFile"],
+    ["glob", "kimi_cli.tools.file:Glob"],
+    ["grep", "kimi_cli.tools.file:Grep"],
+    ["list", "kimi_cli.tools.file:Glob"],
+    ["read", "kimi_cli.tools.file:ReadFile"],
+    ["task", "kimi_cli.tools.agent:Agent"],
+    ["write", "kimi_cli.tools.file:WriteFile"]
+  ]);
+  return [
+    ...new Set((profile.tools ?? []).flatMap((tool) => mapped.get(tool) ?? []))
   ];
 }
 function piDefinitions(config2) {
@@ -29003,111 +29256,21 @@ function piDefinitions(config2) {
     {
       content: markdown({
         "argument-hint": "<task description>",
-        description: "Run the configured pipeline workflow with Pi subagents"
+        description: "Run the configured pipeline workflow"
       }, compactLines([
         header("pi").trimEnd(),
         "",
-        workflowSummary(config2),
-        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("pi", config2)
+        dispatchBlock("pi", config2)
       ]).join(`
 `)),
       host: "pi",
       invocation: "/pipe <task description>",
       path: ".pi/prompts/pipe.md"
-    },
-    {
-      content: [
-        tsHeader("pi").trimEnd(),
-        "",
-        "interface PiCommand {",
-        "  name: string;",
-        "}",
-        "interface PiCommandContext {",
-        "  sendUserMessage(message: string): Promise<void> | void;",
-        "  ui: { notify(message: string, type?: string): void };",
-        "}",
-        "interface PiExtensionApi {",
-        "  getCommands?(): PiCommand[];",
-        "  registerCommand(",
-        "    name: string,",
-        "    command: {",
-        "      description: string;",
-        "      handler(args: string, ctx: PiCommandContext): Promise<void> | void;",
-        "    }",
-        "  ): void;",
-        "}",
-        "",
-        ...piOrchestratorComment(config2),
-        "",
-        ...piWorkflowNodesLiteral(config2),
-        "",
-        "function renderSubagentCommand(task: string): string {",
-        '  const chain = WORKFLOW_NODES.filter((node) => node.kind === "agent")',
-        "    .map((node) => `" + "$" + "{String(node.profile)}: " + "$" + "{node.id} " + "$" + "{task}" + "`)",
-        '    .join(" -> ");',
-        ["  return `/chain ", "$", "{JSON.stringify(chain)}`;"].join(""),
-        "}",
-        "",
-        "export default function pipelineWorkNext(pi: PiExtensionApi): void {",
-        '  pi.registerCommand("pipe", {',
-        '    description: "Run the configured pipeline with Pi subagents",',
-        "    handler: async (args: string, ctx) => {",
-        '      const task = String(args ?? "").trim();',
-        "      if (!task) {",
-        '        ctx.ui.notify("Usage: /pipe <task description>", "error");',
-        "        return;",
-        "      }",
-        "      const commands =",
-        '        typeof pi.getCommands === "function" ? pi.getCommands() : [];',
-        "      const hasPiSubagents = commands.some((command) =>",
-        '        ["run", "chain", "parallel", "run-chain", "subagents-doctor"].some(',
-        "          (name) => command.name === name || command.name.startsWith(`" + "$" + "{name}:" + "`)",
-        "        )",
-        "      );",
-        "      if (!hasPiSubagents) {",
-        '        ctx.ui.notify("Install pi-subagents before running /pipe.", "error");',
-        "        return;",
-        "      }",
-        "      await ctx.sendUserMessage(renderSubagentCommand(task));",
-        "    },",
-        "  });",
-        "}",
-        ""
-      ].join(`
-`),
-      host: "pi",
-      invocation: "/pipe <task description>",
-      path: ".pi/extensions/pipe.ts"
     }
   ];
 }
-function piWorkflowNodesLiteral(config2) {
-  const plan = compileWorkflowPlan(config2);
-  return [
-    "const WORKFLOW_NODES = [",
-    ...plan.topologicalOrder.flatMap((node) => [
-      "  {",
-      `    id: ${JSON.stringify(node.id)},`,
-      `    kind: ${JSON.stringify(node.kind)},`,
-      `    needs: ${JSON.stringify(node.needs)},`,
-      `    profile: ${JSON.stringify(node.profile ?? null)},`,
-      "  },"
-    ]),
-    "] as const;"
-  ];
-}
-function piOrchestratorComment(config2) {
-  return compactLines([
-    "/*",
-    orchestratorBlock(config2),
-    "",
-    nativeDelegationInstruction("pi", config2),
-    "*/"
-  ]);
-}
 function instructionsPointer(actor) {
   if (actor.instructions.path) {
     return `Instructions: ${actor.instructions.path}`;
@@ -29126,6 +29289,67 @@ function definitionsFor(host, config2) {
   const hosts = host === "all" ? COMMAND_HOSTS : [host];
   return hosts.flatMap((name) => definitions[name]());
 }
+function selectedHosts(host) {
+  return host === "all" ? [...COMMAND_HOSTS] : [host];
+}
+var GENERATED_RESOURCE_ROOTS = {
+  claude: [".claude/commands", ".claude/agents"],
+  codex: [".agents/skills", ".codex/agents"],
+  kimi: [".kimi/skills", ".kimi/agents", ".kimi/commands"],
+  opencode: [".opencode/commands", ".opencode/agents"],
+  pi: [".pi/prompts", ".pi/extensions"]
+};
+async function listFiles(root) {
+  if (!existsSync2(root)) {
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = await Promise.all(entries.map((entry) => {
+    const path = join2(root, entry.name);
+    if (entry.isDirectory()) {
+      return listFiles(path);
+    }
+    return [path];
+  }));
+  return files.flat();
+}
+function generatedHostFor(content) {
+  return COMMAND_HOSTS.find((host) => content.includes(`${OWNER_MARKER_PREFIX}host=${host} -->`) || content.includes(`${OWNER_TS_MARKER_PREFIX}host=${host}`) || content.includes(`${OWNER_YAML_MARKER_PREFIX}host=${host}`));
+}
+async function obsoleteGeneratedItems(cwd, host, wantedPaths) {
+  const hosts = new Set(selectedHosts(host));
+  const roots = selectedHosts(host).flatMap((selectedHost) => GENERATED_RESOURCE_ROOTS[selectedHost]);
+  const files = await Promise.all(roots.map((root) => listFiles(join2(cwd, root))));
+  return files.flat().flatMap((absolutePath) => {
+    const content = readFileSync2(absolutePath, "utf8");
+    const generatedHost = generatedHostFor(content);
+    if (!(generatedHost && hosts.has(generatedHost))) {
+      return [];
+    }
+    const path = relative(cwd, absolutePath).replaceAll("\\", "/");
+    if (wantedPaths.has(path)) {
+      return [];
+    }
+    return [
+      {
+        action: "delete",
+        host: generatedHost,
+        invocation: invocationForHost(generatedHost),
+        path
+      }
+    ];
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+function invocationForHost(host) {
+  const invocations = {
+    claude: "/pipe <task description>",
+    codex: "$pipe <task description>",
+    kimi: "/skill:pipe <task description>",
+    opencode: "/pipe <task description>",
+    pi: "/pipe <task description>"
+  };
+  return invocations[host];
+}
 function actionFor(path, content, force) {
   if (!existsSync2(path)) {
     return "create";
@@ -29134,7 +29358,7 @@ function actionFor(path, content, force) {
   if (current === content) {
     return "unchanged";
   }
-  if (!(current.includes(GENERATED_MARKER) || current.includes(GENERATED_TS_MARKER) || force)) {
+  if (!(current.includes(GENERATED_MARKER) || current.includes(GENERATED_TS_MARKER) || current.includes(GENERATED_YAML_MARKER) || force)) {
     return "conflict";
   }
   return "update";
@@ -29144,7 +29368,9 @@ async function installCommands(options2 = {}) {
   const host = options2.host ?? "all";
   const config2 = loadPipelineConfig(cwd);
   const items = [];
-  for (const definition of definitionsFor(host, config2)) {
+  const definitions = definitionsFor(host, config2);
+  const wantedPaths = new Set(definitions.map((definition) => definition.path));
+  for (const definition of definitions) {
     const target = join2(cwd, definition.path);
     const action = actionFor(target, definition.content, Boolean(options2.force));
     items.push({
@@ -29162,6 +29388,13 @@ async function installCommands(options2 = {}) {
     await mkdir(dirname(target), { recursive: true });
     await writeFile(target, definition.content);
   }
+  const obsoleteItems = await obsoleteGeneratedItems(cwd, host, wantedPaths);
+  items.push(...obsoleteItems);
+  if (!(options2.check || options2.dryRun)) {
+    for (const item of obsoleteItems) {
+      await rm(join2(cwd, item.path), { force: true });
+    }
+  }
   if (!options2.dryRun && items.some((item) => item.action === "conflict")) {
     throw new Error([
       "Refusing to overwrite manually edited command files.",
@@ -29619,7 +29852,7 @@ function hostResourceInput(host) {
   return [
     `# ${host} Resource Input`,
     "",
-    "This file is scaffolded input for host-specific resource projection.",
+    "This file is scaffolded input for host-specific generated resources.",
     "The source of truth is `.pipeline/pipeline.yaml` plus `.pipeline/profiles.yaml` and `.pipeline/runners.yaml`; generated host resources must preserve the profiles, prompts, rules, tools, filesystem policy, network policy, and output contracts declared there.",
     ""
   ].join(`
@@ -36912,8 +37145,6 @@ function createActorLaunchPlan(config2, input, actor, runnerId) {
 function piArgv(prompt, config2, actor, worktreePath = process.cwd(), runner) {
   return [
     "--print",
-    "--mode",
-    "json",
     ...optionalModelArgs("pi", runner, actor),
     ...piToolArgs(actor?.tools ?? []),
     ...skillArgsFor("pi", config2, actor, worktreePath),
@@ -38642,7 +38873,10 @@ function createCliProgram() {
     console.log(formatPipelineInitResult(result));
   });
   program2.command("install-commands").description("Install generated slash-command adapters into this repository").addOption(new Option("--host <host>", "host command set to install").choices(["all", "claude", "opencode", "codex", "kimi", "pi"]).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);
+    const result = await installCommands({
+      ...flags,
+      cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
+    });
     console.log(formatInstallCommandsResult(result));
   });
   return program2;

package/dist/install-commands.d.ts

@@ -1,7 +1,7 @@
 export declare const COMMAND_HOSTS: readonly ["claude", "opencode", "codex", "kimi", "pi"];
 export type CommandHost = (typeof COMMAND_HOSTS)[number];
 export type CommandHostSelection = CommandHost | "all";
-export type InstallAction = "conflict" | "create" | "unchanged" | "update";
+export type InstallAction = "conflict" | "create" | "delete" | "unchanged" | "update";
 export interface CommandInstallPlanItem {
     action: InstallAction;
     host: CommandHost;

package/dist/pipeline-runtime.js

@@ -28560,6 +28560,7 @@ var runnerSchema = exports_external.object({
   args: exports_external.array(exports_external.string()).optional(),
   capabilities: runnerCapabilitiesSchema,
   command: exports_external.string().optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   model: exports_external.string().optional(),
   type: exports_external.enum(RUNNER_TYPES)
 }).strict();
@@ -28625,6 +28626,7 @@ var retriesSchema = exports_external.object({
 var profileSchema = exports_external.object({
   description: exports_external.string().optional(),
   filesystem: filesystemSchema.optional(),
+  host_models: exports_external.record(exports_external.string(), exports_external.string().min(1)).optional(),
   instructions: instructionsSchema,
   mcp_servers: exports_external.array(exports_external.string()).optional(),
   model: exports_external.string().optional(),
@@ -29627,8 +29629,6 @@ function createActorLaunchPlan(config2, input, actor, runnerId) {
 function piArgv(prompt, config2, actor, worktreePath = process.cwd(), runner) {
   return [
     "--print",
-    "--mode",
-    "json",
     ...optionalModelArgs("pi", runner, actor),
     ...piToolArgs(actor?.tools ?? []),
     ...skillArgsFor("pi", config2, actor, worktreePath),

package/dist/runner.js

@@ -7381,8 +7381,6 @@ async function execaHarnessPi(prompt, contextFile, worktreePath) {
 ${prompt}` : prompt;
   const argv = [
     "--print",
-    "--mode",
-    "json",
     ...optionalModelArgs("pi"),
     "--no-session",
     effectivePrompt
@@ -7477,8 +7475,6 @@ function createActorLaunchPlan(config, input, actor, runnerId) {
 function piArgv(prompt, config, actor, worktreePath = process.cwd(), runner) {
   return [
     "--print",
-    "--mode",
-    "json",
     ...optionalModelArgs("pi", runner, actor),
     ...piToolArgs(actor?.tools ?? []),
     ...skillArgsFor("pi", config, actor, worktreePath),

package/docs/config-architecture.md

@@ -189,14 +189,14 @@ timeouts, output limits, sanitized env, and explicit trust flags.
 
 ## Host Support Matrix
 
-| Runner | Native subagents | Rules | Skills | MCP | Outputs | Generated resources |
-| --- | --- | --- | --- | --- | --- | --- |
-| Claude | yes | yes | projected as text when declared | yes | text, JSON, schema | command plus `.claude/agents` |
-| Codex | yes | yes | yes | yes | text, JSON, JSONL, schema | skill plus `.codex/agents` |
-| OpenCode | yes | yes | projected as text when declared | yes | text, JSON, JSONL, schema | command plus `.opencode/agents` |
-| Kimi | yes | yes | projected as text when declared | no | text, JSON | command plus `.kimi/agents` |
-| Pi | yes, with pi-subagents | yes | projected as text when declared | no | text, JSON | extension plus prompt |
-| command | no | no | no | no | declared by runner | subprocess argv |
+| Runner   | Native subagents       | Rules | Skills                                        | MCP | Outputs                   | Generated resources              |
+| -------- | ---------------------- | ----- | --------------------------------------------- | --- | ------------------------- | -------------------------------- |
+| Claude   | yes                    | yes   | included in generated profile text            | yes | text, JSON, schema        | command plus `.claude/agents`    |
+| Codex    | yes                    | yes   | yes                                           | yes | text, JSON, JSONL, schema | skill plus `.codex/agents`       |
+| OpenCode | yes                    | yes   | included in generated profile text            | yes | text, JSON, JSONL, schema | command plus `.opencode/agents`  |
+| Kimi     | yes                    | yes   | surfaced through project skills when declared | no  | text, JSON                | skill plus `.kimi/agents/*.yaml` |
+| Pi       | yes, with pi-subagents | yes   | included in generated prompt text             | no  | text, JSON                | prompt plus no-op extension shim |
+| command  | no                     | no    | no                                            | no  | declared by runner        | subprocess argv                  |
 
 The runtime prefers native subagents when the runner advertises
 `native_subagents: true` and the configured permissions, runner, output, and
@@ -204,6 +204,15 @@ resource grants can be represented safely. Otherwise it uses a subprocess for
 the agent node. In both cases each agent node records a separate invocation
 boundary; multi-agent workflows are never collapsed into one prompt.
 
+Generated host resources follow a native-first, runner-correct rule. Same-host
+agent nodes use exact native subagents. Cross-runner nodes use host-native
+execution only when the host can explicitly run the requested model; OpenCode
+does this through per-agent `model:` values resolved from profile or runner
+`model`, with optional `host_models.opencode` overrides when model ids differ.
+If native execution cannot represent the requested runner/model, generated
+instructions dispatch to that runner's CLI instead of doing instruction-only
+translation.
+
 ## Troubleshooting
 
 - Missing config: run `pipe init`; `pipe run` requires
@@ -212,8 +221,9 @@ boundary; multi-agent workflows are never collapsed into one prompt.
 - Capability error: reduce the profile grants or choose a runner whose declared
   capabilities include the requested tools, filesystem, network, output, rules,
   skills, or MCP access.
-- Pi native execution error: install and enable `pi-subagents`; generated Pi
-  resources check for its commands before sending a chain.
+- Pi native execution unavailable: install and enable `pi-subagents` if you want
+  Pi-native chains. Otherwise `/pipe` uses the CLI dispatch instructions in the
+  generated Pi prompt.
 - Gate failure: inspect `pipe run` output for node, gate, reason, and evidence.
   Dependent nodes are not executed after a required gate fails.
 - Schema failure: ensure the agent emits valid JSON and that `schema_path`

package/docs/slash-command-adapter-contract.md

@@ -1,8 +1,9 @@
 # Host Resource Adapter Contract
 
-Generated host resources are projections of `.pipeline/runners.yaml`,
-`.pipeline/profiles.yaml`, and `.pipeline/pipeline.yaml`. They do not shell out
-to a legacy command and do not maintain independent profile definitions.
+Generated host resources are derived from `.pipeline/runners.yaml`,
+`.pipeline/profiles.yaml`, and `.pipeline/pipeline.yaml`. They do not maintain
+independent profile definitions or silently translate one runner into another
+host's default agent.
 
 Install or check generated resources with:
 
@@ -13,23 +14,30 @@ pipe install-commands --host all --check
 
 ## Host Mappings
 
-| Host | Generated resources | Invocation | Mechanical path |
-| --- | --- | --- | --- |
-| Claude Code | `.claude/commands/pipe.md`, `.claude/agents/*.md` | `/pipe <task>` | Project command delegates to configured Claude agents. |
-| Codex | `.agents/skills/pipe/SKILL.md`, `.codex/agents/*.toml` | `$pipe <task>` | Skill instructs Codex to use generated Codex agents. |
-| OpenCode | `.opencode/commands/pipe.md`, `.opencode/agents/*.md` | `/pipe <task>` | Project command runs a primary orchestrator and configured subagents. |
-| Kimi | `.kimi/commands/pipe.md`, `.kimi/agents/*.md` | `/pipe <task>` | Project command and agent specs mirror YAML grants. |
-| Pi | `.pi/extensions/pipe.ts`, `.pi/prompts/pipe.md` | `/pipe <task>` | Extension requires `pi-subagents` before sending a chain. |
+| Host        | Generated resources                                    | Invocation           | Mechanical path                                                                                        |
+| ----------- | ------------------------------------------------------ | -------------------- | ------------------------------------------------------------------------------------------------------ |
+| Claude Code | `.claude/commands/pipe.md`, `.claude/agents/*.md`      | `/pipe <task>`       | Project command delegates to configured Claude agents.                                                 |
+| Codex       | `.agents/skills/pipe/SKILL.md`, `.codex/agents/*.toml` | `$pipe <task>`       | Skill instructs Codex to use generated Codex agents for Codex runner nodes.                            |
+| OpenCode    | `.opencode/commands/pipe.md`, `.opencode/agents/*.md`  | `/pipe <task>`       | Project command runs a primary orchestrator and native subagents when the requested model is resolved. |
+| Kimi        | `.kimi/skills/pipe/SKILL.md`, `.kimi/agents/*.yaml`    | `/skill:pipe <task>` | Kimi discovers project skills as `/skill:<name>` commands; Kimi agents are generated as YAML specs.    |
+| Pi          | `.pi/prompts/pipe.md`, `.pi/extensions/pipe.ts`        | `/pipe <task>`       | Pi discovers project prompt templates as slash commands; the generated extension is a no-op shim.      |
 
 ## Projection Rules
 
 - Profile names, descriptions, instructions, tools, rules, skills, MCP servers,
   filesystem mode, network mode, and output contracts are read from YAML.
+- Exact native dispatch is used when a node runner matches the host.
+- OpenCode can run mixed native subagents when the node runner has a resolved
+  model from `profile.host_models.opencode`, `runner.host_models.opencode`,
+  `profile.model`, or `runner.model`.
+- Cross-runner nodes that cannot be represented natively are dispatched through
+  that runner's CLI. Instruction-only translation is not runner-correct and is
+  not used as an implicit fallback.
 - Host-specific formats can omit unsupported capabilities, but they must not
   grant broader access than requested.
 - Regeneration is idempotent for generated files. Manual edits are protected
   unless `--force` is supplied.
 
-The CLI runtime and host projections share the same workflow plan. Multi-agent
+The CLI runtime and generated host resources share the same workflow plan. Multi-agent
 workflows require separate agent boundaries; host resources must not collapse
 the workflow into a single prompt.

package/package.json

@@ -73,7 +73,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "",
   "main": "index.js",
   "keywords": [],