@codeworksh/harness 0.0.1-dev.20260824182323 → 0.0.1-dev.20260825090614

package/effect.d.mts

@@ -1,8 +1,2083 @@
-import { A as schema_d_exports$1, B as Registration, C as HydratedEntry, D as Payload, E as Service$1, F as CreateConfig$1, G as SandboxDriverRegistrationError, H as SandboxCreateError, I as Controller, K as SandboxMountError, L as Info$2, M as ClientOptions, N as CreateConfig, O as Delivery, P as ClientOptions$1, Q as SandboxStopError, R as Status, S as Service$3, T as SessionNotFoundError, U as SandboxDestroyError, V as Registry, X as SandboxRegisterError, Y as SandboxRefreshError, _ as ToolExecutionMode, a as schema_d_exports, b as RegisteredTool, d as RunError, et as SandboxWakeError, h as Service$5, i as ID$1, j as AbsolutePath, k as ID, l as ModelNotFoundError, m as RequestOptions, n as PromptConflictError, o as Admitted, r as Service$7, s as Service$6, t as Interface$1, u as ProviderTurnError, v as PromptSystemOverride, w as Service$2, x as tool_d_exports, y as Service$4, z as instance_d_exports } from "./control-DyVTL25_.mjs";
-import { Config, Context, Effect, Layer, Option, Stream } from "effect";
-import { Event, Message, Model } from "@codeworksh/aikit";
+import { Cause, Config, Context, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
+import { Event, Message, Model, Protocol } from "@codeworksh/aikit";
 import { SqlClient, SqlClient as SqlClient$1 } from "effect/unstable/sql";
 import { SqliteClient } from "@effect/sql-sqlite-node";
+import { Model as Model$1 } from "effect/unstable/schema";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { SqliteProvider, create } from "@platformatic/vfs";
+import "just-bash";
+import "@codeworksh/aikit/failure";
+//#region src/session/prompt/schema.d.ts
+declare const Prompt: Schema.Struct<{
+  readonly text: Schema.String;
+}> & {
+  equivalence: import("effect/Equivalence").Equivalence<{
+    readonly text: string;
+  }>;
+  fromUserMessage: (input: Pick<Prompt, "text">) => {
+    readonly text: string;
+  };
+};
+type Prompt = typeof Prompt.Type;
+declare const Delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+type Delivery = typeof Delivery.Type;
+//#endregion
+//#region src/db/schema.sql.d.ts
+declare const entryTypes: readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"];
+type EntryType = (typeof entryTypes)[number];
+declare const entryStates: readonly ["draft", "committed", "aborted"];
+type EntryState = (typeof entryStates)[number];
+declare const partTypes: readonly ["text", "image", "thinking", "toolCall"];
+type PartType = (typeof partTypes)[number];
+declare const toolStatuses: readonly ["pending", "running", "completed", "error", "skipped", "aborted"];
+type ToolStatus = (typeof toolStatuses)[number];
+declare const SessionRow_base: import("effect/unstable/schema/VariantSchema").Class<SessionRow, {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.brand<Schema.String, "Session.ID">;
+  readonly projectId: Schema.String;
+  readonly parentId: Model$1.FieldOption<Schema.brand<Schema.String, "Session.ID">>;
+  readonly slug: Schema.String;
+  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly title: Schema.String;
+  readonly tag: Model$1.FieldOption<Schema.String>;
+  readonly metadata: import("effect/unstable/schema/VariantSchema").Field<{
+    readonly select: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly insert: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly update: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly json: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonCreate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonUpdate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+  readonly sandboxInstanceId: Model$1.FieldOption<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  }>;
+  readonly leafEntryId: Model$1.FieldOption<Schema.String>;
+  readonly cost: Model$1.GeneratedByDb<Schema.Finite>;
+  readonly tokensInput: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensOutput: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensCacheRead: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensCacheWrite: Model$1.GeneratedByDb<Schema.Int>;
+}, Schema.Struct<import("effect/unstable/schema/VariantSchema").ExtractFields<"select", {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.brand<Schema.String, "Session.ID">;
+  readonly projectId: Schema.String;
+  readonly parentId: Model$1.FieldOption<Schema.brand<Schema.String, "Session.ID">>;
+  readonly slug: Schema.String;
+  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly title: Schema.String;
+  readonly tag: Model$1.FieldOption<Schema.String>;
+  readonly metadata: import("effect/unstable/schema/VariantSchema").Field<{
+    readonly select: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly insert: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly update: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly json: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonCreate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonUpdate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+  readonly sandboxInstanceId: Model$1.FieldOption<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  }>;
+  readonly leafEntryId: Model$1.FieldOption<Schema.String>;
+  readonly cost: Model$1.GeneratedByDb<Schema.Finite>;
+  readonly tokensInput: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensOutput: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensCacheRead: Model$1.GeneratedByDb<Schema.Int>;
+  readonly tokensCacheWrite: Model$1.GeneratedByDb<Schema.Int>;
+}, true>>> & {
+  readonly insert: Schema.Struct<{
+    readonly createdAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly sandboxInstanceId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Schema.OptionFromNullOr<Schema.String>;
+  }>;
+  readonly json: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Model$1.optionalOption<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly sandboxInstanceId: Model$1.optionalOption<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Model$1.optionalOption<Schema.String>;
+    readonly cost: Schema.Finite;
+    readonly tokensInput: Schema.Int;
+    readonly tokensOutput: Schema.Int;
+    readonly tokensCacheRead: Schema.Int;
+    readonly tokensCacheWrite: Schema.Int;
+  }>;
+  readonly jsonCreate: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Model$1.optionalOption<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly sandboxInstanceId: Model$1.optionalOption<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Model$1.optionalOption<Schema.String>;
+  }>;
+  readonly jsonUpdate: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Model$1.optionalOption<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly sandboxInstanceId: Model$1.optionalOption<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Model$1.optionalOption<Schema.String>;
+  }>;
+  readonly select: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly sandboxInstanceId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Schema.OptionFromNullOr<Schema.String>;
+    readonly cost: Schema.Finite;
+    readonly tokensInput: Schema.Int;
+    readonly tokensOutput: Schema.Int;
+    readonly tokensCacheRead: Schema.Int;
+    readonly tokensCacheWrite: Schema.Int;
+  }>;
+  readonly update: Schema.Struct<{
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.brand<Schema.String, "Session.ID">;
+    readonly projectId: Schema.String;
+    readonly parentId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "Session.ID">>;
+    readonly slug: Schema.String;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly title: Schema.String;
+    readonly tag: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly sandboxInstanceId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+      local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+      create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    }>;
+    readonly leafEntryId: Schema.OptionFromNullOr<Schema.String>;
+  }>;
+};
+declare class SessionRow extends SessionRow_base {}
+declare const SessionEntryRow_base: import("effect/unstable/schema/VariantSchema").Class<SessionEntryRow, {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.String;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+  readonly parentId: Model$1.FieldOption<Schema.String>;
+  readonly seq: Schema.Int;
+  readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+  readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+  readonly data: Schema.String;
+  readonly label: Model$1.FieldOption<Schema.String>;
+  readonly metadata: import("effect/unstable/schema/VariantSchema").Field<{
+    readonly select: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly insert: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly update: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly json: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonCreate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonUpdate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}, Schema.Struct<import("effect/unstable/schema/VariantSchema").ExtractFields<"select", {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.String;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+  readonly parentId: Model$1.FieldOption<Schema.String>;
+  readonly seq: Schema.Int;
+  readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+  readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+  readonly data: Schema.String;
+  readonly label: Model$1.FieldOption<Schema.String>;
+  readonly metadata: import("effect/unstable/schema/VariantSchema").Field<{
+    readonly select: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly insert: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly update: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+    readonly json: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonCreate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+    readonly jsonUpdate: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}, true>>> & {
+  readonly insert: Schema.Struct<{
+    readonly createdAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Schema.OptionFromNullOr<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+  }>;
+  readonly json: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Model$1.optionalOption<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+  readonly jsonCreate: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Model$1.optionalOption<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+  readonly jsonUpdate: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Model$1.optionalOption<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Model$1.optionalOption<Schema.String>;
+    readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+  readonly select: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Schema.OptionFromNullOr<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+  }>;
+  readonly update: Schema.Struct<{
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly parentId: Schema.OptionFromNullOr<Schema.String>;
+    readonly seq: Schema.Int;
+    readonly type: Schema.Literals<readonly ["user", "assistant", "synthetic", "compaction", "branchSummary", "custom", "configChange"]>;
+    readonly state: Schema.Literals<readonly ["draft", "committed", "aborted"]>;
+    readonly data: Schema.String;
+    readonly label: Schema.OptionFromNullOr<Schema.String>;
+    readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
+  }>;
+};
+declare class SessionEntryRow extends SessionEntryRow_base {}
+declare const SessionEntryPartRow_base: import("effect/unstable/schema/VariantSchema").Class<SessionEntryPartRow, {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.String;
+  readonly entryId: Schema.String;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+  readonly partIndex: Schema.Int;
+  readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+  readonly status: Model$1.FieldOption<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+  readonly callId: Model$1.FieldOption<Schema.String>;
+  readonly toolName: Model$1.FieldOption<Schema.String>;
+  readonly data: Schema.String;
+}, Schema.Struct<import("effect/unstable/schema/VariantSchema").ExtractFields<"select", {
+  readonly createdAt: Model$1.DateTimeInsertFromNumber;
+  readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
+  readonly id: Schema.String;
+  readonly entryId: Schema.String;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+  readonly partIndex: Schema.Int;
+  readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+  readonly status: Model$1.FieldOption<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+  readonly callId: Model$1.FieldOption<Schema.String>;
+  readonly toolName: Model$1.FieldOption<Schema.String>;
+  readonly data: Schema.String;
+}, true>>> & {
+  readonly insert: Schema.Struct<{
+    readonly createdAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Schema.OptionFromNullOr<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Schema.OptionFromNullOr<Schema.String>;
+    readonly toolName: Schema.OptionFromNullOr<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+  readonly json: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Model$1.optionalOption<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Model$1.optionalOption<Schema.String>;
+    readonly toolName: Model$1.optionalOption<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+  readonly jsonCreate: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Model$1.optionalOption<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Model$1.optionalOption<Schema.String>;
+    readonly toolName: Model$1.optionalOption<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+  readonly jsonUpdate: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Model$1.optionalOption<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Model$1.optionalOption<Schema.String>;
+    readonly toolName: Model$1.optionalOption<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+  readonly select: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly updatedAt: Schema.DateTimeUtcFromMillis;
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Schema.OptionFromNullOr<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Schema.OptionFromNullOr<Schema.String>;
+    readonly toolName: Schema.OptionFromNullOr<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+  readonly update: Schema.Struct<{
+    readonly updatedAt: import("effect/unstable/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
+    readonly id: Schema.String;
+    readonly entryId: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "Session.ID">;
+    readonly partIndex: Schema.Int;
+    readonly type: Schema.Literals<readonly ["text", "image", "thinking", "toolCall"]>;
+    readonly status: Schema.OptionFromNullOr<Schema.Literals<readonly ["pending", "running", "completed", "error", "skipped", "aborted"]>>;
+    readonly callId: Schema.OptionFromNullOr<Schema.String>;
+    readonly toolName: Schema.OptionFromNullOr<Schema.String>;
+    readonly data: Schema.String;
+  }>;
+};
+declare class SessionEntryPartRow extends SessionEntryPartRow_base {}
+//#endregion
+//#region src/event/schema.d.ts
+declare const ID$3: Schema.brand<Schema.String, "Event.ID"> & {
+  create: () => string & import("effect/Brand").Brand<"Event.ID">;
+};
+type ID$3 = typeof ID$3.Type;
+type Definition$1<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
+  readonly type: Type;
+  readonly durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  readonly data: DataSchema;
+};
+type Data<D extends Definition$1> = Schema.Schema.Type<D["data"]>;
+type Payload<D extends Definition$1 = Definition$1> = {
+  readonly id: ID$3;
+  readonly type: D["type"];
+  readonly data: Data<D>;
+  readonly durable?: {
+    readonly aggregateId: string;
+    readonly seq: number;
+    readonly version: number;
+  };
+  readonly metadata?: Record<string, string>;
+};
+//#endregion
+//#region src/event/event.d.ts
+type Subscriber<D extends Definition$1 = Definition$1> = (event: Payload<D>) => Effect.Effect<void>;
+type Unsubscribe = Effect.Effect<void>;
+/**
+ * A durable read manifest: the definitions whose stored rows are in scope, keyed
+ * by versioned type, plus the decoder those rows are decoded through. `schema`
+ * is the tagged union of the same definitions, so it validates the whole
+ * envelope (id/type/durable/data), not just the payload.
+ */
+type Manifest<A> = {
+  readonly definitions: ReadonlyMap<string, Definition$1>;
+  readonly schema: Schema.Decoder<A, never>;
+};
+type ReadAggregateInput<A> = {
+  readonly aggregateId: string;
+  /** Exclusive lower bound. Omitted reads from the first stored sequence (0). */
+  readonly after?: number;
+  readonly limit: number;
+  readonly manifest: Manifest<A>;
+};
+type ReadAggregateResult<A> = {
+  readonly events: ReadonlyArray<A>;
+  readonly hasMore: boolean;
+};
+interface PublishOptions {
+  /** Caller-supplied event ID. Publishing the same ID twice is a defect, not an upsert. */
+  readonly id?: ID$3;
+  /**
+   * Publish-time context — correlation, tracing — carried to projectors on the
+   * in-memory payload and deliberately not stored in the event row. A projector
+   * persists it into its own projection if it means something there; the log
+   * records what happened, not who asked. It therefore does not survive a
+   * durable reread or a rebuild, which `event.test.ts` pins explicitly.
+   */
+  readonly metadata?: Record<string, string>;
+}
+interface Interface$11 {
+  readonly latestSequence: (aggregateId: string) => Effect.Effect<number>;
+  readonly readAggregate: <A>(input: ReadAggregateInput<A>) => Effect.Effect<ReadAggregateResult<A>>;
+  /**
+   * Appends one event. Durable definitions are assigned the aggregate's next
+   * sequence, projected, and stored in a single transaction; the returned
+   * payload carries that sequence in `durable`.
+   */
+  readonly publish: <D extends Definition$1>(definition: D, data: Data<D>, options?: PublishOptions) => Effect.Effect<Payload<D>>;
+  /**
+   * Registers a projector for one event type. Projectors run inside the commit
+   * transaction, so a failing projector rolls the event back with it.
+   */
+  readonly project: <D extends Definition$1>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>;
+  /**
+   * Live stream of one event type.
+   *
+   * This is the only way to read a non-durable definition -- stream deltas and
+   * block boundaries. They never reach a projector: projectors run inside the
+   * commit, and a live event has no commit, so registering one for a live type
+   * compiles and silently never fires.
+   */
+  readonly subscribe: <D extends Definition$1>(definition: D) => Stream.Stream<Payload<D>>;
+  /** Every event, durable and live alike, in publish order. */
+  readonly all: () => Stream.Stream<Payload>;
+  /** Durable catch-up followed by the process-local event tail for one session. */
+  readonly stream: (input: {
+    readonly sessionId: string;
+    readonly after?: number;
+  }) => Stream.Stream<Payload>;
+  /**
+   * Callback form of {@link all}, returning its own removal. A listener runs
+   * after the commit for a durable event, and its failures are logged rather
+   * than surfaced -- the event already happened, so a watcher cannot undo it.
+   */
+  readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>;
+  /**
+   * Moves an aggregate's head to at least `seq`, so the next published event
+   * lands above it. Two callers need this: a fork, reserving [0..seq] for
+   * copied entries, and any write that takes a position without going through
+   * an event -- otherwise the head still points below state that already
+   * exists, and the next event collides with it.
+   *
+   * A sequence is a version position, not a row count, so declaring an
+   * aggregate "already at version N" is legal. Never rewinds: a lower `seq`
+   * than the current head is a no-op.
+   */
+  readonly advance: (aggregateId: string, seq: number) => Effect.Effect<void>;
+}
+declare const Service_base$10: Context.ServiceClass<Service$10, "@codeworksh/harness/event/event/Service", Interface$11>;
+declare class Service$10 extends Service_base$10 {}
+//#endregion
+//#region src/sandbox/errors.d.ts
+declare const SandboxNotFoundError_base: Schema.Class<SandboxNotFoundError, Schema.TaggedStruct<"SandboxNotFoundError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Lifecycle errors are confined to the control plane. Once a mount succeeds,
+ * consumers continue to see only FileSystemError and ShellError.
+ */
+declare class SandboxNotFoundError extends SandboxNotFoundError_base {}
+declare const SandboxDriverNotRegisteredError_base: Schema.Class<SandboxDriverNotRegisteredError, Schema.TaggedStruct<"SandboxDriverNotRegisteredError", {
+  readonly driver: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverNotRegisteredError extends SandboxDriverNotRegisteredError_base {}
+declare const SandboxDriverRegistrationError_base: Schema.Class<SandboxDriverRegistrationError, Schema.TaggedStruct<"SandboxDriverRegistrationError", {
+  readonly driver: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverRegistrationError extends SandboxDriverRegistrationError_base {}
+declare const SandboxBusyError_base: Schema.Class<SandboxBusyError, Schema.TaggedStruct<"SandboxBusyError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly refCount: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxBusyError extends SandboxBusyError_base {}
+declare const SandboxMustBeStoppedError_base: Schema.Class<SandboxMustBeStoppedError, Schema.TaggedStruct<"SandboxMustBeStoppedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxMustBeStoppedError extends SandboxMustBeStoppedError_base {}
+declare const SandboxRemovedError_base: Schema.Class<SandboxRemovedError, Schema.TaggedStruct<"SandboxRemovedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly removedAt: Schema.optional<Schema.DateTimeUtc>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxRemovedError extends SandboxRemovedError_base {}
+declare const SandboxUnavailError_base: Schema.Class<SandboxUnavailError, Schema.TaggedStruct<"SandboxUnavailError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnavailError extends SandboxUnavailError_base {}
+declare const SandboxUnsupportedError_base: Schema.Class<SandboxUnsupportedError, Schema.TaggedStruct<"SandboxUnsupportedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnsupportedError extends SandboxUnsupportedError_base {}
+declare const SandboxTransitionConflictError_base: Schema.Class<SandboxTransitionConflictError, Schema.TaggedStruct<"SandboxTransitionConflictError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly expected: Schema.$Array<Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>>;
+  readonly actual: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxTransitionConflictError extends SandboxTransitionConflictError_base {}
+declare const SandboxProviderError_base: Schema.Class<SandboxProviderError, Schema.TaggedStruct<"SandboxProviderError", {
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+  readonly sanitized: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+    readonly code: Schema.optional<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A lifecycle failure safe to serialize, persist, or log.
+ *
+ * The raw SDK defect is deliberately absent from the schema. It is retained on
+ * a non-enumerable symbol by {@link providerError}, so Effect's default
+ * formatting and JSON serialization cannot expose credentials nested in it.
+ */
+declare class SandboxProviderError extends SandboxProviderError_base {}
+type SandboxMountError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxRemovedError | SandboxProviderError;
+type SandboxCreateError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxProviderError;
+type SandboxRegisterError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxProviderError;
+type SandboxReadError = never;
+type SandboxRefreshError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxUnsupportedError | SandboxProviderError;
+type SandboxWakeError = SandboxRefreshError | SandboxRemovedError;
+type SandboxStopError = SandboxWakeError | SandboxBusyError | SandboxTransitionConflictError;
+type SandboxDestroyError = SandboxStopError | SandboxMustBeStoppedError;
+//#endregion
+//#region src/sandbox/fs/filesystem.d.ts
+declare const OperationUnsupportedError_base: Schema.Class<OperationUnsupportedError, Schema.TaggedStruct<"OperationUnsupportedError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The runtime filesystem contract, independent of any backend.
+ *
+ * Two surfaces, deliberately:
+ * - {@link Provider} is what a backend implements — plain promises that reject,
+ *   matching every SDK we wrap.
+ * - {@link Interface} is what the harness consumes — Effect with a typed error
+ *   channel and tracing spans. {@link fromProvider} bridges the two exactly
+ *   once, so no consumer ever writes `Effect.tryPromise` against a filesystem.
+ *
+ * Implementations:
+ * - Local:
+ * implement it over a VFS (`./local`);
+ * local filesystem use OS primitives; hence have broader filesytem capabilities.
+ *
+ * - Remote:
+ * implement it over a provider (`./remote`).
+ * remote filesytems depends on the interface provided by the remote provider; hence can have limited filesytem capabilities.
+ *
+ * `isFile`/`isDirectory` are required booleans; size, mtime, and isSymbolicLink are omitted when the
+ * backend cannot report them — never fabricated.
+ *
+ * **Paths are POSIX, and the harness is Unix-only (for now!).** Every path uses `/`
+ * separators on both the host and inside a sandbox — Windows is not supported,
+ * so no translation layer exists. Consumers must use the shared Effect POSIX
+ * path implementation, never the platform default, or a host running the harness would
+ * impose its own flavour on a remote sandbox's paths. Relative paths resolve
+ * against the backend's configured `cwd`.
+ */
+declare class OperationUnsupportedError extends OperationUnsupportedError_base {}
+declare const FileSystemError_base: Schema.Class<FileSystemError, Schema.TaggedStruct<"SandboxFileSystemError", {
+  readonly method: Schema.String;
+  readonly path: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A backend operation failed. `cause` carries the provider's own rejection. */
+declare class FileSystemError extends FileSystemError_base {}
+interface FileStat {
+  readonly isFile: boolean;
+  readonly isDirectory: boolean;
+  readonly isSymbolicLink?: boolean;
+  readonly size?: number;
+  readonly mtime?: Date;
+}
+interface RmOptions {
+  readonly recursive?: boolean;
+  readonly force?: boolean;
+}
+/**
+ * The consumer-facing contract. `exists` distinguishes "absent" from "could not
+ * tell": a backend failure is a typed failure, not `false`, so a caller acting
+ * on absence never acts on a network blip. Use `SandboxFs.existsOrFalse` where
+ * a best-effort answer really is wanted.
+ */
+interface Interface$10 {
+  readonly readFile: (path: string) => Effect.Effect<string, FileSystemError>;
+  readonly readFileBuffer: (path: string) => Effect.Effect<Uint8Array, FileSystemError>;
+  /** Creates missing parent directories, on every backend. */
+  readonly writeFile: (path: string, content: string | Uint8Array) => Effect.Effect<void, FileSystemError>;
+  readonly stat: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+  readonly readdir: (path: string) => Effect.Effect<string[], FileSystemError>;
+  readonly exists: (path: string) => Effect.Effect<boolean, FileSystemError>;
+  readonly mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Effect.Effect<void, FileSystemError>;
+  readonly rm: (path: string, options?: RmOptions) => Effect.Effect<void, FileSystemError | OperationUnsupportedError>;
+  readonly lstat?: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+}
+declare const Service_base$9: Context.ServiceClass<Service$9, "@codeworksh/harness/sandbox/fs/filesystem/Service", Interface$10>;
+/** The runtime filesystem service — the live {@link Interface} for the active sandbox. */
+declare class Service$9 extends Service_base$9 {}
+//#endregion
+//#region src/sandbox/shell/shell.d.ts
+declare const ShellError_base: Schema.Class<ShellError, Schema.TaggedStruct<"ShellError", {
+  readonly command: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The pluggable execution contract. Local sandboxes usually get a Shell through
+ * just-bash over the local `Local.Vfs`; remote sandboxes provide their own
+ * native Shell. Either way the rest of the harness depends only on this service
+ * tag.
+ */
+declare class ShellError extends ShellError_base {}
+interface ExecResult {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: number;
+}
+/**
+ * One options shape for every entry point. `cwd` is the operation-level
+ * override: it wins over the mount's working directory, and a relative value
+ * resolves against it. Neither mutates shared state, so concurrent commands in
+ * one mount can run in different directories.
+ */
+interface ShellOptions {
+  readonly env?: Record<string, string>;
+  readonly cwd?: string;
+}
+/**
+ * A streamed chunk of command output, terminated by a single `exit` carrying the
+ * exit code. (A backend-level mirror of the tool layer's event; kept here so
+ * `sandbox/` does not depend on `tools/`.)
+ */
+type ExecChunk = {
+  readonly _tag: "stdout";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "stderr";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "exit";
+  readonly exitCode: number;
+};
+/**
+ * The command-execution capability a sandbox exposes. For an in-process
+ * backend this is just-bash; for a remote backend it is the sandbox's own
+ * shell. The {@link Shell} service tag carries this interface.
+ */
+interface ISandboxExe {
+  readonly exec: (command: string, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Run a program with an explicit argument vector, bypassing shell word
+   * splitting. Callers that build commands from untrusted values — branch
+   * names, file paths — must use this instead of interpolating into
+   * {@link exec}, where a space or `$(…)` would change what runs.
+   *
+   * Backends whose transport only accepts a string quote the vector with
+   * {@link quote}; backends that spawn directly pass it through untouched.
+   */
+  readonly execArgv: (argv: ReadonlyArray<string>, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Optional streaming output: stdout/stderr chunks then a terminal `exit`.
+   * Backends that can stream (e.g. Vercel) implement it; `ToolShell.fromSandboxShell`
+   * bridges it to `ToolShell.stream` so the bash tool streams over them too.
+   */
+  readonly stream?: (command: string, options?: ShellOptions) => Stream.Stream<ExecChunk, ShellError>;
+}
+declare const Shell_base: Context.ServiceClass<Shell$1, "@codeworksh/harness/sandbox/shell/shell", ISandboxExe>;
+/** Execution service — the live {@link ISandboxExe} for the active sandbox. */
+declare class Shell$1 extends Shell_base {}
+//#endregion
+//#region src/sandbox/io.d.ts
+/**
+ * `SandboxIO` is a **mount**: a filesystem, a shell, and the identity and
+ * working directory they act on.
+ *
+ * It is the whole vocabulary a consumer needs. Project, Git, Copy, Location, and
+ * every tool ask for `SandboxIO.FileSystem`, `SandboxIO.Shell`, and
+ * `SandboxIO.Current` — never for a driver, an address, or a provider SDK — so
+ * a host directory, an in-memory VFS, and a remote microVM are interchangeable
+ * behind one contract.
+ *
+ * The mount neither creates nor destroys infrastructure. `SandboxInstance` is
+ * the durable namespace it acts on — a device, which exists whether or not
+ * anything has it mounted — and `Sandbox.Controller` is the only path that
+ * creates, stops, or destroys one.
+ */
+/**
+ * The filesystem tag. Re-exported here so consumers import one namespace —
+ * Project, Git, Copy, and the runner ask for `SandboxIO.FileSystem`, never for
+ * the module that happens to define it. Code *inside* `sandbox/` keeps importing
+ * the tag directly, since `io.ts` is built on top of it.
+ */
+declare const FileSystem$1: typeof Service$9;
+type FileSystem$1 = Service$9;
+/** The shell tag. Re-exported here so consumers import one namespace. */
+declare const Shell: typeof Shell$1;
+type Shell = Shell$1;
+/**
+ * What a mount sees: immutable identity, plus the working directory resolved for
+ * *this* mount.
+ *
+ * Nothing mutable belongs here. `status`, `usage`, and reference counts all
+ * change while a mount is open, so a mount-time snapshot of them would be wrong
+ * by construction — runtime code that needs live management state asks the
+ * control plane. The driver's own resource locator is likewise absent: consumers
+ * never parse a Vercel name or a Daytona id.
+ */
+interface Identity {
+  readonly id: ID$2;
+  readonly driver: Name;
+  readonly kind: Kind;
+  /** Absolute, and always a path in *this* namespace. */
+  readonly cwd: string;
+}
+declare const Current_base: Context.ServiceClass<Current, "@codeworksh/harness/sandbox/io/Current", Identity>;
+/** Identity and working directory of the current mount. */
+declare class Current extends Current_base {}
+/** Everything a mount provides. */
+type Provides = Current | Service$9 | Shell$1;
+/** A built mount. */
+type Layer$1<E = never, RIn = never> = Layer.Layer<Provides, E, RIn>;
+//#endregion
+//#region src/sandbox/driver.d.ts
+/** Open driver identity. Adding a driver never extends a union in core. */
+declare const Name: Schema.brand<Schema.String, "SandboxDriver.Name">;
+type Name = typeof Name.Type;
+/** A path whose coordinate system is the mounted namespace. */
+declare const AbsolutePath$1: Schema.brand<Schema.String, "SandboxDriver.AbsolutePath">;
+type AbsolutePath$1 = typeof AbsolutePath$1.Type;
+declare const RuntimeConfigBase: Schema.Struct<{
+  readonly defaultCwd: Schema.brand<Schema.String, "SandboxDriver.AbsolutePath">;
+}>;
+interface RuntimeConfigBase extends Schema.Schema.Type<typeof RuntimeConfigBase> {}
+interface Capabilities {
+  readonly reattach: boolean;
+  readonly wake: boolean;
+  readonly stop: boolean;
+  readonly destroy: boolean;
+  readonly cancels: boolean;
+}
+interface Observed {
+  readonly status: Status;
+  readonly providerStatus?: string | undefined;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+}
+interface Provisioned<RuntimeConfig extends RuntimeConfigBase> {
+  readonly providerResourceId?: string | undefined;
+  readonly providerStatus?: string | undefined;
+  readonly runtimeConfig: RuntimeConfig;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+}
+interface RuntimeInput$1<RuntimeConfig extends RuntimeConfigBase> {
+  readonly id: ID$2;
+  readonly providerResourceId: Option.Option<string>;
+  readonly runtimeConfig: RuntimeConfig;
+}
+interface Driver$1<CreateConfig, RuntimeConfig extends RuntimeConfigBase> {
+  readonly name: Name;
+  readonly kind: Kind;
+  readonly capabilities: Capabilities;
+  readonly createConfigCodec: Schema.Codec<CreateConfig, unknown>;
+  readonly runtimeConfigCodec: Schema.Codec<RuntimeConfig, unknown>;
+  readonly create: (input: {
+    readonly instanceId: ID$2;
+    readonly config: CreateConfig;
+  }) => Effect.Effect<Provisioned<RuntimeConfig>, SandboxProviderError>;
+  readonly runtimeConfigFor: (input: {
+    readonly providerResourceId: string;
+    readonly overrides?: Partial<RuntimeConfig> | undefined;
+  }) => Effect.Effect<RuntimeConfig, SandboxProviderError>;
+  readonly attach: (input: RuntimeInput$1<RuntimeConfig>) => Layer.Layer<FileSystem$1 | Shell, SandboxProviderError>;
+  readonly inspect?: (input: RuntimeInput$1<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly wake?: (input: RuntimeInput$1<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly stop?: (input: RuntimeInput$1<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly destroy?: (input: RuntimeInput$1<RuntimeConfig>) => Effect.Effect<void, SandboxProviderError>;
+}
+type Definition<CreateConfig, RuntimeConfig extends RuntimeConfigBase> = Pick<Driver$1<CreateConfig, RuntimeConfig>, "name" | "createConfigCodec" | "runtimeConfigCodec">;
+/**
+ * The registry's type-erased shape. Erasure happens once at registration;
+ * untrusted values still cross the registered driver's codecs before reaching
+ * its typed implementation.
+ */
+interface Registered {
+  readonly name: Name;
+  readonly kind: Kind;
+  readonly capabilities: Capabilities;
+  readonly createConfigCodec: Schema.Codec<unknown, unknown>;
+  readonly runtimeConfigCodec: Schema.Codec<RuntimeConfigBase, unknown>;
+  readonly create: (input: {
+    readonly instanceId: ID$2;
+    readonly config: unknown;
+  }) => Effect.Effect<Provisioned<RuntimeConfigBase>, SandboxProviderError>;
+  readonly runtimeConfigFor: (input: {
+    readonly providerResourceId: string;
+    readonly overrides?: Readonly<Record<string, unknown>> | undefined;
+  }) => Effect.Effect<RuntimeConfigBase, SandboxProviderError>;
+  readonly attach: (input: RuntimeInput$1<RuntimeConfigBase>) => Layer.Layer<FileSystem$1 | Shell, SandboxProviderError>;
+  readonly inspect?: (input: RuntimeInput$1<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly wake?: (input: RuntimeInput$1<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly stop?: (input: RuntimeInput$1<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly destroy?: (input: RuntimeInput$1<RuntimeConfigBase>) => Effect.Effect<void, SandboxProviderError>;
+}
+interface RegistryService {
+  readonly names: ReadonlySet<Name>;
+  readonly find: (name: Name) => Option.Option<Registered>;
+  readonly get: (name: Name) => Effect.Effect<Registered, SandboxDriverNotRegisteredError>;
+  readonly decodeCreateConfig: (name: Name, input: unknown) => Effect.Effect<unknown, SandboxDriverNotRegisteredError | SandboxDriverRegistrationError>;
+  readonly decodeRuntimeConfig: (name: Name, input: unknown) => Effect.Effect<RuntimeConfigBase, SandboxDriverNotRegisteredError | SandboxDriverRegistrationError>;
+  readonly encodeRuntimeConfig: (name: Name, input: RuntimeConfigBase) => Effect.Effect<unknown, SandboxDriverNotRegisteredError | SandboxDriverRegistrationError>;
+}
+declare const Registry_base: Context.ServiceClass<Registry, "@codeworksh/harness/sandbox/driver/Registry", RegistryService>;
+declare class Registry extends Registry_base {}
+interface Registration {
+  readonly registered: Registered;
+}
+declare namespace instance_d_exports {
+  export { ID$2 as ID, Info$3 as Info, Kind, Ownership, PersistedError, instance_d_exports as SandboxInstance, Status, Usage$1 as Usage, fromColumn, fromField, isMountable, mountable, toColumn, toField };
+}
+/**
+ * A Sandbox instance is a **durable filesystem namespace** plus whatever compute
+ * acts on it — a device in Unix terms, which exists whether or not anything has
+ * it mounted. `Sandbox.Controller` is the only thing that creates,
+ * stops, or destroys one; this module is just its identity and state model.
+ *
+ * The application ID is deliberately separate from the driver's own resource
+ * locator: callers never parse a Vercel name or a Daytona ID, driver formats may
+ * change, and a destroyed resource must stay identifiable in Project/Session
+ * history. A missing resource is never recreated under an existing ID — a new
+ * resource is a new namespace and therefore a new ID.
+ */
+declare const ID$2: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+  /**
+   * The host. Reserved, and never written to a column — see {@link toColumn}.
+   * It exists at runtime so nothing has to branch on "is this the host": it is
+   * what identity reads, what logs show, and what the transport cache keys on.
+   */
+  local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  /** A fresh identity for a namespace nothing has named yet. */
+  create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+};
+type ID$2 = typeof ID$2.Type;
+/**
+ * The storage boundary for namespace references, in one place.
+ *
+ * The host filesystem exists whether or not a row describes it, so it gets no
+ * row and `NULL` is the only spelling of it — the Unix analogue is exact, since
+ * `/` has no entry in the mount table you consult to find other mounts. That
+ * makes a session or directory writable before any namespace is registered (the
+ * foreign key is skipped on NULL), makes `SET sandbox_instance_id = NULL` a
+ * meaningful "revert to the host", and leaves the host impossible to tombstone,
+ * collect, or destroy, because there is nothing to point at.
+ *
+ * Two SQLite consequences ride on this and break correctness silently if missed:
+ * unique indexes treat NULLs as distinct, so every uniqueness constraint
+ * spanning a namespace column coalesces to `'local'`; and `= NULL` never
+ * matches, so namespace-scoped reads use `IS`.
+ */
+declare const toColumn: (id: ID$2) => string | null;
+declare const fromColumn: (value: string | null) => ID$2;
+/**
+ * The same mapping for row models, whose optional columns are `Option` rather
+ * than `null`. Kept beside {@link toColumn} so the boundary stays one place:
+ * `toColumn`/`fromColumn` for SQL parameters, these for `Model.FieldOption`.
+ */
+declare const toField: (id: ID$2) => Option.Option<ID$2>;
+declare const fromField: (value: Option.Option<ID$2>) => ID$2;
+/**
+ * Filesystem-class taxonomy, mirroring Unix: disk, tmpfs/procfs, NFS/CIFS.
+ * Stored on the row rather than derived from the registered driver, so reading
+ * an instance never depends on the registry — which matters most when a driver
+ * is *not* configured and you need to list or clean up its rows.
+ */
+declare const Kind: Schema.Literals<readonly ["local", "virtual", "remote"]>;
+type Kind = typeof Kind.Type;
+declare const Ownership: Schema.Literals<readonly ["managed", "external"]>;
+type Ownership = typeof Ownership.Type;
+/**
+ * Lifecycle state, in ZFS pool vocabulary. This is the **last observed** value,
+ * not live driver truth: Daytona auto-stops and auto-archives, Vercel sandboxes
+ * expire on their own timeout, so drift is normal. `stateObservedAt` carries the
+ * freshness and `Controller.refresh` updates it without waking anything.
+ *
+ * `removed` and `unavail` are deliberately distinct. `removed` means we deleted
+ * it; `unavail` means the driver claims it is gone. A "not found" is frequently a
+ * misclassification — wrong region, wrong API url, a revoked key answering 404,
+ * eventual consistency right after create — so it must never be recorded as if we
+ * had destroyed the resource ourselves.
+ */
+declare const Status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+type Status = typeof Status.Type;
+/**
+ * The statuses a `mount` may proceed from. This is the predicate every
+ * conditional write depends on, so it is enumerated once here rather than
+ * restated as prose at each call site.
+ *
+ * `offline` qualifies because mounting wakes.
+ * `faulted` qualifies because a fault is a *usability* condition, not an identity one — see {@link Status}.
+ *
+ * There is no `resuming`: it would exist to be observed by nothing, since
+ * mounting wakes, `offline` is already mountable, and waking is not destructive
+ * so it needs no claim. `suspending` and `removing` stay because they *are*
+ * compare-and-set claims, blocking a concurrent mount mid-destruction.
+ */
+declare const mountable: ReadonlySet<Status>;
+declare const isMountable: (status: Status) => boolean;
+/**
+ * Reference state, derived — never stored. `busy` carries its `umount` meaning:
+ * something holds this and destruction must not proceed unforced.
+ *
+ * `pinned` is the kernel sense of the word: never reclaimable. It short-circuits
+ * counting entirely for instances that cannot be stopped or destroyed (the local
+ * host), which is what keeps them out of any future collector by construction
+ * rather than by an ownership check happening to catch them.
+ */
+declare const Usage$1: Schema.Literals<readonly ["idle", "busy", "pinned"]>;
+type Usage$1 = typeof Usage$1.Type;
+/** Sanitized driver failure. The only error shape allowed to be persisted or logged. */
+declare const PersistedError: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optional<Schema.String>;
+}>;
+type PersistedError = typeof PersistedError.Type;
+/** Durable metadata, safe to return and persist. Assembled by the control plane. */
+interface Info$3 {
+  readonly id: ID$2;
+  readonly driver: Name;
+  readonly kind: Kind;
+  readonly providerResourceId: Option.Option<string>;
+  readonly ownership: Ownership;
+  readonly status: Status;
+  readonly usage: Usage$1;
+  /** References held by *this* control plane. Process-local; see the transport cache. */
+  readonly refCount: number;
+  readonly providerStatus: Option.Option<string>;
+  readonly metadata: Readonly<Record<string, string>>;
+  readonly lastError: Option.Option<PersistedError>;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly stateObservedAt: Date;
+  readonly lastMountedAt: Option.Option<Date>;
+  readonly lastUnmountedAt: Option.Option<Date>;
+  readonly lastUsedAt: Option.Option<Date>;
+  readonly removedAt: Option.Option<Date>;
+}
+//#endregion
+//#region src/schema.d.ts
+/**
+ * Absolute file path (e.g., `/home/user/projects/myapp/src/main.ts`).
+ */
+declare const AbsolutePath: Schema.brand<Schema.String, "AbsolutePath">;
+type AbsolutePath = Schema.Schema.Type<typeof AbsolutePath>;
+declare namespace schema_d_exports$1 {
+  export { AssistantEnvelopeUsage, CompactionData, ID$1 as ID, IDFromDb, JsonObject, MessageEnvelopeIdentity, schema_d_exports$1 as SessionSchema, Usage };
+}
+declare const ID$1: Schema.brand<Schema.String, "Session.ID"> & {
+  ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+  create: () => string & import("effect/Brand").Brand<"Session.ID">;
+};
+type ID$1 = typeof ID$1.Type;
+declare const IDFromDb: Schema.brand<Schema.String, "Session.ID">;
+declare const JsonObject: Schema.fromJsonString<Schema.$Record<Schema.String, Schema.Unknown>>;
+declare const MessageEnvelopeIdentity: Schema.fromJsonString<Schema.Struct<{
+  readonly messageId: Schema.String;
+}>>;
+declare const CompactionData: Schema.fromJsonString<Schema.Struct<{
+  readonly summary: Schema.String;
+  readonly firstKeptEntryId: Schema.NullOr<Schema.String>;
+  readonly tokensBefore: Schema.Int;
+}>>;
+type CompactionData = typeof CompactionData.Type;
+declare const Usage: Schema.Struct<{
+  readonly input: Schema.Int;
+  readonly output: Schema.Int;
+  readonly cacheRead: Schema.Int;
+  readonly cacheWrite: Schema.Int;
+  readonly totalTokens: Schema.Int;
+  readonly cost: Schema.Struct<{
+    readonly input: Schema.Finite;
+    readonly output: Schema.Finite;
+    readonly cacheRead: Schema.Finite;
+    readonly cacheWrite: Schema.Finite;
+    readonly total: Schema.Finite;
+  }>;
+}>;
+type Usage = typeof Usage.Type;
+declare const AssistantEnvelopeUsage: Schema.fromJsonString<Schema.Struct<{
+  readonly usage: Schema.Struct<{
+    readonly input: Schema.Int;
+    readonly output: Schema.Int;
+    readonly cacheRead: Schema.Int;
+    readonly cacheWrite: Schema.Int;
+    readonly totalTokens: Schema.Int;
+    readonly cost: Schema.Struct<{
+      readonly input: Schema.Finite;
+      readonly output: Schema.Finite;
+      readonly cacheRead: Schema.Finite;
+      readonly cacheWrite: Schema.Finite;
+      readonly total: Schema.Finite;
+    }>;
+  }>;
+}>>;
+//#endregion
+//#region src/session/session.d.ts
+declare const SessionNotFoundError_base: Schema.Class<SessionNotFoundError, Schema.TaggedStruct<"SessionNotFoundError", {
+  readonly sessionId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SessionNotFoundError extends SessionNotFoundError_base {}
+declare const EntryNotFoundError_base: Schema.Class<EntryNotFoundError, Schema.TaggedStruct<"EntryNotFoundError", {
+  readonly sessionId: Schema.String;
+  readonly entryId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class EntryNotFoundError extends EntryNotFoundError_base {}
+declare const InvalidEntryDataError_base: Schema.Class<InvalidEntryDataError, Schema.TaggedStruct<"InvalidEntryDataError", {
+  readonly entryId: Schema.String;
+  readonly type: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidEntryDataError extends InvalidEntryDataError_base {}
+interface CreateSession {
+  readonly id?: ID$1;
+  readonly projectId: string;
+  readonly parentId?: ID$1;
+  readonly slug: string;
+  readonly directory: AbsolutePath;
+  readonly title: string;
+  readonly tag?: string;
+  /**
+   * The namespace this session's directory lives in. Defaults to the host,
+   * which needs no row; any other namespace must already be registered.
+   */
+  readonly sandboxInstanceId?: ID$2;
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+interface AppendPart {
+  readonly id?: string;
+  readonly type: PartType;
+  readonly status?: ToolStatus;
+  readonly callId?: string;
+  readonly toolName?: string;
+  readonly data: string;
+}
+interface AppendEntry {
+  readonly id: string;
+  readonly sessionId: ID$1;
+  /**
+   * Position in the session's durable log — the sequence of the event that
+   * produced this entry. Must exceed every existing entry's seq, which the
+   * event log guarantees since sequences only ever advance.
+   */
+  readonly seq: number;
+  readonly type: EntryType;
+  /** Defaults to committed. Only LLMStarted inserts a draft. */
+  readonly state?: EntryState;
+  readonly data: string;
+  readonly parts?: ReadonlyArray<AppendPart>;
+  readonly parentId?: string;
+  /**
+   * Publish-time context from the event that produced this entry. The log does
+   * not store event metadata, so if it is to survive at all it survives here.
+   */
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+interface SettleToolCall {
+  readonly entryId: string;
+  readonly callId: string;
+  readonly status: Exclude<ToolStatus, "pending" | "running">;
+  readonly data: string;
+}
+interface ReplaceAssistant {
+  readonly id: string;
+  readonly sessionId: ID$1;
+  readonly data: string;
+  readonly parts: ReadonlyArray<AppendPart>;
+}
+interface SetEntryState {
+  readonly id: string;
+  readonly sessionId: ID$1;
+  readonly state: "committed";
+}
+interface AbortAssistant {
+  readonly id: string;
+  readonly sessionId: ID$1;
+  /** Encoded assistant stub. Parts are always deleted by the transition. */
+  readonly data: string;
+}
+interface ForkInput {
+  readonly sessionId: ID$1;
+  readonly entryId?: string;
+  readonly mode?: "at" | "before";
+  readonly id?: ID$1;
+  readonly slug: string;
+  readonly title?: string;
+  readonly tag?: string;
+}
+interface HydratedEntry {
+  readonly entry: SessionEntryRow;
+  readonly parts: ReadonlyArray<SessionEntryPartRow>;
+}
+interface Interface$9 {
+  readonly create: (input: CreateSession) => Effect.Effect<SessionRow>;
+  readonly get: (sessionId: ID$1) => Effect.Effect<Option.Option<SessionRow>>;
+  readonly list: (input: {
+    projectId: string;
+  }) => Effect.Effect<SessionRow[]>;
+  readonly entry: (entryId: string) => Effect.Effect<Option.Option<HydratedEntry>>;
+  /** Active root→leaf path with parts attached. */
+  readonly path: (sessionId: ID$1) => Effect.Effect<HydratedEntry[]>;
+  /** All branches, newest-first, paged by entry seq. */
+  readonly timeline: (input: {
+    sessionId: ID$1;
+    cursorSeq?: number;
+    limit?: number;
+  }) => Effect.Effect<HydratedEntry[]>;
+  /** Unsettled toolCall parts (crash recovery / live status). */
+  readonly unsettled: (sessionId: ID$1) => Effect.Effect<SessionEntryPartRow[]>;
+  readonly append: (input: AppendEntry) => Effect.Effect<SessionEntryRow, SessionNotFoundError | EntryNotFoundError | InvalidEntryDataError>;
+  /** Projector-only: replace the payload of an existing draft assistant in place. */
+  readonly replaceAssistant: (input: ReplaceAssistant) => Effect.Effect<void>;
+  /** Projector-only: settle one pending/running tool part on a draft assistant. */
+  readonly settleToolCall: (input: SettleToolCall) => Effect.Effect<void>;
+  /** Projector-only: commit a draft after every tool part is terminal. */
+  readonly setEntryState: (input: SetEntryState) => Effect.Effect<void>;
+  /** Projector-only: turn a draft into a partless aborted tombstone. */
+  readonly abortAssistant: (input: AbortAssistant) => Effect.Effect<void>;
+  /** Copy root→fork-point into a new session (`parentId` = source). Clone = fork at leaf. */
+  readonly fork: (input: ForkInput) => Effect.Effect<SessionRow, SessionNotFoundError | EntryNotFoundError | InvalidEntryDataError>;
+  /** Move the leaf cursor; the next append forks a sibling branch. */
+  readonly branch: (input: {
+    sessionId: ID$1;
+    entryId: string;
+  }) => Effect.Effect<void, EntryNotFoundError>;
+  /** Set or clear (null) the bookmark label on an entry. */
+  readonly setLabel: (input: {
+    sessionId: ID$1;
+    entryId: string;
+    label: string | null;
+  }) => Effect.Effect<void, EntryNotFoundError>;
+}
+declare const Service_base$8: Context.ServiceClass<Service$8, "@codeworksh/harness/session/session/Service", Interface$9>;
+declare class Service$8 extends Service_base$8 {}
+//#endregion
+//#region src/context/errors.d.ts
+declare const ContextDecodeError_base: Schema.Class<ContextDecodeError, Schema.TaggedStruct<"ContextDecodeError", {
+  readonly entryId: Schema.String;
+  readonly type: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ContextDecodeError extends ContextDecodeError_base {}
+declare const ContextEncodeError_base: Schema.Class<ContextEncodeError, Schema.TaggedStruct<"ContextEncodeError", {
+  readonly messageId: Schema.String;
+  readonly role: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ContextEncodeError extends ContextEncodeError_base {}
+//#endregion
+//#region src/sandbox/control.d.ts
+interface CreateInput$2<CreateConfig, RuntimeConfig extends RuntimeConfigBase> {
+  readonly driver: Definition<CreateConfig, RuntimeConfig>;
+  readonly config: CreateConfig;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+  /** Reserved for isolated test/script constructors that already own an id. */
+  readonly instanceId?: ID$2 | undefined;
+}
+interface RegisterInput$1<CreateConfig, RuntimeConfig extends RuntimeConfigBase> {
+  readonly driver: Definition<CreateConfig, RuntimeConfig>;
+  readonly providerResourceId: string;
+  readonly runtimeConfig?: Partial<RuntimeConfig> | undefined;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+}
+interface MountOptions {
+  /** Absolute, or relative to RuntimeConfig.defaultCwd. */
+  readonly cwd?: string;
+}
+interface DestroyOptions {
+  /** Skip only this process's live-reference guard. */
+  readonly force?: boolean;
+}
+interface ListInput {
+  readonly driver?: Name;
+  readonly status?: Status;
+  readonly usage?: Usage$1;
+}
+interface Interface$8 {
+  readonly create: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(input: CreateInput$2<CreateConfig, RuntimeConfig>) => Effect.Effect<Info$3, SandboxCreateError>;
+  readonly createAndMount: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(input: CreateInput$2<CreateConfig, RuntimeConfig>, options?: MountOptions) => Layer$1<SandboxCreateError | SandboxMountError>;
+  readonly register: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(input: RegisterInput$1<CreateConfig, RuntimeConfig>) => Effect.Effect<Info$3, SandboxRegisterError>;
+  readonly get: (id: ID$2) => Effect.Effect<Option.Option<Info$3>, SandboxReadError>;
+  readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info$3>, SandboxReadError>;
+  /** Resolve a session cwd without mounting or waking the sandbox. */
+  readonly resolveCwd: (id?: ID$2, override?: string) => Effect.Effect<AbsolutePath$1, SandboxMountError>;
+  readonly refresh: (id: ID$2) => Effect.Effect<Info$3, SandboxRefreshError>;
+  readonly mount: (id?: ID$2, options?: MountOptions) => Layer$1<SandboxMountError>;
+  readonly withMount: <A, E, R>(id: ID$2 | undefined, use: Effect.Effect<A, E, R>, options?: MountOptions) => Effect.Effect<A, E | SandboxMountError, Exclude<R, Provides>>;
+  readonly wake: (id: ID$2) => Effect.Effect<Info$3, SandboxWakeError>;
+  readonly stop: (id: ID$2) => Effect.Effect<Info$3, SandboxStopError>;
+  readonly destroy: (id: ID$2, options?: DestroyOptions) => Effect.Effect<void, SandboxDestroyError>;
+}
+declare const Controller_base: Context.ServiceClass<Controller, "@codeworksh/harness/sandbox/control/Controller", Interface$8>;
+declare class Controller extends Controller_base {}
+//#endregion
+//#region src/sandbox/drivers/daytona.d.ts
+interface ClientOptions$1 {
+  readonly apiKey?: string | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly target?: string | undefined;
+}
+declare const CreateConfig$1: Schema.Struct<{
+  readonly snapshot: Schema.optional<Schema.String>;
+  readonly image: Schema.optional<Schema.String>;
+  readonly language: Schema.optional<Schema.String>;
+  readonly envVars: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  readonly resources: Schema.optional<Schema.Struct<{
+    readonly cpu: Schema.optional<Schema.Finite>;
+    readonly gpu: Schema.optional<Schema.Finite>;
+    readonly memory: Schema.optional<Schema.Finite>;
+    readonly disk: Schema.optional<Schema.Finite>;
+  }>>;
+  readonly user: Schema.optional<Schema.String>;
+  readonly cwd: Schema.optional<Schema.String>;
+  readonly autoStopInterval: Schema.optional<Schema.Finite>;
+  readonly execTimeout: Schema.optional<Schema.Finite>;
+}>;
+type CreateConfig$1 = typeof CreateConfig$1.Type;
+//#endregion
+//#region src/sandbox/drivers/vercel.d.ts
+interface ClientOptions {
+  readonly token?: string | undefined;
+  readonly teamId?: string | undefined;
+  readonly projectId?: string | undefined;
+}
+declare const CreateConfig: Schema.Struct<{
+  readonly snapshot: Schema.optional<Schema.String>;
+  readonly source: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly url: Schema.String;
+    readonly revision: Schema.optional<Schema.String>;
+    readonly depth: Schema.optional<Schema.Finite>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"tarball">;
+    readonly url: Schema.String;
+  }>]>>;
+  readonly runtime: Schema.optional<Schema.String>;
+  readonly ports: Schema.optional<Schema.$Array<Schema.Finite>>;
+  readonly envVars: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  readonly vcpus: Schema.optional<Schema.Finite>;
+  readonly timeout: Schema.optional<Schema.Finite>;
+  readonly execTimeout: Schema.optional<Schema.Finite>;
+}>;
+type CreateConfig = typeof CreateConfig.Type;
+//#endregion
+//#region src/location/location.d.ts
+declare const Info_base: Schema.Class<Info$2, Schema.Struct<{
+  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly sandboxInstanceId: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly project: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+      local: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly name: Schema.String;
+    readonly vcs: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"git">;
+      readonly store: Schema.brand<Schema.String, "AbsolutePath">;
+    }>]>>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+  }>;
+}>, {}>;
+declare class Info$2 extends Info_base {}
+interface Interface$7 extends Info$2 {}
+declare const Service_base$7: Context.ServiceClass<Service$7, "@codeworksh/harness/location/location/Service", Interface$7>;
+declare class Service$7 extends Service_base$7 {}
+//#endregion
+//#region src/context/assemble.d.ts
+interface EffectiveConfig {
+  readonly model?: {
+    readonly providerId: string;
+    readonly modelId: string;
+  };
+  readonly thinkingLevel?: Model.ThinkingLevel;
+}
+interface Snapshot$1 {
+  readonly sessionId: string;
+  readonly leafEntryId: string | null;
+  readonly messages: ReadonlyArray<Message.Message>;
+  readonly config: EffectiveConfig;
+  readonly lastAssistant?: {
+    readonly entryId: string;
+    readonly message: Message.AssistantMessage;
+  };
+}
+//#endregion
+//#region src/context/context.d.ts
+type ContextReadError = SessionNotFoundError | ContextDecodeError;
+interface Interface$6 {
+  readonly assemble: (sessionId: ID$1) => Effect.Effect<Snapshot$1, ContextReadError>;
+}
+declare const Service_base$6: Context.ServiceClass<Service$6, "@codeworksh/harness/context/context/Service", Interface$6>;
+declare class Service$6 extends Service_base$6 {}
+//#endregion
+//#region src/tools/error.d.ts
+declare const ToolExecutionError_base: Schema.Class<ToolExecutionError, Schema.TaggedStruct<"ToolExecutionError", {
+  readonly toolName: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** A typed wrapper for a tool failure crossing the heterogeneous registry boundary. */
+declare class ToolExecutionError extends ToolExecutionError_base {}
+declare namespace tool_d_exports {
+  export { AnyToolDef, AnyToolImpl, FailureMode, Handler, ModelContent, RegisteredTool, ToolCallContext, ToolDef, ToolImpl, define, implement, make, provide, register$1 as register, toAikitTool, toProviderJsonSchema };
+}
+/**
+ * The tool definition + handler model.
+ *
+ * A tool definition is pure, serializable data: name, description, and Effect
+ * Schema for parameters / success / failure. Execution is a separate `Handler`
+ * — an `Effect` whose capability dependencies (e.g. `ToolShell`) live in its
+ * requirements `R`, provided by a Layer at runtime. Separating the two is the
+ * main testing win: assert on the definition as plain data, and run the handler
+ * against a stub capability Layer.
+ *
+ * Effect Schema is the single source of truth. {@link toAikitTool} derives a
+ * provider-safe JSON Schema object for the aikit wire view; the harness
+ * decode/encodes arguments and results with Effect Schema natively (it does not
+ * use aikit's Typebox validators).
+ */
+/** What the model reads next turn (the `content` side of content/details). */
+type ModelContent = ReadonlyArray<Message.TextContent | Message.ImageContent>;
+/**
+ * Expected failures become a tool-error result fed back to the model ("return");
+ * "error" lets them hit the calling effect's error channel. Defaults to
+ * "return" in {@link define}.
+ *
+ * "return" — almost always, for agent tools.
+ * 	A bash non-zero exit, a file-not-found, a bad-patch — the model should see these and adapt.
+ *
+ * "error" — the rare "this failure is fatal to the run"
+ * 	case: e.g. an unrecoverable auth/quota error where letting the model keep looping is pointless.
+ */
+type FailureMode = "return" | "error";
+/** Per-call metadata handed to a handler instead of positional args. */
+interface ToolCallContext {
+  readonly callID: string;
+  readonly toolName: string;
+  readonly rawArgs: Record<string, unknown>;
+}
+/**
+ * A pure tool definition. Parametrised over the *schema* instances so the
+ * decoded parameter/success/failure types can be recovered via `["Type"]`.
+ */
+interface ToolDef<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  /** Human-readable display label (kept from the previous `AgentTool`). */
+  readonly label?: string;
+  /**
+   * A short one-line summary for compact tool listings (e.g. a system-prompt tool index),
+   * distinct from the fuller `description`.
+   */
+  readonly promptSnippet?: string;
+  /** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */
+  readonly promptGuidelines?: ReadonlyArray<string>;
+  readonly parameters: Params;
+  readonly success: Success;
+  /** Declared, model-visible failures (typed). Omit for tools that cannot fail expectedly. */
+  readonly failure?: Failure;
+  readonly failureMode: FailureMode;
+  /** Render success for the model. Omit → executor falls back to JSON text. */
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  /** Render an expected failure for the model. Omit → executor falls back to JSON text. */
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** A handler: validated params + context → typed success or typed failure. */
+type Handler<Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never> = (params: Params["Type"], ctx: ToolCallContext) => Effect.Effect<Success["Type"], Failure["Type"], R>;
+/** A definition paired with its handler (the unit the executor runs). */
+interface ToolImpl<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top, R = never> {
+  readonly definition: ToolDef<Name, Params, Success, Failure>;
+  readonly handler: Handler<Params, Success, Failure, R>;
+}
+type AnyToolDef = ToolDef<string, any, any, any>;
+type AnyToolImpl<R = never> = ToolImpl<string, any, any, any, R>;
+interface DefineInput<Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  readonly label?: string;
+  readonly promptSnippet?: string;
+  readonly parameters: Params;
+  readonly success: Success;
+  readonly failure?: Failure;
+  readonly failureMode?: FailureMode;
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** Define a pure tool (handler attached later via {@link implement} or a toolkit). */
+declare const define: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top>(input: DefineInput<Name, Params, Success, Failure>) => ToolDef<Name, Params, Success, Failure>;
+/** Attach a handler to an existing definition (the testable def/exec split). */
+declare const implement: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never>(definition: ToolDef<Name, Params, Success, Failure>, handler: Handler<Params, Success, Failure, R>) => ToolImpl<Name, Params, Success, Failure, R>;
+/** Sugar for the co-located case: a definition with its handler in one object. */
+declare const make: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top, R = never>(input: DefineInput<Name, Params, Success, Failure> & {
+  readonly handler: Handler<Params, Success, Failure, R>;
+}) => ToolImpl<Name, Params, Success, Failure, R>;
+/**
+ * A tool ready to register: its capability requirements have been discharged, leaving only
+ * the executor-provided {@link ToolProgress}. The registry and executor hold `RegisteredTool`s
+ * and are non-generic (only `handle` is generic, over a progress sink's `RProgress`), so any
+ * number of tools — built-in or
+ * third-party/plugin — compose without a shared capability union
+ */
+interface RegisteredTool {
+  readonly definition: AnyToolDef;
+  readonly handler: (params: unknown, ctx: ToolCallContext) => Effect.Effect<unknown, ToolExecutionError, ToolProgress>;
+}
+/** Register a tool whose only requirement is the executor-provided progress service. */
+declare const register$1: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top>(impl: ToolImpl<Name, Params, Success, Failure, ToolProgress>) => RegisteredTool;
+/**
+ * Discharge a tool's capability requirements into a {@link RegisteredTool}, erasing its `R`
+ * (the executor still provides `ToolProgress`). This is the registration boundary: a
+ * plugin/third-party tool provides its own fully-resolved capability Layer here, so the
+ * registry never has to unify anyone's `R`.
+ */
+declare const provide: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R>(impl: ToolImpl<Name, Params, Success, Failure, R | ToolProgress>, layer: Layer.Layer<R>) => RegisteredTool;
+/**
+ * Derive a provider-safe JSON Schema object from an Effect Schema. This is the
+ * single boundary that crosses into the provider wire; if a provider rejects a
+ * construct, fix it here. Draft-07 inlines the root (no top-level `$ref`).
+ */
+declare const toProviderJsonSchema: (schema: Schema.Top) => Record<string, unknown>;
+/**
+ * Build the aikit `Message.Tool` wire view from a definition. The derived JSON
+ * Schema object satisfies aikit's `parameters` slot structurally at runtime; the
+ * single localized cast keeps aikit untouched (decision 3-A).
+ */
+declare const toAikitTool: (def: AnyToolDef) => Message.Tool;
+//#endregion
+//#region src/tools/progress.d.ts
+/**
+ * `ToolProgress` — the side-channel a long-running tool (e.g. streaming bash)
+ * writes interim output to, instead of an `onUpdate` callback.
+ *
+ * Most tools never call `report` and keep a clean `Effect<Success, Failure>`
+ * signature. Throttling / coalescing lives in the Layer (the live one routes to
+ * the run's event PubSub, tagged with the active callID); the handler just
+ * reports.
+ */
+/** Mirror of aikit's `Message.ToolRunningPartial` (kept structural to stay decoupled). */
+interface ToolProgressPartial {
+  readonly content?: ModelContent;
+  readonly details?: unknown;
+}
+interface IToolProgress {
+  readonly report: (partial: ToolProgressPartial) => Effect.Effect<void>;
+}
+declare const ToolProgress_base: Context.ServiceClass<ToolProgress, "@codeworksh/harness/tools/progress/ToolProgress", IToolProgress>;
+declare class ToolProgress extends ToolProgress_base {}
+//#endregion
+//#region src/tools/executor.d.ts
+/**
+ * `ToolExecutor` — the uniform pipeline run for every tool call:
+ *
+ *   resolve def → decode args (Effect Schema) → run handler (scoped, exit) →
+ *   encode typed Success/Failure into aikit's message protocol → complete terminal part.
+ *
+ * Tool handlers never touch event plumbing or aikit message shapes. The executor owns
+ * the whole pending → terminal value transition. Result mapping:
+ *   - success            → completed   (content + encoded details)
+ *   - declared failure   → error       (content + encoded details), fed to the model
+ *   - interruption       → aborted
+ *   - undeclared / defect → run error  (re-raised as a defect)
+ */
+/** A complete terminal tool-call part, ready for persistence and event publication. */
+type ToolOutcome = Message.ToolCallTerminalPart;
+/** One progress emission handed to an observer, including the complete running part. */
+interface ProgressEvent {
+  readonly partial: ToolProgressPartial;
+  readonly toolCall: Message.ToolCallRunningPart;
+  readonly ctx: ToolCallContext;
+}
+/**
+ * Per-call execution options (owned here; the registry only forwards them). Progress is
+ * best-effort UI telemetry — see the `handle` progress path in {@link make}.
+ */
+interface HandleOptions<RProgress = never, EProgress = never> {
+  /** Sliding-queue capacity for best-effort progress. Bounded default (64); tunable. */
+  readonly progressBuffer?: number;
+  /**
+   * On NORMAL completion, how long to let the sink flush the queue backlog before the scope
+   * closes and the drain fiber stops (default 3s). Ignored on interruption — abort stays snappy.
+   */
+  readonly progressDrainGrace?: Duration.Input;
+  /**
+   * Best-effort progress observer, drained on a scoped background fiber — never in the tool
+   * hot path. It MAY fail and MAY require services (`RProgress`): failures are logged/dropped,
+   * and intermediate updates may be dropped under load. Not part of tool correctness.
+   */
+  readonly onProgress?: (event: ProgressEvent) => Effect.Effect<void, EProgress, RProgress>;
+}
+interface Executor {
+  /** aikit wire view of the tool set, for the loop context (`convertTools`). */
+  readonly wire: Message.Tool[];
+  /**
+   * Atomically transform one complete pending tool-call part into a complete terminal
+   * part. Most failures become a terminal
+   * `ToolOutcome`; a `failureMode: "error"` tool propagates a {@link ToolExecutionError}
+   * retaining its declared failure as `cause`, and undeclared failures/defects propagate as defects.
+   *
+   * Tools enter as {@link RegisteredTool}s (capability `R` already discharged at
+   * registration), so the only requirement left in the result is a progress sink's own
+   * `RProgress`. `options.onProgress` observes live progress off the hot path.
+   */
+  readonly handle: <RProgress = never, EProgress = never>(call: Message.ToolCallPendingPart, options?: HandleOptions<RProgress, EProgress>) => Effect.Effect<ToolOutcome, ToolExecutionError, RProgress>;
+}
+//#endregion
+//#region src/tools/registry.d.ts
+/**
+ * `ToolRegistry` — the loop-facing entry point to the tool catalog
+ *
+ * A `Registry` is a plain immutable value (like {@link Executor}, not a service): a catalog
+ * of {@link RegisteredTool}s plus a `resolve` that produces a frozen {@link Resolved}
+ * snapshot. The registry **catalogs** tools and produces snapshots; it does **not** execute
+ * them — execution lives on the resolved snapshot (`resolved.handle`), backed by the
+ * `Executor`.
+ *
+ * Because a tool's capability `R` is discharged at registration (`Tool.provide` → a
+ * `RegisteredTool` whose only residual requirement is the executor-provided `ToolProgress`),
+ * `Registry` / `Resolved` are **non-generic** — so any number of tools (built-in or
+ * third-party/plugin) compose without a shared capability union.
+ */
+/** A frozen effective tool set: model-facing defs + the single execution entry point. */
+interface Resolved {
+  /** Pure definition data (prompt index, debugging, future codemode). */
+  readonly defs: ReadonlyArray<AnyToolDef>;
+  /** The aikit wire view handed to the LLM request as `tools`. */
+  readonly wire: ReadonlyArray<Message.Tool>;
+  /**
+   * Transform one complete pending tool-call part into a complete terminal part. The **only**
+   * execution entry point — the
+   * loop never runs a tool any other way. This is the executor's `handle` re-exposed; because
+   * the catalog holds `RegisteredTool`s (capability `R` discharged), only a progress sink's own
+   * `RProgress` surfaces in the result.
+   */
+  readonly handle: Executor["handle"];
+}
+//#endregion
+//#region src/session/runtime.d.ts
+/** Process-local values that cannot be reconstructed from the durable session log. */
+type Bindings = Options$1;
+interface Interface$5 {
+  readonly get: (sessionId: ID$1) => Effect.Effect<Option.Option<Bindings>>;
+  readonly set: (sessionId: ID$1, bindings: Bindings) => Effect.Effect<void>;
+  readonly update: (sessionId: ID$1, patch: Bindings) => Effect.Effect<void>;
+  readonly remove: (sessionId: ID$1) => Effect.Effect<void>;
+}
+declare const Service_base$5: Context.ServiceClass<Service$5, "@codeworksh/harness/session/runtime/Service", Interface$5>;
+declare class Service$5 extends Service_base$5 {}
+//#endregion
+//#region src/state/prompt.d.ts
+/**
+ * What the override sees. The rendered prompt plus the runtime facts it was
+ * rendered from, so a caller can rebuild any part of it rather than only append.
+ *
+ * `tools` is the same resolved set the provider receives, which is what makes a
+ * full override viable without losing the index.
+ *
+ * Conversation messages are deliberately absent. A hook that could read the
+ * transcript is a provider-step concern, not runtime state.
+ */
+interface PromptSystemOverrideInput {
+  readonly systemPrompt: string;
+  readonly tools: ReadonlyArray<AnyToolDef>;
+  readonly sandbox: Identity;
+  readonly location: Info$2;
+  readonly provider: string;
+  readonly model: string;
+  readonly thinkingLevel: Model.ThinkingLevel;
+  readonly toolExecution: ToolExecutionMode;
+}
+/**
+ * The final link in the chain. Its return value is the prompt, verbatim.
+ *
+ * Sync or async: a caller integrating a non-Effect SDK should not have to reach
+ * for Effect to change a string. A throw or rejection becomes a typed
+ * `State.SnapshotError`, never a defect.
+ */
+type PromptSystemOverride = (input: PromptSystemOverrideInput) => string | PromiseLike<string>;
+//#endregion
+//#region src/state/state.d.ts
+/**
+ * How a turn's tool calls are scheduled once the array has been re-read.
+ *
+ * Pinned in the snapshot so a configuration change cannot switch scheduling
+ * halfway through an exchange. State supplies the value; Loop implements it.
+ */
+type ToolExecutionMode = "sequential" | "parallel";
+/**
+ * Everything a caller may legally inject into aikit's
+ * `stream(model, context, options)`.
+ *
+ * aikit's bag is generic per protocol (`Protocol.OptionsFor<TProtocol>`); this is
+ * the erased form, the same move the tool registry makes when it discharges a
+ * tool's capability `R`. Four fields are excluded:
+ *
+ * - `signal` -- `LLM.run` binds it to the scope that aborts the transport on
+ *   interruption. A caller value would silently break cancellation.
+ * - `sessionId` -- Loop owns it.
+ * - `reasoning` -- this *is* the thinking level. Exposing it alongside
+ *   `thinkingLevel` would be two spellings of one value, free to drift.
+ * - `modelId` -- duplicates {@link Options.model}.
+ *
+ * Note: keep options in sync with aikit see @codeworksh/aikit
+ */
+type RequestOptions = Omit<Protocol.CommonOptions, "signal" | "sessionId" | "reasoning"> & {
+  readonly baseURL?: string;
+  readonly method?: Model.APIMethodEnum;
+  readonly toolChoice?: unknown;
+  readonly activeTools?: ReadonlyArray<string>;
+  readonly factoryOptions?: Record<string, unknown>;
+  readonly providerOptions?: Record<string, Record<string, unknown>>;
+};
+interface Options$1 extends RequestOptions {
+  /** Replaces the default foundation prose. */
+  readonly promptCustom?: string;
+  /** Appended after the rendered tool sections. */
+  readonly promptSystemAppend?: string;
+  /** Owns the final prompt outright. Sync or async. */
+  readonly promptSystemOverride?: PromptSystemOverride;
+  /**
+   * Registered after the built-in Bash tool, so the registry's
+   * last-registration-wins rule lets a caller intentionally replace Bash by
+   * name.
+   *
+   * TODO(sanchitrk): check if our assumption is correct here? overriding with same name allowed.
+   * requires fixing if needed within tool registry
+   */
+  readonly tools?: ReadonlyArray<RegisteredTool>;
+  /** Built-in tool names enabled for this session. Omitted keeps the Bash default. */
+  readonly builtinTools?: ReadonlyArray<"bash">;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly thinkingLevel?: Model.ThinkingLevel;
+  readonly toolExecution?: ToolExecutionMode;
+}
+declare const SnapshotError_base: Schema.Class<SnapshotError, Schema.TaggedStruct<"State.SnapshotError", {
+  readonly sessionId: Schema.String;
+  readonly reason: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The prompt override threw or rejected.
+ *
+ * Typed rather than a defect: a caller's callback failing is a caller bug, but it
+ * is one the session should report and survive rather than crash on. The turn
+ * fails before any provider request goes out.
+ */
+declare class SnapshotError extends SnapshotError_base {}
+/**
+ * Immutable runtime state for one exchange.
+ *
+ * `tools.handle` is executable, and that is deliberate: the definitions the model
+ * is shown, the wire schemas it is given, and the handlers that run all come from
+ * one resolved registry. Splitting them would let the advertised set drift from
+ * the executed one.
+ *
+ * Not durable and not serializable. It holds no mutable refs and owns no
+ * lifecycle -- the mount it reads outlives it.
+ */
+interface Snapshot {
+  readonly sessionId: ID$1;
+  readonly sandbox: Identity;
+  readonly location: Info$2;
+  readonly systemPrompt: string;
+  readonly tools: Resolved;
+  readonly provider: string;
+  readonly model: string;
+  readonly thinkingLevel: Model.ThinkingLevel;
+  readonly request: RequestOptions;
+  readonly toolExecution: ToolExecutionMode;
+}
+interface Interface$4 {
+  /**
+   * Capture runtime state for one exchange. Called inside a session drain,
+   * where the mount it reads is already open.
+   */
+  readonly snapshot: (sessionId: ID$1) => Effect.Effect<Snapshot, SnapshotError | ContextReadError, Provides | Service$7>;
+}
+declare const Service_base$4: Context.ServiceClass<Service$4, "@codeworksh/harness/state/state/Service", Interface$4>;
+declare class Service$4 extends Service_base$4 {}
+declare namespace run_d_exports {
+  export { Interface$3 as Interface, LLMStreamError, ModelCatalogError, ModelNotFoundError, ProviderAuthenticationError, ProviderAuthorizationError, ProviderConfigurationError, ProviderContentPolicyError, ProviderError, ProviderFailureReason, ProviderInvalidRequestError, ProviderInvalidResponseError, ProviderModelUnavailableError, ProviderQuotaError, ProviderRateLimitError, ProviderTimeoutError, ProviderTransportError, ProviderUnavailableError, ProviderUnknownError, RunError, run_d_exports as Runner, SandboxDirectoryNotFoundError, Service$3 as Service };
+}
+declare const SandboxDirectoryNotFoundError_base: Schema.Class<SandboxDirectoryNotFoundError, Schema.TaggedStruct<"Runner.SandboxDirectoryNotFoundError", {
+  readonly sessionId: Schema.String;
+  readonly sandboxInstanceId: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDirectoryNotFoundError extends SandboxDirectoryNotFoundError_base {
+  get message(): string;
+}
+declare const ProviderAuthenticationError_base: Schema.Class<ProviderAuthenticationError, Schema.TaggedStruct<"Runner.ProviderAuthenticationError", {
+  readonly message: Schema.String;
+  readonly isRetryable: Schema.Boolean;
+  readonly status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  readonly code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  readonly requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  readonly retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+  readonly authentication: Schema.Literals<readonly ["missing", "invalid", "expired"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderAuthenticationError extends ProviderAuthenticationError_base {}
+declare const ProviderConfigurationError_base: Schema.Class<ProviderConfigurationError, Schema.TaggedStruct<"Runner.ProviderConfigurationError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderConfigurationError extends ProviderConfigurationError_base {}
+declare const ProviderAuthorizationError_base: Schema.Class<ProviderAuthorizationError, Schema.TaggedStruct<"Runner.ProviderAuthorizationError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderAuthorizationError extends ProviderAuthorizationError_base {}
+declare const ProviderModelUnavailableError_base: Schema.Class<ProviderModelUnavailableError, Schema.TaggedStruct<"Runner.ProviderModelUnavailableError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderModelUnavailableError extends ProviderModelUnavailableError_base {}
+declare const ProviderRateLimitError_base: Schema.Class<ProviderRateLimitError, Schema.TaggedStruct<"Runner.ProviderRateLimitError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderRateLimitError extends ProviderRateLimitError_base {}
+declare const ProviderQuotaError_base: Schema.Class<ProviderQuotaError, Schema.TaggedStruct<"Runner.ProviderQuotaError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderQuotaError extends ProviderQuotaError_base {}
+declare const ProviderInvalidRequestError_base: Schema.Class<ProviderInvalidRequestError, Schema.TaggedStruct<"Runner.ProviderInvalidRequestError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderInvalidRequestError extends ProviderInvalidRequestError_base {}
+declare const ProviderContentPolicyError_base: Schema.Class<ProviderContentPolicyError, Schema.TaggedStruct<"Runner.ProviderContentPolicyError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderContentPolicyError extends ProviderContentPolicyError_base {}
+declare const ProviderTimeoutError_base: Schema.Class<ProviderTimeoutError, Schema.TaggedStruct<"Runner.ProviderTimeoutError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderTimeoutError extends ProviderTimeoutError_base {}
+declare const ProviderTransportError_base: Schema.Class<ProviderTransportError, Schema.TaggedStruct<"Runner.ProviderTransportError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderTransportError extends ProviderTransportError_base {}
+declare const ProviderUnavailableError_base: Schema.Class<ProviderUnavailableError, Schema.TaggedStruct<"Runner.ProviderUnavailableError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderUnavailableError extends ProviderUnavailableError_base {}
+declare const ProviderInvalidResponseError_base: Schema.Class<ProviderInvalidResponseError, Schema.TaggedStruct<"Runner.ProviderInvalidResponseError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderInvalidResponseError extends ProviderInvalidResponseError_base {}
+declare const ProviderUnknownError_base: Schema.Class<ProviderUnknownError, Schema.TaggedStruct<"Runner.ProviderUnknownError", {
+  message: Schema.String;
+  isRetryable: Schema.Boolean;
+  status: Schema.decodeTo<Schema.optional<Schema.Finite>, Schema.optionalKey<Schema.Finite>, never, never>;
+  code: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  requestId: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+  retryAfter: Schema.decodeTo<Schema.optional<Schema.Duration>, Schema.optionalKey<Schema.Duration>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderUnknownError extends ProviderUnknownError_base {}
+declare const ProviderFailureReason: Schema.Union<readonly [typeof ProviderAuthenticationError, typeof ProviderConfigurationError, typeof ProviderAuthorizationError, typeof ProviderModelUnavailableError, typeof ProviderRateLimitError, typeof ProviderQuotaError, typeof ProviderInvalidRequestError, typeof ProviderContentPolicyError, typeof ProviderTimeoutError, typeof ProviderTransportError, typeof ProviderUnavailableError, typeof ProviderInvalidResponseError, typeof ProviderUnknownError]>;
+type ProviderFailureReason = Schema.Schema.Type<typeof ProviderFailureReason>;
+declare const ProviderError_base: Schema.Class<ProviderError, Schema.TaggedStruct<"Runner.ProviderError", {
+  readonly provider: Schema.String;
+  readonly model: Schema.String;
+  readonly reason: Schema.Union<readonly [typeof ProviderAuthenticationError, typeof ProviderConfigurationError, typeof ProviderAuthorizationError, typeof ProviderModelUnavailableError, typeof ProviderRateLimitError, typeof ProviderQuotaError, typeof ProviderInvalidRequestError, typeof ProviderContentPolicyError, typeof ProviderTimeoutError, typeof ProviderTransportError, typeof ProviderUnavailableError, typeof ProviderInvalidResponseError, typeof ProviderUnknownError]>;
+}>, import("effect/Cause").YieldableError>;
+/** Stable provider boundary for SDK and RPC consumers; inspect `reason._tag` for the category. */
+declare class ProviderError extends ProviderError_base {
+  readonly cause: ProviderAuthenticationError | ProviderAuthorizationError | ProviderConfigurationError | ProviderContentPolicyError | ProviderInvalidRequestError | ProviderInvalidResponseError | ProviderModelUnavailableError | ProviderQuotaError | ProviderRateLimitError | ProviderTimeoutError | ProviderTransportError | ProviderUnavailableError | ProviderUnknownError;
+  get message(): string;
+  get isRetryable(): boolean;
+}
+declare const ModelCatalogError_base: Schema.Class<ModelCatalogError, Schema.TaggedStruct<"Runner.ModelCatalogError", {
+  readonly path: Schema.String;
+  readonly reason: Schema.Literals<readonly ["missing", "unreadable", "empty", "invalid"]>;
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ModelCatalogError extends ModelCatalogError_base {
+  get message(): string;
+}
+declare const ModelNotFoundError_base: Schema.Class<ModelNotFoundError, Schema.TaggedStruct<"Runner.ModelNotFoundError", {
+  readonly provider: Schema.String;
+  readonly model: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ModelNotFoundError extends ModelNotFoundError_base {
+  get message(): string;
+}
+declare const LLMStreamError_base: Schema.Class<LLMStreamError, Schema.TaggedStruct<"Runner.LLMStreamError", {
+  readonly sessionId: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LLMStreamError extends LLMStreamError_base {
+  get message(): string;
+}
+type RunError = ModelCatalogError | ModelNotFoundError | ProviderError | LLMStreamError | ContextDecodeError | ContextEncodeError | SessionNotFoundError | SnapshotError | SandboxDirectoryNotFoundError | SandboxMountError | FileSystemError;
+interface Interface$3 {
+  /** Drains eligible durable work. Explicit runs perform one provider attempt even when no work is eligible. */
+  readonly run: (input: {
+    readonly sessionId: ID$1;
+    readonly force: boolean;
+  }) => Effect.Effect<void, RunError, Provides | Service$7>;
+}
+declare const Service_base$3: Context.ServiceClass<Service$3, "@codeworksh/harness/runner/run/Service", Interface$3>;
+declare class Service$3 extends Service_base$3 {}
+//#endregion
+//#region src/runner/execution.d.ts
+interface Interface$2 {
+  /** Snapshots active execution owned by this process. */
+  readonly active: Effect.Effect<ReadonlySet<ID$1>>;
+  /** Starts execution while idle or joins the active execution. */
+  readonly resume: (sessionId: ID$1) => Effect.Effect<void, RunError>;
+  /** Drains durable queued input without forcing an otherwise empty provider turn. */
+  readonly drain: (sessionId: ID$1) => Effect.Effect<void, RunError>;
+  /** Registers newly recorded work. Repeated wakeups may coalesce. */
+  readonly wake: (sessionId: ID$1) => Effect.Effect<void>;
+  /** Interrupt active work owned by this process. Idle interruption is a no-op. */
+  readonly interrupt: (sessionId: ID$1) => Effect.Effect<void>;
+}
+declare const Service_base$2: Context.ServiceClass<Service$2, "@codeworksh/harness/runner/execution/Service", Interface$2>;
+declare class Service$2 extends Service_base$2 {}
+//#endregion
+//#region src/session/input/schema.d.ts
+declare const Admitted: Schema.Struct<{
+  readonly admittedSeq: Schema.Int;
+  readonly id: Schema.brand<Schema.String, "Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Message.ID">;
+    from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+  };
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+    create: () => string & import("effect/Brand").Brand<"Session.ID">;
+  };
+  readonly prompt: Schema.Struct<{
+    readonly text: Schema.String;
+  }> & {
+    equivalence: import("effect/Equivalence").Equivalence<{
+      readonly text: string;
+    }>;
+    fromUserMessage: (input: Pick<Prompt, "text">) => {
+      readonly text: string;
+    };
+  };
+  readonly delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+  readonly promotedSeq: Schema.decodeTo<Schema.optional<Schema.Int>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;
+interface Admitted extends Schema.Schema.Type<typeof Admitted> {}
+declare namespace schema_d_exports {
+  export { ID, schema_d_exports as SessionMessageSchema };
+}
+/**
+ * A conversation message id.
+ *
+ * Deliberately unprefixed. aikit mints assistant message ids itself, as bare
+ * uuidv7, and `stream()` accepts no id -- so any naming rule of ours would have
+ * to be imposed on messages aikit hands us, by rewriting a field of the value we
+ * were given. Sharing aikit's format instead means an id means the same thing on
+ * both sides of the boundary and never needs translating.
+ *
+ * The brand carries the meaning; uuidv7 keeps ids time-ordered, so they sort by
+ * creation.
+ */
+declare const ID: Schema.brand<Schema.String, "Message.ID"> & {
+  create: () => string & import("effect/Brand").Brand<"Message.ID">;
+  /**
+   * Adopt an id minted elsewhere -- in practice aikit's, which arrives as a
+   * plain string on every stream event and inside every assistant message.
+   *
+   * `make` does the same thing. This exists so the boundary where a foreign
+   * id enters the domain is named and greppable, and so the pairing with
+   * `create` says which side chose the id.
+   */
+  from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+};
+type ID = typeof ID.Type;
+//#endregion
+//#region src/control.d.ts
+declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"PromptConflictError", {
+  readonly sessionId: Schema.String;
+  readonly messageId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The prompt could not be admitted under the id it was given: either that id
+ * already carries different content, or it has already left the inbox. Typed
+ * rather than a defect — a client that retried with a reused id can act on it.
+ */
+declare class PromptConflictError extends PromptConflictError_base {}
+interface PromptInput$1 {
+  readonly sessionId: ID$1;
+  readonly prompt: Prompt;
+  /** Supply to make the call idempotent across retries; minted when omitted. */
+  readonly id?: ID;
+  /** Defaults to "steer": join the running turn rather than waiting for the next. */
+  readonly delivery?: Delivery;
+}
+interface Interface$1 {
+  /**
+   * Records a prompt in the session's durable inbox, then wakes its drain.
+   *
+   * Returns once the prompt is stored, not once it is answered, and not once it
+   * is in the conversation: an admitted prompt enters the transcript at
+   * promotion, which the runner performs at the start of a turn. Between the
+   * two the inbox is the only durable record, which is what makes a crash in
+   * that window recoverable rather than a user message nothing ever answered.
+   */
+  readonly prompt: (input: PromptInput$1) => Effect.Effect<Admitted, SessionNotFoundError | PromptConflictError>;
+  /** Records a prompt and awaits the drain generation responsible for it. */
+  readonly run: (input: PromptInput$1) => Effect.Effect<Admitted, SessionNotFoundError | PromptConflictError | RunError>;
+  /** Starts a drain while the session is idle, or joins the one already running. */
+  readonly resume: (sessionId: ID$1) => Effect.Effect<void, SessionNotFoundError | RunError>;
+  /** Stops work owned by this process, waiting for its cleanup. Idle is a no-op. */
+  readonly interrupt: (sessionId: ID$1) => Effect.Effect<void>;
+  /** Sessions this process is currently draining. */
+  readonly active: Effect.Effect<ReadonlySet<ID$1>>;
+}
+declare const Service_base$1: Context.ServiceClass<Service$1, "@codeworksh/harness/control/Service", Interface$1>;
+declare class Service$1 extends Service_base$1 {}
+//#endregion
 //#region src/global.d.ts
 declare const Service_base: Context.ServiceClass<Service, "@codeworksh/harness/global/Service", Interface>;
 declare class Service extends Service_base {}
@@ -16,18 +2091,18 @@ interface Interface {
 //#endregion
 //#region src/runner/llm.d.ts
 interface Input {
-  readonly sessionId: ID;
+  readonly sessionId: ID$1;
   readonly context: Message.Context;
   readonly provider: string;
   readonly model: string;
   readonly thinkingLevel?: Model.ThinkingLevel;
   readonly options?: RequestOptions;
 }
-type Open = (input: Input, signal: AbortSignal) => Effect.Effect<AsyncIterable<Event.LLMMessageEvent>, ModelNotFoundError | ProviderTurnError>;
+type Open = (input: Input, signal: AbortSignal) => Effect.Effect<AsyncIterable<Event.LLMMessageEvent>, ModelCatalogError | ModelNotFoundError | ProviderError>;
 declare namespace sandbox_d_exports {
-  export { CreateInput$1 as CreateInput, Driver, Drivers, Info$1 as Info, RegisterInput, sandbox_d_exports as Sandbox, instance_d_exports as SandboxInstance, create$1 as create, destroy, get$1 as get, list, refresh, register, stop, wake };
+  export { CreateInput$1 as CreateInput, Driver, Drivers, Info$1 as Info, RegisterInput, sandbox_d_exports as Sandbox, instance_d_exports as SandboxInstance, create$2 as create, destroy, get$1 as get, list, refresh, register, stop, wake };
 }
-type Info$1 = Info$2;
+type Info$1 = Info$3;
 type Driver = Registration;
 type CreateInput$1 = {
   readonly driver: "memory";
@@ -45,16 +2120,16 @@ type RegisterInput = {
   readonly driver: "vercel" | "daytona";
   readonly providerResourceId: string;
 };
-declare const create$1: (input: CreateInput$1) => Effect.Effect<Info$2, SandboxCreateError, Controller | Registry>;
-declare const register: (input: RegisterInput) => Effect.Effect<Info$2, SandboxRegisterError, Controller | Registry>;
-declare const get$1: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<import("effect/Option").Option<Info$2>, never, Controller>;
+declare const create$2: (input: CreateInput$1) => Effect.Effect<Info$3, SandboxCreateError, Controller | Registry>;
+declare const register: (input: RegisterInput) => Effect.Effect<Info$3, SandboxRegisterError, Controller | Registry>;
+declare const get$1: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<import("effect/Option").Option<Info$3>, never, Controller>;
 declare const list: (input?: {
   readonly driver?: string;
   readonly status?: Status;
-} | undefined) => Effect.Effect<readonly Info$2[], never, Controller>;
-declare const refresh: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$2, SandboxRefreshError, Controller>;
-declare const wake: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$2, SandboxWakeError, Controller>;
-declare const stop: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$2, SandboxStopError, Controller>;
+} | undefined) => Effect.Effect<readonly Info$3[], never, Controller>;
+declare const refresh: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$3, SandboxRefreshError, Controller>;
+declare const wake: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$3, SandboxWakeError, Controller>;
+declare const stop: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<Info$3, SandboxStopError, Controller>;
 declare const destroy: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<void, SandboxDestroyError, Controller>;
 declare const Drivers: {
   readonly memory: Driver;
@@ -71,13 +2146,13 @@ interface Options {
   readonly sandboxes?: ReadonlyArray<Driver>;
   readonly llm?: Open;
 }
-declare const layer: (options?: Options) => Layer.Layer<Controller | Registry | Service | Service$1 | Service$2 | Service$3 | Service$4 | Service$5 | Service$6 | Service$7 | SqlClient$1.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient, import("effect/Config").ConfigError | SandboxDriverRegistrationError, never>;
+declare const layer: (options?: Options) => Layer.Layer<Controller | Registry | Service | Service$10 | Service$8 | Service$6 | Service$5 | Service$4 | Service$2 | Service$1 | SqlClient$1.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient, import("effect/Config").ConfigError | SandboxDriverRegistrationError, never>;
 declare namespace tools_d_exports {
   export { tools_d_exports as Tools, bash };
 }
 declare const bash: "bash";
 declare namespace session_d_exports {
-  export { AbsolutePath, AttachInput, CreateInput, Handle, Info, ModelConfig, PromptInput, RuntimeInput, session_d_exports as Session, schema_d_exports as SessionMessageSchema, schema_d_exports$1 as SessionSchema, SystemPromptConfig, ToolsConfig, attach, create, get };
+  export { AbsolutePath, AttachInput, CreateInput, Handle, Info, ModelConfig, PromptInput, RuntimeInput, session_d_exports as Session, schema_d_exports as SessionMessageSchema, schema_d_exports$1 as SessionSchema, SystemPromptConfig, ToolsConfig, attach, create$1 as create, get };
 }
 interface ModelConfig {
   readonly provider: string;
@@ -106,21 +2181,21 @@ interface CreateInput extends RuntimeInput {
   readonly directory?: string;
 }
 interface AttachInput extends RuntimeInput {
-  readonly sessionId: ID;
+  readonly sessionId: ID$1;
 }
 type PromptInput = string | {
   readonly text: string;
   readonly delivery?: Delivery;
-  readonly id?: ID$1;
+  readonly id?: ID;
 };
 interface Info {
-  readonly id: ID;
+  readonly id: ID$1;
   readonly title: string;
   readonly directory: AbsolutePath;
   readonly sandbox?: Info$1;
 }
 interface Handle {
-  readonly id: ID;
+  readonly id: ID$1;
   readonly active: Effect.Effect<boolean>;
   readonly info: Effect.Effect<Info, SessionNotFoundError>;
   readonly prompt: (input: PromptInput) => ReturnType<Interface$1["prompt"]>;
@@ -132,14 +2207,14 @@ interface Handle {
   }) => Stream.Stream<Payload>;
   readonly path: () => Effect.Effect<ReadonlyArray<HydratedEntry>>;
 }
-declare const create: (input?: CreateInput | undefined) => Effect.Effect<{
+declare const create$1: (input?: CreateInput | undefined) => Effect.Effect<{
   id: string & import("effect/Brand").Brand<"Session.ID">;
   active: Effect.Effect<boolean, never, never>;
   info: Effect.Effect<{
     id: string & import("effect/Brand").Brand<"Session.ID">;
     title: string;
     directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-    sandbox?: Info$2;
+    sandbox?: Info$3;
   }, SessionNotFoundError, never>;
   prompt: (input: PromptInput) => Effect.Effect<Admitted, PromptConflictError | SessionNotFoundError, never>;
   run: (input: PromptInput) => Effect.Effect<Admitted, PromptConflictError | RunError, never>;
@@ -149,9 +2224,9 @@ declare const create: (input?: CreateInput | undefined) => Effect.Effect<{
     readonly after?: number;
   } | undefined) => Stream.Stream<Payload, never, never>;
   path: () => Effect.Effect<HydratedEntry[], never, never>;
-}, SandboxMountError, Controller | Service$1 | Service$2 | Service$4 | Service$7 | SqlClient.SqlClient>;
-declare const get: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Option.None<Handle> | Option.Some<Handle>, never, Controller | Service$1 | Service$2 | Service$7>;
-declare const attach: (input: AttachInput) => Effect.Effect<Handle, SessionNotFoundError, Controller | Service$1 | Service$2 | Service$4 | Service$7>;
+}, SandboxMountError, Controller | Service$10 | Service$8 | Service$5 | Service$1 | SqlClient.SqlClient>;
+declare const get: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Option.None<Handle> | Option.Some<Handle>, never, Controller | Service$10 | Service$8 | Service$1>;
+declare const attach: (input: AttachInput) => Effect.Effect<Handle, SessionNotFoundError, Controller | Service$10 | Service$8 | Service$5 | Service$1>;
 //#endregion
-export { harness_d_exports as Harness, sandbox_d_exports as Sandbox, session_d_exports as Session, tool_d_exports as Tool, tools_d_exports as Tools };
+export { harness_d_exports as Harness, run_d_exports as Runner, sandbox_d_exports as Sandbox, session_d_exports as Session, tool_d_exports as Tool, tools_d_exports as Tools };
 //# sourceMappingURL=effect.d.mts.map