@cerebriline/core 4.100.240

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

@@ -0,0 +1,83 @@
+import type { AgentResult, ITelemetryService } from "@cerebriline/shared";
+import type { HookEventPayload } from "../../hooks";
+import type { RuntimeCapabilities } from "../../runtime/capabilities";
+import type { PendingPromptsServiceApi, RestoreSessionInput, RestoreSessionResult, RuntimeHost, RuntimeHostSubscribeOptions, SendSessionInput, SessionConnectionUpdate, SessionUsageSummary, StartSessionInput, StartSessionResult } from "../../runtime/host/runtime-host";
+import { type SessionCompactionState } from "../../session/models/session-compaction";
+import type { CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsSnapshot, CoreSettingsToggleInput } from "../../settings";
+import type { CoreSessionEvent } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+export interface HubRuntimeHostOptions {
+    url: string;
+    authToken?: string;
+    clientType?: string;
+    displayName?: string;
+    capabilities?: RuntimeCapabilities;
+    telemetry?: ITelemetryService;
+}
+export declare class HubRuntimeHost implements RuntimeHost {
+    runtimeAddress: string;
+    readonly pendingPrompts: PendingPromptsServiceApi;
+    private client;
+    private readonly clientOptions;
+    private readonly clientContext?;
+    private readonly events;
+    private readonly sessionCapabilities;
+    private readonly sessionClientContributionHandlers;
+    private readonly sessionSubscriptions;
+    private readonly pendingApprovalToolCallIds;
+    private readonly agentDoneEmittedForCurrentRunBySession;
+    private readonly activeCapabilityAbortControllers;
+    private readonly defaultCapabilities;
+    private readonly telemetry?;
+    constructor(options: HubRuntimeHostOptions, clientContext?: {
+        workspaceRoot?: string;
+        cwd?: string;
+    });
+    private createClient;
+    private replaceClient;
+    private recoverLocalHubStartupDeadlock;
+    private registerPlannedSession;
+    private cleanupPlannedSession;
+    connect(): Promise<void>;
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    private requestPendingPromptsList;
+    private requestPendingPromptUpdate;
+    private requestPendingPromptDelete;
+    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(): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    listSettings(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggleSetting(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    updateSession(sessionId: string, updates: {
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    updateSessionConnection(sessionId: string, updates: SessionConnectionUpdate): Promise<void>;
+    updateSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<{
+        updated: boolean;
+    }>;
+    readSessionCompactionState(sessionId: string): Promise<SessionCompactionState | undefined>;
+    readSessionMessages(sessionId: string): Promise<import("@cerebriline/llms").MessageWithMetadata[]>;
+    dispatchHookEvent(_payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    private ensureSessionSubscription;
+    private disposeSessionSubscription;
+    private resolveCapabilities;
+    private emitToolCallContentStart;
+    private emitAgentDoneIfNeeded;
+    private handleHubEvent;
+    private captureDetachedHubEventError;
+    private handleCapabilityRequest;
+    private handleCapabilityResolved;
+    private handleApprovalRequested;
+}

package/dist/hub/runtime-host/remote-runtime-host.d.ts

@@ -0,0 +1,9 @@
+import { HubRuntimeHost, type HubRuntimeHostOptions } from "./hub-runtime-host";
+export interface RemoteRuntimeHostOptions extends Omit<HubRuntimeHostOptions, "url"> {
+    endpoint: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export declare class RemoteRuntimeHost extends HubRuntimeHost {
+    constructor(options: RemoteRuntimeHostOptions);
+}

package/dist/hub/server/browser-websocket.d.ts

@@ -0,0 +1,22 @@
+import type { ITelemetryService } from "@cerebriline/shared";
+import type { HubCommandTransport } from "./command-transport";
+export interface BrowserHubSocketLike {
+    send(data: string): void;
+    addEventListener(type: "message", listener: (event: {
+        data: string;
+    }) => void): void;
+    addEventListener(type: "close", listener: () => void): void;
+    removeEventListener(type: "message", listener: (event: {
+        data: string;
+    }) => void): void;
+    removeEventListener(type: "close", listener: () => void): void;
+}
+export declare class BrowserWebSocketHubAdapter {
+    private readonly transport;
+    private readonly telemetry?;
+    private readonly workspaceRoot?;
+    constructor(transport: HubCommandTransport, telemetry?: ITelemetryService | undefined, workspaceRoot?: string | undefined);
+    attach(socket: BrowserHubSocketLike, options?: {
+        allowRegisteredWorkspace?: boolean;
+    }): () => void;
+}

package/dist/hub/server/command-transport.d.ts

@@ -0,0 +1,29 @@
+import type { HubClientRegistration, HubCommandEnvelope, HubEventEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+/** Authority captured once by an authenticated transport connection. */
+export interface HubConnectionAuthority {
+    clientId: string;
+    workspaceContext?: HubClientRegistration["workspaceContext"];
+    /**
+     * Token-authenticated connections may already bind any workspace at
+     * registration time, so they are also allowed to explicitly request
+     * cross-workspace schedule access (`allWorkspaces` command payloads).
+     */
+    crossWorkspace?: boolean;
+}
+export interface HubCommandTransport {
+    command(envelope: HubCommandEnvelope, 
+    /** `null` means the remote connection has not registered yet. */
+    authority?: HubConnectionAuthority | null): Promise<HubReplyEnvelope>;
+    subscribe(clientId: string, listener: (event: HubEventEnvelope) => void, options?: {
+        sessionId?: string;
+    }): Promise<() => void> | (() => void);
+    /**
+     * Durable events with `sequence > sinceSequence` (scoped when a sessionId
+     * is given), oldest first, bounded by `limit`. Absent on transports
+     * without a durable event log; callers must treat replay as best-effort.
+     */
+    replayEventsAfter?(sinceSequence: number, options: {
+        sessionId?: string;
+        limit: number;
+    }): HubEventEnvelope[];
+}

package/dist/hub/server/handlers/approval-handlers.d.ts

@@ -0,0 +1,24 @@
+import type { HubCommandEnvelope, HubEventEnvelope, HubReplyEnvelope, ToolApprovalRequest } from "@cerebriline/shared";
+import { type HubTransportContext } from "./context";
+export declare function requestToolApproval(ctx: HubTransportContext, request: ToolApprovalRequest): Promise<{
+    approved: boolean;
+    reason?: string;
+}>;
+/**
+ * Pending `approval.requested` events, optionally scoped to one session.
+ * Re-issued to a (re)subscribing client so an approval raised while nobody
+ * was connected — or while this client was disconnected — is neither lost
+ * nor implicitly answered.
+ */
+export declare function pendingApprovalEvents(ctx: HubTransportContext, sessionId?: string): HubEventEnvelope[];
+export declare function resolvePendingApproval(ctx: HubTransportContext, approvalId: string, result: {
+    approved: boolean;
+    reason?: string;
+}): {
+    sessionId: string;
+} | undefined;
+export declare function cancelPendingApprovals(ctx: HubTransportContext, filter: (approval: {
+    approvalId: string;
+    sessionId: string;
+}) => boolean, reason: string): number;
+export declare function handleApprovalRespond(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;

package/dist/hub/server/handlers/capability-handlers.d.ts

@@ -0,0 +1,12 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+import { type HubTransportContext } from "./context";
+export declare function requestCapability(ctx: HubTransportContext, sessionId: string, capabilityName: string, payload: Record<string, unknown>, targetClientId: string, onProgress?: (payload: Record<string, unknown>) => void): Promise<Record<string, unknown> | undefined>;
+export declare function handleCapabilityProgress(ctx: HubTransportContext, envelope: HubCommandEnvelope): HubReplyEnvelope;
+export declare function cancelPendingCapabilityRequests(ctx: HubTransportContext, filter: (request: {
+    requestId: string;
+    sessionId: string;
+    targetClientId: string;
+    capabilityName: string;
+}) => boolean, reason: string): number;
+export declare function handleCapabilityRequest(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleCapabilityRespond(ctx: HubTransportContext, envelope: HubCommandEnvelope): HubReplyEnvelope;

package/dist/hub/server/handlers/client-handlers.d.ts

@@ -0,0 +1,6 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+import { type HubTransportContext } from "./context";
+export declare function handleClientRegister(ctx: HubTransportContext, envelope: HubCommandEnvelope): HubReplyEnvelope;
+export declare function handleClientUpdate(ctx: HubTransportContext, envelope: HubCommandEnvelope): HubReplyEnvelope;
+export declare function handleClientUnregister(ctx: HubTransportContext, envelope: HubCommandEnvelope, onClientRemoved: (clientId: string) => void): HubReplyEnvelope;
+export declare function handleClientList(ctx: HubTransportContext, envelope: HubCommandEnvelope): HubReplyEnvelope;

package/dist/hub/server/handlers/connector-handlers.d.ts

@@ -0,0 +1,20 @@
+import type { ConnectorChannelsResponse, HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+import { type HubTransportContext } from "./context";
+declare function connectorChannelsPayload(): ConnectorChannelsResponse;
+declare function configureConnector(payload: unknown): ConnectorChannelsResponse;
+declare function deleteConnectorConfig(payload: unknown): ConnectorChannelsResponse;
+declare function startSupervisedConnector(payload: unknown): Promise<import("@cerebriline/shared").ConnectorStartResult>;
+declare function stopSupervisedConnector(payload: unknown): Promise<{
+    stopped: boolean;
+    channel: string;
+    instanceId: string;
+}>;
+export declare function handleConnectorCommand(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare const __test__: {
+    configureConnector: typeof configureConnector;
+    connectorChannelsPayload: typeof connectorChannelsPayload;
+    deleteConnectorConfig: typeof deleteConnectorConfig;
+    startSupervisedConnector: typeof startSupervisedConnector;
+    stopSupervisedConnector: typeof stopSupervisedConnector;
+};
+export {};

package/dist/hub/server/handlers/context.d.ts

@@ -0,0 +1,98 @@
+import type { AgentExtension, AgentTool, HubClientRecord, HubCommandEnvelope, HubEventEnvelope, HubReplyEnvelope, SessionRecord as HubSessionRecord, ITelemetryService, JsonValue, SessionParticipant } from "@cerebriline/shared";
+import type { CommandExecutionRuntimeService, PendingPromptsRuntimeService, RuntimeHost, SessionConnectionRuntimeService, SessionUsageRuntimeService } from "../../../runtime/host/runtime-host";
+import type { SessionHistorySearchService } from "../../../session/search";
+import { type CoreSessionSnapshot } from "../../../session/session-snapshot";
+import { type HubSessionState } from "../hub-session-records";
+export type PendingApproval = {
+    sessionId: string;
+    resolve: (result: {
+        approved: boolean;
+        reason?: string;
+    }) => void;
+    /**
+     * The `approval.requested` event as originally published. Pending
+     * approvals survive client disconnects, so a (re)subscribing client is
+     * re-issued this event instead of being left with a silently parked turn.
+     */
+    requestedEvent?: HubEventEnvelope;
+};
+export type PendingCapabilityRequest = {
+    sessionId: string;
+    targetClientId: string;
+    capabilityName: string;
+    onProgress?: (payload: Record<string, unknown>) => void;
+    resolve: (result: {
+        ok: boolean;
+        payload?: Record<string, unknown>;
+        error?: string;
+    }) => void;
+};
+/**
+ * Shared mutable state and helpers passed to every command-handler module.
+ * The transport class owns the maps; handlers get a stable read/write surface.
+ */
+export interface HubTransportContext {
+    readonly sessionSearch: SessionHistorySearchService;
+    readonly clients: Map<string, HubClientRecord>;
+    readonly sessionState: Map<string, HubSessionState>;
+    readonly pendingApprovals: Map<string, PendingApproval>;
+    readonly pendingCapabilityRequests: Map<string, PendingCapabilityRequest>;
+    readonly suppressNextTerminalEventBySession: Map<string, string>;
+    /**
+     * Count of RPC-driven turns (`run.start` / session input commands)
+     * currently awaiting `sessionHost.runTurn` per session. While > 0 the
+     * awaiting handler publishes the authoritative terminal run event, so the
+     * session-event projector must not publish its own `run.failed` for
+     * agent-level error events emitted during that turn. Turns drained from
+     * the pending-prompt queue run with no awaiting RPC handler (count 0), so
+     * the projector is their only failure reporter.
+     */
+    readonly activeRpcTurnCountBySession: Map<string, number>;
+    readonly telemetry?: ITelemetryService;
+    /** Hub-owned tools injected into every local session runtime. */
+    readonly sessionTools?: readonly AgentTool[];
+    /** Hub-owned extensions injected into every local session runtime. */
+    readonly sessionExtensions?: readonly AgentExtension[];
+    readonly sessionHost: RuntimeHost & Partial<CommandExecutionRuntimeService & PendingPromptsRuntimeService & SessionUsageRuntimeService & SessionConnectionRuntimeService>;
+    /**
+     * While draining, new mutating work (session.create, run.*) is refused
+     * with the retryable `hub_draining` error so the Hub can be replaced at a
+     * boundary an operator chose instead of being ambushed mid-turn.
+     * Optional: absent contexts (test fixtures) are never draining.
+     */
+    isDraining?(): boolean;
+    publish(event: HubEventEnvelope): void;
+    buildEvent(event: HubEventEnvelope["event"], payload?: Record<string, unknown>, sessionId?: string): HubEventEnvelope;
+    requestCapability(sessionId: string, capabilityName: string, payload: Record<string, unknown>, targetClientId: string, onProgress?: (payload: Record<string, unknown>) => void): Promise<Record<string, unknown> | undefined>;
+}
+type EnvelopeRef = Pick<HubCommandEnvelope, "version" | "requestId">;
+export declare function okReply(envelope: EnvelopeRef, payload?: HubReplyEnvelope["payload"]): HubReplyEnvelope;
+export declare function errorReply(envelope: EnvelopeRef, code: string, message: string): HubReplyEnvelope;
+/** Returns the value when it's a plain object, or undefined otherwise. */
+export declare function asPlainRecord(value: unknown): Record<string, JsonValue | undefined> | undefined;
+/**
+ * Pulls the session id from the envelope. Handlers accept either
+ * `payload.sessionId` (top-level command argument) or `envelope.sessionId`
+ * (envelope-level addressing). Returns "" when neither is present so handlers
+ * can branch on truthiness.
+ */
+export declare function extractSessionId(envelope: HubCommandEnvelope): string;
+export declare function buildHubEvent(event: HubEventEnvelope["event"], payload?: Record<string, unknown>, sessionId?: string): HubEventEnvelope;
+export declare function readHubSessionRecord(ctx: HubTransportContext, sessionId: string): Promise<HubSessionRecord | undefined>;
+/**
+ * Builds the snapshot that rides on hub events and command replies. It is a
+ * state notification — status, usage, model, workspace, checkpoint — and
+ * deliberately does NOT read the transcript: `snapshot.messages` here would
+ * put the entire conversation on every status flip, for every subscriber,
+ * and into the durable event log (observed in the wild as a 25GB hub process
+ * feeding a slow reader). Anything that needs messages fetches them with the
+ * `session.messages` command.
+ */
+export declare function readCoreSessionSnapshot(ctx: HubTransportContext, sessionId: string): Promise<CoreSessionSnapshot | undefined>;
+export declare function ensureSessionState(ctx: HubTransportContext, sessionId: string, clientId: string, role: SessionParticipant["role"], options?: {
+    interactive?: boolean;
+}): HubSessionState;
+export declare function ensureSessionParticipant(ctx: HubTransportContext, sessionId: string, clientId: string, role: SessionParticipant["role"], options?: {
+    interactive?: boolean;
+}): HubSessionState;
+export {};

package/dist/hub/server/handlers/run-handlers.d.ts

@@ -0,0 +1,6 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+import { type HubTransportContext } from "./context";
+export declare function handleSessionInput(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleRunAbort(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleRunProceedWhileRunning(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionHook(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;

package/dist/hub/server/handlers/run-queue-handlers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Queue-backed run admission (`run.enqueue`), queue introspection
+ * (`run.list`), and drain lifecycle (`hub.drain`, `hub.status`).
+ *
+ * `run.start` keeps its historical synchronous-reply contract untouched;
+ * `run.enqueue` is the additive path with app-server semantics: durable FIFO
+ * admission, an immediate `{runId, acceptedAt, queuePosition}` ack, and
+ * execution that never depends on the requesting socket staying alive.
+ */
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/shared";
+import { type HubRunQueue } from "../hub-run-queue";
+import { type HubTransportContext } from "./context";
+export declare const HUB_DRAINING_ERROR_CODE = "hub_draining";
+export declare function isDrainRefusedCommand(command: string): boolean;
+export declare function drainingReply(envelope: HubCommandEnvelope): HubReplyEnvelope;
+/**
+ * Serial per-session executor over the durable queue. Admission and
+ * execution are decoupled: `enqueue` acks immediately, `pump` runs turns one
+ * at a time per session through the same `handleSessionInput` path (and thus
+ * the same event projection) as `run.start`.
+ */
+export declare class HubRunExecutor {
+    private readonly ctx;
+    private readonly queue;
+    private readonly activeSessions;
+    constructor(ctx: HubTransportContext, queue: HubRunQueue);
+    /** Start (or continue) draining the session's queue in the background. */
+    pump(sessionId: string): void;
+    private drainSession;
+    private execute;
+}
+export declare function handleRunEnqueue(ctx: HubTransportContext, envelope: HubCommandEnvelope, queue: HubRunQueue, executor: HubRunExecutor): HubReplyEnvelope;
+export declare function handleRunList(envelope: HubCommandEnvelope, queue: HubRunQueue): HubReplyEnvelope;

package/dist/hub/server/handlers/session-event-projector.d.ts

@@ -0,0 +1,7 @@
+import type { CoreSessionEvent } from "../../../types/events";
+import { type HubTransportContext } from "./context";
+/**
+ * Translates internal `CoreSessionEvent`s emitted by the session host into the
+ * outward-facing `HubEventEnvelope` stream.
+ */
+export declare function projectSessionEvent(ctx: HubTransportContext, event: CoreSessionEvent): Promise<void>;

package/dist/hub/server/handlers/session-handlers.d.ts

@@ -0,0 +1,30 @@
+import type { HubCommandEnvelope, HubReplyEnvelope, ToolApprovalRequest } from "@cerebriline/shared";
+import type { SessionConnectionUpdate } from "../../../runtime/host/runtime-host";
+import { type HubTransportContext } from "./context";
+export declare function selectSessionTools<T extends {
+    name: string;
+}>(tools: readonly T[], mode: string, source?: string): T[];
+export declare function readSessionConnectionUpdate(value: unknown): SessionConnectionUpdate;
+export declare function resolveSessionAutoApproveTools(toolPolicies: unknown, runtimeOptions: Record<string, unknown>): boolean;
+export declare function handleSessionCreate(ctx: HubTransportContext, envelope: HubCommandEnvelope, requestToolApproval: (request: ToolApprovalRequest) => Promise<{
+    approved: boolean;
+    reason?: string;
+}>): Promise<HubReplyEnvelope>;
+export declare function handleSessionRestore(ctx: HubTransportContext, envelope: HubCommandEnvelope, requestToolApproval: (request: ToolApprovalRequest) => Promise<{
+    approved: boolean;
+    reason?: string;
+}>): Promise<HubReplyEnvelope>;
+export declare function handleSessionAttach(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionDetach(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionGet(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionMessages(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionCompactionGet(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionList(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionSearch(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionUpdate(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionUpdateConnection(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionCompactionUpdate(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionDelete(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionPendingPrompts(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionUpdatePendingPrompt(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+export declare function handleSessionRemovePendingPrompt(ctx: HubTransportContext, envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;

package/dist/hub/server/hub-client-contributions.d.ts

@@ -0,0 +1,19 @@
+import type { AgentHooks, HubClientContribution } from "@cerebriline/shared";
+export { HUB_CHECKPOINT_CAPABILITY, HUB_COMPACTION_CAPABILITY, HUB_CUSTOM_TOOL_CAPABILITY_PREFIX, HUB_HOOK_CAPABILITY_PREFIX, HUB_MISTAKE_LIMIT_CAPABILITY, HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX, HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY, } from "@cerebriline/shared";
+import type { ToolExecutors } from "../../extensions/tools";
+import type { LocalRuntimeStartOptions, RuntimeSessionConfig } from "../../runtime/host/runtime-host";
+type RequestCapability = (sessionId: string, capabilityName: string, payload: Record<string, unknown>, targetClientId: string, onProgress?: (payload: Record<string, unknown>) => void) => Promise<Record<string, unknown> | undefined>;
+export declare function listHubAgentHookNames(hooks: AgentHooks | undefined): string[];
+export declare function parseHubClientContributions(value: unknown): HubClientContribution[];
+export declare function createHubClientContributionRuntime(input: {
+    sessionId: string;
+    targetClientId: string;
+    contributions: readonly HubClientContribution[];
+    sessionConfig?: Partial<RuntimeSessionConfig>;
+    requestCapability: RequestCapability;
+}): {
+    localRuntime: LocalRuntimeStartOptions;
+    toolExecutors?: Partial<ToolExecutors>;
+    hasClientContributions: boolean;
+};
+export declare function defaultClientContributionCapabilityName(contribution: Pick<HubClientContribution, "kind"> & Record<string, unknown>): string | undefined;

package/dist/hub/server/hub-event-log.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Durable, cursor-addressed Hub event log.
+ *
+ * Every event the Hub publishes is appended here with a monotonically
+ * increasing global sequence before it is fanned out to live sockets. A
+ * client that reconnects can resume exactly where it left off by passing
+ * `sinceSequence` on `stream.subscribe`: the adapter replays pages from this
+ * log, then live-tails. Nothing about delivery depends on who was watching
+ * when the event happened — disconnect never implies data loss.
+ *
+ * The log is a projection aid, not the source of truth for conversation
+ * history (session messages remain canonical on disk); it is bounded by a
+ * retention sweep so it can run forever.
+ */
+import type { HubEventEnvelope } from "@cerebriline/shared";
+export interface HubEventLogOptions {
+    /** Database file. Defaults to an owner-scoped `<data>/db/hub-events-*.db`; use ":memory:" in tests. */
+    dbPath?: string;
+    /** Scopes the default `dbPath`; ignored when `dbPath` is given. */
+    ownerId?: string;
+    /** Events older than this are pruned. Defaults to 7 days. */
+    retentionMs?: number;
+    /** Hard cap on rows kept, oldest pruned first. Defaults to 200k. */
+    maxRows?: number;
+    /** Cap on the database file size, oldest rows pruned first. Defaults to 64 MiB. */
+    maxTotalBytes?: number;
+}
+export interface HubEventLogScope {
+    sessionId?: string;
+}
+/**
+ * Default log location, scoped per hub owner context so coexisting hubs
+ * (production and a dev shared hub) never interleave one log's sequences.
+ */
+export declare function resolveHubEventLogPath(ownerId?: string): string;
+export declare class HubEventLogStore {
+    private readonly db;
+    private readonly retentionMs;
+    private readonly maxRows;
+    private readonly maxTotalBytes;
+    private appendedBytesSincePrune;
+    private closed;
+    constructor(options?: HubEventLogOptions);
+    /**
+     * Append a durable event and return it stamped with its global sequence.
+     * The returned envelope (not the input) is what must be fanned out so
+     * live listeners and replaying clients observe identical frames.
+     */
+    append(envelope: HubEventEnvelope): HubEventEnvelope;
+    /** Events after `sequence`, oldest first, optionally scoped to a session. */
+    listAfter(sequence: number, scope: HubEventLogScope, limit: number): HubEventEnvelope[];
+    lastSequence(): number;
+    /** Bound the log: drop rows past retention, the row cap, and the size budget. */
+    prune(now?: number): void;
+    private fileSizeBytes;
+    close(): void;
+}

package/dist/hub/server/hub-notifications.d.ts

@@ -0,0 +1,7 @@
+import type { SessionRecord as HubSessionRecord } from "@cerebriline/shared";
+export declare function truncateNotificationBody(value: string): string;
+export declare function buildCompletionNotification(session: HubSessionRecord | undefined): Promise<{
+    title: string;
+    body: string;
+    severity: "info";
+}>;

package/dist/hub/server/hub-run-queue.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Durable FIFO run queue with immediate acknowledgement.
+ *
+ * `run.enqueue` admits a prompt into this queue and acks immediately with
+ * `{runId, acceptedAt, queuePosition}` — acceptance is decoupled from
+ * execution, so the reply never blocks on the turn and never dies with the
+ * socket. One run executes at a time per session, in admission order.
+ *
+ * Runs are durable: a daemon crash leaves `queued` rows to re-admit in FIFO
+ * order at the next startup, and `running` rows are marked `interrupted` —
+ * never silently resumed, never left dangling as ghost "running" state.
+ *
+ * Admission applies backpressure: a full per-session queue rejects with a
+ * retryable `run_admission_rejected` instead of accepting unbounded work.
+ */
+export type HubRunState = "queued" | "running" | "completed" | "failed" | "aborted" | "interrupted";
+export interface HubRunRecord {
+    runId: string;
+    sessionId: string;
+    state: HubRunState;
+    /** The `run.start`-shaped payload to execute (prompt, mode, attachments, ...). */
+    input: Record<string, unknown>;
+    clientId?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    endedAt?: number;
+    error?: string;
+}
+export interface HubRunAccepted {
+    runId: string;
+    acceptedAt: number;
+    queuePosition: number;
+}
+export declare class HubRunAdmissionRejectedError extends Error {
+    readonly retryable = true;
+    constructor(sessionId: string, pending: number, limit: number);
+}
+export interface HubRunQueueOptions {
+    /** Database file. Defaults to an owner-scoped `<data>/db/hub-runs-*.db`; use ":memory:" in tests. */
+    dbPath?: string;
+    /** Scopes the default `dbPath`; ignored when `dbPath` is given. */
+    ownerId?: string;
+    maxPendingPerSession?: number;
+}
+/**
+ * Default queue location, scoped per hub owner context: startup recovery
+ * marks orphaned `running` rows interrupted, and a coexisting hub (dev
+ * shared next to production) must never reap another hub's live runs.
+ */
+export declare function resolveHubRunQueuePath(ownerId?: string): string;
+export declare class HubRunQueue {
+    private readonly db;
+    private readonly maxPendingPerSession;
+    private closed;
+    constructor(options?: HubRunQueueOptions);
+    /** Durable FIFO admission + immediate acknowledgement. */
+    admit(sessionId: string, input: Record<string, unknown>, clientId?: string): HubRunAccepted;
+    get(runId: string): HubRunRecord | undefined;
+    /** Oldest queued run for the session, if any. */
+    nextQueued(sessionId: string): HubRunRecord | undefined;
+    /** Whether a run is currently marked running for the session. */
+    hasRunning(sessionId: string): boolean;
+    countPendingBySession(sessionId: string): number;
+    countPending(): number;
+    markRunning(runId: string): void;
+    markTerminal(runId: string, state: Extract<HubRunState, "completed" | "failed" | "aborted" | "interrupted">, error?: string): void;
+    list(options?: {
+        sessionId?: string;
+        limit?: number;
+    }): HubRunRecord[];
+    /**
+     * Crash recovery, run once at daemon startup, before any new admission:
+     * runs left `running` by a dead daemon are marked `interrupted` (never
+     * auto-resumed — a resumed half-turn is worse than an honest interrupt),
+     * and committed `queued` runs are returned for FIFO re-admission.
+     */
+    recoverOnStartup(): {
+        interrupted: HubRunRecord[];
+        requeued: HubRunRecord[];
+    };
+    close(): void;
+}

package/dist/hub/server/hub-schedule-events.d.ts

@@ -0,0 +1,2 @@
+import type { HubCommandEnvelope, HubEventEnvelope } from "@cerebriline/shared";
+export declare function eventNameForScheduleCommand(command: HubCommandEnvelope["command"]): HubEventEnvelope["event"] | undefined;

package/dist/hub/server/hub-server-logging.d.ts

@@ -0,0 +1,2 @@
+export declare function logHubMessage(level: "debug" | "info" | "warn" | "error", message: string, context?: Record<string, unknown>): void;
+export declare function logHubBoundaryError(message: string, error: unknown): void;