@cerebriline/core 4.100.240

package/dist/runtime/escalation/watch-tool.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `wait_for_expert` — the base model's turn valve while it stands down.
+ *
+ * The escalation is not a blocking call any more: `escalate` hands over and
+ * returns, and the base model is live for the whole exchange. That raises a
+ * question the blocking call never had to answer -- what does a live base
+ * model DO between the hand-over and the delivery? Left to itself it will burn
+ * its whole turn budget re-reading files, or call `escalate` again to see if
+ * anything has happened, which is the same busy-wait with a worse bill.
+ *
+ * So there is one call that means "wake me when there is something", and it
+ * blocks until there is. One turn per batch, and the batching interval decides
+ * how many batches there are. That is the entire turn economy of the
+ * supervision, in one tool.
+ *
+ * It is deliberately not a poll that returns "nothing yet". A tool that can
+ * return nothing is a tool a model will call in a loop.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+export declare const WAIT_FOR_EXPERT_TOOL_NAME = "wait_for_expert";
+export declare const WAIT_FOR_EXPERT_TOOL_DESCRIPTION = "Wait for the expert, and be told what it has been doing.\n\nWhile the expert works you are standing down from changes, and this is how you follow it. The call returns when there is something for you: a batch of notes covering everything the expert has done since you last looked, or its delivery once it is finished. It costs you one turn each time, which is why the notes arrive in batches rather than one per action.\n\nEach note names a tool the expert called, and where that call wrote a file it also gives the revision number holding what was written. Read the flow rather than auditing it \u2014 you are forming a view of whether the work is going somewhere, not checking receipts. Spot-check the parts that matter: `read_files` with `revision: \"#4\"` shows you the exact bytes a note is about, which is the only way to check a claim against what was actually written rather than against a file that has moved on since.\n\nIf what you see is the expert going round in circles \u2014 the same file rewritten again and again, a check failing the same way each time, nothing moving across several batches \u2014 say so. Call `escalate` with `message` to tell it what you see, or to tell it to stop. That judgement is yours, and nobody else is going to make it.";
+/** What waiting turned up. */
+export interface ExpertWatchResult {
+    kind: "batch" | "delivered" | "none";
+    text: string;
+}
+export interface WaitForExpertToolOptions {
+    /** Blocks until the next batch or the delivery. Owned by the session. */
+    collect: () => Promise<ExpertWatchResult>;
+    onError?: (message: string, error: unknown) => void;
+}
+export declare function createWaitForExpertTool(options: WaitForExpertToolOptions): AgentTool;
+/** No expert is working, so there is nothing to wait for. */
+export declare const NOTHING_TO_WAIT_FOR = "No expert is working right now, so there is nothing to wait for. The workspace is yours \u2014 carry on with the task.";

package/dist/runtime/host/history.d.ts

@@ -0,0 +1,19 @@
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionHistoryRecord, SessionRecord } from "../../types/sessions";
+import type { SessionBackend } from "./host";
+import type { RuntimeHost } from "./runtime-host";
+export interface SessionHistoryListOptions {
+    limit?: number;
+    includeManifestFallback?: boolean;
+    hydrate?: boolean;
+    includeSubagents?: boolean;
+}
+export declare function manifestToSessionRecord(manifest: SessionManifest): SessionRecord;
+export declare function hydrateSessionHistory(host: Pick<RuntimeHost, "readSessionMessages">, rows: SessionRecord[]): Promise<SessionHistoryRecord[]>;
+export declare function listSessionHistory(host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">, options?: SessionHistoryListOptions): Promise<SessionHistoryRecord[]>;
+/**
+ * Lists history directly from the persistence backend without constructing a
+ * runtime host. This keeps read-only history commands from initializing runtime
+ * services such as plugins, MCP, or hub transport.
+ */
+export declare function listSessionHistoryFromBackend(backend: Pick<SessionBackend, "listSessions">, options?: SessionHistoryListOptions): Promise<SessionHistoryRecord[]>;

package/dist/runtime/host/host.d.ts

@@ -0,0 +1,7 @@
+import type { ClineCoreOptions } from "../../cline-core/types";
+import { FileSessionService } from "../../session/services/file-session-service";
+import { CoreSessionService } from "../../session/services/session-service";
+import type { RuntimeHost } from "./runtime-host";
+export type SessionBackend = CoreSessionService | FileSessionService;
+export declare function resolveSessionBackend(options: ClineCoreOptions): Promise<SessionBackend>;
+export declare function createRuntimeHost(options: ClineCoreOptions): Promise<RuntimeHost>;

package/dist/runtime/host/local/agent-event-bridge.d.ts

@@ -0,0 +1,50 @@
+import type { AgentEvent, BasicLogger } from "@cerebriline/shared";
+import type { TeamEvent } from "../../../extensions/tools/team";
+import { type AgentEventContext } from "../../../services/agent-events";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { CoreSessionEvent } from "../../../types/events";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionAccumulatedUsage } from "../runtime-host";
+export interface AgentEventBridgeDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    usageBySession: Map<string, SessionAccumulatedUsage>;
+    aggregateUsageBySession: Map<string, SessionAccumulatedUsage>;
+    emit(event: CoreSessionEvent): void;
+    persistMessages: AgentEventContext["persistMessages"];
+    enqueuePendingPrompt(sessionId: string, entry: {
+        prompt: string;
+        delivery: "queue" | "steer";
+    }): void;
+    invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+}
+export declare class AgentEventBridge {
+    private readonly deps;
+    constructor(deps: AgentEventBridgeDeps);
+    /**
+     * Last agent identity stamped on each session's events while the session
+     * was still registered. A session's agent can keep emitting after the host
+     * removes it from the sessions map (teardown deletes the entry before the
+     * run fully drains), and without this snapshot those late events reach
+     * telemetry with no agent identity at all. Bounded FIFO so a long-lived
+     * host doesn't accumulate entries forever.
+     */
+    private readonly lastKnownIdentityBySession;
+    private static readonly MAX_IDENTITY_SNAPSHOTS;
+    dispatchAgentEvent(sessionId: string, config: CoreSessionConfig, event: AgentEvent): void;
+    private rememberSessionIdentity;
+    handleTeamEvent(rootSessionId: string, event: TeamEvent): Promise<void>;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"], fallbackTelemetry?: CoreSessionConfig["telemetry"]): Promise<void>;
+    /**
+     * Route `plugin_telemetry` events emitted by the sandbox-side telemetry
+     * bridge into the host telemetry service. Sandboxed plugins cannot hold
+     * the live service (it is not JSON-serializable across the IPC boundary),
+     * so their capture/record calls arrive as events. All plugin events are
+     * namespaced under `plugin.` and stamped with the plugin name so they
+     * cannot impersonate first-party events.
+     */
+    handlePluginTelemetry(rootSessionId: string, payload: unknown, fallbackTelemetry?: CoreSessionConfig["telemetry"]): void;
+    handlePluginLog(rootSessionId: string, payload: unknown, fallbackLogger?: BasicLogger): void;
+}

package/dist/runtime/host/local/session-record.d.ts

@@ -0,0 +1,6 @@
+import type { FileSessionService } from "../../../session/services/file-session-service";
+import type { CoreSessionService } from "../../../session/services/session-service";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionRecord } from "../../../types/sessions";
+export type SessionBackend = CoreSessionService | FileSessionService;
+export declare function toActiveSessionRecord(session: ActiveSession): SessionRecord;

package/dist/runtime/host/local/session-service-invoker.d.ts

@@ -0,0 +1,4 @@
+import type { SessionBackend } from "./session-record";
+export declare function invokeBackend<T>(backend: SessionBackend, method: string, ...args: unknown[]): Promise<T>;
+export declare function invokeBackendOptional(backend: SessionBackend, method: string, ...args: unknown[]): Promise<void>;
+export declare function invokeBackendOptionalValue<T = unknown>(backend: SessionBackend, method: string, ...args: unknown[]): Promise<T | undefined>;

package/dist/runtime/host/local/spawn-tool.d.ts

@@ -0,0 +1,57 @@
+import type { AgentEvent, AgentTool } from "@cerebriline/shared";
+import { type ToolExecutors } from "../../../extensions/tools";
+import { type DocumentExtractExecutorOptions } from "../../../extensions/tools/executors/document-extract";
+import type { SubAgentEndContext, SubAgentSettledContext, SubAgentStartContext } from "../../../extensions/tools/team";
+import type { DelegatedSandboxProvider } from "../../../extensions/tools/team/agent-sandbox-executors";
+import { type DelegatedSandboxes, type DelegatedWorkspace, type HandedRevision } from "../../../extensions/tools/team/delegated-sandboxes";
+import type { SpawnToolOptions } from "../../../extensions/tools/team/spawn-agent-tool";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { ActiveSession } from "../../../types/session";
+export type SubAgentStartTracker = Map<string, {
+    startedAt: number;
+    rootSessionId: string;
+}>;
+export interface SpawnToolDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    subAgentStarts: SubAgentStartTracker;
+    onAgentEvent(rootSessionId: string, config: CoreSessionConfig, event: AgentEvent): void;
+    invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+    /**
+     * The session's delegated-agent workspaces. When present, every agent this
+     * builds -- a `spawn_agent` agent and each swarm worker -- runs over a
+     * private overlay of the workspace instead of the lead's executors, and gets
+     * a shell only where the sandbox can launch one and the user allowed agent
+     * commands. Absent, an agent keeps the lead's executors and gets no shell at
+     * all: an unsandboxed command would run against the real workspace.
+     */
+    sandboxes?: DelegatedSandboxes;
+}
+/** Kept for hosts that name the provider type from here. */
+export type { DelegatedSandboxProvider };
+/**
+ * The builtin-tool options that bind a delegated agent to its workspace: the
+ * overlay-backed executors, and the shell only when the workspace allows it.
+ * Without a workspace, the lead's executors and never a shell.
+ */
+export declare function delegatedToolOptions(workspace: DelegatedWorkspace | undefined, leadExecutors: Partial<ToolExecutors> | undefined, 
+/** The lead's document reader settings and vision model, when the tool is on. */
+extractDocument?: DocumentExtractExecutorOptions): {
+    executorOptions?: DelegatedWorkspace["executorOptions"];
+    executors?: Partial<ToolExecutors>;
+    enableBash?: false;
+};
+export interface SessionSubAgentLifecycleCallbacks {
+    onSubAgentEvent: (event: AgentEvent) => void;
+    onSubAgentStart: (context: SubAgentStartContext) => void;
+    onSubAgentEnd: (context: SubAgentEndContext) => void;
+    onSubAgentSettled: (context: SubAgentSettledContext) => Promise<void>;
+}
+export declare function createSessionSubAgentLifecycleCallbacks(deps: SpawnToolDeps, config: CoreSessionConfig, rootSessionId: string): SessionSubAgentLifecycleCallbacks;
+/**
+ * Append a note to the agent's answer naming the revisions its changes were
+ * handed back as, so the lead adopts them with `restore_file` instead of judging
+ * the agent by an on-disk copy the overlay never touched.
+ */
+export declare function appendHandbackNote(context: SubAgentEndContext, agentName: string, handed: readonly HandedRevision[]): void;
+export declare function createSessionSpawnTool(deps: SpawnToolDeps, config: CoreSessionConfig, rootSessionId: string, toolExecutors?: Partial<ToolExecutors>, options?: SpawnToolOptions): AgentTool;
+export declare function createSessionSwarmTool(deps: SpawnToolDeps, config: CoreSessionConfig, rootSessionId: string, toolExecutors?: Partial<ToolExecutors>): AgentTool;

package/dist/runtime/host/local/user-files.d.ts

@@ -0,0 +1 @@
+export declare function loadUserFileContent(path: string): Promise<string>;

package/dist/runtime/host/local-runtime-host.d.ts

@@ -0,0 +1,298 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import { type AgentConfig, type AgentResult, type BasicLogger, type ITelemetryService } from "@cerebriline/shared";
+import { type BackgroundDelegationView } from "../../extensions/tools/team/background-delegations";
+import { type ConfiguredAgentDelegationResult, type ConfiguredAgentSummary } from "../../extensions/tools/team/delegate-to-agent";
+import type { HookEventPayload } from "../../hooks";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+import { type SessionCompactionState } from "../../session/models/session-compaction";
+import type { CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+import { RuntimeOAuthTokenManager } from "../orchestration/runtime-oauth-token-manager";
+import type { RuntimeBuilder } from "../orchestration/session-runtime";
+import { SessionRuntime } from "../orchestration/session-runtime-orchestrator";
+import { type SessionBackend } from "./local/session-record";
+import type { PendingPromptsServiceApi, RestoreSessionInput, RestoreSessionResult, RuntimeHost, RuntimeHostSubscribeOptions, SendSessionInput, SessionConnectionUpdate, SessionUsageSummary, StartSessionInput, StartSessionResult } from "./runtime-host";
+export interface LocalRuntimeHostOptions {
+    distinctId?: string;
+    sessionService: SessionBackend;
+    runtimeBuilder?: RuntimeBuilder;
+    createAgent?: (config: AgentConfig) => SessionRuntime;
+    capabilities?: RuntimeCapabilities;
+    toolPolicies?: AgentConfig["toolPolicies"];
+    providerSettingsManager?: ProviderSettingsManager;
+    oauthTokenManager?: RuntimeOAuthTokenManager;
+    telemetry?: ITelemetryService;
+    logger?: BasicLogger;
+    /**
+     * Default custom `fetch` implementation threaded into every
+     * `ProviderConfig.fetch` built during local session bootstrap. Used by
+     * the AI gateway providers when issuing HTTP requests.
+     */
+    fetch?: typeof fetch;
+}
+export declare class LocalRuntimeHost implements RuntimeHost {
+    /**
+     * Sessions whose change protocol is to stand down at the next safe point.
+     *
+     * A request, not the act. The act is in `consumePendingUserMessage`, which
+     * is the only place in the loop where putting files back cannot race a tool
+     * call that is still open.
+     */
+    private readonly pendingAtomicDisengage;
+    readonly runtimeAddress: undefined;
+    readonly pendingPrompts: PendingPromptsServiceApi;
+    private readonly sessionService;
+    private readonly runtimeBuilder;
+    private readonly createAgentInstance;
+    private readonly toolExecutors?;
+    private readonly defaultCapabilities?;
+    private readonly defaultToolPolicies?;
+    private readonly providerSettingsManager;
+    private readonly oauthTokenManager;
+    private readonly defaultTelemetry?;
+    private readonly distinctId;
+    private readonly defaultLogger?;
+    private readonly defaultFetch?;
+    private readonly events;
+    private readonly sessions;
+    private readonly manifestMutationQueues;
+    private readonly usageBySession;
+    private readonly aggregateUsageBySession;
+    private readonly subAgentStarts;
+    private readonly pendingPromptsController;
+    /**
+     * One registry per session, because a background run belongs to the
+     * conversation it was started from and its report has nowhere else to go.
+     */
+    private readonly backgroundDelegations;
+    /**
+     * The lead's agent config, kept for the side turn that answers a steer
+     * while the lead waits on its agents (`steer-side-turn.ts`), and the
+     * chain that runs those turns one at a time per session.
+     */
+    private readonly sideTurnConfigs;
+    private readonly sideTurns;
+    private readonly leadNudgeUnsubscribes;
+    /** Each session's subscription to its settled rounds (spec A). */
+    private readonly roundUnsubscribes;
+    private readonly eventBridge;
+    private readonly sessionVersioning;
+    private readonly runCommandExecutionController;
+    constructor(options: LocalRuntimeHostOptions);
+    private applyInitialOAuthCredentials;
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    private startResolvedSession;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    /**
+     * Answer a steer with the lead's model while the lead waits on its agents.
+     * One at a time per session; the reply goes to the chat as a status notice,
+     * and the lead's real turn is told what happened when the round returns.
+     */
+    private answerSteerInSideTurn;
+    /**
+     * The agent system's report of agents stuck for a long time. Answered in
+     * a side turn while the lead waits on its round -- where it can stop them
+     * -- and queued for its next turn when there is no round to answer from.
+     */
+    private nudgeLead;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    getAccumulatedUsage(sessionId: string): Promise<SessionUsageSummary | undefined>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    proceedWhileRunning(sessionId: string, toolCallId?: string): Promise<number>;
+    stopSession(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    updateSession(sessionId: string, updates: {
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    updateSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<{
+        updated: boolean;
+    }>;
+    readSessionCompactionState(sessionId: string): Promise<SessionCompactionState | undefined>;
+    private isCompactionStateForSession;
+    private canPersistCompactionState;
+    private persistActiveSessionCompactionState;
+    private enqueueCompactionStateWrite;
+    listConfiguredAgents(sessionId: string): Promise<ConfiguredAgentSummary[]>;
+    /**
+     * Run a configured agent because the user asked for it.
+     *
+     * Refused while a turn is in flight, for the reason manual compaction is:
+     * the report is appended to the conversation, and appending to a transcript
+     * the agent loop is currently writing to would race it.
+     */
+    delegateToConfiguredAgent(input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }): Promise<ConfiguredAgentDelegationResult>;
+    /**
+     * Start a configured agent beside the turn instead of in place of it.
+     *
+     * No `canStartRun()` check, unlike the foreground call: running while the
+     * lead is working is the reason this exists. What that costs is a report
+     * that can arrive mid-turn, which {@link deliverBackgroundDelegation}
+     * answers.
+     */
+    startBackgroundDelegation(input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+    }): Promise<BackgroundDelegationView>;
+    listBackgroundDelegations(sessionId: string): Promise<BackgroundDelegationView[]>;
+    controlBackgroundDelegation(input: {
+        sessionId: string;
+        id: string;
+        action: "pause" | "resume" | "stop";
+    }): Promise<boolean>;
+    private backgroundDelegationsFor;
+    /**
+     * Put a finished background run into the conversation it was started from.
+     *
+     * Two ways in, because a background run finishes whenever it finishes. With
+     * the session idle it is appended directly, exactly as the foreground call
+     * does. With a turn in flight, appending would race the agent loop over the
+     * message list, so it is queued as a steer and the runtime picks it up at
+     * the top of its next iteration.
+     *
+     * A failure is reported too. A delegation the user asked for and that did
+     * not work is something both they and the lead need to know; only a run the
+     * user stopped says nothing, and that one never reaches here.
+     */
+    /**
+     * The user turned the change protocol off.
+     *
+     * Two ways in, for the same reason `deliverBackgroundDelegation` has two:
+     * with the session idle the notice is appended to the transcript directly,
+     * and with a turn in flight nothing is touched now -- the request is parked
+     * and the standing down happens at the top of the next iteration, where no
+     * tool call is open. A rollback is a write to the user's files, and the one
+     * thing it must never do is land while the model is mid-edit.
+     *
+     * Returns whether there was a protocol to stand down at all.
+     */
+    disengageAtomicProtocol(sessionId: string): Promise<boolean>;
+    /**
+     * A settled round the lead was not waiting for, delivered the way a
+     * background delegation's report is: appended with the session idle,
+     * queued as a steer for the next boundary with a turn in flight.
+     */
+    private deliverRound;
+    private deliverBackgroundDelegation;
+    readLiveSessionMessages(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+    updateSessionConnection(sessionId: string, rawUpdates: SessionConnectionUpdate): Promise<void>;
+    /**
+     * Serialized read-modify-write for a live session's manifest. Every
+     * manifest write for an active session MUST go through this helper: it
+     * re-reads the disk manifest first so disk-only writers (compaction-path
+     * updates, title/metadata renames) are never reverted by a stale in-memory
+     * copy, applies the field-level mutation, syncs the in-memory copy, and
+     * persists — one mutation at a time per session.
+     */
+    private mutateSessionManifest;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"]): Promise<void>;
+    private executeTurn;
+    private completeInteractiveTurn;
+    private resolveInteractiveStopStatus;
+    private resolveInteractiveStopExitCode;
+    private completeAbortedInteractiveTurn;
+    private executeAgentTurn;
+    /**
+     * Anchor `task.completed` telemetry to the assistant's explicit
+     * completion declaration. We emit at most once per session, the moment
+     * a successful `submit_and_exit` tool call is observed in the run
+     * result. This is the SDK analog of original Cline's
+     * `attempt_completion`-driven emission and works for both interactive
+     * and non-interactive sessions.
+     *
+     * `emitTaskCompletedOnTeardown(...)` retains a fallback emission for
+     * completed sessions that finish without an explicit completion-tool
+     * observation (e.g., non-interactive runs not using the yolo preset,
+     * or hosts that disable `submit_and_exit` entirely). This helper sets
+     * `taskCompletedEmitted` so the teardown fallback can suppress a
+     * duplicate emission for the same logical completion.
+     */
+    private observeTaskCompletionTool;
+    /**
+     * Single choke point for the fallback `task.completed` emission on
+     * session teardown. Every path a session can end through funnels into
+     * `shutdownSession(...)` or `releaseSessionRuntime(...)`, and BOTH must
+     * call this helper — the emission must never depend on which teardown
+     * branch a stop happens to route through. (The 4.1.11 regression:
+     * truthful session-status reporting re-routed many interactive stops
+     * onto the release branch, and the fallback that lived only inside
+     * `shutdownSession` silently stopped firing for them.)
+     *
+     * Emits at most once per session (`taskCompletedEmitted`), and never
+     * after the `submit_and_exit` observer already reported the completion.
+     * The completion criterion deliberately does not read `session.status`
+     * (whose lifecycle is what changed in 4.1.11):
+     *
+     * - Interactive sessions use the recorded final-turn outcome,
+     *   `lastInteractiveTurnFinishReason === "completed"`. The extra guards
+     *   suppress emission when teardown arrives mid-run (the in-flight turn
+     *   being aborted is the real final turn, and it did not complete).
+     * - Non-interactive sessions use the terminal status their run result
+     *   resolved to (`finalStatus`, from `finalizeSingleRun`), preserving
+     *   the pre-existing `input.status === "completed"` semantics.
+     *
+     * Sessions whose final turn errored or aborted emit nothing.
+     */
+    private emitTaskCompletedOnTeardown;
+    private prepareTurnInput;
+    /**
+     * Say whether the change protocol engaged, once, on the session's stream.
+     *
+     * Deferred from `startSession` deliberately: see `pendingAtomicStatus`. By
+     * here the session is persisted and every host has it on record, so the
+     * notice lands in the same channel as the verdicts rather than being
+     * dropped as an event for a session nobody has heard of.
+     */
+    private emitPendingAtomicStatus;
+    private ensureSessionPersisted;
+    private markTurnRunning;
+    /** Whether the session record already names this process as its owner. */
+    private ownsSessionRecord;
+    private refreshActiveSessionGitMetadata;
+    private markTurnPending;
+    private markTurnIdle;
+    private persistSessionMetadata;
+    private finalizeSingleRun;
+    private failSession;
+    private shutdownSession;
+    private releaseSessionRuntime;
+    private updateStatus;
+    private runWithAuthRetry;
+    private syncOAuthCredentials;
+    private getSessionOrThrow;
+    private resolveAbsoluteFilePaths;
+    private getSessionAgentTelemetryIdentity;
+    private seedAggregateUsageFromArtifacts;
+    private summarizePersistedTeammateUsage;
+    private withPersistedAggregateUsageFloor;
+    private emitStatus;
+    private emitSessionSnapshot;
+    private emit;
+    private listRows;
+    private getRow;
+    private readManifest;
+    private invoke;
+    private invokeOptional;
+    private invokeOptionalValue;
+}

package/dist/runtime/host/runtime-host-support.d.ts

@@ -0,0 +1,39 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { HookEventPayload } from "../../hooks";
+import type { CoreSessionEvent } from "../../types/events";
+import type { RuntimeHostSubscribeOptions, SessionAccumulatedUsage } from "./runtime-host";
+export declare class RuntimeHostEventBus {
+    private readonly listeners;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    emit(event: CoreSessionEvent): void;
+    get size(): number;
+}
+/**
+ * Where a session's messages really are, when the recorded path has moved.
+ *
+ * A session row stores the ABSOLUTE path of its own messages file. That is a
+ * cache -- the location is always derivable from the session id and the current
+ * sessions directory -- and it goes stale the moment the data directory moves.
+ * The Cerebriline migration moves it (`~/.cline` to `~/.cerebriline`), and the
+ * result was the worst shape of failure: the history list is built from the
+ * rows, so every session still LISTED, and every one of them opened EMPTY,
+ * because `readPersistedMessagesFile` answers `[]` for a file that is not there
+ * and says nothing about why.
+ *
+ * The stored path still wins when it resolves, so a session whose artifacts
+ * genuinely live somewhere else is untouched. And when neither location has the
+ * file, the stored path is returned unchanged rather than the derived one:
+ * a session whose messages are actually gone must keep reporting the path it
+ * expected, or real data loss is silently redressed as an empty conversation.
+ */
+export declare function resolveMessagesPath(storedPath: string | undefined | null, sessionId: string, sessionsDir: string | undefined | null): string | undefined;
+export declare function readPersistedMessagesFile(messagesPath?: string | null): Promise<LlmsProviders.MessageWithMetadata[]>;
+export declare function cloneAccumulatedUsage(usage: SessionAccumulatedUsage | undefined): SessionAccumulatedUsage | undefined;
+type HookAuditBackend = {
+    queueSpawnRequest(payload: HookEventPayload): Promise<void>;
+    upsertSubagentSessionFromHook(payload: HookEventPayload): Promise<string | undefined>;
+    appendSubagentHookAudit(sessionId: string, payload: HookEventPayload): Promise<void>;
+    applySubagentStatus(sessionId: string, payload: HookEventPayload): Promise<void>;
+};
+export declare function replaySubagentHookEvent(payload: HookEventPayload, backend: HookAuditBackend): Promise<void>;
+export {};