@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/extension/config.js

@@ -0,0 +1,22 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "../shared/utils.js";
+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;
+        }
+    }
+    catch (error) {
+        console.error(`Failed to load subagent config from '${configPath}':`, error);
+    }
+    return {};
+}

package/dist/extension/control-notices.js

@@ -0,0 +1,29 @@
+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 (!input.details?.event || 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/doctor.js

@@ -0,0 +1,143 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { VERSION as PI_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 EXTENSION_MODULE = fileURLToPath(import.meta.url);
+function errorText(error) {
+    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+function lineFromCheck(label, check) {
+    try {
+        return check();
+    }
+    catch (error) {
+        return `- ${label}: failed — ${errorText(error)}`;
+    }
+}
+function formatExistingDirectory(label, dirPath) {
+    try {
+        if (!fs.existsSync(dirPath))
+            return `- ${label}: missing (${dirPath})`;
+        const stats = fs.statSync(dirPath);
+        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})`;
+    }
+    catch (error) {
+        return `- ${label}: failed (${dirPath}) — ${errorText(error)}`;
+    }
+}
+function formatSourceCounts(counts) {
+    return `builtin ${counts.builtin}, package ${counts.package}, user ${counts.user}, project ${counts.project}`;
+}
+function formatSkillSourceCounts(skills) {
+    const counts = new Map();
+    for (const skill of skills)
+        counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
+    const ordered = [
+        "project",
+        "project-settings",
+        "project-package",
+        "user",
+        "user-settings",
+        "user-package",
+        "extension",
+        "builtin",
+        "unknown",
+    ];
+    const parts = ordered
+        .map((source) => `${source} ${counts.get(source) ?? 0}`)
+        .filter((part) => !part.endsWith(" 0"));
+    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);
+    }
+    return "not configured";
+}
+function formatSessionLines(input) {
+    const sessionFile = input.currentSessionFile ?? null;
+    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 id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
+    ];
+    if (input.sessionError)
+        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 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 });
+            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 });
+            return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
+        }),
+    ];
+}
+function formatIntercomSection(input) {
+    return [
+        `- bridge: ${input.connection ? "responding" : "unavailable (no live health response)"}`,
+        `- connection: ${input.connection?.status ?? "unknown"}${input.connection?.reason ? ` — ${input.connection.reason}` : ""}`,
+        `- broker session id: ${input.connection?.sessionId ?? "not available"}`,
+        `- orchestrator target: ${input.orchestratorTarget?.trim() || "not available"}`,
+    ];
+}
+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}`] : []),
+        `- 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)`,
+        "- 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)"}`,
+        `- extension module: ${EXTENSION_MODULE}`,
+        "- async support: available (Node >=24)",
+        ...formatSessionLines(input),
+        "",
+        "Filesystem",
+        formatExistingDirectory("temp root", TEMP_ROOT_DIR),
+        formatExistingDirectory("async runs", ASYNC_DIR),
+        formatExistingDirectory("results", RESULTS_DIR),
+        formatExistingDirectory("chain runs", CHAIN_RUNS_DIR),
+        "",
+        "Discovery",
+        ...formatDiscovery(input),
+        "",
+        "Intercom",
+        ...formatIntercomSection(input),
+    ];
+    return lines.join("\n");
+}

package/dist/extension/fanout-child.js

@@ -0,0 +1,326 @@
+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);
+    }
+    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;
+}
+export default function registerFanoutChildSubagentExtension(pi) {
+    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))
+        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];
+        }
+    });
+}