dsh-pstack 0.3.0-beta.1 → 0.3.1

package/dist/role-editor.mjs

@@ -0,0 +1,372 @@
+import { collectCatalogue } from "./models.mjs";
+import { isBudgetRowBlocked, parseBudgetApplyRequest, planBudget, renderBudgetText } from "./budget.mjs";
+import { isRoleLineFor, parseRoleFileDocument } from "./role-file.mjs";
+import { parseRoleConfiguration, readRoleConfiguration } from "./role-config.mjs";
+import { ROLE_MANIFEST, findRole } from "./role-manifest.mjs";
+import { renderRouteValue, validateRoleRouteShape, validateRouteParts } from "./route.mjs";
+import { parseSaveRoleRequest } from "./role-wire.mjs";
+import { dirname } from "node:path";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+// src/role-editor.ts
+/**
+* Role-file editing behind the settings page.
+*
+* A save changes or removes one logical role entry and preserves the other
+* logical lines. The editor normalizes line endings and the final newline.
+* Concrete routes are validated against the live model catalogue before the
+* first byte is written, so a rejected save leaves the file unchanged.
+*/
+/** Project one parsed file onto the manifest. */
+function snapshotFromConfiguration(config) {
+	if (config.status === "unreadable") return {
+		path: config.path,
+		status: "unreadable",
+		reason: config.reason,
+		roles: ROLE_MANIFEST.map((role) => roleView(role.key, role.shape, void 0)),
+		issues: [],
+		canSave: false
+	};
+	if (config.status === "missing") return {
+		path: config.path,
+		status: "missing",
+		roles: ROLE_MANIFEST.map((role) => roleView(role.key, role.shape, void 0)),
+		issues: [],
+		canSave: true
+	};
+	return {
+		path: config.path,
+		status: "loaded",
+		...config.budget === void 0 ? {} : { budget: config.budget },
+		roles: ROLE_MANIFEST.map((role) => roleView(role.key, role.shape, config.roles.get(role.key))),
+		issues: config.issues.map((issue) => ({
+			...issue.line === void 0 ? {} : { line: issue.line },
+			message: issue.message
+		})),
+		canSave: true
+	};
+}
+function roleView(key, shape, entry) {
+	return {
+		key,
+		shape,
+		configured: entry !== void 0,
+		...entry === void 0 ? {} : { line: entry.line },
+		routes: entry === void 0 ? [] : entry.routes.map(routeView),
+		issues: entry === void 0 ? [] : [...entry.issues]
+	};
+}
+function routeView(route) {
+	if (route.kind === "inherit") return {
+		kind: "inherit",
+		alias: route.alias
+	};
+	return {
+		kind: "route",
+		provider: route.provider,
+		model: route.model,
+		...route.effort === void 0 ? {} : { effort: route.effort }
+	};
+}
+/** Validate a save against the manifest and the live model catalogue. */
+function validateSaveRequest(request, catalogue) {
+	const spec = findRole(request.key);
+	if (spec === void 0) return {
+		ok: false,
+		reason: `unknown pstack role ${JSON.stringify(request.key)}`
+	};
+	const shapeIssue = validateRoleRouteShape(spec, request.routes);
+	if (shapeIssue !== void 0) return {
+		ok: false,
+		reason: shapeIssue
+	};
+	if (request.routes.length === 0) return {
+		ok: true,
+		key: spec.key,
+		routes: []
+	};
+	const routes = [];
+	for (const [index, route] of request.routes.entries()) {
+		if (route.kind === "inherit") {
+			routes.push({
+				kind: "inherit",
+				alias: route.alias
+			});
+			continue;
+		}
+		const provider = route.provider.trim();
+		const model = route.model.trim();
+		if (provider === "" || model === "") return {
+			ok: false,
+			reason: `route ${index + 1} needs both a provider and a model`
+		};
+		const effort = route.effort?.trim();
+		const routeIssue = validateRouteParts(provider, model, effort);
+		if (routeIssue !== void 0) return {
+			ok: false,
+			reason: `route ${index + 1} ${routeIssue}`
+		};
+		const providerEntry = catalogue.providers.find((entry) => entry.provider === provider);
+		if (providerEntry === void 0) return {
+			ok: false,
+			reason: `provider ${JSON.stringify(provider)} is not in the live model directory`
+		};
+		if (providerEntry.error !== void 0) return {
+			ok: false,
+			reason: `provider ${JSON.stringify(provider)} failed discovery: ${providerEntry.error}`
+		};
+		const modelEntry = providerEntry.models.find((entry) => entry.id === model);
+		if (modelEntry === void 0) return {
+			ok: false,
+			reason: `provider ${JSON.stringify(provider)} does not advertise ${JSON.stringify(model)}`
+		};
+		if (modelEntry.error !== void 0) return {
+			ok: false,
+			reason: `model ${JSON.stringify(`${provider}/${model}`)} failed discovery: ${modelEntry.error}`
+		};
+		if (effort !== void 0 && effort !== "" && !modelEntry.efforts.includes(effort)) return {
+			ok: false,
+			reason: `model ${JSON.stringify(`${provider}/${model}`)} does not advertise effort ${JSON.stringify(effort)}`
+		};
+		routes.push({
+			kind: "route",
+			provider,
+			model,
+			...effort === void 0 || effort === "" ? {} : { effort }
+		});
+	}
+	return {
+		ok: true,
+		key: spec.key,
+		routes
+	};
+}
+/** Replace or append one role line, preserving the other logical lines. */
+function updateRoleText(text, key, value) {
+	const { bom, eol, body } = splitDocumentText(text);
+	const document = parseRoleFileDocument(stripTrailingEol(body), "");
+	const matches = [];
+	document.lines.forEach((line, index) => {
+		if (isRoleLineFor(line, key)) matches.push(index);
+	});
+	const target = matches.at(-1) ?? -1;
+	const matching = new Set(matches);
+	const lines = document.lines.flatMap((line, index) => {
+		if (index === target) return [`${key}: ${value}`];
+		if (matching.has(index)) return [];
+		return [line.raw];
+	});
+	if (target === -1) {
+		if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+		lines.push(`${key}: ${value}`);
+	}
+	return `${bom}${lines.join(eol)}${eol}`;
+}
+/** Remove every matching role line. Clearing an absent role is a no-op. */
+function removeRoleText(text, key) {
+	const { bom, eol, body } = splitDocumentText(text);
+	const document = parseRoleFileDocument(stripTrailingEol(body), "");
+	const remaining = document.lines.filter((line) => !isRoleLineFor(line, key)).map((line) => line.raw);
+	if (remaining.length === document.lines.length) return text;
+	return remaining.length === 0 ? "" : `${bom}${remaining.join(eol)}${eol}`;
+}
+/** Split a document into BOM, dominant EOL, and body. */
+function splitDocumentText(text) {
+	const bom = text.startsWith("") ? "" : "";
+	const body = bom === "" ? text : text.slice(1);
+	return {
+		bom,
+		eol: body.includes("\r\n") ? "\r\n" : "\n",
+		body
+	};
+}
+function stripTrailingEol(body) {
+	return body.replace(/\r?\n$/, "");
+}
+/** Save one role and return the reloaded snapshot. */
+async function saveRoleConfiguration(path, request, llm, signal) {
+	signal.throwIfAborted();
+	let parsed;
+	try {
+		parsed = parseSaveRoleRequest(request);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: describeError(error)
+		};
+	}
+	const current = readRoleConfiguration(path);
+	if (current.status === "unreadable") return {
+		ok: false,
+		reason: `the role file is unreadable: ${current.reason}`
+	};
+	let text = "";
+	const readText = () => {
+		if (current.status !== "loaded") return {
+			ok: true,
+			text: ""
+		};
+		try {
+			return {
+				ok: true,
+				text: readFileSync(path, "utf8")
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				reason: `the role file could not be read: ${describeError(error)}`
+			};
+		}
+	};
+	let next;
+	if (parsed.routes.length === 0) {
+		const validation = validateSaveRequest(parsed, {
+			providers: [],
+			truncated: false
+		});
+		if (!validation.ok) return validation;
+		const read = readText();
+		if (!read.ok) return read;
+		text = read.text;
+		next = removeRoleText(text, validation.key);
+	} else if (parsed.routes.every((route) => route.kind === "inherit")) {
+		const validation = validateSaveRequest(parsed, {
+			providers: [],
+			truncated: false
+		});
+		if (!validation.ok) return validation;
+		const read = readText();
+		if (!read.ok) return read;
+		text = read.text;
+		next = updateRoleText(text, validation.key, renderRouteValue(validation.routes));
+	} else {
+		let catalogue;
+		try {
+			catalogue = await collectCatalogue(llm, void 0, signal);
+		} catch (error) {
+			signal.throwIfAborted();
+			return {
+				ok: false,
+				reason: `the model catalogue could not be loaded: ${describeError(error)}`
+			};
+		}
+		signal.throwIfAborted();
+		const validation = validateSaveRequest(parsed, catalogue);
+		if (!validation.ok) return validation;
+		const read = readText();
+		if (!read.ok) return read;
+		text = read.text;
+		next = updateRoleText(text, validation.key, renderRouteValue(validation.routes));
+	}
+	if (next === text) return {
+		ok: true,
+		snapshot: snapshotFromConfiguration(readRoleConfiguration(path))
+	};
+	try {
+		writeAtomically(path, next);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `the role file could not be written: ${describeError(error)}`
+		};
+	}
+	return {
+		ok: true,
+		snapshot: snapshotFromConfiguration(parseRoleConfiguration(next, path))
+	};
+}
+/** Apply one global budget target to the role file in a single atomic write. */
+async function saveBudgetConfiguration(path, request, llm, signal) {
+	signal.throwIfAborted();
+	let parsed;
+	try {
+		parsed = parseBudgetApplyRequest(request);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: describeError(error)
+		};
+	}
+	const initial = readRoleConfiguration(path);
+	if (initial.status === "unreadable") return {
+		ok: false,
+		reason: `the role file is unreadable: ${initial.reason}`
+	};
+	let catalogue;
+	try {
+		catalogue = await collectCatalogue(llm, void 0, signal);
+	} catch (error) {
+		signal.throwIfAborted();
+		return {
+			ok: false,
+			reason: `the model catalogue could not be loaded: ${describeError(error)}`
+		};
+	}
+	signal.throwIfAborted();
+	const current = readRoleConfiguration(path);
+	if (current.status === "unreadable") return {
+		ok: false,
+		reason: `the role file is unreadable: ${current.reason}`
+	};
+	let text = "";
+	if (current.status === "loaded") try {
+		text = readFileSync(path, "utf8");
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `the role file could not be read: ${describeError(error)}`
+		};
+	}
+	try {
+		const document = parseRoleFileDocument(text, path);
+		const inputs = ROLE_MANIFEST.map((spec) => ({
+			key: spec.key,
+			shape: spec.shape,
+			autoPanel: spec.autoPanel,
+			configured: document.roles.has(spec.key),
+			routes: document.roles.get(spec.key)?.routes ?? [{
+				kind: "inherit",
+				alias: "inherit-parent"
+			}],
+			hasIssues: (document.roles.get(spec.key)?.issues.length ?? 0) > 0
+		}));
+		const plan = planBudget(inputs, catalogue, parsed);
+		const blocked = plan.rows.filter(isBudgetRowBlocked);
+		if (blocked.length > 0) return {
+			ok: false,
+			reason: `the budget needs attention for: ${blocked.map((row) => row.key).join(", ")}`
+		};
+		const next = renderBudgetText(text, plan, updateRoleText);
+		if (next === text) return {
+			ok: true,
+			snapshot: snapshotFromConfiguration(readRoleConfiguration(path))
+		};
+		writeAtomically(path, next);
+		return {
+			ok: true,
+			snapshot: snapshotFromConfiguration(parseRoleConfiguration(next, path))
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: describeError(error)
+		};
+	}
+}
+function writeAtomically(path, text) {
+	mkdirSync(dirname(path), { recursive: true });
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, text, "utf8");
+		renameSync(temporary, path);
+	} catch (error) {
+		try {
+			rmSync(temporary, { force: true });
+		} catch {}
+		throw error;
+	}
+}
+function describeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+export { removeRoleText, saveBudgetConfiguration, saveRoleConfiguration, snapshotFromConfiguration, updateRoleText, validateSaveRequest };

package/dist/role-file-CIVHnhBg.d.mts

@@ -0,0 +1,53 @@
+import { c as RoleSpec } from "./role-manifest-D1npMjqZ.mjs";
+import { n as Route } from "./route-7SqXDYrL.mjs";
+/** One recognized role line. */
+interface RoleEntry {
+  readonly line: number;
+  readonly key: string;
+  readonly spec: RoleSpec;
+  readonly routes: readonly Route[];
+  readonly issues: readonly string[];
+}
+/** A file-level issue. Unknown and malformed lines are reported, never dropped. */
+interface RoleFileIssue {
+  readonly line?: number;
+  readonly message: string;
+}
+/** One physical line, classified once for parsing and editing. */
+type RoleFileLine = {
+  readonly kind: "blank";
+  readonly line: number;
+  readonly raw: string;
+} | {
+  readonly kind: "comment";
+  readonly line: number;
+  readonly raw: string;
+} | {
+  readonly kind: "role";
+  readonly line: number;
+  readonly raw: string;
+  readonly key: string;
+  readonly spec: RoleSpec;
+  readonly routes: readonly Route[];
+  readonly issues: readonly string[];
+} | {
+  readonly kind: "other";
+  readonly line: number;
+  readonly raw: string;
+  readonly issue?: string;
+};
+/** Parsed role file with its original lines preserved for the editor. */
+interface RoleFileDocument {
+  readonly path: string;
+  readonly budget?: string;
+  readonly lines: readonly RoleFileLine[];
+  readonly roles: ReadonlyMap<string, RoleEntry>;
+  readonly issues: readonly RoleFileIssue[];
+}
+/** Parse role-file text into a document and its semantic view. */
+declare function parseRoleFileDocument(text: string, path: string): RoleFileDocument;
+/** Whether a line is the role entry the editor is looking for. */
+declare function isRoleLineFor(line: RoleFileLine, key: string): line is Extract<RoleFileLine, {
+  kind: "role";
+}>;
+export { isRoleLineFor as a, RoleFileLine as i, RoleFileDocument as n, parseRoleFileDocument as o, RoleFileIssue as r, RoleEntry as t };

package/dist/role-file.d.mts

@@ -0,0 +1,2 @@
+import { a as isRoleLineFor, i as RoleFileLine, n as RoleFileDocument, o as parseRoleFileDocument, r as RoleFileIssue, t as RoleEntry } from "./role-file-CIVHnhBg.mjs";
+export { RoleEntry, RoleFileDocument, RoleFileIssue, RoleFileLine, isRoleLineFor, parseRoleFileDocument };

package/dist/role-file.mjs

@@ -0,0 +1,121 @@
+import { budgetLineValue } from "./budget.mjs";
+import { findRole, normalizeRoleName } from "./role-manifest.mjs";
+import { parseRouteValue, validateRoleRouteShape } from "./route.mjs";
+// src/role-file.ts
+/** The parsed line model behind the role file and its editor. */
+/** Parse role-file text into a document and its semantic view. */
+function parseRoleFileDocument(text, path) {
+	const roles = /* @__PURE__ */ new Map();
+	const issues = [];
+	const lines = [];
+	let budget;
+	if (text !== "") text.split(/\r?\n/).forEach((rawLine, index) => {
+		const line = index + 1;
+		const trimmed = rawLine.trim();
+		if (trimmed === "") {
+			lines.push({
+				kind: "blank",
+				line,
+				raw: rawLine
+			});
+			return;
+		}
+		if (trimmed.startsWith("#")) {
+			const value = budgetLineValue(rawLine);
+			if (value !== void 0 && value !== "") budget = value;
+			lines.push({
+				kind: "comment",
+				line,
+				raw: rawLine
+			});
+			return;
+		}
+		const colon = rawLine.indexOf(":");
+		if (colon === -1) {
+			const message = `expected \`<role>: <value>\`, found ${JSON.stringify(trimmed)}`;
+			issues.push({
+				line,
+				message
+			});
+			lines.push({
+				kind: "other",
+				line,
+				raw: rawLine,
+				issue: message
+			});
+			return;
+		}
+		const rawKey = rawLine.slice(0, colon).trim();
+		if (rawKey === "") {
+			const message = "the role key is empty";
+			issues.push({
+				line,
+				message
+			});
+			lines.push({
+				kind: "other",
+				line,
+				raw: rawLine,
+				issue: message
+			});
+			return;
+		}
+		const spec = findRole(rawKey);
+		if (spec === void 0) {
+			const message = `unknown pstack role ${JSON.stringify(rawKey)}`;
+			issues.push({
+				line,
+				message
+			});
+			lines.push({
+				kind: "other",
+				line,
+				raw: rawLine,
+				issue: message
+			});
+			return;
+		}
+		const parsed = parseRouteValue(rawLine.slice(colon + 1));
+		const entryIssues = [...parsed.issues];
+		const shapeIssue = validateRoleRouteShape(spec, parsed.routes);
+		if (shapeIssue !== void 0) entryIssues.push(shapeIssue);
+		for (const issue of entryIssues) issues.push({
+			line,
+			message: `${rawKey}: ${issue}`
+		});
+		lines.push({
+			kind: "role",
+			line,
+			raw: rawLine,
+			key: spec.key,
+			spec,
+			routes: parsed.routes,
+			issues: entryIssues
+		});
+		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,
+			key: spec.key,
+			spec,
+			routes: parsed.routes,
+			issues: entryIssues
+		});
+	});
+	return {
+		path,
+		...budget === void 0 ? {} : { budget },
+		lines,
+		roles,
+		issues
+	};
+}
+/** Whether a line is the role entry the editor is looking for. */
+function isRoleLineFor(line, key) {
+	return line.kind === "role" && normalizeRoleName(line.key) === normalizeRoleName(key);
+}
+export { isRoleLineFor, parseRoleFileDocument };

package/dist/{role-manifest-8OERX9-s.d.mts → role-manifest-D1npMjqZ.d.mts}

@@ -1,22 +1,27 @@
 /**
- * The one pstack role manifest.
+ * The 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.
+ * Role keys are matched exactly after whitespace and comma normalization. Commas
+ * belong to some keys (`feature, refactoring`), so the key is never split on a
+ * comma. Role behavior comes from `pstack/skills/setup-pstack/SKILL.md`.
  */
 /** Whether a role holds one route or a comma-separated list of routes. */
-type RoleValueShape = "single" | "list";
+declare const ROLE_SHAPES: readonly ["single", "list"];
+type RoleShape = (typeof ROLE_SHAPES)[number];
+/** One role accepted by `pstack_subagent`'s `role` field. */
 interface RoleSpec {
   /** Exact key as written in the role file. Commas belong to the key. */
   readonly key: string;
-  readonly shape: RoleValueShape;
+  readonly shape: RoleShape;
   /** A list role that starts one child per entry automatically. */
   readonly autoPanel: boolean;
 }
-/** The 17 roles, in manifest order. */
+/** Role file name under `$DSH_HOME`. DSH never loads `.mdc`; this plugin does. */
+declare const PSTACK_MODELS_FILENAME = "pstack-models.mdc";
+/** Values that resolve to "send no route override and inherit the parent route". */
+declare const INHERIT_ALIASES: readonly ["inherit-parent", "auto"];
+type InheritAlias = (typeof INHERIT_ALIASES)[number];
+/** The 17 roles, in the order `setup-pstack` documents them. */
 declare const ROLE_MANIFEST: readonly [{
   readonly key: "feature, refactoring";
   readonly shape: "single";
@@ -87,4 +92,10 @@ declare const ROLE_MANIFEST: readonly [{
   readonly autoPanel: true;
 }];
 type RoleKey = (typeof ROLE_MANIFEST)[number]["key"];
-export { RoleSpec as n, RoleValueShape as r, RoleKey as t };
+/** Normalize spacing and comma formatting without splitting the key. */
+declare function normalizeRoleName(raw: string): string;
+/** Look up one role by its exact normalized key. */
+declare function findRole(raw: string): RoleSpec | undefined;
+/** Whether a string is one of the manifest keys. */
+declare function isRoleKey(raw: string): raw is RoleKey;
+export { ROLE_SHAPES as a, RoleSpec as c, normalizeRoleName as d, ROLE_MANIFEST as i, findRole as l, InheritAlias as n, RoleKey as o, PSTACK_MODELS_FILENAME as r, RoleShape as s, INHERIT_ALIASES as t, isRoleKey as u };

package/dist/role-manifest.d.mts

@@ -0,0 +1,2 @@
+import { a as ROLE_SHAPES, c as RoleSpec, d as normalizeRoleName, i as ROLE_MANIFEST, l as findRole, n as InheritAlias, o as RoleKey, r as PSTACK_MODELS_FILENAME, s as RoleShape, t as INHERIT_ALIASES, u as isRoleKey } from "./role-manifest-D1npMjqZ.mjs";
+export { INHERIT_ALIASES, InheritAlias, PSTACK_MODELS_FILENAME, ROLE_MANIFEST, ROLE_SHAPES, RoleKey, RoleShape, RoleSpec, findRole, isRoleKey, normalizeRoleName };

package/dist/{role-manifest-79cnFfDM.mjs → role-manifest.mjs}

@@ -1,15 +1,18 @@
-// src/internal/role-manifest.ts
+// src/role-manifest.ts
 /**
-* File name the role configuration lives under inside `$DSH_HOME`.
+* The pstack role manifest.
 *
-* 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.
+* Role keys are matched exactly after whitespace and comma normalization. Commas
+* belong to some keys (`feature, refactoring`), so the key is never split on a
+* comma. Role behavior comes from `pstack/skills/setup-pstack/SKILL.md`.
 */
+/** Whether a role holds one route or a comma-separated list of routes. */
+const ROLE_SHAPES = ["single", "list"];
+/** Role file name under `$DSH_HOME`. DSH never loads `.mdc`; this plugin does. */
 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. */
+/** Values that resolve to "send no route override and inherit the parent route". */
+const INHERIT_ALIASES = ["inherit-parent", "auto"];
+/** The 17 roles, in the order `setup-pstack` documents them. */
 const ROLE_MANIFEST = [
 	{
 		key: "feature, refactoring",
@@ -97,16 +100,17 @@ const ROLE_MANIFEST = [
 		autoPanel: true
 	}
 ];
-function isRoleKey(value) {
-	return ROLE_MANIFEST.some((role) => role.key === value);
-}
-/** Normalize formatting while keeping commas that belong to a role name. */
+/** Normalize spacing and comma formatting without splitting the key. */
 function normalizeRoleName(raw) {
 	return raw.normalize("NFC").trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").replace(/:+$/, "").trim();
 }
-/** Exact manifest lookup. Callers normalize the key first. */
-function findRoleSpec(key) {
-	if (!isRoleKey(key)) return void 0;
+/** Look up one role by its exact normalized key. */
+function findRole(raw) {
+	const key = normalizeRoleName(raw);
 	return ROLE_MANIFEST.find((role) => role.key === key);
 }
-export { isRoleKey as a, findRoleSpec as i, PSTACK_MODELS_FILENAME as n, normalizeRoleName as o, ROLE_MANIFEST as r, INHERIT_PARENT_ALIASES as t };
+/** Whether a string is one of the manifest keys. */
+function isRoleKey(raw) {
+	return findRole(raw) !== void 0;
+}
+export { INHERIT_ALIASES, PSTACK_MODELS_FILENAME, ROLE_MANIFEST, ROLE_SHAPES, findRole, isRoleKey, normalizeRoleName };

package/dist/role-remote.d.mts

@@ -0,0 +1,23 @@
+import { n as CatalogueResult } from "./catalogue-wgVaGeUx.mjs";
+import "./models.mjs";
+import { BudgetApplyRequest } from "./budget.mjs";
+import { BudgetApplyResult, RoleFileSnapshot, SaveRoleRequest, SaveRoleResult } from "./role-wire.mjs";
+import { RemoteResult, TypertRemoteInfo } from "@deepseek-ai/dsh-typert-protocol";
+import { TypertContribution } from "@deepseek-ai/dsh-typert-registry";
+/** npm package owning these methods. */
+export declare const REMOTE_PACKAGE = "dsh-pstack";
+/** Cordis service key and wire namespace. */
+export declare const ROLES_SERVICE = "pstackRoles";
+/** Typed Client face installed by `$mount()`. */
+export interface PstackRolesNamespace {
+  readonly pstackRoles: {
+    status(): Promise<RemoteResult<RoleFileSnapshot>>;
+    catalogue(signal?: AbortSignal): Promise<RemoteResult<CatalogueResult>>;
+    save(request: SaveRoleRequest, signal?: AbortSignal): Promise<RemoteResult<SaveRoleResult>>;
+    budget(request: BudgetApplyRequest, signal?: AbortSignal): Promise<RemoteResult<BudgetApplyResult>>;
+  };
+}
+/** Mountable contribution shared by Host registration and Client `$mount`. */
+export declare const pstackRolesRemote: TypertRemoteInfo;
+/** Register the Host's strict invocation definitions in `ctx.typert.local`. */
+export declare const pstackRolesHostContribution: TypertContribution;