@ashx-j/lunr 0.1.0

package/dist/builtin-extensions/pi-subagents/src/extension/index.js

@@ -0,0 +1,577 @@
+// @ts-nocheck
+/**
+ * Subagent Tool
+ *
+ * Full-featured subagent with sync and async modes.
+ * - Sync (default): Streams output, renders markdown, tracks usage
+ * - Async: Background execution, emits events when done
+ *
+ * Modes: single (agent + task), parallel (tasks[]), chain (chain[] with {previous})
+ * Toggle: async parameter (default: false, configurable via config.json)
+ *
+ * Config file: ~/.pi/agent/extensions/subagent/config.json
+ *   { "asyncByDefault": true, "forceTopLevelAsync": true, "maxSubagentDepth": 1, "intercomBridge": { "mode": "always", "instructionFile": "./intercom-bridge.md" }, "worktreeSetupHook": "./scripts/setup-worktree.mjs" }
+ */
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { keyText } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { discoverAgents } from "../agents/agents.js";
+import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.js";
+import { resolveCurrentSessionId } from "../shared/session-identity.js";
+import { cleanupOldChainDirs } from "../shared/settings.js";
+import { clearLegacyResultAnimationTimer, renderSubagentResult, subagentAnimSink } from "../tui/render.js";
+import { SubagentParams } from "./schemas.js";
+import { validateChainInput } from "./chain-validation.js";
+import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
+import { createAsyncJobTracker } from "../runs/background/async-job-tracker.js";
+import { createResultWatcher } from "../runs/background/result-watcher.js";
+import { createScheduledRunManager } from "../runs/background/scheduled-runs.js";
+import { registerSlashCommands } from "../slash/slash-commands.js";
+import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.js";
+import { registerMainWatchdog } from "../watchdog/register-main.js";
+import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
+import { createNativeSupervisorChannel } from "../intercom/native-supervisor-channel.js";
+import { registerSubagentRpcBridge } from "./rpc.js";
+import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots } from "../slash/slash-live-state.js";
+import { resolveWaitToolConfig } from "../runs/background/subagent-wait.js";
+import { registerWaitTool } from "../runs/background/wait-tool.js";
+import { drainOutstandingWork } from "../runs/background/auto-drain.js";
+import registerSubagentNotify, { parseSubagentNotifyContent } from "../runs/background/notify.js";
+import { formatSteeringNotice, handleSubagentSteeringNotice, SUBAGENT_STEERING_MESSAGE_TYPE } from "./steering-notices.js";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../runs/shared/pi-args.js";
+import { formatDuration, shortenPath } from "../shared/formatters.js";
+import { loadConfig } from "./config.js";
+import { buildSubagentToolDescription } from "./tool-description.js";
+import { ASYNC_DIR, DEFAULT_ARTIFACT_CONFIG, RESULTS_DIR, SLASH_RESULT_TYPE, SLASH_TEXT_RESULT_TYPE, SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_CONTROL_EVENT, SUBAGENT_STEERING_NOTICE_EVENT, WIDGET_KEY, } from "../shared/types.js";
+import { clearPendingForegroundControlNotices, formatSubagentControlNotice, handleSubagentControlNotice, SUBAGENT_CONTROL_MESSAGE_TYPE, } from "./control-notices.js";
+export { loadConfig } from "./config.js";
+/**
+ * Derive subagent session base directory from parent session file.
+ * If parent session is ~/.pi/agent/sessions/abc123.jsonl,
+ * returns ~/.pi/agent/sessions/abc123/ as the base.
+ * Callers add runId to create the actual session root: abc123/{runId}/
+ * Falls back to a unique temp directory if no parent session.
+ */
+function getSubagentSessionRoot(parentSessionFile) {
+    if (parentSessionFile) {
+        const baseName = path.basename(parentSessionFile, ".jsonl");
+        const sessionsDir = path.dirname(parentSessionFile);
+        return path.join(sessionsDir, baseName);
+    }
+    return fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
+}
+function expandTilde(p) {
+    return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
+}
+/**
+ * Create a directory and verify it is actually accessible.
+ * On Windows with Azure AD/Entra ID, directories created shortly after
+ * wake-from-sleep can end up with broken NTFS ACLs (null DACL) when the
+ * cloud SID cannot be resolved without network connectivity. This leaves
+ * the directory completely inaccessible to the creating user.
+ */
+function ensureAccessibleDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    try {
+        fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+    }
+    catch {
+        try {
+            fs.rmSync(dirPath, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort: retry mkdir/access even if cleanup fails.
+        }
+        fs.mkdirSync(dirPath, { recursive: true });
+        fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+    }
+}
+function isSlashResultRunning(result) {
+    return result.details?.progress?.some((entry) => entry.status === "running")
+        || result.details?.results.some((entry) => entry.progress?.status === "running")
+        || false;
+}
+// Drives the inline running-indicator braille animation for foreground subagent
+// results. Foreground runs receive progress only on child events, so the glyph
+// (derived from progress fields) would freeze between events. While a result is
+// running we tick a frame counter every 80ms; renderResult registers the
+// running-glyph lines in state.animEntries (via subagentAnimSink) and the timer
+// rewrites just those Text nodes + requests a repaint, instead of invalidate()-ing
+// the whole tool component (a full renderSubagentResult rebuild 12.5x/s made the
+// spinner laggy).
+function subagentResultIsRunning(result) {
+    return result.details?.progress?.some((entry) => entry.status === "running")
+        || result.details?.results.some((entry) => entry.progress?.status === "running")
+        || false;
+}
+function ensureSubagentResultAnimation(context) {
+    const state = context.state;
+    if (state.subagentResultAnimationTimer)
+        return;
+    if (typeof context.invalidate !== "function")
+        return;
+    if (state.frame === undefined)
+        state.frame = 0;
+    state.subagentResultAnimationTimer = setInterval(() => {
+        state.frame = ((state.frame ?? 0) + 1) % 10;
+        try {
+            const entries = state.animEntries;
+            if (entries?.length && typeof context.requestRender === "function") {
+                for (const entry of entries)
+                    entry.text.setText(entry.line(state.frame ?? 0));
+                context.requestRender();
+            }
+            else {
+                context.invalidate();
+            }
+        }
+        catch { }
+    }, 80);
+}
+function isSlashResultError(result) {
+    return result.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || false;
+}
+function isStaleExtensionContextError(error) {
+    return error instanceof Error && error.message.includes("Extension context no longer active");
+}
+function rebuildSlashResultContainer(container, result, options, theme) {
+    container.clear();
+    container.addChild(new Spacer(1));
+    const boxTheme = isSlashResultRunning(result) ? "toolPendingBg" : isSlashResultError(result) ? "toolErrorBg" : "toolSuccessBg";
+    const box = new Box(1, 1, (text) => theme.bg(boxTheme, text));
+    box.addChild(renderSubagentResult(result, options, theme));
+    container.addChild(box);
+}
+function createSlashResultComponent(details, options, theme) {
+    const container = new Container();
+    let lastVersion = -1;
+    container.render = (width) => {
+        const snapshot = getSlashRenderableSnapshot(details);
+        if (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) {
+            lastVersion = snapshot.version;
+            rebuildSlashResultContainer(container, snapshot.result, options, theme);
+        }
+        return Container.prototype.render.call(container, width);
+    };
+    return container;
+}
+class SubagentControlNoticeComponent {
+    details;
+    theme;
+    constructor(details, theme) {
+        this.details = details;
+        this.theme = theme;
+    }
+    invalidate() { }
+    render(width) {
+        const eventLabel = this.details.event.type.replaceAll("_", " ");
+        if (width < 3)
+            return [truncateToWidth(`Subagent ${eventLabel}`, width)];
+        const bodyWidth = Math.max(1, width - 2);
+        const borderChar = "─";
+        const header = ` ⚠ Subagent ${eventLabel}: ${this.details.event.agent} `;
+        const headerText = truncateToWidth(header, bodyWidth, "");
+        const headerPadding = Math.max(0, bodyWidth - visibleWidth(headerText));
+        const lines = [this.theme.fg("accent", `╭${headerText}${borderChar.repeat(headerPadding)}╮`)];
+        for (const line of wrapTextWithAnsi(formatSubagentControlNotice(this.details), bodyWidth)) {
+            const text = truncateToWidth(line, bodyWidth, "");
+            const padding = Math.max(0, bodyWidth - visibleWidth(text));
+            lines.push(this.theme.fg("accent", `│${text}${" ".repeat(padding)}│`));
+        }
+        lines.push(this.theme.fg("accent", `╰${borderChar.repeat(bodyWidth)}╯`));
+        return lines;
+    }
+}
+export default function registerSubagentExtension(pi) {
+    if (process.env[SUBAGENT_CHILD_ENV] === "1") {
+        return;
+    }
+    const globalStore = globalThis;
+    const runtimeCleanupStoreKey = "__piSubagentRuntimeCleanup";
+    const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];
+    if (typeof previousRuntimeCleanup === "function") {
+        try {
+            previousRuntimeCleanup();
+        }
+        catch {
+            // Best effort cleanup for stale timers from an older reload.
+        }
+    }
+    ensureAccessibleDir(RESULTS_DIR);
+    ensureAccessibleDir(ASYNC_DIR);
+    cleanupOldChainDirs();
+    const config = loadConfig();
+    const waitToolConfig = resolveWaitToolConfig(config.waitTool);
+    const asyncByDefault = config.asyncByDefault === true;
+    const tempArtifactsDir = getArtifactsDir(null);
+    cleanupAllArtifactDirs(DEFAULT_ARTIFACT_CONFIG.cleanupDays);
+    const state = {
+        baseCwd: "",
+        currentSessionId: null,
+        subagentInProgress: false,
+        subagentSpawns: { sessionId: null, count: 0 },
+        asyncJobs: new Map(),
+        fleetJobs: new Map(),
+        foregroundRuns: new Map(),
+        foregroundControls: new Map(),
+        lastForegroundControlId: null,
+        pendingForegroundControlNotices: new Map(),
+        cleanupTimers: new Map(),
+        lastUiContext: null,
+        poller: null,
+        completionSeen: new Map(),
+        watcher: null,
+        watcherRestartTimer: null,
+        resultFileCoalescer: {
+            schedule: () => false,
+            clear: () => { },
+        },
+    };
+    const supervisorChannel = createNativeSupervisorChannel(pi, state);
+    const mainWatchdog = registerMainWatchdog(pi);
+    const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(pi, state, RESULTS_DIR, 10 * 60 * 1000);
+    startResultWatcher();
+    primeExistingResults();
+    const runtimeCleanup = () => {
+        mainWatchdog.dispose();
+        stopResultWatcher();
+        scheduledRunManager.stop();
+        supervisorChannel.dispose();
+        clearPendingForegroundControlNotices(state);
+        if (state.poller) {
+            clearInterval(state.poller);
+            state.poller = null;
+        }
+    };
+    globalStore[runtimeCleanupStoreKey] = runtimeCleanup;
+    const { ensurePoller, refreshWidget, handleStarted, handleComplete, resetJobs, restoreActiveJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR, {
+        widgetEnabled: config.asyncWidget !== false,
+    });
+    let executorExecute;
+    const scheduledRunManager = createScheduledRunManager({
+        config,
+        launch: (params, ctx, signal) => {
+            if (!executorExecute) {
+                return Promise.resolve({
+                    content: [{ type: "text", text: "Scheduled subagent launch is unavailable (executor not ready)." }],
+                    isError: true,
+                    details: { mode: "management", results: [] },
+                });
+            }
+            return executorExecute(randomUUID(), params, signal, undefined, ctx);
+        },
+    });
+    const executor = createSubagentExecutor({
+        pi,
+        state,
+        config,
+        asyncByDefault,
+        waitToolEnabled: waitToolConfig.enabled,
+        handleScheduledRunAction: (params, ctx) => scheduledRunManager.handleToolCall(params, ctx),
+        watchdog: mainWatchdog,
+        tempArtifactsDir,
+        getSubagentSessionRoot,
+        expandTilde,
+        discoverAgents,
+    });
+    executorExecute = executor.execute;
+    pi.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
+        const details = resolveSlashMessageDetails(message.details);
+        if (!details)
+            return undefined;
+        return createSlashResultComponent(details, options, theme);
+    });
+    pi.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
+        const content = typeof message.content === "string"
+            ? message.content
+            : message.content
+                .filter((entry) => entry.type === "text")
+                .map((entry) => entry.text)
+                .join("\n");
+        return new Text(content, 0, 0);
+    });
+    pi.registerMessageRenderer("subagent-notify", (message, options, theme) => {
+        const content = typeof message.content === "string" ? message.content : "";
+        const details = message.details ?? parseSubagentNotifyContent(content);
+        if (!details)
+            return new Text(content, 0, 0);
+        const icon = details.status === "completed"
+            ? theme.fg("success", "✓")
+            : details.status === "paused"
+                ? theme.fg("warning", "■")
+                : theme.fg("error", "✗");
+        const parts = [];
+        if (details.taskInfo)
+            parts.push(details.taskInfo);
+        if (details.durationMs !== undefined)
+            parts.push(formatDuration(details.durationMs));
+        let text = `${icon} ${theme.bold(details.agent)} ${theme.fg("dim", details.status)}`;
+        if (parts.length > 0)
+            text += ` ${theme.fg("dim", "·")} ${parts.map((part) => theme.fg("dim", part)).join(` ${theme.fg("dim", "·")} `)}`;
+        const trimmedPreview = details.resultPreview.trim();
+        const previewLines = options.expanded
+            ? trimmedPreview.split("\n").filter((line) => line.trim())
+            : [trimmedPreview.split("\n", 1)[0] ?? ""].filter((line) => line.trim());
+        for (const line of previewLines.length > 0 ? previewLines : ["(no output)"]) {
+            text += `\n  ${theme.fg("dim", `⎿  ${line}`)}`;
+        }
+        if (!options.expanded && trimmedPreview.includes("\n")) {
+            const expandKey = keyText("app.tools.expand");
+            text += `\n  ${theme.fg("dim", `${expandKey} full notification`)}`;
+        }
+        if (details.sessionLabel && details.sessionValue) {
+            text += `\n  ${theme.fg("muted", `${details.sessionLabel}: ${shortenPath(details.sessionValue)}`)}`;
+        }
+        return new Text(text, 0, 0);
+    });
+    pi.registerMessageRenderer(SUBAGENT_STEERING_MESSAGE_TYPE, (message, _options, theme) => {
+        const details = message.details;
+        if (!details)
+            return undefined;
+        return new Text(theme.fg(details.state === "recovered" ? "warning" : "error", formatSteeringNotice(details)), 0, 0);
+    });
+    pi.registerMessageRenderer(SUBAGENT_CONTROL_MESSAGE_TYPE, (message, _options, theme) => {
+        const details = message.details;
+        if (!details?.event)
+            return undefined;
+        const content = typeof message.content === "string" ? message.content : undefined;
+        return new SubagentControlNoticeComponent({ ...details, noticeText: formatSubagentControlNotice(details, content) }, theme);
+    });
+    const executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => {
+        if (ctx.hasUI)
+            ctx.ui.setToolsExpanded(false);
+        return executor.execute(id, params, signal, onUpdate, ctx);
+    };
+    const slashBridge = registerSlashSubagentBridge({
+        events: pi.events,
+        getContext: () => state.lastUiContext,
+        execute: (id, params, signal, onUpdate, ctx) => executeSubagentCollapsed(id, params, signal, onUpdate, ctx),
+    });
+    const promptTemplateBridge = registerPromptTemplateDelegationBridge({
+        events: pi.events,
+        getContext: () => state.lastUiContext,
+        execute: (requestId, params, signal, ctx, onUpdate) => executeSubagentCollapsed(requestId, params, signal, onUpdate, ctx),
+    });
+    const rpcBridge = registerSubagentRpcBridge({
+        events: pi.events,
+        getContext: () => state.lastUiContext,
+        execute: (id, params, signal, onUpdate, ctx) => executor.execute(id, params, signal, onUpdate, ctx),
+    });
+    function effectiveParallelTaskCount(tasks) {
+        if (!tasks || tasks.length === 0)
+            return 0;
+        return tasks.reduce((total, task) => {
+            const count = typeof task.count === "number" && Number.isInteger(task.count) && task.count >= 1 ? task.count : 1;
+            return total + count;
+        }, 0);
+    }
+    const tool = {
+        name: "subagent",
+        label: "Subagent",
+        description: buildSubagentToolDescription(config),
+        parameters: SubagentParams,
+        // lunr: sequential so multiple subagent calls in one turn run one-at-a-time
+        // instead of tripping the subagentInProgress guard (parallel mode uses the tasks array).
+        executionMode: "sequential",
+        prepareArguments(args) {
+            // Run friendly chain validation before pi-ai's raw TypeBox schema check
+            // so the model sees which property is disallowed, what is allowed, and a
+            // valid example instead of `chain.N: must not have additional properties`.
+            validateChainInput(args);
+            return args;
+        },
+        execute(id, params, signal, onUpdate, ctx) {
+            return executeSubagentCollapsed(id, params, signal, onUpdate, ctx);
+        },
+        renderCall(args, theme) {
+            if (args.action) {
+                const target = args.agent || args.chainName || "";
+                return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`, 0, 0);
+            }
+            const isParallel = (args.tasks?.length ?? 0) > 0;
+            const parallelCount = effectiveParallelTaskCount(args.tasks);
+            const asyncLabel = args.async === true && args.clarify !== true ? theme.fg("warning", " [async]") : "";
+            if (args.chain?.length)
+                return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}chain (${args.chain.length})${asyncLabel}`, 0, 0);
+            if (isParallel)
+                return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})${asyncLabel}`, 0, 0);
+            return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}${asyncLabel}`, 0, 0);
+        },
+        renderResult(result, options, theme, context) {
+            // lunr: hide the `subagent list` result body — the call row already shows
+            // the action; the roster stays in the transcript for the model.
+            if (context.args?.action === "list") {
+                return { render: () => [], invalidate() { } };
+            }
+            if (subagentResultIsRunning(result)) {
+                ensureSubagentResultAnimation(context);
+            }
+            else {
+                clearLegacyResultAnimationTimer(context);
+            }
+            const state = context.state;
+            // lunr: collect running-glyph line templates while rendering so the
+            // animation timer can rewrite them in place (see ensureSubagentResultAnimation).
+            const entries = [];
+            state.animEntries = entries;
+            subagentAnimSink.current = entries;
+            try {
+                return renderSubagentResult(result, options, theme, state.frame ?? 0);
+            }
+            finally {
+                subagentAnimSink.current = null;
+            }
+        },
+    };
+    pi.registerTool(tool);
+    // lunr: register a callback so toggling model tiers mid-session rebuilds the subagent
+    // tool description (adds/removes MODEL TIERS guidance) and refreshes the tool registry.
+    const modelTierBridge = globalThis[Symbol.for("@lunr/model-tiers")];
+    modelTierBridge?.registerToolDescriptionRefresher?.(() => {
+        tool.description = buildSubagentToolDescription(config);
+        pi.runtime.refreshTools();
+    });
+    registerWaitTool(pi, state, waitToolConfig.enabled);
+    pi.on("agent_end", async (_event, ctx) => {
+        if (ctx.hasUI)
+            return;
+        await drainOutstandingWork({ state, events: pi.events });
+    });
+    registerSlashCommands(pi, state);
+    const eventUnsubscribeStoreKey = "__piSubagentEventUnsubscribes";
+    const controlNoticeSeenStoreKey = "__piSubagentVisibleControlNotices";
+    const previousEventUnsubscribes = globalStore[eventUnsubscribeStoreKey];
+    if (Array.isArray(previousEventUnsubscribes)) {
+        for (const unsubscribe of previousEventUnsubscribes) {
+            if (typeof unsubscribe !== "function")
+                continue;
+            try {
+                unsubscribe();
+            }
+            catch {
+                // Best effort cleanup for stale handlers from an older reload.
+            }
+        }
+    }
+    registerSubagentNotify(pi, state, { batchConfig: config.completionBatch });
+    const existingVisibleControlNotices = globalStore[controlNoticeSeenStoreKey];
+    const visibleControlNotices = existingVisibleControlNotices instanceof Set ? existingVisibleControlNotices : new Set();
+    globalStore[controlNoticeSeenStoreKey] = visibleControlNotices;
+    const controlEventHandler = (payload) => {
+        handleSubagentControlNotice({
+            pi,
+            state,
+            visibleControlNotices,
+            details: payload,
+        });
+    };
+    const steeringNoticeHandler = (payload) => {
+        handleSubagentSteeringNotice({ pi, state, details: payload });
+    };
+    const eventUnsubscribes = [
+        pi.events.on(SUBAGENT_ASYNC_STARTED_EVENT, handleStarted),
+        pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete),
+        pi.events.on(SUBAGENT_CONTROL_EVENT, controlEventHandler),
+        pi.events.on(SUBAGENT_STEERING_NOTICE_EVENT, steeringNoticeHandler),
+        rpcBridge.dispose,
+    ];
+    globalStore[eventUnsubscribeStoreKey] = eventUnsubscribes;
+    pi.on("tool_result", (event, ctx) => {
+        if (event.toolName !== "subagent")
+            return;
+        if (!ctx.hasUI)
+            return;
+        state.lastUiContext = ctx;
+        if (state.asyncJobs.size > 0) {
+            refreshWidget(ctx);
+            ensurePoller();
+        }
+    });
+    const cleanupSessionArtifacts = (ctx) => {
+        try {
+            const sessionFile = ctx.sessionManager.getSessionFile();
+            if (sessionFile) {
+                cleanupOldArtifacts(getArtifactsDir(sessionFile), DEFAULT_ARTIFACT_CONFIG.cleanupDays);
+            }
+        }
+        catch {
+            // Cleanup failures should not block session lifecycle events.
+        }
+    };
+    const resetSessionState = (ctx) => {
+        state.baseCwd = ctx.cwd;
+        state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
+        state.subagentSpawns = { sessionId: state.currentSessionId, count: 0 };
+        // Set PI_SUBAGENT_PARENT_SESSION for permission-system forwarding.
+        // Only set in the root session (the interactive UI session), not in
+        // child subagent processes — children inherit the parent's value
+        // through the process environment at spawn time and must not overwrite
+        // it with their own session identity.
+        if (!process.env[SUBAGENT_CHILD_ENV]) {
+            const sessionId = ctx.sessionManager.getSessionId();
+            if (sessionId) {
+                process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId;
+            }
+        }
+        state.lastUiContext = ctx;
+        cleanupSessionArtifacts(ctx);
+        clearPendingForegroundControlNotices(state);
+        resetJobs(ctx);
+        restoreActiveJobs(ctx);
+        scheduledRunManager.bindSession(ctx);
+        restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
+        primeExistingResults();
+    };
+    pi.on("session_start", (_event, ctx) => {
+        resetSessionState(ctx);
+        rpcBridge.emitReady(ctx);
+        supervisorChannel.start();
+    });
+    pi.on("session_shutdown", () => {
+        delete process.env[SUBAGENT_PARENT_SESSION_ENV];
+        for (const unsubscribe of eventUnsubscribes) {
+            try {
+                unsubscribe();
+            }
+            catch {
+                // Best effort cleanup during shutdown.
+            }
+        }
+        if (globalStore[eventUnsubscribeStoreKey] === eventUnsubscribes) {
+            delete globalStore[eventUnsubscribeStoreKey];
+        }
+        stopResultWatcher();
+        scheduledRunManager.stop();
+        if (state.poller)
+            clearInterval(state.poller);
+        state.poller = null;
+        clearPendingForegroundControlNotices(state);
+        for (const timer of state.cleanupTimers.values()) {
+            clearTimeout(timer);
+        }
+        state.cleanupTimers.clear();
+        state.asyncJobs.clear();
+        clearSlashSnapshots();
+        slashBridge.cancelAll();
+        slashBridge.dispose();
+        promptTemplateBridge.cancelAll();
+        promptTemplateBridge.dispose();
+        supervisorChannel.dispose();
+        if (globalStore[runtimeCleanupStoreKey] === runtimeCleanup) {
+            delete globalStore[runtimeCleanupStoreKey];
+        }
+        try {
+            if (state.lastUiContext?.hasUI) {
+                state.lastUiContext.ui.setWidget(WIDGET_KEY, undefined);
+            }
+        }
+        catch (error) {
+            if (!isStaleExtensionContextError(error))
+                throw error;
+        }
+    });
+}
+//# sourceMappingURL=index.js.map