@bubblebrain-ai/bubble 0.0.46 → 0.0.48

package/dist/agent/subagent-control.d.ts

@@ -61,6 +61,11 @@ export interface SubagentThreadRecord {
     /** True for agents spawned inside a run_workflow: kept out of list_agents /
      * wait_agent and not persisted (design v2 appendix; option C). */
     workflowInternal?: boolean;
+    /** A SubagentStart hook fired for the current logical run and its paired
+     * SubagentStop has not fired yet (design §9). Lets terminal paths that
+     * assume "the run never started" — cancel during a retry backoff — close
+     * the pair instead of leaking an unmatched Start. */
+    hookStopPending?: boolean;
     abortController: AbortController;
     waiters: Set<() => void>;
     agent?: {

package/dist/agent/subagent-store.d.ts

@@ -13,9 +13,25 @@
  */
 import { type SubagentThreadRecord, type SubagentThreadStatus } from "./subagent-control.js";
 export declare class SubagentStore {
-    private readonly persistDir?;
     private readonly threads;
-    constructor(persistDir?: string | undefined);
+    private persistDir?;
+    constructor(persistDir?: string);
+    /**
+     * Repoints persistence at a different session's directory (the TUI reuses
+     * one Agent across session switches; see Agent.setSessionID).
+     *
+     * Final non-workflow records are evicted first: they are already persisted
+     * in the OLD directory and reloadable by switching back, and keeping them
+     * would leak one session's children into another's list_agents — growing
+     * monotonically with every switch. Live records stay (their runs are still
+     * attached to this process; their eventual persist lands in the new
+     * directory — an accepted tradeoff, preferable to losing them). Workflow-
+     * internal records stay because a running workflow's schema-correction
+     * retry looks its members up in this store by agentId.
+     *
+     * `undefined` disables persistence and loads nothing; threads are kept.
+     */
+    repoint(persistDir: string | undefined): void;
     get(agentId: string): SubagentThreadRecord | undefined;
     set(record: SubagentThreadRecord): void;
     values(): SubagentThreadRecord[];

package/dist/agent/subagent-store.js

@@ -16,11 +16,37 @@ import { join } from "node:path";
 import { isFinalSubagentThreadStatus, } from "./subagent-control.js";
 const PERSIST_SCHEMA_VERSION = 1;
 export class SubagentStore {
-    persistDir;
     threads = new Map();
+    persistDir;
     constructor(persistDir) {
         this.persistDir = persistDir;
     }
+    /**
+     * Repoints persistence at a different session's directory (the TUI reuses
+     * one Agent across session switches; see Agent.setSessionID).
+     *
+     * Final non-workflow records are evicted first: they are already persisted
+     * in the OLD directory and reloadable by switching back, and keeping them
+     * would leak one session's children into another's list_agents — growing
+     * monotonically with every switch. Live records stay (their runs are still
+     * attached to this process; their eventual persist lands in the new
+     * directory — an accepted tradeoff, preferable to losing them). Workflow-
+     * internal records stay because a running workflow's schema-correction
+     * retry looks its members up in this store by agentId.
+     *
+     * `undefined` disables persistence and loads nothing; threads are kept.
+     */
+    repoint(persistDir) {
+        if (persistDir === this.persistDir)
+            return;
+        for (const [agentId, record] of this.threads) {
+            if (isFinalSubagentThreadStatus(record.status) && !record.workflowInternal) {
+                this.threads.delete(agentId);
+            }
+        }
+        this.persistDir = persistDir;
+        this.loadPersisted();
+    }
     get(agentId) {
         return this.threads.get(agentId);
     }
@@ -62,6 +88,11 @@ export class SubagentStore {
             return;
         if (!isFinalSubagentThreadStatus(record.status))
             return;
+        // Workflow-internal members never persist (design: they never re-import
+        // on restart). The onFinal gate alone was not enough — markDelivered
+        // reaches persist too (known-defects #5) — so the store enforces it.
+        if (record.workflowInternal)
+            return;
         try {
             mkdirSync(this.persistDir, { recursive: true });
             const payload = {

package/dist/agent/tool-intent.d.ts

@@ -24,6 +24,16 @@ export interface ParsedSearchCommand {
     pattern: string;
     path?: string;
     include?: string;
+    /**
+     * True only when a structured-grep rewrite would execute EXACTLY what the
+     * model asked for. False whenever anything was dropped or reinterpreted:
+     * unknown flags (-i, -A, -w, ...), --iglob (case-insensitivity lost),
+     * --include under rg (not an rg flag - a faithful run would error), more
+     * than one path, or the `grep` binary itself (BRE dialect vs the tool's
+     * rg engine). Observation (intent classification) tolerates lossy parses;
+     * execution rewriting must not (tool-arbiter).
+     */
+    lossless: boolean;
 }
 export interface ParsedReadCommand {
     path: string;

package/dist/agent/tool-intent.js

@@ -79,6 +79,10 @@ export function parseSearchBashCommand(command) {
     if (!["grep", "rg", "ripgrep"].includes(binary)) {
         return undefined;
     }
+    // The structured grep tool shells out to rg, so only rg-origin commands
+    // can be dialect-identical; GNU grep patterns are BRE and must not be
+    // silently re-executed under rg's Rust regex engine.
+    let lossless = binary !== "grep";
     const positional = [];
     let include;
     for (let index = 1; index < tokens.length; index++) {
@@ -87,14 +91,24 @@ export function parseSearchBashCommand(command) {
             continue;
         if (token === "--glob" || token === "--iglob" || token === "--include") {
             include = tokens[index + 1];
+            // --iglob loses case-insensitivity in translation; --include is not an
+            // rg flag at all (a faithful run would error, and hiding that from the
+            // model masks its mistake). Only --glob maps 1:1 onto the tool.
+            if (token !== "--glob")
+                lossless = false;
             index += 1;
             continue;
         }
         if (token.startsWith("--glob=") || token.startsWith("--iglob=") || token.startsWith("--include=")) {
             include = token.slice(token.indexOf("=") + 1);
+            if (!token.startsWith("--glob="))
+                lossless = false;
             continue;
         }
         if (token.startsWith("-")) {
+            // Any other flag (-i, -A 3, -w, -l, ...) has no representation in the
+            // structured tool; dropping it would change the search's meaning.
+            lossless = false;
             continue;
         }
         positional.push(token);
@@ -102,11 +116,15 @@ export function parseSearchBashCommand(command) {
     if (positional.length === 0) {
         return undefined;
     }
+    // A third positional (multiple search roots) cannot be expressed either.
+    if (positional.length > 2)
+        lossless = false;
     const [pattern, maybePath] = positional;
     return {
         pattern,
         path: maybePath,
         include,
+        lossless,
     };
 }
 export function parseReadBashCommand(command) {

package/dist/agent/tool-visibility.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transcript visibility of tool results.
+ *
+ * `hiddenFromTranscript` is a general mechanism: a hook may block a tool call
+ * and mark the exchange hidden so it never reaches the model's transcript or
+ * the UI. These helpers are the canonical way to test for it.
+ */
+import type { ToolResult, ToolResultMetadata } from "../types.js";
+export declare function isHiddenToolResult(result: ToolResult | undefined): result is ToolResult;
+export declare function isHiddenToolMetadata(metadata: ToolResultMetadata | undefined): boolean;

package/dist/agent/tool-visibility.js

@@ -0,0 +1,6 @@
+export function isHiddenToolResult(result) {
+    return result?.metadata?.hiddenFromTranscript === true;
+}
+export function isHiddenToolMetadata(metadata) {
+    return metadata?.hiddenFromTranscript === true;
+}

package/dist/agent/workflow/runs.d.ts

@@ -0,0 +1,72 @@
+import { type WorkflowRunSnapshot } from "./control.js";
+import type { AgentProfile } from "../profiles.js";
+import type { SubagentThreadSnapshot } from "../subagent-control.js";
+import type { ToolUpdate } from "../../types.js";
+export interface WorkflowExecuteOptions {
+    script: string;
+    args?: unknown;
+    parentToolCallId: string;
+    abortSignal?: AbortSignal;
+    directEmit?: (update: ToolUpdate) => void;
+    queueUpdates?: boolean;
+    ensureProfileTrusted?: (profile: AgentProfile) => Promise<{
+        content: string | unknown;
+    } | undefined>;
+}
+export interface WorkflowExecuteOutcome {
+    result: {
+        ok: true;
+        value: unknown;
+    } | {
+        ok: false;
+        error: string;
+    };
+    agentCount: number;
+    logs: string[];
+    snapshots: SubagentThreadSnapshot[];
+}
+export interface WorkflowLedgerDeps {
+    /** Runs the script. Supplied by Agent — the ledger never executes anything itself. */
+    execute(cwd: string, options: WorkflowExecuteOptions): Promise<WorkflowExecuteOutcome>;
+}
+export declare class WorkflowLedger {
+    private readonly deps;
+    private readonly runs;
+    /** Completed runs whose result has not yet been announced to the parent. */
+    private readonly pendingDeliveries;
+    constructor(deps: WorkflowLedgerDeps);
+    hasRunning(): boolean;
+    /**
+     * Starts a workflow in the BACKGROUND: returns a runId immediately; the
+     * script runs detached, its agents stream progress through the queued
+     * channel (drained at turn boundaries like spawn_agent), and its result is
+     * ingested at the next turn. Collect explicitly with wait().
+     */
+    start(cwd: string, options: {
+        script: string;
+        args?: unknown;
+        title?: string;
+        parentToolCallId: string;
+        abortSignal?: AbortSignal;
+        ensureProfileTrusted?: (profile: AgentProfile) => Promise<{
+            content: string | unknown;
+        } | undefined>;
+    }): {
+        runId: string;
+        title: string;
+    };
+    /**
+     * Blocks until a background workflow reaches a final state (or times out).
+     * `timeoutMs` must already be normalized by the caller.
+     */
+    wait(runId: string, timeoutMs: number): Promise<WorkflowRunSnapshot | undefined>;
+    /** Cancels a running background workflow. */
+    close(runId: string): WorkflowRunSnapshot | undefined;
+    list(): WorkflowRunSnapshot[];
+    /**
+     * Completed background-workflow results to announce before the next turn
+     * (§5 analog). Marks each record delivered, so a notice is emitted once.
+     */
+    drainDeliveryNotices(): string[];
+    private snapshot;
+}

package/dist/agent/workflow/runs.js

@@ -0,0 +1,157 @@
+/**
+ * Background workflow run ledger (option C Phase 4).
+ *
+ * Owns run records, waiters, cancellation and the pending-delivery set —
+ * everything about tracking a detached workflow EXCEPT actually executing the
+ * script, which stays on Agent (it needs subagent dispatch, profiles and the
+ * concurrency gate) and arrives here as the single injected `execute` callback.
+ *
+ * Delivery notices are PULLED (`drainDeliveryNotices`) rather than pushed into
+ * the parent, matching ResultIntegrator.drainNotices: the ledger never holds a
+ * reference back to the agent.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { getBubbleHome } from "../../bubble-home.js";
+import { composeAbortSignals } from "../budget-ledger.js";
+import { buildWorkflowDeliveryNotice, renderWorkflowResultValue } from "./control.js";
+export class WorkflowLedger {
+    deps;
+    runs = new Map();
+    /** Completed runs whose result has not yet been announced to the parent. */
+    pendingDeliveries = new Set();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    hasRunning() {
+        return [...this.runs.values()].some((record) => record.status === "running");
+    }
+    /**
+     * Starts a workflow in the BACKGROUND: returns a runId immediately; the
+     * script runs detached, its agents stream progress through the queued
+     * channel (drained at turn boundaries like spawn_agent), and its result is
+     * ingested at the next turn. Collect explicitly with wait().
+     */
+    start(cwd, options) {
+        const runId = randomUUID();
+        const abortController = new AbortController();
+        const composed = composeAbortSignals([options.abortSignal, abortController.signal]);
+        if (composed) {
+            composed.addEventListener("abort", () => abortController.abort(composed.reason), { once: true });
+        }
+        const record = {
+            runId,
+            title: options.title ?? "workflow",
+            status: "running",
+            agentCount: 0,
+            snapshots: [],
+            logs: [],
+            abortController,
+            waiters: new Set(),
+            createdAt: Date.now(),
+            parentToolCallId: options.parentToolCallId,
+        };
+        this.runs.set(runId, record);
+        record.promise = this.deps.execute(cwd, {
+            script: options.script,
+            args: options.args,
+            parentToolCallId: options.parentToolCallId,
+            abortSignal: abortController.signal,
+            queueUpdates: true,
+            ensureProfileTrusted: options.ensureProfileTrusted,
+        }).then((out) => {
+            record.agentCount = out.agentCount;
+            record.snapshots = out.snapshots;
+            record.logs = out.logs;
+            record.result = out.result;
+            record.status = out.result.ok ? "completed" : (abortController.signal.aborted ? "cancelled" : "failed");
+            if (out.result.ok)
+                record.resultPath = persistWorkflowResult(runId, out.result.value);
+        }, (error) => {
+            record.result = { ok: false, error: error?.message || String(error) };
+            record.status = "failed";
+        }).finally(() => {
+            record.updatedAt = Date.now();
+            this.pendingDeliveries.add(runId);
+            for (const waiter of record.waiters)
+                waiter();
+            record.waiters.clear();
+        });
+        return { runId, title: record.title };
+    }
+    /**
+     * Blocks until a background workflow reaches a final state (or times out).
+     * `timeoutMs` must already be normalized by the caller.
+     */
+    async wait(runId, timeoutMs) {
+        const record = this.runs.get(runId);
+        if (!record)
+            return undefined;
+        if (record.status === "running") {
+            let waiter;
+            await Promise.race([
+                new Promise((resolve) => { waiter = resolve; record.waiters.add(resolve); }),
+                new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+            ]).finally(() => { if (waiter)
+                record.waiters.delete(waiter); });
+        }
+        if (record.status !== "running")
+            this.pendingDeliveries.delete(runId);
+        return this.snapshot(record);
+    }
+    /** Cancels a running background workflow. */
+    close(runId) {
+        const record = this.runs.get(runId);
+        if (!record)
+            return undefined;
+        if (record.status === "running")
+            record.abortController.abort(new Error("workflow cancelled"));
+        return this.snapshot(record);
+    }
+    list() {
+        return [...this.runs.values()].map((record) => this.snapshot(record));
+    }
+    /**
+     * Completed background-workflow results to announce before the next turn
+     * (§5 analog). Marks each record delivered, so a notice is emitted once.
+     */
+    drainDeliveryNotices() {
+        if (this.pendingDeliveries.size === 0)
+            return [];
+        const notices = [];
+        for (const runId of [...this.pendingDeliveries]) {
+            this.pendingDeliveries.delete(runId);
+            const record = this.runs.get(runId);
+            if (!record || record.status === "running" || record.deliveredAt)
+                continue;
+            record.deliveredAt = Date.now();
+            notices.push(buildWorkflowDeliveryNotice(this.snapshot(record)));
+        }
+        return notices;
+    }
+    snapshot(record) {
+        return {
+            runId: record.runId,
+            title: record.title,
+            status: record.status,
+            agentCount: record.agentCount,
+            result: record.result,
+            resultPath: record.resultPath,
+            logs: record.logs,
+            snapshots: record.snapshots,
+        };
+    }
+}
+function persistWorkflowResult(runId, value) {
+    try {
+        const dir = join(getBubbleHome(), "workflows");
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, `${runId}.result.txt`);
+        writeFileSync(path, renderWorkflowResultValue(value));
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/agent.d.ts

@@ -8,6 +8,7 @@ import { type TurnHooks } from "./orchestrator/hooks.js";
 import type { ExternalHookController } from "./hooks/controller.js";
 import { type AgentCategoriesConfig, type ResolvedSubagentRoute } from "./agent/categories.js";
 import { type AgentRoutingConfig, type RoutableModelEntry, type RoutableModelIndex, type RoutingSnapshotAccessor } from "./agent/routing-catalog.js";
+import { SubagentRuntime } from "./agent/subagent/runtime.js";
 import { type WorkflowRunSnapshot } from "./agent/workflow/control.js";
 import { BudgetLedger } from "./agent/budget-ledger.js";
 import { type AgentProfile, type SubagentRunResult } from "./agent/profiles.js";
@@ -52,6 +53,15 @@ export interface AgentOptions {
     onToolResult?: (toolName: string, result: ToolResult) => void;
     onTodosUpdate?: (todos: Todo[]) => void;
     onModeUpdate?: (mode: PermissionMode) => void;
+    /**
+     * Fired when MULTI-TURN compaction rewrites resident history, with the
+     * summary text. Hosts persist it (SessionManager.applyLLMCompaction) so the
+     * compacted state — including the cumulative file blocks — survives resume;
+     * without this, meta summaries live only in memory (session-log drops meta).
+     * Sub-turn summaries never fire it: they cover only the current turn, and a
+     * session-level summary entry would make resume skip earlier history.
+     */
+    onCompactionApplied?: (summary: string) => void;
     hooks?: TurnHooks[];
     externalHooks?: ExternalHookController;
     agentRole?: "parent" | "subagent";
@@ -119,7 +129,6 @@ export declare class Agent {
      * If the model read the nudge once and chose not to delegate, repeating
      * it is noise.
      */
-    largeTaskNudgeConsumed: boolean;
     private _providerId;
     private _model;
     private tools;
@@ -129,6 +138,7 @@ export declare class Agent {
     private _mode;
     private _modeVersion;
     private onModeUpdate?;
+    private onCompactionApplied?;
     private _todos;
     private _todosVersion;
     private onTodosUpdate?;
@@ -147,32 +157,21 @@ export declare class Agent {
     private fileStateTracker?;
     private agentCategories;
     private agentRouting;
-    private routingSnapshotAccessor?;
-    private routableModelIndex?;
-    /** Detector state (design §6): once per session, absolute defaulted count. */
-    private routingReminderFired;
-    private defaultedRoutingStreak;
-    private pendingRoutingReminder?;
+    /** Owns the routing decision chain, the §6 detector state and the §4 menu. */
+    private readonly router;
     private providerFactory?;
-    private readonly subagentStore;
-    private readonly subagentScheduler;
-    private readonly childRunner;
-    private readonly resultIntegrator;
-    /** Background dynamic-workflow runs (option C Phase 4), keyed by runId. */
-    private readonly workflowRuns;
-    /** runIds whose completed result should be ingested at the next turn. */
-    private readonly pendingWorkflowDeliveries;
-    private subagentsConfig;
-    private readonly rateLimitPolicy?;
-    private pendingSubagentUpdates;
     /**
-     * Wakers for tool-execution update loops currently awaiting updates. A
-     * blocking lifecycle tool (wait_workflow / wait_agent) produces no updates of
-     * its own, so without this wake the background children's queued lifecycle
-     * updates sit undrained until the tool settles — the UI would only show
-     * subagent traces after the whole team finished.
+     * Subagent thread lifecycle + workflow script execution: the store,
+     * scheduler, ChildRunner and their dispatch/ingestion plumbing.
      */
-    private readonly subagentUpdateWakers;
+    private readonly subagents;
+    /**
+     * Background dynamic-workflow runs (option C Phase 4): run records, waiters,
+     * cancellation and the pending-delivery set. Execution stays on Agent.
+     */
+    private readonly workflowLedger;
+    private subagentsConfig;
+    private readonly rateLimitPolicy?;
     private lastInputTokens;
     private lastAnchorMessageCount;
     private compactionStats;
@@ -191,6 +190,13 @@ export declare class Agent {
      * accurate (background-tasks design §2.2c).
      */
     setSessionID(sessionID: string | undefined): void;
+    /**
+     * Children persist next to the session file so a later process can resume
+     * them via send_input (design §7). An explicit subagents.persistDir config
+     * always wins over the sessionID derivation. Child agents themselves
+     * (agentRole "subagent") never persist children — no recursion exists.
+     */
+    private deriveSubagentPersistDir;
     getSessionID(): string | undefined;
     /**
      * Background-task reminder, state-change gated (design §2.3a): returns a
@@ -227,6 +233,20 @@ export declare class Agent {
     private getActiveToolEntries;
     injectSystemReminder(content: string): void;
     injectModeReminder(): void;
+    /**
+     * Mode reminders are enter-announcements with no cancel semantics, so a stale
+     * one keeps describing a mode the session left long ago. Shift+Tab cycles
+     * through plan on the way to bypassPermissions, which used to leave a live
+     * "Plan mode is now ACTIVE" (plus its "call exit_plan_mode" rule) in history
+     * for the rest of the session — the model then planned instead of building,
+     * and hunted for a tool that is filtered out outside plan mode.
+     *
+     * Hidden rather than spliced: keeping the array shape intact leaves message
+     * indices (usage anchors, compaction bookkeeping) valid, and the transcript
+     * still shows what happened. Cache cost is one invalidated prefix per real
+     * mode switch — the no-op path above keeps repeat injections free.
+     */
+    private retireStaleModeReminders;
     get role(): "parent" | "subagent";
     get model(): string;
     set model(value: string);
@@ -278,32 +298,8 @@ export declare class Agent {
      * if the provider stream itself errors.
      */
     summarizeForCompaction(oldMessages: Message[], onDelta?: (full: string, delta: string) => void, abortSignal?: AbortSignal): Promise<string>;
-    runSubAgent(input: string | ContentPart[], cwd: string, options: {
-        profile: AgentProfile;
-        runId: string;
-        subAgentId: string;
-        parentToolCallId: string;
-        category?: string;
-        route?: ResolvedSubagentRoute;
-        approval?: "fail" | "disabled";
-        emitUpdate?: (update: ToolUpdate) => void;
-        description?: string;
-        abortSignal?: AbortSignal;
-        nickname?: string;
-        forkContext?: boolean;
-    }): Promise<SubagentRunResult>;
-    spawnSubAgent(input: string | ContentPart[], cwd: string, options: {
-        profile: AgentProfile;
-        parentToolCallId: string;
-        category?: string;
-        model?: string;
-        effort?: ThinkingLevel;
-        route?: ResolvedSubagentRoute;
-        approval?: "fail" | "disabled";
-        description?: string;
-        abortSignal?: AbortSignal;
-        forkContext?: boolean;
-    }): Promise<SubagentThreadSnapshot>;
+    runSubAgent(input: string | ContentPart[], cwd: string, options: Parameters<SubagentRuntime["runSubAgent"]>[2]): Promise<SubagentRunResult>;
+    spawnSubAgent(input: string | ContentPart[], cwd: string, options: Parameters<SubagentRuntime["spawnSubAgent"]>[2]): Promise<SubagentThreadSnapshot>;
     waitSubAgents(options?: {
         agentIds?: string[];
         timeoutMs?: number;
@@ -321,9 +317,18 @@ export declare class Agent {
      * never be used to answer "am I currently delegating?".
      */
     activeSubAgentCount(): number;
+    listSubAgents(): SubagentThreadSnapshot[];
+    /** Marks a child's full summary as delivered to parent context (design §3.3). */
+    markSubagentDelivered(agentId: string): void;
+    /**
+     * The child store, still reachable at its old name. Several tests inspect a
+     * spawned child's record (and its live child Agent) through
+     * `(agent as any).subagentStore`; keeping this forward means the extraction
+     * changed no caller, test or otherwise.
+     */
+    private get subagentStore();
     /** run_workflow children are workflowInternal and invisible to listSubAgents. */
     hasRunningWorkflow(): boolean;
-    listSubAgents(): SubagentThreadSnapshot[];
     /**
      * Dynamic workflow (option C): runs an LLM-authored JS orchestration script in
      * a QuickJS sandbox. Each agent() call in the script becomes a real scheduled
@@ -379,68 +384,45 @@ export declare class Agent {
     /** Cancels a running background workflow. */
     closeWorkflow(runId: string): WorkflowRunSnapshot | undefined;
     listWorkflows(): WorkflowRunSnapshot[];
-    private snapshotWorkflow;
     /** Injects completed background-workflow results before the next turn (§5 analog). */
     private flushWorkflowDeliveries;
-    private executeWorkflow;
-    /** Marks a child's full summary as delivered to parent context (design §3.3). */
-    markSubagentDelivered(agentId: string): void;
-    private snapshotSubagent;
-    /** Returns the blocking diagnostic message when the profile cannot run, else undefined. */
-    private admitSubagentProfile;
-    /**
-     * Background children (queueUpdates) get their results ingested before the
-     * parent's next inference turn (design §5); foreground children (team,
-     * legacy task) deliver through their tool result instead.
-     */
-    private maybeEnqueueIngestion;
-    private flushSubagentIngestions;
-    private finalizeSubagentBlocked;
-    private dispatchSubagentRun;
-    private emitSubagentLifecycle;
-    /** Lets a blocked tool-execution loop drain freshly queued subagent updates. */
-    private wakeSubagentUpdateWaiters;
-    private runSubagentLifecycleHookFor;
     /**
      * Resolves a child's model route. Priority, highest first (design v2 §1.1):
      *   call-site override (model/effort)  >  profile.model  >  category  >  inherit parent.
      * The call-site override is what lets the model say "opus for this reviewer,
      * haiku for these twenty scouts" per spawn/batch member at request time.
      */
+    /** Kept as a thin delegator: routing decisions now live in SubagentRouter. */
     private resolveRouteForSubagent;
-    /** Live snapshot for the CURRENT parent route; undefined when no accessor is wired. */
-    private currentRoutingSnapshot;
-    /**
-     * Early route validation at dispatch time (design §7). Throws with an
-     * actionable message so the model self-corrects in the same turn. The
-     * cross-provider lock (§7.2.1) is snapshot-independent; catalog checks
-     * degrade silently when no snapshot is available (§7.0).
-     */
-    private validateRouteForDispatch;
     /** Routable catalog across runnable providers (design v3.6); undefined when unwired. */
     listRoutableModels(): RoutableModelEntry[] | undefined;
     /**
-     * Decision-point detector (design §6): counts dispatches whose model was
-     * decided by NO routing layer (modelSource "inherit") under a strong-tier
-     * parent. Fires once per session at the Nth qualifying dispatch; the
-     * reminder rides the same channel as the lifecycle reminder.
+     * The ONE place a child Agent is constructed. The runtime hands over what it
+     * resolved (provider/route/tools/prompt); everything inherited from the
+     * parent is filled in here, which is also what keeps the deliberately
+     * ABSENT arguments absent — `onMessageAppend` (a child must not append to
+     * the parent's session log), `sessionID` (a child must not stop the
+     * parent's auto servers) and the routing catalog (children route by
+     * default, not from the parent's menu).
      */
-    private noteRoutingDispatch;
-    /** Consumed by the turn hooks; also closes the counting window (§6). */
-    consumePendingRoutingReminder(): string | undefined;
-    private createSubagentThreadRecord;
-    private runSubagentThread;
-    private createSubAgentInstance;
-    private resolveProviderForRoute;
+    private createChildAgent;
     private forkMessagesForSubagent;
-    private buildSubagentUpdate;
-    private queueSubagentUpdate;
-    private drainSubagentToolUpdates;
-    private activeSubagentNicknames;
-    private resolveSubagentTargets;
     private maybeCompactResidentHistory;
+    /**
+     * Hand a multi-turn compaction summary to the host for session persistence.
+     * Failure is swallowed: losing persistence must never break the run itself.
+     */
+    private persistCompactionSummary;
     private appendMessage;
     private appendInterruptedAssistantBoundary;
     private clearTodosAfterInterruptedRun;
     private executeTool;
 }
+/** Exported for tests: the wake latch below is easiest to pin directly. */
+export declare function createUpdateQueue<T>(): {
+    push(item: T): void;
+    drain(): T[];
+    hasItems(): boolean;
+    wait(signal?: AbortSignal): Promise<"woken" | "aborted">;
+    wake(): void;
+};