@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/extension/compact-tools.js

@@ -1,61 +1,85 @@
 import { Type } from "../shared/native-typebox.js";
-import { createSubagentExecutor, normalizeSubagentParamsLike } from "../runs/foreground/subagent-executor.js";
+import { normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
 import { activateTools, restoreLazyTools } from "../shared/lazy-tools.js";
-import { runHistoryIndex } from "../runs/shared/history-index.js";
 import { listSupervisorQuestionsAsync } from "../runs/shared/supervisor-questions.js";
 import { renderSubagentResult } from "../tui/render.js";
 import { AgentRunsParams, DelegateParams } from "./schemas.js";
 import { normalizeEverydayParams } from "./tool-input.js";
-export function registerCompactSubagentTools(pi, options) {
-    const { executor, adapt, guidelines, childSafe, asyncByDefault, state } = options;
+function hasOwnedRunsFor(state, owner) {
+    return ((state.lastUiContext?.sessionManager.getSessionId() ?? state.currentSessionId) === owner &&
+        (state.ownedRuns?.size ?? 0) > 0);
+}
+async function activateOwnedControls(pi, state, getHistoryIndex, owner) {
+    try {
+        const index = await getHistoryIndex();
+        const needed = await index.needsControls();
+        if (state.historyIndex === index && needed) {
+            activateTools(pi, ["agent_runs"]);
+        }
+    }
+    catch {
+        // An unavailable browse index cannot establish that genuine owned work is inert.
+        if (hasOwnedRunsFor(state, owner)) {
+            activateTools(pi, ["agent_runs"]);
+        }
+    }
+}
+function createRunControlsReconciler(pi, state, getHistoryIndex) {
     let checking;
-    const checkRuns = () => {
-        if (pi.getActiveTools().includes("agent_runs") || !state.ownedRuns?.size)
+    return () => {
+        if (pi.getActiveTools().includes("agent_runs") || (state.ownedRuns?.size ?? 0) === 0) {
             return Promise.resolve();
+        }
         const owner = state.lastUiContext?.sessionManager.getSessionId() ?? state.currentSessionId;
-        if (checking?.owner === owner)
+        if (checking?.owner === owner) {
             return checking.promise;
-        const promise = Promise.resolve().then(async () => {
-            try {
-                const index = await runHistoryIndex(state);
-                const needed = await index.needsControls();
-                if (state.historyIndex === index && needed)
-                    activateTools(pi, ["agent_runs"]);
-            }
-            catch {
-                // An unavailable browse index cannot establish that genuine owned work is inert.
-                if ((state.lastUiContext?.sessionManager.getSessionId() ?? state.currentSessionId) === owner && state.ownedRuns?.size)
-                    activateTools(pi, ["agent_runs"]);
-            }
-            finally {
-                if (checking?.promise === promise)
-                    checking = undefined;
+        }
+        const promise = activateOwnedControls(pi, state, getHistoryIndex, owner);
+        checking = { owner, promise };
+        promise
+            .finally(() => {
+            if (checking?.promise === promise) {
+                checking = undefined;
             }
+        })
+            .catch((error) => {
+            console.error("Could not reconcile owned subagent controls:", error);
         });
-        checking = { owner, promise };
         return promise;
     };
-    const reconcileRuns = () => checkRuns();
-    const onRunsChanged = state.onRunsChanged;
-    state.onRunsChanged = () => { reconcileRuns(); onRunsChanged?.(); };
-    const asyncDescription = asyncByDefault ? "Background by default; false waits for the result." : "Foreground by default; true detaches work. Use false when the result must appear in your report.";
+}
+function registerDelegate(pi, options, checkRuns) {
+    const asyncDescription = options.asyncByDefault
+        ? "Background by default; false waits for the result."
+        : "Foreground by default; true detaches work. Use false when the result must appear in your report.";
     pi.registerTool({
         name: "delegate",
         label: "Delegate",
         description: `Delegate one bounded task to a configured agent. For profiles/history, load_subagent({advanced:false}) enables agent_runs. Delegation enables run controls automatically. ${asyncDescription} Use worktree for an isolated writer, acceptance for explicit requirements, and fresh context for independent review. Fresh handoffs must include relevant exact user instructions and settled decisions or readable source references, not just summaries, alongside the bounded task. Advanced workflows remain behind load_subagent.`,
-        ...(childSafe ? { promptGuidelines: [...guidelines] } : {}),
-        parameters: Type.Object({ ...DelegateParams.properties, async: Type.Optional(Type.Boolean({ description: asyncDescription })) }, { additionalProperties: false }),
+        ...(options.childSafe === true ? { promptGuidelines: [...options.guidelines] } : {}),
+        parameters: Type.Object({
+            ...DelegateParams.properties,
+            async: Type.Optional(Type.Boolean({ description: asyncDescription })),
+        }, { additionalProperties: false }),
         async execute(id, params, signal, onUpdate, ctx) {
             const { worktree, context, async: background, ...task } = normalizeEverydayParams(params);
-            const request = worktree
+            const request = worktree === true
                 ? { tasks: [task], worktree: true, context, async: background, cwd: task.cwd }
                 : { ...task, context, async: background };
-            const result = await executor.execute(id, normalizeSubagentParamsLike(request), signal, onUpdate, ctx);
+            const result = await options.executor.execute({
+                toolCallId: id,
+                params: normalizeSubagentParamsLike(request),
+                signal,
+                onUpdate,
+                ctx,
+            });
             await checkRuns();
-            return adapt(result, ctx);
+            return options.adapt(result, ctx);
         },
         renderResult: renderSubagentResult,
     });
+}
+function registerRuns(pi, options, childSafe) {
     pi.registerTool({
         name: "agent_runs",
         defaultActive: false,
@@ -64,49 +88,96 @@ export function registerCompactSubagentTools(pi, options) {
         parameters: AgentRunsParams,
         async execute(id, params, signal, onUpdate, ctx) {
             const normalized = normalizeEverydayParams(params, true);
-            if (params.action === "list" && !params.id && options.listRuns)
-                return adapt(await options.listRuns({ ...normalized, signal }, ctx), ctx);
-            const actions = { list: "status", inspect: "status", history: "history", search: "search", nudge: "nudge", stop: "interrupt", continue: "resume", profiles: "list", questions: "questions", answer: "answer", review: "review" };
-            return adapt(await executor.execute(id, normalizeSubagentParamsLike({ ...normalized, action: actions[params.action] }), signal, onUpdate, ctx), ctx);
+            if (params.action === "list" && params.id === undefined && options.listRuns) {
+                return options.adapt(await options.listRuns({ ...normalized, signal }, ctx), ctx);
+            }
+            const actions = {
+                list: "status",
+                inspect: "status",
+                history: "history",
+                search: "search",
+                nudge: "nudge",
+                stop: "interrupt",
+                continue: "resume",
+                profiles: "list",
+                questions: "questions",
+                answer: "answer",
+                review: "review",
+            };
+            return options.adapt(await options.executor.execute({
+                toolCallId: id,
+                params: normalizeSubagentParamsLike({ ...normalized, action: actions[params.action] }),
+                signal,
+                onUpdate,
+                ctx,
+            }), ctx);
         },
         renderResult: renderSubagentResult,
     });
+}
+function requireAvailableTool(pi, name, error) {
+    if (!pi.getAllTools().some((tool) => tool.name === name && !("namespace" in tool && tool.namespace))) {
+        throw new Error(error);
+    }
+}
+function registerLoader(pi, options) {
     pi.registerTool({
         name: "load_subagent",
         label: "Load Subagent",
-        description: `Enable agent_runs for profiles, history and run controls; advanced:false loads only those controls. By default also enable advanced subagent orchestration: parallel groups, chains, saved workflows, detailed overrides, get, extend and doctor.${childSafe ? " Agent-definition mutations remain blocked." : " Includes agent-definition management."} Ordinary delegation and control use delegate and agent_runs. After loading advanced workflows, call subagent with { action: "list" } before execution.`,
+        description: `Enable agent_runs for profiles, history and run controls; advanced:false loads only those controls. By default also enable advanced subagent orchestration: parallel groups, chains, saved workflows, detailed overrides, get, extend and doctor.${options.childSafe === true ? " Agent-definition mutations remain blocked." : " Includes agent-definition management."} Ordinary delegation and control use delegate and agent_runs. After loading advanced workflows, call subagent with { action: "list" } before execution.`,
         promptSnippet: "Discover profiles/history with advanced:false, or load full subagent orchestration by default.",
-        parameters: Type.Object({ advanced: Type.Optional(Type.Boolean({ description: "Also enable advanced orchestration (default true); false loads only agent_runs for profiles, history and controls." })) }),
+        parameters: Type.Object({
+            advanced: Type.Optional(Type.Boolean({
+                description: "Also enable advanced orchestration (default true); false loads only agent_runs for profiles, history and controls.",
+            })),
+        }),
         async execute(_id, params) {
             const advanced = params.advanced !== false;
-            if (advanced && !pi.getAllTools().some((tool) => tool.name === "subagent" && !("namespace" in tool && tool.namespace))) {
-                throw new Error("Subagent is unavailable because the full tool is excluded from this session.");
-            }
-            if (!advanced && !pi.getAllTools().some((tool) => tool.name === "agent_runs" && !("namespace" in tool && tool.namespace)))
-                throw new Error("Run controls are excluded from this session.");
+            requireAvailableTool(pi, advanced ? "subagent" : "agent_runs", advanced
+                ? "Subagent is unavailable because the full tool is excluded from this session."
+                : "Run controls are excluded from this session.");
             const added = !pi.getActiveTools().includes(advanced ? "subagent" : "agent_runs");
             activateTools(pi, advanced ? ["agent_runs", "subagent"] : ["agent_runs"]);
             return {
-                content: [{ type: "text", text: advanced ? [`Subagent ${added ? "enabled" : "already enabled"}.`, ...guidelines.map((line) => `- ${line}`)].join("\n") : "Run controls enabled. Use agent_runs({action:'profiles'}) to discover agents; list, history, or search browses owned saved work." }],
+                content: [
+                    {
+                        type: "text",
+                        text: advanced
+                            ? [
+                                `Subagent ${added ? "enabled" : "already enabled"}.`,
+                                ...options.guidelines.map((line) => `- ${line}`),
+                            ].join("\n")
+                            : "Run controls enabled. Use agent_runs({action:'profiles'}) to discover agents; list, history, or search browses owned saved work.",
+                    },
+                ],
                 details: {},
             };
         },
     });
+}
+export function registerCompactSubagentTools(pi, options) {
+    const checkRuns = createRunControlsReconciler(pi, options.state, options.getHistoryIndex);
+    registerDelegate(pi, options, checkRuns);
+    registerRuns(pi, options, options.childSafe === true);
+    registerLoader(pi, options);
     const reconcile = async (ctx) => {
-        if (options.keepAdvancedActive)
+        if (options.keepAdvancedActive === true) {
             activateTools(pi, ["subagent"]);
+        }
         await checkRuns();
-        if (!pi.getActiveTools().includes("agent_runs") && (await listSupervisorQuestionsAsync(ctx.sessionManager.getSessionId())).some((question) => question.state === "awaiting_input" || question.state === "answer_pending"))
+        if (!pi.getActiveTools().includes("agent_runs") &&
+            (await listSupervisorQuestionsAsync(ctx.sessionManager.getSessionId())).some((question) => question.state === "awaiting_input" || question.state === "answer_pending")) {
             activateTools(pi, ["agent_runs"]);
+        }
     };
-    const restore = async (event, ctx) => {
-        if (event.reason !== "reload")
+    pi.on("session_start", async (event, ctx) => {
+        if (event.reason !== "reload") {
             restoreLazyTools(pi, ctx, "load_subagent", ["subagent", "agent_runs"]);
+        }
         await reconcile(ctx);
-    };
-    pi.on("session_start", restore);
+    });
     pi.on("session_tree", (_event, ctx) => reconcile(ctx));
     pi.on("session_compact", (_event, ctx) => reconcile(ctx));
     pi.on("before_agent_start", (_event, ctx) => reconcile(ctx));
-    return reconcileRuns;
+    return checkRuns;
 }

package/dist/extension/config-schema.js

@@ -0,0 +1,29 @@
+import { Compile, Type } from "../shared/native-typebox.js";
+const policy = Type.Enum(["inherit", "approve", "no-approve"], { type: "string" });
+const optionalNumber = Type.Optional(Type.Number());
+const optionalBoolean = Type.Optional(Type.Boolean());
+const optionalString = Type.Optional(Type.String());
+export const extensionConfig = Compile(Type.Object({
+    compactChildTools: optionalBoolean,
+    asyncByDefault: optionalBoolean,
+    forceTopLevelAsync: optionalBoolean,
+    defaultSessionDir: optionalString,
+    maxSubagentDepth: optionalNumber,
+    worktreeSetupHook: optionalString,
+    worktreeSetupHookTimeoutMs: optionalNumber,
+    projectTrust: Type.Optional(Type.Union([
+        policy,
+        Type.Object({ childRuns: Type.Optional(policy) }, { additionalProperties: true }),
+    ])),
+    parallel: Type.Optional(Type.Object({ maxTasks: optionalNumber, concurrency: optionalNumber }, { additionalProperties: true })),
+    chain: Type.Optional(Type.Object({
+        dynamicFanout: Type.Optional(Type.Object({ maxItems: optionalNumber }, { additionalProperties: true })),
+    }, { additionalProperties: true })),
+    control: Type.Optional(Type.Object({
+        enabled: optionalBoolean,
+        needsAttentionAfterMs: optionalNumber,
+        failedToolAttemptsBeforeAttention: optionalNumber,
+        notifyOn: Type.Optional(Type.Array(Type.Enum(["needs_attention"], { type: "string" }))),
+        notifyChannels: Type.Optional(Type.Array(Type.Enum(["event", "async", "intercom"], { type: "string" }))),
+    }, { additionalProperties: true })),
+}, { additionalProperties: true }));

package/dist/extension/config.js

@@ -1,22 +1,38 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getAgentDir } from "../shared/utils.js";
+import { getAgentDir } from "../shared/agent-dir.js";
+import { isRecord } from "../shared/unknown.js";
+import { extensionConfig } from "./config-schema.js";
+function normalizedTrust(config, configPath) {
+    const trust = config.projectTrust;
+    const childRuns = isRecord(trust) ? trust.childRuns : trust;
+    if (childRuns !== undefined &&
+        childRuns !== "inherit" &&
+        childRuns !== "approve" &&
+        childRuns !== "no-approve") {
+        console.error(`Invalid projectTrust in '${configPath}'; child runs will use no-approve.`);
+        return { ...config, projectTrust: "no-approve" };
+    }
+    return config;
+}
 export function loadConfig() {
     const configPath = path.join(getAgentDir(), "extensions", "subagent", "config.json");
     try {
-        if (fs.existsSync(configPath)) {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-            const trust = config.projectTrust;
-            const childRuns = typeof trust === "object" && trust !== null ? trust.childRuns : trust;
-            if (childRuns !== undefined && childRuns !== "inherit" && childRuns !== "approve" && childRuns !== "no-approve") {
-                console.error(`Invalid projectTrust in '${configPath}'; child runs will use no-approve.`);
-                config.projectTrust = "no-approve";
-            }
-            return config;
+        if (!fs.existsSync(configPath)) {
+            return {};
+        }
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (!isRecord(parsed)) {
+            throw new Error("Subagent configuration must be an object.");
+        }
+        const config = normalizedTrust(parsed, configPath);
+        if (!extensionConfig.Check(config)) {
+            throw new Error([...extensionConfig.Errors(config)].map((error) => error.message).join("; "));
         }
+        return config;
     }
     catch (error) {
         console.error(`Failed to load subagent config from '${configPath}':`, error);
+        return {};
     }
-    return {};
 }

package/dist/extension/control-notice-schema.js

@@ -0,0 +1,37 @@
+import { Compile, Type } from "../shared/native-typebox.js";
+const optionalString = Type.Optional(Type.String());
+const optionalNumber = Type.Optional(Type.Number());
+const attention = Type.Enum(["needs_attention"], { type: "string" });
+const notice = Compile(Type.Object({
+    event: Type.Object({
+        type: attention,
+        from: Type.Optional(attention),
+        to: attention,
+        ts: Type.Number(),
+        agent: Type.String(),
+        runId: Type.String(),
+        message: Type.String(),
+        index: optionalNumber,
+        reason: Type.Optional(Type.Enum(["idle", "completion_guard", "tool_failures"], { type: "string" })),
+        turns: optionalNumber,
+        tokens: optionalNumber,
+        toolCount: optionalNumber,
+        currentTool: optionalString,
+        currentToolDurationMs: optionalNumber,
+        currentPath: optionalString,
+        elapsedMs: optionalNumber,
+        recentFailureSummary: optionalString,
+        supervisorQuestion: Type.Optional(Type.Object({
+            questionId: Type.String(),
+            state: Type.Enum(["awaiting_input", "answer_pending"], { type: "string" }),
+            answer: optionalString,
+        }, { additionalProperties: true })),
+    }, { additionalProperties: true }),
+    source: Type.Optional(Type.Enum(["foreground", "async"], { type: "string" })),
+    asyncDir: optionalString,
+    childIntercomTarget: optionalString,
+    noticeText: optionalString,
+}, { additionalProperties: true }));
+export function parseControlNotice(value) {
+    return notice.Check(value) ? value : undefined;
+}

package/dist/extension/control-notices.js

@@ -1,20 +1,25 @@
-import { controlNotificationKey, formatControlNoticeMessage, isObsoleteIdleNotice } from "../runs/shared/subagent-control.js";
+import { controlNotificationKey, formatControlNoticeMessage, isObsoleteIdleNotice, } from "../runs/shared/subagent-control.js";
 export const SUBAGENT_CONTROL_MESSAGE_TYPE = "subagent_control_notice";
 export function controlNoticeTarget(details) {
     return details.childIntercomTarget;
 }
 export function formatSubagentControlNotice(details, content) {
-    return details.noticeText ?? content ?? formatControlNoticeMessage(details.event, controlNoticeTarget(details));
+    return (details.noticeText ??
+        content ??
+        formatControlNoticeMessage(details.event, controlNoticeTarget(details)));
 }
 export function handleSubagentControlNotice(input) {
-    if (!input.details?.event || isObsoleteIdleNotice(input.details))
+    if (isObsoleteIdleNotice(input.details)) {
         return;
+    }
     const childIntercomTarget = controlNoticeTarget(input.details);
     const key = controlNotificationKey(input.details.event, childIntercomTarget);
-    if (input.visibleControlNotices.has(key))
+    if (input.visibleControlNotices.has(key)) {
         return;
+    }
     input.visibleControlNotices.add(key);
-    const noticeText = input.details.noticeText ?? formatControlNoticeMessage(input.details.event, childIntercomTarget);
+    const noticeText = input.details.noticeText ??
+        formatControlNoticeMessage(input.details.event, childIntercomTarget);
     input.pi.sendMessage({
         customType: SUBAGENT_CONTROL_MESSAGE_TYPE,
         content: noticeText,
@@ -25,5 +30,7 @@ export function handleSubagentControlNotice(input) {
     // result deliver the single automatic wakeup. In a parallel group that result
     // arrives only after all siblings finish, so reaction to a mid-group guard
     // notice is bounded by the longest-running sibling.
-    { triggerTurn: !(input.details.source === "async" && input.details.event.reason === "completion_guard") });
+    {
+        triggerTurn: !(input.details.source === "async" && input.details.event.reason === "completion_guard"),
+    });
 }

package/dist/extension/delegation-bridges.js

@@ -0,0 +1,43 @@
+import { normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
+import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.js";
+import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
+/** Translate the two existing event protocols into the canonical application invocation. */
+export function registerDelegationBridges(input) {
+    const slash = registerSlashSubagentBridge({
+        events: input.events,
+        getContext: input.getContext,
+        execute: (request) => input.executor.execute(request),
+    });
+    const template = registerPromptTemplateDelegationBridge({
+        events: input.events,
+        getContext: input.getContext,
+        execute: async ({ request, signal, ctx, onUpdate }) => {
+            const params = request.tasks !== undefined && request.tasks.length > 0
+                ? {
+                    tasks: request.tasks,
+                    context: request.context,
+                    cwd: request.cwd,
+                    worktree: request.worktree,
+                    async: false,
+                    clarify: false,
+                }
+                : {
+                    agent: request.agent,
+                    task: request.task,
+                    context: request.context,
+                    cwd: request.cwd,
+                    model: request.model,
+                    async: false,
+                    clarify: false,
+                };
+            return input.executor.execute({
+                toolCallId: request.requestId,
+                params: normalizeSubagentParamsLike(params),
+                signal,
+                onUpdate,
+                ctx,
+            });
+        },
+    });
+    return { slash, template };
+}

package/dist/extension/doctor.js

@@ -1,15 +1,16 @@
 import * as fs from "node:fs";
+import { errorMessage } from "../shared/unknown.js";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { VERSION as PI_VERSION, getPackageDir } from "@earendil-works/pi-coding-agent";
+import { VERSION as PI_SDK_VERSION, getPackageDir } from "@earendil-works/pi-coding-agent";
 import { EXTENSION_BUILD } from "./build-info.js";
 import { discoverAgentsAll } from "../agents/agents.js";
 import { discoverAvailableSkills } from "../agents/skills.js";
 import { ASYNC_DIR, CHAIN_RUNS_DIR, RESULTS_DIR, TEMP_ROOT_DIR, } from "../shared/types.js";
-const PI_PACKAGE_DIR = getPackageDir();
+const PI_SDK_RESOURCE_DIR = getPackageDir();
 const EXTENSION_MODULE = fileURLToPath(import.meta.url);
 function errorText(error) {
-    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    return error instanceof Error ? `${error.name}: ${error.message}` : errorMessage(error);
 }
 function lineFromCheck(label, check) {
     try {
@@ -21,11 +22,13 @@ function lineFromCheck(label, check) {
 }
 function formatExistingDirectory(label, dirPath) {
     try {
-        if (!fs.existsSync(dirPath))
+        if (!fs.existsSync(dirPath)) {
             return `- ${label}: missing (${dirPath})`;
+        }
         const stats = fs.statSync(dirPath);
-        if (!stats.isDirectory())
+        if (!stats.isDirectory()) {
             throw new Error(`not a directory: ${dirPath}`);
+        }
         fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
         return `- ${label}: ok (${dirPath})`;
     }
@@ -38,8 +41,9 @@ function formatSourceCounts(counts) {
 }
 function formatSkillSourceCounts(skills) {
     const counts = new Map();
-    for (const skill of skills)
+    for (const skill of skills) {
         counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
+    }
     const ordered = [
         "project",
         "project-settings",
@@ -57,11 +61,10 @@ function formatSkillSourceCounts(skills) {
     return parts.length > 0 ? parts.join(", ") : "none";
 }
 function formatConfiguredSessionDir(input) {
-    if (input.requestedSessionDir) {
-        return path.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
-    }
-    if (input.config.defaultSessionDir) {
-        return path.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
+    const dir = input.requestedSessionDir ?? "";
+    const configured = dir.length > 0 ? dir : (input.config.defaultSessionDir ?? "");
+    if (configured.length > 0) {
+        return path.resolve(input.expandTilde?.(configured) ?? configured);
     }
     return "not configured";
 }
@@ -70,59 +73,79 @@ function formatSessionLines(input) {
     const lines = [
         lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
         `- current session file: ${sessionFile ?? "not available"}`,
-        `- current session dir: ${sessionFile ? path.dirname(sessionFile) : "not available"}`,
+        `- current session dir: ${sessionFile !== null && sessionFile.length > 0 ? path.dirname(sessionFile) : "not available"}`,
         `- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
     ];
-    if (input.sessionError)
+    if (input.sessionError !== undefined && input.sessionError.length > 0) {
         lines.push(`- session manager: failed — ${input.sessionError}`);
+    }
     return lines;
 }
 function formatDiscovery(input) {
     return [
         lineFromCheck("agents/chains", () => {
-            const discovered = discoverAgentsAll(input.cwd, { projectTrusted: input.projectTrusted ?? true });
+            const discovered = discoverAgentsAll(input.cwd, {
+                projectTrusted: input.projectTrusted ?? true,
+            });
             const agentCounts = {
                 builtin: discovered.builtin.length,
                 package: discovered.package.length,
                 user: discovered.user.length,
                 project: discovered.project.length,
             };
-            const chainCounts = discovered.chains.reduce((counts, chain) => {
-                counts[chain.source] += 1;
-                return counts;
-            }, { builtin: 0, package: 0, user: 0, project: 0 });
+            const chainCounts = { builtin: 0, package: 0, user: 0, project: 0 };
+            for (const chain of discovered.chains) {
+                chainCounts[chain.source] += 1;
+            }
             return [
                 `- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
                 `- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
             ].join("\n");
         }),
         lineFromCheck("skills", () => {
-            const skills = discoverAvailableSkills(input.cwd, { projectTrusted: input.projectTrusted ?? true });
+            const skills = discoverAvailableSkills(input.cwd, {
+                projectTrusted: input.projectTrusted ?? true,
+            });
             return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
         }),
     ];
 }
+function connectionStatus(connection, reason) {
+    return `${connection?.status ?? "unknown"}${reason.length > 0 ? ` — ${reason}` : ""}`;
+}
 function formatIntercomSection(input) {
+    const reason = input.connection?.reason ?? "";
+    const target = input.orchestratorTarget?.trim() ?? "";
     return [
         `- bridge: ${input.connection ? "responding" : "unavailable (no live health response)"}`,
-        `- connection: ${input.connection?.status ?? "unknown"}${input.connection?.reason ? ` — ${input.connection.reason}` : ""}`,
+        `- connection: ${connectionStatus(input.connection, reason)}`,
         `- broker session id: ${input.connection?.sessionId ?? "not available"}`,
-        `- orchestrator target: ${input.orchestratorTarget?.trim() || "not available"}`,
+        `- orchestrator target: ${target.length > 0 ? target : "not available"}`,
     ];
 }
+function formatBuild() {
+    const { version, sha256 } = EXTENSION_BUILD;
+    return version !== undefined && sha256 !== undefined && version.length > 0 && sha256.length > 0
+        ? `${version} (runtime SHA-256 ${sha256})`
+        : "unknown (unbuilt source)";
+}
 export function buildDoctorReport(input) {
     const lines = [
         "Subagents doctor report",
         "",
         "Runtime",
         `- Native session cwd: ${input.nativeSessionCwd ?? input.cwd}`,
-        ...(input.nativeSessionCwd && input.nativeSessionCwd !== input.cwd ? [`- Requested cwd: ${input.cwd}`] : []),
+        ...(input.nativeSessionCwd !== undefined &&
+            input.nativeSessionCwd.length > 0 &&
+            input.nativeSessionCwd !== input.cwd
+            ? [`- Requested cwd: ${input.cwd}`]
+            : []),
         `- Node: ${process.version}`,
         `- process: ${process.pid} (${process.execPath})`,
-        `- loaded Pi version: ${PI_VERSION}`,
-        `- Pi package directory: ${PI_PACKAGE_DIR} (Pi resource path; may be overridden)`,
+        `- imported Pi SDK version: ${PI_SDK_VERSION} (not proof of the executing CLI version)`,
+        `- Pi SDK resource directory: ${PI_SDK_RESOURCE_DIR} (may be overridden; not executable provenance)`,
         "- native queue contract: not verified (version alone does not identify fork patches)",
-        `- loaded pi-subagents build: ${EXTENSION_BUILD.version && EXTENSION_BUILD.sha256 ? `${EXTENSION_BUILD.version} (runtime SHA-256 ${EXTENSION_BUILD.sha256})` : "unknown (unbuilt source)"}`,
+        `- loaded pi-subagents build: ${formatBuild()}`,
         `- extension module: ${EXTENSION_MODULE}`,
         "- async support: available (Node >=24)",
         ...formatSessionLines(input),