@codeworksh/harness 0.3.0 → 0.4.0-canary.52.1.ge7df22a4

package/effect.d.mts

@@ -1,6 +1,6 @@
 import "./index-BlvIgEtU.mjs";
 import "./index-BEZ8eL--.mjs";
-import { Cause, Config, Context, Duration, Effect, JsonSchema, Layer, Option, Ref, Schema, Stream } from "effect";
+import { Cause, Config, Context, DateTime, Duration, Effect, JsonSchema, Layer, Option, Ref, Schema, Stream } from "effect";
 import { Event, Message, Model, Protocol } from "@codeworksh/aikit";
 import { MessageID as ID, SessionID as ID$1 } from "@codeworksh/plugin/ids";
 import { SqlClient, SqlClient as SqlClient$1, SqlSchema as SqlSchema$1 } from "effect/sql";
@@ -8,7 +8,7 @@ import { SqliteClient } from "@effect/sql-sqlite-node";
 import { Model as Model$1 } from "effect/schema";
 import { SqliteProvider, create } from "@platformatic/vfs";
 import { ChildProcessSpawner } from "effect/process";
-import { DirectoryNotFoundError, Error, Error as Error$1, Info as Info$5, Interface as Interface$9, NotDirectoryError, Service, Service as Service$10 } from "@codeworksh/plugin/location";
+import { DirectoryNotFoundError, Error, Error as Error$1, Info as Info$5, Interface as Interface$10, NotDirectoryError, Service, Service as Service$10 } from "@codeworksh/plugin/location";
 import * as Section from "@codeworksh/plugin/plugin/section";
 import { Config as Config$1, Events, PluginOptions, PluginRef, PluginRegistry, PromptResolver, SharedPluginContext } from "@codeworksh/plugin/plugin";
 import * as AikitFailure from "@codeworksh/aikit/failure";
@@ -284,6 +284,8 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
   readonly tokensOutput: Model$1.GeneratedByDb<Schema.Int>;
   readonly tokensCacheRead: Model$1.GeneratedByDb<Schema.Int>;
   readonly tokensCacheWrite: Model$1.GeneratedByDb<Schema.Int>;
+  readonly execution: Model$1.FieldOption<Schema.Literals<readonly ["running", "closed"]>>;
+  readonly restarts: Model$1.GeneratedByDb<Schema.Int>;
 }, Schema.Struct<import("effect/schema/VariantSchema").ExtractFields<"select", {
   readonly createdAt: Model$1.DateTimeInsertFromNumber;
   readonly updatedAt: Model$1.DateTimeUpdateFromNumber;
@@ -371,6 +373,8 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
   readonly tokensOutput: Model$1.GeneratedByDb<Schema.Int>;
   readonly tokensCacheRead: Model$1.GeneratedByDb<Schema.Int>;
   readonly tokensCacheWrite: Model$1.GeneratedByDb<Schema.Int>;
+  readonly execution: Model$1.FieldOption<Schema.Literals<readonly ["running", "closed"]>>;
+  readonly restarts: Model$1.GeneratedByDb<Schema.Int>;
 }, true>>> & {
   readonly insert: Schema.Struct<{
     readonly createdAt: import("effect/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
@@ -395,6 +399,7 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tag: Schema.OptionFromNullOr<Schema.String>;
     readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
     readonly leafEntryId: Schema.OptionFromNullOr<Schema.String>;
+    readonly execution: Schema.OptionFromNullOr<Schema.Literals<readonly ["running", "closed"]>>;
   }>;
   readonly json: Schema.Struct<{
     readonly createdAt: Schema.DateTimeUtcFromMillis;
@@ -424,6 +429,8 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tokensOutput: Schema.Int;
     readonly tokensCacheRead: Schema.Int;
     readonly tokensCacheWrite: Schema.Int;
+    readonly execution: Model$1.optionalOption<Schema.Literals<readonly ["running", "closed"]>>;
+    readonly restarts: Schema.Int;
   }>;
   readonly jsonCreate: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Session.ID">;
@@ -446,6 +453,7 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tag: Model$1.optionalOption<Schema.String>;
     readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
     readonly leafEntryId: Model$1.optionalOption<Schema.String>;
+    readonly execution: Model$1.optionalOption<Schema.Literals<readonly ["running", "closed"]>>;
   }>;
   readonly jsonUpdate: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Session.ID">;
@@ -468,6 +476,7 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tag: Model$1.optionalOption<Schema.String>;
     readonly metadata: Model$1.optionalOption<Schema.$Record<Schema.String, Schema.String>>;
     readonly leafEntryId: Model$1.optionalOption<Schema.String>;
+    readonly execution: Model$1.optionalOption<Schema.Literals<readonly ["running", "closed"]>>;
   }>;
   readonly select: Schema.Struct<{
     readonly createdAt: Schema.DateTimeUtcFromMillis;
@@ -497,6 +506,8 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tokensOutput: Schema.Int;
     readonly tokensCacheRead: Schema.Int;
     readonly tokensCacheWrite: Schema.Int;
+    readonly execution: Schema.OptionFromNullOr<Schema.Literals<readonly ["running", "closed"]>>;
+    readonly restarts: Schema.Int;
   }>;
   readonly update: Schema.Struct<{
     readonly updatedAt: import("effect/schema/VariantSchema").Overrideable<Schema.DateTimeUtcFromMillis>;
@@ -520,6 +531,7 @@ declare const SessionRow_base: import("effect/schema/VariantSchema").Class<Sessi
     readonly tag: Schema.OptionFromNullOr<Schema.String>;
     readonly metadata: Schema.OptionFromNullOr<Schema.fromJsonString<Schema.$Record<Schema.String, Schema.String>>>;
     readonly leafEntryId: Schema.OptionFromNullOr<Schema.String>;
+    readonly execution: Schema.OptionFromNullOr<Schema.Literals<readonly ["running", "closed"]>>;
   }>;
 };
 declare class SessionRow extends SessionRow_base {}
@@ -739,7 +751,7 @@ declare const SessionEntryPartRow_base: import("effect/schema/VariantSchema").Cl
 declare class SessionEntryPartRow extends SessionEntryPartRow_base {}
 import * as import__codeworksh_plugin_event from "@codeworksh/plugin/event";
 declare namespace event_d_exports {
-  export { event_d_exports as Event, Interface$17 as Interface, InvalidDurableEventError, LogInput, LogItem, Manifest, PublishOptions, ReadAggregateInput, ReadAggregateResult, SerializedEvent, Service$17 as Service, Subscribe, SubscribeOptions, Subscriber, SubscriptionOverflowError, Synced, Unsubscribe, isSynced, layer$19 as layer };
+  export { event_d_exports as Event, Interface$18 as Interface, InvalidDurableEventError, LogInput, LogItem, Manifest, PublishOptions, ReadAggregateInput, ReadAggregateResult, SerializedEvent, Service$17 as Service, Subscribe, SubscribeOptions, Subscriber, SubscriptionOverflowError, Synced, Unsubscribe, isSynced, layer$19 as layer };
 }
 type SerializedEvent = {
   readonly id: schema_d_exports$10.ID;
@@ -835,7 +847,7 @@ interface Subscribe {
   (options?: SubscribeOptions): Stream.Stream<schema_d_exports$10.Payload, SubscriptionOverflowError>;
   <D extends schema_d_exports$10.Definition>(definition: D, options?: SubscribeOptions): Stream.Stream<schema_d_exports$10.Payload<D>, SubscriptionOverflowError>;
 }
-interface Interface$17 {
+interface Interface$18 {
   /** Current sequence head, or -1 if absent. A version position, not a row count. */
   readonly latestSequence: (aggregateId: string) => Effect.Effect<number>;
   /**
@@ -893,14 +905,14 @@ interface Interface$17 {
    */
   readonly advance: (aggregateId: string, seq: number) => Effect.Effect<void>;
 }
-declare const Service_base$15: Context.ServiceClass<Service$17, "@codeworksh/harness/event/event/Service", Interface$17>;
+declare const Service_base$15: Context.ServiceClass<Service$17, "@codeworksh/harness/event/event/Service", Interface$18>;
 declare class Service$17 extends Service_base$15 {}
 declare const layer$19: Layer.Layer<Service$17, never, SqlClient.SqlClient>;
 import * as import__codeworksh_plugin_project from "@codeworksh/plugin/project";
 import * as import__codeworksh_plugin_schema from "@codeworksh/plugin/schema";
 import * as import__codeworksh_plugin_space from "@codeworksh/plugin/space";
 declare namespace schema_d_exports$6 {
-  export { AssistantEnvelopeUsage, CompactionData, Config$2 as Config, DEFAULT_TITLE, ID$1 as ID, IDFromDb, InterruptReason, JsonObject, MessageEnvelopeIdentity, schema_d_exports$6 as SessionSchema, TITLE_MAX_LENGTH, ThinkingLevel, Usage, titleFrom };
+  export { AssistantEnvelopeUsage, CompactionData, Config$2 as Config, DEFAULT_TITLE, Execution, ID$1 as ID, IDFromDb, InterruptReason, JsonObject, MessageEnvelopeIdentity, schema_d_exports$6 as SessionSchema, TITLE_MAX_LENGTH, ThinkingLevel, Usage, titleFrom };
 }
 declare const IDFromDb: Schema.brand<Schema.String, "Session.ID">;
 /** The title of a session created without one; its first prompt replaces it. */
@@ -935,6 +947,13 @@ type Config$2 = typeof Config$2.Type;
  */
 declare const InterruptReason: Schema.Literals<readonly ["user", "shutdown"]>;
 type InterruptReason = typeof InterruptReason.Type;
+/**
+ * A run left unfinished: `running` while one is in flight, and still after the process died during
+ * it; `closed` once a shutdown stopped it. Either resumes when the server starts again; a run that
+ * ended any other way leaves none.
+ */
+declare const Execution: Schema.Literals<readonly ["running", "closed"]>;
+type Execution = typeof Execution.Type;
 declare const JsonObject: Schema.fromJsonString<Schema.$Record<Schema.String, Schema.Unknown>>;
 declare const MessageEnvelopeIdentity: Schema.fromJsonString<Schema.Struct<{
   readonly messageId: Schema.String;
@@ -977,7 +996,7 @@ declare const AssistantEnvelopeUsage: Schema.fromJsonString<Schema.Struct<{
   }>;
 }>>;
 declare namespace session_d_exports$1 {
-  export { AbortAssistant, AppendEntry, AppendPart, CreateSession, EntryNotFoundError, EntryState, EntryType, ForkInput, HydratedEntry, Interface$16 as Interface, InvalidEntryDataError, ListInput$1 as ListInput, MessageEntryType, PartType, RelinkError, RelinkInput$1 as RelinkInput, RelinkReason, ReplaceAssistant, Service$16 as Service, session_d_exports$1 as Session, SessionEntryPartRow, SessionEntryRow, SessionLinkedSpaceNotFoundError, SessionNotFoundError, SessionNotLinkedError, SessionRow, SetEntryState, SettleToolCall, ToolCallNotFoundError, ToolStatus, defaultLayer$6 as defaultLayer, entryStates, entryTypes, layer$18 as layer, messageEntryTypes, partTypes, rebaseDirectory, toolStatuses };
+  export { AbortAssistant, AppendEntry, AppendPart, CreateSession, EntryNotFoundError, EntryState, EntryType, ForkInput, HydratedEntry, Interface$17 as Interface, InvalidEntryDataError, ListInput$1 as ListInput, MessageEntryType, PartType, RelinkError, RelinkInput$1 as RelinkInput, RelinkReason, ReplaceAssistant, Service$16 as Service, session_d_exports$1 as Session, SessionEntryPartRow, SessionEntryRow, SessionLinkedSpaceNotFoundError, SessionNotFoundError, SessionNotLinkedError, SessionRow, SetEntryState, SettleToolCall, ToolCallNotFoundError, ToolStatus, defaultLayer$6 as defaultLayer, entryStates, entryTypes, layer$18 as layer, messageEntryTypes, partTypes, rebaseDirectory, toolStatuses };
 }
 declare const SessionNotFoundError_base: Schema.Class<SessionNotFoundError, Schema.TaggedStruct<"SessionNotFoundError", {
   readonly sessionId: Schema.String;
@@ -1129,7 +1148,7 @@ interface HydratedEntry {
   readonly entry: SessionEntryRow;
   readonly parts: ReadonlyArray<SessionEntryPartRow>;
 }
-interface Interface$16 {
+interface Interface$17 {
   readonly create: (input: CreateSession) => Effect.Effect<SessionRow>;
   /**
    * Point an existing session at a host directory, or clear it with `null`.
@@ -1153,9 +1172,31 @@ interface Interface$16 {
    * value. The projection of `session.config.changed`, so it runs inside that event's commit.
    */
   readonly configure: (sessionId: ID$1, config: Config$2) => Effect.Effect<void>;
+  /** Records that the session has a run to do: one starting, or one a prompt just woke. */
+  readonly markRunning: (sessionId: ID$1) => Effect.Effect<void>;
+  /**
+   * Records how a run ended. `closed` (a shutdown) leaves it to resume. `stopped` (the user) and
+   * `finished` clear it and the restart count, except that a finished run with prompts still
+   * pending stays marked: they are accepted work a successor, or the next server start, runs.
+   */
+  readonly endExecution: (sessionId: ID$1, end: "finished" | "stopped" | "closed",
+  /** For a stop: the log position it was asked at. A prompt admitted after it keeps the mark. */
+  stoppedAt?: number) => Effect.Effect<void>;
+  /**
+   * Claims a session's unfinished run for recovery: marks it running again, counting a restart when
+   * a dying process left it running (a shutdown's closed run is not counted). The new count, or none
+   * when nothing is unfinished any more, say because the user stopped it since.
+   */
+  readonly claimRestart: (sessionId: ID$1) => Effect.Effect<Option.Option<number>>;
+  /** A committed turn is progress: the restart count starts over. Runs inside `TurnEnded`'s commit. */
+  readonly resetRestarts: (sessionId: ID$1) => Effect.Effect<void>;
+  /** Sessions with a run left unfinished, oldest first. */
+  readonly unfinished: Effect.Effect<ReadonlyArray<SessionRow>>;
   readonly get: (sessionId: ID$1) => Effect.Effect<Option.Option<SessionRow>>;
   /** The space a session attaches to — its env and absolute location. None when the session is unknown. */
   readonly space: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$7.SpaceSchema.Info>>;
+  /** The project a session belongs to, through its space. None when the session is unknown. */
+  readonly project: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$9.ProjectSchema.Info>>;
   /** Sessions newest first, across the whole database when no scope is given. */
   readonly list: (input?: ListInput$1) => Effect.Effect<SessionRow[]>;
   readonly entry: (entryId: string) => Effect.Effect<Option.Option<HydratedEntry>>;
@@ -1198,7 +1239,7 @@ interface Interface$16 {
     label: string | null;
   }) => Effect.Effect<void, EntryNotFoundError>;
 }
-declare const Service_base$14: Context.ServiceClass<Service$16, "@codeworksh/harness/session/session/Service", Interface$16>;
+declare const Service_base$14: Context.ServiceClass<Service$16, "@codeworksh/harness/session/session/Service", Interface$17>;
 declare class Service$16 extends Service_base$14 {}
 declare const layer$18: Layer.Layer<Service$16, never, Service$17 | SqlClient.SqlClient>;
 declare const defaultLayer$6: Layer.Layer<Service$16, import("effect/Config").ConfigError, Service$17>;
@@ -1226,7 +1267,7 @@ import * as import__codeworksh_plugin_sandbox_io from "@codeworksh/plugin/sandbo
 import * as import__codeworksh_plugin_sandbox_driver from "@codeworksh/plugin/sandbox/driver";
 import * as import__codeworksh_plugin_sandbox_errors from "@codeworksh/plugin/sandbox/errors";
 declare namespace registry_d_exports$1 {
-  export { DriverInfo, Registry, RegistryService, registry_d_exports$1 as SandboxDriverRegistry, layer$17 as layer, make$5 as make };
+  export { DriverInfo, Registry, RegistryService, registry_d_exports$1 as SandboxDriverRegistry, layer$17 as layer, make$6 as make };
 }
 interface DriverInfo {
   readonly name: driver_d_exports.SandboxDriver.Name;
@@ -1247,10 +1288,10 @@ interface RegistryService {
 }
 declare const Registry_base: Context.ServiceClass<Registry, "@codeworksh/harness/sandbox/registry", RegistryService>;
 declare class Registry extends Registry_base {}
-declare const make$5: (drivers: ReadonlyArray<driver_d_exports.SandboxDriver.Registration>) => Effect.Effect<RegistryService, errors_d_exports.SandboxDriverRegistrationError>;
+declare const make$6: (drivers: ReadonlyArray<driver_d_exports.SandboxDriver.Registration>) => Effect.Effect<RegistryService, errors_d_exports.SandboxDriverRegistrationError>;
 declare const layer$17: (...drivers: ReadonlyArray<driver_d_exports.SandboxDriver.Registration>) => Layer.Layer<Registry, errors_d_exports.SandboxDriverRegistrationError, never>;
 declare namespace control_d_exports$1 {
-  export { Controller, CreateInput$2 as CreateInput, DestroyOptions, Interface$15 as Interface, ListInput, MountOptions, Options$5 as Options, RegisterInput$1 as RegisterInput, control_d_exports$1 as SandboxController, layer$16 as layer, make$4 as make };
+  export { Controller, CreateInput$2 as CreateInput, DestroyOptions, Interface$16 as Interface, ListInput, MountOptions, Options$5 as Options, RegisterInput$1 as RegisterInput, control_d_exports$1 as SandboxController, layer$16 as layer, make$5 as make };
 }
 interface CreateInput$2<CreateConfig, RuntimeConfig extends driver_d_exports.SandboxDriver.RuntimeConfigBase> {
   readonly driver: driver_d_exports.SandboxDriver.Definition<CreateConfig, RuntimeConfig>;
@@ -1278,7 +1319,7 @@ interface ListInput {
   readonly status?: instance_d_exports.SandboxInstance.Status;
   readonly usage?: instance_d_exports.SandboxInstance.Usage;
 }
-interface Interface$15 {
+interface Interface$16 {
   readonly create: <CreateConfig, RuntimeConfig extends driver_d_exports.SandboxDriver.RuntimeConfigBase>(input: CreateInput$2<CreateConfig, RuntimeConfig>) => Effect.Effect<instance_d_exports.SandboxInstance.Info, errors_d_exports.SandboxCreateError>;
   readonly createAndMount: <CreateConfig, RuntimeConfig extends driver_d_exports.SandboxDriver.RuntimeConfigBase>(input: CreateInput$2<CreateConfig, RuntimeConfig>, options?: MountOptions) => io_d_exports.SandboxIO.Layer<errors_d_exports.SandboxCreateError | errors_d_exports.SandboxMountError>;
   readonly register: <CreateConfig, RuntimeConfig extends driver_d_exports.SandboxDriver.RuntimeConfigBase>(input: RegisterInput$1<CreateConfig, RuntimeConfig>) => Effect.Effect<instance_d_exports.SandboxInstance.Info, errors_d_exports.SandboxRegisterError>;
@@ -1293,7 +1334,7 @@ interface Interface$15 {
   readonly stop: (id: instance_d_exports.SandboxInstance.ID) => Effect.Effect<instance_d_exports.SandboxInstance.Info, errors_d_exports.SandboxStopError>;
   readonly destroy: (id: instance_d_exports.SandboxInstance.ID, options?: DestroyOptions) => Effect.Effect<void, errors_d_exports.SandboxDestroyError>;
 }
-declare const Controller_base: Context.ServiceClass<Controller, "@codeworksh/harness/sandbox/control/Controller", Interface$15>;
+declare const Controller_base: Context.ServiceClass<Controller, "@codeworksh/harness/sandbox/control/Controller", Interface$16>;
 declare class Controller extends Controller_base {}
 interface Options$5 {
   /** Absolute host cwd used by the local instance. Never inferred from ambient process state. */
@@ -1301,7 +1342,7 @@ interface Options$5 {
   readonly transportIdleTimeToLive?: Duration.Input;
   readonly provisioningTimeoutMs?: number;
 }
-declare const make$4: (options: Options$5) => Effect.Effect<Interface$15, errors_d_exports.SandboxDriverRegistrationError, Registry | import("effect/Scope").Scope | SqlClient.SqlClient>;
+declare const make$5: (options: Options$5) => Effect.Effect<Interface$16, errors_d_exports.SandboxDriverRegistrationError, Registry | import("effect/Scope").Scope | SqlClient.SqlClient>;
 declare const layer$16: (options: Options$5) => Layer.Layer<Controller, errors_d_exports.SandboxDriverRegistrationError, Registry | SqlClient.SqlClient>;
 //#endregion
 //#region src/sandbox/sandbox.d.ts
@@ -1319,7 +1360,7 @@ type Provides = io_d_exports.SandboxIO.Provides;
 /** A sandbox is any Layer providing the runtime services above. */
 type Sandbox<E = never, RIn = never> = Layer.Layer<Provides, E, RIn>;
 declare namespace git_d_exports {
-  export { AppProcessError, git_d_exports as Git, Interface$14 as Interface, Result$1 as Result, RevParse, Service$15 as Service, defaultLayer$5 as defaultLayer, layer$15 as layer, layerWith$5 as layerWith, resolvePath };
+  export { AppProcessError, git_d_exports as Git, Interface$15 as Interface, Result$1 as Result, RevParse, Service$15 as Service, defaultLayer$5 as defaultLayer, layer$15 as layer, layerWith$5 as layerWith, resolvePath };
 }
 declare const AppProcessError_base: Schema.Class<AppProcessError, Schema.TaggedStruct<"AppProcessError", {
   readonly command: Schema.String;
@@ -1334,7 +1375,7 @@ interface Result$1 {
   readonly stderr: string;
 }
 type RevParse = "--show-toplevel" | "--git-dir" | "--git-common-dir";
-interface Interface$14 {
+interface Interface$15 {
   /** Run `git <args>` in `directory`; fails only when the process cannot be spawned. */
   readonly exec: (directory: string, args: ReadonlyArray<string>) => Effect.Effect<Result$1, AppProcessError>;
   readonly revParse: (directory: string, arg: RevParse) => Effect.Effect<string | undefined>;
@@ -1362,7 +1403,7 @@ interface Interface$14 {
     readonly env?: Record<string, string>;
   }) => Effect.Effect<Result$1, AppProcessError>;
 }
-declare const Service_base$13: Context.ServiceClass<Service$15, "@codeworksh/harness/git/git/Service", Interface$14>;
+declare const Service_base$13: Context.ServiceClass<Service$15, "@codeworksh/harness/git/git/Service", Interface$15>;
 declare class Service$15 extends Service_base$13 {}
 declare const layer$15: Layer.Layer<Service$15, never, import("@codeworksh/plugin/sandbox/shell").Shell>;
 /**
@@ -1380,7 +1421,7 @@ declare const defaultLayer$5: (rootPath: string) => Layer.Layer<Service$15, neve
 declare function resolvePath(cwd: string, value: string): string;
 import * as import__codeworksh_plugin_repo from "@codeworksh/plugin/repo";
 declare namespace repo_d_exports {
-  export { Identity, Interface$13 as Interface, MARKER, repo_d_exports as Repo, Service$14 as Service, defaultLayer$4 as defaultLayer, layer$14 as layer, layerWith$4 as layerWith, normalize };
+  export { Identity, Interface$14 as Interface, MARKER, repo_d_exports as Repo, Service$14 as Service, defaultLayer$4 as defaultLayer, layer$14 as layer, layerWith$4 as layerWith, normalize };
 }
 /** Per-clone file under the store that pins the project id (see PROJECT.md §1 "marker"). */
 declare const MARKER = "codework";
@@ -1391,13 +1432,13 @@ interface Identity {
   /** True when a portable id was computed and written to the marker this call. */
   readonly stamp: boolean;
 }
-interface Interface$13 {
+interface Interface$14 {
   /** Locate the checkout containing `input`, or undefined when there is none git can read. */
   readonly find: (input: schema_d_exports$8.AbsolutePath) => Effect.Effect<schema_d_exports$5.RepoSchema.Info | undefined>;
   /** PROJECT.md §5.1 PHASE 2. Stamps the marker when a portable id is found for the first time. */
   readonly identity: (repo: schema_d_exports$5.RepoSchema.Info) => Effect.Effect<Identity>;
 }
-declare const Service_base$12: Context.ServiceClass<Service$14, "@codeworksh/harness/repo/repo/Service", Interface$13>;
+declare const Service_base$12: Context.ServiceClass<Service$14, "@codeworksh/harness/repo/repo/Service", Interface$14>;
 declare class Service$14 extends Service_base$12 {}
 /**
  * Canonical `host/path` for a remote url (D-URL): host and path lowercased,
@@ -1409,7 +1450,7 @@ declare const layer$14: Layer.Layer<Service$14, never, import("@codeworksh/plugi
 declare const layerWith$4: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$14, E, RIn>;
 declare const defaultLayer$4: (rootPath: string) => Layer.Layer<Service$14, never, never>;
 declare namespace space_d_exports {
-  export { AbsorbInput, Interface$12 as Interface, RehomeInput, Service$13 as Service, space_d_exports as Space, archiveEnv, fromRow, id, layer$13 as layer, layerWith$3 as layerWith };
+  export { AbsorbInput, Interface$13 as Interface, RehomeInput, Service$13 as Service, space_d_exports as Space, archiveEnv, fromRow, id, layer$13 as layer, layerWith$3 as layerWith };
 }
 /** `hash(env, location)` — no project component (D-SPACEID). */
 declare const id: (env: instance_d_exports.SandboxInstance.ID, location: string) => schema_d_exports$7.SpaceSchema.ID;
@@ -1424,7 +1465,7 @@ interface AbsorbInput {
   readonly strayId: schema_d_exports$7.SpaceSchema.ID;
   readonly into: schema_d_exports$7.SpaceSchema.ID;
 }
-interface Interface$12 {
+interface Interface$13 {
   readonly get: (id: schema_d_exports$7.SpaceSchema.ID) => Effect.Effect<Option.Option<schema_d_exports$7.SpaceSchema.Info>>;
   /** Active spaces of the project in this env, sorted by location. */
   readonly list: (projectId: schema_d_exports$9.ProjectSchema.ID) => Effect.Effect<schema_d_exports$7.SpaceSchema.Info[]>;
@@ -1437,7 +1478,7 @@ interface Interface$12 {
   /** Re-point a stray subdirectory space's sessions at its parent, then delete it (§5.3). `session.directory` is absolute and stays put. */
   readonly absorb: (input: AbsorbInput) => Effect.Effect<void>;
 }
-declare const Service_base$11: Context.ServiceClass<Service$13, "@codeworksh/harness/space/space/Service", Interface$12>;
+declare const Service_base$11: Context.ServiceClass<Service$13, "@codeworksh/harness/space/space/Service", Interface$13>;
 declare class Service$13 extends Service_base$11 {}
 /** Row → public shape. Shared with `Session.space`, which reads the same row through a join. */
 declare const fromRow: (row: SpaceRow) => schema_d_exports$7.SpaceSchema.Info;
@@ -1451,7 +1492,7 @@ declare const archiveEnv: (env: string & import("effect/Brand").Brand<"SandboxIn
 declare const layer$13: Layer.Layer<Service$13, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | SqlClient.SqlClient>;
 declare const layerWith$3: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$13, E, RIn | SqlClient.SqlClient>;
 declare namespace worktree_d_exports {
-  export { Entry$2 as Entry, Input$1 as Input, Interface$11 as Interface, Service$12 as Service, worktree_d_exports as Worktree, WorktreeError, defaultLayer$3 as defaultLayer, layer$12 as layer, layerWith$2 as layerWith };
+  export { Entry$2 as Entry, Input$1 as Input, Interface$12 as Interface, Service$12 as Service, worktree_d_exports as Worktree, WorktreeError, defaultLayer$3 as defaultLayer, layer$12 as layer, layerWith$2 as layerWith };
 }
 declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"Worktree.WorktreeError", {
   readonly operation: Schema.Literals<readonly ["add", "remove", "list"]>;
@@ -1470,7 +1511,7 @@ interface Input$1 {
   readonly repo: schema_d_exports$5.RepoSchema.Info;
   readonly directory: schema_d_exports$8.AbsolutePath;
 }
-interface Interface$11 {
+interface Interface$12 {
   /** `git worktree list`, main checkout first. Never prunes (D-PRUNE). */
   readonly list: (repo: schema_d_exports$5.RepoSchema.Info) => Effect.Effect<ReadonlyArray<Entry$2>, WorktreeError>;
   /** Detached worktree at `directory` checked out at the repo's HEAD. */
@@ -1478,13 +1519,13 @@ interface Interface$11 {
   /** Force-remove the worktree, then prune stale administrative entries. */
   readonly remove: (input: Input$1) => Effect.Effect<void, WorktreeError>;
 }
-declare const Service_base$10: Context.ServiceClass<Service$12, "@codeworksh/harness/worktree/worktree/Service", Interface$11>;
+declare const Service_base$10: Context.ServiceClass<Service$12, "@codeworksh/harness/worktree/worktree/Service", Interface$12>;
 declare class Service$12 extends Service_base$10 {}
 declare const layer$12: Layer.Layer<Service$12, never, import("@codeworksh/plugin/sandbox/filesystem").Service | Service$15>;
 declare const layerWith$2: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$12, E, RIn>;
 declare const defaultLayer$3: (rootPath: string) => Layer.Layer<Service$12, never, never>;
 declare namespace project_d_exports {
-  export { Interface$10 as Interface, project_d_exports as Project, Resolved$2 as Resolved, Service$11 as Service, defaultLayer$2 as defaultLayer, layer$11 as layer, layerWith$1 as layerWith, provisional };
+  export { Interface$11 as Interface, project_d_exports as Project, ProjectNotFoundError, ResolveOptions, Resolved$2 as Resolved, Service$11 as Service, defaultLayer$2 as defaultLayer, layer$11 as layer, layerWith$1 as layerWith, provisional, rename };
 }
 /** Deterministic, env-local id for a directory without a portable identity. Never written to a marker. */
 declare const provisional: (env: instance_d_exports.SandboxInstance.ID, location: string) => schema_d_exports$9.ProjectSchema.ID;
@@ -1496,43 +1537,59 @@ interface Resolved$2 {
   /** `space.kind ∈ { primary, plain }` */
   readonly isDefault: boolean;
 }
-interface Interface$10 {
-  readonly resolveOrCreate: (cwd: schema_d_exports$8.AbsolutePath) => Effect.Effect<Resolved$2, Error$1>;
+interface ResolveOptions {
+  /**
+   * Names the project when this resolution creates it, ahead of the repository's and the
+   * folder's name. An existing project keeps its name; {@link rename} changes it.
+   */
+  readonly name?: string;
+}
+interface Interface$11 {
+  readonly resolveOrCreate: (cwd: schema_d_exports$8.AbsolutePath, options?: ResolveOptions) => Effect.Effect<Resolved$2, Error$1>;
   readonly get: (id: schema_d_exports$9.ProjectSchema.ID) => Effect.Effect<Option.Option<schema_d_exports$9.ProjectSchema.Info>>;
   readonly list: () => Effect.Effect<schema_d_exports$9.ProjectSchema.Info[]>;
 }
-declare const Service_base$9: Context.ServiceClass<Service$11, "@codeworksh/harness/project/project/Service", Interface$10>;
+declare const Service_base$9: Context.ServiceClass<Service$11, "@codeworksh/harness/project/project/Service", Interface$11>;
 declare class Service$11 extends Service_base$9 {}
 declare const layer$11: Layer.Layer<Service$11, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | Service$13 | Service$14 | Service$12 | SqlClient.SqlClient>;
+declare const ProjectNotFoundError_base: Schema.Class<ProjectNotFoundError, Schema.TaggedStruct<"ProjectNotFoundError", {
+  readonly projectId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ProjectNotFoundError extends ProjectNotFoundError_base {}
+/** Renames a project. Needs only the database, not a mount: a name is the same in every env. */
+declare const rename: (input: {
+  readonly projectId: string;
+  readonly name: string;
+}) => Effect.Effect<schema_d_exports$9.ProjectSchema.Info, ProjectNotFoundError, SqlClient.SqlClient>;
 /** Takes an assembled sandbox — local or remote — not a local backend. */
 declare const layerWith$1: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$11, E | import("effect/Config").ConfigError, Exclude<RIn, SqlClient.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient>>;
 declare const defaultLayer$2: (path: string) => Layer.Layer<Service$11, import("effect/Config").ConfigError, never>;
 declare namespace location_d_exports {
-  export { DirectoryNotFoundError, Error, Info$5 as Info, Interface$9 as Interface, location_d_exports as Location, NotDirectoryError, Service$10 as Service, layer$10 as layer, layerMounted };
+  export { DirectoryNotFoundError, Error, Info$5 as Info, Interface$10 as Interface, location_d_exports as Location, NotDirectoryError, Service$10 as Service, layer$10 as layer, layerMounted };
 }
-declare const layer$10: () => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | Service$11>;
+declare const layer$10: (options?: ResolveOptions) => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | Service$11>;
 /**
  * `layer` with the whole resolution stack (Project, Space, Repo, Worktree, Git)
  * folded in. What remains is exactly the mount and the database — for callers
  * that already hold both, such as the runner and `Session.create`.
  */
-declare const layerMounted: () => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | import("@codeworksh/plugin/sandbox/shell").Shell | import("effect/sql/SqlClient").SqlClient>;
+declare const layerMounted: (options?: ResolveOptions) => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | import("@codeworksh/plugin/sandbox/shell").Shell | import("effect/sql/SqlClient").SqlClient>;
 declare namespace global_d_exports {
-  export { global_d_exports as Global, Interface$8 as Interface, Service$9 as Service, app, appConfigDir, authFile, defaultLayer$1 as defaultLayer, homeConfig, layer$9 as layer, layerWith, make$3 as make, resolve$3 as resolve };
+  export { global_d_exports as Global, Interface$9 as Interface, Service$9 as Service, app, appConfigDir, authFile, defaultLayer$1 as defaultLayer, homeConfig, layer$9 as layer, layerWith, make$4 as make, resolve$3 as resolve };
 }
 declare const appConfigDir = ".codework";
 declare const app = "codework";
 declare const homeConfig: Config.Config<string>;
-declare const Service_base$8: Context.ServiceClass<Service$9, "@codeworksh/harness/global/Service", Interface$8>;
+declare const Service_base$8: Context.ServiceClass<Service$9, "@codeworksh/harness/global/Service", Interface$9>;
 declare class Service$9 extends Service_base$8 {}
-interface Interface$8 {
+interface Interface$9 {
   readonly home: string;
   readonly cache: string;
   readonly data: string;
   readonly log: string;
   readonly bin: string;
 }
-declare function make$3(input?: Partial<Interface$8>): Interface$8;
+declare function make$4(input?: Partial<Interface$9>): Interface$9;
 /**
  * Where a Codework home keeps its OAuth credentials, or undefined to let aikit
  * resolve them (`CODEWORK_CREDENTIALS`, then the default home).
@@ -1543,13 +1600,13 @@ declare function make$3(input?: Partial<Interface$8>): Interface$8;
  * would be invisible to the other.
  */
 declare const authFile: (home: string | undefined) => string | undefined;
-declare const resolve$3: (input?: Partial<Interface$8> | undefined) => Effect.Effect<Interface$8, Config.ConfigError, never>;
+declare const resolve$3: (input?: Partial<Interface$9> | undefined) => Effect.Effect<Interface$9, Config.ConfigError, never>;
 declare const layer$9: Layer.Layer<Service$9, Config.ConfigError, never>;
 declare const defaultLayer$1: Layer.Layer<Service$9, Config.ConfigError, never>;
-declare const layerWith: (input: Partial<Interface$8>) => Layer.Layer<Service$9, Config.ConfigError, never>;
+declare const layerWith: (input: Partial<Interface$9>) => Layer.Layer<Service$9, Config.ConfigError, never>;
 import * as import__codeworksh_plugin_settings from "@codeworksh/plugin/settings";
 declare namespace settings_d_exports {
-  export { Interface$7 as Interface, Options$4 as Options, Service$8 as Service, settings_d_exports as Settings, SettingsError, schema_d_exports$4.defaults as defaults, layer$8 as layer, load$1 as load, modules, parse$1 as parse, paths, projectRoot, userConfigDir };
+  export { Interface$8 as Interface, Options$4 as Options, Service$8 as Service, settings_d_exports as Settings, SettingsError, schema_d_exports$4.defaults as defaults, layer$8 as layer, load$1 as load, modules, parse$1 as parse, paths, projectRoot, userConfigDir };
 }
 interface Options$4 {
   /**
@@ -1736,6 +1793,7 @@ declare const parse$1: (path: string, source: string) => Effect.Effect<{
       supportsOpenAIGrammarTools?: boolean;
       supportsThinkingTokenBudget?: boolean;
       forceAdaptiveThinking?: boolean;
+      supportsTemperature?: boolean;
       thinkingTokenBudgetField?: string;
     };
     contextWindow: number;
@@ -1808,7 +1866,7 @@ declare const parse$1: (path: string, source: string) => Effect.Effect<{
     readonly maxDelayMs?: number | undefined;
   } | undefined;
 }, SettingsError, never>;
-interface Interface$7 {
+interface Interface$8 {
   /**
    * Await fresh host files at each exchange. No cache, mutation, or reload API. Fails when a
    * file exists and cannot be used, including on an edit made mid-session.
@@ -1820,7 +1878,7 @@ interface Interface$7 {
    */
   readonly load: (hostDir: string | undefined) => Effect.Effect<schema_d_exports$4.Info, SettingsError>;
 }
-declare const Service_base$7: Context.ServiceClass<Service$8, "@codeworksh/harness/settings/settings/Service", Interface$7>;
+declare const Service_base$7: Context.ServiceClass<Service$8, "@codeworksh/harness/settings/settings/Service", Interface$8>;
 declare class Service$8 extends Service_base$7 {}
 /**
  * One read of every layer. Exported for the harness constructor, which needs the plugin
@@ -1948,21 +2006,21 @@ declare const modules: (declared: ReadonlyArray<schema_d_exports$4.Declared>) =>
 declare const layer$8: (options?: Omit<Options$4, "hostDir">) => Layer.Layer<Service$8, never, Service$9>;
 import * as import__codeworksh_plugin_plugin from "@codeworksh/plugin/plugin";
 declare namespace registry_d_exports {
-  export { EventRegistrationError, registry_d_exports as EventRegistry, Interface$6 as Interface, Service$7 as Service, flatten, layer$7 as layer };
+  export { EventRegistrationError, registry_d_exports as EventRegistry, Interface$7 as Interface, Service$7 as Service, flatten, layer$7 as layer };
 }
 /**
  * Every event definition this harness knows: the kernel's, plus whatever the
  * configured plugins registered. A validated replacement lands with each new
  * plugin generation; published events retain the schema they were encoded with.
  */
-interface Interface$6 {
+interface Interface$7 {
   readonly definitions: ReadonlyArray<schema_d_exports$10.EventSchema.Definition>;
   /** The latest definition for a type, or `undefined` when nothing declares it. */
   readonly get: (type: string) => schema_d_exports$10.EventSchema.Definition | undefined;
   /** Validate and atomically replace the definitions for a newly loaded plugin pool. */
   readonly replace: (plugins: ReadonlyArray<plugin_d_exports.Plugin>) => Effect.Effect<void, EventRegistrationError>;
 }
-declare const Service_base$6: Context.ServiceClass<Service$7, "@codeworksh/harness/event/registry/Service", Interface$6>;
+declare const Service_base$6: Context.ServiceClass<Service$7, "@codeworksh/harness/event/registry/Service", Interface$7>;
 declare class Service$7 extends Service_base$6 {}
 declare const EventRegistrationError_base: Schema.Class<EventRegistrationError, Schema.TaggedStruct<"EventRegistrationError", {
   readonly pluginId: Schema.String;
@@ -2192,7 +2250,7 @@ interface Origin {
   readonly file?: string;
 }
 declare namespace runtime_d_exports {
-  export { Bindings, Interface$5 as Interface, Service$6 as Service, runtime_d_exports as SessionRuntime, layer$6 as layer };
+  export { Bindings, Interface$6 as Interface, Service$6 as Service, runtime_d_exports as SessionRuntime, layer$6 as layer };
 }
 /**
  * Per-session configuration, held in process.
@@ -2202,20 +2260,20 @@ declare namespace runtime_d_exports {
  * thinking level are not held here: they are the session's durable `SessionSchema.Config`.
  */
 type Bindings = Options$2;
-interface Interface$5 {
+interface Interface$6 {
   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$6, "@codeworksh/harness/session/runtime/Service", Interface$5>;
+declare const Service_base$5: Context.ServiceClass<Service$6, "@codeworksh/harness/session/runtime/Service", Interface$6>;
 declare class Service$6 extends Service_base$5 {}
 declare const layer$6: Layer.Layer<Service$6, never, never>;
 import * as import__codeworksh_plugin_plugin_tool from "@codeworksh/plugin/plugin/tool";
 import * as import__codeworksh_plugin_tool_progress from "@codeworksh/plugin/tool/progress";
 import * as import__codeworksh_plugin_tool from "@codeworksh/plugin/tool";
 declare namespace executor_d_exports {
-  export { Executor, HandleOptions, ProgressEvent, ToolOutcome, make$2 as make };
+  export { Executor, HandleOptions, ProgressEvent, ToolOutcome, make$3 as make };
 }
 /**
  * `ToolExecutor` — the uniform pipeline run for every tool call:
@@ -2279,7 +2337,7 @@ interface Executor {
  * already discharged at registration (`Tool.provide`). The executor therefore needs no tool
  * `R`; only a progress sink's `RProgress` (if any) surfaces from `handle`.
  */
-declare const make$2: (tools: ReadonlyArray<tool_d_exports.RegisteredTool | schema_d_exports$3.ToolRegistration>) => Executor;
+declare const make$3: (tools: ReadonlyArray<tool_d_exports.RegisteredTool | schema_d_exports$3.ToolRegistration>) => Executor;
 //#endregion
 //#region src/tool/registry.d.ts
 /**
@@ -2312,7 +2370,7 @@ interface Resolved$1 {
   readonly handle: Executor["handle"];
 }
 declare namespace state_d_exports {
-  export { Configuration, Interface$4 as Interface, Options$2 as Options, Reloaded, RequestOptions, Service$5 as Service, Snapshot$1 as Snapshot, SnapshotError, state_d_exports as State, ToolExecutionMode, layer$5 as layer };
+  export { Configuration, Interface$5 as Interface, Options$2 as Options, Reloaded, RequestOptions, Service$5 as Service, Snapshot$1 as Snapshot, SnapshotError, state_d_exports as State, ToolExecutionMode, layer$5 as layer };
 }
 /**
  * How a turn's tool calls are scheduled once the array has been re-read.
@@ -2409,7 +2467,7 @@ interface Reloaded {
   /** Why the swap did not happen. The previous set is still the one in use. */
   readonly failure?: string;
 }
-interface Interface$4 {
+interface Interface$5 {
   /**
    * Re-import every configured plugin, and swap the loaded set if it works.
    *
@@ -2442,7 +2500,7 @@ interface Interface$4 {
    */
   readonly snapshot: (sessionId: ID$1) => Effect.Effect<Snapshot$1, SnapshotError | SettingsError | ModelCatalogError | ModelNotFoundError | ProviderError, io_d_exports.SandboxIO.Provides | Service$10>;
 }
-declare const Service_base$4: Context.ServiceClass<Service$5, "@codeworksh/harness/state/state/Service", Interface$4>;
+declare const Service_base$4: Context.ServiceClass<Service$5, "@codeworksh/harness/state/state/Service", Interface$5>;
 declare class Service$5 extends Service_base$4 {}
 /**
  * `pool` is the loaded module set, behind a `Ref` rather than a frozen array.
@@ -2491,7 +2549,7 @@ rebuild: (root: string | undefined, current: Pool) => Effect.Effect<Pool, {
 /** The view a session in `hostDir` runs from: its project root, or the process view. */
 viewOf?: (hostDir: string | undefined) => Effect.Effect<string | undefined>) => Layer.Layer<Service$5, never, Service$9 | Service$8 | Service$17 | Service$16 | Service$7 | Service$6>;
 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$4 as Service };
+  export { Interface$4 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$4 as Service };
 }
 declare const SandboxDirectoryNotFoundError_base: Schema.Class<SandboxDirectoryNotFoundError, Schema.TaggedStruct<"Runner.SandboxDirectoryNotFoundError", {
   readonly sessionId: Schema.String;
@@ -2637,7 +2695,7 @@ declare class ProviderError extends ProviderError_base {
 }
 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 reason: Schema.Literals<readonly ["unreadable", "empty", "invalid"]>;
   readonly detail: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 declare class ModelCatalogError extends ModelCatalogError_base {
@@ -2658,23 +2716,31 @@ declare class LLMStreamError extends LLMStreamError_base {
   get message(): string;
 }
 type RunError = ModelCatalogError | ModelNotFoundError | ProviderError | LLMStreamError | ContextDecodeError | ContextEncodeError | SessionNotFoundError | SessionLinkedSpaceNotFoundError | SettingsError | SnapshotError | SandboxDirectoryNotFoundError | errors_d_exports.SandboxMountError | filesystem_d_exports.SandboxFileSystem.FileSystemError;
-interface Interface$3 {
+interface Interface$4 {
   /** 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;
+    /** Resuming a run a previous process left unfinished: its cut-off reply is answered first. */
+    readonly recovered?: boolean;
   }) => Effect.Effect<void, RunError, io_d_exports.SandboxIO.Provides | Service$10>;
 }
-declare const Service_base$3: Context.ServiceClass<Service$4, "@codeworksh/harness/runner/run/Service", Interface$3>;
+declare const Service_base$3: Context.ServiceClass<Service$4, "@codeworksh/harness/runner/run/Service", Interface$4>;
 declare class Service$4 extends Service_base$3 {}
 declare namespace execution_d_exports {
-  export { Interface$2 as Interface, execution_d_exports as RunnerExecution, Service$3 as Service, noopLayer };
+  export { Interface$3 as Interface, execution_d_exports as RunnerExecution, Service$3 as Service, noopLayer };
 }
-interface Interface$2 {
+interface Interface$3 {
   /** 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>;
+  /**
+   * Resumes a run the last process left unfinished. Like `resume`, except that it marks nothing,
+   * and runs nothing when the session is no longer marked as it begins: a stop that landed since
+   * recovery chose the session stands.
+   */
+  readonly recover: (sessionId: ID$1) => Effect.Effect<void, RunError>;
   /** Registers newly recorded work. Repeated wakeups may coalesce. */
   readonly wake: (sessionId: ID$1) => Effect.Effect<void>;
   /**
@@ -2687,7 +2753,7 @@ interface Interface$2 {
   /** Waits until this process owns no execution for the session. */
   readonly awaitIdle: (sessionId: ID$1) => Effect.Effect<void>;
 }
-declare const Service_base$2: Context.ServiceClass<Service$3, "@codeworksh/harness/runner/execution/Service", Interface$2>;
+declare const Service_base$2: Context.ServiceClass<Service$3, "@codeworksh/harness/runner/execution/Service", Interface$3>;
 declare class Service$3 extends Service_base$2 {}
 declare const noopLayer: Layer.Layer<Service$3, never, never>;
 declare namespace assemble_d_exports {
@@ -3367,15 +3433,18 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
   messageId: string;
 }, ContextDecodeError, never>;
 declare namespace context_d_exports {
-  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
+  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$2 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
 }
 type ContextReadError = SessionNotFoundError | ContextDecodeError;
-interface Interface$1 {
+interface Interface$2 {
   readonly assemble: (sessionId: ID$1) => Effect.Effect<Snapshot, ContextReadError>;
 }
-declare const Service_base$1: Context.ServiceClass<Service$2, "@codeworksh/harness/context/context/Service", Interface$1>;
+declare const Service_base$1: Context.ServiceClass<Service$2, "@codeworksh/harness/context/context/Service", Interface$2>;
 declare class Service$2 extends Service_base$1 {}
 declare const layer$4: Layer.Layer<Service$2, never, Service$16>;
+declare namespace schema_d_exports$2 {
+  export { ID, schema_d_exports$2 as SessionMessageSchema };
+}
 //#endregion
 //#region src/session/input/schema.d.ts
 declare const Admitted: Schema.Struct<{
@@ -3423,13 +3492,128 @@ declare const Admitted: Schema.Struct<{
   readonly delivery: Schema.Literals<readonly ["steer", "followUp"]>;
   readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
   readonly promotedSeq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+  readonly cancelledSeq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
 }>;
 interface Admitted extends Schema.Schema.Type<typeof Admitted> {}
-declare namespace schema_d_exports$2 {
-  export { ID, schema_d_exports$2 as SessionMessageSchema };
+declare namespace input_d_exports {
+  export { AdmitInput, Interface$1 as Interface, LifecycleConflict, ProjectAdmittedInput, ProjectCancelledInput, ProjectPromptedInput, ProjectUpdatedInput, input_d_exports as SessionInput, UpdatePatch, equivalent, make$2 as make };
+}
+declare const LifecycleConflict_base: Schema.Class<LifecycleConflict, Schema.TaggedStruct<"SessionInput.LifecycleConflict", {
+  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">;
+  };
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a durable input is already past the lifecycle point being
+ * projected -- a second admission of the same id, or a second promotion.
+ *
+ * It is a defect, not an error: projectors run inside the event commit, so
+ * raising it rolls the event back and leaves the store untouched. `admit` and
+ * `promote*` then recover by reading the row that won.
+ */
+declare class LifecycleConflict extends LifecycleConflict_base {}
+/**
+ * Whether a stored input carries the prompt the caller believes it admitted.
+ * A retry that reuses an id with different content is a conflict, not an
+ * idempotent replay.
+ */
+declare const equivalent: (input: Admitted, expected: {
+  readonly sessionId: ID$1;
+  readonly prompt: Prompt;
+  readonly delivery: Delivery;
+}) => boolean;
+interface AdmitInput {
+  readonly id: ID;
+  readonly sessionId: ID$1;
+  readonly prompt: Prompt;
+  readonly delivery: Delivery;
+}
+interface ProjectAdmittedInput extends AdmitInput {
+  readonly admittedSeq: number;
+  readonly timeCreated: DateTime.Utc;
+}
+interface ProjectCancelledInput {
+  readonly id: ID;
+  readonly sessionId: ID$1;
+  readonly cancelledSeq: number;
+}
+interface ProjectUpdatedInput {
+  readonly id: ID;
+  readonly sessionId: ID$1;
+  readonly prompt?: Prompt | undefined;
+  readonly delivery?: Delivery | undefined;
+}
+/** What `update` changes; an absent field stays as it is. */
+interface UpdatePatch {
+  readonly prompt?: Prompt;
+  readonly delivery?: Delivery;
+}
+interface ProjectPromptedInput extends AdmitInput {
+  readonly promotedSeq: number;
+  readonly timeCreated: DateTime.Utc;
+}
+interface Interface$1 {
+  readonly find: (id: ID) => Effect.Effect<Option.Option<Admitted>>;
+  /** Records a prompt durably. Re-admitting the same id returns the stored row. */
+  readonly admit: (input: AdmitInput) => Effect.Effect<Admitted>;
+  /** Projector for `PromptAdmitted`. Runs inside the event commit. */
+  readonly projectAdmitted: (input: ProjectAdmittedInput) => Effect.Effect<void>;
+  /** Projector for `Prompted`. Runs inside the event commit. */
+  readonly projectPrompted: (input: ProjectPromptedInput) => Effect.Effect<void>;
+  /** Projector for `PromptCancelled`. Runs inside the event commit. */
+  readonly projectCancelled: (input: ProjectCancelledInput) => Effect.Effect<void>;
+  /** Projector for `PromptUpdated`. Runs inside the event commit. */
+  readonly projectUpdated: (input: ProjectUpdatedInput) => Effect.Effect<void>;
+  /**
+   * Moves a pending input to the other lane, or rewrites it, keeping its place in admission
+   * order. The stored input after the change, or none when it was promoted, cancelled, or unknown.
+   */
+  readonly update: (sessionId: ID$1, id: ID, patch: UpdatePatch) => Effect.Effect<Option.Option<Admitted>>;
+  /**
+   * Withdraws a pending input of the session. False when there is none by that id, or it was
+   * promoted or cancelled first: a cancel that loses to promotion leaves the prompt in the
+   * conversation.
+   */
+  readonly cancel: (sessionId: ID$1, id: ID) => Effect.Effect<boolean>;
+  /** Inputs not promoted yet, both lanes, in admission order. */
+  readonly pending: (sessionId: ID$1) => Effect.Effect<ReadonlyArray<Admitted>>;
+  /** Whether the lane holds an input that has not been promoted yet. */
+  readonly hasPending: (sessionId: ID$1, delivery: Delivery) => Effect.Effect<boolean>;
+  /**
+   * Promotes every pending steer admitted at or before `cutoff`, in admission
+   * order. The cutoff keeps a steer that lands mid-promotion out of a request
+   * that is already being assembled.
+   *
+   * Counts promotions *this* caller won. A row another drainer promoted first
+   * is not counted: callers treat a positive count as new work to answer, and
+   * counting a promotion someone else committed would have two workers answer
+   * one prompt.
+   */
+  readonly promoteSteers: (sessionId: ID$1, cutoff: number) => Effect.Effect<number>;
+  /**
+   * Promotes the single oldest pending follow-up, if any. One per run, unlike
+   * steers, which is what makes the follow-up lane strictly turn-at-a-time.
+   * False when there was none, or when another caller promoted it first.
+   */
+  readonly promoteFollowUp: (sessionId: ID$1) => Effect.Effect<boolean>;
 }
+declare const make$2: Effect.Effect<{
+  find: (id: string & import("effect/Brand").Brand<"Message.ID">) => Effect.Effect<Option.Option<Admitted>, never, never>;
+  admit: (input: AdmitInput) => Effect.Effect<Admitted, never, never>;
+  projectAdmitted: (input: ProjectAdmittedInput) => Effect.Effect<undefined, never, never>;
+  projectPrompted: (input: ProjectPromptedInput) => Effect.Effect<undefined, never, never>;
+  projectCancelled: (input: ProjectCancelledInput) => Effect.Effect<undefined, never, never>;
+  projectUpdated: (input: ProjectUpdatedInput) => Effect.Effect<undefined, never, never>;
+  update: (sessionId: string & import("effect/Brand").Brand<"Session.ID">, id: string & import("effect/Brand").Brand<"Message.ID">, patch: UpdatePatch) => Effect.Effect<Option.Option<Admitted>, never, never>;
+  cancel: (sessionId: string & import("effect/Brand").Brand<"Session.ID">, id: string & import("effect/Brand").Brand<"Message.ID">) => Effect.Effect<boolean, never, never>;
+  pending: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Admitted[], never, never>;
+  hasPending: (sessionId: string & import("effect/Brand").Brand<"Session.ID">, delivery: "followUp" | "steer") => Effect.Effect<boolean, never, never>;
+  promoteSteers: (sessionId: string & import("effect/Brand").Brand<"Session.ID">, cutoff: number) => Effect.Effect<number, never, never>;
+  promoteFollowUp: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<boolean, never, never>;
+}, never, Service$17 | SqlClient.SqlClient>;
 declare namespace control_d_exports {
-  export { control_d_exports as Control, Interface, PromptConflictError, PromptInput$1 as PromptInput, Service$1 as Service, layer$3 as layer };
+  export { control_d_exports as Control, Interface, PromptConflictError, PromptInput$1 as PromptInput, RESTART_LIMIT, Service$1 as Service, layer$3 as layer };
 }
 declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"PromptConflictError", {
   readonly sessionId: Schema.String;
@@ -3449,6 +3633,11 @@ interface PromptInput$1 {
   /** Defaults to "steer": join the running turn rather than waiting for the next. */
   readonly delivery?: Delivery;
 }
+/**
+ * Times a run may be cut off by a dying process before the session is parked instead of resumed.
+ * A committed turn starts the count over.
+ */
+declare const RESTART_LIMIT = 5;
 interface Interface {
   /**
    * Records a prompt in the session's durable inbox, then wakes its drain.
@@ -3478,6 +3667,22 @@ interface Interface {
   }) => Effect.Effect<boolean>;
   /** Sessions this process is currently draining. */
   readonly active: Effect.Effect<ReadonlySet<ID$1>>;
+  /**
+   * Resumes the runs the last process left unfinished, as the server starts. One a crash cut off
+   * counts a restart, one a shutdown closed does not; at {@link RESTART_LIMIT} the session is parked
+   * and waits for its next prompt. Resolves once every resumed run has settled.
+   */
+  readonly resumeUnfinished: Effect.Effect<void>;
+  /** Prompts admitted but not yet in the conversation, steers and follow-ups, in admission order. */
+  readonly pending: (sessionId: ID$1) => Effect.Effect<ReadonlyArray<Admitted>>;
+  /**
+   * Moves a pending prompt to the other lane or rewrites it, keeping its place; false when it was
+   * already promoted, cancelled, or is unknown. Asking for the steer lane also wakes the session, so
+   * a prompt left waiting by a stop or a failure runs now.
+   */
+  readonly update: (sessionId: ID$1, id: ID, patch: UpdatePatch) => Effect.Effect<boolean>;
+  /** Withdraws a pending prompt; false when it was already promoted, cancelled, or is unknown. */
+  readonly cancel: (sessionId: ID$1, id: ID) => Effect.Effect<boolean>;
 }
 declare const Service_base: Context.ServiceClass<Service$1, "@codeworksh/harness/control/Service", Interface>;
 declare class Service$1 extends Service_base {}
@@ -3546,6 +3751,7 @@ declare const models: Effect.Effect<Partial<Record<string, Record<string, {
     supportsOpenAIGrammarTools?: boolean;
     supportsThinkingTokenBudget?: boolean;
     forceAdaptiveThinking?: boolean;
+    supportsTemperature?: boolean;
     thinkingTokenBudgetField?: string;
   };
   contextWindow: number;
@@ -3653,6 +3859,7 @@ declare const effective: (declared: readonly schema_d_exports$4.DeclaredModel[])
     supportsOpenAIGrammarTools?: boolean;
     supportsThinkingTokenBudget?: boolean;
     forceAdaptiveThinking?: boolean;
+    supportsTemperature?: boolean;
     thinkingTokenBudgetField?: string;
   };
   contextWindow: number;
@@ -3997,6 +4204,10 @@ interface CreateInput extends RuntimeInput {
    * own directory. {@link link} assigns one afterwards.
    */
   readonly hostDir?: string;
+  /** Names the session's project if this creates it; an existing project keeps its name. */
+  readonly project?: {
+    readonly name: string;
+  };
 }
 interface AttachInput extends RuntimeInput {
   readonly sessionId: ID$1;
@@ -4029,6 +4240,25 @@ interface Info$1 {
    */
   readonly hasHostLink: boolean;
   readonly sandbox?: Info$2;
+  /** Absent only when the session's space or project row is missing. */
+  readonly project?: {
+    readonly id: schema_d_exports$9.ProjectSchema.ID;
+    readonly name: string;
+  };
+  /** Last activity, epoch milliseconds: every appended entry moves it. */
+  readonly updatedAt: number;
+  /** The model chosen for this session over settings; absent when settings decide. */
+  readonly model?: {
+    readonly provider: string;
+    readonly id: string;
+  };
+  /** The thinking level chosen for this session over settings; absent when settings decide. */
+  readonly thinkingLevel?: Model.ThinkingLevel;
+  /**
+   * Its unfinished run was cut off {@link Control.RESTART_LIMIT} times, so the server no longer
+   * resumes it; the next prompt runs it again.
+   */
+  readonly parked: boolean;
 }
 interface Handle {
   readonly id: ID$1;
@@ -4054,6 +4284,17 @@ declare const create$1: (input?: CreateInput | undefined) => Effect.Effect<{
     hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
     hasHostLink: boolean;
     sandbox?: instance_d_exports.SandboxInstance.Info;
+    project?: {
+      id: string & import("effect/Brand").Brand<"Project.ID">;
+      name: string;
+    };
+    updatedAt: number;
+    model?: {
+      readonly provider: string;
+      readonly id: string;
+    };
+    thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+    parked: boolean;
   }, SessionNotFoundError, never>;
   prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
   run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4082,6 +4323,17 @@ declare const link: (input: {
     hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
     hasHostLink: boolean;
     sandbox?: instance_d_exports.SandboxInstance.Info;
+    project?: {
+      id: string & import("effect/Brand").Brand<"Project.ID">;
+      name: string;
+    };
+    updatedAt: number;
+    model?: {
+      readonly provider: string;
+      readonly id: string;
+    };
+    thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+    parked: boolean;
   }, SessionNotFoundError, never>;
   prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
   run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4108,6 +4360,17 @@ declare const relink: (input: RelinkInput) => Effect.Effect<{
     hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
     hasHostLink: boolean;
     sandbox?: instance_d_exports.SandboxInstance.Info;
+    project?: {
+      id: string & import("effect/Brand").Brand<"Project.ID">;
+      name: string;
+    };
+    updatedAt: number;
+    model?: {
+      readonly provider: string;
+      readonly id: string;
+    };
+    thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+    parked: boolean;
   }, SessionNotFoundError, never>;
   prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
   run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4126,7 +4389,7 @@ declare const attach: (input: AttachInput) => Effect.Effect<Handle, SessionNotFo
  */
 declare const configuration: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Configuration, ModelCatalogError | ModelNotFoundError | ProviderError | SessionNotFoundError | SettingsError, Service$16 | Service$5>;
 declare namespace list_d_exports {
-  export { ConfigChanged, Definitions, DurableDefinitions, list_d_exports as EventList, ExecutionFailed, ExecutionInterrupted, ExecutionStarted, ExecutionSucceeded, LLMEnded, LLMFailed, LLMStarted, LLMTextDelta, LLMTextEnd, LLMTextStart, LLMThinkingDelta, LLMThinkingEnd, LLMThinkingStart, PluginUpdated, PromptAdmitted, Prompted, PublicDefinitions, RetryFinished, RetryScheduled, SessionForked, ToolProgress, ToolSettled, ToolStarted, TurnAbortCause, TurnAborted, TurnEnded, TurnStarted };
+  export { ConfigChanged, Definitions, DurableDefinitions, list_d_exports as EventList, ExecutionFailed, ExecutionInterrupted, ExecutionStarted, ExecutionSucceeded, LLMEnded, LLMFailed, LLMStarted, LLMTextDelta, LLMTextEnd, LLMTextStart, LLMThinkingDelta, LLMThinkingEnd, LLMThinkingStart, PluginUpdated, PromptAdmitted, PromptCancelled, PromptUpdated, Prompted, PublicDefinitions, RetryFinished, RetryScheduled, SessionForked, ToolProgress, ToolSettled, ToolStarted, TurnAbortCause, TurnAborted, TurnEnded, TurnStarted };
 }
 declare const PromptAdmitted: Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -4350,6 +4613,229 @@ declare const Prompted: Schema.Struct<{
   }>;
 };
 type Prompted = typeof Prompted.Type;
+/** A pending prompt withdrawn before promotion; it never enters the conversation. */
+declare const PromptCancelled: Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.cancelled">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}> & {
+  type: "session.prompt.cancelled";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+};
+type PromptCancelled = typeof PromptCancelled.Type;
+/**
+ * A pending prompt moved to the other lane or rewritten before promotion; it keeps its place. Only
+ * what changed is carried, so two updates of different fields both stand.
+ */
+declare const PromptUpdated: Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.updated">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: 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 prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
+  }>;
+}> & {
+  type: "session.prompt.updated";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: 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 prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
+  }>;
+};
+type PromptUpdated = typeof PromptUpdated.Type;
 declare const ConfigChanged: Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
     create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -9708,14 +10194,275 @@ declare const Definitions: readonly [Schema.Struct<{
       ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
       create: () => string & import("effect/Brand").Brand<"Session.ID">;
     };
-    readonly reason: Schema.Literals<readonly ["user", "shutdown"]>;
+    readonly reason: Schema.Literals<readonly ["user", "shutdown"]>;
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.admitted">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
+    };
+    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+    prompt: Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}> & {
+  type: "session.prompt.admitted";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
+    };
+    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+    prompt: Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.promoted">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
+    };
+    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+    prompt: Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}> & {
+  type: "session.prompt.promoted";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
+    };
+    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+    prompt: Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.cancelled">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}> & {
+  type: "session.prompt.cancelled";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
   }>;
 }, Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
     create: () => string & import("effect/Brand").Brand<"Event.ID">;
   };
   readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
-  readonly type: Schema.Literal<"session.prompt.admitted">;
+  readonly type: Schema.Literal<"session.prompt.updated">;
   readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
     readonly aggregateId: Schema.String;
     readonly seq: Schema.Int;
@@ -9726,16 +10473,16 @@ declare const Definitions: readonly [Schema.Struct<{
     readonly version: Schema.Int;
   }>>, never, never>;
   readonly data: Schema.Struct<{
-    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
     };
-    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
       create: () => string & import("effect/Brand").Brand<"Message.ID">;
       from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
     };
-    prompt: Schema.Struct<{
+    readonly prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
       readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
@@ -9766,26 +10513,7 @@ declare const Definitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
-  }>;
-}> & {
-  type: "session.prompt.admitted";
-  durable?: {
-    readonly version: number;
-    readonly aggregate: string;
-  };
-  data: Schema.Struct<{
-    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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">;
-    };
-    messageId: Schema.brand<Schema.String, "Message.ID"> & {
-      create: () => string & import("effect/Brand").Brand<"Message.ID">;
-      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
-    };
-    prompt: Schema.Struct<{
+    }>>, Schema.optionalKey<Schema.Struct<{
       readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
@@ -9816,35 +10544,26 @@ declare const Definitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
   }>;
-}, Schema.Struct<{
-  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+}> & {
+  type: "session.prompt.updated";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
   };
-  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
-  readonly type: Schema.Literal<"session.prompt.promoted">;
-  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-    readonly aggregateId: Schema.String;
-    readonly seq: Schema.Int;
-    readonly version: Schema.Int;
-  }>>>, Schema.optionalKey<Schema.Struct<{
-    readonly aggregateId: Schema.String;
-    readonly seq: Schema.Int;
-    readonly version: Schema.Int;
-  }>>, never, never>;
-  readonly data: Schema.Struct<{
-    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
     };
-    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
       create: () => string & import("effect/Brand").Brand<"Message.ID">;
       from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
     };
-    prompt: Schema.Struct<{
+    readonly prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
       readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
@@ -9875,26 +10594,7 @@ declare const Definitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
-  }>;
-}> & {
-  type: "session.prompt.promoted";
-  durable?: {
-    readonly version: number;
-    readonly aggregate: string;
-  };
-  data: Schema.Struct<{
-    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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">;
-    };
-    messageId: Schema.brand<Schema.String, "Message.ID"> & {
-      create: () => string & import("effect/Brand").Brand<"Message.ID">;
-      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
-    };
-    prompt: Schema.Struct<{
+    }>>, Schema.optionalKey<Schema.Struct<{
       readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
@@ -9925,8 +10625,8 @@ declare const Definitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
   }>;
 }, Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -15223,26 +15923,209 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}> & {
+  type: "session.prompt.promoted";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
+    };
+    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+    prompt: Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    };
+    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.cancelled">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}> & {
+  type: "session.prompt.cancelled";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.updated">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: 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 prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
   }>;
 }> & {
-  type: "session.prompt.promoted";
+  type: "session.prompt.updated";
   durable?: {
     readonly version: number;
     readonly aggregate: string;
   };
   data: Schema.Struct<{
-    timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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">;
     };
-    messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
       create: () => string & import("effect/Brand").Brand<"Message.ID">;
       from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
     };
-    prompt: Schema.Struct<{
+    readonly prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
       readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
@@ -15273,8 +16156,39 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
         })[];
       };
       text: (prompt: Prompt) => string;
-    };
-    delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
   }>;
 }, Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -20467,6 +21381,220 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
     };
     delivery: Schema.Literals<readonly ["steer", "followUp"]>;
   }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.cancelled">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}> & {
+  type: "session.prompt.cancelled";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: Schema.brand<Schema.String, "Message.ID"> & {
+      create: () => string & import("effect/Brand").Brand<"Message.ID">;
+      from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+    };
+  }>;
+}, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Event.ID">;
+  };
+  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+  readonly type: Schema.Literal<"session.prompt.updated">;
+  readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly aggregateId: Schema.String;
+    readonly seq: Schema.Int;
+    readonly version: Schema.Int;
+  }>>, never, never>;
+  readonly data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: 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 prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
+  }>;
+}> & {
+  type: "session.prompt.updated";
+  durable?: {
+    readonly version: number;
+    readonly aggregate: string;
+  };
+  data: Schema.Struct<{
+    readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    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 messageId: 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 prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>>, Schema.optionalKey<Schema.Struct<{
+      readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+      }>]>>;
+    }> & {
+      equivalence: import("effect/Equivalence").Equivalence<{
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      }>;
+      fromText: (text: string) => {
+        readonly parts: readonly ({
+          readonly type: "text";
+          readonly text: string;
+        } | {
+          readonly type: "image";
+          readonly data: string;
+          readonly mimeType: string;
+        })[];
+      };
+      text: (prompt: Prompt) => string;
+    }>, never, never>;
+    readonly delivery: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["steer", "followUp"]>>>, Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>, never, never>;
+  }>;
 }, Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "Event.ID"> & {
     create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -25063,5 +26191,5 @@ type DateTimeUtcFromMillis = import__codeworksh_plugin_schema.DateTimeUtcFromMil
 type EventSchema = import__codeworksh_plugin_event.EventSchema;
 type SandboxError = import__codeworksh_plugin_sandbox_errors.SandboxError;
 type optional = import__codeworksh_plugin_schema.optional;
-export { control_d_exports as Control, db_d_exports as Database, DateTimeUtcFromMillis, event_d_exports as Event, list_d_exports as EventList, registry_d_exports as EventRegistry, EventSchema, global_d_exports as Global, harness_d_exports as Harness, location_d_exports as Location, catalog_d_exports as ModelCatalog, index_d_exports as Plugin, schema_d_exports as PromptSchema, run_d_exports as Runner, sandbox_d_exports as Sandbox, SandboxError, session_d_exports as Session, session_d_exports$1 as SessionStore, settings_d_exports as Settings, state_d_exports as State, tool_d_exports as Tool, optional };
+export { control_d_exports as Control, db_d_exports as Database, DateTimeUtcFromMillis, event_d_exports as Event, list_d_exports as EventList, registry_d_exports as EventRegistry, EventSchema, global_d_exports as Global, harness_d_exports as Harness, location_d_exports as Location, catalog_d_exports as ModelCatalog, index_d_exports as Plugin, project_d_exports as Project, schema_d_exports as PromptSchema, run_d_exports as Runner, sandbox_d_exports as Sandbox, SandboxError, session_d_exports as Session, session_d_exports$1 as SessionStore, settings_d_exports as Settings, state_d_exports as State, tool_d_exports as Tool, optional };
 //# sourceMappingURL=effect.d.mts.map