@henryqw/pi-subagent 8.0.1 → 9.0.0

package/CONTEXT.md

@@ -2,7 +2,7 @@
 
 ## Purpose
 
-Provide validated built-in and user Roles, shared task-model Pi launch policy, generic managed Herdr Subagent hosting, generic `delegate_task` delegation, and package-owned `delegate_flow` Git orchestration. Main plans and orchestrates; `delegate_task` remains a flat bounded delegation tool, while Flow uses the effective Implementer and only invokes its effective Reviewer for explicit judgment criteria after authoritative validation. The bundled Main-side Skill adds no runtime behavior or changes generic fallback.
+Provide validated built-in and user Roles, shared task-model Pi launch policy, generic `delegate_task` delegation, and package-owned `delegate_flow` Git orchestration. Main plans and orchestrates; `delegate_task` remains a flat bounded delegation tool, while Flow uses the effective Implementer and only invokes its effective Reviewer for explicit judgment criteria after authoritative validation. The bundled Main-side Skill adds no runtime behavior or changes generic fallback.
 
 ## Domain glossary
 
@@ -20,12 +20,11 @@ Provide validated built-in and user Roles, shared task-model Pi launch policy, g
 - **Resource Policy**: Role ownership of base tools, extensions, and Skill names, plus explicit caller additions of tools, extensions, and environment through `createRoleLaunch`.
 - **Pi Launch**: reusable `{env,args}` policy for one Role, resolved model route, explicit caller resources, and project trust.
 - **Ephemeral Executor**: mechanism that receives a prepared Pi Launch, runs one bounded Delegated Task in one no-session child process, and returns its result without discovering resources or composing a Workflow.
-- **Managed Subagent**: Pi agent hosted in a reconciled Herdr tab or pane; lifecycle orchestration remains with the caller.
 
 ## Invariants
 
 - One Delegated Task creates one ephemeral child process and no saved session. Execution ends at the first hard budget: attempted turn 51 by default (`maxTurns`, positive safe integer) or `deadline = min(last recognized Pi JSON event + idle timeout, child start + maximum runtime)` (recognized Pi events renew; raw bytes do not; max always terminates). A terminal turn 50 succeeds; attempted continuation rejects with `turn_limit`, accumulated usage, and bounded output. On continuing `turn_end`, the existing child Role tool extension steers the fixed convergence warning once at 80% of completed turns and once at 80% of maximum runtime, combining thresholds first due together and never starting a warning timer or extra turn. After direct Pi exits, inherited stdout/stderr drain until EOF unless an escaped descendant holds them past short inactivity or a one-second hard deadline. Configurable in `~/.pi/agent/config/pi-subagent/pi-subagent.json` (`maxTurns` default 50; `timeout.idleMinutes`/`maxMinutes` defaults 10/30).
-- Up to five active ephemeral `delegate_task` children run per Main by default, configurable via `maxSubagents` in `~/.pi/agent/config/pi-subagent/pi-subagent.json` or the `PI_SUBAGENT_MAX_SUBAGENTS` environment variable; excess calls wait FIFO. Queued calls do not start a child or consume child timeout. Managed Herdr workers are unaffected.
+- Up to five active ephemeral `delegate_task` children run per Main by default, configurable via `maxSubagents` in `~/.pi/agent/config/pi-subagent/pi-subagent.json` or the `PI_SUBAGENT_MAX_SUBAGENTS` environment variable; excess calls wait FIFO. Queued calls do not start a child or consume child timeout.
 - Ambient child extensions and Skills stay disabled. Every Role requires `tools`, `extensions`, and `skills` YAML arrays, and every launch installs the Role tool policy. `tools: []` activates no base built-ins but does activate all tools from explicitly selected trusted extension bundles and explicit caller tool additions; `skills: []` selects no separately named Role Skills but trusted selected extension Skills still load; `extensions: []` selects no Role extension bundle. A Role/caller explicitly selected extension is a trusted atomic capability bundle: all tools it registers and all Skills supplied through its Pi package metadata or dynamic `resources_discover` load alongside separately named Role Skills. This intentionally includes the extension's executable lifecycle/prompt behavior; pi-subagent does not infer or externally narrow undocumented dependencies, and loading an extension is not sandboxing. Scope children by selecting fewer trusted extensions; finer granularity requires separate entry points/configuration or an upstream split. Explicit Role/caller tool names still verify against the final filtered registry, while parent-only recursive orchestration tools remain excluded.
 - Role Skill names resolve through Main's effective Pi Skill registry; unavailable names warn and skip without blocking delegation. Explicit Role/caller tool names verify against the final filtered child registry after explicit provider `session_start` handlers, and unavailable names fail before the first turn.
 - Main policy populates direct `model` and `thinking` only for explicit user overrides; otherwise it selects only `modelClass` (`fast` normally, `balanced` upfront for obvious complexity). This has no provenance tracking or runtime enforcement. An omitted class uses pi-subagent's local `pi-subagent/delegateTask` Model Task declaration (default `fast`); library callers select a Role plus their own Model Task declaration.
@@ -35,4 +34,3 @@ Provide validated built-in and user Roles, shared task-model Pi launch policy, g
 - Flow is memory-only. Only a post-rebase commit drop produces a no-op (`base === tip`); it validates, skips Reviewer and merge, then cleans up ordinarily. Initial zero-commit implementations block. Implementer, validation, or reviewer blocks allow one `delegate_flow_continue({ guidance, modelClass? })` repair in the same worktree; omission retains the Unit's current class and presence replaces it for that repair. A second block is terminal. Rebase and evidence/Reviewer/infrastructure failures retain worktrees. A reported fast-forward failure retains its worktree unless Main is clean at the exact integrated tip, which completes with the merge diagnostic as a warning. Cleanup uses non-forced worktree removal and branch deletion; cleanup refusal is a completion warning.
 - Flow has no graph, saved recovery, automatic retry, aggregate review, or post-merge validation. It never changes generic `delegate_task` Role resolution, isolation, non-Git fallback, or ordinary direct plan/file review.
 - Numbered Codex routes prefer Main's active account slot and explicitly load the multi-Codex child extension.
-- Generic Herdr host functions validate workspace ownership and provisioning identity while callers retain domain state, prompts, and lifecycle decisions.

package/README.md

@@ -252,7 +252,7 @@ Scope a child by selecting fewer trusted extensions. Finer-grained selection req
 
 ## Library API
 
-The package root exports Role loading and launch resolution, `createEphemeralSubagentExecutor`, worktree helpers, and generic managed Herdr lifecycle helpers.
+The package root exports Role loading and launch resolution, `createEphemeralSubagentExecutor`, and worktree helpers.
 
 The executor is for code already running inside active Pi. It does not provide standalone Node.js Pi discovery or launch support.
 

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type HerdrExecutor } from "@henryqw/pi-herdr";
 import { type AvailableModel, type ModelTask, type ProfileName, type ResolvedTaskRoute, type ThinkingLevel } from "@henryqw/pi-task-models";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, type EphemeralSubagentActivityEvent, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, worktreeContextNote, type WorktreeDirtyInspection, type WorktreeInfo, type WorktreePayload, } from "./worktree.ts";
@@ -60,40 +59,3 @@ export declare function resolveTaskRoute(ctx: ExtensionContext, profileName: Pro
 export declare function resolveRoleSkills(pi: Pick<ExtensionAPI, "getCommands">, role: Role): ResolvedRoleSkills;
 export declare function createRoleLaunch(pi: Pick<ExtensionAPI, "getCommands">, ctx: Pick<ExtensionContext, "isProjectTrusted">, input: CreateRoleLaunchInput): ResolvedRoleLaunch;
 export declare function resolveRoleLaunch(pi: Pick<ExtensionAPI, "getCommands">, ctx: ExtensionContext, input: ResolveRoleLaunchInput): ResolvedRoleLaunch;
-export interface ManagedSubagentHost {
-    cwd: string;
-    workspaceId: string;
-}
-export interface ManagedSubagentCommandOptions {
-    cwd: string;
-}
-export type ManagedSubagentExecutor = HerdrExecutor<ManagedSubagentCommandOptions>;
-export interface ManagedSubagentHostOptions {
-    execute: ManagedSubagentExecutor;
-    delay?: (milliseconds: number) => Promise<void>;
-}
-export interface ManagedSubagentTab {
-    tabId: string;
-    paneId: string;
-}
-export declare function managedSubagentName(workspaceId: string, ...identity: string[]): string;
-export declare function managedSubagentWorkspaceId(cwd: string, mainPane: string, options: ManagedSubagentHostOptions): Promise<string>;
-/** Returns pane ID to Herdr status for agents owned by this workspace. */
-export declare function listManagedSubagents(host: ManagedSubagentHost, options: ManagedSubagentHostOptions): Promise<Map<string, string>>;
-export declare function createManagedSubagentTab(host: ManagedSubagentHost, cwd: string, launch: PiLaunch, label: string, options: ManagedSubagentHostOptions): Promise<ManagedSubagentTab>;
-export declare function reconcileManagedSubagentTab(host: ManagedSubagentHost, input: {
-    tabId?: string;
-    paneId?: string;
-    cwd: string;
-    launch: PiLaunch;
-    label: string;
-}, options: ManagedSubagentHostOptions): Promise<ManagedSubagentTab>;
-export declare function findManagedSubagentTab(host: ManagedSubagentHost, label: string, options: ManagedSubagentHostOptions): Promise<ManagedSubagentTab | undefined>;
-export declare function managedSubagentTabExists(host: ManagedSubagentHost, tabId: string, options: ManagedSubagentHostOptions): Promise<boolean>;
-export declare function reconcileManagedSubagentPane(host: ManagedSubagentHost, tabId: string, rootPaneId: string, cwd: string, launch: PiLaunch, label: string, options: ManagedSubagentHostOptions): Promise<string>;
-export declare function startManagedSubagent(host: ManagedSubagentHost, agent: string, pane: string, launch: PiLaunch, options: ManagedSubagentHostOptions, hooks?: {
-    beforeStart?: () => Promise<void>;
-    onStarted?: () => Promise<void>;
-}): Promise<"existing" | "started">;
-export declare function promptManagedSubagent(host: ManagedSubagentHost, agent: string, prompt: string | Record<string, unknown>, options: ManagedSubagentHostOptions): Promise<void>;
-export declare function retireManagedSubagentTab(host: ManagedSubagentHost, tabId: string, options: ManagedSubagentHostOptions): Promise<void>;

package/dist/index.js

@@ -1,9 +1,7 @@
-import { createHash } from "node:crypto";
 import { readFileSync, readdirSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { createHerdrClient, herdrCommandFailure, hasHerdrErrorCode, startPiAgent } from "@henryqw/pi-herdr";
 import { modelReference, orderedProfileRoutes, readTaskModelsConfig, resolveConfiguredTaskRoute, resolveTaskModelRoute, } from "@henryqw/pi-task-models";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, } from "./ephemeral.js";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, worktreeContextNote, } from "./worktree.js";
@@ -197,231 +195,3 @@ export function resolveRoleLaunch(pi, ctx, input) {
         route: resolveConfiguredTaskRoute(ctx, input.task, input.agentDir),
     });
 }
-function launchEnvironmentArgs(launch) {
-    return Object.entries(launch.env).flatMap(([key, value]) => {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || typeof value !== "string" || value.includes("\0")) {
-            throw new Error(`Invalid launch environment: ${key}`);
-        }
-        return ["--env", `${key}=${value}`];
-    });
-}
-export function managedSubagentName(workspaceId, ...identity) {
-    const parts = [nonEmptyString(workspaceId, "Herdr workspace id"), ...identity.map((part, index) => nonEmptyString(part, `Subagent identity ${index}`))];
-    if (!identity.length)
-        throw new Error("Managed Subagent identity is required");
-    return `subagent-${createHash("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 23)}`;
-}
-export async function managedSubagentWorkspaceId(cwd, mainPane, options) {
-    const paneId = nonEmptyString(mainPane, "recorded main Herdr pane");
-    const pane = (await listPanes(cwd, options))
-        .map((entry, index) => object(entry, `Herdr pane ${index}`))
-        .find((entry) => entry.pane_id === paneId);
-    if (!pane)
-        throw new Error(`Recorded main Herdr pane is missing: ${paneId}`);
-    return nonEmptyString(pane.workspace_id, "recorded main Herdr workspace");
-}
-/** Returns pane ID to Herdr status for agents owned by this workspace. */
-export async function listManagedSubagents(host, options) {
-    const workspaceId = nonEmptyString(host.workspaceId, "recorded Herdr workspace");
-    const response = object(await createHerdrClient(options.execute).json(["agent", "list"], { cwd: host.cwd }), "Herdr agent list response");
-    const result = object(response.result, "Herdr agent list result");
-    return new Map(array(result.agents, "Herdr agents").flatMap((entry, index) => {
-        const agent = object(entry, `Herdr agent ${index}`);
-        if (nonEmptyString(agent.workspace_id, `Herdr agent ${index} workspace`) !== workspaceId)
-            return [];
-        return [[
-                nonEmptyString(agent.pane_id, `Herdr agent ${index} pane`),
-                nonEmptyString(agent.agent_status, `Herdr agent ${index} status`),
-            ]];
-    }));
-}
-export async function createManagedSubagentTab(host, cwd, launch, label, options) {
-    const response = await createHerdrClient(options.execute).json([
-        "tab", "create", "--workspace", nonEmptyString(host.workspaceId, "recorded Herdr workspace"), "--cwd", cwd,
-        ...launchEnvironmentArgs(launch), "--label", nonEmptyString(label, "Herdr tab label"), "--no-focus",
-    ], { cwd: host.cwd });
-    const result = object(object(response, "Herdr tab response").result, "Herdr tab result");
-    return {
-        tabId: nonEmptyString(object(result.tab, "Herdr tab").tab_id, "Herdr tab id"),
-        paneId: nonEmptyString(object(result.root_pane, "Herdr root pane").pane_id, "Herdr root pane id"),
-    };
-}
-export async function reconcileManagedSubagentTab(host, input, options) {
-    if (input.tabId && input.paneId && await managedSubagentTabExists(host, input.tabId, options)) {
-        return { tabId: input.tabId, paneId: input.paneId };
-    }
-    return await findManagedSubagentTab(host, input.label, options)
-        ?? await createManagedSubagentTab(host, input.cwd, input.launch, input.label, options);
-}
-export async function findManagedSubagentTab(host, label, options) {
-    const workspaceId = nonEmptyString(host.workspaceId, "recorded Herdr workspace");
-    const matches = (await listTabs(host.cwd, options))
-        .map((entry, index) => object(entry, `Herdr tab ${index}`))
-        .filter((tab, index) => nonEmptyString(tab.workspace_id, `Herdr tab ${index} workspace`) === workspaceId)
-        .filter((tab) => tab.label === label);
-    if (matches.length > 1)
-        throw new Error(`Multiple Herdr tabs match provisioning identity: ${label}`);
-    if (!matches.length)
-        return undefined;
-    const tabId = nonEmptyString(object(matches[0], "Herdr tab").tab_id, "Herdr tab id");
-    const panes = (await listPanes(host.cwd, options))
-        .filter((entry, index) => object(entry, `Herdr pane ${index}`).tab_id === tabId);
-    if (panes.length !== 1)
-        throw new Error(`Provisioned Herdr tab ${tabId} must contain exactly one root pane`);
-    return { tabId, paneId: nonEmptyString(object(panes[0], "Herdr pane").pane_id, "Herdr pane id") };
-}
-export async function managedSubagentTabExists(host, tabId, options) {
-    const expected = nonEmptyString(host.workspaceId, "recorded Herdr workspace");
-    const id = nonEmptyString(tabId, "Herdr tab id");
-    const tab = (await listTabs(host.cwd, options))
-        .map((entry, index) => object(entry, `Herdr tab ${index}`))
-        .find((entry) => entry.tab_id === id);
-    if (!tab)
-        return false;
-    const actual = nonEmptyString(tab.workspace_id, `Herdr tab ${id} workspace`);
-    if (actual !== expected)
-        throw new Error(`Herdr tab ${id} belongs to workspace ${actual}, expected initiating workspace ${expected}`);
-    return true;
-}
-export async function reconcileManagedSubagentPane(host, tabId, rootPaneId, cwd, launch, label, options) {
-    const tab = nonEmptyString(tabId, "Herdr tab id");
-    const workspace = nonEmptyString(host.workspaceId, "recorded Herdr workspace");
-    const ownerTab = (await listTabs(host.cwd, options))
-        .map((entry, index) => object(entry, `Herdr tab ${index}`))
-        .find((entry) => entry.tab_id === tab);
-    if (!ownerTab)
-        throw new Error(`Herdr tab is missing: ${tab}`);
-    const ownerWorkspace = nonEmptyString(ownerTab.workspace_id, `Herdr tab ${tab} workspace`);
-    if (ownerWorkspace !== workspace)
-        throw new Error(`Herdr tab ${tab} belongs to workspace ${ownerWorkspace}, expected initiating workspace ${workspace}`);
-    const root = nonEmptyString(rootPaneId, "Herdr root pane");
-    const panes = (await listPanes(host.cwd, options)).map((entry, index) => object(entry, `Herdr pane ${index}`));
-    const owner = panes.find((pane) => pane.pane_id === root);
-    if (!owner)
-        throw new Error(`Herdr root pane is missing: ${root}`);
-    if (owner.tab_id !== tab)
-        throw new Error(`Herdr root pane ${root} does not belong to tab ${tab}`);
-    const siblings = panes.filter((pane) => pane.tab_id === tab && pane.pane_id !== root);
-    const named = siblings.filter((pane) => pane.label === label);
-    if (named.length > 1)
-        throw new Error(`Multiple Herdr panes match provisioning identity: ${label}`);
-    if (named.length)
-        return nonEmptyString(named[0].pane_id, "Herdr Subagent pane id");
-    if (siblings.length > 1)
-        throw new Error(`Provisioned Herdr tab ${tab} has multiple Subagent panes`);
-    if (siblings.length)
-        return nonEmptyString(siblings[0].pane_id, "Herdr Subagent pane id");
-    const herdr = createHerdrClient(options.execute);
-    const response = await herdr.json([
-        "pane", "split", "--pane", root, "--direction", "right", "--cwd", cwd,
-        ...launchEnvironmentArgs(launch), "--no-focus",
-    ], { cwd: host.cwd });
-    const result = object(object(response, "Herdr pane response").result, "Herdr pane result");
-    const pane = nonEmptyString(object(result.pane, "Herdr Subagent pane").pane_id, "Herdr Subagent pane id");
-    await herdr.run(["pane", "rename", pane, nonEmptyString(label, "Herdr pane label")], { cwd: host.cwd });
-    return pane;
-}
-export async function startManagedSubagent(host, agent, pane, launch, options, hooks = {}) {
-    assertAgentName(agent);
-    const name = nonEmptyString(agent, "Herdr agent name");
-    const paneId = nonEmptyString(pane, "Herdr agent pane");
-    const existing = await getManagedSubagent(host, name, options);
-    if (existing) {
-        assertAgentPane(name, paneId, existing);
-        return "existing";
-    }
-    await hooks.beforeStart?.();
-    const herdr = createHerdrClient(options.execute);
-    const startArgs = ["agent", "start", name, "--kind", "pi", "--pane", paneId, "--", ...launch.args];
-    const result = await startPiAgent(herdr, {
-        name,
-        pane: paneId,
-        args: launch.args,
-        options: { cwd: host.cwd },
-        delay: options.delay,
-    });
-    if (result.code === 0 && !result.killed) {
-        await hooks.onStarted?.();
-        return "started";
-    }
-    if (hasHerdrErrorCode(result, "agent_name_taken")) {
-        const raced = await getManagedSubagent(host, name, options);
-        if (!raced)
-            throw new Error(`Herdr agent ${name} reported agent_name_taken but could not be found; refusing to start a duplicate`);
-        assertAgentPane(name, paneId, raced);
-        return "existing";
-    }
-    throw new Error(herdrCommandFailure(startArgs, result));
-}
-export async function promptManagedSubagent(host, agent, prompt, options) {
-    assertAgentName(agent);
-    const text = typeof prompt === "string" ? nonEmptyString(prompt, "Subagent prompt") : JSON.stringify(prompt);
-    await createHerdrClient(options.execute).run(["agent", "prompt", agent, text], { cwd: host.cwd });
-}
-export async function retireManagedSubagentTab(host, tabId, options) {
-    const id = nonEmptyString(tabId, "Herdr tab id");
-    try {
-        if (!(await managedSubagentTabExists(host, id, options)))
-            return;
-        await createHerdrClient(options.execute).run(["tab", "close", id], { cwd: host.cwd });
-    }
-    catch (error) {
-        if (!(await confirmsTabAbsent(host, id, options)))
-            throw error;
-    }
-}
-function assertAgentName(agent) {
-    if (!/^[a-z][a-z0-9_-]{0,31}$/.test(agent))
-        throw new Error(`Invalid Herdr agent name: ${agent}`);
-}
-function object(value, label) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error(`${label} must be an object`);
-    return value;
-}
-function array(value, label) {
-    if (!Array.isArray(value))
-        throw new Error(`${label} must be an array`);
-    return value;
-}
-function nonEmptyString(value, label) {
-    if (typeof value !== "string")
-        throw new Error(`${label} must be a string`);
-    if (!value.trim() || value.includes("\0"))
-        throw new Error(`${label} must not be empty`);
-    return value;
-}
-async function listTabs(cwd, options) {
-    const response = await createHerdrClient(options.execute).json(["tab", "list"], { cwd });
-    return array(object(object(response, "Herdr tab list response").result, "Herdr tab list result").tabs, "Herdr tabs");
-}
-async function listPanes(cwd, options) {
-    const response = await createHerdrClient(options.execute).json(["pane", "list"], { cwd });
-    return array(object(object(response, "Herdr pane list response").result, "Herdr pane list result").panes, "Herdr panes");
-}
-async function getManagedSubagent(host, name, options) {
-    const arguments_ = ["agent", "get", name];
-    const result = await createHerdrClient(options.execute).exec(arguments_, { cwd: host.cwd });
-    if (result.code !== 0 || result.killed) {
-        if (hasHerdrErrorCode(result, "agent_not_found"))
-            return undefined;
-        throw new Error(herdrCommandFailure(arguments_, result));
-    }
-    const response = object(JSON.parse(result.stdout), "Herdr agent get response");
-    return object(object(response.result, "Herdr agent get result").agent, `Herdr agent ${name}`);
-}
-function assertAgentPane(name, expected, agent) {
-    const actual = typeof agent.pane_id === "string" ? agent.pane_id : "missing";
-    if (actual !== expected) {
-        throw new Error(`Herdr agent name collision for ${name}: expected pane ${expected}, found ${actual}; refusing to reuse or replace it`);
-    }
-}
-async function confirmsTabAbsent(host, tabId, options) {
-    try {
-        const result = await createHerdrClient(options.execute).exec(["tab", "get", tabId], { cwd: host.cwd });
-        return !result.killed && result.code !== 0 && hasHerdrErrorCode(result, "tab_not_found");
-    }
-    catch {
-        return false;
-    }
-}

package/docs/orchestration.md

@@ -262,8 +262,6 @@ Activity text is limited to 4 KiB per field. An invalid `toolCallId` or `toolNam
 
 The low-level executor does not interpret `Role.isolation`, discover resources, compose modes, create shared state, or promote child failure outcomes to tool errors. A direct caller that wants worktrees must call `createChildWorktree` after the permit, choose the returned `cwd`, call `finalizeChildWorktree` on every exit path, and preserve its recovery payload.
 
-Generic managed Herdr exports (`managedSubagentWorkspaceId`, reconciliation helpers, `startManagedSubagent`, prompting/listing, and retirement) consume the same launch policy for durable workers. They intentionally contain no workflow prompts, semantic state, or retry policy.
-
 ## JavaScript composition
 
 The examples below use caller-selected `Role` objects and the `runRole` function returned by the package's initializer. A consuming Pi extension calls the initializer once at startup:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "Delegate bounded single, parallel, or chained tasks to isolated Pi roles.",
   "keywords": [
     "pi-package",
@@ -64,7 +64,6 @@
     ]
   },
   "dependencies": {
-    "@henryqw/pi-herdr": "^0.4.0",
     "@henryqw/pi-multi-codex": "^0.3.8",
     "@henryqw/pi-task-models": "^3.0.0"
   }