@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/extension/everyday-schemas.js

@@ -0,0 +1,207 @@
+import { Type } from "../shared/native-typebox.js";
+import { DelegateAcceptance } from "./acceptance-schema.js";
+import { HistoryQueryFields, TaskItem, requiredObject } from "./schema-overrides.js";
+export const DelegateParams = Type.Object({
+    agent: TaskItem.properties.agent,
+    task: TaskItem.properties.task,
+    label: TaskItem.properties.label,
+    cwd: TaskItem.properties.cwd,
+    model: TaskItem.properties.model,
+    context: Type.Optional(Type.Enum(["fresh", "fork"], {
+        type: "string",
+        description: "Override the profile's context policy.",
+    })),
+    async: Type.Optional(Type.Boolean({ description: "Background by default; false waits for the result." })),
+    worktree: Type.Optional(Type.Boolean({
+        description: "Isolate this writer in a Git worktree; return its patch. Requires a clean checkout.",
+    })),
+    output: TaskItem.properties.output,
+    acceptance: Type.Optional(DelegateAcceptance),
+}, { additionalProperties: false });
+export const AgentRunsValidationParams = Type.Object({
+    action: Type.Enum([
+        "list",
+        "inspect",
+        "history",
+        "search",
+        "nudge",
+        "stop",
+        "continue",
+        "profiles",
+        "questions",
+        "answer",
+        "review",
+    ], { type: "string" }),
+    id: Type.Optional(Type.String({ minLength: 1, description: "Run ID or unambiguous prefix." })),
+    questionId: Type.Optional(Type.String({
+        minLength: 1,
+        description: "Durable supervisor question ID for exact questions lookup or answer.",
+    })),
+    async: Type.Optional(Type.Boolean({
+        description: "Continue/answer: false waits for the actual continuation result.",
+    })),
+    index: Type.Optional(Type.Integer({ minimum: 0, description: "Child index for a multi-child run." })),
+    message: Type.Optional(Type.String({
+        minLength: 1,
+        description: "Guidance, follow-up, answer, or optional parent-only review note. Review notes are not sent to the child; put actionable instructions in continue/nudge. Only continue/answer can start a saved child.",
+    })),
+    decision: Type.Optional(Type.Enum(["accepted", "needs_changes"], {
+        type: "string",
+        description: "Parent-only review outcome; not sent to the child. Separate from execution and runtime acceptance checks.",
+    })),
+    offset: Type.Optional(Type.Integer({
+        minimum: 0,
+        description: "List/questions offset; history is retained regardless of page size.",
+    })),
+    limit: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Results per list/questions/search/history page (default 20; history 100).",
+    })),
+    ...HistoryQueryFields,
+    full: Type.Optional(Type.Boolean({
+        description: "Inspect only: include the full task and saved launch configuration. Default is a concise report; stored data is unchanged.",
+    })),
+    agent: Type.Optional(Type.String({
+        minLength: 1,
+        description: "List/search: filter by child agent. Continue/answer: adopt this current profile, including model, thinking and fallbacks; a separate model override wins. Otherwise keep saved settings. Required for old runs without a saved profile.",
+    })),
+    model: TaskItem.properties.model,
+    cwd: TaskItem.properties.cwd,
+    output: TaskItem.properties.output,
+    acceptance: TaskItem.properties.acceptance,
+}, {
+    additionalProperties: false,
+    allOf: [
+        {
+            if: {
+                properties: {
+                    action: {
+                        enum: ["inspect", "history", "nudge", "stop", "continue", "answer", "review"],
+                    },
+                },
+            },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("id"),
+        },
+        {
+            if: { properties: { action: { enum: ["search"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("query"),
+        },
+        {
+            if: { properties: { action: { enum: ["nudge", "continue", "answer"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("message"),
+        },
+        {
+            if: { properties: { action: { enum: ["answer"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("questionId"),
+        },
+        {
+            if: { properties: { action: { enum: ["review"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("decision"),
+        },
+        {
+            if: {
+                anyOf: [
+                    requiredObject("async"),
+                    requiredObject("model"),
+                    requiredObject("cwd"),
+                    requiredObject("output"),
+                    requiredObject("acceptance"),
+                ],
+            },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["continue", "answer"] } } },
+        },
+        {
+            if: requiredObject("agent"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list", "search", "continue", "answer"] } } },
+        },
+        {
+            if: requiredObject("offset"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list", "questions"] } } },
+        },
+        {
+            if: requiredObject("limit"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list", "questions", "history", "search"] } } },
+        },
+        {
+            if: requiredObject("cursor"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list", "history", "search"] } } },
+        },
+        {
+            if: requiredObject("sort"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list", "search"] } } },
+        },
+        { not: { anyOf: [requiredObject("cursor", "offset"), requiredObject("cursor", "before")] } },
+        {
+            if: { allOf: [{ properties: { action: { enum: ["search"] } } }, requiredObject("index")] },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: requiredObject("id"),
+        },
+        {
+            if: { anyOf: [requiredObject("state"), requiredObject("text")] },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["list"] } } },
+        },
+        {
+            if: requiredObject("query"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["search"] } } },
+        },
+        {
+            if: requiredObject("before"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["history"] } } },
+        },
+        {
+            if: { properties: { action: { enum: ["list"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { sort: { enum: ["attention", "newest", "oldest"] } } },
+        },
+        {
+            if: { properties: { action: { enum: ["search"] } } },
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { sort: { enum: ["relevance", "newest"] } } },
+        },
+        {
+            if: requiredObject("decision"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["review"] } } },
+        },
+        {
+            if: requiredObject("full"),
+            // JSON Schema's non-callable consequence keyword is not a Promise method.
+            // oxlint-disable-next-line unicorn/no-thenable
+            then: { properties: { action: { enum: ["inspect"] } } },
+        },
+    ],
+});
+export const AgentRunsParams = Type.Object({ ...AgentRunsValidationParams.properties, acceptance: Type.Optional(DelegateAcceptance) }, { additionalProperties: false });

package/dist/extension/fanout-child.js

@@ -1,326 +1,25 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-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_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_EAGER_TOOL_ENV, SUBAGENT_PARENT_CHILD_INDEX_ENV } from "../runs/shared/pi-args.js";
-import { readNestedControlRequests, resolveNestedRouteFromEnv, writeNestedControlResult } 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 { registerToolResultAdapter } from "./tool-result.js";
-import { renderSubagentResult } from "../tui/render.js";
-import {} from "../shared/types.js";
-import { finalizedChildUsage, registerParentUsage } from "../runs/shared/parent-usage.js";
-import { resolveCurrentSessionId } from "../shared/session-identity.js";
-import { OWNED_RUN_ENTRY, ownedRunList, restoreOwnedRunsAsync } from "../runs/shared/run-records.js";
-import { closeRunHistory, startRunHistory } from "../runs/shared/history-index.js";
-import { createCompletionDelivery } from "../runs/background/completion-delivery.js";
-function getSubagentSessionRoot(parentSessionFile) {
-    if (parentSessionFile) {
-        const baseName = path.basename(parentSessionFile, ".jsonl");
-        const sessionsDir = path.dirname(parentSessionFile);
-        return path.join(sessionsDir, baseName);
+import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.js";
+import { CHILD_CLEANUP_KEY, FanoutChildRuntime } from "./child-runtime.js";
+import { cleanupStaleRuntime, sharedRuntimeValue, setSharedRuntimeValue, } from "./runtime-reload.js";
+const REGISTERED_APIS_KEY = "__piSubagentFanoutChildRegisteredApis";
+function registeredApis() {
+    const value = sharedRuntimeValue(REGISTERED_APIS_KEY);
+    if (value instanceof WeakSet) {
+        return value;
     }
-    return fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
-}
-function expandTilde(p) {
-    return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
-}
-function createChildSafeState() {
-    return {
-        baseCwd: "",
-        currentSessionId: null,
-        asyncJobs: new Map(),
-        foregroundRuns: new Map(),
-        cleanupTimers: new Map(),
-        lastUiContext: null,
-        poller: null,
-        completionSeen: new Map(),
-        watcher: null,
-        watcherRestartTimer: null,
-        resultFileCoalescer: {
-            schedule: () => false,
-            clear: () => { },
-        },
-    };
-}
-function addBounded(set, value, max = 1000) {
-    set.add(value);
-    while (set.size > max)
-        set.delete(set.values().next().value);
-}
-function startNestedControlInboxListener(pi, state, isRestoring) {
-    let route;
-    try {
-        route = resolveNestedRouteFromEnv();
-    }
-    catch {
-        return undefined;
-    }
-    if (!route)
-        return undefined;
-    const seen = new Set();
-    const seenFiles = new Set();
-    const inFlight = new Set();
-    const pendingResults = new Map();
-    const parsedChildIndex = Number(process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV]);
-    const localChildIndex = Number.isInteger(parsedChildIndex) && parsedChildIndex >= 0 ? parsedChildIndex : undefined;
-    const timer = setInterval(() => {
-        if (isRestoring())
-            return;
-        try {
-            for (const request of readNestedControlRequests(route, seenFiles)) {
-                if (seen.has(request.requestId) || inFlight.has(request.requestId))
-                    continue;
-                if (request.targetChildIndex !== undefined && request.targetChildIndex !== localChildIndex)
-                    continue;
-                const owned = state.ownedRuns?.get(request.targetRunId);
-                const asyncJob = state.asyncJobs.get(request.targetRunId);
-                if (!owned && !asyncJob && (request.targetChildIndex !== undefined || Date.now() - request.ts < 400))
-                    continue;
-                inFlight.add(request.requestId);
-                void (async () => {
-                    const claimPath = `${request.filePath}.claimed`;
-                    try {
-                        let result = pendingResults.get(request.requestId);
-                        if (!result && pendingResults.size >= 100) {
-                            result = {
-                                ts: Date.now(),
-                                requestId: request.requestId,
-                                targetRunId: request.targetRunId,
-                                ok: false,
-                                message: "Nested control result queue is full; retry after pending results are delivered.",
-                            };
-                        }
-                        if (!result) {
-                            try {
-                                const claimFd = fs.openSync(claimPath, "wx", 0o600);
-                                try {
-                                    fs.writeFileSync(claimFd, `${request.requestId}\n`, "utf-8");
-                                }
-                                finally {
-                                    fs.closeSync(claimFd);
-                                }
-                            }
-                            catch (error) {
-                                const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
-                                result = {
-                                    ts: Date.now(),
-                                    requestId: request.requestId,
-                                    targetRunId: request.targetRunId,
-                                    ok: false,
-                                    message: code === "EEXIST"
-                                        ? "Nested control request was already claimed; refusing to execute it again because the original outcome is unavailable."
-                                        : `Failed to claim nested control request safely: ${error instanceof Error ? error.message : String(error)}`,
-                                };
-                            }
-                        }
-                        if (!result) {
-                            let ok = false;
-                            let message = "Control request failed.";
-                            try {
-                                const asyncDir = state.ownedRuns?.get(request.targetRunId)?.asyncDir ?? state.asyncJobs.get(request.targetRunId)?.asyncDir;
-                                const status = asyncDir ? readStatus(asyncDir) : null;
-                                if (!status || status.state !== "running") {
-                                    message = `Nested run ${request.targetRunId} is not active in this fanout child.`;
-                                }
-                                else if (request.action === "interrupt") {
-                                    const receipt = interruptAsyncRun(state, request.targetRunId, request.index);
-                                    ok = Boolean(receipt && !receipt.isError);
-                                    message = receipt?.content.map((part) => part.type === "text" ? part.text : "").join("\n") ?? "Nested run is not interruptible.";
-                                }
-                                else if (!request.message?.trim()) {
-                                    message = "Nested resume requires message.";
-                                }
-                                else {
-                                    const index = request.index ?? status.steps?.findIndex((step) => step.status === "running") ?? -1;
-                                    const step = status.steps?.[index];
-                                    const agent = step?.status === "running" ? step.agent : undefined;
-                                    if (!agent) {
-                                        message = `Nested run ${request.targetRunId} has no active child message route.`;
-                                    }
-                                    else {
-                                        const target = resolveSubagentIntercomTarget(request.targetRunId, agent, index);
-                                        ok = await deliverSubagentIntercomMessageEvent(pi.events, target, `Follow-up for nested run ${request.targetRunId} (${agent}):\n\n${request.message.trim()}`, 500, { source: "nested-resume", runId: request.targetRunId, agent, index });
-                                        message = ok
-                                            ? `Delivered follow-up to live nested run ${request.targetRunId}.`
-                                            : `Nested child intercom target is not registered: ${target}`;
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                message = error instanceof Error ? error.message : String(error);
-                            }
-                            result = { ts: Date.now(), requestId: request.requestId, targetRunId: request.targetRunId, ok, message };
-                        }
-                        try {
-                            writeNestedControlResult(route, result);
-                        }
-                        catch (error) {
-                            if (pendingResults.size < 100 || pendingResults.has(request.requestId))
-                                pendingResults.set(request.requestId, result);
-                            console.error(`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route.controlInbox}'; keeping request for retry:`, error);
-                            return;
-                        }
-                        pendingResults.delete(request.requestId);
-                        addBounded(seen, request.requestId);
-                        addBounded(seenFiles, path.basename(request.filePath));
-                        let requestRemoved = false;
-                        try {
-                            fs.unlinkSync(request.filePath);
-                            requestRemoved = true;
-                        }
-                        catch (error) {
-                            const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
-                            requestRemoved = code === "ENOENT";
-                        }
-                        if (requestRemoved) {
-                            try {
-                                fs.unlinkSync(claimPath);
-                            }
-                            catch { }
-                        }
-                    }
-                    finally {
-                        inFlight.delete(request.requestId);
-                    }
-                })();
-            }
-        }
-        catch (error) {
-            console.error(`Failed to poll nested control inbox '${route.controlInbox}' for root '${route.rootRunId}':`, error);
-        }
-    }, 200);
-    timer.unref?.();
-    return timer;
+    const apis = new WeakSet();
+    setSharedRuntimeValue(REGISTERED_APIS_KEY, apis);
+    return apis;
 }
 export default function registerFanoutChildSubagentExtension(pi) {
-    if (process.env[SUBAGENT_CHILD_ENV] !== "1" || process.env[SUBAGENT_FANOUT_CHILD_ENV] !== "1")
+    if (process.env[SUBAGENT_CHILD_ENV] !== "1" || process.env[SUBAGENT_FANOUT_CHILD_ENV] !== "1") {
         return;
-    const globalStore = globalThis;
-    const registeredKey = "__piSubagentFanoutChildRegisteredApis";
-    const registeredApis = globalStore[registeredKey] instanceof WeakSet
-        ? globalStore[registeredKey]
-        : new WeakSet();
-    globalStore[registeredKey] = registeredApis;
-    if (registeredApis.has(pi))
+    }
+    const apis = registeredApis();
+    if (apis.has(pi)) {
         return;
-    registeredApis.add(pi);
-    const controlInboxCleanupStoreKey = "__piSubagentFanoutChildControlInboxCleanup";
-    const previousControlInboxCleanup = globalStore[controlInboxCleanupStoreKey];
-    if (typeof previousControlInboxCleanup === "function") {
-        try {
-            previousControlInboxCleanup();
-        }
-        catch {
-            // Best effort cleanup for stale timers from an older reload.
-        }
     }
-    const config = loadConfig();
-    const state = createChildSafeState();
-    state.persistOwnedRun = (run) => pi.appendEntry(OWNED_RUN_ENTRY, run);
-    let sessionReset;
-    const ensureSessionState = (ctx) => {
-        const sessionId = resolveCurrentSessionId(ctx.sessionManager);
-        if (sessionReset)
-            return sessionReset;
-        if (state.currentSessionId === sessionId) {
-            state.lastUiContext = ctx;
-            return;
-        }
-        sessionReset = (async () => {
-            await completionDelivery.stopAndJoin();
-            state.lastUiContext = ctx;
-            void closeRunHistory(state).catch((error) => console.error("Could not close child history:", error));
-            state.foregroundRuns?.clear();
-            await restoreOwnedRunsAsync(state, ctx);
-            state.currentSessionId = sessionId;
-            startRunHistory(state, ctx);
-            completionDelivery.start();
-        })().finally(() => { sessionReset = undefined; });
-        return sessionReset;
-    };
-    pi.on("session_start", async (_event, ctx) => {
-        await ensureSessionState(ctx);
-    });
-    const executor = createSubagentExecutor({
-        pi,
-        state,
-        config,
-        // Keep the stock nested default foreground so evidence returns before this caller exits.
-        asyncByDefault: config.asyncByDefault === true,
-        tempArtifactsDir: getArtifactsDir(null),
-        getSubagentSessionRoot,
-        expandTilde,
-        discoverAgents,
-        allowMutatingManagementActions: false,
-        ensureSessionState,
-    });
-    const compact = config.compactChildTools !== false;
-    const toolNames = compact ? ["subagent", "delegate", "agent_runs"] : ["subagent"];
-    const parentUsage = registerParentUsage(pi, toolNames);
-    const completionDelivery = createCompletionDelivery(pi, state, parentUsage);
-    const adaptToolResult = registerToolResultAdapter(pi, toolNames);
-    const toRegisteredToolResult = (result, ctx) => adaptToolResult(result.details.wait?.status === "completed" && result.details.run?.ownerSessionId === ctx.sessionManager.getSessionId()
-        ? parentUsage.attach(result, finalizedChildUsage(result.details.run.children, result.details.wait.index), ctx)
-        : result);
-    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.",
-    ];
-    const guidelines = [
-        "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.",
-        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.",
-    ];
-    if (compact)
-        registerCompactSubagentTools(pi, { executor, state, adapt: toRegisteredToolResult, guidelines: [...guidelines, ...acceptanceGuidelines], childSafe: true,
-            asyncByDefault: config.asyncByDefault === true, keepAdvancedActive: process.env[SUBAGENT_EAGER_TOOL_ENV] === "1",
-            listRuns: async (params, ctx) => { await ensureSessionState(ctx); return ownedRunList(state, params); },
-        });
-    const tool = {
-        name: "subagent",
-        defaultActive: !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: guidelines,
-        parameters: SubagentParams,
-        async execute(id, params, signal, onUpdate, ctx) {
-            return toRegisteredToolResult(await executor.execute(id, normalizeSubagentParamsLike(params), signal, onUpdate, ctx), ctx);
-        },
-        renderResult: renderSubagentResult,
-    };
-    pi.registerTool(tool);
-    const controlInboxTimer = startNestedControlInboxListener(pi, state, () => sessionReset !== undefined);
-    const clearControlInboxTimer = () => {
-        if (controlInboxTimer)
-            clearInterval(controlInboxTimer);
-        completionDelivery.stop();
-        return closeRunHistory(state);
-    };
-    globalStore[controlInboxCleanupStoreKey] = clearControlInboxTimer;
-    pi.on("session_shutdown", async () => {
-        if (controlInboxTimer)
-            clearInterval(controlInboxTimer);
-        await completionDelivery.stopAndJoin({ preservePending: true });
-        await closeRunHistory(state);
-        if (globalStore[controlInboxCleanupStoreKey] === clearControlInboxTimer) {
-            delete globalStore[controlInboxCleanupStoreKey];
-        }
-    });
+    apis.add(pi);
+    cleanupStaleRuntime(CHILD_CLEANUP_KEY);
+    new FanoutChildRuntime(pi).register();
 }