@oisincoveney/pipeline 1.5.0 → 1.5.2

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",
@@ -28684,6 +28688,17 @@ function tsHeader(host) {
   ].join(`
 `);
 }
+function yamlHeader(host) {
+  return [
+    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,6 +28714,9 @@ function profileEntries(config2) {
   }
   return [...profileIds].sort((a, b) => a.localeCompare(b)).map((id) => [id, config2.profiles[id]]);
 }
+function nativeProfileEntries(host, config2) {
+  return profileEntries(config2).filter(([_, profile]) => canRunNatively(host, config2, profile));
+}
 function hasAgentWorkflowNodes(config2) {
   return compileWorkflowPlan(config2).topologicalOrder.some((node) => node.kind === "agent");
 }
@@ -28726,6 +28744,7 @@ function workflowSummary(config2) {
         `- ${node.id}`,
         `kind=${node.kind}`,
         node.profile ? `profile=${node.profile}` : "",
+        runnerForNode(config2, node.profile) ? `runner=${runnerForNode(config2, node.profile)}` : "",
         node.needs.length ? `needs=${node.needs.join(",")}` : "needs=none"
       ].filter(Boolean);
       return parts.join(" ");
@@ -28733,6 +28752,62 @@ function workflowSummary(config2) {
   ].join(`
 `);
 }
+function runnerForNode(config2, profileId) {
+  return profileId ? config2.profiles[profileId]?.runner : undefined;
+}
+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 (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 runnerCliLabel(runnerId) {
+  return `${runnerId} CLI`;
+}
+function dispatchSummary(host, config2) {
+  const plan = compileWorkflowPlan(config2);
+  const lines = plan.topologicalOrder.flatMap((node) => {
+    if (!(node.kind === "agent" && node.profile)) {
+      return [];
+    }
+    const profile = config2.profiles[node.profile];
+    if (!profile) {
+      return [];
+    }
+    return [dispatchLineForAgent(host, config2, node.id, node.profile, profile)];
+  });
+  return ["Node dispatch:", ...lines.length > 0 ? lines : ["- none"]].join(`
+`);
+}
+function dispatchLineForAgent(host, config2, nodeId, profileId, profile) {
+  if (profile.runner === host) {
+    return sameHostDispatchLine(host, nodeId, profileId, profile.runner);
+  }
+  if (host === "opencode" && isModelRunner(profile.runner)) {
+    const model = resolvedHostModel(config2, host, profile);
+    if (model) {
+      return `- ${nodeId}: OpenCode native subagent profile=${profileId} model=${model} runner=${profile.runner}`;
+    }
+  }
+  return `- ${nodeId}: ${runnerCliLabel(profile.runner)} profile=${profileId} runner=${profile.runner}`;
+}
+function sameHostDispatchLine(host, nodeId, profileId, runnerId) {
+  const labels = {
+    claude: `Claude native subagent subagent_type=${profileId}`,
+    codex: `Codex native worker subagent profile=${profileId} agent_type=worker`,
+    kimi: `Kimi native Agent subagent subagent_type=${profileId}`,
+    opencode: `OpenCode native subagent subagent_type=${profileId}`,
+    pi: `Pi native subagent chain profile=${profileId}`
+  };
+  return `- ${nodeId}: ${labels[host]} runner=${runnerId}`;
+}
 function entrypointSummary(config2) {
   const entries = Object.entries(config2.entrypoints);
   if (entries.length === 0) {
@@ -28772,9 +28847,36 @@ function nativeDelegationInstruction(host, config2) {
     return;
   }
   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.";
+    return "Dispatch each agent workflow node by its runner. For lines marked `OpenCode native subagent`, use OpenCode's task tool with `subagent_type` exactly equal to the configured profile id. For cross-runner nodes with an explicit resolved OpenCode model, use the generated OpenCode native subagent. For lines marked CLI, invoke that runner's CLI directly. Do not substitute a default subagent. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+  }
+  if (host === "codex") {
+    return 'Dispatch each agent workflow node by its runner. For lines marked `Codex native worker subagent`, call `spawn_agent` with `agent_type: "worker"` and `fork_context: false`, then pass a node prompt containing the task, workflow id, node id, profile id, runner id, configured profile instructions, grants, and dependency outputs. Codex `exec` exposes native built-in agent types (`default`, `explorer`, `worker`) rather than arbitrary generated project profile ids, so do not call `spawn_agent` with the profile id as `agent_type`. Do not spawn the default agent for configured Codex nodes. For lines marked CLI, invoke that runner\'s CLI directly. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.';
+  }
+  if (host === "claude") {
+    return "Dispatch each agent workflow node by its runner. For lines marked `Claude native subagent`, use Claude's Task tool with `subagent_type` exactly equal to the configured profile id. For lines marked CLI, invoke that runner's CLI directly. Do not substitute a default subagent. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.";
   }
-  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.";
+  if (host === "kimi") {
+    return "Dispatch each agent workflow node by its runner. For lines marked `Kimi native Agent subagent`, use Kimi's Agent tool with `subagent_type` exactly equal to the configured profile id when the current Kimi root agent exposes that subagent type. If that native subagent type is not available, invoke Kimi CLI with the generated `.kimi/agents/<profile>.yaml` agent spec. For non-Kimi nodes, invoke that runner's CLI directly. Do not substitute a default subagent. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+  }
+  if (host === "pi") {
+    return "Dispatch each agent workflow node by its runner. Use Pi's native subagent chain only when every agent node is a Pi runner node and the Pi subagent commands are available. If Pi native subagent commands are unavailable, invoke each configured runner through its CLI directly. For mixed-runner workflows, invoke each configured runner through its CLI directly. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+  }
+  return "Dispatch each agent workflow node by its runner. Use this host's native subagent mechanism only when it can actually run the requested runner/model. For cross-runner nodes that cannot be represented natively, invoke that runner's CLI directly. Do not use instruction-only translation. Do not invoke package scripts or the pipeline CLI to run this workflow.";
+}
+function cliDispatchInstructions(config2) {
+  if (!hasAgentWorkflowNodes(config2)) {
+    return;
+  }
+  return [
+    "For CLI-dispatched nodes, construct the node prompt with the task, workflow id, node id, profile id, runner id, and dependency outputs.",
+    "CLI dispatch command shapes:",
+    "- codex: `codex exec --json -C <repo-root> --sandbox <mode> --config 'approval_policy=\"never\"' --skip-git-repo-check <node prompt>`",
+    "- kimi: `kimi --print --agent-file .kimi/agents/<profile>.yaml --work-dir <repo-root> --final-message-only --prompt <node prompt>`",
+    "- opencode: `opencode run --agent <profile> --format json --dir <repo-root> <node prompt>`",
+    "- claude: `claude --print -p <node prompt>`",
+    "- pi: `pi --print --no-session <node prompt>`"
+  ].join(`
+`);
 }
 function compactLines(lines) {
   return lines.filter((line) => line !== undefined);
@@ -28805,10 +28907,14 @@ function claudeDefinitions(config2) {
         "",
         workflowSummary(config2),
         "",
+        dispatchSummary("claude", config2),
+        "",
         orchestratorBlock(config2),
         "",
         nativeDelegationInstruction("claude", config2),
         "",
+        cliDispatchInstructions(config2),
+        "",
         `Delegate work only to configured profiles: ${profileNames(config2)}.`
       ]).join(`
 `)),
@@ -28816,7 +28922,7 @@ function claudeDefinitions(config2) {
       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,
@@ -28863,10 +28969,14 @@ function opencodeDefinitions(config2) {
         "",
         workflowSummary(config2),
         "",
+        dispatchSummary("opencode", config2),
+        "",
         orchestratorBlock(config2),
         "",
         nativeDelegationInstruction("opencode", config2),
         "",
+        cliDispatchInstructions(config2),
+        "",
         `Delegate work only to configured profiles: ${profileNames(config2)}.`
       ]).join(`
 `)),
@@ -28886,17 +28996,22 @@ function opencodeDefinitions(config2) {
         "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("opencode", config2)
+        dispatchSummary("opencode", config2),
+        "",
+        nativeDelegationInstruction("opencode", config2),
+        "",
+        cliDispatchInstructions(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(),
@@ -28928,10 +29043,14 @@ function codexDefinitions(config2) {
         "",
         workflowSummary(config2),
         "",
+        dispatchSummary("codex", config2),
+        "",
         orchestratorBlock(config2),
         "",
         nativeDelegationInstruction("codex", config2),
         "",
+        cliDispatchInstructions(config2),
+        "",
         `Use separate configured profiles: ${profileNames(config2)}.`
       ]).join(`
 `)),
@@ -28939,8 +29058,8 @@ function codexDefinitions(config2) {
       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 +29082,164 @@ function kimiDefinitions(config2) {
   return [
     {
       content: markdown({
+        name: "pipe",
         description: "Run the configured pipeline workflow with Kimi agents"
       }, compactLines([
         header("kimi").trimEnd(),
         "",
         workflowSummary(config2),
         "",
+        dispatchSummary("kimi", config2),
+        "",
         orchestratorBlock(config2),
         "",
         nativeDelegationInstruction("kimi", config2),
         "",
+        cliDispatchInstructions(config2),
+        "",
         `Use separate configured profiles: ${profileNames(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) {
+  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(),
+        "",
+        workflowSummary(config2),
+        "",
+        dispatchSummary("kimi", config2),
+        "",
+        orchestratorBlock(config2),
+        "",
+        nativeDelegationInstruction("kimi", config2),
+        "",
+        cliDispatchInstructions(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) {
@@ -29009,9 +29253,13 @@ function piDefinitions(config2) {
         "",
         workflowSummary(config2),
         "",
+        dispatchSummary("pi", config2),
+        "",
         orchestratorBlock(config2),
         "",
-        nativeDelegationInstruction("pi", config2)
+        nativeDelegationInstruction("pi", config2),
+        "",
+        cliDispatchInstructions(config2)
       ]).join(`
 `)),
       host: "pi",
@@ -29022,58 +29270,12 @@ function piDefinitions(config2) {
       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));",
-        "    },",
-        "  });",
+        "// Pi exposes project prompt templates as slash commands.",
+        "// The real /pipe command is .pi/prompts/pipe.md.",
+        "// This generated shim intentionally registers no command so it cannot",
+        "// intercept /pipe in print mode before the prompt-template expansion runs.",
+        "export default function pipelineWorkNext(): void {",
+        "  return;",
         "}",
         ""
       ].join(`
@@ -29084,30 +29286,6 @@ function piDefinitions(config2) {
     }
   ];
 }
-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 +29304,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 +29373,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 +29383,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 +29403,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 +29867,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(`
@@ -36683,8 +36931,8 @@ async function runTests(worktreePath, signal) {
   }
   try {
     const result = await execa(projectCommand.command, projectCommand.args, {
+      cancelSignal: signal,
       cwd: worktreePath,
-      signal,
       shell: projectCommand.shell
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join(`
@@ -36708,8 +36956,8 @@ async function runTypecheck(worktreePath, signal) {
   }
   try {
     const result = await execa(projectCommand.command, projectCommand.args, {
+      cancelSignal: signal,
       cwd: worktreePath,
-      signal,
       shell: projectCommand.shell
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join(`
@@ -36741,8 +36989,8 @@ function parseJscpdOutput(output) {
 async function runJscpd(worktreePath, signal) {
   try {
     const result = await execa("bunx", ["jscpd", "--min-tokens", "50", "--reporters", "json", "."], {
-      cwd: worktreePath,
-      signal
+      cancelSignal: signal,
+      cwd: worktreePath
     });
     return parseJscpdOutput(result.stdout ?? "");
   } catch (err) {
@@ -36912,8 +37160,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),
@@ -37059,9 +37305,9 @@ function renderArgv(args, prompt, cwd) {
 async function runLaunchPlan(plan, options2 = {}) {
   try {
     const result = await execa(plan.command, plan.args, {
+      cancelSignal: options2.signal,
       cwd: plan.cwd,
       env: plan.env,
-      signal: options2.signal,
       stdin: "ignore",
       timeout: plan.timeoutMs
     });
@@ -37743,12 +37989,12 @@ async function executeCommand(command, context, options2 = {}) {
   }
   try {
     const result = await execa(command[0], command.slice(1), {
+      cancelSignal: context.signal,
       cwd: context.worktreePath,
       ...options2.env ? { env: options2.env } : {},
       ...options2.extendEnv === false ? { extendEnv: false } : {},
       ...options2.input ? { input: options2.input } : {},
       ...options2.outputLimitBytes ? { maxBuffer: options2.outputLimitBytes } : {},
-      signal: context.signal,
       timeout: options2.timeout
     });
     const output = limitOutput([result.stdout, result.stderr].filter(Boolean).join(`
@@ -38642,7 +38888,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(),
@@ -29404,8 +29406,8 @@ async function runTests(worktreePath, signal) {
   }
   try {
     const result = await execa(projectCommand.command, projectCommand.args, {
+      cancelSignal: signal,
       cwd: worktreePath,
-      signal,
       shell: projectCommand.shell
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join(`
@@ -29429,8 +29431,8 @@ async function runTypecheck(worktreePath, signal) {
   }
   try {
     const result = await execa(projectCommand.command, projectCommand.args, {
+      cancelSignal: signal,
       cwd: worktreePath,
-      signal,
       shell: projectCommand.shell
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join(`
@@ -29462,8 +29464,8 @@ function parseJscpdOutput(output) {
 async function runJscpd(worktreePath, signal) {
   try {
     const result = await execa("bunx", ["jscpd", "--min-tokens", "50", "--reporters", "json", "."], {
-      cwd: worktreePath,
-      signal
+      cancelSignal: signal,
+      cwd: worktreePath
     });
     return parseJscpdOutput(result.stdout ?? "");
   } catch (err) {
@@ -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),
@@ -29774,9 +29774,9 @@ function renderArgv(args, prompt, cwd) {
 async function runLaunchPlan(plan, options = {}) {
   try {
     const result = await execa(plan.command, plan.args, {
+      cancelSignal: options.signal,
       cwd: plan.cwd,
       env: plan.env,
-      signal: options.signal,
       stdin: "ignore",
       timeout: plan.timeoutMs
     });
@@ -30680,12 +30680,12 @@ async function executeCommand(command, context, options = {}) {
   }
   try {
     const result = await execa(command[0], command.slice(1), {
+      cancelSignal: context.signal,
       cwd: context.worktreePath,
       ...options.env ? { env: options.env } : {},
       ...options.extendEnv === false ? { extendEnv: false } : {},
       ...options.input ? { input: options.input } : {},
       ...options.outputLimitBytes ? { maxBuffer: options.outputLimitBytes } : {},
-      signal: context.signal,
       timeout: options.timeout
     });
     const output = limitOutput([result.stdout, result.stderr].filter(Boolean).join(`

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),
@@ -7624,9 +7620,9 @@ function renderArgv(args, prompt, cwd) {
 async function runLaunchPlan(plan, options = {}) {
   try {
     const result = await execa(plan.command, plan.args, {
+      cancelSignal: options.signal,
       cwd: plan.cwd,
       env: plan.env,
-      signal: options.signal,
       stdin: "ignore",
       timeout: plan.timeoutMs
     });

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.0",
+  "version": "1.5.2",
   "description": "",
   "main": "index.js",
   "keywords": [],