@cerebriline/core 4.100.240

package/dist/extensions/tools/team/multi-agent.d.ts

@@ -0,0 +1,364 @@
+/**
+ * Multi-Agent Coordination
+ *
+ * Utilities for orchestrating multiple agents working together.
+ */
+import { type AgentConfig, type AgentEvent, type AgentResult, type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamAgentSampling, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus } from "@cerebriline/shared";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+import { type HandedRevision } from "./delegated-sandboxes";
+export { type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type MissionLogKind, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamOutcomeFragmentStatus, type TeamOutcomeStatus, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus, } from "@cerebriline/shared";
+export interface TeamMemberConfig extends AgentConfig {
+    role?: string;
+}
+export interface AgentTask {
+    agentId: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TaskResult {
+    agentId: string;
+    result: AgentResult;
+    error?: Error;
+    metadata?: Record<string, unknown>;
+}
+type TeamTaskEndStatus = "completed" | "failed" | "cancelled";
+export type TeamEvent = {
+    type: TeamMessageType.TaskStart;
+    agentId: string;
+    message: string;
+} | {
+    type: TeamMessageType.TaskEnd;
+    agentId: string;
+    status?: TeamTaskEndStatus;
+    result?: AgentResult;
+    error?: Error;
+    messages?: AgentResult["messages"];
+} | {
+    type: TeamMessageType.AgentEvent;
+    agentId: string;
+    event: AgentEvent;
+    /**
+     * The event moved the teammate's tool-call or compaction count, so
+     * its row has something new to show. Most events are streamed
+     * chunks that move nothing.
+     */
+    activityChanged?: boolean;
+} | {
+    type: TeamMessageType.TeammateSpawned;
+    agentId: string;
+    role?: string;
+    teammate: TeammateLifecycleSpec;
+} | {
+    type: TeamMessageType.TeammateShutdown;
+    agentId: string;
+    reason?: string;
+} | {
+    type: TeamMessageType.TeamTaskUpdated;
+    task: TeamTask;
+} | {
+    type: TeamMessageType.TeamMessage;
+    message: TeamMailboxMessage;
+} | {
+    type: TeamMessageType.TeamMissionLog;
+    entry: MissionLogEntry;
+} | {
+    type: TeamMessageType.RunQueued;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunStarted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunProgress;
+    run: TeamRunRecord;
+    message: string;
+} | {
+    type: TeamMessageType.RunCompleted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunFailed;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunCancelled;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.RunInterrupted;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.OutcomeCreated;
+    outcome: TeamOutcome;
+} | {
+    type: TeamMessageType.OutcomeFragmentAttached;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFragmentReviewed;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFinalized;
+    outcome: TeamOutcome;
+} | {
+    type: TeamMessageType.TeamCleaned;
+};
+/**
+ * Whether an event changed the team's state -- what a store must write.
+ *
+ * A teammate's own agent events are not: every streamed text or reasoning
+ * delta is one, and each was a full-state SQLite transaction. Nor is the
+ * progress of a run that is still running (its 2 s heartbeat and its live
+ * activity): the run's recorded state is written when it starts and ends.
+ */
+export declare function isTeamStateChange(event: TeamEvent): boolean;
+export interface AgentTeamsRuntimeOptions {
+    teamName: string;
+    leadAgentId?: string;
+    /**
+     * The lead's session. A teammate's task is registered under it while it
+     * runs, as a `spawn_agent` agent is: the lead's stop_agents,
+     * restart_agent, message_agents and requeue_agent, and its row's stop,
+     * reach it there. Without it a task runs unregistered.
+     */
+    sessionId?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConcurrentRuns?: number;
+    onTeamEvent?: (event: TeamEvent) => void;
+    /**
+     * The teammates' private workspaces, when the host sandboxes them. A
+     * teammate's toolset opens its workspace when it is spawned; the runtime
+     * owns the rest of the lifecycle through these hooks.
+     */
+    teammateWorkspaces?: TeammateWorkspaceHooks;
+    /**
+     * The part of a session connection push a live teammate takes. A
+     * teammate on a connection of its own (the Agents tab) keeps the fields
+     * that connection names; without this the push takes everything.
+     */
+    acceptTeammateConnectionUpdates?: (overrides: TeammateConnectionUpdate) => TeammateConnectionUpdate;
+}
+type TeammateConnectionUpdate = Partial<Pick<AgentConfig, "apiKey" | "baseUrl" | "headers">>;
+/**
+ * The lifecycle of a teammate's private workspace, as the team runtime drives
+ * it. A teammate is long-lived, so its overlay is too: it is handed back at
+ * the end of every task, and released only when the teammate goes.
+ */
+export interface TeammateWorkspaceHooks {
+    /**
+     * Fold what the teammate changed since its last hand-back into the lead's
+     * revision log. Called when each of its runs ends, however it ended, so the
+     * lead finds the revisions named in the result it is handed.
+     */
+    handBack(agentId: string): Promise<readonly HandedRevision[]>;
+    /**
+     * Hand back anything outstanding and dispose the workspace: the teammate
+     * was shut down or removed. Idempotent.
+     */
+    release(agentId: string): Promise<void>;
+}
+export interface SpawnTeammateOptions {
+    agentId: string;
+    config: TeamMemberConfig;
+    /**
+     * The sampler the lead spawned it with, already applied to `config`.
+     * Carried on the spawn event so the persisted spec -- and a restore from
+     * it -- keeps it.
+     */
+    sampling?: TeamAgentSampling;
+}
+export declare class AgentTeam {
+    private agents;
+    private configs;
+    private onTeamEvent?;
+    constructor(configs?: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void);
+    addAgent(id: string, config: TeamMemberConfig): void;
+    removeAgent(id: string): boolean;
+    getAgent(id: string): SessionRuntime | undefined;
+    getAgentIds(): string[];
+    get size(): number;
+    routeTo(agentId: string, message: string): Promise<AgentResult>;
+    continueTo(agentId: string, message: string): Promise<AgentResult>;
+    runParallel(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runSequential(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runPipeline(pipeline: string[], initialMessage: string, messageTransformer?: (prevResult: AgentResult, nextAgentId: string) => string): Promise<TaskResult[]>;
+    abortAll(): void;
+    clear(): void;
+    private emitEvent;
+}
+export declare function createAgentTeam(configs: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void): AgentTeam;
+export declare function createWorkerReviewerTeam(configs: {
+    worker: TeamMemberConfig;
+    reviewer: TeamMemberConfig;
+}): AgentTeam & {
+    doAndReview: (message: string) => Promise<{
+        workerResult: AgentResult;
+        reviewResult: AgentResult;
+    }>;
+};
+export declare class AgentTeamsRuntime {
+    private readonly teamId;
+    private readonly teamName;
+    private readonly sessionId?;
+    private readonly onTeamEvent?;
+    private readonly members;
+    private readonly tasks;
+    private readonly missionLog;
+    private readonly mailbox;
+    private missionStepCounter;
+    private taskCounter;
+    private messageCounter;
+    private missionCounter;
+    private runCounter;
+    private outcomeCounter;
+    private outcomeFragmentCounter;
+    private readonly runs;
+    private readonly runQueue;
+    private queuedRunDispatchTimer;
+    private readonly outcomes;
+    private readonly outcomeFragments;
+    private readonly missionLogIntervalSteps;
+    private readonly missionLogIntervalMs;
+    private readonly maxConcurrentRuns;
+    private readonly teammateWorkspaces?;
+    private readonly acceptTeammateConnectionUpdates?;
+    constructor(options: AgentTeamsRuntimeOptions);
+    getTeamId(): string;
+    getTeamName(): string;
+    getMemberRole(agentId: string): "lead" | "teammate" | undefined;
+    getMemberIds(): string[];
+    getTeammateIds(): string[];
+    getTask(taskId: string): TeamTask | undefined;
+    listTasks(): TeamTask[];
+    listTaskItems(options?: {
+        status?: TeamTaskStatus;
+        assignee?: string;
+    }): TeamTaskListItem[];
+    listMissionLog(limit?: number): MissionLogEntry[];
+    listMailbox(agentId: string, options?: {
+        unreadOnly?: boolean;
+        markRead?: boolean;
+        limit?: number;
+    }): TeamMailboxMessage[];
+    getSnapshot(): TeamRuntimeSnapshot;
+    exportState(): TeamRuntimeState;
+    hydrateState(state: TeamRuntimeState): void;
+    isTeammateActive(agentId: string): boolean;
+    /**
+     * Throw unless `agentId` is a live teammate that can be given a task. A
+     * stopped one kept its agent for the task it was ending, and a task given
+     * it ran on a released workspace and booked an engine session nothing
+     * closed.
+     */
+    private requireTaskableTeammate;
+    /**
+     * Throw if `agentId` cannot be (re)spawned now. Asked before anything is
+     * built for the new teammate: building its toolset opens its workspace,
+     * which replaces -- and releases -- the one a teammate still running under
+     * the same id is writing to.
+     */
+    assertCanSpawnTeammate(agentId: string): void;
+    spawnTeammate({ agentId, config, sampling, }: SpawnTeammateOptions): TeamMemberSnapshot;
+    shutdownTeammate(agentId: string, reason?: string): void;
+    private releaseWorkspace;
+    /**
+     * Give the teammate's engine session back: its window, its slot affinity,
+     * any pool it holds. Once -- the id is dropped from the member -- and never
+     * waited on: this runs on shutdown paths that must not block.
+     */
+    private releaseEngineSession;
+    /**
+     * Give the engine session back at the end of a task, keeping the id: the
+     * teammate's next task sends it again and is booked afresh (after this
+     * close has landed), and its shutdown still has it to close.
+     */
+    private releaseEngineSessionBetweenTasks;
+    /**
+     * Between a restart's or a requeue's two attempts: give back the session
+     * the stopped one held and wait for the close, so the next books afresh.
+     * A fresh start asks for a fresh window; a requeue keeps its own.
+     */
+    private rebookEngineSession;
+    /**
+     * One stretch of a teammate's task, under its controls: the task itself,
+     * or -- after a requeue -- its carrying on from its transcript. A stop
+     * aborts it as intended, so the task ends cancelled; a restart or a
+     * requeue aborts only the stretch, and the controls run the next.
+     */
+    private runTeammateSegment;
+    /**
+     * Hand a teammate's changes back at the end of a run, and say where they
+     * went. Best-effort: a failed hand-back must not fail the task.
+     */
+    private handBackWorkspace;
+    updateTeammateConnections(overrides: TeammateConnectionUpdate): void;
+    createTask(input: CreateTeamTaskInput): TeamTask;
+    claimTask(taskId: string, agentId: string): TeamTask;
+    blockTask(taskId: string, agentId: string, reason: string): TeamTask;
+    completeTask(taskId: string, agentId: string, summary: string): TeamTask;
+    routeToTeammate(agentId: string, message: string, options?: RouteToTeammateOptions): Promise<AgentResult>;
+    startTeammateRun(agentId: string, message: string, options?: RouteToTeammateOptions & {
+        priority?: number;
+        maxRetries?: number;
+        leaseOwner?: string;
+    }): TeamRunRecord;
+    private dispatchQueuedRuns;
+    private selectNextDispatchableQueuedRun;
+    /** Whether `agentId` is free for its next queued run: idle, and not stopped. */
+    private canTakeQueuedRun;
+    private scheduleQueuedRunDispatch;
+    private clearQueuedRunDispatchTimer;
+    private countActiveRuns;
+    private executeQueuedRun;
+    listRuns(options?: {
+        status?: TeamRunStatus | null;
+        agentId?: string | null;
+        includeCompleted?: boolean | null;
+    }): TeamRunRecord[];
+    getRun(runId: string): TeamRunRecord | undefined;
+    /**
+     * Wait for one run to end. `requesterId` is who waits: a teammate asking
+     * for its own active run is refused, since that run cannot end while it
+     * waits for it.
+     */
+    awaitRun(runId: string, pollIntervalMs?: number, requesterId?: string): Promise<TeamRunRecord>;
+    /**
+     * Wait for every active run to end, and list them. The requester's own
+     * runs are left out: a teammate that waits for "all runs" is inside one of
+     * them, and waiting for it deadlocked until the lead was stopped.
+     */
+    awaitAllRuns(pollIntervalMs?: number, requesterId?: string): Promise<TeamRunRecord[]>;
+    /**
+     * Cancel work owned by this team runtime without removing teammate or
+     * conversation state. Used when the owning lead session is aborted.
+     */
+    cancelOutstandingWork(reason?: unknown): void;
+    cancelRun(runId: string, reason?: string): TeamRunRecord;
+    /**
+     * Abort what `agentId` is running now, marked as intended so its end is
+     * reported as cancelled. Once: a teammate already being stopped is left.
+     */
+    private abortTeammateRun;
+    recoverActiveRuns(reason?: string): TeamRunRecord[];
+    markStaleRunsInterrupted(reason?: string): TeamRunRecord[];
+    sendMessage(fromAgentId: string, toAgentId: string, subject: string, body: string, taskId?: string): TeamMailboxMessage;
+    broadcast(fromAgentId: string, subject: string, body: string, options?: {
+        taskId?: string;
+    }): TeamMailboxMessage[];
+    appendMissionLog(input: AppendMissionLogInput): MissionLogEntry;
+    createOutcome(input: CreateTeamOutcomeInput): TeamOutcome;
+    listOutcomes(): TeamOutcome[];
+    attachOutcomeFragment(input: AttachTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    reviewOutcomeFragment(input: ReviewTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    listOutcomeFragments(outcomeId: string): TeamOutcomeFragment[];
+    finalizeOutcome(outcomeId: string): TeamOutcome;
+    cleanup(): void;
+    private requireTask;
+    private assertDependenciesResolved;
+    private getUnresolvedDependencies;
+    private trackMeaningfulEvent;
+    private recordRunActivityFromAgentEvent;
+    private recordRunProgress;
+    private formatProgressErrorActivity;
+    private recordProgressStep;
+    private buildMailboxNotification;
+    private emitEvent;
+}

package/dist/extensions/tools/team/node-reachability.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Whether a failed agent run means its node could not be reached at all.
+ *
+ * §9i.2. A node that is off, unplugged or behind a dead tunnel costs a connect
+ * timeout on every spawn, and with round-robin that is once a lap for the life
+ * of the session. Taking it out of the rotation for a cool-off is only safe if
+ * "unreachable" is read narrowly, because the cost of reading it too widely is
+ * the opposite failure: a node marked down for a cool-off because one model
+ * call happened to fail.
+ *
+ * So the test is transport-level and nothing else. A server that answered --
+ * a 429 from an admission gate, a 400 on a bad field, a context overflow, a
+ * model that returned an error -- is a server that is alive, and none of them
+ * says anything about the node's reachability. Only failures that mean no HTTP
+ * response ever arrived count.
+ *
+ * `fetch failed` is included because that is all undici gives for a connection
+ * that never opened; its `cause` carries the real code, which is checked too
+ * when it is there.
+ */
+export declare function isNodeUnreachable(error: unknown, depth?: number): boolean;
+export declare function isModelMissing(text: unknown): boolean;
+/**
+ * This attempt spent nothing, so the agent may be placed again.
+ *
+ * The whole point of re-placing rather than failing: a run that never reached
+ * a model has done no work to lose and no side effect to repeat. Both halves
+ * are required -- a failure that burned tokens may have edited a file, and
+ * running it again on another node would do it twice.
+ *
+ * Note this reads a *returned* result, not a thrown error. The measured
+ * failure did not throw: the sub-agent returned `finishReason: "error"` with
+ * the message in `text`, so the catch clause that marks nodes down was never
+ * entered, and the node stayed in rotation for the rest of the session.
+ */
+export declare function isWastedNodeRun(result: {
+    finishReason?: unknown;
+    text?: unknown;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}): boolean;
+export declare function isGatewayDown(text: unknown): boolean;
+/** A run that spent nothing because the node's gateway had nothing behind it. */
+export declare function isGatewayDownRun(result: {
+    finishReason?: unknown;
+    text?: unknown;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}): boolean;

package/dist/extensions/tools/team/node-throughput.d.ts

@@ -0,0 +1,40 @@
+/**
+ * How fast each node produces tokens, measured from what its agents report.
+ *
+ * For the lead's `agents_status`: an ETA needs a rate, and a rate the lead
+ * can judge needs two -- the last five minutes and the node's own history in
+ * this process. When they agree the ETA can be trusted; when the recent one
+ * has fallen far below the historical one, something on the node changed (a
+ * compaction wave, a prefill storm, another client) and the ETA says so.
+ *
+ * Measured here rather than asked of a server so it works for every provider:
+ * an agent's output-token count rises as it works, whoever serves it. Time
+ * is counted in active minutes -- minutes in which the node produced
+ * anything -- so an idle hour between rounds does not halve the history.
+ */
+/** The window the recent rate covers. */
+export declare const RECENT_WINDOW_MS: number;
+export type RateReliability = "high" | "medium" | "low" | "too early";
+export interface NodeRate {
+    /** Tokens per second over the active part of the last five minutes. */
+    recentTps?: number;
+    /** Tokens per second over every active minute so far. */
+    historicalTps?: number;
+    activeMinutes: number;
+    reliability: RateReliability;
+}
+/** The key an agent's tokens are counted under: its node, or its model. */
+export declare function nodeKeyOf(agent: {
+    nodeId?: string;
+    providerId?: string;
+    modelId?: string;
+}): string;
+export declare function noteNodeTokens(key: string, tokens: number, at: number): void;
+/**
+ * Whether two rates agree well enough to trust an ETA drawn from them. The
+ * recent rate is the one used; the historical one is the check on it.
+ */
+export declare function rateReliability(recent: number | undefined, historical: number | undefined, activeMinutes: number): RateReliability;
+export declare function nodeRate(key: string, now: number): NodeRate | undefined;
+/** Test seam. */
+export declare function __resetNodeThroughput(): void;

package/dist/extensions/tools/team/placed-run.d.ts

@@ -0,0 +1,114 @@
+import { type AgentEvent, type AgentResult, type TurnFaultRecovery } from "@cerebriline/shared";
+import type { AgentNodePlacement, PlacedAgentNode } from "./agent-node-placement";
+import { type TurnFaultWait } from "./turn-fault-recovery";
+/**
+ * Longest a node is held after refusing an agent that has not started, when
+ * none of its agents finishes first.
+ *
+ * A refusal is never the agent's result, however many there are: ruled after
+ * 1tmrl, where 13 agents were never admitted and became "projected mean tps
+ * below floor" as their final answer. What stops a refused agent from
+ * hammering the node is the hold, which grows from the queue's 5 s with each
+ * refusal in a row to this, and ends early the moment one of the node's own
+ * agents finishes -- the room the refusal was waiting for.
+ */
+export declare const REFUSED_HOLD_MAX_MS = 60000;
+/** The hold after the `refusals`th consecutive refusal (1-based). */
+export declare function refusedHoldMs(refusals: number): number;
+/**
+ * The engine said no to starting this agent: a 429 from the admission gate, or
+ * the pool owner's window being full.
+ *
+ * Read from a thrown error, or from a run that ended in error having spent
+ * nothing -- the two shapes a refusal reaches a spawn path in, depending on
+ * whether the agent loop caught it.
+ */
+export declare function isRefusedSpawn(outcome: unknown): boolean;
+/** What the engine said when it refused, for a person to read. */
+export declare function refusalReason(outcome: unknown): string;
+export declare function isDurableRefusal(outcome: unknown): boolean;
+/**
+ * The KV the pool could admit at the moment it refused, from `largest
+ * admissible N`, or undefined when the refusal did not state one.
+ *
+ * It is the one signal that says whether waiting is worth it: a number that
+ * climbs across refusals means siblings are finishing and space is opening, so
+ * the next attempt might fit; a number that does not move is a pool that is
+ * stuck — in the deadlock case every worker holds nothing and waits, so nothing
+ * finishes to free the cells the next worker needs.
+ */
+export declare function admissionHeadroom(outcome: unknown): number | undefined;
+/**
+ * The attempt never reached a server that could run it: a refused or reset
+ * connection, a gateway with nothing behind it, or a server going down. Read
+ * from a thrown error or from a run that ended in error having spent nothing.
+ */
+export declare function isTransportFailure(outcome: {
+    result: AgentResult;
+} | {
+    error: unknown;
+}): boolean;
+/** An event that shows the engine is generating for this agent. */
+export declare function isAdmissionEvent(event: AgentEvent): boolean;
+export interface PlacedRunInput {
+    placement: AgentNodePlacement;
+    signal?: AbortSignal;
+    emitUpdate?: (update: unknown) => void;
+    logger?: {
+        log: (message: string) => void;
+    };
+    /** How the agent is named in the log lines. */
+    label: string;
+    /**
+     * Build the agent for this node and run it. `admitted` is to be called on
+     * its first output; {@link isAdmissionEvent} says which event that is.
+     *
+     * `recoverTurnFault` is to be given to the agent (`AgentConfig`): it waits
+     * out a turn the server dropped or refused once the engine has admitted the
+     * agent, and declines before that, so the failure comes back here and the
+     * agent is placed again.
+     */
+    run: (placed: PlacedAgentNode, admitted: () => void, recoverTurnFault: TurnFaultRecovery) => Promise<AgentResult>;
+    /** Told whenever the agent is waiting on a fault or a refusal. */
+    onWaiting?: (state: TurnFaultWait) => void;
+    /**
+     * Move this running agent off `avoidNodeId`, with its transcript: the
+     * path's requeue. Called only when another node has room. `false` when it
+     * cannot be moved, and it waits where it is.
+     */
+    relocate?: (avoidNodeId: string, reason: string) => boolean;
+    /** Seam for tests: the backoff between re-placements. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** Between a failed spawn and the next placement: close its engine session. */
+    beforeRetry?: () => Promise<void>;
+    /**
+     * The first placement of an agent the lead requeued: back at the front of
+     * the queue, and off the node it named as slow or misbehaving when another
+     * has room. Re-placements after a refusal or a fault are the queue's own.
+     */
+    requeued?: {
+        avoidNodeId?: string;
+    };
+}
+export interface PlacedRunOutcome {
+    result: AgentResult;
+    /** Where it finally ran. */
+    placed: Pick<PlacedAgentNode, "nodeId" | "nodeLabel">;
+}
+export declare function runPlacedAgent(input: PlacedRunInput): Promise<PlacedRunOutcome>;
+/**
+ * Where an agent resumed after its spawn call returned runs: back through
+ * its path's placement. On a node, a lease on that same node -- its transcript
+ * was produced by that node's model -- at the front of the queue, taken as
+ * admitted (the engine held it before; a refusal on the resumed turn is the
+ * turn-fault recovery's). Off nodes, the endpoint's slot gate. The lease is
+ * given back when the resumed run ends, whatever its end.
+ */
+export declare function resumePlacement(input: {
+    placement?: AgentNodePlacement;
+    nodeId?: string;
+    slotGate?: {
+        run<T>(task: (admitted: () => void) => Promise<T>): Promise<T>;
+    };
+    signal?: () => AbortSignal | undefined;
+}): <T>(run: () => Promise<T>) => Promise<T>;

package/dist/extensions/tools/team/projections.d.ts

@@ -0,0 +1,8 @@
+import type { TeamProgressLifecycleEvent, TeamProgressSummary, TeamRuntimeState } from "@cerebriline/shared";
+import type { TeamEvent } from "./multi-agent";
+export declare function buildTeamProgressSummary(teamName: string, state: TeamRuntimeState): TeamProgressSummary;
+export declare function toTeamProgressLifecycleEvent(input: {
+    teamName: string;
+    sessionId: string;
+    event: TeamEvent;
+}): TeamProgressLifecycleEvent;

package/dist/extensions/tools/team/runtime.d.ts

@@ -0,0 +1,6 @@
+export { type AgentSlotGate, type AgentSlotGateRegistry, agentEndpointKey, agentNodesAllowParallelDelegation, agentSlotLimitsByEndpoint, createAgentSlotGate, createAgentSlotGateRegistry, delegationCanRunInParallel, slotsAllowParallelDelegation, } from "./agent-slot-gate";
+export { buildDelegatedAgentConfig, createDelegatedAgent, createDelegatedAgentConfigProvider, type DelegatedAgentConfigProvider, type DelegatedAgentConnectionConfig, type DelegatedAgentKind, type DelegatedAgentRuntimeConfig, type DelegatedPrepareTurnTarget, } from "./delegated-agent";
+export { buildSubagentLayout, pinConversationHead, SUBAGENT_BASE_PROMPT, type SubagentKnowledge, type SubagentLayout, } from "./subagent-layout";
+export { createSpawnAgentTool, type SpawnAgentInput, type SpawnAgentOutput, type SpawnAgentToolConfig, type SubAgentEndContext, type SubAgentStartContext, } from "./spawn-agent-tool";
+export { type AgentTask, AgentTeam, AgentTeamsRuntime, type AgentTeamsRuntimeOptions, createAgentTeam, createWorkerReviewerTeam, type SpawnTeammateOptions, type TaskResult, type TeamEvent, type TeamMemberConfig, } from "./multi-agent";
+export { type BootstrapAgentTeamsOptions, type BootstrapAgentTeamsResult, bootstrapAgentTeams, type CreateAgentTeamsToolsOptions, createAgentTeamsTools, reviveTeamStateDates, sanitizeTeamName, type TeamTeammateRuntimeConfig, } from "./team-tools";

package/dist/extensions/tools/team/session-window-retry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A worker refused because the lead's window is full, which is a wait.
+ *
+ * Pooled workers are charged against the session that owns the pool -- that is
+ * what makes them cost no allocation of their own -- so the lead's window, not
+ * the server's cells, is what bounds how many can run at once. When the tree
+ * fills it the engine refuses the next one:
+ *
+ *     admission rejected: session allocation full (worker of '<session>':
+ *     39653 of 65536 cells free, needs 40252) — compact the session
+ *
+ * Measured live on 8240, 2026-09-22: four workers of ~10k prompt each under a
+ * 65,536-token lead already holding 22k, and the fifth and sixth were refused.
+ * The room appears again the moment a running worker finishes, so this is a
+ * queueing condition wearing an error's clothes -- the same shape as the 429
+ * the admission gate answers with, and treated the same way.
+ *
+ * Every other failure is the worker's own and travels untouched.
+ */
+export declare function isSessionAllocationFull(error: unknown): boolean;
+export interface SessionFullRetryOptions {
+    /** Runs in total, the first included. */
+    attempts?: number;
+    /** Seam for tests; real waits are seconds, which is the right scale here. */
+    sleep?: (ms: number) => Promise<void>;
+    onRetry?: (attempt: number, waitMs: number) => void;
+}
+export declare function retryWhileSessionFull<T>(run: () => Promise<T>, options?: SessionFullRetryOptions): Promise<T>;