@marcoscale98/pi-extensible-workflows 5.14.1-fork.1 → 5.17.0-fork.1

package/dist/src/validation.js

@@ -1,17 +1,14 @@
-import { atomicWriteFile } from "./persistence.js";
-import { mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, extname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import * as acorn from "acorn";
 import { Script } from "node:vm";
-import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { registeredWorkflowRoleDirectoryRegistrations } from "./registry.js";
-import { annotateModelAliasError, assertModelThinking, deepFreeze, errorText, fail, isNodeError, jsonObject, jsonValue, mergeWorkflowExtensionSettings, modelAliasName, modelCapability, object, positiveInteger, resolveModelReference, resourcePatternHasMagic, unknownModel, validateModelAliases, validateResourcePattern, validWorkflowExtensionNamespace } from "./utils.js";
-import { WORKFLOW_CALL_KINDS, isContextFileScope } from "./types.js";
-import { canonicalPath, workflowProjectSettingsPath } from "./paths.js";
-export { workflowProjectSettingsPath } from "./paths.js";
-export const DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, backgroundWidget: true });
+import { assertModelThinking, validateSchema, deepFreeze, errorText, fail, jsonObject, jsonValue, mergeWorkflowExtensionSettings, modelAliasName, modelCapability, object, positiveInteger, resolveModelReference, resourcePatternHasMagic, unknownModel } from "./utils.js";
+import { WORKFLOW_CALL_KINDS } from "./types.js";
+export { validateSchema } from "./utils.js";
+import { loadAgentDefinitions, loadProjectAgentDefinitions } from "./roles.js";
+export { loadAgentDefinitions, loadProjectAgentDefinitions, parseRoleMarkdown, workflowRoleDirectories } from "./roles.js";
+import { validateContextFileScopes, validateSelectorList } from "./settings.js";
+export { DEFAULT_SETTINGS, loadSettings, loadSettingsOverrides, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateContextFileScopes, validateModelAliasAvailability, validateSelectorList, validateWorkflowExtensionSettings, workflowProjectSettingsPath, workflowSettingsPath } from "./settings.js";
 export function validateCheckpoint(value) {
     if (!object(value) || Object.keys(value).some((key) => !["name", "prompt", "context"].includes(key)) || typeof value.name !== "string" || value.name.trim() === "" || typeof value.prompt !== "string" || !jsonValue(value.context))
         fail("INVALID_METADATA", "checkpoint requires only name, prompt, and JSON context");
@@ -21,442 +18,6 @@ export function validateCheckpoint(value) {
         fail("INVALID_METADATA", "checkpoint context exceeds 4096 UTF-8 bytes");
     return { name: value.name, prompt: value.prompt, context: value.context };
 }
-export function workflowSettingsPath(agentDir = getAgentDir()) { return join(agentDir, ROLE_DIRECTORY, "settings.json"); }
-function normalizedResourcePath(value, settingsPath) {
-    if (value === "*")
-        return value;
-    let expanded = value === "~" ? homedir() : value.startsWith("~/") || value.startsWith("~\\") ? join(homedir(), value.slice(2)) : value;
-    if (expanded.startsWith("file://"))
-        expanded = fileURLToPath(expanded);
-    const resolved = resolve(dirname(settingsPath), expanded);
-    if (expanded === "**" || expanded.startsWith("**/") || expanded.startsWith("**\\"))
-        return expanded;
-    if (resourcePatternHasMagic(expanded)) {
-        const magicIndex = resolved.search(/[*?\x5b\x5d{}()]/);
-        const separatorIndex = Math.max(resolved.lastIndexOf("/", magicIndex), resolved.lastIndexOf("\\", magicIndex));
-        const rootBoundary = separatorIndex === 0 || (separatorIndex === 2 && /^[A-Za-z]:[\\/]/.test(resolved));
-        const prefix = rootBoundary ? resolved.slice(0, separatorIndex + 1) : separatorIndex >= 0 ? resolved.slice(0, separatorIndex) : resolved;
-        const suffix = rootBoundary ? resolved.slice(separatorIndex + 1) : separatorIndex >= 0 ? resolved.slice(separatorIndex) : "";
-        return `${canonicalPath(prefix)}${suffix}`;
-    }
-    return canonicalPath(resolved);
-}
-function validateSelectorList(value, path, kind, errorCode = "INVALID_SETTINGS", normalizeExtensions = true) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value))
-        fail(errorCode, `${path}.${kind} must be an array`);
-    const normalized = [];
-    for (const [index, entry] of value.entries()) {
-        if (typeof entry !== "string" || !entry.trim())
-            fail(errorCode, `${path}.${kind}[${String(index)}] must be a non-empty string`);
-        let selector = entry.trim();
-        if (kind === "extensions" && normalizeExtensions) {
-            const negated = selector.startsWith("!");
-            const body = negated ? selector.slice(1) : selector;
-            if (!body)
-                fail(errorCode, `${path}.${kind}[${String(index)}] must be a valid minimatch pattern: Empty minimatch pattern ${JSON.stringify(selector)}`);
-            try {
-                selector = `${negated ? "!" : ""}${normalizedResourcePath(body, path)}`;
-            }
-            catch (error) {
-                fail(errorCode, `${path}.${kind}[${String(index)}] must be a valid path: ${errorText(error)}`);
-            }
-        }
-        try {
-            validateResourcePattern(selector);
-        }
-        catch (error) {
-            fail(errorCode, `${path}.${kind}[${String(index)}] must be a valid minimatch pattern: ${errorText(error)}`);
-        }
-        normalized.push(selector);
-    }
-    return Object.freeze(normalized);
-}
-function validateWorktreePostCreateCommand(value, settingsPath) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || value.length === 0)
-        fail("INVALID_SETTINGS", `${settingsPath}.worktreePostCreateCommand must be a non-empty array`);
-    return Object.freeze(value.map((entry, index) => {
-        if (typeof entry !== "string" || !entry.trim())
-            fail("INVALID_SETTINGS", `${settingsPath}.worktreePostCreateCommand[${String(index)}] must be a non-empty string`);
-        return entry;
-    }));
-}
-function selectorsFromSettings(settings) {
-    return {
-        ...(settings.skills === undefined ? {} : { skills: settings.skills }),
-        ...(settings.extensions === undefined ? {} : { extensions: settings.extensions }),
-        ...(settings.tools === undefined ? {} : { tools: settings.tools }),
-    };
-}
-function selectorSet(value) { return { skills: [...(value?.skills ?? [])], extensions: [...(value?.extensions ?? [])], ...(value?.tools === undefined ? {} : { tools: [...value.tools] }) }; }
-function validateContextFileScopes(value, rolePath) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || !value.every(isContextFileScope))
-        fail("INVALID_METADATA", `${rolePath}.contextFiles must be an array containing only global, project, or cwd`);
-    return [...value];
-}
-export function validateWorkflowExtensionSettings(value, settingsPath, errorCode = "INVALID_SETTINGS", applyDefaults = true) {
-    if (value === undefined)
-        return undefined;
-    const base = `${settingsPath}.extensionSettings`;
-    if (!object(value))
-        fail(errorCode, `${base} must be an object`);
-    const normalized = {};
-    for (const [namespace, raw] of Object.entries(value)) {
-        if (!validWorkflowExtensionNamespace(namespace))
-            fail(errorCode, `${base} contains an invalid namespace: ${namespace}`);
-        if (namespace === "herdr") {
-            if (!object(raw))
-                fail(errorCode, `${base}.herdr must be an object`);
-            if (Object.keys(raw).some((key) => key !== "enableFullyInspectableMode"))
-                fail(errorCode, `${base}.herdr contains an unsupported setting`);
-            if (raw.enableFullyInspectableMode !== undefined && typeof raw.enableFullyInspectableMode !== "boolean")
-                fail(errorCode, `${base}.herdr.enableFullyInspectableMode must be a boolean`);
-            normalized.herdr = Object.freeze({ ...(raw.enableFullyInspectableMode === undefined ? {} : { enableFullyInspectableMode: raw.enableFullyInspectableMode }) });
-            continue;
-        }
-        if (namespace === "trajectory") {
-            if (!object(raw))
-                fail(errorCode, `${base}.trajectory must be an object`);
-            if (Object.keys(raw).some((key) => key !== "port" && key !== "themes"))
-                fail(errorCode, `${base}.trajectory contains an unsupported setting`);
-            if (raw.port !== undefined && (!positiveInteger(raw.port) || raw.port > 65535))
-                fail(errorCode, `${base}.trajectory.port must be an integer from 1 to 65535`);
-            if (raw.themes !== undefined && typeof raw.themes !== "boolean")
-                fail(errorCode, `${base}.trajectory.themes must be a boolean`);
-            normalized.trajectory = Object.freeze({ ...(raw.port === undefined ? {} : { port: raw.port }), ...(raw.themes === undefined ? (applyDefaults ? { themes: false } : {}) : { themes: raw.themes }) });
-            continue;
-        }
-        if (!jsonValue(raw))
-            fail(errorCode, `${base}.${namespace} must be JSON-compatible`);
-        normalized[namespace] = structuredClone(raw);
-    }
-    return deepFreeze(normalized);
-}
-function positiveRetentionInteger(value) { return positiveInteger(value) && Number.isSafeInteger(value); }
-function validateRetention(value, settingsPath) {
-    if (value === undefined)
-        return undefined;
-    const base = `${settingsPath}.retention`;
-    if (!object(value))
-        fail("INVALID_SETTINGS", `${base} must be an object`);
-    const unknown = Object.keys(value).find((key) => key !== "olderThanDays" && key !== "maxTerminalRuns");
-    if (unknown)
-        fail("INVALID_SETTINGS", `Unknown retention setting at ${base}: ${unknown}`);
-    if (value.olderThanDays !== undefined && !positiveRetentionInteger(value.olderThanDays))
-        fail("INVALID_SETTINGS", `${base}.olderThanDays must be a positive integer`);
-    if (value.maxTerminalRuns !== undefined && !positiveRetentionInteger(value.maxTerminalRuns))
-        fail("INVALID_SETTINGS", `${base}.maxTerminalRuns must be a positive integer`);
-    return Object.freeze({ ...(value.olderThanDays === undefined ? {} : { olderThanDays: value.olderThanDays }), ...(value.maxTerminalRuns === undefined ? {} : { maxTerminalRuns: value.maxTerminalRuns }) });
-}
-function parseSettings(path, partial) {
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch (error) {
-        if (isNodeError(error, "ENOENT"))
-            return partial ? Object.freeze({}) : DEFAULT_SETTINGS;
-        fail("CONFIG_ERROR", `Invalid workflow settings JSON at ${path}: ${errorText(error)}`);
-    }
-    if (!object(parsed))
-        fail("INVALID_SETTINGS", `Workflow settings at ${path} must be an object`);
-    const allowed = new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...(partial ? [] : ["backgroundWidget"])]);
-    const unknown = Object.keys(parsed).find((key) => !allowed.has(key));
-    if (Object.prototype.hasOwnProperty.call(parsed, "disabledAgentResources"))
-        fail("INVALID_SETTINGS", `disabledAgentResources is no longer supported; use skills, extensions, and tools selectors (settings: ${path})`);
-    if (unknown)
-        fail("INVALID_SETTINGS", `Unknown workflow setting at ${path}: ${unknown}`);
-    const concurrency = parsed.concurrency === undefined ? (partial ? undefined : DEFAULT_SETTINGS.concurrency) : parsed.concurrency;
-    if (concurrency !== undefined && (!positiveInteger(concurrency) || concurrency > 16))
-        fail("INVALID_SETTINGS", `${path}.concurrency must be an integer from 1 to 16`);
-    const backgroundWidget = parsed.backgroundWidget === undefined ? (partial ? undefined : DEFAULT_SETTINGS.backgroundWidget) : parsed.backgroundWidget;
-    if (backgroundWidget !== undefined && typeof backgroundWidget !== "boolean")
-        fail("INVALID_SETTINGS", `${path}.backgroundWidget must be a boolean`);
-    const modelAliases = parsed.modelAliases === undefined ? undefined : validateModelAliases(parsed.modelAliases, path);
-    const skills = validateSelectorList(parsed.skills, path, "skills");
-    const tools = validateSelectorList(parsed.tools, path, "tools");
-    const extensions = validateSelectorList(parsed.extensions, path, "extensions");
-    const extensionSettings = parsed.extensionSettings === undefined ? undefined : validateWorkflowExtensionSettings(parsed.extensionSettings, path, "INVALID_SETTINGS", !partial);
-    const retention = validateRetention(parsed.retention, path);
-    const worktreePostCreateCommand = validateWorktreePostCreateCommand(parsed.worktreePostCreateCommand, path);
-    return Object.freeze({
-        ...(concurrency === undefined ? {} : { concurrency }), ...(backgroundWidget === undefined ? {} : { backgroundWidget }), ...(modelAliases === undefined ? {} : { modelAliases }),
-        ...(skills === undefined ? {} : { skills }), ...(extensions === undefined ? {} : { extensions }),
-        ...(extensionSettings === undefined ? {} : { extensionSettings }), ...(tools === undefined ? {} : { tools }), ...(retention === undefined ? {} : { retention }),
-        ...(worktreePostCreateCommand === undefined ? {} : { worktreePostCreateCommand }),
-    });
-}
-export function loadSettings(path = workflowSettingsPath()) { return parseSettings(path, false); }
-export function loadSettingsOverrides(path) { return parseSettings(path, true); }
-export function resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath = workflowSettingsPath()) {
-    const projectSettingsPath = workflowProjectSettingsPath(cwd);
-    const global = loadSettings(globalSettingsPath);
-    const project = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
-    const projectHas = (key) => Object.prototype.hasOwnProperty.call(project, key);
-    const sourceFor = (key) => projectHas(key) ? projectSettingsPath : globalSettingsPath;
-    const globalSelectors = selectorsFromSettings(global);
-    const projectSelectors = selectorsFromSettings(project);
-    const effectiveSelectors = selectorSet({
-        skills: [...(globalSelectors.skills ?? []), ...(projectSelectors.skills ?? [])],
-        extensions: [...(globalSelectors.extensions ?? []), ...(projectSelectors.extensions ?? [])],
-        ...(globalSelectors.tools === undefined && projectSelectors.tools === undefined ? {} : { tools: [...(globalSelectors.tools ?? []), ...(projectSelectors.tools ?? [])] }),
-    });
-    const hasExtensionSelectors = global.extensions !== undefined || project.extensions !== undefined;
-    const extensionSettings = projectHas("extensionSettings") ? project.extensionSettings : global.extensionSettings;
-    const sources = {
-        concurrency: projectHas("concurrency") ? projectSettingsPath : globalSettingsPath,
-        modelAliases: projectHas("modelAliases") ? projectSettingsPath : globalSettingsPath,
-        skills: sourceFor("skills"), extensions: sourceFor("extensions"), tools: sourceFor("tools"),
-        ...(extensionSettings === undefined ? {} : { extensionSettings: projectHas("extensionSettings") ? projectSettingsPath : globalSettingsPath }),
-        ...(project.retention === undefined && global.retention === undefined ? {} : { retention: project.retention === undefined ? globalSettingsPath : projectSettingsPath }),
-        ...(projectHas("worktreePostCreateCommand") || global.worktreePostCreateCommand !== undefined ? { worktreePostCreateCommand: projectHas("worktreePostCreateCommand") ? projectSettingsPath : globalSettingsPath } : {}),
-    };
-    const effective = Object.freeze({
-        concurrency: project.concurrency ?? global.concurrency,
-        backgroundWidget: global.backgroundWidget ?? true,
-        ...(projectHas("modelAliases") ? { modelAliases: project.modelAliases } : global.modelAliases === undefined ? {} : { modelAliases: global.modelAliases }),
-        ...(effectiveSelectors.skills.length ? { skills: effectiveSelectors.skills } : global.skills !== undefined || project.skills !== undefined ? { skills: effectiveSelectors.skills } : {}),
-        ...(hasExtensionSelectors ? { extensions: effectiveSelectors.extensions } : {}),
-        ...(extensionSettings === undefined ? {} : { extensionSettings }),
-        ...(effectiveSelectors.tools?.length ? { tools: effectiveSelectors.tools } : global.tools !== undefined || project.tools !== undefined ? { tools: effectiveSelectors.tools } : {}),
-        ...((project.retention ?? global.retention) === undefined ? {} : { retention: project.retention ?? global.retention }),
-        ...(projectHas("worktreePostCreateCommand") ? { worktreePostCreateCommand: project.worktreePostCreateCommand } : global.worktreePostCreateCommand === undefined ? {} : { worktreePostCreateCommand: global.worktreePostCreateCommand }),
-    });
-    return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources };
-}
-export function validateModelAliasAvailability(aliases, names, availableModels, knownModels, settingsPath) {
-    for (const name of names) {
-        try {
-            const target = modelCapability(name, aliases, knownModels, settingsPath);
-            if (!availableModels.has(target))
-                unknownModel(name, target, settingsPath);
-        }
-        catch (error) {
-            throw annotateModelAliasError(error, name);
-        }
-    }
-}
-export function resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath = workflowSettingsPath()) {
-    const resolved = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
-    const global = selectorSet(selectorsFromSettings(resolved.global));
-    const project = selectorSet(selectorsFromSettings(resolved.project));
-    const effective = selectorSet(selectorsFromSettings(resolved.effective));
-    return { globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted, global, project, effective, unmatchedSkills: [], unmatchedExtensions: [], unmatchedTools: [], selectorSources: { global: selectorsFromSettings(resolved.global), project: selectorsFromSettings(resolved.project) } };
-}
-export function saveModelAliases(path = workflowSettingsPath(), aliases = {}) {
-    const normalized = validateModelAliases(aliases, path);
-    let parsed = {};
-    try {
-        loadSettings(path);
-        parsed = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch (error) {
-        if (!isNodeError(error, "ENOENT"))
-            throw error;
-    }
-    if (!object(parsed))
-        fail("INVALID_SETTINGS", `Workflow settings at ${path} must be an object`);
-    mkdirSync(dirname(path), { recursive: true });
-    atomicWriteFile(path, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, true);
-}
-export function parseRoleMarkdown(content, strict = false, rolePath) {
-    if (!strict) {
-        if (!content.startsWith("---\n"))
-            return { prompt: content };
-        const end = content.indexOf("\n---", 4);
-        if (end < 0)
-            return { prompt: content };
-        const meta = {};
-        for (const line of content.slice(4, end).split("\n")) {
-            const match = /^(model|tools|skills|extensions|description|overrideSystemPrompt|override_system_prompt|is_system_prompt|contextFiles|extensionSettings|disabledAgentResources|thinking)\s*:\s*(.+)$/.exec(line.trim());
-            if (match?.[1] === "disabledAgentResources")
-                fail("INVALID_METADATA", "disabledAgentResources is no longer supported; use skills, extensions, and tools selectors");
-            if (match?.[1] === "thinking")
-                fail("INVALID_METADATA", "Role thinking is not supported; put it on model as provider/model:thinking");
-            if (match?.[1] && match[2])
-                meta[match[1]] = match[2].trim();
-        }
-        const unquote = (v) => v.replace(/^['"]|['"]$/g, "");
-        const parseList = (value) => value === undefined ? undefined : value.replace(/^\[|\]$/g, "").split(",").map((entry) => unquote(entry.trim())).filter(Boolean);
-        const tools = parseList(meta.tools);
-        const skills = parseList(meta.skills);
-        const extensions = parseList(meta.extensions);
-        let extensionSettings;
-        if (meta.extensionSettings !== undefined) {
-            try {
-                extensionSettings = JSON.parse(meta.extensionSettings);
-            }
-            catch (error) {
-                fail("INVALID_METADATA", `Invalid role extensionSettings: ${errorText(error)}`);
-            }
-        }
-        const rolePathValue = rolePath ?? "<role>";
-        const normalizedExtensionSettings = validateWorkflowExtensionSettings(extensionSettings, rolePathValue, "INVALID_METADATA", false);
-        const definition = { prompt: content.slice(end + 4).replace(/^\n/, "") };
-        if (meta.model) {
-            const model = unquote(meta.model);
-            assertModelThinking(model, "Role model");
-            definition.model = model;
-        }
-        if (meta.description)
-            definition.description = unquote(meta.description);
-        if (tools)
-            definition.tools = tools;
-        if (skills)
-            definition.skills = skills;
-        if (extensions)
-            definition.extensions = extensions;
-        if (normalizedExtensionSettings !== undefined)
-            definition.extensionSettings = normalizedExtensionSettings;
-        const overrideSystemPrompt = meta.overrideSystemPrompt ?? meta.override_system_prompt ?? meta.is_system_prompt;
-        const contextFiles = meta.contextFiles ? meta.contextFiles.replace(/^\[|\]$/g, "").split(",").map((scope) => unquote(scope.trim())).filter(Boolean) : undefined;
-        const normalizedContextFiles = validateContextFileScopes(contextFiles, "role");
-        if (overrideSystemPrompt)
-            definition.overrideSystemPrompt = overrideSystemPrompt === "true";
-        if (normalizedContextFiles)
-            definition.contextFiles = normalizedContextFiles;
-        return definition;
-    }
-    const normalized = content.replace(/\r\n?/g, "\n");
-    if (normalized.startsWith("---\n") && normalized.indexOf("\n---", 3) < 0)
-        fail("INVALID_METADATA", "Role frontmatter is missing its closing delimiter");
-    let parsed;
-    try {
-        parsed = parseFrontmatter(content);
-    }
-    catch (error) {
-        fail("INVALID_METADATA", `Invalid role frontmatter: ${errorText(error)}`);
-    }
-    if (!object(parsed.frontmatter))
-        fail("INVALID_METADATA", "Role frontmatter must be an object");
-    const { model, tools, skills, extensions, extensionSettings, description, contextFiles } = parsed.frontmatter;
-    if (Object.prototype.hasOwnProperty.call(parsed.frontmatter, "disabledAgentResources"))
-        fail("INVALID_METADATA", "disabledAgentResources is no longer supported; use skills, extensions, and tools selectors");
-    if (Object.prototype.hasOwnProperty.call(parsed.frontmatter, "thinking"))
-        fail("INVALID_METADATA", "Role thinking is not supported; put it on model as provider/model:thinking");
-    const overrideSystemPrompt = parsed.frontmatter.overrideSystemPrompt ?? parsed.frontmatter.override_system_prompt ?? parsed.frontmatter.is_system_prompt;
-    if (model !== undefined && (typeof model !== "string" || model.trim() === ""))
-        fail("INVALID_METADATA", "Role model must be a non-empty string");
-    if (description !== undefined && (typeof description !== "string" || description.trim() === "" || description.length > 1024 || /[\r\n]/.test(description)))
-        fail("INVALID_METADATA", "Role description must be a non-empty single-line string of at most 1024 characters");
-    if (overrideSystemPrompt !== undefined && typeof overrideSystemPrompt !== "boolean")
-        fail("INVALID_METADATA", "Role overrideSystemPrompt must be a boolean");
-    const normalizedContextFiles = validateContextFileScopes(contextFiles, rolePath ?? "<role>");
-    const rolePathValue = rolePath ?? "<role>";
-    const normalizedTools = validateSelectorList(tools, rolePathValue, "tools", "INVALID_METADATA");
-    const normalizedSkills = validateSelectorList(skills, rolePathValue, "skills", "INVALID_METADATA");
-    const normalizedExtensions = validateSelectorList(extensions, rolePathValue, "extensions", "INVALID_METADATA");
-    const normalizedExtensionSettings = validateWorkflowExtensionSettings(extensionSettings, rolePathValue, "INVALID_METADATA", false);
-    const normalizedDescription = typeof description === "string" ? description.trim() : undefined;
-    const normalizedModel = typeof model === "string" ? model.trim() : undefined;
-    if (normalizedModel !== undefined)
-        assertModelThinking(normalizedModel, "Role model");
-    const definition = { prompt: parsed.body };
-    if (normalizedDescription !== undefined)
-        definition.description = normalizedDescription;
-    if (normalizedModel !== undefined)
-        definition.model = normalizedModel;
-    if (normalizedTools !== undefined)
-        definition.tools = normalizedTools;
-    if (normalizedSkills !== undefined)
-        definition.skills = normalizedSkills;
-    if (normalizedExtensions !== undefined)
-        definition.extensions = normalizedExtensions;
-    if (normalizedExtensionSettings !== undefined)
-        definition.extensionSettings = normalizedExtensionSettings;
-    if (typeof overrideSystemPrompt === "boolean")
-        definition.overrideSystemPrompt = overrideSystemPrompt;
-    if (normalizedContextFiles !== undefined)
-        definition.contextFiles = normalizedContextFiles;
-    return definition;
-}
-const ROLE_DIRECTORY = "pi-extensible-workflows";
-export function workflowRoleDirectories(agentDir = getAgentDir()) {
-    return [join(agentDir, ROLE_DIRECTORY, "roles")];
-}
-function projectRoleDirectories(root) {
-    return [join(root, ROLE_DIRECTORY, "roles")];
-}
-function roleDirectorySources(dirs) {
-    const seen = new Set();
-    return dirs.flatMap((value) => {
-        const source = typeof value === "string" ? { path: value } : { path: value.path, extension: value.extension, ...(value.builtin === true ? { builtin: true } : {}) };
-        if (seen.has(source.path))
-            return [];
-        seen.add(source.path);
-        return [source];
-    });
-}
-function roleDirectoryLabel(source, extension = true) {
-    return source.extension ? `Extension "${source.extension.headline}" (${source.extension.version})` : extension ? "Registered workflow extension" : "Standard workflow";
-}
-function isRoleFile(dir, entry) {
-    if (extname(entry.name) !== ".md")
-        return false;
-    if (entry.isFile())
-        return true;
-    if (!entry.isSymbolicLink())
-        return false;
-    try {
-        return statSync(join(dir, entry.name)).isFile();
-    }
-    catch (error) {
-        if (isNodeError(error, "ENOENT"))
-            return false;
-        throw error;
-    }
-}
-function scanRoleFiles(dirs, extension) {
-    const files = [];
-    for (const source of roleDirectorySources(dirs)) {
-        let entries;
-        try {
-            entries = readdirSync(source.path, { withFileTypes: true });
-        }
-        catch (error) {
-            if (!extension && isNodeError(error, "ENOENT"))
-                continue;
-            fail("INVALID_METADATA", `${roleDirectoryLabel(source, extension)} role directory "${source.path}" could not be scanned: ${errorText(error)}`);
-        }
-        for (const entry of entries)
-            if (isRoleFile(source.path, entry))
-                files.push({ name: basename(entry.name, ".md"), path: join(source.path, entry.name), source });
-    }
-    return files.sort((left, right) => left.name.localeCompare(right.name) || left.path.localeCompare(right.path));
-}
-function readRoleDefinitions(dirs, extension = false) {
-    const files = scanRoleFiles(dirs, extension);
-    const starterFiles = files.filter(({ source }) => source.builtin === true);
-    const regularFiles = files.filter(({ source }) => source.builtin !== true);
-    if (extension) {
-        const byName = new Map();
-        for (const file of regularFiles)
-            byName.set(file.name, [...(byName.get(file.name) ?? []), file]);
-        for (const [name, matches] of byName)
-            if (matches.length > 1)
-                fail("INVALID_METADATA", `Duplicate extension role "${name}": ${matches.map(({ path, source }) => `${roleDirectoryLabel(source)} role directory "${source.path}" (${path})`).join("; ")}`);
-    }
-    const read = (roleFiles) => Object.fromEntries(roleFiles.map(({ name, path, source }) => {
-        try {
-            return [name, parseRoleMarkdown(readFileSync(path, "utf8"), true, path)];
-        }
-        catch (error) {
-            if (extension)
-                fail("INVALID_METADATA", `${roleDirectoryLabel(source)} role directory "${source.path}" contains invalid role "${name}" at "${path}": ${errorText(error)}`);
-            throw error;
-        }
-    }));
-    return extension ? { ...read(starterFiles), ...read(regularFiles) } : read(files);
-}
-export function loadProjectAgentDefinitions(cwd) { return readRoleDefinitions(projectRoleDirectories(join(cwd, ".pi"))); }
-export function loadAgentDefinitions(cwd, agentDir = getAgentDir(), projectTrusted = true, extensionRoleDirectories = registeredWorkflowRoleDirectoryRegistrations()) {
-    return deepFreeze({ ...readRoleDefinitions(extensionRoleDirectories, true), ...readRoleDefinitions(workflowRoleDirectories(agentDir)), ...(projectTrusted ? readRoleDefinitions(projectRoleDirectories(join(cwd, ".pi"))) : {}) });
-}
 function validateRolePolicies(definitions, roles, availableModels, aliases = {}, knownModels = availableModels, settingsPath) {
     for (const role of roles) {
         const definition = definitions[role];
@@ -767,16 +328,6 @@ export function workflowPrompt(template, values) {
         return typeof value === "string" ? value : JSON.stringify(value, null, 2);
     });
 }
-export function validateSchema(schema, at = "schema") {
-    if (!object(schema) || Object.getPrototypeOf(schema) !== Object.prototype || !jsonValue(schema))
-        fail("INVALID_SCHEMA", `${at} must be a plain JSON-compatible Schema object`);
-    if (typeof schema.type !== "string" && !Array.isArray(schema.type) && schema.$ref === undefined && schema.anyOf === undefined && schema.oneOf === undefined && schema.allOf === undefined && schema.const === undefined && schema.enum === undefined)
-        fail("INVALID_SCHEMA", `${at} has no JSON Schema shape`);
-    if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string")))
-        fail("INVALID_SCHEMA", `${at}.required must be an array of strings`);
-    if (schema.properties !== undefined && !object(schema.properties))
-        fail("INVALID_SCHEMA", `${at}.properties must be an object`);
-}
 const AGENT_OPTION_KEYS = new Set(["label", "model", "tools", "skills", "extensions", "contextFiles", "role", "outputSchema", "retries", "timeoutMs"]);
 function validateAgentOption(key, value, aliases, knownModels, settingsPath) {
     switch (key) {