@opencode/core 0.0.0-reserved → 2.0.1

package/dist/types/session/info.d.ts

@@ -0,0 +1,3 @@
+import { SessionSchema } from "./schema.js";
+import type { SessionTable } from "./sql.js";
+export declare function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info;

package/dist/types/session/instruction-entry.d.ts

@@ -0,0 +1,52 @@
+export * as InstructionEntry from "./instruction-entry.js";
+import { Context, Effect, Schema } from "effect";
+import { InstructionEntry } from "@opencode/schema/instruction-entry";
+import { Instructions } from "../instructions/index.js";
+import { SessionSchema } from "./schema.js";
+export declare const Key: Schema.String;
+export type Key = typeof Key.Type;
+export declare const Info: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Snapshot: Schema.$Array<Schema.Struct<{
+    readonly removed: Schema.Boolean;
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>>;
+export type Snapshot = typeof Snapshot.Type;
+export declare const MaxValueBytes: number;
+export declare const ValueTooLargeError: typeof InstructionEntry.ValueTooLargeError;
+export declare const snapshot: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<{
+    key: string;
+    value: Schema.Json;
+    removed: boolean;
+}[], never, never>;
+export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, entries: readonly {
+    readonly removed: boolean;
+    readonly key: string;
+    readonly value: Schema.Json;
+}[], created: number) => Effect.Effect<void, never, never>;
+export interface Interface {
+    readonly list: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Info>>;
+    readonly put: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly key: Key;
+        readonly value: Schema.Json;
+    }) => Effect.Effect<void, InstructionEntry.ValueTooLargeError>;
+    readonly remove: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly key: Key;
+    }) => Effect.Effect<void>;
+    /** Produces one Instructions source per stored entry, keyed `api/<key>`. */
+    readonly load: (sessionID: SessionSchema.ID) => Effect.Effect<Instructions.List>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/InstructionEntry", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/instruction-state.d.ts

@@ -0,0 +1,48 @@
+export * as InstructionState from "./instruction-state.js";
+import { Effect } from "effect";
+import type { Bus } from "../bus.js";
+import { Instructions } from "../instructions/index.js";
+import { SessionSchema } from "./schema.js";
+export interface Observation extends Instructions.Admission {
+    readonly sessionID: SessionSchema.ID;
+    readonly initial: boolean;
+    readonly previous: Instructions.Values;
+    readonly current: Instructions.Values;
+}
+export declare const observe: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, instructions: Instructions.List, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<Observation, Instructions.InitializationBlocked, never>;
+export declare const commit: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, bus: Bus.Interface, instructions: Instructions.List, observation: Observation) => Effect.Effect<void, never, never>;
+export declare const prepare: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, bus: Bus.Interface, instructions: Instructions.List, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<void, Instructions.InitializationBlocked, never>;
+export declare const apply: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, seq: number, delta: {
+    readonly [x: string]: (string & import("effect/Brand").Brand<"Instruction.Hash">) | "removed";
+}) => Effect.Effect<void, never, never>;
+export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, seq: number, values: Readonly<Record<string, string & import("effect/Brand").Brand<"Instruction.Hash">>>) => Effect.Effect<void, never, never>;
+export declare const advanceEpoch: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, epochStart: number) => Effect.Effect<void, never, never>;
+export declare const reset: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<void, never, never>;
+/** Renders the epoch baseline shown at the start of every model request. */
+export declare const initial: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List) => Effect.Effect<string, never, never>;
+/** The current instruction values, used to seed a fork's baseline. */
+export declare const current: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<Readonly<Record<string, string & import("effect/Brand").Brand<"Instruction.Hash">>> | undefined, never, never>;
+export declare const preview: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List, observed: Instructions.ReadResult) => Effect.Effect<{
+    initial: string;
+    update: string;
+}, Instructions.InitializationBlocked, never>;

package/dist/types/session/instructions.d.ts

@@ -0,0 +1,15 @@
+export * as SessionInstructions from "./instructions.js";
+import { Context, Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { MessageDecodeError } from "./error.js";
+import { SessionSchema } from "./schema.js";
+export interface Interface {
+    readonly load: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly paths: ReadonlyArray<string>;
+    }) => Effect.Effect<void, MessageDecodeError | FSUtil.Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionInstructions", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/message-updater.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { SessionEvent } from "./event.js";
+import { SessionMessage } from "./message.js";
+export interface Adapter {
+    readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined>;
+    readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined>;
+    readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"]>;
+    readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>;
+    readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>;
+    readonly getShell: (shellID: SessionMessage.Shell["shellID"]) => Effect.Effect<SessionMessage.Shell | undefined>;
+    readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined>;
+    readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>;
+    readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>;
+    readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void>;
+    readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void>;
+}
+export declare function update(adapter: Adapter, event: SessionEvent.DurableEvent): Effect.Effect<void, never, never>;
+export * as SessionMessageUpdater from "./message-updater.js";

package/dist/types/session/message.d.ts

@@ -0,0 +1,2 @@
+export * as SessionMessage from "@opencode/schema/session-message";
+export * from "@opencode/schema/session-message";

package/dist/types/session/model-request.d.ts

@@ -0,0 +1,68 @@
+export * as SessionModelRequest from "./model-request.js";
+import { LLM, LLMRequest, Message, SystemPart } from "@opencode/ai";
+import type { StreamOptions } from "@opencode/ai/route";
+import type { SessionCompaction, SessionContext, SessionGenerate, SessionRequest, SessionTitle } from "@opencode/plugin/effect/session";
+import type { Agent } from "@opencode/schema/agent";
+import type { Model } from "@opencode/schema/model";
+import { Context, Effect, Layer } from "effect";
+import { Permission } from "../permission.js";
+import { PluginHooks } from "../plugin/hooks.js";
+import { QuestionTool } from "../tool/plugin/question.js";
+import { Tool } from "../tool.js";
+import { SessionModelTransport } from "./model-transport.js";
+import { SessionRunnerModel } from "./runner/model.js";
+import { SessionSchema } from "./schema.js";
+import type { SessionMessage } from "./message.js";
+/** Tool errors, plus the user declining a permission or dismissing a question. */
+export type ExecuteError = Tool.Error | Permission.DeclinedError | QuestionTool.CancelledError;
+export interface Prepared<Event = SessionRequest> {
+    readonly event: Event;
+    readonly request: LLMRequest;
+    readonly options: StreamOptions;
+    readonly retry: (event: PluginHooks.Domains["session"]["retry"]) => Effect.Effect<void>;
+    /** Runs a tool call against the tools this request advertised. */
+    readonly executeTool: (input: Parameters<Tool.Snapshot["execute"]>[0]) => Effect.Effect<Tool.NormalizedResult, ExecuteError>;
+}
+export interface Input {
+    readonly session: SessionSchema.Info;
+    readonly agent: Agent.ID;
+    readonly model: SessionRunnerModel.Resolved;
+    readonly tools?: Tool.Snapshot;
+    readonly system: Array<SystemPart>;
+    readonly messages: Array<Message>;
+    readonly toolChoice?: LLM.RequestInput["toolChoice"];
+    /** Only the durable runner may use a stateful WebSocket. */
+    readonly webSocket?: "session";
+}
+export declare const baseTranscript: (input: {
+    readonly agent: Agent.Info;
+    readonly model: SessionRunnerModel.Resolved;
+    readonly tools: Tool.Snapshot;
+    readonly initial: string;
+    readonly messages: ReadonlyArray<SessionMessage.Info>;
+}) => {
+    providerMetadataKey: string;
+    system: {
+        readonly type: "text";
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly cache?: import("@opencode/ai").CacheHint | undefined;
+    }[];
+    messages: Message[];
+};
+export declare const unsupportedParts: (messages: LLMRequest["messages"], capabilities: Model.Capabilities) => Message[];
+export declare const boundImages: (messages: LLMRequest["messages"]) => readonly Message[];
+/** Builds the model request for each session flow. Each entry runs its own plugin hook. */
+export interface Interface {
+    readonly primary: (input: Input) => Effect.Effect<Prepared<SessionContext>>;
+    readonly compaction: (input: Input) => Effect.Effect<Prepared<SessionCompaction>>;
+    readonly generate: (input: Input) => Effect.Effect<Prepared<SessionGenerate>>;
+    readonly title: (input: Input) => Effect.Effect<Prepared<SessionTitle>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionModelRequest", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, PluginHooks.Service | SessionModelTransport.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/model-transport.d.ts

@@ -0,0 +1,16 @@
+export * as SessionModelTransport from "./model-transport.js";
+import { type WebSocketChannelExecutor, type WebSocketConnector } from "@opencode/ai/route";
+import { Context, Effect, Layer } from "effect";
+import { Socket } from "effect/unstable/socket";
+import { SessionSchema } from "./schema.js";
+export interface Interface {
+    readonly bind: (sessionID: SessionSchema.ID) => WebSocketChannelExecutor;
+    readonly close: (sessionID: SessionSchema.ID) => Effect.Effect<void>;
+    readonly closeAll: Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionModelTransport", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const makeLayer: (connector: WebSocketConnector) => Layer.Layer<Service, never, never>;
+export declare const layer: Layer.Layer<Service, never, Socket.WebSocketConstructor>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/session/move.d.ts

@@ -0,0 +1,34 @@
+export * as SessionMove from "./move.js";
+import type { Session } from "@opencode/schema/session";
+import { Cause, Context, Effect, Schema } from "effect";
+import { Location } from "../location.js";
+import { AbsolutePath } from "../schema.js";
+import { NotFoundError } from "./error.js";
+import { SessionInbox } from "./inbox.js";
+declare const DestinationNotFoundError_base: Schema.Class<DestinationNotFoundError, Schema.TaggedStruct<"Session.DestinationNotFoundError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, Cause.YieldableError>;
+export declare class DestinationNotFoundError extends DestinationNotFoundError_base {
+}
+declare const DestinationNotDirectoryError_base: Schema.Class<DestinationNotDirectoryError, Schema.TaggedStruct<"Session.DestinationNotDirectoryError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, Cause.YieldableError>;
+export declare class DestinationNotDirectoryError extends DestinationNotDirectoryError_base {
+}
+declare const DestinationUnavailableError_base: Schema.Class<DestinationUnavailableError, Schema.TaggedStruct<"Session.DestinationUnavailableError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, Cause.YieldableError>;
+export declare class DestinationUnavailableError extends DestinationUnavailableError_base {
+}
+export interface Interface {
+    readonly move: (input: {
+        sessionID: Session.ID;
+        directory: AbsolutePath;
+        workspaceID?: Location.Ref["workspaceID"];
+        delivery?: SessionInbox.Delivery;
+    }) => Effect.Effect<void, NotFoundError | DestinationNotFoundError | DestinationNotDirectoryError | DestinationUnavailableError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionMove", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/session/projector.d.ts

@@ -0,0 +1,4 @@
+export * as SessionProjector from "./projector.js";
+export declare class SessionAlreadyProjected extends Error {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<never, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/session/prompt.d.ts

@@ -0,0 +1,66 @@
+export * as SessionPrompt from "./prompt.js";
+import { PromptInput } from "@opencode/schema/prompt-input";
+import { SessionInbox } from "@opencode/schema/session-inbox";
+import type { Session } from "@opencode/schema/session";
+import type { SessionMessage } from "@opencode/schema/session-message";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Effect } from "effect";
+import { Instance } from "../instance/service.js";
+import { AttachmentError, SkillNotFoundError } from "./error.js";
+export type Input = {
+    text: string;
+    files?: PromptInput.Prompt["files"];
+    agents?: PromptInput.Prompt["agents"];
+    skills?: PromptInput.Prompt["skills"];
+    metadata?: Record<string, unknown>;
+    delivery?: SessionInbox.Delivery;
+};
+export declare const prepare: (request: {
+    session: Session.Info;
+    messageID: SessionMessage.ID;
+    input: Input;
+}) => Effect.Effect<{
+    type: "user";
+    payload: {
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly files?: readonly {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly name?: string | undefined;
+            readonly description?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly agents?: readonly {
+            readonly name: string;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+        readonly skills?: readonly {
+            readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+            readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+            readonly text?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+    delivery: "steer" | "queue";
+}, AttachmentError | SkillNotFoundError, FSUtil.Service | Instance.Service>;

package/dist/types/session/provider-context.d.ts

@@ -0,0 +1,46 @@
+export * as SessionProviderContext from "./provider-context.js";
+import { Message } from "@opencode/ai";
+import { SessionProviderContext } from "@opencode/schema/session-provider-context";
+import { Schema } from "effect";
+import type { SessionMessage } from "./message.js";
+import type { SessionRunnerModel } from "./runner/model.js";
+export type Provenance = SessionProviderContext.Provenance;
+export declare const Info: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly provenance: Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly provider: Schema.String;
+        readonly modelID: Schema.String;
+        readonly route: Schema.String;
+        readonly protocol: Schema.String;
+        readonly endpoint: Schema.String;
+    }>;
+    readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type Info = SessionProviderContext.Info;
+/** No guessed endpoints. Dynamic URL builders cannot establish a durable deployment identity here. */
+export declare function provenance(resolved: Pick<SessionRunnerModel.Resolved, "model" | "ref">): Provenance | undefined;
+export declare const compatible: (source: Provenance, target: Provenance | undefined) => boolean;
+/** A completed compaction that installed a native replacement window instead of a local summary. */
+export declare const isCheckpoint: (message: SessionMessage.Info) => message is SessionMessage.CompactionCompleted & {
+    readonly providerContext: Info;
+};
+/** Stores the canonical replacement, not a local summary or transport continuation.
+ * Provider and attachment metadata can contain optional undefined entries. Use JSON's
+ * omission semantics, while preserving canonical binary media as equivalent base64.
+ */
+export declare const encode: (provenance: Provenance, replacement: ReadonlyArray<Message>) => Info;
+export declare const decode: (context: Info) => readonly Message[];
+export declare const validate: (context: Info) => import("effect/Effect").Effect<readonly Message[], Schema.SchemaError, never>;

package/dist/types/session/revert.d.ts

@@ -0,0 +1,27 @@
+export * as SessionRevert from "./revert.js";
+import { Effect } from "effect";
+import { Database } from "../database/database.js";
+import { Bus } from "../bus.js";
+import { Instance } from "../instance/service.js";
+import { Snapshot } from "../snapshot.js";
+import { MessageNotFoundError } from "./error.js";
+import { SessionMessage } from "./message.js";
+import { SessionSchema } from "./schema.js";
+export { MessageNotFoundError };
+export declare const stage: (input: {
+    session: SessionSchema.Info;
+    messageID: SessionMessage.ID;
+    files?: boolean;
+}) => Effect.Effect<{
+    messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
+    files: readonly {
+        readonly file: string;
+        readonly patch: string;
+        readonly additions: number;
+        readonly deletions: number;
+        readonly status: "added" | "deleted" | "modified";
+    }[];
+}, MessageNotFoundError | Snapshot.Error, Database.Service | Bus.Service | Instance.Service>;
+export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error, Bus.Service | Instance.Service>;
+export declare const commit: (bus: Bus.Interface, session: SessionSchema.Info) => Effect.Effect<void, never, never>;

package/dist/types/session/run-coordinator.d.ts

@@ -0,0 +1,47 @@
+export * as SessionRunCoordinator from "./run-coordinator.js";
+import { Effect, Exit, Scope } from "effect";
+import type { Promotable } from "./inbox.js";
+/** Serializes execution for each key while allowing different keys to run concurrently. */
+export interface Coordinator<Key, E, Reason = never> {
+    /** Snapshots keys with an execution owned by this coordinator. */
+    readonly active: Effect.Effect<ReadonlySet<Key>>;
+    /** Checks ownership for one key, including cleanup and terminal settlement. */
+    readonly isActive: (key: Key) => Effect.Effect<boolean>;
+    /** Starts an execution while idle, or joins the active execution and returns its exit. */
+    readonly run: (key: Key) => Effect.Effect<void, E>;
+    /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
+    readonly wake: (key: Key, scope?: Promotable) => Effect.Effect<void>;
+    /**
+     * Stops the active execution and clears its doorbell. No-op when idle. Resolves once the
+     * interruption is accepted, not when cleanup settles: the execution fiber finishes its
+     * finalizers and settled hook on its own time. Returns whether an active execution was
+     * interrupted. `awaitSettlement` waits for this execution's cleanup and settled hook,
+     * without following fresh work admitted during cleanup. `awaitIdle` follows successors too.
+     */
+    readonly interrupt: (key: Key, reason?: Reason, options?: {
+        readonly awaitSettlement?: boolean;
+    }) => Effect.Effect<boolean>;
+    /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
+    readonly awaitIdle: (key: Key) => Effect.Effect<void>;
+}
+/**
+ * ```text
+ *              wake | run
+ *      idle ──────────────▶ execution (one fiber)
+ *                             drain ⟲ doorbell rung mid-drain
+ *                             │ exit (settled hook runs)
+ *      doorbell quiet ◀───────┴───────▶ doorbell rung
+ *      idle, waiters get exit          successor execution,
+ *                                      waiters get this exit
+ * ```
+ */
+export declare const make: <Key, E, Reason = never>(options: {
+    readonly drain: (key: Key, force: boolean, scope: Promotable) => Effect.Effect<void, E>;
+    /** Runs once when a process-local busy period begins, before its first drain. */
+    readonly started?: (key: Key) => Effect.Effect<void>;
+    /**
+     * Runs in the execution fiber for every exit, including interruption, after the final
+     * drain and before the execution settles (waiters resolve after it completes).
+     */
+    readonly settled?: (key: Key, exit: Exit.Exit<void, E>, reason?: Reason) => Effect.Effect<void>;
+}) => Effect.Effect<Coordinator<Key, E, Reason>, never, Scope.Scope>;

package/dist/types/session/runner/index.d.ts

@@ -0,0 +1,81 @@
+export * as SessionRunner from "./index.js";
+import type { AIError } from "@opencode/ai";
+import { Context, Data, Effect } from "effect";
+import { SessionSchema } from "../schema.js";
+import type { Promotable } from "../inbox.js";
+import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js";
+import { SessionRunnerModel } from "./model.js";
+import type { Instructions } from "../../instructions/index.js";
+export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | UserInterruptedError | Instructions.InitializationBlocked;
+export type Continuation = {
+    readonly step: number;
+};
+export type DrainResult = Data.TaggedEnum<{
+    Complete: {};
+    Moved: {
+        readonly continuation?: Continuation;
+    };
+}>;
+export declare const DrainResult: {
+    readonly Complete: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Complete";
+    }, "_tag">;
+    readonly Moved: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Moved";
+        readonly continuation?: Continuation | undefined;
+    }, "_tag">;
+    readonly $is: <Tag extends "Complete" | "Moved">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Complete";
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Moved";
+        readonly continuation?: Continuation | undefined;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends {
+            readonly Complete: (args: {
+                readonly _tag: "Complete";
+            }) => any;
+            readonly Moved: (args: {
+                readonly _tag: "Moved";
+                readonly continuation?: Continuation | undefined;
+            }) => any;
+        }>(cases: Cases): (value: {
+            readonly _tag: "Complete";
+        } | {
+            readonly _tag: "Moved";
+            readonly continuation?: Continuation | undefined;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Moved"]>>;
+        <Cases extends {
+            readonly Complete: (args: {
+                readonly _tag: "Complete";
+            }) => any;
+            readonly Moved: (args: {
+                readonly _tag: "Moved";
+                readonly continuation?: Continuation | undefined;
+            }) => any;
+        }>(value: {
+            readonly _tag: "Complete";
+        } | {
+            readonly _tag: "Moved";
+            readonly continuation?: Continuation | undefined;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Moved"]>>;
+    };
+};
+/** Runs one local continuation from already-recorded Session history. */
+export interface Interface {
+    /** Drains eligible durable work, returning transient state when execution must continue at a new Location. */
+    readonly drain: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly force: boolean;
+        readonly continuation?: Continuation;
+        /** "steer" settles the active intent without promoting queued next-turn work. */
+        readonly promotable?: Promotable;
+    }) => Effect.Effect<DrainResult, RunError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRunner", Interface>;
+export declare class Service extends Service_base {
+}

package/dist/types/session/runner/llm.d.ts

@@ -0,0 +1,3 @@
+export * as SessionRunnerLLM from "./llm.js";
+import { Service } from "./index.js";
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, import("../../persistent-pty/index.js").UnavailableError, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/runner/max-steps.d.ts

@@ -0,0 +1 @@
+export declare const MAX_STEPS_PROMPT = "CRITICAL - MAXIMUM STEPS REACHED\n\nThe maximum number of steps allowed for this task has been reached. Tools are disabled until next user input. Respond with text only.\n\nSTRICT REQUIREMENTS:\n1. Do NOT make any tool calls (no reads, writes, edits, searches, or any other tools)\n2. MUST provide a text response summarizing work done so far\n3. This constraint overrides ALL other instructions, including any user requests for edits or tool use\n\nResponse must include:\n- Statement that maximum steps for this agent have been reached\n- Summary of what has been accomplished so far\n- List of any remaining tasks that were not completed\n- Recommendations for what should be done next\n\nAny attempt to use tools is a critical violation. Respond with text ONLY.";

package/dist/types/session/runner/model.d.ts

@@ -0,0 +1,66 @@
+export * as SessionRunnerModel from "./model.js";
+import { LanguageModel } from "@opencode/ai";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { Context, Effect, Schema } from "effect";
+import { ModelResolver } from "../../model-resolver.js";
+import { SessionSchema } from "../schema.js";
+declare const ModelNotSelectedError_base: Schema.Class<ModelNotSelectedError, Schema.TaggedStruct<"SessionRunnerModel.ModelNotSelectedError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelNotSelectedError extends ModelNotSelectedError_base {
+    get message(): string;
+}
+declare const ModelUnavailableError_base: Schema.Class<ModelUnavailableError, Schema.TaggedStruct<"SessionRunnerModel.ModelUnavailableError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelUnavailableError extends ModelUnavailableError_base {
+    get message(): string;
+}
+export declare const VariantUnavailableError: typeof ModelResolver.VariantUnavailableError;
+export type VariantUnavailableError = ModelResolver.VariantUnavailableError;
+export declare const UnsupportedPackageError: typeof ModelResolver.UnsupportedPackageError;
+export type UnsupportedPackageError = ModelResolver.UnsupportedPackageError;
+export declare const ModelConfigurationError: typeof ModelResolver.ModelConfigurationError;
+export type ModelConfigurationError = ModelResolver.ModelConfigurationError;
+export declare const ModelInitializationError: typeof ModelResolver.ModelInitializationError;
+export type ModelInitializationError = ModelResolver.ModelInitializationError;
+export declare const UnresolvedProviderVariablesError: typeof ModelResolver.UnresolvedProviderVariablesError;
+export type UnresolvedProviderVariablesError = ModelResolver.UnresolvedProviderVariablesError;
+export declare const UnsupportedCompactionError: typeof ModelResolver.UnsupportedCompactionError;
+export type UnsupportedCompactionError = ModelResolver.UnsupportedCompactionError;
+export type Error = ModelNotSelectedError | ModelUnavailableError | ModelResolver.Error;
+export type Resolved = ModelResolver.Resolved;
+export interface Interface {
+    /** Availability is sampled lazily for each explicitly selected model resolution. */
+    readonly resolve: (session: SessionSchema.Info, available: () => Effect.Effect<ReadonlyArray<Model.Info>>) => Effect.Effect<Resolved, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRunnerModel", Interface>;
+export declare class Service extends Service_base {
+}
+/** Builds a Resolved whose catalog identity mirrors the route model. Test or embedding seam. */
+export declare const resolved: (model: LanguageModel, options: {
+    readonly capabilities: Model.Capabilities;
+    readonly variant?: Model.VariantID;
+    readonly cost: Model.Info["cost"];
+    readonly limit: Model.Info["limit"];
+    readonly compaction?: Provider.Compaction;
+    readonly websocket?: boolean;
+}) => Resolved;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;