dsh-pstack 0.2.0-beta.1 → 0.2.0

package/dist/remote.mjs

@@ -0,0 +1,234 @@
+// src/remote.ts
+/** npm package that owns these methods. */
+const REMOTE_PACKAGE = "dsh-pstack";
+/** Cordis service key and wire namespace of the Host role service. */
+const ROLES_SERVICE = "pstackRoles";
+function jsonCodec(typeSymbol, parse, decode) {
+	return {
+		mode: "strict",
+		typeSymbol,
+		create: () => ({ parse }),
+		...decode === void 0 ? {} : { decode }
+	};
+}
+function parameter(wire, typeSymbol, parse) {
+	return {
+		name: wire,
+		wire,
+		source: "json",
+		codec: jsonCodec(typeSymbol, parse)
+	};
+}
+function parseRecord(value, subject) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${subject} must be an object`);
+	return value;
+}
+function parseRoute(value, subject) {
+	const record = parseRecord(value, subject);
+	if (record["kind"] === "inherit") {
+		const alias = record["alias"] ?? "inherit-parent";
+		if (alias !== "inherit-parent" && alias !== "auto") throw new TypeError(`${subject}.alias must be "inherit-parent" or "auto"`);
+		return {
+			kind: "inherit",
+			alias
+		};
+	}
+	if (record["kind"] !== "route") throw new TypeError(`${subject}.kind is unknown`);
+	const provider = record["provider"];
+	const model = record["model"];
+	const effort = record["effort"];
+	if (typeof provider !== "string" || provider.trim() === "") throw new TypeError(`${subject}.provider must be a non-empty string`);
+	if (typeof model !== "string" || model.trim() === "") throw new TypeError(`${subject}.model must be a non-empty string`);
+	if (effort !== void 0 && (typeof effort !== "string" || effort.trim() === "")) throw new TypeError(`${subject}.effort must be a non-empty string when present`);
+	return {
+		kind: "route",
+		provider,
+		model,
+		...typeof effort === "string" ? { effort } : {}
+	};
+}
+/** Parse one save request from the wire. */
+function parseSaveRoleRequest(value) {
+	const record = parseRecord(value, "the save request");
+	if (typeof record["key"] !== "string") throw new TypeError("the save request must name a role");
+	const routes = record["routes"];
+	if (!Array.isArray(routes)) throw new TypeError("the save request must carry a route list");
+	return {
+		key: record["key"],
+		routes: routes.map((route, index) => parseRoute(route, `routes[${index}]`))
+	};
+}
+function parseRoleFileIssue(value) {
+	const record = parseRecord(value, "a role file issue");
+	if (typeof record["message"] !== "string") throw new TypeError("a role file issue needs a message");
+	const line = record["line"];
+	if (line !== void 0 && typeof line !== "number") throw new TypeError("a role file issue line must be a number");
+	return {
+		...typeof line === "number" ? { line } : {},
+		message: record["message"]
+	};
+}
+function parseRoleView(value, index) {
+	const record = parseRecord(value, `roles[${index}]`);
+	if (typeof record["key"] !== "string") throw new TypeError(`roles[${index}].key must be a string`);
+	if (record["shape"] !== "single" && record["shape"] !== "list") throw new TypeError(`roles[${index}].shape is unknown`);
+	if (typeof record["configured"] !== "boolean") throw new TypeError(`roles[${index}].configured must be a boolean`);
+	const routes = record["routes"];
+	const issues = record["issues"];
+	if (!Array.isArray(routes) || !Array.isArray(issues)) throw new TypeError(`roles[${index}] must carry routes and issues arrays`);
+	const line = record["line"];
+	return {
+		key: record["key"],
+		shape: record["shape"],
+		configured: record["configured"],
+		...typeof line === "number" ? { line } : {},
+		routes: routes.map((route, routeIndex) => parseRoute(route, `roles[${index}].routes[${routeIndex}]`)),
+		issues: issues.map((issue) => String(issue))
+	};
+}
+/** Parse a role-file snapshot from the wire. */
+function parseRoleFileSnapshot(value) {
+	const record = parseRecord(value, "the role file snapshot");
+	const status = record["status"];
+	if (status !== "missing" && status !== "loaded" && status !== "unreadable") throw new TypeError("the role file snapshot status is unknown");
+	if (typeof record["path"] !== "string") throw new TypeError("the role file snapshot path must be a string");
+	if (typeof record["canSave"] !== "boolean") throw new TypeError("the role file snapshot canSave must be a boolean");
+	const roles = record["roles"];
+	const issues = record["issues"];
+	if (!Array.isArray(roles) || !Array.isArray(issues)) throw new TypeError("the role file snapshot must carry roles and issues arrays");
+	const reason = record["reason"];
+	const budget = record["budget"];
+	return {
+		path: record["path"],
+		status,
+		...typeof reason === "string" ? { reason } : {},
+		...typeof budget === "string" ? { budget } : {},
+		roles: roles.map((role, index) => parseRoleView(role, index)),
+		issues: issues.map(parseRoleFileIssue),
+		canSave: record["canSave"]
+	};
+}
+/** Parse a save result from the wire. */
+function parseSaveRoleResult(value) {
+	const record = parseRecord(value, "the save result");
+	if (record["ok"] === true) return {
+		ok: true,
+		snapshot: parseRoleFileSnapshot(record["snapshot"])
+	};
+	if (record["ok"] === false && typeof record["reason"] === "string") return {
+		ok: false,
+		reason: record["reason"]
+	};
+	throw new TypeError("the save result must be ok with a snapshot or refused with a reason");
+}
+/** Parse the live catalogue the page offers. */
+function parseCatalogue(value) {
+	const record = parseRecord(value, "the catalogue");
+	const providers = record["providers"];
+	if (!Array.isArray(providers)) throw new TypeError("the catalogue must carry providers");
+	if (typeof record["truncated"] !== "boolean") throw new TypeError("the catalogue truncated flag must be a boolean");
+	return {
+		providers: providers.map((provider, index) => {
+			const entry = parseRecord(provider, `providers[${index}]`);
+			if (typeof entry["provider"] !== "string" || typeof entry["name"] !== "string") throw new TypeError(`providers[${index}] needs provider and name strings`);
+			const models = entry["models"];
+			if (!Array.isArray(models)) throw new TypeError(`providers[${index}].models must be an array`);
+			return {
+				provider: entry["provider"],
+				name: entry["name"],
+				...typeof entry["error"] === "string" ? { error: entry["error"] } : {},
+				models: models.map((model, modelIndex) => {
+					const item = parseRecord(model, `providers[${index}].models[${modelIndex}]`);
+					if (typeof item["route"] !== "string" || typeof item["id"] !== "string" || typeof item["name"] !== "string") throw new TypeError(`providers[${index}].models[${modelIndex}] needs route, id, and name strings`);
+					const efforts = item["efforts"];
+					if (!Array.isArray(efforts) || efforts.some((effort) => typeof effort !== "string")) throw new TypeError(`providers[${index}].models[${modelIndex}].efforts must be strings`);
+					return {
+						route: item["route"],
+						id: item["id"],
+						name: item["name"],
+						...typeof item["description"] === "string" ? { description: item["description"] } : {},
+						...typeof item["contextWindow"] === "number" ? { contextWindow: item["contextWindow"] } : {},
+						...typeof item["maxTokens"] === "number" ? { maxTokens: item["maxTokens"] } : {},
+						efforts,
+						...typeof item["defaultEffort"] === "string" ? { defaultEffort: item["defaultEffort"] } : {},
+						...typeof item["error"] === "string" ? { error: item["error"] } : {}
+					};
+				})
+			};
+		}),
+		truncated: record["truncated"]
+	};
+}
+function directMethod(options) {
+	const descriptor = {
+		id: `${REMOTE_PACKAGE}#${ROLES_SERVICE}/${options.method}`,
+		service: ROLES_SERVICE,
+		namespace: ROLES_SERVICE,
+		method: options.method,
+		invocation: { kind: "direct" },
+		parameters: options.parameters,
+		result: options.result,
+		...options.cancellation === true ? { cancellation: { parameter: "signal" } } : {}
+	};
+	const input = { create() {
+		return { parse(value) {
+			const record = parseRecord(value, "the method input");
+			const parsed = {};
+			for (const item of options.parameters) if (record[item.wire] !== void 0) {
+				const codec = item.codec;
+				parsed[item.wire] = codec.create().parse(record[item.wire]);
+			}
+			return parsed;
+		} };
+	} };
+	return {
+		...descriptor,
+		input: () => input,
+		invoke(remote, named, signal) {
+			const namespace = Reflect.get(remote, ROLES_SERVICE);
+			const values = options.parameters.map((item) => named[item.wire]);
+			if (options.cancellation === true) values.push(signal);
+			return namespace[options.method](...values);
+		}
+	};
+}
+const statusMethod = directMethod({
+	method: "status",
+	parameters: [],
+	result: jsonCodec("PstackRoleFileSnapshot", parseRoleFileSnapshot, parseRoleFileSnapshot),
+	invoke: (remote) => remote.pstackRoles.status()
+});
+const catalogueMethod = directMethod({
+	method: "catalogue",
+	parameters: [],
+	result: jsonCodec("PstackRoleCatalogue", parseCatalogue, parseCatalogue),
+	cancellation: true,
+	invoke: (remote, _input, signal) => remote.pstackRoles.catalogue(signal)
+});
+const saveMethod = directMethod({
+	method: "save",
+	parameters: [parameter("request", "PstackSaveRoleRequest", (value) => {
+		parseSaveRoleRequest(value);
+		return value;
+	})],
+	result: jsonCodec("PstackSaveRoleResult", parseSaveRoleResult, parseSaveRoleResult),
+	cancellation: true,
+	invoke: (remote, request, signal) => remote.pstackRoles.save(request, signal)
+});
+/** Mountable contribution the Client passes to `ctx.remote.$mount()`. */
+const pstackRolesRemote = {
+	package: REMOTE_PACKAGE,
+	descriptors: [
+		statusMethod,
+		catalogueMethod,
+		saveMethod
+	],
+	methods: {
+		[`${ROLES_SERVICE}/status`]: statusMethod,
+		[`${ROLES_SERVICE}/catalogue`]: catalogueMethod,
+		[`${ROLES_SERVICE}/save`]: saveMethod
+	}
+};
+/** The same descriptors registered by the Host as its strict definitions. */
+const pstackRolesContribution = pstackRolesRemote;
+export { REMOTE_PACKAGE, ROLES_SERVICE, parseCatalogue, parseRoleFileSnapshot, parseSaveRoleRequest, parseSaveRoleResult, pstackRolesContribution, pstackRolesRemote };

package/dist/role-config-NNn5r1JX.mjs

@@ -0,0 +1,415 @@
+import { join, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+// src/internal/role-manifest.ts
+/**
+* File name the role configuration lives under inside `$DSH_HOME`.
+*
+* It keeps the upstream name `pstack-models.mdc`, so a reader moving from the Cursor docs
+* recognizes it, but stores it directly under `$DSH_HOME`; DSH does not load `.mdc` files
+* on its own, and `pstack_subagent` is the only reader.
+*/
+const PSTACK_MODELS_FILENAME = "pstack-models.mdc";
+/** Values that resolve to "send no `agentOptions` and inherit the parent route". */
+const INHERIT_PARENT_ALIASES = ["inherit-parent", "auto"];
+/** The 17 roles, in manifest order. */
+const ROLE_MANIFEST = [
+	{
+		key: "feature, refactoring",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "bug-fix",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "perf-issue",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "hillclimb",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "judgment and prose",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "hardest tasks",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "how explorer",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "how explainer",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "why investigators",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "why synthesizer",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "reflect tooling",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "reflect judgment, divergent, synthesizer",
+		shape: "single",
+		autoPanel: false
+	},
+	{
+		key: "arena runners",
+		shape: "list",
+		autoPanel: true
+	},
+	{
+		key: "arena cross-judge pool",
+		shape: "list",
+		autoPanel: false
+	},
+	{
+		key: "swarm workers",
+		shape: "list",
+		autoPanel: false
+	},
+	{
+		key: "architect runners",
+		shape: "list",
+		autoPanel: true
+	},
+	{
+		key: "interrogate reviewers",
+		shape: "list",
+		autoPanel: true
+	}
+];
+/** Exact manifest lookup. Callers normalize the key first. */
+function findRoleSpec(key) {
+	return ROLE_MANIFEST.find((role) => role.key === key);
+}
+// src/internal/role-config.ts
+/**
+* The pstack role configuration: `$DSH_HOME/pstack-models.mdc`.
+*
+* `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 stay apart because each needs a different fix: the file is missing (no
+* policy, so every role inherits the parent route), unreadable (a broken install, never
+* treated as "no configuration"), or loaded with per-line issues reported by line.
+*/
+/** 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`. */
+function resolveDshHome(env = process.env, home = homedir()) {
+	const configured = env["DSH_HOME"];
+	const path = configured !== void 0 && configured.trim() !== "" ? configured : join(home, ".dsh");
+	const expanded = path === "~" ? home : path.startsWith("~/") || path.startsWith("~\\") ? join(home, path.slice(2)) : path;
+	return resolve(expanded);
+}
+/** Read the role file. Never throws for a missing or unreadable file. */
+function readRoleConfiguration(path) {
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch (error) {
+		if (isMissingFile(error)) return {
+			status: "missing",
+			path
+		};
+		return {
+			status: "unreadable",
+			path,
+			reason: describeError(error)
+		};
+	}
+	return parseRoleConfiguration(text, path);
+}
+/** Parse role-file text. Pure: no file system access. */
+function parseRoleConfiguration(text, path) {
+	const issues = [];
+	const roles = /* @__PURE__ */ new Map();
+	let budget;
+	stripFrontmatter(text).split("\n").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 = findRoleSpec(key);
+		if (spec === void 0) {
+			issues.push({
+				line,
+				message: unknownRoleMessage(rawKey, key)
+			});
+			return;
+		}
+		const parsed = parseRouteValue(rawValue);
+		const entryIssues = [...parsed.issues];
+		if (spec.shape === "single" && parsed.routes.length > 1) entryIssues.push("a single-route role cannot hold a comma-separated list");
+		for (const issue of entryIssues) 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,
+			routes: parsed.routes,
+			issues: entryIssues
+		});
+	});
+	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" };
+	const alias = value.toLowerCase();
+	if (INHERIT_PARENT_ALIASES.includes(alias)) return { route: {
+		kind: "inherit",
+		alias
+	} };
+	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.
+*
+* Automatic panels start one child per entry. Another list role selects one entry, the
+* first by default; `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`);
+	if (entry === void 0) return {
+		role: spec,
+		mode: spec.autoPanel ? "panel" : "single",
+		configured: false,
+		routes: [{ kind: "inherit" }],
+		total: 1
+	};
+	if (entry.issues.length > 0) throw new RouteSelectionError(`role "${spec.key}" has invalid configuration on line ${entry.line}: ${entry.issues.join("; ")}. Fix the role file before delegating.`);
+	if (spec.autoPanel) return {
+		role: spec,
+		mode: "panel",
+		configured: true,
+		routes: entry.routes,
+		total: entry.routes.length
+	};
+	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
+		};
+	}
+	return {
+		role: spec,
+		mode: "single",
+		configured: true,
+		routes: [entry.routes[0]],
+		total: entry.routes.length
+	};
+}
+/** Keys of the list-valued roles, including the automatic panels. */
+function listRoleKeys() {
+	return ROLE_MANIFEST.filter((role) => role.shape === "list").map((role) => role.key);
+}
+/** Raised when a role name does not match the manifest. */
+var RoleNameError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RoleNameError";
+	}
+};
+/** Normalize a role name for lookup. Case, spacing, spacing around a comma, and a trailing colon are formatting. */
+function normalizeRoleName(raw) {
+	return raw.normalize("NFC").trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").replace(/:+$/, "").trim();
+}
+/** Resolve a role name, or throw a diagnostic that names the near misses. */
+function requireRole(raw) {
+	const spec = findRoleSpec(normalizeRoleName(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 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);
+}
+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 is reported rather than ignored.`;
+}
+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 !== "");
+}
+/** 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];
+}
+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(error) {
+	if (error instanceof Error) {
+		const code = error.code;
+		return typeof code === "string" ? `${code}: ${error.message}` : error.message;
+	}
+	return String(error);
+}
+export { resolveDshHome as a, ROLE_MANIFEST as c, requireRole as i, findRoleSpec as l, normalizeRoleName as n, selectRoleRoutes as o, readRoleConfiguration as r, INHERIT_PARENT_ALIASES as s, modelsFilePath as t };

package/dist/role-manifest-C3fUzjLI.d.mts

@@ -0,0 +1,19 @@
+/**
+ * The one pstack role manifest.
+ *
+ * Keys are matched exactly after normalization, and commas belong to some keys
+ * (`feature, refactoring`, `reflect judgment, divergent, synthesizer`), so nothing here
+ * may split a key on a comma. A second literal role list anywhere is a bug.
+ *
+ * This module has no Node imports: the bundle imports it directly.
+ */
+/** Whether a role holds one route or a comma-separated list of routes. */
+type RoleValueShape = "single" | "list";
+interface RoleSpec {
+  /** Exact key as written in the role file. Commas belong to the key. */
+  readonly key: string;
+  readonly shape: RoleValueShape;
+  /** A list role that starts one child per entry automatically. */
+  readonly autoPanel: boolean;
+}
+export { RoleValueShape as n, RoleSpec as t };