@codeworksh/harness 0.0.1-dev.20260923035712 → 0.0.1-dev.20260925125142

package/README.md

@@ -212,7 +212,7 @@ Vercel and Daytona are the first remote drivers. More providers can be added beh
 - Node.js 24.14.1 or newer
 - An API key for the model provider you select, or OAuth credentials created with
   `codework auth login --openai-codex` / `codework auth login --github-copilot`
-- A generated Aikit model catalog; run `codework models generate` from the project you want to use
+- Network access to models.dev the first time: the model catalog is downloaded into `<home>/models.gen.json` on demand
 
 ## CLI
 
@@ -221,8 +221,6 @@ Run the current development release without installing it globally:
 ```sh
 export OPENAI_API_KEY="..."
 
-pnpm dlx @codeworksh/harness@dev models generate
-
 pnpm dlx @codeworksh/harness@dev \
   --home .codework-beta \
   run --cwd "$PWD" --provider openai --model gpt-5.5 --thinking high \
@@ -244,7 +242,7 @@ cache    9,600 read · 0 write
 cost     $0.014200 · 1 turn
 ```
 
-`codework models generate [path]` uses Aikit's model generator and writes `./models.gen.json` by default. Set `CODEWORK_MODELS_FILE` or pass a path when you keep the catalog elsewhere.
+The model catalog lives at `<home>/models.gen.json` and is refreshed once it is older than 15 minutes; `codework models refresh --force` downloads it now. Set `CODEWORK_MODELS_FILE` to pin a catalog you manage yourself.
 
 The CLI prints the session ID to stderr. Provider, model, and thinking settings are stored with the session, so use the same home directory and session ID to continue it:
 

package/effect.d.mts

@@ -498,7 +498,7 @@ declare const SessionEntryPartRow_base: import("effect/unstable/schema/VariantSc
 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$18 as layer };
+  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 };
 }
 type SerializedEvent = {
   readonly id: schema_d_exports$10.ID;
@@ -654,7 +654,7 @@ interface Interface$17 {
 }
 declare const Service_base$15: Context.ServiceClass<Service$17, "@codeworksh/harness/event/event/Service", Interface$17>;
 declare class Service$17 extends Service_base$15 {}
-declare const layer$18: Layer.Layer<Service$17, never, SqlClient.SqlClient>;
+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";
@@ -711,7 +711,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$7 as defaultLayer, entryStates, entryTypes, layer$17 as layer, messageEntryTypes, partTypes, rebaseDirectory, toolStatuses };
+  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$7 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;
@@ -926,7 +926,7 @@ interface Interface$16 {
 }
 declare const Service_base$14: Context.ServiceClass<Service$16, "@codeworksh/harness/session/session/Service", Interface$16>;
 declare class Service$16 extends Service_base$14 {}
-declare const layer$17: Layer.Layer<Service$16, never, Service$17 | SqlClient.SqlClient>;
+declare const layer$18: Layer.Layer<Service$16, never, Service$17 | SqlClient.SqlClient>;
 declare const defaultLayer$7: Layer.Layer<Service$16, import("effect/Config").ConfigError, Service$17>;
 //#endregion
 //#region src/context/errors.d.ts
@@ -947,9 +947,9 @@ declare const ContextInvariantError_base: Schema.Class<ContextInvariantError, Sc
 }>, import("effect/Cause").YieldableError>;
 declare class ContextInvariantError extends ContextInvariantError_base {}
 declare namespace db_d_exports {
-  export { db_d_exports as Database, SqlClient$1 as SqlClient, SqlSchema$1 as SqlSchema, defaultLayer$6 as defaultLayer, layer$16 as layer, locationConfig, path, resolveDatabaseLocation };
+  export { db_d_exports as Database, SqlClient$1 as SqlClient, SqlSchema$1 as SqlSchema, defaultLayer$6 as defaultLayer, layer$17 as layer, locationConfig, path, resolveDatabaseLocation };
 }
-declare function layer$16(location: string): Layer.Layer<SqlClient.SqlClient | SqliteClient.SqliteClient, never, never>;
+declare function layer$17(location: string): Layer.Layer<SqlClient.SqlClient | SqliteClient.SqliteClient, never, never>;
 declare const locationConfig: Config.Config<string>;
 declare function resolveDatabaseLocation(configured: string, data: string): string;
 declare const path: (data?: string | undefined) => Effect.Effect<string, Config.ConfigError, never>;
@@ -960,7 +960,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$15 as layer, make$5 as make };
+  export { DriverInfo, Registry, RegistryService, registry_d_exports$1 as SandboxDriverRegistry, layer$16 as layer, make$5 as make };
 }
 interface DriverInfo {
   readonly name: driver_d_exports.SandboxDriver.Name;
@@ -982,9 +982,9 @@ 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 layer$15: (...drivers: ReadonlyArray<driver_d_exports.SandboxDriver.Registration>) => Layer.Layer<Registry, errors_d_exports.SandboxDriverRegistrationError, never>;
+declare const layer$16: (...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$14 as layer, make$4 as make };
+  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$15 as layer, make$4 as make };
 }
 interface CreateInput$2<CreateConfig, RuntimeConfig extends driver_d_exports.SandboxDriver.RuntimeConfigBase> {
   readonly driver: driver_d_exports.SandboxDriver.Definition<CreateConfig, RuntimeConfig>;
@@ -1036,7 +1036,7 @@ interface Options$5 {
   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 layer$14: (options: Options$5) => Layer.Layer<Controller, errors_d_exports.SandboxDriverRegistrationError, Registry | SqlClient.SqlClient>;
+declare const layer$15: (options: Options$5) => Layer.Layer<Controller, errors_d_exports.SandboxDriverRegistrationError, Registry | SqlClient.SqlClient>;
 //#endregion
 //#region src/sandbox/sandbox.d.ts
 /**
@@ -1053,7 +1053,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$13 as layer, layerWith$6 as layerWith, resolvePath };
+  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$14 as layer, layerWith$6 as layerWith, resolvePath };
 }
 declare const AppProcessError_base: Schema.Class<AppProcessError, Schema.TaggedStruct<"AppProcessError", {
   readonly command: Schema.String;
@@ -1098,7 +1098,7 @@ interface Interface$14 {
 }
 declare const Service_base$13: Context.ServiceClass<Service$15, "@codeworksh/harness/git/git/Service", Interface$14>;
 declare class Service$15 extends Service_base$13 {}
-declare const layer$13: Layer.Layer<Service$15, never, import("@codeworksh/plugin/sandbox/shell").Shell>;
+declare const layer$14: Layer.Layer<Service$15, never, import("@codeworksh/plugin/sandbox/shell").Shell>;
 /**
  * Run git inside the given sandbox — local, remote, or virtual. Every command
  * goes through the sandbox shell, so git never executes anywhere other than
@@ -1114,7 +1114,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$12 as layer, layerWith$5 as layerWith, normalize };
+  export { Identity, Interface$13 as Interface, MARKER, repo_d_exports as Repo, Service$14 as Service, defaultLayer$4 as defaultLayer, layer$13 as layer, layerWith$5 as layerWith, normalize };
 }
 /** Per-clone file under the store that pins the project id (see PROJECT.md §1 "marker"). */
 declare const MARKER = "codework";
@@ -1139,11 +1139,11 @@ declare class Service$14 extends Service_base$12 {}
  * `file:` urls and empty input yield undefined.
  */
 declare function normalize(url: string): string | undefined;
-declare const layer$12: Layer.Layer<Service$14, never, import("@codeworksh/plugin/sandbox/filesystem").Service | Service$15>;
+declare const layer$13: Layer.Layer<Service$14, never, import("@codeworksh/plugin/sandbox/filesystem").Service | Service$15>;
 declare const layerWith$5: <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$11 as layer, layerWith$4 as layerWith };
+  export { AbsorbInput, Interface$12 as Interface, RehomeInput, Service$13 as Service, space_d_exports as Space, archiveEnv, fromRow, id, layer$12 as layer, layerWith$4 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;
@@ -1182,10 +1182,10 @@ declare const fromRow: (row: SpaceRow) => schema_d_exports$7.SpaceSchema.Info;
  * Write-first so a DEFERRED transaction takes the write lock immediately.
  */
 declare const archiveEnv: (env: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<void, never, SqlClient.SqlClient>;
-declare const layer$11: Layer.Layer<Service$13, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | SqlClient.SqlClient>;
+declare const layer$12: Layer.Layer<Service$13, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | SqlClient.SqlClient>;
 declare const layerWith$4: <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$10 as layer, layerWith$3 as layerWith };
+  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$11 as layer, layerWith$3 as layerWith };
 }
 declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"Worktree.WorktreeError", {
   readonly operation: Schema.Literals<readonly ["add", "remove", "list"]>;
@@ -1214,11 +1214,11 @@ interface Interface$11 {
 }
 declare const Service_base$10: Context.ServiceClass<Service$12, "@codeworksh/harness/worktree/worktree/Service", Interface$11>;
 declare class Service$12 extends Service_base$10 {}
-declare const layer$10: Layer.Layer<Service$12, never, import("@codeworksh/plugin/sandbox/filesystem").Service | Service$15>;
+declare const layer$11: Layer.Layer<Service$12, never, import("@codeworksh/plugin/sandbox/filesystem").Service | Service$15>;
 declare const layerWith$3: <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$9 as layer, layerWith$2 as layerWith, provisional };
+  export { Interface$10 as Interface, project_d_exports as Project, Resolved$2 as Resolved, Service$11 as Service, defaultLayer$2 as defaultLayer, layer$10 as layer, layerWith$2 as layerWith, provisional };
 }
 /** 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;
@@ -1237,14 +1237,14 @@ interface Interface$10 {
 }
 declare const Service_base$9: Context.ServiceClass<Service$11, "@codeworksh/harness/project/project/Service", Interface$10>;
 declare class Service$11 extends Service_base$9 {}
-declare const layer$9: 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 layer$10: Layer.Layer<Service$11, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | Service$13 | Service$14 | Service$12 | SqlClient.SqlClient>;
 /** Takes an assembled sandbox — local or remote — not a local backend. */
 declare const layerWith$2: <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, Ref$2 as Ref, Service$10 as Service, defaultLayer$1 as defaultLayer, layer$8 as layer, layerMounted, layerWith$1 as layerWith };
+  export { DirectoryNotFoundError, Error, Info$5 as Info, Interface$9 as Interface, location_d_exports as Location, NotDirectoryError, Ref$2 as Ref, Service$10 as Service, defaultLayer$1 as defaultLayer, layer$9 as layer, layerMounted, layerWith$1 as layerWith };
 }
-declare const layer$8: (ref?: Ref$1) => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | Service$11>;
+declare const layer$9: (ref?: Ref$1) => 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
@@ -1254,7 +1254,7 @@ declare const layerMounted: (ref?: Ref$1) => Layer.Layer<Service, import("@codew
 declare const layerWith$1: <E, RIn>(ref: Ref$1, sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service, E | import("effect/Config").ConfigError | import("@codeworksh/plugin/location").Error, Exclude<RIn, SqlClient$1.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient>>;
 declare const defaultLayer$1: (ref: Ref$1, path: string) => Layer.Layer<Service, import("effect/Config").ConfigError | import("@codeworksh/plugin/location").Error, never>;
 declare namespace global_d_exports {
-  export { global_d_exports as Global, Interface$8 as Interface, Service$9 as Service, app, appConfigDir, authFile, defaultLayer, homeConfig, layer$7 as layer, layerWith, make$3 as make, resolve$3 as resolve };
+  export { global_d_exports as Global, Interface$8 as Interface, Service$9 as Service, app, appConfigDir, authFile, defaultLayer, homeConfig, layer$8 as layer, layerWith, make$3 as make, resolve$3 as resolve };
 }
 declare const appConfigDir = ".codework";
 declare const app = "codework";
@@ -1279,14 +1279,18 @@ declare function make$3(input?: Partial<Interface$8>): Interface$8;
  */
 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 layer$7: Layer.Layer<Service$9, Config.ConfigError, never>;
+declare const layer$8: Layer.Layer<Service$9, Config.ConfigError, never>;
 declare const defaultLayer: Layer.Layer<Service$9, Config.ConfigError, never>;
 declare const layerWith: (input: Partial<Interface$8>) => 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$6 as layer, load$1 as load, parse$1 as parse, paths, projectRoot };
+  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$7 as layer, load$1 as load, modules, parse$1 as parse, paths, projectRoot, userConfigDir };
 }
 interface Options$4 {
+  /**
+   * `--user-config-dir`, already absolute ({@link userConfigDir}): the directory whose settings
+   * file replaces the user layer's.
+   */
   readonly userConfigDir?: string;
   /**
    * The host directory this load discovers the project layer from, supplied by the caller --
@@ -1302,6 +1306,12 @@ interface Options$4 {
    */
   readonly hostDir?: string | undefined;
 }
+/**
+ * An app-level `--user-config-dir` as the absolute directory it names: `~` is the user's home, and
+ * a relative spelling is relative to `hostCwd` -- never to a session's `hostDir`, which is not
+ * where the flag was typed.
+ */
+declare const userConfigDir: (raw: string, hostCwd: string) => string;
 /**
  * The project a directory is in: the nearest ancestor holding a `.codework` **directory**.
  *
@@ -1336,9 +1346,8 @@ declare function paths(input: {
   readonly home: string;
   /** The project root, from {@link projectRoot}. */
   readonly root?: string | undefined;
-  /** What a relative `--user-config-dir` is resolved against. */
-  readonly from?: string | undefined;
-  readonly custom?: string | undefined;
+  /** `--user-config-dir`, absolute ({@link userConfigDir}): replaces the home's settings. */
+  readonly userConfigDir?: string | undefined;
 }): ReadonlyArray<ReadonlyArray<string>>;
 declare const SettingsError_base: Schema.Class<SettingsError, Schema.TaggedStruct<"SettingsError", {
   readonly path: Schema.String;
@@ -1565,10 +1574,20 @@ declare const load$1: (options: Options$4 & {
   })[];
   declared: readonly schema_d_exports$4.Declared[];
 }, SettingsError, never>;
-declare const layer$6: (options?: Omit<Options$4, "hostDir">) => Layer.Layer<Service$8, never, Service$9>;
+/**
+ * Each module reference once, owned by the **last** file to declare it (D6).
+ *
+ * The owner is not bookkeeping: its `.npmrc` chain keys the store artifact. The CLI that installs
+ * a reference and the runtime that loads it must pick the same owner, or `plugin update` refreshes
+ * an artifact the runtime never reads. Only a string entry loads a module, so only a string entry
+ * owns one -- a `{ package }` patch in another file configures it and must not move its registry.
+ * A reference keeps the position of its first declaration.
+ */
+declare const modules: (declared: ReadonlyArray<schema_d_exports$4.Declared>) => ReadonlyMap<string, schema_d_exports$4.Declared>;
+declare const layer$7: (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$5 as layer };
+  export { EventRegistrationError, registry_d_exports as EventRegistry, Interface$6 as Interface, Service$7 as Service, flatten, layer$6 as layer };
 }
 /**
  * Every event definition this harness knows: the kernel's, plus whatever the
@@ -1598,7 +1617,7 @@ declare class EventRegistrationError extends EventRegistrationError_base {}
  * hide it behind plugin ordering.
  */
 declare const flatten: (plugins: readonly plugin_d_exports.Plugin[]) => Effect.Effect<readonly schema_d_exports$10.EventSchema.Definition<string, Schema.Codec<unknown, unknown, never, never>>[], EventRegistrationError, never>;
-declare const layer$5: (definitions?: ReadonlyArray<schema_d_exports$10.EventSchema.Definition>) => Layer.Layer<Service$7, never, never>;
+declare const layer$6: (definitions?: ReadonlyArray<schema_d_exports$10.EventSchema.Definition>) => Layer.Layer<Service$7, never, never>;
 //#endregion
 //#region src/plugin/error.d.ts
 declare const SourceError_base: Schema.Class<SourceError, Schema.TaggedStruct<"PluginSourceError", {
@@ -1686,6 +1705,11 @@ type Fetchable = Exclude<Target, {
 declare const parse: (reference: string, from: string) => Effect.Effect<Target, SourceError>;
 //#endregion
 //#region src/plugin/loader.d.ts
+/**
+ * The name a local package declares, read without importing it: the alias the catalog registers
+ * for it, so a `{ package }` entry and a command naming the package both reach it.
+ */
+declare const localName: (location: string) => Effect.Effect<string | undefined>;
 interface Options$3 {
   readonly cache: string;
   /**
@@ -1807,7 +1831,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$4 as layer };
+  export { Bindings, Interface$5 as Interface, Service$6 as Service, runtime_d_exports as SessionRuntime, layer$5 as layer };
 }
 /**
  * Per-session configuration, held in process.
@@ -1824,7 +1848,7 @@ interface Interface$5 {
 }
 declare const Service_base$5: Context.ServiceClass<Service$6, "@codeworksh/harness/session/runtime/Service", Interface$5>;
 declare class Service$6 extends Service_base$5 {}
-declare const layer$4: Layer.Layer<Service$6, never, never>;
+declare const layer$5: 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";
@@ -1926,7 +1950,7 @@ interface Resolved$1 {
   readonly handle: Executor["handle"];
 }
 declare namespace state_d_exports {
-  export { 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$3 as layer };
+  export { 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$4 as layer };
 }
 /**
  * How a turn's tool calls are scheduled once the array has been re-read.
@@ -2060,27 +2084,37 @@ declare class Service$5 extends Service_base$4 {}
  * `references` says which entries the config pass walks. It is a function of the settings that
  * exchange read, so a caller that pinned an explicit list keeps it and everyone else follows the
  * files.
+ *
+ * `pool` is the **process view**: what boot loaded from the user layers. A session in a project
+ * runs from that project's own view, a pool created from the process view the first time the
+ * project is seen and moved only by its own sessions. The same spec can be owned by different
+ * files -- and so name different registries -- in two views; one shared pool could hold only one of
+ * those builds, and sessions in different projects would keep evicting each other's.
  */
-declare const layer$3: (options: Options$2, pool: Ref.Ref<Pool>, references: (settings: schema_d_exports$4.Info) => ReadonlyArray<PluginRef>,
+declare const layer$4: (options: Options$2, pool: Ref.Ref<Pool>, references: (settings: schema_d_exports$4.Info) => ReadonlyArray<PluginRef>,
 /**
  * The exchange-boundary check: the new pool when the store has moved, nothing when it has not.
  * State does not know what a store is, so whoever built the pool answers this.
  */
-follow: (refs: ReadonlyArray<PluginRef>, current: Pool, settings: schema_d_exports$4.Info) => Effect.Effect<Option.Option<Pool>, {
+follow: (refs: ReadonlyArray<PluginRef>, current: Pool, settings: schema_d_exports$4.Info,
+/** The view's project root, whose host directory the view resolves against. */
+root: string | undefined) => Effect.Effect<Option.Option<Pool>, {
   readonly message: string;
 }>,
 /**
  * A full load pass, told to re-import even where nothing looks different. Resolve-only, like
  * `follow`: reload re-imports what is on disk, it does not fetch.
  *
- * It takes no references and reads its own settings, because the set it must produce is the
- * *process's* -- every module any session might name -- and State only ever sees one session's
- * view. Handing it `references` from here would quietly narrow the pool to whatever the
- * caller's project declares, and drop every other project's plugins on the floor.
+ * It takes a view rather than references and reads that view's settings itself, because the set
+ * it must produce is the view's -- every module any of its sessions has named -- and State only
+ * ever sees one session. Handing it `references` from here would quietly narrow the pool to
+ * whatever the caller declares, and drop what the view's other sessions loaded on the floor.
  */
-rebuild: () => Effect.Effect<Pool, {
+rebuild: (root: string | undefined, current: Pool) => Effect.Effect<Pool, {
   readonly message: string;
-}>) => Layer.Layer<Service$5, never, Service$17 | Service$16 | Service$8 | Service$7 | Service$6>;
+}>,
+/** 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$17 | Service$16 | Service$8 | 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 };
 }
@@ -2954,7 +2988,7 @@ 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$2 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$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$3 as layer, validateUserMessage };
 }
 type ContextReadError = SessionNotFoundError | ContextDecodeError;
 interface Interface$1 {
@@ -2962,7 +2996,7 @@ interface Interface$1 {
 }
 declare const Service_base$1: Context.ServiceClass<Service$2, "@codeworksh/harness/context/context/Service", Interface$1>;
 declare class Service$2 extends Service_base$1 {}
-declare const layer$2: Layer.Layer<Service$2, never, Service$16>;
+declare const layer$3: Layer.Layer<Service$2, never, Service$16>;
 //#endregion
 //#region src/session/input/schema.d.ts
 declare const Admitted: Schema.Struct<{
@@ -2994,7 +3028,7 @@ declare namespace schema_d_exports$2 {
   export { ID, schema_d_exports$2 as SessionMessageSchema };
 }
 declare namespace control_d_exports {
-  export { control_d_exports as Control, Interface, PromptConflictError, PromptInput$1 as PromptInput, Service$1 as Service, layer$1 as layer };
+  export { control_d_exports as Control, Interface, PromptConflictError, PromptInput$1 as PromptInput, Service$1 as Service, layer$2 as layer };
 }
 declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"PromptConflictError", {
   readonly sessionId: Schema.String;
@@ -3046,7 +3080,7 @@ interface Interface {
 }
 declare const Service_base: Context.ServiceClass<Service$1, "@codeworksh/harness/control/Service", Interface>;
 declare class Service$1 extends Service_base {}
-declare const layer$1: Layer.Layer<Service$1, never, Service$17 | Service$16 | Service$3 | import("effect/unstable/sql/SqlClient").SqlClient>;
+declare const layer$2: Layer.Layer<Service$1, never, Service$17 | Service$16 | Service$3 | import("effect/unstable/sql/SqlClient").SqlClient>;
 declare namespace event_d_exports$1 {
   export { event_d_exports$1 as LLMEventPublisher, Publisher, Terminal, make$1 as make };
 }
@@ -3171,7 +3205,7 @@ interface Options$1 {
 declare const load: (entry: Entry$1, options: Options$1) => Effect.Effect<driver_d_exports.SandboxDriver.Registration, errors_d_exports.SandboxDriverLoadError, never>;
 declare const loadAll: (entries: ReadonlyArray<Entry$1>, options: Options$1) => Effect.Effect<ReadonlyArray<driver_d_exports.SandboxDriver.Registration>, errors_d_exports.SandboxDriverLoadError>;
 declare namespace harness_d_exports {
-  export { harness_d_exports as Harness, Options, layer };
+  export { harness_d_exports as Harness, Options, layer$1 as layer };
 }
 interface Options {
   /**
@@ -3183,20 +3217,33 @@ interface Options {
   readonly database?: string;
   /**
    * The process-level host directory: the default sandbox mount, the `.npmrc`/parse fallback
-   * for plugin references no file declared, and the base a relative `--user-config-dir`
+   * for plugin references no file declared, and the base a relative `home` or `userConfigDir`
    * resolves against. Defaults to the OS process's directory. It is never a project-settings
-   * root -- that discovery belongs to a session's `hostDir`.
+   * root -- that discovery belongs to a session's `hostDir` -- and never a sandbox `cwd`.
    */
   readonly hostCwd?: string;
+  /**
+   * `--home`: the shared, user-wide home -- `~/.codework` by default -- holding the user
+   * settings, credentials, plugin cache and data.
+   */
   readonly home?: string;
-  /** user provided directory containing the highest-priority config. */
+  /**
+   * `--user-config-dir`: a hard override of the user settings file only. Its `settings.jsonc`
+   * is read *instead of* the home's; the project layer still sits above it, and everything else
+   * the home holds stays in the home.
+   */
   readonly userConfigDir?: string;
   readonly sandboxes?: ReadonlyArray<Entry$1>;
   readonly llm?: Open;
+  /**
+   * Keep `<home>/models.gen.json` fresh for the life of the process, as a server does.
+   * Otherwise it is checked once, at boot.
+   */
+  readonly watchModels?: boolean;
 }
-declare const layer: (options?: Options) => Layer.Layer<Controller | Registry | Service$9 | Service$17 | Service$16 | Service$2 | Service$8 | Service$7 | Service$6 | Service$5 | Service$3 | Service$1 | SqlClient$1.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient, import("effect/Config").ConfigError | EventRegistrationError | InstallError | LoadError | import("@codeworksh/plugin/sandbox/errors").SandboxDriverLoadError | import("@codeworksh/plugin/sandbox/errors").SandboxDriverRegistrationError | SettingsError | SourceError | StoreError, never>;
+declare const layer$1: (options?: Options) => Layer.Layer<Controller | Registry | Service$9 | Service$17 | Service$16 | Service$2 | Service$8 | Service$7 | Service$6 | Service$5 | Service$3 | Service$1 | SqlClient$1.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient, import("effect/Config").ConfigError | EventRegistrationError | InstallError | LoadError | import("@codeworksh/plugin/sandbox/errors").SandboxDriverLoadError | import("@codeworksh/plugin/sandbox/errors").SandboxDriverRegistrationError | SettingsError | SourceError | StoreError, never>;
 declare namespace sandbox_d_exports {
-  export { CreateInput$1 as CreateInput, Driver, DriverInfo, Info$2 as Info, RegisterInput, sandbox_d_exports as Sandbox, instance_d_exports.SandboxInstance as SandboxInstance, Selection, create$2 as create, destroy, drivers, get$1 as get, list, refresh, register, resolve$1 as resolve, stop, wake };
+  export { CreateInput$1 as CreateInput, Driver, DriverInfo, Info$2 as Info, RegisterInput, sandbox_d_exports as Sandbox, instance_d_exports.SandboxInstance as SandboxInstance, Selection, create$2 as create, destroy, drivers, get$1 as get, list, refresh$1 as refresh, register, resolve$1 as resolve, stop, wake };
 }
 type Info$2 = instance_d_exports.SandboxInstance.Info;
 type Driver = Entry$1;
@@ -3240,7 +3287,7 @@ declare const list: (input?: {
   readonly driver?: string;
   readonly status?: instance_d_exports.SandboxInstance.Status;
 } | undefined) => Effect.Effect<readonly instance_d_exports.SandboxInstance.Info[], never, Controller>;
-declare const refresh: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<instance_d_exports.SandboxInstance.Info, import("@codeworksh/plugin/sandbox/errors").SandboxRefreshError, Controller>;
+declare const refresh$1: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<instance_d_exports.SandboxInstance.Info, import("@codeworksh/plugin/sandbox/errors").SandboxRefreshError, Controller>;
 declare const wake: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<instance_d_exports.SandboxInstance.Info, import("@codeworksh/plugin/sandbox/errors").SandboxWakeError, Controller>;
 declare const stop: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<instance_d_exports.SandboxInstance.Info, import("@codeworksh/plugin/sandbox/errors").SandboxStopError, Controller>;
 declare const destroy: (id: string & import("effect/Brand").Brand<"SandboxInstance.ID">) => Effect.Effect<void, import("@codeworksh/plugin/sandbox/errors").SandboxDestroyError, Controller>;
@@ -23176,6 +23223,129 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
     }>, Schema.Unknown, never, never>;
   }>;
 }];
+declare namespace catalog_d_exports {
+  export { catalog_d_exports as ModelCatalog, RefreshError, Status, filename, layer, loadError, models, providers, refresh, sync, ttlConfig };
+}
+declare const filename = "models.gen.json";
+/** How old the catalog may get before a check downloads a new one. */
+declare const ttlConfig: Config.Config<Duration.Duration>;
+declare const RefreshError_base: Schema.Class<RefreshError, Schema.TaggedStruct<"ModelCatalog.RefreshError", {
+  readonly path: Schema.String;
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RefreshError extends RefreshError_base {
+  get message(): string;
+}
+interface Status {
+  readonly path: string;
+  /** False when the catalog was fresh enough to keep. */
+  readonly refreshed: boolean;
+}
+/** Download a new catalog for the home when it is missing, older than the TTL, or `force` asks. */
+declare const refresh: (home: string, options?: {
+  readonly force?: boolean;
+} | undefined) => Effect.Effect<{
+  path: string;
+  refreshed: false;
+} | {
+  path: string;
+  refreshed: true;
+}, Config.ConfigError | RefreshError, never>;
+/** Check the home's catalog once, for a command that runs and exits; returns the file aikit reads. */
+declare const sync: (home: string) => Effect.Effect<string, never, never>;
+/**
+ * Check at boot, and with `watch`, keep checking for the life of the layer. A file whose mtime
+ * moved -- refreshed here, by `codework models refresh`, or by hand -- is reloaded, so the
+ * process never serves a catalog older than what is on disk.
+ */
+declare const layer: (options: {
+  readonly home: string;
+  readonly watch: boolean;
+}) => Layer.Layer<never, never, never>;
+/** Translate aikit's catalog failure, or undefined for anything else. */
+declare const loadError: (cause: unknown) => ModelCatalogError | undefined;
+declare const models: Effect.Effect<Partial<Record<string, Record<string, {
+  api?: {
+    id?: string;
+    url?: string;
+    method?: "chat" | "completion" | "completionModel" | "languageModel" | "messages" | "responses";
+  };
+  baseUrl: string;
+  compat?: {
+    supportsThinkingLevel?: boolean;
+    supportsToolSearch?: boolean;
+    supportsAdditionalTools?: boolean;
+    supportsStrictMode?: boolean;
+    supportsOpenAIGrammarTools?: boolean;
+    supportsThinkingTokenBudget?: boolean;
+    forceAdaptiveThinking?: boolean;
+    thinkingTokenBudgetField?: string;
+  };
+  contextWindow: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    tiers?: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      inputTokensAbove: number;
+    }[];
+    serviceTierMultipliers?: Record<string, number>;
+  };
+  headers?: Record<string, string>;
+  id: string;
+  input: ("image" | "text")[];
+  maxTokens: number;
+  name: string;
+  npm?: string;
+  options?: Record<string, unknown>;
+  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+  provider: {
+    id: string;
+    name: string;
+    source: "api" | "config" | "custom" | "env" | "unknown";
+    env: string[];
+    key?: string;
+    options?: Record<string, any>;
+  };
+  providerOptions?: Record<string, unknown>;
+  providerOptionsKey?: string;
+  reasoning: boolean;
+  supportedProtocols?: {
+    anthropic?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    google?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    googleVertex?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    googleVertexAnthropic?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    githubCopilot?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    openai?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    openaiCompatible?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    openaiCodex?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    openrouter?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    xai?: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+  };
+  thinkingBudgets?: {
+    high?: number;
+    low?: number;
+    max?: number;
+    medium?: number;
+    minimal?: number;
+    xhigh?: number;
+  };
+  thinkingLevelMap?: {
+    high?: string | null;
+    low?: string | null;
+    max?: string | null;
+    medium?: string | null;
+    minimal?: string | null;
+    off?: string | null;
+    xhigh?: string | null;
+  };
+}>>>, ModelCatalogError, never>;
+declare const providers: Effect.Effect<string[], ModelCatalogError, never>;
 //#endregion
 //#region src/plugin/host.d.ts
 declare const SetupError_base: Schema.Class<SetupError, Schema.TaggedStruct<"Plugin.SetupError", {
@@ -23263,6 +23433,15 @@ interface Entry extends Marker {
   /** A `file:` URL for the entrypoint, ready to import. */
   readonly url: string;
 }
+/**
+ * The **full** SHA-256 of the source identity: canonical spec plus effective registry for a
+ * registry package, and the canonical spec alone for git.
+ *
+ * Not truncated. The fast path proves a hit by checking that a marker *exists* rather than by
+ * decoding it, and the index is keyed by digest alone, so a truncated digest would let a collision
+ * return the wrong package silently.
+ */
+declare const digest: (target: Fetchable, cache: string, from: string) => Effect.Effect<string, InstallError | import("effect/PlatformError").PlatformError, never>;
 /**
  * Disk-only lookup. No network, no install -- this is what boot uses, and the reason booting
  * offline works.
@@ -23362,11 +23541,11 @@ declare const update: <A>(target: Fetchable, cache: string, options: {
   readonly validated?: A & ({} | null);
 }, InstallError | LoadError | StoreError, never>;
 declare namespace index_d_exports {
-  export { Checked, Config$1 as Config, Entry, Events, Fetchable, InstallError, LoadError, plugin_d_exports.Mount as Mount, plugin_d_exports.Plugin as Plugin, PluginOptions, PluginRef, PluginRegistry, Probe, schema_d_exports$1 as Prompt, PromptResolver, SetupError, SharedPluginContext, SourceError, StoreError, Target, schema_d_exports$3 as Tool, Updated, anchor, canonical, check, plugin_d_exports.define as define, definition, inspect, parse, probe, resolve, required as resolveCached, lock as settingsLock, update };
+  export { Checked, Config$1 as Config, Entry, Events, Fetchable, InstallError, LoadError, plugin_d_exports.Mount as Mount, plugin_d_exports.Plugin as Plugin, PluginOptions, PluginRef, PluginRegistry, Probe, schema_d_exports$1 as Prompt, PromptResolver, SetupError, SharedPluginContext, SourceError, StoreError, Target, schema_d_exports$3 as Tool, Updated, anchor, canonical, check, plugin_d_exports.define as define, definition, digest as identity, inspect, localName, parse, probe, resolve, required as resolveCached, lock as settingsLock, update };
 }
 type DateTimeUtcFromMillis = import__codeworksh_plugin_schema.DateTimeUtcFromMillis;
 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, 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, 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