dsh-pstack 0.1.0 → 0.2.0-beta.1

package/dist/subagent.mjs

@@ -1,436 +1,1402 @@
-import { n as SKILLS_ROOT, t as AGENTS_ROOT } from "./paths-Bbai4CaT.mjs";
-import { readFile } from "node:fs/promises";
-import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
-import { defineTool } from "@deepseek-ai/dsh-tools";
-import { homedir } from "node:os";
+import { i as POTETO_MODE_SKILL_PATH, o as agentPreamblePath, t as ASSETS_ROOT } from "./paths-D_JlVmBk.mjs";
+import { c as parseFrontmatter } from "./frontmatter-BQX3ekwP.mjs";
 import { join } from "node:path";
-//#region src/roles.ts
-const INHERIT = /* @__PURE__ */ new Set([
-	"inherit-parent",
-	"auto",
-	"parent"
-]);
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region scripts/role-manifest.ts
+/** File name the role policy lives under inside `$DSH_HOME`. */
+const PSTACK_MODELS_FILENAME = "pstack-models.md";
+/** Values that resolve to "send no `agentOptions` and inherit the parent route". */
+const INHERIT_PARENT_ALIASES = ["inherit-parent", "auto"];
+const ROLE_MANIFEST = [
+	{
+		key: "feature, refactoring",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["poteto-mode/playbooks/feature.md", "poteto-mode/playbooks/refactoring.md"],
+		summary: "One route for both code playbooks. The comma joins two playbook names into a single key."
+	},
+	{
+		key: "bug-fix",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["poteto-mode/playbooks/bug-fix.md"],
+		summary: "Implementation route for the bug-fix playbook."
+	},
+	{
+		key: "perf-issue",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["poteto-mode/playbooks/perf-issue.md"],
+		summary: "Implementation route for the perf-issue playbook."
+	},
+	{
+		key: "hillclimb",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["poteto-mode/playbooks/hillclimb.md"],
+		summary: "Implementation route for the hillclimb playbook."
+	},
+	{
+		key: "judgment and prose",
+		shape: "single",
+		autoPanel: false,
+		consumers: [
+			"poteto-mode/SKILL.md",
+			"unslop",
+			"technical-writing"
+		],
+		summary: "Route for prose work and vague-instruction judgment calls."
+	},
+	{
+		key: "hardest tasks",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["poteto-mode/SKILL.md"],
+		summary: "Route for the strongest judgment model on cross-cutting or subtle work."
+	},
+	{
+		key: "how explorer",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["how/SKILL.md", "how/references/explorer-prompt.md"],
+		summary: "Route for each how explorer child."
+	},
+	{
+		key: "how explainer",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["how/SKILL.md", "how/references/explainer-prompt.md"],
+		summary: "Route for the single how explainer child."
+	},
+	{
+		key: "why investigators",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["why/SKILL.md", "why/references/investigator-prompt.md"],
+		summary: "Route for each why investigator child."
+	},
+	{
+		key: "why synthesizer",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["why/SKILL.md", "why/references/synthesizer-prompt.md"],
+		summary: "Route for the why synthesis child."
+	},
+	{
+		key: "reflect tooling",
+		shape: "single",
+		autoPanel: false,
+		consumers: ["reflect/SKILL.md", "reflect/references/tooling-reviewer.md"],
+		summary: "Route for the reflect tooling reviewer."
+	},
+	{
+		key: "reflect judgment, divergent, synthesizer",
+		shape: "single",
+		autoPanel: false,
+		consumers: [
+			"reflect/SKILL.md",
+			"reflect/references/judgment-reviewer.md",
+			"reflect/references/divergent-reviewer.md",
+			"reflect/references/synthesizer.md"
+		],
+		summary: "One shared route for the judgment reviewer, the divergent reviewer, and the synthesizer. The commas belong to the key."
+	},
+	{
+		key: "arena runners",
+		shape: "list",
+		autoPanel: true,
+		consumers: ["arena/SKILL.md"],
+		summary: "Panel: one arena child per entry, all started together."
+	},
+	{
+		key: "arena cross-judge pool",
+		shape: "list",
+		autoPanel: false,
+		consumers: ["arena/SKILL.md"],
+		summary: "A pool arena picks one entry from, preferring a model family unlike the parent's. Not fanned out automatically."
+	},
+	{
+		key: "swarm workers",
+		shape: "list",
+		autoPanel: false,
+		consumers: ["swarm/SKILL.md", "poteto-mode/playbooks/multi-phase-plan.md"],
+		summary: "One default route for every worker. A race gives each arm another entry through `roleIndex`, and the caller still starts one worker per call."
+	},
+	{
+		key: "architect runners",
+		shape: "list",
+		autoPanel: true,
+		consumers: ["architect/SKILL.md"],
+		summary: "Panel: one architect child per entry, all started together."
+	},
+	{
+		key: "interrogate reviewers",
+		shape: "list",
+		autoPanel: true,
+		consumers: ["interrogate/SKILL.md"],
+		summary: "Panel: one interrogate reviewer per entry, all started together."
+	}
+];
+ROLE_MANIFEST.map((role) => role.key);
+ROLE_MANIFEST.filter((role) => role.autoPanel).map((role) => role.key);
+/** Exact manifest lookup. Callers normalize the key first. */
+function findRoleSpec(key) {
+	return ROLE_MANIFEST.find((role) => role.key === key);
+}
+//#endregion
+//#region src/effort.ts
+/** Model-facing name of the child's own control. */
+const SET_EFFORT_TOOL = "set_reasoning_effort";
 /**
-* Reasoning efforts DSH understands, widest first. A token outside this set is
-* reported rather than dropped: a route that silently loses `xhigh` looks
-* configured and is not.
+* Resolve the route a child's effort will actually apply to.
+*
+* The session's latest request header is the live route after a model switch, and
+* `Agent.options` is the creation-time fallback. DSH's own delegation code resolves
+* `inherit-parent` the same way, so reading `options` alone would validate a
+* different model than the child really inherits.
+*
+* An explicit route wins over both, because it is what the delegation will request.
 */
-const REASONING_EFFORTS = [
-	"max",
-	"xhigh",
-	"high",
-	"medium",
-	"low",
-	"off"
-];
-const EFFORTS = new Set(REASONING_EFFORTS);
+function resolveEffortTarget(agent, route) {
+	const explicit = route?.kind === "route" ? route : void 0;
+	const header = agent?.session.requestHeader()?.config;
+	const provider = explicit?.provider ?? header?.provider ?? agent?.options.provider;
+	const model = explicit?.model ?? header?.model ?? agent?.options.model;
+	return provider !== void 0 && model !== void 0 ? {
+		provider,
+		model
+	} : void 0;
+}
+/** The efforts one route advertises, in the adapter's own order. */
+async function advertisedEfforts(llm, target, signal) {
+	return (await llm.resolveModelInfo(target.provider, target.model, signal)).reasoning?.efforts.map((entry) => entry.id) ?? [];
+}
 /**
-* Register the role names on one line.
+* Validate one effort against the route a child will actually request.
 *
-* The whole left side is always stored as one key, so
-* `reflect judgment, divergent, synthesizer` stays addressable as written.
-* When the comma list is a genuine group (`feature, refactoring`), each part is
-* stored too, so a caller can name just one of them. Both spellings therefore
-* work, and neither can shadow the other: the full key is a different string.
+* Rejects with the target's real effort list rather than a generic message, because
+* "max is not supported" leaves the caller guessing while "supports xhigh, high,
+* medium" is actionable. A model that advertises no efforts at all is reported
+* separately: that is a route incapable of the control, not a wrong token.
 */
-function splitRoles(left) {
-	const whole = left.trim().toLowerCase().replace(/\s+/g, " ");
-	if (!whole) return [];
-	const parts = left.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
-	return parts.length > 1 ? [whole, ...parts] : [whole];
-}
-function parseModelConfigWithIssues(source) {
-	const table = /* @__PURE__ */ new Map();
-	const issues = [];
-	const lines = source.replace(/\r\n/g, "\n").split("\n");
-	for (const [index, rawLine] of lines.entries()) {
-		const line = rawLine.trim();
-		if (!line || line.startsWith("#") || line.startsWith("//")) continue;
-		const lineNumber = index + 1;
-		const separator = line.indexOf(":");
-		if (separator === -1) {
-			issues.push({
-				line: lineNumber,
-				message: `expected "role: value", got ${JSON.stringify(line)}`
-			});
-			continue;
-		}
-		const roles = splitRoles(line.slice(0, separator));
-		if (roles.length === 0) {
-			issues.push({
-				line: lineNumber,
-				message: "no role name before the colon"
-			});
-			continue;
-		}
-		const values = [];
-		for (const entry of line.slice(separator + 1).split(",")) {
-			const parsed = parseValue(entry.trim(), lineNumber, issues);
-			if (parsed !== void 0) values.push(parsed);
-		}
-		if (values.length === 0) {
-			issues.push({
-				line: lineNumber,
-				message: `no usable value for ${roles.join(", ")}`
-			});
-			continue;
-		}
-		for (const role of roles) table.set(role, values);
+async function validateEffortFor(llm, route, effort, parent, signal) {
+	const target = resolveEffortTarget(parent, route);
+	if (target === void 0) throw new Error("cannot resolve the child provider/model route for reasoningEffort. Pass `role` with an exact route, or run the delegation from a session that has already made a request.");
+	let efforts;
+	try {
+		efforts = await advertisedEfforts(llm, target, signal);
+	} catch (error) {
+		throw new Error(`route ${target.provider}/${target.model} could not be resolved for reasoningEffort: ${describeError$2(error)}`, { cause: error });
 	}
-	return {
-		table,
-		issues
+	if (efforts.length === 0) throw new Error(`${target.provider}/${target.model} advertises no reasoning efforts, so it cannot take reasoningEffort "${effort}". Omit the argument and let the adapter use its own default.`);
+	if (!efforts.includes(effort)) throw new Error(`${target.provider}/${target.model} does not support reasoning effort "${effort}". It supports: ${efforts.join(", ")}.`);
+}
+/**
+* Install the effort control on one live child.
+*
+* Registration is child-scoped, so the waterfall and the tool dispose with the
+* child: a sibling delegation never sees them, and a later child cannot inherit a
+* stale value.
+*
+* The waterfall re-states the starting effort on every request and applies a
+* change from the next request onward. It never rewrites a request already in
+* flight, because `next()` has already been called and its result is the request
+* the machine built.
+*
+* A missing route is not fatal here. The child still runs on whatever the adapter
+* chose; the tool reports the missing route when the child tries to change effort.
+*
+* @param child - the live child agent, already started.
+* @param llm - the adapter host used to validate a requested change.
+* @param initialEffort - the effort the delegation started the child at, if any.
+* @returns a disposer that unwinds this contribution early, or does nothing when
+* the child context is already gone.
+*/
+function installEffortControl(child, llm, initialEffort) {
+	let current = initialEffort;
+	const disposeListener = child.ctx.on("agent/request", async (_payload, next) => {
+		const config = await next();
+		return current === void 0 ? config : {
+			...config,
+			reasoningEffort: current
+		};
+	});
+	const disposeTool = child.ctx.tools.register(defineSetEffortTool(child, llm, (effort) => {
+		current = effort;
+	}));
+	return () => {
+		disposeTool();
+		disposeListener();
 	};
 }
-function parseValue(value, line = 0, issues = []) {
-	if (!value) return void 0;
-	if (INHERIT.has(value.toLowerCase())) return "inherit-parent";
-	const [route, ...rest] = value.split(/\s+/).filter(Boolean);
-	if (!route) return void 0;
-	const slash = route.indexOf("/");
-	if (slash <= 0 || slash === route.length - 1) {
-		issues.push({
-			line,
-			message: `"${route}" is not <provider>/<model>, so this role inherits the parent route`
-		});
-		return "inherit-parent";
-	}
-	let reasoningEffort;
-	for (const token of rest) {
-		if (EFFORTS.has(token.toLowerCase())) {
-			reasoningEffort = token.toLowerCase();
-			continue;
-		}
-		issues.push({
-			line,
-			message: `unknown effort "${token}"; expected one of ${REASONING_EFFORTS.join(", ")}`
-		});
-	}
+/** The child's own view of its effort, for the tool body. */
+function defineSetEffortTool(child, llm, apply) {
 	return {
-		provider: route.slice(0, slash),
-		model: route.slice(slash + 1),
-		...reasoningEffort ? { reasoningEffort } : {}
+		name: SET_EFFORT_TOOL,
+		description: [
+			"Change your reasoning effort for future model requests.",
+			"Use it when the task turns out harder or more routine than the role line assumed: raise it for subtle design, concurrency, or algorithm work, lower it once the remaining work is mechanical.",
+			"The change applies from your next step; a request already in flight is unaffected, and it lasts for the rest of this child's life.",
+			"This tool may not be visible until your second step. The effort you were started with applies to the first step, so a slow first step is expected when that level is high."
+		].join(" "),
+		parameters: { effort: {
+			type: "string",
+			description: "The reasoning effort to use from your next step onward. Use one of the values this model advertises; the call rejects an unknown one and lists the real values."
+		} },
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: String(value)
+			}]
+		},
+		isConcurrencySafe: () => false,
+		async execute(rawArgs, exec) {
+			const args = rawArgs;
+			const value = typeof args.effort === "string" ? args.effort.trim() : "";
+			if (value === "") throw new Error("set_reasoning_effort needs a non-empty `effort`. Pass the exact token this model advertises; an empty value would silently re-enable the adapter default.");
+			const target = resolveEffortTarget(exec.agent ?? child);
+			if (target === void 0) throw new Error("this child has no resolved provider/model route, so reasoning effort cannot be validated against the live adapter metadata");
+			let efforts;
+			try {
+				efforts = await advertisedEfforts(llm, target, exec.signal);
+			} catch (error) {
+				throw new Error(`${target.provider}/${target.model} could not be resolved for reasoning effort: ${describeError$2(error)}`, { cause: error });
+			}
+			if (efforts.length === 0) throw new Error(`${target.provider}/${target.model} advertises no reasoning efforts, so this child has none to change. Your current effort stays as it is.`);
+			if (!efforts.includes(value)) throw new Error(`${target.provider}/${target.model} does not support reasoning effort "${value}", so nothing changed. It supports: ${efforts.join(", ")}.`);
+			apply(value);
+			return `reasoning effort set to "${value}". It applies from your next step; the request already in flight is unaffected.`;
+		}
 	};
 }
 /**
-* Look a role up by name.
+* The `agentOptions` one (route, effort override) pair contributes.
 *
-* The parser stores both the whole left side of a line and, when the comma list
-* is a genuine group, each part. So a direct map hit is the only match worth
-* making. Matching is exact on purpose: a near miss such as `how` against
-* `how explorer` must not resolve, because picking a route the user did not name
-* changes both cost and model without saying so. `findNearMisses` reports those
-* for a human instead.
+* The two independent halves are easy to get wrong in opposite directions:
+*
+* - an inherit-parent route with an override must still send `reasoningEffort`,
+*   which means `{ reasoningEffort }` on its own is a real `agentOptions` value and
+*   the backend still has to support the capability;
+* - an override always wins over the role line, because the caller asked for this
+*   delegation specifically.
 */
-function lookupRole(table, role) {
-	if (!role) return void 0;
-	const key = role.trim().toLowerCase().replace(/\s+/g, " ");
-	if (!key) return void 0;
-	const values = table.get(key);
-	if (!values) return void 0;
+function agentOptionsFor(route, effortOverride) {
+	const effort = effortOverride ?? (route.kind === "route" ? route.effort : void 0);
+	if (route.kind === "inherit") return effort === void 0 ? void 0 : { reasoningEffort: effort };
 	return {
-		key,
-		values,
-		fromList: key.includes(",")
+		provider: route.provider,
+		model: route.model,
+		...effort === void 0 ? {} : { reasoningEffort: effort }
 	};
 }
+/** The effort a plan entry will actually run at, override included. */
+function effectiveEffort(route, effortOverride) {
+	return effortOverride ?? (route.kind === "route" ? route.effort : void 0);
+}
+function describeError$2(error) {
+	if (error instanceof Error) {
+		const code = error.code;
+		return typeof code === "string" ? `${error.message} (${code})` : error.message;
+	}
+	return String(error);
+}
+//#endregion
+//#region src/roles.ts
 /**
-* Configured role names a caller could have meant. Used to explain a miss, not
-* to resolve one: `how` is a near miss for `how explorer`, and quietly running
-* on the explorer route would look configured while being wrong.
+* Role lookup over the single manifest in `scripts/role-manifest.ts`.
+*
+* A role name is matched exactly after normalization. A near miss is reported as
+* a hint and never guessed, because silently running a role on the wrong route is
+* worse than refusing the delegation.
+*
+* Commas belong to some keys (`feature, refactoring`), so nothing here splits a
+* key on a comma. Only a role file *value* is a comma-separated list.
 */
-function findNearMisses(table, role) {
-	const key = role.trim().toLowerCase().replace(/\s+/g, " ");
-	if (!key) return [];
-	const hits = [];
-	for (const candidate of table.keys()) {
-		if (candidate === key) continue;
-		if (candidate.includes(key) || key.includes(candidate)) {
-			hits.push(candidate);
-			continue;
-		}
-		for (const part of candidate.split(",").map((item) => item.trim())) {
-			if (part === key) continue;
-			if (part.includes(key) || key.includes(part)) {
-				hits.push(candidate);
-				break;
-			}
-		}
+/** Raised when a role name does not match the manifest. */
+var RoleNameError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RoleNameError";
 	}
-	return [...new Set(hits)];
+};
+/**
+* Normalize a role name for lookup.
+*
+* Case, surrounding whitespace, runs of whitespace, spacing around a comma, and a
+* trailing colon are formatting, not naming. Nothing else is normalized: a
+* different word is a different role.
+*/
+function normalizeRoleName(raw) {
+	return raw.normalize("NFC").trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").replace(/:+$/, "").trim();
+}
+/** Look a role up by its exact normalized key. */
+function lookupRole(raw) {
+	return findRoleSpec(normalizeRoleName(raw));
 }
 /**
-* Resolve one role to a route.
+* Near-miss hints for a role name that did not match.
 *
-* `index` selects a panel entry and wraps, so a caller that spawns more
-* children than the list has entries still gets a deterministic route. A
-* missing role or an `inherit-parent` entry both return `undefined`, which
-* tells the caller to omit `agentOptions` and inherit.
+* Only used to build a diagnostic. A suggestion is never turned into a selection.
 */
-function resolveRole(table, role, index = 0) {
-	const values = lookupRole(table, role)?.values;
-	if (!values || values.length === 0) return void 0;
-	const value = values[Math.abs(index) % values.length];
-	return value && value !== "inherit-parent" ? value : void 0;
+function suggestRoles(raw, limit = 3) {
+	const target = normalizeRoleName(raw);
+	if (target === "") return [];
+	return ROLE_MANIFEST.map((role) => {
+		const shared = sharedTokenCount(target, role.key);
+		const distance = editDistance(target, role.key);
+		const contains = role.key.includes(target) || target.includes(role.key);
+		const score = (contains ? 1e3 : 0) + shared * 100 - distance + Math.min(role.key.length, target.length);
+		return {
+			key: role.key,
+			score,
+			distance,
+			shared,
+			contains
+		};
+	}).filter((candidate) => candidate.contains || candidate.shared > 0 || candidate.distance <= 4).sort((left, right) => right.score - left.score).slice(0, limit).map((candidate) => candidate.key);
 }
-//#endregion
-//#region src/models.ts
 /**
-* Read `~/.dsh/pstack-models.md`, the role file `/setup-pstack` writes.
+* Resolve a role name, or throw a diagnostic that names the near misses.
 */
-function dshHome() {
-	return process.env.DSH_HOME || join(homedir(), ".dsh");
+function requireRole(raw) {
+	const spec = lookupRole(raw);
+	if (spec !== void 0) return spec;
+	const suggestions = suggestRoles(raw);
+	const hint = suggestions.length === 0 ? "No role key is close to it." : `Closest role keys: ${suggestions.map((key) => `"${key}"`).join(", ")}.`;
+	throw new RoleNameError(`unknown pstack role ${JSON.stringify(raw)}. ${hint} Role names come from the role manifest, not from free text: pass the exact key, or omit \`role\` to inherit the parent route.`);
+}
+function sharedTokenCount(left, right) {
+	const rightTokens = new Set(tokenize(right));
+	return [...new Set(tokenize(left))].filter((token) => rightTokens.has(token)).length;
+}
+function tokenize(value) {
+	return value.split(/[^a-z0-9]+/).filter((token) => token !== "");
 }
-function modelConfigPath() {
-	return join(dshHome(), "pstack-models.md");
+/** Levenshtein distance, iterative with one row of state. */
+function editDistance(left, right) {
+	if (left === right) return 0;
+	if (left === "") return right.length;
+	if (right === "") return left.length;
+	let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let row = 1; row <= left.length; row += 1) {
+		const current = [row];
+		for (let column = 1; column <= right.length; column += 1) {
+			const substitution = previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1);
+			const deletion = previous[column] + 1;
+			const insertion = current[column - 1] + 1;
+			current.push(Math.min(substitution, deletion, insertion));
+		}
+		previous = current;
+	}
+	return previous[right.length];
 }
+//#endregion
+//#region src/models.ts
 /**
-* Read the role file.
+* The pstack role file: `$DSH_HOME/pstack-models.md`.
 *
-* A missing file is normal and means every role inherits the parent route. A
-* malformed line degrades only that line, and the issues travel with the table
-* so the tool can name them in its reply. A read failure keeps that distinction
-* explicit instead of collapsing into an empty table.
+* `pstack_subagent` reads this file again on every delegation, so a change reaches
+* the next child and never a child that already started.
+*
+* Three states are kept apart on purpose, because they need different fixes:
+*
+* - the file does not exist: no policy is configured, so every role inherits the
+*   parent route;
+* - the file exists but cannot be read: a broken installation or permission
+*   problem, reported as an error and never treated as "no configuration";
+* - the file loads but a line is wrong: a typo in a key, an unknown retired role,
+*   or a malformed value is reported with the line number and the near misses.
+*/
+/** Absolute path of the role file for one DSH home. */
+function modelsFilePath(dshHome) {
+	return join(dshHome, PSTACK_MODELS_FILENAME);
+}
+/**
+* Resolve `$DSH_HOME` the way the Host does: the environment when set, else
+* `~/.dsh`.
 */
-async function loadRoleTable() {
+function resolveDshHome(env = process.env, home = homedir()) {
+	const configured = env["DSH_HOME"];
+	if (configured !== void 0 && configured.trim() !== "") return configured;
+	return join(home, ".dsh");
+}
+/** Read the role file. Never throws for a missing or unreadable file. */
+function readRoleFile(path) {
+	let text;
 	try {
-		const { table, issues } = parseModelConfigWithIssues(await readFile(modelConfigPath(), "utf8"));
-		return {
-			table,
-			issues,
-			unreadable: false
-		};
+		text = readFileSync(path, "utf8");
 	} catch (error) {
-		if (error.code === "ENOENT") return {
-			table: /* @__PURE__ */ new Map(),
-			issues: [],
-			unreadable: false
+		if (isMissingFile(error)) return {
+			status: "missing",
+			path
 		};
 		return {
-			table: /* @__PURE__ */ new Map(),
-			issues: [{
-				line: 0,
-				message: `could not read ${modelConfigPath()}: ${error.message}`
-			}],
-			unreadable: true
+			status: "unreadable",
+			path,
+			reason: describeError$1(error)
+		};
+	}
+	return parseRoleFile(text, path);
+}
+/** Parse role-file text. Pure: no file system access. */
+function parseRoleFile(text, path) {
+	const issues = [];
+	const roles = /* @__PURE__ */ new Map();
+	const lines = stripFrontmatter(text).split("\n");
+	let budget;
+	lines.forEach((rawLine, index) => {
+		const line = index + 1;
+		const trimmed = rawLine.trim();
+		if (trimmed === "") return;
+		if (trimmed.startsWith("#")) {
+			const match = /^#\s*budget:\s*(.+)$/i.exec(trimmed);
+			if (match !== null) budget = match[1].trim();
+			return;
+		}
+		const separator = trimmed.indexOf(":");
+		if (separator === -1) {
+			issues.push({
+				line,
+				message: `expected \`<role>: <value>\`, found ${JSON.stringify(trimmed)}`
+			});
+			return;
+		}
+		const rawKey = trimmed.slice(0, separator).trim();
+		const rawValue = trimmed.slice(separator + 1).trim();
+		const key = normalizeRoleName(rawKey);
+		if (key === "") {
+			issues.push({
+				line,
+				message: "the role key is empty"
+			});
+			return;
+		}
+		const spec = findSpec(key);
+		if (spec === void 0) {
+			issues.push({
+				line,
+				message: unknownRoleMessage(rawKey, key)
+			});
+			return;
+		}
+		const parsed = parseRouteValue(rawValue);
+		for (const issue of parsed.issues) issues.push({
+			line,
+			message: `${rawKey}: ${issue}`
+		});
+		if (parsed.routes.length === 0) return;
+		const previous = roles.get(spec.key);
+		if (previous !== void 0) issues.push({
+			line,
+			message: `role "${spec.key}" is already configured on line ${previous.line}; line ${line} wins`
+		});
+		roles.set(spec.key, {
+			line,
+			rawKey,
+			key: spec.key,
+			spec,
+			rawValue,
+			routes: parsed.routes
+		});
+	});
+	return budget === void 0 ? {
+		status: "loaded",
+		path,
+		roles,
+		issues
+	} : {
+		status: "loaded",
+		path,
+		budget,
+		roles,
+		issues
+	};
+}
+/** Parse a role value: one route, or a comma-separated list of routes. */
+function parseRouteValue(raw) {
+	const routes = [];
+	const issues = [];
+	const segments = raw.split(",");
+	segments.forEach((segment, index) => {
+		const trimmed = segment.trim();
+		if (trimmed === "") {
+			if (index !== segments.length - 1) issues.push(`entry ${index + 1} of the list is empty`);
+			return;
+		}
+		const parsed = parseRoute(trimmed);
+		if (parsed.route === void 0) {
+			issues.push(parsed.issue);
+			return;
+		}
+		routes.push(parsed.route);
+	});
+	if (routes.length === 0 && issues.length === 0) issues.push("the value is empty; use `inherit-parent`, `auto`, or `<provider>/<model> [effort]`");
+	return {
+		routes,
+		issues
+	};
+}
+/** Parse one entry of a role value. */
+function parseRoute(raw) {
+	const value = raw.trim();
+	if (value === "") return { issue: "the value is empty" };
+	if (INHERIT_PARENT_ALIASES.includes(value.toLowerCase())) return { route: { kind: "inherit" } };
+	const match = /^([^\s/,[]+)\/([^\s/,[\]]+(?:\/[^\s/,[\]]+)*)(?:\s+\[([^[\]]*)\])?$/.exec(value);
+	if (match === null) return { issue: `${JSON.stringify(value)} is not a route; use \`inherit-parent\`, \`auto\`, or \`<provider>/<model> [effort]\`` };
+	const provider = match[1];
+	const model = match[2];
+	const effort = match[3];
+	if (effort === void 0) return { route: {
+		kind: "route",
+		provider,
+		model
+	} };
+	const trimmedEffort = effort.trim();
+	if (trimmedEffort === "") return { issue: `${JSON.stringify(value)} has empty brackets; write \`<provider>/<model> [effort]\` or drop the brackets` };
+	if (/\s/.test(trimmedEffort)) return { issue: `${JSON.stringify(value)} has a multi-word effort; an effort is one adapter-owned token` };
+	return { route: {
+		kind: "route",
+		provider,
+		model,
+		effort: trimmedEffort
+	} };
+}
+/** Raised when a role's configured list cannot be selected from. */
+var RouteSelectionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RouteSelectionError";
+	}
+};
+/**
+* Expand one role into the routes this call starts.
+*
+* The three auto-panel roles start one child per entry. Another list role selects
+* one entry, the first by default, and `roleIndex` chooses which. A single role
+* holds exactly one route and rejects `roleIndex`.
+*/
+function selectRoleRoutes(spec, entry, roleIndex) {
+	if (spec.shape === "single" && roleIndex !== void 0) throw new RouteSelectionError(`role "${spec.key}" holds a single route, so \`roleIndex\` does not apply; drop \`roleIndex\` or use a list-valued role (${listRoleKeys().join(", ")})`);
+	if (spec.autoPanel && roleIndex !== void 0) throw new RouteSelectionError(`role "${spec.key}" is an automatic panel: it starts one child per entry, so \`roleIndex\` does not apply; configure the entries you want in ${PSTACK_MODELS_FILENAME}`);
+	if (entry === void 0) return {
+		role: spec,
+		mode: spec.autoPanel ? "panel" : "single",
+		configured: false,
+		routes: [{ kind: "inherit" }],
+		total: 1,
+		issues: []
+	};
+	if (spec.autoPanel) return {
+		role: spec,
+		mode: "panel",
+		configured: true,
+		routes: entry.routes,
+		total: entry.routes.length,
+		issues: []
+	};
+	if (spec.shape === "list") {
+		const index = roleIndex ?? 0;
+		if (index >= entry.routes.length) throw new RouteSelectionError(`role "${spec.key}" has ${entry.routes.length} entr${entry.routes.length === 1 ? "y" : "ies"}, so \`roleIndex\` ${index} is out of range; valid indexes are ${entry.routes.map((_route, position) => position).join(", ")}`);
+		return {
+			role: spec,
+			mode: "selected",
+			configured: true,
+			routes: [entry.routes[index]],
+			total: entry.routes.length,
+			roleIndex: index,
+			issues: []
 		};
 	}
+	return {
+		role: spec,
+		mode: "single",
+		configured: true,
+		routes: [entry.routes[0]],
+		total: entry.routes.length,
+		issues: []
+	};
+}
+/** Keys of the list-valued roles, including the automatic panels. */
+function listRoleKeys() {
+	return ROLE_MANIFEST.filter((role) => role.shape === "list").map((role) => role.key);
+}
+function findSpec(key) {
+	return ROLE_MANIFEST.find((role) => role.key === key);
+}
+function unknownRoleMessage(rawKey, key) {
+	const suggestions = suggestRoles(key);
+	const hint = suggestions.length === 0 ? "no role key is close to it" : `closest role keys: ${suggestions.map((candidate) => `"${candidate}"`).join(", ")}`;
+	return `unknown role ${JSON.stringify(rawKey)} (${hint}). A line for a retired or misspelled role would otherwise be ignored, so it is reported instead.`;
+}
+function stripFrontmatter(text) {
+	const normalized = text.replaceAll("\r\n", "\n");
+	if (!normalized.startsWith("---\n")) return normalized;
+	const end = normalized.indexOf("\n---", 3);
+	if (end === -1) return normalized;
+	const after = normalized.indexOf("\n", end + 1);
+	return after === -1 ? "" : normalized.slice(after + 1);
+}
+function isMissingFile(error) {
+	return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function describeError$1(error) {
+	if (error instanceof Error) {
+		const code = error.code;
+		return typeof code === "string" ? `${code}: ${error.message}` : error.message;
+	}
+	return String(error);
 }
 //#endregion
 //#region src/subagent.ts
 /**
-* `pstack_subagent`: pstack's delegation surface for DSH.
+* `pstack_subagent`: pstack's delegation entry point.
 *
-* Cursor's `Task` tool gives every spawn a `subagent_type`, a model slug, and
-* background execution. DSH splits those across `ctx.subagents` (background
-* activations), the agent preset system (composition), and the LLM adapter
-* routes (model choice). This tool joins them back into one call whose shape a
-* ported pstack skill can use unchanged.
+* One call plans one or more fresh children, validates everything before the first
+* start, then starts them through `ctx.subagents.startActivation` with parent
+* delivery. Results arrive as completion notices; this module never polls.
+*
+* Validation order follows the design's delegation flow, and every check that can
+* reject a call happens before the first child starts, except a start failure in
+* the middle of a panel, which keeps the children already running and names them.
 */
+/** Cordis row name, used by Loader diagnostics. */
 const name = "pstack-subagent";
-const inject = ["tools", "subagents"];
+/**
+* Delegation needs the tool registry, the subagent registry, and the LLM adapters.
+*
+* `agents` is deliberately **not** here. It is used only to reach a child this tool
+* has just started, and a composition without it still delegates: the children keep
+* the effort their request carried and cannot change it afterwards. Declaring it as
+* a hard dependency would make the whole row inert in such a profile, so the tool
+* would not exist at all — the failure `pstack-history` already paid for once with
+* `sessionQuery`. It is read per call through `ctx.get("agents")` instead, which is
+* why a controller mounted after this row is still seen.
+*/
+const inject = [
+	"tools",
+	"subagents",
+	"llm"
+];
+/** Model-facing tool name. */
+const TOOL_NAME = "pstack_subagent";
+/** Backend used when the row does not name one. */
+const DEFAULT_SUBAGENT_PROVIDER = "spawn";
+/** Agent type used when the call does not name one. */
+const DEFAULT_AGENT_KIND = "poteto-agent";
+/** The child kinds this tool knows how to brief. */
 const AGENT_KINDS = [
 	"poteto-agent",
 	"comment-sicko",
 	"general"
 ];
-const POTETO_AGENT_PATH = `${AGENTS_ROOT}poteto-agent.md`;
-const COMMENT_SICKO_PATH = `${AGENTS_ROOT}comment-sicko.md`;
-const POTETO_MODE_PATH = `${SKILLS_ROOT}poteto-mode/SKILL.md`;
-function stripFrontmatter(source) {
-	if (!source.startsWith("---")) return source;
-	const end = source.indexOf("\n---", 3);
-	return end === -1 ? source : source.slice(end + 4).replace(/^\n+/, "");
-}
-async function readAgentInstructions(kind) {
-	if (kind === "general") return "";
-	const path = kind === "poteto-agent" ? POTETO_AGENT_PATH : COMMENT_SICKO_PATH;
+const DEFAULT_CONFIG = {
+	provider: DEFAULT_SUBAGENT_PROVIDER,
+	allowedModels: [],
+	allowedAgentPresets: []
+};
+/** Raised for a configuration or argument problem, before any child starts. */
+var DelegationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DelegationError";
+	}
+};
+/** Raised when a child starts but a later entry in the same call fails. */
+var PartialDelegationError = class extends DelegationError {
+	startedChildren;
+	constructor(message, startedChildren) {
+		super(message);
+		this.name = "PartialDelegationError";
+		this.startedChildren = startedChildren;
+	}
+};
+/** Raised when a required agent preamble is missing or unusable. */
+var PreambleError = class extends DelegationError {
+	constructor(message) {
+		super(message);
+		this.name = "PreambleError";
+	}
+};
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+function isNonNegativeSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+/**
+* Minimal Standard Schema for this row, so an omitted `config` is valid and a
+* typo fails at load instead of at the first delegation.
+*/
+const Config = { "~standard": {
+	version: 1,
+	vendor: "dsh-pstack",
+	validate(value) {
+		if (value === void 0 || value === null) return { value: DEFAULT_CONFIG };
+		if (typeof value !== "object" || Array.isArray(value)) return { issues: [{ message: "config must be a mapping" }] };
+		const record = value;
+		const issues = [];
+		const allowedKeys = /* @__PURE__ */ new Set([
+			"provider",
+			"maxDepth",
+			"allowedModels",
+			"allowedAgentPresets"
+		]);
+		for (const key of Object.keys(record)) if (!allowedKeys.has(key)) issues.push({
+			message: `unknown field "${key}"`,
+			path: [key]
+		});
+		const provider = record["provider"];
+		if (provider !== void 0 && !isNonEmptyString(provider)) issues.push({
+			message: "provider must be a non-empty string",
+			path: ["provider"]
+		});
+		const maxDepth = record["maxDepth"];
+		if (maxDepth !== void 0 && !isNonNegativeSafeInteger(maxDepth)) issues.push({
+			message: "maxDepth must be a non-negative safe integer",
+			path: ["maxDepth"]
+		});
+		const allowedModels = record["allowedModels"];
+		const models = [];
+		if (allowedModels !== void 0) {
+			if (!Array.isArray(allowedModels)) issues.push({
+				message: "allowedModels must be an array",
+				path: ["allowedModels"]
+			});
+			else allowedModels.forEach((entry, index) => {
+				if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+					issues.push({
+						message: "each allowedModels entry must be a { provider, model } object",
+						path: ["allowedModels", index]
+					});
+					return;
+				}
+				const route = entry;
+				const routeProvider = route["provider"];
+				const routeModel = route["model"];
+				if (!isNonEmptyString(routeProvider) || !isNonEmptyString(routeModel)) {
+					issues.push({
+						message: "each allowedModels entry needs a non-empty provider and model",
+						path: ["allowedModels", index]
+					});
+					return;
+				}
+				if (models.some((known) => known.provider === routeProvider && known.model === routeModel)) {
+					issues.push({
+						message: `duplicate allowedModels route "${routeProvider}/${routeModel}"`,
+						path: ["allowedModels", index]
+					});
+					return;
+				}
+				models.push({
+					provider: routeProvider,
+					model: routeModel
+				});
+			});
+		}
+		const allowedPresets = record["allowedAgentPresets"];
+		const presets = [];
+		if (allowedPresets !== void 0) {
+			if (!Array.isArray(allowedPresets)) issues.push({
+				message: "allowedAgentPresets must be an array",
+				path: ["allowedAgentPresets"]
+			});
+			else allowedPresets.forEach((entry, index) => {
+				if (!isNonEmptyString(entry)) {
+					issues.push({
+						message: "each allowedAgentPresets entry must be a non-empty string",
+						path: ["allowedAgentPresets", index]
+					});
+					return;
+				}
+				if (presets.includes(entry)) {
+					issues.push({
+						message: `duplicate allowedAgentPresets entry "${entry}"`,
+						path: ["allowedAgentPresets", index]
+					});
+					return;
+				}
+				presets.push(entry);
+			});
+		}
+		if (issues.length > 0) return { issues };
+		return { value: {
+			provider: isNonEmptyString(provider) ? provider : DEFAULT_SUBAGENT_PROVIDER,
+			...isNonNegativeSafeInteger(maxDepth) ? { maxDepth } : {},
+			allowedModels: models,
+			allowedAgentPresets: presets
+		} };
+	}
+} };
+/**
+* Read one agent preamble from the package assets by absolute path.
+*
+* A missing or empty preamble blocks that agent type. It never degrades into a
+* plain child, because a `comment-sicko` or `poteto-agent` child without its
+* instructions is a different agent wearing the name.
+*/
+function loadAgentPreamble(agent, assetsRoot) {
+	if (agentPreamblePath(agent) === void 0) return void 0;
+	const absolute = join(assetsRoot, "agents", `${agent}.md`);
+	let text;
 	try {
-		return stripFrontmatter(await readFile(path, "utf8"));
-	} catch {
-		return "";
+		text = readFileSync(absolute, "utf8");
+	} catch (error) {
+		const code = error.code;
+		throw new PreambleError(`the ${agent} preamble cannot be read at ${absolute} (${typeof code === "string" ? code : String(error)}). This agent type does not start without its preamble; reinstall dsh-pstack so the packaged assets are present, or pass agent: "general" for a plain child that gets no preamble.`);
 	}
+	const body = parseFrontmatter(text).body.trim();
+	if (body === "") throw new PreambleError(`the ${agent} preamble at ${absolute} is empty. This agent type does not start without its instructions; repair the packaged asset or pass agent: "general".`);
+	return body;
+}
+/**
+* Compose the self-contained prompt one child receives.
+*
+* The preambles used to locate things themselves; the Host injects the absolute
+* paths instead, so a child never scans a plugin directory or guesses a version.
+*/
+function composeChildPrompt(input) {
+	const sections = [];
+	if (input.preamble !== void 0) sections.push(input.preamble);
+	const injected = input.injectedPaths ?? [];
+	if (injected.length > 0) sections.push([
+		"Absolute paths injected by `pstack_subagent`. Read them directly; do not search a plugin directory.",
+		"",
+		...injected.map((entry) => `- ${entry.label}: \`${entry.path}\``)
+	].join("\n"));
+	if (sections.length === 0) return input.task;
+	sections.push(`Task:\n\n${input.task}`);
+	return sections.join("\n\n---\n\n");
+}
+/** The text form of one route, as reported back to the model. */
+function routeLabel(route) {
+	if (route.kind === "inherit") return "inherit-parent";
+	return route.effort === void 0 ? `${route.provider}/${route.model}` : `${route.provider}/${route.model} [${route.effort}]`;
 }
 /**
-* Build the child prompt. A pstack delegate must read `poteto-mode` first, and
-* the parent normally passes its absolute path. When the parent omits it, this
-* fallback keeps the delegate from drifting into general-purpose style.
+* The route text a caller sees when an effort override wins.
+*
+* `routeLabel` describes the role file, which stops being the whole truth once the
+* caller overrode the effort. Reporting the file's value there would tell the model
+* its override had been ignored.
+*/
+function plannedRouteLabel(route, effortOverride) {
+	const effort = effectiveEffort(route, effortOverride);
+	const base = route.kind === "inherit" ? "inherit-parent" : `${route.provider}/${route.model}`;
+	return effort === void 0 ? base : `${base} [${effort}]`;
+}
+/**
+* Take the smallest of the requested depth, this row's cap, and the Host setting.
+*
+* A request above the row cap is an error rather than a silent clamp, so a caller
+* cannot believe it asked for two levels when the row allows one.
 */
-function composePrompt(input) {
-	if (input.kind === "general") return input.prompt;
-	const path = input.potetoModePath ?? POTETO_MODE_PATH;
-	return [
-		input.agentInstructions.trim(),
-		`Parent task label: ${input.description}`,
-		`Read \`${path}\` in full before any work, including its inline Principles index. Navigate to a leaf \`principle-*\` skill whenever you apply that principle.`,
-		input.prompt.trim()
-	].filter(Boolean).join("\n\n");
+function resolveDelegationDepth(configured, requested, hostLimit) {
+	if (requested !== void 0 && !isNonNegativeSafeInteger(requested)) throw new DelegationError("maxDepth must be a non-negative safe integer");
+	if (configured !== void 0 && requested !== void 0 && requested > configured) throw new DelegationError(`maxDepth ${requested} exceeds this row's configured cap of ${configured}. Lower the request or raise \`pstack-subagent\` config.maxDepth; this tool never forwards a depth above its own row.`);
+	const candidates = [
+		configured,
+		requested,
+		hostLimit
+	].filter((value) => value !== void 0);
+	return candidates.length === 0 ? void 0 : Math.min(...candidates);
 }
 /**
-* Resolve the `role` argument against the shipped role table, explaining a miss
-* instead of swallowing it.
+* Validate the model-facing arguments.
 *
-* A missing file is normal. A configured-but-unmatched role is not: it means a
-* skill and `~/.dsh/pstack-models.md` disagree, and the child would silently run
-* on the parent route. The tool reply says so, so the parent can fix the file or
-* report the miss rather than believing the route applied.
+* The tool schema is advisory at the model boundary, so every constraint is
+* re-checked here and reported with the reason.
 */
-async function resolveRoleArg(role) {
-	if (!role) return {
-		route: void 0,
-		notes: []
+function parseDelegationArgs(raw, config = DEFAULT_CONFIG) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new DelegationError("arguments must be an object");
+	const record = raw;
+	const known = /* @__PURE__ */ new Set([
+		"description",
+		"prompt",
+		"agent",
+		"role",
+		"cwd",
+		...config.allowedAgentPresets.length > 0 ? ["agentPreset"] : [],
+		"maxDepth",
+		"roleIndex",
+		"reasoningEffort"
+	]);
+	for (const key of Object.keys(record)) if (!known.has(key)) throw new DelegationError(`unknown argument "${key}": ${key === "agentPreset" ? "agentPreset is only available when this row configures allowedAgentPresets" : `accepted arguments are ${[...known].join(", ")}`}`);
+	const description = record["description"];
+	if (!isNonEmptyString(description)) throw new DelegationError("description must be a non-empty string: it becomes the child label");
+	const prompt = record["prompt"];
+	if (!isNonEmptyString(prompt)) throw new DelegationError("prompt must be a non-empty string");
+	const agentRaw = record["agent"];
+	if (agentRaw !== void 0 && typeof agentRaw !== "string") throw new DelegationError(`agent must be a string: ${AGENT_KINDS.join(", ")}`);
+	const agent = agentRaw ?? "poteto-agent";
+	if (!AGENT_KINDS.includes(agent)) throw new DelegationError(`unknown agent "${agent}". Accepted kinds are ${AGENT_KINDS.join(", ")}; a pstack agent type is not a DSH agent preset, so \`agent\` never accepts a preset id.`);
+	const role = record["role"];
+	if (role !== void 0 && !isNonEmptyString(role)) throw new DelegationError("role must be a non-empty string when present");
+	const cwd = record["cwd"];
+	if (cwd !== void 0 && !isNonEmptyString(cwd)) throw new DelegationError("cwd must be a non-empty string when present");
+	const agentPreset = record["agentPreset"];
+	if (agentPreset !== void 0) {
+		if (config.allowedAgentPresets.length === 0) throw new DelegationError("agentPreset is not available: this pstack-subagent row configures no allowedAgentPresets");
+		if (!isNonEmptyString(agentPreset) || !config.allowedAgentPresets.includes(agentPreset)) throw new DelegationError(`agentPreset ${JSON.stringify(agentPreset)} is not in this row's allowlist (${config.allowedAgentPresets.join(", ")})`);
+	}
+	const maxDepth = record["maxDepth"];
+	if (maxDepth !== void 0 && !isNonNegativeSafeInteger(maxDepth)) throw new DelegationError("maxDepth must be a non-negative safe integer");
+	const roleIndex = record["roleIndex"];
+	if (roleIndex !== void 0) {
+		if (!isNonNegativeSafeInteger(roleIndex)) throw new DelegationError("roleIndex must be a non-negative safe integer");
+		if (role === void 0) throw new DelegationError("roleIndex requires role: it selects one entry of a list-valued role, and without a role there is no list");
+	}
+	const requestedEffort = record["reasoningEffort"];
+	if (requestedEffort !== void 0 && !isNonEmptyString(requestedEffort)) throw new DelegationError("reasoningEffort must be a non-empty string when present. It is one adapter-owned token, validated against the model this call will actually request; an empty value would silently re-enable the adapter default.");
+	if (typeof requestedEffort === "string" && /\s/.test(requestedEffort.trim())) throw new DelegationError(`reasoningEffort ${JSON.stringify(requestedEffort)} contains whitespace. An effort is one token, exactly as the model advertises it.`);
+	return {
+		description,
+		prompt,
+		agent,
+		...role === void 0 ? {} : { role },
+		...cwd === void 0 ? {} : { cwd },
+		...agentPreset === void 0 ? {} : { agentPreset },
+		...maxDepth === void 0 ? {} : { maxDepth },
+		...roleIndex === void 0 ? {} : { roleIndex },
+		...requestedEffort === void 0 ? {} : { reasoningEffort: requestedEffort.trim() }
 	};
-	const { table, issues, unreadable } = await loadRoleTable();
-	if (lookupRole(table, role)) {
-		const notes = [];
-		for (const issue of issues) if (issue.line === 0) notes.push(issue.message);
+}
+/**
+* Resolve the role file, the routes, the prompt, and the depth into one plan.
+*
+* Pure with respect to the Host: it reads the role file and the packaged preamble,
+* and it makes no service call.
+*/
+function planDelegation(args, runtime, config = DEFAULT_CONFIG) {
+	const preamble = loadAgentPreamble(args.agent, runtime.assetsRoot);
+	const rolePath = modelsFilePath(runtime.dshHome);
+	const roleFile = readRoleFile(rolePath);
+	if (roleFile.status === "unreadable") throw new DelegationError(`the pstack role file at ${rolePath} exists but cannot be read (${roleFile.reason}). This is a broken configuration, not "no configuration": fix its permissions or delete the file, which makes every role inherit the parent route.`);
+	const diagnostics = [];
+	if (roleFile.status === "loaded") for (const issue of roleFile.issues) diagnostics.push(`${rolePath}${issue.line === void 0 ? "" : `:${issue.line}`}: ${issue.message}`);
+	let selection;
+	let roleSpec;
+	if (args.role !== void 0) {
+		roleSpec = requireRole(args.role);
+		const entry = roleFile.status === "loaded" ? roleFile.roles.get(roleSpec.key) : void 0;
+		selection = selectRoleRoutes(roleSpec, entry, args.roleIndex);
+	}
+	const routes = selection?.routes ?? [{ kind: "inherit" }];
+	const roleName = roleSpec?.key ?? "(none)";
+	if (selection !== void 0) {
+		if (!selection.configured) diagnostics.push(`role "${selection.role.key}" has no line in ${rolePath}, so it inherits the parent route. Add a line to route it explicitly.`);
+		if (selection.mode === "selected") diagnostics.push(`role "${selection.role.key}" holds ${selection.total} entries and is not an automatic panel; entry ${(selection.roleIndex ?? 0) + 1} was selected. Pass \`roleIndex\` to choose another.`);
+		if (selection.role.key === "swarm workers") diagnostics.push("role \"swarm workers\" is a list, not a panel: its first entry is the default route for every worker, and `roleIndex` gives one race arm another entry. Each worker still needs its own pstack_subagent call, because this tool cannot compare separate calls.");
+	}
+	assertAllowedModels(routes, config, roleName);
+	const injected = args.agent === "poteto-agent" ? [{
+		label: "`poteto-mode` SKILL.md",
+		path: POTETO_MODE_SKILL_PATH
+	}] : [];
+	const prompt = composeChildPrompt({
+		...preamble === void 0 ? {} : { preamble },
+		injectedPaths: injected,
+		task: args.prompt
+	});
+	const depth = resolveDelegationDepth(config.maxDepth, args.maxDepth, void 0);
+	const total = routes.length;
+	const children = routes.map((route, index) => {
+		const agentOptions = agentOptionsFor(route, args.reasoningEffort);
+		const effort = effectiveEffort(route, args.reasoningEffort);
 		return {
-			route: resolveRole(table, role),
-			notes
+			index,
+			total,
+			label: total > 1 ? `${args.description} [${roleName} ${index + 1}/${total}]` : args.description,
+			agent: args.agent,
+			role: roleName,
+			route,
+			routeLabel: plannedRouteLabel(route, args.reasoningEffort),
+			...effort === void 0 ? {} : { effort },
+			...agentOptions === void 0 ? {} : { agentOptions },
+			...args.agentPreset === void 0 ? {} : { agentPreset: args.agentPreset },
+			...args.cwd === void 0 ? {} : { cwd: args.cwd },
+			...depth === void 0 ? {} : { maxDepth: depth }
 		};
+	});
+	if (args.reasoningEffort !== void 0) {
+		const overwritten = routes.filter((route) => route.kind === "route" && route.effort !== void 0 && route.effort !== args.reasoningEffort);
+		if (overwritten.length > 0) diagnostics.push(`reasoningEffort "${args.reasoningEffort}" overrides the effort this call's role line names (${overwritten.map((route) => routeLabel(route)).join(", ")}). The role line is a starting baseline, so this is allowed; pass no reasoningEffort to keep it.`);
 	}
-	const near = findNearMisses(table, role);
-	const lines = [];
-	if (unreadable) lines.push(`pstack: ${modelConfigPath()} could not be read; the child inherits the parent route.`);
-	else if (table.size === 0) lines.push(`pstack: no role table at ${modelConfigPath()}; the child inherits the parent route. Run /setup-pstack to configure roles.`);
-	else {
-		lines.push(`pstack: role "${role}" is not in ${modelConfigPath()}; the child inherits the parent route.`);
-		if (near.length > 0) lines.push(`pstack: did you mean ${near.map((n) => `"${n}"`).join(" or ")}?`);
-	}
+	addPanelDiagnostics(children, roleName, selection, rolePath, diagnostics);
 	return {
-		route: void 0,
-		notes: lines
+		agent: args.agent,
+		prompt,
+		provider: config.provider,
+		role: roleName,
+		mode: selection?.mode ?? "single",
+		...selection?.roleIndex === void 0 ? {} : { roleIndex: selection.roleIndex },
+		roleTotal: selection?.total ?? 1,
+		...args.reasoningEffort === void 0 ? {} : { reasoningEffort: args.reasoningEffort },
+		children,
+		diagnostics
 	};
 }
+function assertAllowedModels(routes, config, roleName) {
+	if (config.allowedModels.length === 0) return;
+	const unauthorized = routes.filter((route) => route.kind === "route" && !config.allowedModels.some((allowed) => allowed.provider === route.provider && allowed.model === route.model));
+	if (unauthorized.length === 0) return;
+	const allowed = config.allowedModels.map((route) => `${route.provider}/${route.model}`).join(", ");
+	throw new DelegationError(`role ${roleName} resolves to ${unauthorized.map(routeLabel).join(", ")}, which this row's allowedModels does not authorize. Authorized routes: ${allowed}. This is pstack's own row limit and is unrelated to the native session allowedModels policy.`);
+}
+function addPanelDiagnostics(children, roleName, selection, rolePath, diagnostics) {
+	if (selection === void 0 || selection.mode !== "panel") return;
+	if (children.length === 1) {
+		diagnostics.push(`panel "${roleName}" has one configured entry, so this call started one child and claims no model diversity. Add entries to ${rolePath} for a real panel.`);
+		return;
+	}
+	const distinct = new Set(children.map((child) => child.routeLabel));
+	if (distinct.size > 1) return;
+	diagnostics.push(`all ${children.length} entries of panel "${roleName}" resolve to the same route (${[...distinct][0]}), so these children are not a cross-model review. Configure distinct routes in ${rolePath} for a real panel.`);
+}
+/**
+* Validate every route, and every requested effort, before anything starts.
+*
+* `resolveCallConfig` rejects an unsupported effort and any route the owning
+* adapter does not serve. An inherit-parent entry has no provider/model of its own,
+* so its effort is validated against the parent's live route instead. This does not
+* prove credentials, quota, or a successful model call; only a real child request
+* does.
+*
+* Every entry is checked before the first child starts. A panel whose second entry
+* cannot take the effort therefore starts none of them, which is the only outcome
+* that leaves no half-applied override behind.
+*/
+async function preflightRoutes(llm, parent, children, roleName, effortOverride, signal) {
+	for (const child of children) {
+		if (child.agentOptions === void 0) continue;
+		if (child.route.kind === "inherit") {
+			const effort = effortOverride;
+			try {
+				await validateEffortFor(llm, void 0, effort, parent, signal);
+			} catch (error) {
+				throw new DelegationError(`role ${roleName} inherits the parent route, and reasoningEffort "${effort}" failed preflight there: ${describeError(error)} Omit \`reasoningEffort\`, or name a role whose line holds an exact route.`);
+			}
+			continue;
+		}
+		const route = child.route;
+		const callConfig = {
+			provider: route.provider,
+			model: route.model,
+			...child.effort === void 0 ? {} : { reasoningEffort: child.effort }
+		};
+		try {
+			await llm.resolveCallConfig(callConfig, signal);
+		} catch (error) {
+			throw new DelegationError(`role ${roleName} resolves to ${child.routeLabel}, which failed route preflight: ${describeError(error)}. ${await effortHint(llm, route, child.effort, signal)}`);
+		}
+	}
+}
+async function effortHint(llm, route, effort, signal) {
+	if (effort !== void 0) try {
+		const efforts = (await llm.resolveModelInfo(route.provider, route.model, signal)).reasoning?.efforts.map((entry) => entry.id) ?? [];
+		if (efforts.length > 0) return `Model ${route.provider}/${route.model} supports these efforts: ${efforts.join(", ")}.`;
+		return `Model ${route.provider}/${route.model} advertises no reasoning efforts.`;
+	} catch {
+		return `Fix the route or the effort in ${PSTACK_MODELS_FILENAME}; the configured provider/model pair may not be served by this deployment.`;
+	}
+	return `Check the route in ${PSTACK_MODELS_FILENAME} against the providers this deployment registers.`;
+}
+/** Check the backend can enforce what this call asks for. */
+function assertProviderCapabilities(capabilities, providerName, asks) {
+	const missing = [];
+	if (asks.agentOptions && !capabilities.agentOptions) missing.push("agentOptions");
+	if (asks.agentPreset && !capabilities.agentPreset) missing.push("agentPreset");
+	if (asks.maxDepth && !capabilities.depthLimit) missing.push("maxDepth");
+	if (missing.length === 0) return;
+	throw new DelegationError(`subagent provider "${providerName}" does not support ${missing.join(", ")}, so this call cannot be honored. Change the route to \`inherit-parent\`, drop the unsupported argument, or configure a backend that supports it; this tool never silently ignores it.`);
+}
 /**
-* Turn a resolved role into the `agentOptions` a child activation carries.
+* Start the planned children.
 *
-* This is the only place a `Route` becomes a provider request. Keeping it a
-* pure function lets a test assert the exact options without starting a child,
-* which is where a role-to-route bug would otherwise stay invisible until a
-* live delegation picked the wrong model.
+* Everything that can be rejected has already been rejected. A failure at entry N
+* keeps children 1..N-1 running and reports their ids, because the runtime owns
+* those activations and this tool cannot roll them back.
 */
-function routeToAgentOptions(route) {
-	if (!route) return void 0;
+async function startPlannedChildren(parent, plan, runtime, config, signal) {
+	const provider = runtime.subagents.getProvider(plan.provider);
+	if (provider === void 0) {
+		const available = runtime.subagents.list();
+		throw new DelegationError(`subagent provider "${plan.provider}" is not registered; registered providers: ${available.length === 0 ? "(none)" : available.join(", ")}. This pstack-subagent row delegates to "${plan.provider}"; compose that backend or change the row's provider.`);
+	}
+	const hostLimit = runtime.subagents.resolveMaxDepth(config.maxDepth);
+	const effectiveDepth = resolveDelegationDepth(config.maxDepth, plan.children[0]?.maxDepth, hostLimit);
+	assertProviderCapabilities(provider.capabilities, plan.provider, {
+		agentOptions: plan.children.some((child) => child.agentOptions !== void 0),
+		agentPreset: plan.children.some((child) => child.agentPreset !== void 0),
+		maxDepth: effectiveDepth !== void 0
+	});
+	const children = plan.children.map((child) => ({
+		...child,
+		...effectiveDepth === void 0 ? {} : { maxDepth: effectiveDepth }
+	}));
+	await preflightRoutes(runtime.llm, parent, children, plan.role, plan.reasoningEffort, signal);
+	if (runtime.subagents.getProvider(plan.provider) !== provider) throw new DelegationError(`subagent provider "${plan.provider}" changed while the child routes were being resolved; retry the delegation`);
+	const started = [];
+	const diagnostics = [...plan.diagnostics];
+	for (const child of children) {
+		signal.throwIfAborted();
+		try {
+			const activation = await runtime.subagents.startActivation({
+				provider: plan.provider,
+				label: child.label,
+				request: {
+					prompt: [{
+						type: "text",
+						text: plan.prompt
+					}],
+					parent,
+					...child.cwd === void 0 ? {} : { cwd: child.cwd },
+					...child.agentPreset === void 0 ? {} : { agentPreset: child.agentPreset },
+					...child.agentOptions === void 0 ? {} : { agentOptions: child.agentOptions },
+					...child.maxDepth === void 0 ? {} : { maxDepth: child.maxDepth }
+				},
+				signal,
+				delivery: "parent"
+			});
+			const target = runtime.agents === void 0 ? void 0 : runtime.agents.get(activation.childId);
+			if (target === void 0) diagnostics.push(`child ${activation.childId} has no live local Agent handle, so it cannot change its own reasoning effort with \`${SET_EFFORT_TOOL}\`. It runs at ${child.effort === void 0 ? "the adapter default" : `"${child.effort}"`} for its whole life.`);
+			else installEffortControl(target, runtime.llm, child.effort);
+			started.push({
+				childId: activation.childId,
+				label: child.label,
+				agent: child.agent,
+				role: child.role,
+				route: child.routeLabel,
+				...child.effort === void 0 ? {} : { effort: child.effort },
+				...child.maxDepth === void 0 ? {} : { maxDepth: child.maxDepth }
+			});
+		} catch (error) {
+			if (started.length === 0) throw new DelegationError(`starting the ${plan.role === "(none)" ? "child" : `"${plan.role}" child`} "${child.label}" (${child.routeLabel}) failed: ${describeError(error)}`);
+			throw new PartialDelegationError(`starting entry ${child.index + 1} of ${child.total} for role "${plan.role}" (${child.label}, ${child.routeLabel}) failed: ${describeError(error)}. The ${started.length} already started: ${started.map((record) => `${record.childId} (${record.label})`).join(", ")}. Those children are still running and are not rolled back; do not start them again, and use list_agents or send_message to reach them.`, started);
+		}
+	}
 	return {
-		provider: route.provider,
-		model: route.model,
-		...route.reasoningEffort ? { reasoningEffort: ReasoningEffortId(route.reasoningEffort) } : {}
+		kind: started.length === 1 ? "activation" : "activations",
+		children: started,
+		diagnostics
 	};
 }
-/** Tool definition over injected dependencies; `apply` supplies the runtime. */
-function createPstackTool(deps) {
-	return defineTool({
-		name: deps.toolName ?? "pstack_subagent",
-		description: "Delegate a self-contained task to a pstack subagent. Use `agent: \"poteto-agent\"` for code-writing delegates and helper tasks spawned inside a /poteto-mode playbook step. Use `agent: \"general\"` for workflow reviewers such as how, why, arena, swarm, interrogate, and reflect. Use `agent: \"comment-sicko\"` only through /no-comments. Pass `role` to select the route configured in ~/.dsh/pstack-models.md; omit it to inherit the parent route. The call returns the child id immediately and the runtime reports the final answer in a completion notice.",
-		parameters: {
-			description: {
-				type: "string",
-				description: "A short (3-5 word) description of the delegated task, for display.",
-				required: true
-			},
-			prompt: {
-				type: "string",
-				description: "The complete, self-contained task for the subagent. It does not share this conversation, so include context, file pointers, constraints, and the check that proves the work.",
-				required: true
-			},
-			agent: {
-				type: "string",
-				enum: AGENT_KINDS,
-				description: "poteto-agent (default) for pstack delegates; general for workflow reviewers; comment-sicko for comment review."
-			},
-			role: {
-				type: "string",
-				description: "Role line in ~/.dsh/pstack-models.md, such as \"feature, refactoring\" or \"judgment and prose\". Omit to inherit the parent route."
-			},
-			cwd: {
-				type: "string",
-				description: "Initial child working directory. Omit to inherit the parent directory."
+/** Full delegation: plan, validate, start. */
+async function delegate(parent, args, runtime, config = DEFAULT_CONFIG, signal = new AbortController().signal) {
+	return startPlannedChildren(parent, planDelegation(args, runtime, config), runtime, config, signal);
+}
+const TOOL_DESCRIPTION = [
+	"Delegate self-contained work to one or more fresh child agents.",
+	"",
+	"Returns the id of every child it started plus the route each one resolved. The children run",
+	"in the background: their results arrive later as completion notices in this conversation.",
+	"Never wait or poll for them, and keep working on something useful meanwhile.",
+	"",
+	"`agent` picks the brief: `poteto-agent` (default) injects the poteto subagent preamble and",
+	"the absolute path of the poteto-mode instructions; `comment-sicko` injects the comment",
+	"reviewer persona and must be briefed read-only; `general` is a plain child with no preamble.",
+	"",
+	"`role` selects a configured pstack role and therefore the child's model route and reasoning",
+	"effort. The role names and the meaning of each are in the pstack role manifest, not here.",
+	"Omit `role` to inherit the parent route. Panel roles start one child per configured entry.",
+	"",
+	"`reasoningEffort` raises or lowers the effort for this delegation alone. The role line is a",
+	"starting baseline, not a verdict: start from it, raise it for hard work and lower it for",
+	"routine work. The value must be one the target model advertises, and this package does not",
+	"assume a ladder, so read the effort list the role's model reports rather than guessing. An",
+	"unsupported value fails the call before any child starts, including every entry of a panel.",
+	"",
+	"A running child can also change its own effort with `set_reasoning_effort`, which applies",
+	"from its next step. You do not have to predict the level up front.",
+	"",
+	"Every prompt is a fresh child that does not see this conversation, so include everything it",
+	"needs. A child's own summary is not evidence: review its diff or artifacts yourself."
+].join("\n");
+function buildParameters(config) {
+	const properties = {
+		description: {
+			type: "string",
+			description: "A short 3-5 word label for the child, shown in list_agents and its notices."
+		},
+		prompt: {
+			type: "string",
+			description: "The complete, self-contained brief. The child does not see this conversation, so include the task, every prior directive, and the paths or branches it needs."
+		},
+		agent: {
+			type: "string",
+			enum: [...AGENT_KINDS],
+			description: "Child brief type: \"poteto-agent\" (default) for pstack implementation delegates, \"comment-sicko\" for the read-only comment reviewer, \"general\" for a plain child with no preamble."
+		},
+		role: {
+			type: "string",
+			description: "A pstack role key, matched exactly. It selects the child's model route and effort. Omit it to inherit the parent route."
+		},
+		cwd: {
+			type: "string",
+			description: "The child's initial working directory. Relative paths resolve against this session's directory. Omitted inherits it."
+		},
+		maxDepth: {
+			type: "integer",
+			description: "How many further delegation levels the child may use; 0 or greater, and negative values are rejected. It can only lower this row's configured cap, never raise it."
+		},
+		roleIndex: {
+			type: "integer",
+			description: "Selects one entry of a list-valued role that is not an automatic panel; 0 or greater, and negative values are rejected. Requires `role`."
+		},
+		reasoningEffort: {
+			type: "string",
+			description: [
+				"Reasoning effort for every child this call starts, overriding the role line's value for this delegation.",
+				"Start from the role's level, raise it for hard work, lower it for routine work.",
+				"The value must be one the target model advertises: this package assumes no ladder and rejects an unknown token with that model's real effort list.",
+				"It is validated for every panel entry before any child starts, so one incompatible entry fails the whole call instead of half-starting it.",
+				"Omit it to use the role line's effort."
+			].join(" ")
+		}
+	};
+	if (config.allowedAgentPresets.length > 0) properties["agentPreset"] = {
+		type: "string",
+		enum: [...config.allowedAgentPresets],
+		description: "An independent child preset from this row's allowlist."
+	};
+	return {
+		type: "object",
+		additionalProperties: false,
+		properties,
+		required: ["description", "prompt"]
+	};
+}
+const OUTPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		kind: {
+			type: "string",
+			enum: ["activation", "activations"],
+			description: "How many children this call started."
+		},
+		children: {
+			type: "array",
+			description: "One record per started child, in start order.",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					childId: {
+						type: "string",
+						description: "The child session id."
+					},
+					label: {
+						type: "string",
+						description: "The label this call gave the child."
+					},
+					agent: {
+						type: "string",
+						description: "The child brief type."
+					},
+					role: {
+						type: "string",
+						description: "The role key, or `(none)`."
+					},
+					route: {
+						type: "string",
+						description: "`inherit-parent` or `<provider>/<model> [effort]`."
+					},
+					effort: {
+						type: "string",
+						description: "The reasoning effort this child runs at, when one applies. Equal to the call's `reasoningEffort` when that was passed."
+					},
+					maxDepth: {
+						type: "integer",
+						description: "The delegation-depth cap the child received."
+					}
+				},
+				required: [
+					"childId",
+					"label",
+					"agent",
+					"role",
+					"route"
+				]
 			}
 		},
+		diagnostics: {
+			type: "array",
+			description: "Configuration notes, including a panel whose entries share one route. Empty when nothing needs reporting.",
+			items: { type: "string" }
+		}
+	},
+	required: [
+		"kind",
+		"children",
+		"diagnostics"
+	]
+};
+/** Render one delegation result for the model. */
+function renderDelegationResult(result) {
+	const lines = [
+		result.kind === "activation" ? `started 1 child: ${result.children[0]?.childId ?? "(none)"}` : `started ${result.children.length} children:`,
+		...result.children.map((child) => `- ${child.childId} (${child.label}) agent=${child.agent} role=${child.role} route=${child.route}${child.effort === void 0 ? "" : ` effort=${child.effort}`}${child.maxDepth === void 0 ? "" : ` maxDepth=${child.maxDepth}`}`),
+		"Results arrive as completion notices; do not poll for them. Each child can change its own",
+		"effort from its next step with `set_reasoning_effort`; you do not need to predict it up front."
+	];
+	if (result.diagnostics.length > 0) lines.push("", "Diagnostics:", ...result.diagnostics.map((diagnostic) => `- ${diagnostic}`));
+	return lines.join("\n");
+}
+/** Build the model-facing tool for one row. */
+function createPstackSubagentTool(runtime, config = DEFAULT_CONFIG) {
+	return {
+		name: TOOL_NAME,
+		description: TOOL_DESCRIPTION,
+		parameters: buildParameters(config),
 		output: {
-			schema: { type: "string" },
+			schema: OUTPUT_SCHEMA,
 			render: (_args, value) => [{
 				type: "text",
-				text: value
+				text: renderDelegationResult(value)
 			}]
 		},
-		async execute(args, exec) {
+		isConcurrencySafe: () => true,
+		async execute(rawArgs, exec) {
 			const parent = exec.agent;
-			if (!parent) throw new Error("pstack_subagent requires an agent context");
-			const kind = args.agent ?? deps.defaultAgent ?? "poteto-agent";
-			const agentInstructions = await deps.loadAgent(kind);
-			const prompt = composePrompt({
-				kind,
-				description: args.description,
-				prompt: args.prompt,
-				agentInstructions,
-				...deps.potetoModePath ? { potetoModePath: deps.potetoModePath } : {}
-			});
-			const { route, notes } = await deps.loadRole(args.role);
-			const started = `started subagent ${(await deps.start({
-				parent,
-				label: args.description,
-				prompt: [{
-					type: "text",
-					text: prompt
-				}],
-				signal: exec.signal,
-				route,
-				cwd: args.cwd
-			})).childId}`;
-			return notes.length > 0 ? [started, ...notes].join("\n") : started;
+			if (parent === void 0) throw new DelegationError("pstack_subagent needs a calling Agent, and exec.agent was undefined. This tool runs inside a conversation; it cannot start a child from a context that has no parent Agent.");
+			return await delegate(parent, parseDelegationArgs(rawArgs, config), runtime, config, exec.signal);
 		}
-	});
+	};
 }
-/**
-* Build the provider-facing activation request for one child.
-*
-* A role is resolved once, at delegation time, into concrete provider options.
-* The child inherits the parent route when the role is absent or resolves to
-* `inherit-parent`, which is why the field is omitted rather than set to a
-* placeholder.
-*/
-function buildActivationRequest(input) {
-	const options = routeToAgentOptions(input.route);
+/** Build the runtime a real Host call reads. */
+function hostRuntime(ctx, getAgentRegistry = () => void 0) {
 	return {
-		parent: input.parent,
-		prompt: input.prompt,
-		...input.cwd ? { cwd: input.cwd } : {},
-		...options ? { agentOptions: options } : {}
+		subagents: ctx.subagents,
+		llm: ctx.llm,
+		get agents() {
+			return getAgentRegistry();
+		},
+		dshHome: resolveDshHome(),
+		assetsRoot: ASSETS_ROOT
 	};
 }
 /**
-* Mount the tool. `ctx.subagents` owns child lifecycle; this row only supplies
-* the pstack-specific shape (agent preambles and role routes) on top.
+* Register `pstack_subagent` for this row.
+*
+* @param ctx - context providing the tool registry, the subagent registry, the LLM
+*   adapters, and optionally `ctx.get` for the agent registry.
+* @param config - validated row config.
 */
-function apply(ctx, config = {}) {
-	const providerName = config.provider ?? "spawn";
-	const tool = createPstackTool({
-		async start({ parent, label, prompt, signal, route, cwd }) {
-			const activation = await ctx.subagents.startActivation({
-				provider: providerName,
-				label,
-				signal,
-				delivery: "parent",
-				request: buildActivationRequest({
-					parent,
-					prompt,
-					route,
-					cwd
-				})
-			});
-			return { childId: String(activation.childId) };
-		},
-		loadAgent: readAgentInstructions,
-		loadRole: resolveRoleArg,
-		potetoModePath: POTETO_MODE_PATH,
-		...config.defaultAgent ? { defaultAgent: config.defaultAgent } : {},
-		...config.toolName ? { toolName: config.toolName } : {}
-	});
+function apply(ctx, config = DEFAULT_CONFIG) {
+	const tool = createPstackSubagentTool(hostRuntime(ctx, () => ctx.get?.("agents")), config);
 	ctx.tools.register(tool);
 }
+function describeError(error) {
+	if (error instanceof Error) {
+		const code = error.code;
+		const suffix = typeof code === "string" ? ` (${code})` : "";
+		return `${error.message}${suffix}`;
+	}
+	return String(error);
+}
 //#endregion
-export { apply, buildActivationRequest, composePrompt, createPstackTool, inject, name, readAgentInstructions, resolveRoleArg, routeToAgentOptions, stripFrontmatter };
+export { AGENT_KINDS, Config, DEFAULT_AGENT_KIND, DEFAULT_SUBAGENT_PROVIDER, DelegationError, OUTPUT_SCHEMA, PartialDelegationError, PreambleError, TOOL_NAME, agentOptionsFor, apply, assertProviderCapabilities, composeChildPrompt, createPstackSubagentTool, delegate, hostRuntime, inject, loadAgentPreamble, name, parseDelegationArgs, planDelegation, plannedRouteLabel, renderDelegationResult, resolveDelegationDepth, routeLabel, startPlannedChildren };
 
 //# sourceMappingURL=subagent.mjs.map