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

package/dist/src/roles.js

@@ -1,325 +0,0 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, dirname, extname, join, resolve } from "node:path";
-import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { registeredWorkflowRoleDirectoryRegistrations } from "./registry.js";
-import { resolveWorkflowSettings, validateContextFileScopes, validateSelectorList, validateWorkflowExtensionSettings, workflowSettingsPath } from "./settings.js";
-import { assertModelThinking, deepFreeze, object, errorText, fail, isNodeError, modelAliasName, modelCapability, resourcePatternHasMagic, resolveModelReference, selectResourcesByLayers, unmatchedResourcePatterns } from "./utils.js";
-import { canonicalPath } from "./paths.js";
-const ROLE_DIRECTORY = "pi-extensible-workflows";
-// Preserve the role-file base when a discovered definition is resolved again through the public API.
-const roleDefinitionPaths = new WeakMap();
-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");
-        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");
-    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;
-}
-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 roleEntries(dirs, extension) {
-    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 {
-            const definition = parseRoleMarkdown(readFileSync(path, "utf8"), true, path);
-            roleDefinitionPaths.set(definition, path);
-            return [name, { name, path, source, definition }];
-        }
-        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);
-}
-function discoveryInput(input) {
-    return { cwd: input.cwd, agentDir: input.agentDir ?? getAgentDir(), projectTrusted: input.projectTrusted ?? true, extensionRoleDirectories: input.extensionRoleDirectories ?? registeredWorkflowRoleDirectoryRegistrations() };
-}
-function discoveredRoleEntries(input) {
-    const resolved = discoveryInput(input);
-    return {
-        ...roleEntries(resolved.extensionRoleDirectories, true),
-        ...roleEntries(workflowRoleDirectories(resolved.agentDir), false),
-        ...(resolved.projectTrusted ? roleEntries(projectRoleDirectories(join(resolved.cwd, ".pi")), false) : {}),
-    };
-}
-export function loadProjectAgentDefinitions(cwd) {
-    return deepFreeze(Object.fromEntries(Object.entries(roleEntries(projectRoleDirectories(join(cwd, ".pi")), false)).map(([name, entry]) => [name, entry.definition])));
-}
-export function discoverRoles(input) {
-    return deepFreeze(Object.fromEntries(Object.entries(discoveredRoleEntries(input)).map(([name, entry]) => [name, entry.definition])));
-}
-export function loadRole(name, input) {
-    const entry = discoveredRoleEntries(input)[name];
-    if (!entry)
-        fail("UNKNOWN_AGENT_TYPE", `Unknown agent role: ${name}`);
-    return entry.definition;
-}
-export function loadAgentDefinitions(cwd, agentDir = getAgentDir(), projectTrusted = true, extensionRoleDirectories = registeredWorkflowRoleDirectoryRegistrations()) {
-    return discoverRoles({ cwd, agentDir, projectTrusted, extensionRoleDirectories });
-}
-export function canonicalExtensionSelector(selector, base = process.cwd()) {
-    const negated = selector.startsWith("!");
-    const body = negated ? selector.slice(1) : selector;
-    if (body === "*" || body === "**" || body.startsWith("**/"))
-        return selector;
-    const resolved = resolve(base, body);
-    if (resourcePatternHasMagic(body))
-        return `${negated ? "!" : ""}${resolved}`;
-    return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
-}
-function selectorsFromSettings(settings) {
-    return { ...(settings.skills === undefined ? {} : { skills: settings.skills }), ...(settings.extensions === undefined ? {} : { extensions: settings.extensions }), ...(settings.tools === undefined ? {} : { tools: settings.tools }) };
-}
-function rootToolNames(value) {
-    return value === undefined ? undefined : value instanceof Set ? [...value] : [...value];
-}
-function roleDefinitionFor(name, options) {
-    if (name === undefined)
-        return {};
-    if (options.definition !== undefined) {
-        const path = roleDefinitionPaths.get(options.definition);
-        return { definition: options.definition, ...(path === undefined ? {} : { path }) };
-    }
-    if (options.definitions?.[name] !== undefined) {
-        const definition = options.definitions[name];
-        const path = roleDefinitionPaths.get(definition);
-        return { definition, ...(path === undefined ? {} : { path }) };
-    }
-    const entries = discoveredRoleEntries(options);
-    const entry = entries[name];
-    if (!entry)
-        fail("UNKNOWN_AGENT_TYPE", `Unknown agent role: ${name}`);
-    return entry;
-}
-/** Without a supplied root/tool/resource boundary, this API reports selector layers but does not infer available resources; tools and model remain undefined when no candidates are supplied. When selector sources are supplied, model aliases default to none and blocked aliases are not applied unless provided. */
-export function resolveRole(name, options) {
-    const { definition, path } = roleDefinitionFor(name, options);
-    const settings = options.selectorSources === undefined ? resolveWorkflowSettings(options.cwd, options.projectTrusted ?? true, options.settingsPath ?? workflowSettingsPath(options.agentDir ?? getAgentDir())) : undefined;
-    const baseSources = options.selectorSources ?? { global: selectorsFromSettings(settings?.global ?? {}), project: selectorsFromSettings(settings?.project ?? {}) };
-    const canonicalSources = (sources) => ({
-        ...sources,
-        global: { ...sources.global, ...(sources.global.extensions === undefined ? {} : { extensions: sources.global.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }) },
-        project: { ...sources.project, ...(sources.project.extensions === undefined ? {} : { extensions: sources.project.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }) },
-        ...(sources.role === undefined ? {} : { role: { ...sources.role, ...(sources.role.extensions === undefined ? {} : { extensions: sources.role.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }) } }),
-        ...(sources.call === undefined ? {} : { call: { ...sources.call, ...(sources.call.extensions === undefined ? {} : { extensions: sources.call.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }) } }),
-    });
-    const roleLayer = definition?.skills !== undefined || definition?.extensions !== undefined || definition?.tools !== undefined ? { ...(definition.skills === undefined ? {} : { skills: definition.skills }), ...(definition.extensions === undefined ? {} : { extensions: definition.extensions.map((selector) => canonicalExtensionSelector(selector, path ? dirname(path) : options.cwd)) }), ...(definition.tools === undefined ? {} : { tools: definition.tools }) } : baseSources.role;
-    const callLayer = options.skills !== undefined || options.extensions !== undefined || options.tools !== undefined ? { ...(options.skills === undefined ? {} : { skills: options.skills }), ...(options.extensions === undefined ? {} : { extensions: options.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }), ...(options.tools === undefined ? {} : { tools: options.tools }) } : baseSources.call;
-    const selectorSources = canonicalSources({ global: baseSources.global, project: baseSources.project, ...(roleLayer === undefined ? {} : { role: roleLayer }), ...(callLayer === undefined ? {} : { call: callLayer }) });
-    const callSelectors = selectorSources.call;
-    const roleSelectors = selectorSources.role;
-    const selectorLayers = {
-        skills: [selectorSources.global.skills, selectorSources.project.skills, roleSelectors?.skills, callSelectors?.skills],
-        extensions: [selectorSources.global.extensions, selectorSources.project.extensions, roleSelectors?.extensions, callSelectors?.extensions],
-        tools: [selectorSources.global.tools, selectorSources.project.tools, roleSelectors?.tools, callSelectors?.tools],
-    };
-    const resources = options.resources ?? {};
-    const candidateTools = options.inheritedTools ?? rootToolNames(options.rootTools) ?? resources.tools;
-    const tools = options.effectiveTools ?? (candidateTools === undefined ? undefined : selectResourcesByLayers(selectorLayers.tools, candidateTools));
-    const rootTools = rootToolNames(options.rootTools);
-    if (rootTools !== undefined) {
-        const outsideEffectiveTool = options.effectiveTools?.find((tool) => !candidateTools?.includes(tool));
-        if (outsideEffectiveTool)
-            fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideEffectiveTool}`);
-        const outsideCallTool = (options.tools ?? []).find((tool) => !tool.startsWith("!") && !resourcePatternHasMagic(tool) && !candidateTools?.includes(tool));
-        if (outsideCallTool)
-            fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideCallTool}`);
-        const outsideRootTool = tools?.find((tool) => !rootTools.includes(tool));
-        if (outsideRootTool)
-            fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideRootTool}`);
-    }
-    const selectedSkills = resources.skills === undefined ? undefined : selectResourcesByLayers(selectorLayers.skills, resources.skills);
-    const extensionResources = resources.extensions?.map((extension) => canonicalPath(extension));
-    const selectedExtensions = extensionResources === undefined ? undefined : selectResourcesByLayers(selectorLayers.extensions, extensionResources);
-    const unmatchedSkills = resources.skills === undefined ? undefined : unmatchedResourcePatterns(selectorLayers.skills.flatMap((layer) => layer ?? []), resources.skills);
-    const unmatchedExtensions = extensionResources === undefined ? undefined : unmatchedResourcePatterns(selectorLayers.extensions.flatMap((layer) => layer ?? []), extensionResources);
-    const unmatchedTools = candidateTools === undefined ? undefined : unmatchedResourcePatterns(selectorLayers.tools.flatMap((layer) => layer ?? []), candidateTools);
-    const aliases = options.modelAliases ?? settings?.effective.modelAliases ?? {};
-    const requestedModel = options.model ?? (definition?.model && definition.thinking && !definition.model.includes(":") ? `${definition.model}:${definition.thinking}` : definition?.model);
-    const blockedAlias = requestedModel?.split(":", 1)[0];
-    if (requestedModel !== undefined && blockedAlias && options.blockedAliases?.has(blockedAlias) && !modelAliasName(requestedModel, aliases)) {
-        const target = options.blockedAliasTargets?.[blockedAlias];
-        fail("UNKNOWN_MODEL", `Unknown model alias ${requestedModel}${target ? ` resolved to ${target}` : ""}${options.settingsPath ? ` (settings: ${options.settingsPath})` : ""}`);
-    }
-    let model = options.modelOverride;
-    if (model === undefined && requestedModel !== undefined) {
-        assertModelThinking(requestedModel);
-        model = resolveModelReference(requestedModel, aliases, options.knownModels ?? options.availableModels, options.settingsPath ?? settings?.sources.modelAliases);
-    }
-    if (model === undefined)
-        model = options.rootModel;
-    const availableModels = options.knownModels ?? options.availableModels ?? (options.rootModel === undefined ? undefined : new Set([modelCapability(options.rootModel)]));
-    if (model !== undefined && availableModels !== undefined && !availableModels.has(modelCapability(model)))
-        fail("UNKNOWN_MODEL", `Unknown model${requestedModel ? ` ${requestedModel} resolved to ${modelCapability(model)}` : ""}${options.settingsPath ? ` (settings: ${options.settingsPath})` : ""}`);
-    const prompt = definition?.prompt ?? "";
-    const overrideSystemPrompt = definition?.overrideSystemPrompt === true;
-    const contextFiles = options.contextFiles ?? definition?.contextFiles;
-    return { ...(name === undefined ? {} : { name }), ...(definition === undefined ? {} : { definition }), ...(model === undefined ? {} : { model }), ...(modelAliasName(requestedModel ?? "", aliases) && requestedModel ? { requestedModel } : {}), ...(tools === undefined ? {} : { tools }), prompt, overrideSystemPrompt, systemPrompt: { mode: overrideSystemPrompt ? "override" : "append", text: prompt }, ...(contextFiles === undefined ? {} : { contextFiles: [...contextFiles] }), ...(definition?.extensionSettings === undefined ? {} : { extensionSettings: definition.extensionSettings }), selectorSources, selectorLayers, ...(selectedSkills === undefined ? {} : { selectedSkills }), ...(selectedExtensions === undefined ? {} : { selectedExtensions }), ...(unmatchedSkills === undefined ? {} : { unmatchedSkills }), ...(unmatchedExtensions === undefined ? {} : { unmatchedExtensions }), ...(unmatchedTools === undefined ? {} : { unmatchedTools }) };
-}

package/dist/starter/roles/developer.md

@@ -1,6 +0,0 @@
----
-model: developer-model
-description: Developer focused agent
----
-
-Act as a senior developer. Implement the requested task with the smallest working change. Read the relevant flow first, reuse existing project patterns, keep the change surgical, and verify the result with the smallest relevant check.

package/dist/starter/roles/oracle.md

@@ -1,18 +0,0 @@
----
-model: oracle-model
-tools: ["!*", "read", "grep", "find", "ls", "bash"]
-description: Oracle. Use for a second opinion on a plan, design, or decision before committing to it
----
-
-Give a second opinion on the presented plan, design, or decision. Do not edit files. You are not a second decision-maker; you challenge, verify, and report.
-
-Reconstruct the stated goals and constraints first, then verify the claims against the actual code, tests, and docs. Run read-only commands when they settle a question. When source contradicts the plan or its assumptions, trust source and report the conflict.
-
-Return:
-
-- The strongest challenge to the proposal, with evidence.
-- Hidden assumptions or contradictions you found.
-- What the proposal gets right and should keep.
-- A recommendation, naming any decision that still belongs to the caller.
-
-If the proposal is sound, say so plainly instead of inventing objections.

package/dist/starter/roles/researcher.md

@@ -1,20 +0,0 @@
----
-model: researcher-model
-tools: ["!edit", "!write", "!bash"]
-description: Researcher. Use for deep research across the codebase, docs, and the web when web tools are available
----
-
-Research the requested question in depth. Do not edit files.
-
-Use every read and search capability you have: code, files, docs, and any web search or fetch tools present in this session. If the question needs web evidence and no web tool is available, say so explicitly instead of guessing.
-
-Verify claims against primary sources: the actual code, official docs, or the cited page. Prefer primary sources over aggregators.
-
-Return a research brief:
-
-- Direct answer to the question.
-- Evidence per claim, citing files and lines for code and URLs for web sources.
-- Contradictions or version-specific caveats you found.
-- What is known, what is uncertain, and what would settle the open questions.
-
-Report only what you verified. Mark everything else as unverified.

package/dist/starter/roles/reviewer.md

@@ -1,19 +0,0 @@
----
-model: reviewer-model
-tools: ["!*", "read", "grep", "find", "ls"]
-description: Reviewer. Use when we need to review decisions or code changes
----
-
-Inspect the requested change for correctness, missed callers, broken assumptions, regressions, security or data-loss risk, and missing verification. Do not edit files.
-
-Filter findings on evidence, not severity: report only concrete, current issues caused or made reachable by the change, backed by source proof, a failing test or repro, or a contract contradiction. Cite exact files and lines. Ignore style unless it hides a real defect. Do not report speculative or pre-existing issues unless asked.
-
-Label each finding:
-
-- P0: blocks merge (broken behavior, data loss, security).
-- P1: should be fixed before release.
-- P2: report-only note.
-
-If nothing qualifies, say exactly `No issues found.`
-
-End with one line: `Merge verdict: BLOCK`, `Merge verdict: OK`, or `Merge verdict: OK with notes`.

package/dist/starter/roles/scout.md

@@ -1,18 +0,0 @@
----
-model: scout-model
-tools: ["!*", "read", "grep", "find", "ls"]
-description: Scout. Use for fast read-only codebase recon before planning or implementing
----
-
-Perform fast, read-only reconnaissance of the codebase for the requested question. Do not edit files.
-
-Locate the relevant files, entry points, and data flow. Trace the actual code paths instead of inferring from names. Note existing patterns, helpers, and tests the task should reuse.
-
-Return a compact brief:
-
-- Relevant files with one-line purpose each.
-- How the flow works end to end, citing files and lines.
-- Existing patterns or utilities to reuse.
-- What is known, what is uncertain, and the smallest next step.
-
-Report only what you verified in the code. Mark anything unverified as an open question. Keep output concise; no implementation plan.

package/examples/workflow-extension-template/roles/reviewer.md

@@ -1,4 +0,0 @@
----
-description: Packaged reviewer role
----
-Review the requested change carefully. Return concrete findings with file names and a next check.