@piewf/cli 5.0.0 → 5.1.1

package/dist/src/bundles.js

@@ -328,6 +328,8 @@ function roleMarkdown(role) {
         metadata.push(`tools: ${JSON.stringify(role.tools)}`);
     if (role.overrideSystemPrompt !== undefined)
         metadata.push(`overrideSystemPrompt: ${String(role.overrideSystemPrompt)}`);
+    if (role.contextFiles !== undefined)
+        metadata.push(`contextFiles: ${JSON.stringify(role.contextFiles)}`);
     if (role.disabledAgentResources !== undefined)
         metadata.push(`disabledAgentResources: ${JSON.stringify(role.disabledAgentResources)}`);
     metadata.push("---");

package/dist/src/cli.d.ts

@@ -15,5 +15,9 @@ export interface CliOptions extends DoctorOptions {
 }
 export declare function formatWorkflowCliHelp(fn: WorkflowCatalogFunction, command?: string): string;
 export declare function parseWorkflowCliArgs(schema: JsonSchema, rawArgs: readonly string[]): Record<string, JsonValue>;
+export declare function parseDoctorArgs(rawArgs: readonly string[]): {
+    role?: string;
+    prompt?: string;
+};
 export declare function parseDoctorCleanupArgs(rawArgs: readonly string[]): Required<Pick<DoctorCleanupOptions, "olderThanDays" | "yes">>;
 export declare function runCli(args: readonly string[], options?: CliOptions, write?: (text: string) => void): Promise<number>;

package/dist/src/cli.js

@@ -218,6 +218,41 @@ function parseInspectArgs(rawArgs) {
     }
     return { ...(sessionId ? { sessionId } : {}), mode: failedOnly && mode === "tui" ? "summary" : mode, failedOnly };
 }
+export function parseDoctorArgs(rawArgs) {
+    let role;
+    let prompt;
+    for (let index = 0; index < rawArgs.length; index += 1) {
+        const token = rawArgs[index];
+        const equals = token.indexOf("=");
+        const option = equals >= 0 ? token.slice(0, equals) : token;
+        if (option === "--role" || option === "--prompt") {
+            const value = equals >= 0 ? token.slice(equals + 1) : rawArgs[++index];
+            if (!value)
+                throw new Error(`Missing value for ${option}`);
+            if (option === "--role") {
+                if (role !== undefined)
+                    throw new Error("--role may only be provided once");
+                role = value;
+            }
+            else {
+                if (prompt !== undefined)
+                    throw new Error("--prompt may only be provided once");
+                prompt = value;
+            }
+            continue;
+        }
+        if (token === "--help" || token === "-h")
+            throw new Error("help");
+        if (token.startsWith("--"))
+            throw new Error(`Unknown doctor option: ${token}`);
+        if (role !== undefined)
+            throw new Error(`Unexpected argument: ${token}`);
+        role = token;
+    }
+    if (prompt !== undefined && role === undefined)
+        throw new Error("--prompt requires --role");
+    return { ...(role === undefined ? {} : { role }), ...(prompt === undefined ? {} : { prompt }) };
+}
 export function parseDoctorCleanupArgs(rawArgs) {
     let olderThanDays = 90;
     let yes = false;
@@ -360,8 +395,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 let cli;
-try { cli = await import(import.meta.resolve("@piewf/cli")); } catch {}
-if (!cli) try { cli = await import(pathToFileURL(join(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "npm", "node_modules", "@piewf/cli", "dist", "src", "cli.js")).href); } catch {}
+try { cli = await import(pathToFileURL(join(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "npm", "node_modules", "@piewf/cli", "dist", "src", "cli.js")).href); } catch {}
+if (!cli) try { cli = await import(import.meta.resolve("@piewf/cli")); } catch {}
 if (cli) process.exitCode = await cli.runCli(["run", ${JSON.stringify(workflowName)}, ...process.argv.slice(2)]);
 else { const result = spawnSync("piewf", ["run", ${JSON.stringify(workflowName)}, ...process.argv.slice(2)], { stdio: "inherit" }); if (result.error) { console.error("Could not resolve @piewf/cli; install it or put piewf on PATH."); process.exitCode = 1; } else process.exitCode = result.status ?? 1; }
 `;
@@ -674,10 +709,21 @@ async function bundleWorkflowCli(rawArgs, options) {
 }
 export async function runCli(args, options = {}, write = (text) => { process.stdout.write(text); }) {
     const stderr = options.stderr ?? ((text) => { process.stderr.write(text); });
-    if (args[0] === "doctor" && args.length === 1) {
-        const report = await doctor(options);
-        write(formatDoctorReport(report));
-        return doctorExitCode(report);
+    if (args[0] === "doctor" && args[1] !== "cleanup") {
+        if (args.slice(1).some((arg) => arg === "--help" || arg === "-h")) {
+            write("Usage: piewf doctor [role] [--role <role>] [--prompt <text>]\n");
+            return 0;
+        }
+        try {
+            const parsed = parseDoctorArgs(args.slice(1));
+            const report = await doctor({ ...options, ...parsed });
+            write(formatDoctorReport(report));
+            return doctorExitCode(report);
+        }
+        catch (error) {
+            stderr(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
     }
     if (args[0] === "doctor" && args[1] === "cleanup") {
         if (args.slice(2).some((arg) => arg === "--help" || arg === "-h")) {
@@ -735,7 +781,7 @@ export async function runCli(args, options = {}, write = (text) => { process.std
             return 1;
         }
     }
-    write("Usage: piewf doctor | inspect [session-id] [--json|--summary] [--failed] | transcript <session-file> | bundle <workflow-name> [--name <command>] [--output <path>] [--force] | run <workflow-name> [workflow arguments] | export <workflow-name> [--name <command>] [--output <path>] [--force] [--bundle]\n");
+    write("Usage: piewf doctor [role] [--role <role>] [--prompt <text>] | inspect [session-id] [--json|--summary] [--failed] | transcript <session-file> | bundle <workflow-name> [--name <command>] [--output <path>] [--force] | run <workflow-name> [workflow arguments] | export <workflow-name> [--name <command>] [--output <path>] [--force] [--bundle]\n");
     return 1;
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {

package/dist/src/doctor-cleanup.js

@@ -50,9 +50,33 @@ function agentDefinition(value, label) { if (!object(value))
     throw new Error(`${label} is invalid`); optionalString(value.prompt, `${label}.prompt`); optionalString(value.description, `${label}.description`); optionalString(value.model, `${label}.model`); if (value.thinking !== undefined && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value.thinking))
     throw new Error(`${label}.thinking is invalid`); if (value.tools !== undefined)
     stringList(value.tools, `${label}.tools`); resourceExclusions(value.disabledAgentResources, `${label}.disabledAgentResources`); }
+function optionalRole(value, label) {
+    if (value === undefined)
+        return;
+    if (typeof value === "string") {
+        if (!value.trim())
+            throw new Error(`${label} is invalid`);
+        return;
+    }
+    if (!object(value) || typeof value.name !== "string" || !value.name.trim())
+        throw new Error(`${label} is invalid`);
+    for (const key of ["model", "description"])
+        if (value[key] !== undefined && value[key] !== null && typeof value[key] !== "string")
+            throw new Error(`${label}.${key} is invalid`);
+    if (value.thinking !== undefined && value.thinking !== null && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value.thinking))
+        throw new Error(`${label}.thinking is invalid`);
+    if (value.tools !== undefined && value.tools !== null)
+        stringList(value.tools, `${label}.tools`);
+    if (value.overrideSystemPrompt !== undefined && value.overrideSystemPrompt !== null && typeof value.overrideSystemPrompt !== "boolean")
+        throw new Error(`${label}.overrideSystemPrompt is invalid`);
+    if (value.contextFiles !== undefined && value.contextFiles !== null)
+        stringList(value.contextFiles, `${label}.contextFiles`);
+    if (value.disabledAgentResources !== undefined && value.disabledAgentResources !== null)
+        resourceExclusions(value.disabledAgentResources, `${label}.disabledAgentResources`);
+}
 function validateScheduledOptions(value, label) { if (!object(value) || typeof value.label !== "string" || !value.label || typeof value.cwd !== "string" || !value.cwd)
     throw new Error(`${label} is invalid`); optionalString(value.requestedLabel, `${label}.requestedLabel`); optionalString(value.parentBreadcrumb, `${label}.parentBreadcrumb`); stringList(value.tools, `${label}.tools`); optionalString(value.worktreeOwner, `${label}.worktreeOwner`); optionalString(value.model, `${label}.model`); if (value.thinking !== undefined && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value.thinking))
-    throw new Error(`${label}.thinking is invalid`); optionalString(value.role, `${label}.role`); if (value.schema !== undefined)
+    throw new Error(`${label}.thinking is invalid`); optionalRole(value.role, `${label}.role`); if (value.schema !== undefined)
     validateSchema(value.schema, `${label}.schema`); if (value.retries !== undefined)
     nonNegativeInteger(value.retries, `${label}.retries`); if (value.timeoutMs !== undefined && value.timeoutMs !== null)
     positiveInteger(value.timeoutMs, `${label}.timeoutMs`); if (value.agentOptions !== undefined && (!object(value.agentOptions) || !jsonValue(value.agentOptions)))

package/dist/src/doctor.d.ts

@@ -27,8 +27,42 @@ export interface DoctorTrust {
     trusted: boolean;
     source: string;
 }
+export interface DoctorRoleInspection {
+    role: string;
+    path: string;
+    model: {
+        provider: string;
+        model: string;
+        thinking?: string;
+        inherited?: boolean;
+    };
+    tools: readonly string[];
+    resources: {
+        skills: readonly string[];
+        extensions: readonly string[];
+        excludedSkills: readonly string[];
+        excludedExtensions: readonly string[];
+        unmatchedSkills: readonly string[];
+        unmatchedExtensions: readonly string[];
+    };
+    systemPrompt: {
+        probe: string;
+        expandedProbe: string;
+        text: string;
+        source?: string;
+    };
+    setup: {
+        hooks: readonly string[];
+        diagnostics: readonly DoctorDiagnostic[];
+    };
+}
 export interface DoctorPiState {
     trust: DoctorTrust;
+    model?: {
+        provider: string;
+        model: string;
+        thinking?: string;
+    };
     activeTools: readonly string[];
     knownModels: readonly string[];
     availableModels: readonly string[];
@@ -48,16 +82,22 @@ export interface DoctorReport {
     settingsSources: WorkflowSettingsSources;
     trust: DoctorTrust;
     activeTools: readonly string[];
+    piExtensions: readonly string[];
+    piSkills: readonly string[];
     roles: readonly DoctorRole[];
     functions: readonly DoctorFunction[];
     resourcePolicy: AgentResourcePolicy;
     modelAliases: readonly WorkflowCatalogModelAlias[];
+    roleTarget?: string;
+    roleInspection?: DoctorRoleInspection;
     diagnostics: readonly DoctorDiagnostic[];
 }
 export interface DoctorOptions {
     cwd?: string;
     agentDir?: string;
     settingsPath?: string;
+    role?: string;
+    prompt?: string;
     discoverPi?: (cwd: string, agentDir: string) => Promise<DoctorPiState>;
     activeTools?: readonly string[];
     registry?: WorkflowRegistryApi;

package/dist/src/doctor.js

@@ -2,7 +2,7 @@ import { readFileSync, readdirSync, realpathSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import { ModelRuntime, createAgentSessionFromServices, createAgentSessionServices, getAgentDir, hasTrustRequiringProjectResources, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_SETTINGS, loadSettings, resolveAgentResourcePolicy, resolveWorkflowSettings, resolveModelReference, parseThinking, parseRoleMarkdown, registeredWorkflowFunctions, registeredWorkflowRoleDirectoryRegistrations, workflowRoleDirectories, workflowProjectSettingsPath, workflowSettingsPath, } from "pi-extensible-workflows";
+import { DEFAULT_SETTINGS, createLocalPiSession, loadSettings, prepareAgentSetupForInspection, resolveAgentResourcePolicy, resolveWorkflowSettings, resolveModelReference, parseThinking, parseRoleMarkdown, registeredWorkflowFunctions, registeredWorkflowRoleDirectoryRegistrations, workflowRoleDirectories, workflowProjectSettingsPath, workflowSettingsPath, } from "pi-extensible-workflows";
 import { loadingRegistry } from "pi-extensible-workflows";
 import { disabledResources, unmatchedResourcePatterns } from "pi-extensible-workflows";
 const THINKING_HINT = "Use off, minimal, low, medium, high, xhigh, or max.";
@@ -86,6 +86,7 @@ async function discoverPi(cwd, agentDir) {
         const skills = services.resourceLoader.getSkills().skills;
         return {
             trust: { required, trusted, source },
+            model: { provider: model.provider, model: model.id, thinking: session.thinkingLevel },
             activeTools,
             knownModels: allModels.map(({ provider, id }) => `${provider}/${id}`),
             availableModels: availableModels.map(({ provider, id }) => `${provider}/${id}`),
@@ -184,7 +185,7 @@ function inspectRole(path, activeTools, knownModels, availableModels, diagnostic
         validateModel(definition.model, knownModels, availableModels, path, diagnostics, aliases, dynamicAliases, settingsPath);
     for (const tool of definition.tools ?? [])
         if (!activeTools.has(tool))
-            diagnostics.push(diagnostic("error", "ROLE_TOOL_INACTIVE", `Tool is unknown or inactive: ${tool}`, path, "Use a tool listed under Active tools or enable its Pi extension."));
+            diagnostics.push(diagnostic("error", "ROLE_TOOL_INACTIVE", `Tool is unknown or inactive: ${tool}`, path, "Use a tool listed under Pi active tools or enable its Pi extension."));
     return definition;
 }
 function matchResourcePolicy(policy, pi) {
@@ -192,6 +193,60 @@ function matchResourcePolicy(policy, pi) {
     const skills = [...new Set(pi.skills ?? [])];
     return { ...policy, excludedSkills: disabledResources(policy.effective.skills, skills), excludedExtensions: disabledResources(policy.effective.extensions, extensions), unmatchedSkills: unmatchedResourcePatterns(policy.effective.skills, skills), unmatchedExtensions: unmatchedResourcePatterns(policy.effective.extensions, extensions) };
 }
+async function inspectRoleSession(cwd, agentDir, roleName, definition, rolePath, basePolicy, rootModel, activeTools, aliases, knownModels, availableModels, settingsPath, prompt, hooks, diagnostics) {
+    const setupDiagnostics = [];
+    const signal = new AbortController().signal;
+    const transport = { id: "doctor-local", createSession: async () => { throw new Error("Doctor inspection does not create transport sessions"); } };
+    const run = { cwd, sessionId: "doctor", runId: "doctor", workflow: { name: "doctor" }, args: null, signal };
+    const root = { cwd, model: { ...rootModel }, tools: new Set(activeTools), agentDefinitions: { [roleName]: definition }, agentDir, modelAliases: aliases, knownModels, availableModels, settingsPath, agentSetupHooks: hooks, agentResourcePolicy: () => structuredClone(basePolicy), runContext: run };
+    const options = { label: roleName, workflowName: "doctor", role: roleName };
+    let prepared;
+    try {
+        prepared = await prepareAgentSetupForInspection(root, prompt, options, transport);
+    }
+    catch (error) {
+        setupDiagnostics.push(diagnostic("error", "ROLE_INSPECTION", error instanceof Error ? error.message : String(error), rolePath));
+        diagnostics.push(...setupDiagnostics);
+        return undefined;
+    }
+    if (prepared.failure) {
+        const error = prepared.failure.error;
+        const code = prepared.failure.hook ? "ROLE_SETUP_HOOK" : "ROLE_INSPECTION";
+        setupDiagnostics.push(diagnostic("error", code, `${prepared.failure.hook ? `Role setup hook ${prepared.failure.hook} failed: ` : ""}${error instanceof Error ? error.message : String(error)}`, prepared.failure.hook ?? rolePath));
+        diagnostics.push(...setupDiagnostics);
+        return undefined;
+    }
+    const session = await (async () => { try {
+        return await createLocalPiSession({ ...prepared.setup.sessionInput, sessionManager: SessionManager.inMemory() });
+    }
+    catch (error) {
+        setupDiagnostics.push(diagnostic("error", "ROLE_INSPECTION", error instanceof Error ? error.message : String(error), rolePath));
+        return undefined;
+    } })();
+    if (!session) {
+        diagnostics.push(...setupDiagnostics);
+        return undefined;
+    }
+    try {
+        const promptResult = await session.preparePrompt(prompt);
+        const resources = session.getResourceInspection();
+        const state = session.agent?.state;
+        const inherited = prepared.setup.sessionInput.model.provider === rootModel.provider && prepared.setup.sessionInput.model.model === rootModel.model && prepared.setup.sessionInput.model.thinking === rootModel.thinking;
+        const actualModel = session.model?.provider && (session.model.model ?? session.model.id) ? { provider: session.model.provider, model: session.model.model ?? session.model.id ?? prepared.setup.sessionInput.model.model, ...(session.thinkingLevel ? { thinking: session.thinkingLevel } : {}), ...(inherited ? { inherited: true } : {}) } : { ...prepared.setup.sessionInput.model, ...(inherited ? { inherited: true } : {}) };
+        const policy = prepared.setup.sessionInput.resourcePolicy ?? basePolicy;
+        for (const item of [...resources.diagnostics, ...promptResult.diagnostics])
+            setupDiagnostics.push(diagnostic(item.type === "error" ? "error" : "warning", "ROLE_INSPECTION", item.message, item.source));
+        return { role: roleName, path: rolePath, model: actualModel, tools: state?.tools.map(({ name }) => name) ?? [...prepared.setup.sessionInput.tools], resources: { skills: resources.skills, extensions: resources.extensions, excludedSkills: policy.excludedSkills ?? [], excludedExtensions: policy.excludedExtensions ?? [], unmatchedSkills: policy.unmatchedSkills, unmatchedExtensions: policy.unmatchedExtensions }, systemPrompt: { probe: prompt, expandedProbe: promptResult.expandedPrompt, text: promptResult.systemPrompt, ...(resources.systemPromptSource ? { source: resources.systemPromptSource } : {}) }, setup: { hooks: prepared.summary.hookNames, diagnostics: setupDiagnostics } };
+    }
+    catch (error) {
+        setupDiagnostics.push(diagnostic("error", "ROLE_INSPECTION", error instanceof Error ? error.message : String(error), rolePath));
+        diagnostics.push(...setupDiagnostics);
+        return undefined;
+    }
+    finally {
+        session.dispose();
+    }
+}
 function resourcePolicySource(settingsSource) { return settingsSource; }
 export async function doctor(options = {}) {
     const cwd = canonical(options.cwd ?? process.cwd());
@@ -335,6 +390,40 @@ export async function doctor(options = {}) {
         else
             definitions.delete(name);
     }
+    let roleInspection;
+    if (options.role !== undefined) {
+        const activeRole = roles.find(({ name, active }) => name === options.role && active);
+        const definition = activeRole ? definitions.get(options.role) : undefined;
+        if (!activeRole || !definition)
+            diagnostics.push(diagnostic("error", "ROLE_NOT_FOUND", `Active role not found: ${options.role}`, options.role));
+        else {
+            const rootReference = pi.model ? `${pi.model.provider}/${pi.model.model}` : pi.availableModels[0] ?? pi.knownModels[0];
+            if (!rootReference)
+                diagnostics.push(diagnostic("error", "ROLE_INSPECTION_MODEL", "Cannot inspect a role because Pi has no registered model"));
+            else {
+                let rootModel;
+                try {
+                    if (pi.model) {
+                        const thinking = parseThinking(pi.model.thinking);
+                        rootModel = { provider: pi.model.provider, model: pi.model.model, ...(thinking ? { thinking } : {}) };
+                    }
+                    else
+                        rootModel = resolveModelReference(rootReference, aliases, knownModels, settingsPath);
+                    let roleAliases = aliases;
+                    if (definition.model && isDynamicModelAlias(definition.model, dynamicAliases)) {
+                        const dynamic = await registry.resolveModelAliases({ cwd, projectTrusted: pi.trust.trusted, rootModel, knownModels, availableModels, signal: new AbortController().signal });
+                        roleAliases = { ...aliases, ...dynamic };
+                    }
+                    roleInspection = await inspectRoleSession(cwd, agentDir, options.role, definition, activeRole.path, resourcePolicy, rootModel, [...activeTools], roleAliases, knownModels, availableModels, settingsPath, options.prompt ?? "", registry.agentSetupHooks(), diagnostics);
+                    if (roleInspection)
+                        diagnostics.push(...roleInspection.setup.diagnostics);
+                }
+                catch (error) {
+                    diagnostics.push(diagnostic("error", "ROLE_INSPECTION_MODEL", error instanceof Error ? error.message : String(error), activeRole.path));
+                }
+            }
+        }
+    }
     const functions = [];
     for (const [name, fn] of Object.entries(pi.functions).sort(([left], [right]) => left.localeCompare(right))) {
         functions.push({ name, description: fn.description, valid: true });
@@ -342,11 +431,55 @@ export async function doctor(options = {}) {
     const severityOrder = { error: 0, warning: 1 };
     diagnostics.sort((left, right) => severityOrder[left.severity] - severityOrder[right.severity] || (left.source ?? "").localeCompare(right.source ?? "") || left.code.localeCompare(right.code) || left.message.localeCompare(right.message));
     roles.sort((left, right) => left.name.localeCompare(right.name) || left.scope.localeCompare(right.scope));
-    return { cwd, agentDir, settingsPath, settings, settingsSources, trust: pi.trust, activeTools: [...activeTools].sort(), roles, functions, modelAliases, resourcePolicy, diagnostics };
+    return { cwd, agentDir, settingsPath, settings, settingsSources, trust: pi.trust, activeTools: [...activeTools].sort(), piExtensions: [...new Set((pi.extensions ?? []).map(canonical))].sort(), piSkills: [...new Set(pi.skills ?? [])].sort(), roles, functions, modelAliases, resourcePolicy, ...(options.role !== undefined ? { roleTarget: options.role } : {}), ...(roleInspection ? { roleInspection } : {}), diagnostics };
 }
 function count(report, severity) { return report.diagnostics.filter((item) => item.severity === severity).length; }
 export function doctorExitCode(report) { return count(report, "error") > 0 ? 1 : 0; }
+function exposedValues(values, excluded) {
+    const disabled = new Set(excluded);
+    return values.filter((value) => !disabled.has(value));
+}
+function nestedValues(label, values) {
+    return [`- ${label}:`, ...(values.length ? values.map((value) => `  - \`${value}\``) : ["  - (none)"])];
+}
+function roleInspectionLines(inspection) {
+    return [
+        `- Role: \`${inspection.role}\` - \`${inspection.path}\``,
+        `- Model: \`${inspection.model.provider}/${inspection.model.model}\` (${inspection.model.inherited ? "inherited, " : ""}${inspection.model.thinking ?? "off"})`,
+        ...nestedValues("Tools", inspection.tools),
+        ...nestedValues("Effective skills", inspection.resources.skills),
+        ...nestedValues("Effective extensions", inspection.resources.extensions),
+        ...nestedValues("Excluded skills", inspection.resources.excludedSkills),
+        ...nestedValues("Excluded extensions", inspection.resources.excludedExtensions),
+        ...nestedValues("Unmatched skills", inspection.resources.unmatchedSkills),
+        ...nestedValues("Unmatched extensions", inspection.resources.unmatchedExtensions),
+        `- Prompt probe: ${inspection.systemPrompt.probe ? JSON.stringify(inspection.systemPrompt.probe) : "empty"}`,
+        `- Expanded probe: ${JSON.stringify(inspection.systemPrompt.expandedProbe)}`,
+        `- System prompt source: ${inspection.systemPrompt.source ?? "(none)"}`,
+        "### Final system prompt",
+        "```",
+        inspection.systemPrompt.text,
+        "```",
+        ...nestedValues("Applied setup hooks", inspection.setup.hooks),
+        `- Setup diagnostics: ${String(inspection.setup.diagnostics.length)}`,
+    ];
+}
 export function formatDoctorReport(report) {
+    if (report.roleInspection || report.roleTarget !== undefined) {
+        const lines = [
+            "# pi-extensible-workflows doctor",
+            "",
+            "## Role inspection",
+            ...(report.roleInspection ? roleInspectionLines(report.roleInspection) : [`- Role: \`${report.roleTarget ?? "(unknown)"}\``, "- Inspection unavailable"]),
+            "",
+            "## Diagnostics",
+            ...(report.diagnostics.length ? report.diagnostics.map((item) => `- [${item.severity}] ${item.code}${item.source ? ` \`${item.source}\`` : ""}: ${item.message}${item.hint ? ` Fix: ${item.hint}` : ""}`) : ["- [ok] No diagnostics"]),
+            "",
+            "## Summary",
+            `- ${String(count(report, "error"))} error(s), ${String(count(report, "warning"))} warning(s)`,
+        ];
+        return `${lines.join("\n")}\n`;
+    }
     const lines = [
         "# pi-extensible-workflows doctor",
         "",
@@ -361,7 +494,16 @@ export function formatDoctorReport(report) {
         "## Trust/resources",
         `- [${report.trust.trusted ? "ok" : "warning"}] ${report.trust.source}`,
         "",
-        "## Agent resource exclusions",
+        "## Pi active tools",
+        ...(report.activeTools.length ? report.activeTools.map((tool) => `- \`${tool}\``) : ["- None resolved"]),
+        "",
+        "## Pi active extensions",
+        ...(report.piExtensions.length ? report.piExtensions.map((extension) => `- \`${extension}\``) : ["- None resolved"]),
+        "",
+        "## Pi active skills",
+        ...(report.piSkills.length ? report.piSkills.map((skill) => `- \`${skill}\``) : ["- None resolved"]),
+        "",
+        "## Workflow agent resources (after disabledAgentResources)",
         `- Global settings: \`${report.resourcePolicy.globalSettingsPath}\``,
         `- Global skills: ${report.resourcePolicy.global.skills.join(", ") || "(none)"}`,
         `- Global extensions: ${report.resourcePolicy.global.extensions.join(", ") || "(none)"}`,
@@ -370,14 +512,13 @@ export function formatDoctorReport(report) {
         `- Project extensions: ${report.resourcePolicy.project.extensions.join(", ") || "(none)"}`,
         `- Effective skills: ${report.resourcePolicy.effective.skills.join(", ") || "(none)"}`,
         `- Effective extensions: ${report.resourcePolicy.effective.extensions.join(", ") || "(none)"}`,
-        `- Excluded skills: ${report.resourcePolicy.excludedSkills?.join(", ") || "(none)"}`,
-        `- Excluded extensions: ${report.resourcePolicy.excludedExtensions?.join(", ") || "(none)"}`,
+        ...nestedValues("Exposed skills", exposedValues(report.piSkills, report.resourcePolicy.excludedSkills ?? [])),
+        ...nestedValues("Exposed extensions", exposedValues(report.piExtensions, report.resourcePolicy.excludedExtensions ?? [])),
+        ...nestedValues("Disabled skills", report.resourcePolicy.excludedSkills ?? []),
+        ...nestedValues("Disabled extensions", report.resourcePolicy.excludedExtensions ?? []),
         `- Unmatched skills: ${report.resourcePolicy.unmatchedSkills.join(", ") || "(none)"}`,
         `- Unmatched extensions: ${report.resourcePolicy.unmatchedExtensions.join(", ") || "(none)"}`,
         "",
-        "## Active tools",
-        ...(report.activeTools.length ? report.activeTools.map((tool) => `- \`${tool}\``) : ["- None resolved"]),
-        "",
         "## Roles",
         ...(report.roles.length ? report.roles.map((role) => `- \`${role.name}\` (${role.scope}, ${role.active ? "active" : role.overriddenBy ? `overridden by ${role.overriddenBy}` : "inactive: project untrusted"}) - \`${role.path}\`${role.extension ? `; ${extensionLabel(role.extension)} role directory "${dirname(role.path)}"` : ""}${role.overrides ? `; overrides \`${role.overrides}\`` : ""}`) : ["- None found"]),
         "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piewf/cli",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "description": "CLI for pi-extensible-workflows",
   "homepage": "https://vekexasia.github.io/pi-extensible-workflows/",
   "repository": {
@@ -45,7 +45,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "pi-extensible-workflows": "5.0.0"
+    "pi-extensible-workflows": "5.1.1"
   },
   "publishConfig": {
     "access": "public"