@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/extension/child-runtime.js

@@ -1,237 +0,0 @@
-import { discoverAgents } from "../agents/agents.js";
-import { getArtifactsDir } from "../shared/artifacts.js";
-import { createSubagentExecutor, normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
-import { interruptAsyncRun } from "../runs/foreground/foreground-control.js";
-import { SUBAGENT_EAGER_TOOL_ENV, SUBAGENT_PARENT_CHILD_INDEX_ENV, } from "../runs/shared/pi-args.js";
-import { resolveNestedRouteFromEnv, } from "../runs/shared/nested-events.js";
-import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.js";
-import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
-import { readStatus } from "../shared/utils.js";
-import { SubagentParams } from "./schemas.js";
-import { loadConfig } from "./config.js";
-import { registerCompactSubagentTools } from "./compact-tools.js";
-import { adaptFinalizedToolResult, registerToolResultAdapter } from "./tool-result.js";
-import { renderSubagentResult } from "../tui/render.js";
-import { registerParentUsage } from "../runs/shared/parent-usage.js";
-import { resolveCurrentSessionId } from "../shared/session-identity.js";
-import { ownedRunList, restoreOwnedRunsAsync } from "../runs/shared/run-records.js";
-import { closeRunHistory, runHistoryIndex, startRunHistory } from "../runs/shared/history-index.js";
-import { createCompletionDelivery } from "../runs/background/completion-delivery.js";
-import { createRuntimeState, expandTilde, getSubagentSessionRoot } from "./runtime-storage.js";
-import { NestedControlInbox } from "./nested-control-inbox.js";
-import { removeSharedRuntimeValue, setSharedRuntimeValue } from "./runtime-reload.js";
-export const CHILD_CLEANUP_KEY = "__piSubagentFanoutChildControlInboxCleanup";
-const acceptanceGuidelines = [
-    "For goal-style requests such as /goal, goal, active goal, or work until evidence says done, use explicit acceptance on the delegated run: criteria for the target, evidence/verify for proof, stopRules for constraints, and maxFinalizationTurns for the bounded loop.",
-    "For implementation handoffs from a plan, PRD, spec, issue, or broad fix, put implementation instructions and plan paths in task, and put the definition of done, evidence, verification commands, constraints, and loop cap in acceptance.",
-];
-/** Owns the fanout child's session, completion delivery and inbox resources. */
-export class FanoutChildRuntime {
-    config = loadConfig();
-    state;
-    parentUsage;
-    completionDelivery;
-    adaptToolResult;
-    executor;
-    compact = this.config.compactChildTools !== false;
-    sessionReset;
-    inbox;
-    checks = new Set();
-    cleanup = () => this.shutdown();
-    pi;
-    constructor(pi) {
-        this.pi = pi;
-        this.state = createRuntimeState(pi);
-        const toolNames = this.compact ? ["subagent", "delegate", "agent_runs"] : ["subagent"];
-        this.parentUsage = registerParentUsage(pi, toolNames);
-        this.completionDelivery = createCompletionDelivery(pi, this.state, this.parentUsage);
-        this.adaptToolResult = registerToolResultAdapter(pi, toolNames);
-        this.executor = createSubagentExecutor({
-            pi,
-            state: this.state,
-            config: this.config,
-            asyncByDefault: this.config.asyncByDefault === true,
-            tempArtifactsDir: getArtifactsDir(null),
-            getSubagentSessionRoot,
-            expandTilde,
-            discoverAgents,
-            allowMutatingManagementActions: false,
-            ensureSessionState: (ctx) => this.ensureSessionState(ctx),
-        });
-    }
-    ensureSessionState(ctx) {
-        const sessionId = resolveCurrentSessionId(ctx.sessionManager);
-        if (this.sessionReset) {
-            return this.sessionReset;
-        }
-        if (this.state.currentSessionId === sessionId) {
-            this.state.lastUiContext = ctx;
-            return Promise.resolve();
-        }
-        this.sessionReset = this.resetSession(ctx, sessionId).finally(() => {
-            this.sessionReset = undefined;
-        });
-        return this.sessionReset;
-    }
-    async resetSession(ctx, sessionId) {
-        await this.completionDelivery.stopAndJoin();
-        await closeRunHistory(this.state);
-        this.state.lastUiContext = ctx;
-        this.state.foregroundRuns?.clear();
-        await restoreOwnedRunsAsync(this.state, ctx);
-        this.state.currentSessionId = sessionId;
-        startRunHistory(this.state, ctx);
-        this.completionDelivery.start();
-    }
-    guidelines() {
-        return [
-            "Delegate useful helper work within your assigned task when it saves time or improves quality; the original parent owns integration and final delivery.",
-            "Nested execution defaults to foreground unless configuration explicitly opts into async. Set async:false whenever the nested result must appear in this child's report; use async:true only for intentionally detached work.",
-            this.compact
-                ? "Use load_subagent({advanced:false}), then agent_runs({action:'profiles'}) before delegation unless the executable agent is already known. Use load_subagent for advanced workflows."
-                : "Use subagent action:list before nested execution unless the executable nested agent is already known from the task context.",
-            "Do not use subagent child-safe mode for agent config mutation actions; create, update, and delete are blocked here.",
-        ];
-    }
-    registerTools() {
-        if (this.compact) {
-            const checkRuns = registerCompactSubagentTools(this.pi, {
-                executor: this.executor,
-                state: this.state,
-                getHistoryIndex: () => runHistoryIndex(this.state),
-                adapt: (result, ctx) => adaptFinalizedToolResult(result, ctx, this.parentUsage, this.adaptToolResult),
-                guidelines: [...this.guidelines(), ...acceptanceGuidelines],
-                childSafe: true,
-                asyncByDefault: this.config.asyncByDefault === true,
-                keepAdvancedActive: process.env[SUBAGENT_EAGER_TOOL_ENV] === "1",
-                listRuns: async (params, ctx) => {
-                    await this.ensureSessionState(ctx);
-                    return ownedRunList(this.state, params);
-                },
-            });
-            this.state.onRunsChanged = () => this.trackCheck(checkRuns());
-        }
-        const tool = {
-            name: "subagent",
-            defaultActive: !this.compact,
-            label: "Subagent",
-            description: [
-                "Delegate to subagents from child-safe fanout mode.",
-                ...acceptanceGuidelines,
-                "Allowed management/control actions: list, get, status, history, search, nudge, interrupt, extend, resume, questions, answer, review, doctor. History/search browse only directly owned saved work; bounded previews and index freshness are not canonical proof. Exact status is concise; full:true includes the full task/configuration. Review notes are parent-only, not sent to children. Put actionable instructions in resume/nudge. Resume/answer overrides do not amend live acceptance.",
-                "Agent config mutation actions create, update, and delete are blocked in this mode.",
-            ].join("\n"),
-            promptSnippet: "Delegate nested child-safe subagent work from an explicitly allowed fanout child.",
-            promptGuidelines: this.guidelines(),
-            parameters: SubagentParams,
-            execute: async (id, params, signal, onUpdate, ctx) => adaptFinalizedToolResult(await this.executor.execute({
-                toolCallId: id,
-                params: normalizeSubagentParamsLike(params),
-                signal,
-                onUpdate,
-                ctx,
-            }), ctx, this.parentUsage, this.adaptToolResult),
-            renderResult: renderSubagentResult,
-        };
-        this.pi.registerTool(tool);
-    }
-    trackCheck(pending) {
-        this.checks.add(pending);
-        pending
-            .finally(() => {
-            this.checks.delete(pending);
-        })
-            .catch((error) => {
-            console.error("Could not reconcile nested subagent controls:", error);
-        });
-    }
-    async executeControl(request) {
-        const asyncDir = this.state.ownedRuns?.get(request.targetRunId)?.asyncDir ??
-            this.state.asyncJobs.get(request.targetRunId)?.asyncDir;
-        const status = asyncDir !== undefined && asyncDir.length > 0 ? readStatus(asyncDir) : null;
-        if (!status || status.state !== "running") {
-            return {
-                ok: false,
-                message: `Nested run ${request.targetRunId} is not active in this fanout child.`,
-            };
-        }
-        return request.action === "interrupt"
-            ? this.interruptControl(request)
-            : this.resumeControl(request, status);
-    }
-    interruptControl(request) {
-        const receipt = interruptAsyncRun(this.state, request.targetRunId, request.index);
-        return {
-            ok: receipt !== null && receipt.isError !== true,
-            message: receipt?.content.map((part) => (part.type === "text" ? part.text : "")).join("\n") ??
-                "Nested run is not interruptible.",
-        };
-    }
-    async resumeControl(request, status) {
-        const message = request.message?.trim() ?? "";
-        if (message.length === 0) {
-            return { ok: false, message: "Nested resume requires message." };
-        }
-        const { index, agent } = this.activeMessageRoute(request.index, status);
-        if (agent === undefined || agent.length === 0) {
-            return {
-                ok: false,
-                message: `Nested run ${request.targetRunId} has no active child message route.`,
-            };
-        }
-        return this.deliverFollowUp(request.targetRunId, agent, index, message);
-    }
-    activeMessageRoute(requestedIndex, status) {
-        const index = requestedIndex ?? status.steps?.findIndex((step) => step.status === "running") ?? -1;
-        const step = status.steps?.[index];
-        return { index, agent: step?.status === "running" ? step.agent : undefined };
-    }
-    async deliverFollowUp(runId, agent, index, message) {
-        const target = resolveSubagentIntercomTarget(runId, agent, index);
-        const ok = await deliverSubagentIntercomMessageEvent(this.pi.events, target, `Follow-up for nested run ${runId} (${agent}):\n\n${message}`, 500, { source: "nested-resume", runId, agent, index });
-        return {
-            ok,
-            message: ok
-                ? `Delivered follow-up to live nested run ${runId}.`
-                : `Nested child intercom target is not registered: ${target}`,
-        };
-    }
-    startInbox() {
-        let route;
-        try {
-            route = resolveNestedRouteFromEnv();
-        }
-        catch {
-            return;
-        }
-        if (!route) {
-            return;
-        }
-        const parsed = Number(process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV]);
-        this.inbox = new NestedControlInbox({
-            route,
-            childIndex: Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined,
-            restoring: () => this.sessionReset !== undefined,
-            owns: (id) => this.state.ownedRuns?.has(id) === true || this.state.asyncJobs.has(id),
-            execute: (request) => this.executeControl(request),
-        });
-    }
-    register() {
-        this.pi.on("session_start", async (_event, ctx) => {
-            await this.ensureSessionState(ctx);
-        });
-        this.registerTools();
-        this.startInbox();
-        setSharedRuntimeValue(CHILD_CLEANUP_KEY, this.cleanup);
-        this.pi.on("session_shutdown", () => this.shutdown());
-    }
-    async shutdown() {
-        this.inbox?.stop();
-        await this.sessionReset;
-        await this.inbox?.stopAndJoin();
-        await this.completionDelivery.stopAndJoin({ preservePending: true });
-        await Promise.all(this.checks);
-        await closeRunHistory(this.state);
-        removeSharedRuntimeValue(CHILD_CLEANUP_KEY, this.cleanup);
-    }
-}

package/dist/extension/compact-tools.js

@@ -1,183 +0,0 @@
-import { Type } from "../shared/native-typebox.js";
-import { normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
-import { activateTools, restoreLazyTools } from "../shared/lazy-tools.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";
-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;
-    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) {
-            return checking.promise;
-        }
-        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);
-        });
-        return promise;
-    };
-}
-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.`,
-        ...(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 === true
-                ? { tasks: [task], worktree: true, context, async: background, cwd: task.cwd }
-                : { ...task, context, async: background };
-            const result = await options.executor.execute({
-                toolCallId: id,
-                params: normalizeSubagentParamsLike(request),
-                signal,
-                onUpdate,
-                ctx,
-            });
-            await checkRuns();
-            return options.adapt(result, ctx);
-        },
-        renderResult: renderSubagentResult,
-    });
-}
-function registerRuns(pi, options, childSafe) {
-    pi.registerTool({
-        name: "agent_runs",
-        defaultActive: false,
-        label: "Agent Runs",
-        description: `List ${childSafe ? "only this child's directly owned" : "your delegated"} runs across working directories (questions/failures, then live work, then unreviewed results; 20 per page). Filter globally by agent/state/text, sort, and page with the returned cursor. history reads 100 bounded native-entry previews; search finds saved visible text using words or quoted phrases, not operators or prefixes. questions pages 20 compact previews (offset/limit); questionId selects one, and questionPath/answerPath retain full records. Browse freshness is not completion or delivery proof. Inspect concise results, paths and continuations; full:true includes the full task/configuration. Answer durable questions, nudge, stop, continue, or save parent-only review. Review notes are not sent to children; put actionable instructions in continue/nudge. Inspect/review/nudge never restart finished work. Continue/answer can launch a saved child; async:false waits for its actual result. Saved continuations keep settings unless agent selects a current profile; model overrides win. Live guidance never mutates model or acceptance. profiles lists roles, sources, context and model/thinking/fallback defaults. History survives reload.`,
-        parameters: AgentRunsParams,
-        async execute(id, params, signal, onUpdate, ctx) {
-            const normalized = normalizeEverydayParams(params, true);
-            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.${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.",
-            })),
-        }),
-        async execute(_id, params) {
-            const advanced = params.advanced !== false;
-            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"}.`,
-                                ...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 === 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")) {
-            activateTools(pi, ["agent_runs"]);
-        }
-    };
-    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_tree", (_event, ctx) => reconcile(ctx));
-    pi.on("session_compact", (_event, ctx) => reconcile(ctx));
-    pi.on("before_agent_start", (_event, ctx) => reconcile(ctx));
-    return checkRuns;
-}

package/dist/extension/config-schema.js

@@ -1,29 +0,0 @@
-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,38 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-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)) {
-            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 {};
-    }
-}

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

@@ -1,37 +0,0 @@
-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,36 +0,0 @@
-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)));
-}
-export function handleSubagentControlNotice(input) {
-    if (isObsoleteIdleNotice(input.details)) {
-        return;
-    }
-    const childIntercomTarget = controlNoticeTarget(input.details);
-    const key = controlNotificationKey(input.details.event, childIntercomTarget);
-    if (input.visibleControlNotices.has(key)) {
-        return;
-    }
-    input.visibleControlNotices.add(key);
-    const noticeText = input.details.noticeText ??
-        formatControlNoticeMessage(input.details.event, childIntercomTarget);
-    input.pi.sendMessage({
-        customType: SUBAGENT_CONTROL_MESSAGE_TYPE,
-        content: noticeText,
-        display: true,
-        details: { ...input.details, childIntercomTarget, noticeText },
-    }, 
-    // Async completion-guard notices stay visible but let the matching completion
-    // 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"),
-    });
-}

package/dist/extension/delegation-bridges.js

@@ -1,43 +0,0 @@
-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 };
-}