@opencode-ai/core 0.0.0-next-17293

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

@@ -0,0 +1,3 @@
+import { SessionSchema } from "./schema.js";
+import { 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,32 @@
+export * as InstructionEntry from "./instruction-entry.js";
+import { Context, Effect, Schema } from "effect";
+import { InstructionEntry } from "@opencode-ai/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 MaxValueBytes: number;
+export declare const ValueTooLargeError: typeof InstructionEntry.ValueTooLargeError;
+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-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/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-ai/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-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/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, never, never>;
+    readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>;
+    readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"], never, never>;
+    readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>;
+    readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined, never, never>;
+    readonly getShell: (shellID: SessionMessage.Shell["shellID"]) => Effect.Effect<SessionMessage.Shell | undefined, never, never>;
+    readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined, never, never>;
+    readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void, never, never>;
+    readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void, never, never>;
+    readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void, never, never>;
+    readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void, never, never>;
+}
+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 "./message.js";
+export * from "@opencode-ai/schema/session-message";

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

@@ -0,0 +1,12 @@
+export * as SessionModelHeaders from "./model-headers.js";
+import { App } from "../app.js";
+import { SessionSchema } from "./schema.js";
+export declare const make: (session: Pick<SessionSchema.Info, "id" | "parentID" | "projectID">, app: App.Info) => {
+    "User-Agent": string;
+    "x-opencode-project": string & import("effect/Brand").Brand<"Project.ID">;
+    "x-opencode-session": string & import("effect/Brand").Brand<"SessionID">;
+    "x-opencode-client": string;
+    "x-parent-session-id"?: (string & import("effect/Brand").Brand<"SessionID">) | undefined;
+    "x-session-affinity": string & import("effect/Brand").Brand<"SessionID">;
+    "X-Session-Id": string & import("effect/Brand").Brand<"SessionID">;
+};

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

@@ -0,0 +1,11 @@
+export * as SessionModelHttp from "./model-http.js";
+import type { StreamOptions } from "@opencode-ai/ai/route";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import type { Session } from "@opencode-ai/schema/session";
+import { PluginHooks } from "../plugin/hooks.js";
+export declare const middleware: (hooks: PluginHooks.Interface, input: {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+}) => NonNullable<StreamOptions["http"]>;

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

@@ -0,0 +1,44 @@
+export * as SessionModelRequest from "./model-request.js";
+import { Message, type LLMRequest } from "@opencode-ai/ai";
+import type { StreamOptions } from "@opencode-ai/ai/route";
+import { Context, Effect, Layer } from "effect";
+import { Model } from "../model.js";
+import { Permission } from "../permission.js";
+import { PluginHooks } from "../plugin/hooks.js";
+import { QuestionTool } from "../tool/plugin/question.js";
+import { Tool } from "../tool.js";
+import { SessionContext } from "./context.js";
+/** Failures a prepared execution can surface: infrastructure errors plus user declines resurfaced from the defect tunnel. */
+export type ExecuteError = Tool.Error | Permission.DeclinedError | QuestionTool.CancelledError;
+interface Prepared {
+    readonly request: LLMRequest;
+    readonly options: StreamOptions;
+    /**
+     * One request-scoped execution operation. Unknown, hook-removed, and
+     * step-limit-violating calls fail individually through the same seam.
+     */
+    readonly executeTool: (input: Parameters<Tool.Snapshot["execute"]>[0]) => Effect.Effect<Tool.Result, ExecuteError>;
+    /** True when this request is the final Step; violating calls are rejected and no continuation follows. */
+    readonly stepLimitReached: boolean;
+}
+interface PrepareInput {
+    readonly context: SessionContext.Loaded;
+    readonly step: number;
+}
+export declare const unsupportedParts: (messages: LLMRequest["messages"], capabilities: Model.Capabilities) => Message[];
+export declare const boundImages: (messages: LLMRequest["messages"]) => readonly Message[];
+/**
+ * Builds an outbound model request and captures the tool-call capability that
+ * must remain paired with it. It does not execute the request or mutate
+ * Session state.
+ */
+export interface Interface {
+    /** Builds one outbound model request and its matching tool-call capability. */
+    readonly prepare: (input: PrepareInput) => Effect.Effect<Prepared>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionModelRequest", Interface>;
+/** Location-scoped outbound model-request preparation. */
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, PluginHooks.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,380 @@
+export * as SessionPending from "./pending.js";
+import { DateTime, Effect, Schema } from "effect";
+import { Compaction, Delivery, Info, Message, Synthetic, SyntheticData, User, UserData } from "@opencode-ai/schema/session-pending";
+import { Bus } from "../bus.js";
+import { SessionMessage } from "./message.js";
+import { SessionSchema } from "./schema.js";
+export { Compaction, Delivery, Info, Message, Synthetic, SyntheticData, User, UserData };
+/**
+ * Which pending input `promote` may consume: "steer" promotes steers only (a step
+ * boundary mid-work), while "input" also allows one queued input when no steers are
+ * waiting (the idle boundary, where the Session picks up fresh work).
+ */
+export type Promotable = "input" | "steer";
+type PendingRef = {
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+};
+declare const LifecycleConflict_base: Schema.Class<LifecycleConflict, Schema.TaggedStruct<"SessionPending.LifecycleConflict", {
+    readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class LifecycleConflict extends LifecycleConflict_base {
+}
+export declare const find: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, id: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<{
+    readonly type: "user";
+    readonly data: {
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly files?: readonly {
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly data: 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;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "synthetic";
+    readonly data: {
+        readonly text: string;
+        readonly description?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | undefined, never, never>;
+export declare const compaction: (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 type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | undefined, never, never>;
+export declare const admit: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, bus: Bus.Interface, request: {
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+    readonly input: Message;
+}) => Effect.Effect<{
+    readonly type: "user";
+    readonly data: {
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly files?: readonly {
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly data: 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;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "synthetic";
+    readonly data: {
+        readonly text: string;
+        readonly description?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+}, never, never>;
+export declare const admitCompaction: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, bus: Bus.Interface, input: {
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+}) => Effect.Effect<{
+    readonly type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+}, never, never>;
+export declare const projectAdmitted: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, request: {
+    readonly admittedSeq: number;
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+    readonly input: Message;
+    readonly timeCreated: DateTime.Utc;
+}) => Effect.Effect<undefined, never, never>;
+export declare const projectCompactionAdmitted: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: {
+    readonly admittedSeq: number;
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+    readonly timeCreated: DateTime.Utc;
+}) => Effect.Effect<{
+    readonly type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+}, never, never>;
+/**
+ * Consume one pending row at promotion. The row's content feeds the projected
+ * message insert inside the same event transaction; the deleted row is what
+ * makes the table pending-only.
+ */
+export declare const projectPromoted: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: PendingRef) => Effect.Effect<{
+    readonly type: "user";
+    readonly data: {
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly files?: readonly {
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly data: 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;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "synthetic";
+    readonly data: {
+        readonly text: string;
+        readonly description?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+}, never, never>;
+export declare const projectCancelled: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: PendingRef) => Effect.Effect<undefined, never, never>;
+export declare const projectSteered: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: PendingRef) => Effect.Effect<undefined, never, never>;
+export declare const projectQueued: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: PendingRef) => Effect.Effect<undefined, never, never>;
+export declare const settleCompaction: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, input: {
+    readonly sessionID: SessionSchema.ID;
+}) => Effect.Effect<{
+    readonly type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | undefined, never, never>;
+export declare const list: (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 type: "user";
+    readonly data: {
+        readonly text: string;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly files?: readonly {
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly data: 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;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        }[] | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "synthetic";
+    readonly data: {
+        readonly text: string;
+        readonly description?: string | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    readonly delivery: "steer" | "queue";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+} | {
+    readonly type: "compaction";
+    readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+    readonly timeCreated: DateTime.Utc;
+})[], never, never>;
+/**
+ * Which pending rows count: "any" counts every row including compaction, while
+ * delivery scopes are blocked behind a pending compaction barrier. "input" means
+ * any model-facing input, steered or queued.
+ */
+export type Scope = "any" | "input" | Delivery;
+export declare const has: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, scope: Scope) => Effect.Effect<boolean, never, never>;
+export declare const equivalent: (input: User | Synthetic, expected: {
+    readonly sessionID: SessionSchema.ID;
+    readonly input: Message;
+}) => boolean;
+export declare const cancel: (bus: Bus.Interface, input: PendingRef) => Effect.Effect<void, never, never>;
+export declare const steer: (bus: Bus.Interface, input: PendingRef) => Effect.Effect<void, never, never>;
+export declare const queue: (bus: Bus.Interface, input: PendingRef) => Effect.Effect<void, never, never>;
+/**
+ * Promotes pending input into visible messages and returns the promoted count.
+ * Steers always go first; only the "input" scope may fall through to one queued
+ * input, and it then collects steers that arrived during promotion.
+ */
+export declare const promote: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, bus: Bus.Interface, sessionID: string & import("effect/Brand").Brand<"SessionID">, scope: Promotable) => Effect.Effect<number, never, never>;

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-ai/util/effect/layer-node").Node<never, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/session/prompt-cache-diagnostics.d.ts

@@ -0,0 +1,29 @@
+export * as PromptCacheDiagnostics from "./prompt-cache-diagnostics.js";
+import type { LLMRequest } from "@opencode-ai/ai";
+interface Entry {
+    readonly label: string;
+    readonly hash: string;
+}
+export interface Snapshot {
+    readonly settings: string;
+    readonly tools: ReadonlyArray<Entry>;
+    readonly system: ReadonlyArray<Entry>;
+    readonly messages: ReadonlyArray<Entry>;
+}
+export type Comparison = {
+    readonly status: "initial";
+} | {
+    readonly status: "stable";
+    readonly messages: number;
+} | {
+    readonly status: "append-only";
+    readonly previousMessages: number;
+    readonly currentMessages: number;
+} | {
+    readonly status: "changed";
+    readonly component: "settings" | "tools" | "system" | "messages";
+    readonly index: number;
+    readonly label: string;
+};
+export declare function snapshot(request: LLMRequest): Snapshot;
+export declare function compare(previous: Snapshot | undefined, current: Snapshot): Comparison;

package/dist/types/session/prompt-cache-key.d.ts

@@ -0,0 +1,3 @@
+export * as SessionPromptCacheKey from "./prompt-cache-key.js";
+import { SessionSchema } from "./schema.js";
+export declare const make: (sessionID: SessionSchema.ID) => string;