@clinebot/core 0.0.37 → 0.0.38

package/dist/runtime/capabilities/index.d.ts

@@ -0,0 +1,2 @@
+export { normalizeRuntimeCapabilities } from "./normalize-runtime-capabilities";
+export type { RuntimeCapabilities } from "./runtime-capabilities";

package/dist/runtime/capabilities/normalize-runtime-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeCapabilities } from "./runtime-capabilities";
+export declare function normalizeRuntimeCapabilities(...sources: Array<RuntimeCapabilities | undefined>): RuntimeCapabilities | undefined;

package/dist/runtime/capabilities/runtime-capabilities.d.ts

@@ -0,0 +1,6 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@clinebot/shared";
+import type { ToolExecutors } from "../../extensions/tools";
+export interface RuntimeCapabilities {
+    toolExecutors?: Partial<ToolExecutors>;
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+}

package/dist/runtime/config/agent-message-codec.d.ts

@@ -0,0 +1,6 @@
+import type { AgentMessage, Message, MessageWithMetadata } from "@clinebot/shared";
+export declare function messageToAgentMessages(message: MessageWithMetadata): AgentMessage[];
+export declare function messagesToAgentMessages(messages: readonly MessageWithMetadata[]): AgentMessage[];
+export declare function agentMessageToMessageWithMetadata(message: AgentMessage): MessageWithMetadata;
+export declare function agentMessagesToMessagesWithMetadata(messages: readonly AgentMessage[]): MessageWithMetadata[];
+export declare function agentMessagesToMessages(messages: readonly AgentMessage[]): Message[];

package/dist/runtime/{agent-runtime-config-builder.d.ts → config/agent-runtime-config-builder.d.ts}

@@ -2,23 +2,16 @@
  * Build an `AgentRuntimeConfig` from an `AgentConfig` plus session-owned
  * supporting objects (model handler, tools, hooks, plugins, telemetry).
  *
- * @see PLAN.md §3.1 — new file introduced alongside the core runtime port.
- * @see PLAN.md §3.2.1 — field-by-field mapping.
- *
- * Implemented in Step 8c. The function is intentionally **pure** — it
- * does not create handlers or tools itself; it receives them already
- * adapted (via `agent-config-adapter.ts`) from the caller
- * (`SessionRuntime`) and wires them into an `AgentRuntimeConfig`.
+ * The function is intentionally **pure**: it does not create handlers or tools
+ * itself; it receives them already resolved from the caller (`SessionRuntime`)
+ * and wires them into an `AgentRuntimeConfig`.
  *
  * Fields that do **not** round-trip into `AgentRuntimeConfig`
- * (e.g. `execution.maxConsecutiveMistakes`,
- * `execution.loopDetection`, `hookPolicies`) are
+ * (e.g. `execution.maxConsecutiveMistakes`, `execution.loopDetection`) are
  * consumed by `SessionRuntime` / `MistakeTracker` /
- * `LoopDetectionTracker` — not passed through here. See §3.2.1's
- * "Fields with no corresponding AgentRuntimeConfig slot" note.
+ * `LoopDetectionTracker` — not passed through here.
  */
-import type { AgentConfig, AgentMessage, AgentModel, AgentRuntimeConfig, AgentRuntimePlugin, AgentTelemetry, AgentTool, BasicLogger } from "@clinebot/shared";
-import type { HookBridge } from "../hooks/hook-bridge";
+import type { AgentConfig, AgentMessage, AgentModel, AgentRuntimeConfig, AgentRuntimeHooks, AgentRuntimePlugin, AgentRuntimePrepareTurnContext, AgentRuntimePrepareTurnResult, AgentTelemetry, AgentTool, BasicLogger } from "@clinebot/shared";
 /**
  * Inputs required to assemble an `AgentRuntimeConfig`. Distinct from
  * `AgentConfig` because some of these (the model adapter, the hook
@@ -47,14 +40,13 @@ export interface CreateAgentRuntimeConfigInput {
     readonly telemetry?: AgentTelemetry;
     /** Pre-built tool array (builtins + plugin-contributed + session extras). */
     readonly tools?: readonly AgentTool<unknown, unknown>[];
+    readonly toolContextMetadata?: Record<string, unknown>;
     /** Pre-resolved plugin list from the plugin loader. */
     readonly plugins?: readonly AgentRuntimePlugin[];
-    /**
-     * Optional hook bridge. When provided, `AgentRuntimeConfig.hooks`
-     * is populated from `hookBridge.toRuntimeHooks()`. Omit for
-     * runtimes that do not need hook dispatch (e.g. unit tests).
-     */
-    readonly hookBridge?: HookBridge;
+    /** Runtime hooks supplied by the session/runtime builder. */
+    readonly hooks?: Partial<AgentRuntimeHooks>;
+    /** Host-owned context pipeline invoked before runtime model hooks. */
+    readonly prepareTurn?: (context: AgentRuntimePrepareTurnContext) => Promise<AgentRuntimePrepareTurnResult | undefined> | AgentRuntimePrepareTurnResult | undefined;
     /** Seed messages (usually `session.conversation.getMessages()`). */
     readonly initialMessages?: readonly AgentMessage[];
     /**
@@ -66,7 +58,7 @@ export interface CreateAgentRuntimeConfigInput {
     readonly systemPrompt?: string;
 }
 /**
- * Produce an `AgentRuntimeConfig` per PLAN.md §3.2.1 mapping.
+ * Produce an `AgentRuntimeConfig` from session-owned runtime inputs.
  */
 export declare function createAgentRuntimeConfig(input: CreateAgentRuntimeConfigInput): AgentRuntimeConfig;
 /**
@@ -93,4 +85,3 @@ export declare function resolveToolExecution(maxParallelToolCalls: number | unde
  * `ITelemetryService` instance owned by `SessionRuntime`.
  */
 export declare function mapTelemetry(telemetry: AgentConfig["telemetry"]): AgentTelemetry | undefined;
-//# sourceMappingURL=agent-runtime-config-builder.d.ts.map

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

@@ -0,0 +1,18 @@
+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;
+}
+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.d.ts → host/host.d.ts}

@@ -1,8 +1,7 @@
-import type { ClineCoreOptions } from "../ClineCore";
-import { FileSessionService } from "../session/file-session-service";
-import { CoreSessionService } from "../session/session-service";
+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>;
-//# sourceMappingURL=host.d.ts.map

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

@@ -0,0 +1,29 @@
+import type { AgentEvent, BasicLogger } from "@clinebot/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>;
+    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);
+    dispatchAgentEvent(sessionId: string, config: CoreSessionConfig, event: AgentEvent): void;
+    handleTeamEvent(rootSessionId: string, event: TeamEvent): Promise<void>;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"]): Promise<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,15 @@
+import type { AgentEvent, AgentTool } from "@clinebot/shared";
+import { type ToolExecutors } from "../../../extensions/tools";
+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>;
+}
+export declare function createSessionSpawnTool(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,118 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import { type AgentConfig, type AgentResult, type ITelemetryService } from "@clinebot/shared";
+import type { HookEventPayload } from "../../hooks";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+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, SessionAccumulatedUsage, 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;
+    /**
+     * 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 {
+    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 defaultFetch?;
+    private readonly events;
+    private readonly sessions;
+    private readonly usageBySession;
+    private readonly subAgentStarts;
+    private readonly pendingPromptsController;
+    private readonly eventBridge;
+    private readonly sessionVersioning;
+    constructor(options: LocalRuntimeHostOptions);
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    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;
+    }>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+    handlePluginEvent(rootSessionId: string, event: {
+        name: string;
+        payload?: unknown;
+    }, fallbackAutomation?: NonNullable<CoreSessionConfig["extensionContext"]>["automation"]): Promise<void>;
+    private executeTurn;
+    private completeInteractiveTurn;
+    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.
+     *
+     * `shutdownSession(...)` 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). This helper
+     * sets `submitAndExitObserved` so the shutdown fallback can suppress a
+     * duplicate emission for the same logical completion.
+     */
+    private observeTaskCompletionTool;
+    private prepareTurnInput;
+    private ensureSessionPersisted;
+    private markTurnRunning;
+    private persistSessionMetadata;
+    private finalizeSingleRun;
+    private failSession;
+    private shutdownSession;
+    private releaseSessionRuntime;
+    private updateStatus;
+    private runWithAuthRetry;
+    private syncOAuthCredentials;
+    private getSessionOrThrow;
+    private resolveAbsoluteFilePaths;
+    private getSessionAgentTelemetryIdentity;
+    private emitStatus;
+    private emitSessionSnapshot;
+    private emit;
+    private listRows;
+    private getRow;
+    private readManifest;
+    private invoke;
+    private invokeOptional;
+    private invokeOptionalValue;
+}

package/dist/{transports → runtime/host}/runtime-host-support.d.ts

@@ -1,7 +1,7 @@
 import type * as LlmsProviders from "@clinebot/llms";
-import type { HookEventPayload } from "../hooks";
-import type { RuntimeHostSubscribeOptions, SessionAccumulatedUsage } from "../runtime/runtime-host";
-import type { CoreSessionEvent } from "../types/events";
+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;
@@ -9,7 +9,6 @@ export declare class RuntimeHostEventBus {
     get size(): number;
 }
 export declare function readPersistedMessagesFile(messagesPath?: string | null): Promise<LlmsProviders.Message[]>;
-export declare function sanitizeDisplayMessages(messages: LlmsProviders.Message[]): LlmsProviders.Message[];
 export declare function cloneAccumulatedUsage(usage: SessionAccumulatedUsage | undefined): SessionAccumulatedUsage | undefined;
 type HookAuditBackend = {
     queueSpawnRequest(payload: HookEventPayload): Promise<void>;
@@ -19,4 +18,3 @@ type HookAuditBackend = {
 };
 export declare function replaySubagentHookEvent(payload: HookEventPayload, backend: HookAuditBackend): Promise<void>;
 export {};
-//# sourceMappingURL=runtime-host-support.d.ts.map

package/dist/runtime/{runtime-host.d.ts → host/runtime-host.d.ts}

@@ -1,29 +1,38 @@
 import type * as LlmsProviders from "@clinebot/llms";
-import type { AgentResult, RuntimeConfigExtensionKind, ToolApprovalRequest, ToolApprovalResult } from "@clinebot/shared";
-import type { ToolExecutors } from "../extensions/tools";
-import type { HookEventPayload } from "../hooks";
-import type { ProviderSettings } from "../llms/provider-settings";
-import type { SessionManifest } from "../session/session-manifest";
-import type { SessionSource } from "../types/common";
-import type { CoreSessionConfig } from "../types/config";
-import type { CoreSessionEvent, SessionPendingPrompt } from "../types/events";
-import type { SessionRecord } from "../types/sessions";
+import type { AgentResult, RuntimeConfigExtensionKind } from "@clinebot/shared";
+import type { HookEventPayload } from "../../hooks";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+import type { ProviderSettings } from "../../services/llms/provider-settings";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent, SessionPendingPrompt } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
 type LocalOnlyCoreSessionConfigKeys = "hooks" | "logger" | "telemetry" | "extensionContext" | "extraTools" | "extensions" | "onTeamEvent" | "onConsecutiveMistakeLimitReached";
 export type RuntimeSessionConfig = Omit<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"> & {
     checkpoint?: Omit<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint">;
     compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
 };
-export type LocalRuntimeConfigOverrides = Pick<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys> & {
+export type LocalRuntimeBootstrapConfig = Pick<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys> & {
     checkpoint?: Pick<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint"> & Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
     compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> & Partial<NonNullable<CoreSessionConfig["compaction"]>>;
 };
 export interface LocalRuntimeStartOptions {
-    configOverrides?: Partial<LocalRuntimeConfigOverrides>;
+    hooks?: LocalRuntimeBootstrapConfig["hooks"];
+    logger?: LocalRuntimeBootstrapConfig["logger"];
+    telemetry?: LocalRuntimeBootstrapConfig["telemetry"];
+    extensionContext?: LocalRuntimeBootstrapConfig["extensionContext"];
+    extraTools?: LocalRuntimeBootstrapConfig["extraTools"];
+    extensions?: LocalRuntimeBootstrapConfig["extensions"];
+    onTeamEvent?: LocalRuntimeBootstrapConfig["onTeamEvent"];
+    onConsecutiveMistakeLimitReached?: LocalRuntimeBootstrapConfig["onConsecutiveMistakeLimitReached"];
+    checkpoint?: LocalRuntimeBootstrapConfig["checkpoint"];
+    compaction?: LocalRuntimeBootstrapConfig["compaction"];
     modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
-    userInstructionWatcher?: import("../extensions/config").UserInstructionConfigWatcher;
+    userInstructionService?: import("../../extensions/config").UserInstructionConfigService;
     configExtensions?: RuntimeConfigExtensionKind[];
     onTeamRestored?: () => void;
-    defaultToolExecutors?: Partial<ToolExecutors>;
 }
 export interface StartSessionInput {
     config: RuntimeSessionConfig;
@@ -40,8 +49,8 @@ export interface StartSessionInput {
      * same execution contract while still allowing host-specific preparation.
      */
     localRuntime?: LocalRuntimeStartOptions;
+    capabilities?: RuntimeCapabilities;
     toolPolicies?: import("@clinebot/shared").AgentConfig["toolPolicies"];
-    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
 }
 export declare function splitCoreSessionConfig(config: CoreSessionConfig): {
     config: RuntimeSessionConfig;
@@ -60,6 +69,7 @@ export interface SendSessionInput {
     userImages?: string[];
     userFiles?: string[];
     delivery?: "queue" | "steer";
+    timeoutMs?: number;
 }
 export interface SessionAccumulatedUsage {
     inputTokens: number;
@@ -75,7 +85,6 @@ export interface PendingPromptMutationResult {
     updated?: boolean;
     removed?: boolean;
 }
-export type PendingPromptsAction = "list" | "update" | "delete";
 export interface PendingPromptsListInput {
     sessionId: string;
 }
@@ -89,40 +98,66 @@ export interface PendingPromptsDeleteInput {
     sessionId: string;
     promptId: string;
 }
+export interface PendingPromptsServiceApi {
+    list(input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>;
+    update(input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>;
+    delete(input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>;
+}
+export interface PendingPromptsRuntimeService {
+    readonly pendingPrompts: PendingPromptsServiceApi;
+}
+export interface SessionUsageRuntimeService {
+    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
+}
+export interface SessionModelRuntimeService {
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+}
 export interface RuntimeHostSubscribeOptions {
     sessionId?: string;
 }
+export interface RestoreSessionInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: {
+        messages?: boolean;
+        workspace?: boolean;
+        omitCheckpointMessageFromSession?: boolean;
+    };
+    start?: StartSessionInput;
+}
+export interface RestoreSessionResult {
+    sessionId?: string;
+    startResult?: StartSessionResult;
+    messages?: LlmsProviders.Message[];
+    checkpoint: CheckpointEntry;
+}
 /**
  * RuntimeHost is the transport/runtime boundary for core session execution.
  * Callers must normalize broad local config into `RuntimeSessionConfig`
- * plus optional `localRuntime` overrides before invoking a host.
+ * plus optional named `localRuntime` bootstrap fields before invoking a host.
  */
 export interface RuntimeHost {
     readonly runtimeAddress?: string;
-    start(input: StartSessionInput): Promise<StartSessionResult>;
-    send(input: SendSessionInput): Promise<AgentResult | undefined>;
-    pendingPrompts(action: "list", input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>;
-    pendingPrompts(action: "update", input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>;
-    pendingPrompts(action: "delete", input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>;
-    getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
     abort(sessionId: string, reason?: unknown): Promise<void>;
-    stop(sessionId: string): Promise<void>;
+    stopSession(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;
-    get(sessionId: string): Promise<SessionRecord | undefined>;
-    list(limit?: number): Promise<SessionRecord[]>;
-    delete(sessionId: string): Promise<boolean>;
-    update(sessionId: string, updates: {
+    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;
     }>;
-    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
-    handleHookEvent(payload: HookEventPayload): Promise<void>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
     subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
-    updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
 }
 export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";
 export {};
-//# sourceMappingURL=runtime-host.d.ts.map

package/dist/runtime/{runtime-builder.d.ts → orchestration/runtime-builder.d.ts}

@@ -4,4 +4,3 @@ export declare class DefaultRuntimeBuilder implements RuntimeBuilder {
     private readonly teamRuntimeEntries;
     build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment>;
 }
-//# sourceMappingURL=runtime-builder.d.ts.map

package/dist/runtime/{runtime-event-adapter.d.ts → orchestration/runtime-event-adapter.d.ts}

@@ -99,4 +99,3 @@ export declare class RuntimeEventAdapter {
  */
 export declare function toLegacyAgentEvent(event: AgentRuntimeEvent): AgentEvent | undefined;
 export { textFromMessage };
-//# sourceMappingURL=runtime-event-adapter.d.ts.map

package/dist/runtime/{runtime-oauth-token-manager.d.ts → orchestration/runtime-oauth-token-manager.d.ts}

@@ -1,5 +1,5 @@
 import { type ITelemetryService, type OAuthProviderId } from "@clinebot/shared";
-import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
 type ManagedOAuthProviderId = OAuthProviderId;
 export declare class OAuthReauthRequiredError extends Error {
     readonly providerId: ManagedOAuthProviderId;
@@ -28,4 +28,3 @@ export declare class RuntimeOAuthTokenManager {
     private resolveCredentials;
 }
 export {};
-//# sourceMappingURL=runtime-oauth-token-manager.d.ts.map