@codeworksh/harness 0.0.1-dev.20260925163524 → 0.1.0-dev.20261007133219

package/effect.mjs

@@ -3,32 +3,34 @@ import { a as io_exports, i as errors_exports, n as shell_exports, o as instance
 import "./daytona-BAurx6Gp.mjs";
 import "./vercel-C0v5nh20.mjs";
 import { createRequire, registerHooks } from "node:module";
-import { Cause, Clock, Config, Context, Crypto, DateTime, Deferred, Duration, Effect, Encoding, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Option, Path, Predicate, PubSub, Queue, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
+import { Cause, Clock, Config, Context, Crypto, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Option, Path, Predicate, PubSub, Queue, Random, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
+import { Message, Model, getEnvApiKey, llm, stream } from "@codeworksh/aikit";
 import { MessageID as ID, SessionID as ID$1 } from "@codeworksh/plugin/ids";
-import { Migrator, SqlClient, SqlClient as SqlClient$1, SqlError, SqlSchema, SqlSchema as SqlSchema$1 } from "effect/unstable/sql";
+import { Migrator, SqlClient, SqlClient as SqlClient$1, SqlError, SqlSchema, SqlSchema as SqlSchema$1 } from "effect/sql";
 import { uuidv7 } from "uuidv7";
 import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node";
 import * as os from "node:os";
 import { homedir, tmpdir } from "node:os";
 import { NodeChildProcessSpawner, NodeCrypto, NodeFileSystem, NodePath } from "@effect/platform-node";
-import { Model, VariantSchema } from "effect/unstable/schema";
-import { Message, Model as Model$1, llm, stream } from "@codeworksh/aikit";
+import { Model as Model$1, VariantSchema } from "effect/schema";
+import { Hex } from "effect/encoding";
 import { MemoryProvider, RealFSProvider, SqliteProvider, create } from "@platformatic/vfs";
 import fs, { statSync } from "node:fs";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { Bash } from "just-bash";
-import { DirectoryNotFoundError, DirectoryNotFoundError as DirectoryNotFoundError$1, Info, Info as Info$1, NotDirectoryError, NotDirectoryError as NotDirectoryError$1, Ref as Ref$2, Service, Service as Service$8 } from "@codeworksh/plugin/location";
+import { DirectoryNotFoundError, DirectoryNotFoundError as DirectoryNotFoundError$1, Info, Info as Info$1, NotDirectoryError, NotDirectoryError as NotDirectoryError$1, Service, Service as Service$8 } from "@codeworksh/plugin/location";
 import { generateModels } from "@codeworksh/aikit/modelgen";
+import { JsonGitHubCopilotAuthStorage, getGitHubCopilotApiKey } from "@codeworksh/aikit/oauth/github/copilot";
+import { JsonOpenAICodexAuthStorage, getOpenAICodexApiKey } from "@codeworksh/aikit/oauth/openai/codex";
+import { parse, printParseErrorCode } from "jsonc-parser";
+import * as Section from "@codeworksh/plugin/plugin/section";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
 import { Script, constants } from "node:vm";
 import npa from "npm-package-arg";
 import * as AikitFailure from "@codeworksh/aikit/failure";
-import { JsonGitHubCopilotAuthStorage, getGitHubCopilotApiKey } from "@codeworksh/aikit/oauth/github/copilot";
-import { JsonOpenAICodexAuthStorage, getOpenAICodexApiKey } from "@codeworksh/aikit/oauth/openai/codex";
 import "@codeworksh/plugin/tool/error";
-import { parse, printParseErrorCode } from "jsonc-parser";
 //#region src/schema.ts
 var schema_exports$9 = /* @__PURE__ */ __exportAll({});
 import * as import__codeworksh_plugin_schema from "@codeworksh/plugin/schema";
@@ -38,15 +40,46 @@ __reExport(schema_exports$9, import__codeworksh_plugin_schema);
 var schema_exports$8 = /* @__PURE__ */ __exportAll({
 	AssistantEnvelopeUsage: () => AssistantEnvelopeUsage,
 	CompactionData: () => CompactionData,
+	Config: () => Config$1,
+	DEFAULT_TITLE: () => DEFAULT_TITLE,
 	ID: () => ID$1,
 	IDFromDb: () => IDFromDb,
 	InterruptReason: () => InterruptReason,
 	JsonObject: () => JsonObject,
 	MessageEnvelopeIdentity: () => MessageEnvelopeIdentity,
 	SessionSchema: () => schema_exports$8,
-	Usage: () => Usage
+	TITLE_MAX_LENGTH: () => 48,
+	ThinkingLevel: () => ThinkingLevel,
+	Usage: () => Usage,
+	titleFrom: () => titleFrom
 });
 const IDFromDb = Schema.String.pipe(Schema.brand("Session.ID"));
+/** The title of a session created without one; its first prompt replaces it. */
+const DEFAULT_TITLE = "Session";
+/**
+* A title from a prompt: its first non-empty line, whitespace collapsed, cut on a word boundary
+* to {@link TITLE_MAX_LENGTH} characters including the ellipsis. `undefined` for a blank prompt.
+*/
+const titleFrom = (text) => {
+	const line = text.split("\n").map((one) => one.replace(/\s+/g, " ").trim()).find((one) => one.length > 0);
+	if (line === void 0 || line.length <= 48) return line;
+	const cut = line.slice(0, 47);
+	const space = cut.lastIndexOf(" ");
+	return `${(space > 0 ? cut.slice(0, space) : cut).trimEnd()}…`;
+};
+const ThinkingLevel = Schema.Literals(Object.values(Model.ThinkingLevelEnum));
+/**
+* The model and thinking level chosen for a session, over its settings. Every key is optional:
+* an absent one means the session follows its settings. `session.config.changed` carries only the
+* keys it changes, and the `session.config` column holds them merged.
+*/
+const Config$1 = Schema.Struct({
+	model: (0, schema_exports$9.optional)(Schema.Struct({
+		provider: Schema.String,
+		id: Schema.String
+	})),
+	thinkingLevel: (0, schema_exports$9.optional)(ThinkingLevel)
+});
 /**
 * Why an execution stopped. Supplied by whoever asked for the interruption --
 * a stop the user asked for and a stop the process imposed on shutdown are
@@ -101,10 +134,10 @@ var global_exports = /* @__PURE__ */ __exportAll({
 	app: () => app,
 	appConfigDir: () => appConfigDir,
 	authFile: () => authFile,
-	defaultLayer: () => defaultLayer$4,
+	defaultLayer: () => defaultLayer$2,
 	homeConfig: () => homeConfig,
 	layer: () => layer$27,
-	layerWith: () => layerWith$1,
+	layerWith: () => layerWith,
 	make: () => make$18,
 	resolve: () => resolve$3
 });
@@ -150,8 +183,8 @@ const build = (input) => Effect.gen(function* () {
 	return Service$17.of(paths);
 });
 const layer$27 = Layer.effect(Service$17, build({}));
-const defaultLayer$4 = layer$27;
-const layerWith$1 = (input) => Layer.effect(Service$17, build(input));
+const defaultLayer$2 = layer$27;
+const layerWith = (input) => Layer.effect(Service$17, build(input));
 //#endregion
 //#region src/db/migrations.ts
 const migrations = {
@@ -329,6 +362,9 @@ const migrations = {
 	}),
 	"202609190001_session_host_dir": Effect.gen(function* () {
 		yield* (yield* SqlClient.SqlClient)`ALTER TABLE session ADD COLUMN host_dir TEXT`;
+	}),
+	"202609290001_session_config": Effect.gen(function* () {
+		yield* (yield* SqlClient.SqlClient)`ALTER TABLE session ADD COLUMN config TEXT`;
 	})
 };
 //#endregion
@@ -337,7 +373,7 @@ var db_exports = /* @__PURE__ */ __exportAll({
 	Database: () => db_exports,
 	SqlClient: () => SqlClient$1,
 	SqlSchema: () => SqlSchema$1,
-	defaultLayer: () => defaultLayer$3,
+	defaultLayer: () => defaultLayer$1,
 	layer: () => layer$26,
 	locationConfig: () => locationConfig,
 	path: () => path$1,
@@ -371,7 +407,7 @@ const path$1 = Effect.fn("Database.path")(function* (data) {
 	const directory = data ?? (yield* resolve$3()).data;
 	return resolveDatabaseLocation(yield* locationConfig, directory);
 });
-const defaultLayer$3 = Layer.unwrap(path$1().pipe(Effect.map(layer$26)));
+const defaultLayer$1 = Layer.unwrap(path$1().pipe(Effect.map(layer$26)));
 //#endregion
 //#region src/event/schema.ts
 var schema_exports$7 = /* @__PURE__ */ __exportAll({});
@@ -386,13 +422,54 @@ __reExport(schema_exports$6, import__codeworksh_plugin_project);
 //#region src/session/prompt/schema.ts
 var schema_exports = /* @__PURE__ */ __exportAll({
 	Delivery: () => Delivery,
+	IMAGE_MAX_BASE64: () => IMAGE_MAX_BASE64,
+	IMAGE_TYPES: () => IMAGE_TYPES,
+	ImagePart: () => ImagePart,
+	InvalidPromptError: () => InvalidPromptError,
+	Part: () => Part,
 	Prompt: () => Prompt,
-	PromptSchema: () => schema_exports
+	PromptSchema: () => schema_exports,
+	TextPart: () => TextPart,
+	imageProblem: () => imageProblem
+});
+const IMAGE_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+const IMAGE_MAX_BASE64 = 4718592;
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+const imageProblem = (image) => {
+	if (!IMAGE_TYPES.includes(image.mimeType)) return `Unsupported image type ${image.mimeType}; use ${IMAGE_TYPES.join(", ")}`;
+	if (image.data.length > 4718592) return `Image exceeds the ${IMAGE_MAX_BASE64 / 1024 / 1024} MB limit of base64`;
+	if (image.data.length === 0 || image.data.length % 4 !== 0 || !BASE64.test(image.data)) return "Image data is not base64";
+};
+const TextPart = Schema.Struct({
+	type: Schema.Literal("text"),
+	text: Schema.String
 });
-const Prompt = Schema.Struct({ text: Schema.String }).annotate({ identifier: "Prompt" }).pipe((0, schema_exports$9.withStatics)((schema) => ({
+/** aikit's image content: base64 `data` and its `mimeType`. */
+const ImagePart = Schema.Struct({
+	type: Schema.Literal("image"),
+	data: Schema.String,
+	mimeType: Schema.String
+}).check(Schema.makeFilter(imageProblem));
+const Part = Schema.Union([TextPart, ImagePart]);
+/** A user prompt: aikit user-message parts, in the order they were written. */
+const Prompt = Schema.Struct({ parts: Schema.Array(Part).check(Schema.isMinLength(1)) }).annotate({ identifier: "Prompt" }).pipe((0, schema_exports$9.withStatics)((schema) => ({
 	equivalence: Schema.toEquivalence(schema),
-	fromUserMessage: (input) => schema.make({ text: input.text })
+	fromText: (text) => schema.make({ parts: [{
+		type: "text",
+		text
+	}] }),
+	text: (prompt) => prompt.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n\n")
 })));
+var InvalidPromptError = class extends Schema.TaggedError()("InvalidPromptError", { reason: Schema.String }) {
+	get message() {
+		return this.reason;
+	}
+};
 const Delivery = Schema.Literals(["steer", "followUp"]);
 //#endregion
 //#region src/space/schema.ts
@@ -402,8 +479,8 @@ __reExport(schema_exports$5, import__codeworksh_plugin_space);
 //#endregion
 //#region src/db/schema.sql.ts
 const Timestamps = {
-	createdAt: Model.DateTimeInsertFromNumber,
-	updatedAt: Model.DateTimeUpdateFromNumber
+	createdAt: Model$1.DateTimeInsertFromNumber,
+	updatedAt: Model$1.DateTimeUpdateFromNumber
 };
 const Metadata = Schema.Record(Schema.String, Schema.String);
 const entryTypes = [
@@ -441,19 +518,19 @@ const toolStatuses = [
 ];
 const inputDeliveries = ["steer", "followUp"];
 const EventData = Schema.Record(Schema.String, Schema.Unknown);
-Model.Class("EventSequenceRow")({
+Model$1.Class("EventSequenceRow")({
 	aggregateId: Schema.String,
 	seq: Schema.Natural,
-	ownerId: Model.FieldOption(Schema.String)
+	ownerId: Model$1.FieldOption(Schema.String)
 });
-var EventRow = class extends Model.Class("EventRow")({
+var EventRow = class extends Model$1.Class("EventRow")({
 	id: schema_exports$7.EventSchema.ID,
 	aggregateId: Schema.String,
 	seq: Schema.Natural,
 	type: Schema.String,
-	data: Model.JsonFromString(EventData)
+	data: Model$1.JsonFromString(EventData)
 }) {};
-var ProjectRow = class extends Model.Class("ProjectRow")({
+var ProjectRow = class extends Model$1.Class("ProjectRow")({
 	id: Schema.String,
 	name: Schema.String,
 	status: schema_exports$6.ProjectSchema.Status,
@@ -467,81 +544,82 @@ var ProjectRow = class extends Model.Class("ProjectRow")({
 * The host has no row: `local` is reserved and `NULL` is its storage form, so
 * this table only ever holds namespaces something had to provision.
 */
-var SandboxInstanceRow = class extends Model.Class("SandboxInstanceRow")({
+var SandboxInstanceRow = class extends Model$1.Class("SandboxInstanceRow")({
 	id: instance_exports.SandboxInstance.ID,
 	driver: Schema.String,
 	kind: instance_exports.SandboxInstance.Kind,
-	providerResourceId: Model.FieldOption(Schema.String),
-	runtimeConfig: Model.FieldOption(Schema.String),
+	providerResourceId: Model$1.FieldOption(Schema.String),
+	runtimeConfig: Model$1.FieldOption(Schema.String),
 	ownership: instance_exports.SandboxInstance.Ownership,
 	status: instance_exports.SandboxInstance.Status,
-	providerStatus: Model.FieldOption(Schema.String),
-	stateObservedAt: Model.DateTimeFromNumberWithNow,
-	metadata: Model.FieldOption(Model.JsonFromString(Metadata)),
-	lastError: Model.FieldOption(Model.JsonFromString(instance_exports.SandboxInstance.PersistedError)),
-	lastMountedAt: Model.FieldOption(Schema.DateTimeUtcFromMillis),
-	lastUnmountedAt: Model.FieldOption(Schema.DateTimeUtcFromMillis),
-	lastUsedAt: Model.FieldOption(Schema.DateTimeUtcFromMillis),
-	removedAt: Model.FieldOption(Schema.DateTimeUtcFromMillis),
+	providerStatus: Model$1.FieldOption(Schema.String),
+	stateObservedAt: Model$1.DateTimeFromNumberWithNow,
+	metadata: Model$1.FieldOption(Model$1.JsonFromString(Metadata)),
+	lastError: Model$1.FieldOption(Model$1.JsonFromString(instance_exports.SandboxInstance.PersistedError)),
+	lastMountedAt: Model$1.FieldOption(Schema.DateTimeUtcFromMillis),
+	lastUnmountedAt: Model$1.FieldOption(Schema.DateTimeUtcFromMillis),
+	lastUsedAt: Model$1.FieldOption(Schema.DateTimeUtcFromMillis),
+	removedAt: Model$1.FieldOption(Schema.DateTimeUtcFromMillis),
 	...Timestamps
 }) {};
-var SpaceRow = class extends Model.Class("SpaceRow")({
+var SpaceRow = class extends Model$1.Class("SpaceRow")({
 	id: Schema.String,
 	projectId: Schema.String,
 	location: schema_exports$9.AbsolutePath,
 	kind: schema_exports$5.SpaceSchema.Kind,
-	env: Model.FieldOption(instance_exports.SandboxInstance.ID),
+	env: Model$1.FieldOption(instance_exports.SandboxInstance.ID),
 	status: schema_exports$5.SpaceSchema.Status,
 	...Timestamps
 }) {};
-var SessionRow = class extends Model.Class("SessionRow")({
+var SessionRow = class extends Model$1.Class("SessionRow")({
 	id: IDFromDb,
 	spaceId: Schema.String,
-	parentId: Model.FieldOption(IDFromDb),
+	parentId: Model$1.FieldOption(IDFromDb),
 	slug: Schema.String,
 	directory: schema_exports$9.AbsolutePath,
-	hostDir: Model.FieldOption(schema_exports$9.AbsolutePath),
+	hostDir: Model$1.FieldOption(schema_exports$9.AbsolutePath),
+	config: Model$1.FieldOption(Model$1.JsonFromString(Config$1)),
 	title: Schema.String,
-	tag: Model.FieldOption(Schema.String),
-	metadata: Model.FieldOption(Model.JsonFromString(Metadata)),
-	leafEntryId: Model.FieldOption(Schema.String),
-	cost: Model.GeneratedByDb(Schema.Finite),
-	tokensInput: Model.GeneratedByDb(Schema.Int),
-	tokensOutput: Model.GeneratedByDb(Schema.Int),
-	tokensCacheRead: Model.GeneratedByDb(Schema.Int),
-	tokensCacheWrite: Model.GeneratedByDb(Schema.Int),
+	tag: Model$1.FieldOption(Schema.String),
+	metadata: Model$1.FieldOption(Model$1.JsonFromString(Metadata)),
+	leafEntryId: Model$1.FieldOption(Schema.String),
+	cost: Model$1.GeneratedByDb(Schema.Finite),
+	tokensInput: Model$1.GeneratedByDb(Schema.Int),
+	tokensOutput: Model$1.GeneratedByDb(Schema.Int),
+	tokensCacheRead: Model$1.GeneratedByDb(Schema.Int),
+	tokensCacheWrite: Model$1.GeneratedByDb(Schema.Int),
 	...Timestamps
 }) {};
-var SessionInputRow = class extends Model.Class("SessionInputRow")({
+var SessionInputRow = class extends Model$1.Class("SessionInputRow")({
 	id: Schema.String,
 	sessionId: IDFromDb,
-	prompt: Model.JsonFromString(Prompt),
+	prompt: Model$1.JsonFromString(Prompt),
 	delivery: Schema.Literals(inputDeliveries),
 	admittedSeq: Schema.Int,
-	promotedSeq: Model.FieldOption(Schema.Int),
-	createdAt: Model.DateTimeInsertFromNumber
+	promotedSeq: Model$1.FieldOption(Schema.Int),
+	createdAt: Model$1.DateTimeInsertFromNumber
 }) {};
-var SessionEntryRow = class extends Model.Class("SessionEntryRow")({
+var SessionEntryRow = class extends Model$1.Class("SessionEntryRow")({
 	id: Schema.String,
 	sessionId: IDFromDb,
-	parentId: Model.FieldOption(Schema.String),
+	parentId: Model$1.FieldOption(Schema.String),
 	seq: schema_exports$9.NonNegativeInt,
 	type: Schema.Literals(entryTypes),
 	state: Schema.Literals(entryStates),
 	data: Schema.String,
-	label: Model.FieldOption(Schema.String),
-	metadata: Model.FieldOption(Model.JsonFromString(Metadata)),
+	label: Model$1.FieldOption(Schema.String),
+	metadata: Model$1.FieldOption(Model$1.JsonFromString(Metadata)),
 	...Timestamps
 }) {};
-var SessionEntryPartRow = class extends Model.Class("SessionEntryPartRow")({
+var SessionEntryPartRow = class extends Model$1.Class("SessionEntryPartRow")({
 	id: Schema.String,
 	entryId: Schema.String,
 	sessionId: IDFromDb,
 	partIndex: Schema.Int,
 	type: Schema.Literals(partTypes),
-	status: Model.FieldOption(Schema.Literals(toolStatuses)),
-	callId: Model.FieldOption(Schema.String),
-	toolName: Model.FieldOption(Schema.String),
+	status: Model$1.FieldOption(Schema.Literals(toolStatuses)),
+	callId: Model$1.FieldOption(Schema.String),
+	toolName: Model$1.FieldOption(Schema.String),
 	data: Schema.String,
 	...Timestamps
 }) {};
@@ -631,6 +709,7 @@ var schema_exports$4 = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/event/list.ts
 var list_exports = /* @__PURE__ */ __exportAll({
+	ConfigChanged: () => ConfigChanged,
 	Definitions: () => Definitions,
 	DurableDefinitions: () => DurableDefinitions,
 	EventList: () => list_exports,
@@ -651,6 +730,8 @@ var list_exports = /* @__PURE__ */ __exportAll({
 	PromptAdmitted: () => PromptAdmitted,
 	Prompted: () => Prompted,
 	PublicDefinitions: () => PublicDefinitions,
+	RetryFinished: () => RetryFinished,
+	RetryScheduled: () => RetryScheduled,
 	SessionForked: () => SessionForked,
 	ToolProgress: () => ToolProgress$2,
 	ToolSettled: () => ToolSettled,
@@ -684,6 +765,14 @@ const Prompted = schema_exports$7.EventSchema.define({
 	...durableOptions,
 	schema: PromptFields
 });
+const ConfigChanged = schema_exports$7.EventSchema.define({
+	type: "session.config.changed",
+	...durableOptions,
+	schema: {
+		...baseOptions,
+		...Config$1.fields
+	}
+});
 const LLMFields = {
 	...baseOptions,
 	messageId: ID
@@ -713,6 +802,30 @@ const TurnAborted = schema_exports$7.EventSchema.define({
 		cause: TurnAbortCause
 	}
 });
+/**
+* A failed provider request will be repeated after `delayMs`. `attempt` counts retries from 1, so
+* the request that failed was attempt `attempt - 1`; the failed draft is already settled.
+*/
+const RetryScheduled = schema_exports$7.EventSchema.define({
+	type: "session.retry.scheduled",
+	schema: {
+		...baseOptions,
+		attempt: schema_exports$9.NonNegativeInt,
+		maxRetries: schema_exports$9.NonNegativeInt,
+		delayMs: schema_exports$9.NonNegativeInt,
+		message: Schema.String
+	}
+});
+/** Once per turn that retried: whether a retry succeeded, after how many. */
+const RetryFinished = schema_exports$7.EventSchema.define({
+	type: "session.retry.finished",
+	schema: {
+		...baseOptions,
+		attempt: schema_exports$9.NonNegativeInt,
+		success: Schema.Boolean,
+		message: (0, schema_exports$9.optional)(Schema.String)
+	}
+});
 /** Durable insertion of the request's draft assistant placeholder. */
 const LLMStarted = schema_exports$7.EventSchema.define({
 	type: "session.llm.started",
@@ -787,7 +900,10 @@ const ToolStarted = schema_exports$7.EventSchema.define({
 	schema: {
 		...LLMFields,
 		callID: Schema.String,
-		name: Schema.String
+		name: Schema.String,
+		/** The tool's display label, when its definition declares one. */
+		label: (0, schema_exports$9.optional)(Schema.String),
+		arguments: Schema.Record(Schema.String, Schema.Json)
 	}
 });
 const ToolProgress$2 = schema_exports$7.EventSchema.define({
@@ -883,14 +999,14 @@ const PluginUpdated = schema_exports$7.EventSchema.define({
 * Everything the kernel can publish. `PublicDefinitions` is the narrower set
 * that reaches clients -- adding an event here does not publish it.
 */
-const Definitions = schema_exports$7.EventSchema.inventory(ExecutionStarted, ExecutionSucceeded, ExecutionFailed, ExecutionInterrupted, PromptAdmitted, Prompted, SessionForked, TurnStarted, TurnEnded, TurnAborted, LLMStarted, LLMTextStart, LLMTextDelta, LLMTextEnd, LLMThinkingStart, LLMThinkingDelta, LLMThinkingEnd, LLMEnded, LLMFailed, ToolStarted, ToolProgress$2, ToolSettled, PluginUpdated);
+const Definitions = schema_exports$7.EventSchema.inventory(ExecutionStarted, ExecutionSucceeded, ExecutionFailed, ExecutionInterrupted, PromptAdmitted, Prompted, ConfigChanged, SessionForked, TurnStarted, TurnEnded, TurnAborted, RetryScheduled, RetryFinished, LLMStarted, LLMTextStart, LLMTextDelta, LLMTextEnd, LLMThinkingStart, LLMThinkingDelta, LLMThinkingEnd, LLMEnded, LLMFailed, ToolStarted, ToolProgress$2, ToolSettled, PluginUpdated);
 /**
 * The wire contract: what a client is allowed to receive. Identical to
 * `Definitions` today, and separate so that adding a kernel event is not by
 * itself a decision to publish it.
 */
 const PublicDefinitions = Definitions;
-const DurableDefinitions = schema_exports$7.EventSchema.inventory(PromptAdmitted, Prompted, SessionForked, TurnEnded, LLMStarted, LLMEnded, LLMFailed, ToolSettled);
+const DurableDefinitions = schema_exports$7.EventSchema.inventory(PromptAdmitted, Prompted, ConfigChanged, SessionForked, TurnEnded, LLMStarted, LLMEnded, LLMFailed, ToolSettled);
 const Manifest$2 = {
 	definitions: schema_exports$7.EventSchema.durable([...DurableDefinitions]),
 	schema: Schema.Union([...DurableDefinitions], { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
@@ -1235,7 +1351,7 @@ const layer$25 = Layer.effect(Service$16, Effect.gen(function* () {
 const encoder = new TextEncoder();
 function fast(input) {
 	const data = typeof input === "string" ? encoder.encode(input) : input;
-	return Encoding.encodeHex(Effect.runSync(crypto.digest("SHA-1", data)));
+	return Hex.encode(Effect.runSync(crypto.digest("SHA-1", data)));
 }
 //#endregion
 //#region src/space/space.ts
@@ -1377,6 +1493,77 @@ const layer$24 = Layer.effect(Service$15, Effect.gen(function* () {
 	});
 }));
 //#endregion
+//#region src/util/slug.ts
+const PREFIXES = [
+	"binary",
+	"protocol",
+	"astromech",
+	"thermal",
+	"ionic",
+	"encrypted",
+	"holonet",
+	"hyperspace",
+	"magnetic",
+	"logic",
+	"plasma",
+	"vector",
+	"optical",
+	"quantum",
+	"mechanical",
+	"servo",
+	"fusion",
+	"flux",
+	"sychro",
+	"static"
+];
+const HARDWARE = [
+	"core",
+	"unit",
+	"node",
+	"array",
+	"link",
+	"processor",
+	"module",
+	"uplink",
+	"interface",
+	"splicer",
+	"matrix",
+	"buffer",
+	"relay",
+	"circuit",
+	"sensor",
+	"driver",
+	"bridge",
+	"manifold",
+	"oscillator",
+	"terminal"
+];
+const SECTORS = [
+	"kuat",
+	"corellia",
+	"coruscant",
+	"bespin",
+	"kamino",
+	"mustafar",
+	"fondor",
+	"hosnian",
+	"lothal",
+	"scarif",
+	"sub-level",
+	"deep-space",
+	"outer-rim",
+	"mid-rim",
+	"sector-7"
+];
+const CONNECTORS = [
+	"at",
+	"of",
+	"in"
+];
+const create$3 = Effect.fnUntraced(function* (id) {
+	return `${yield* Random.choice(PREFIXES)}-${yield* Random.choice(HARDWARE)}-${yield* Random.choice(CONNECTORS)}-${yield* Random.choice(SECTORS)}-${id.slice(-8)}`;
+});
+//#endregion
 //#region src/session/session.ts
 var session_exports$1 = /* @__PURE__ */ __exportAll({
 	EntryNotFoundError: () => EntryNotFoundError,
@@ -1391,7 +1578,7 @@ var session_exports$1 = /* @__PURE__ */ __exportAll({
 	SessionNotLinkedError: () => SessionNotLinkedError,
 	SessionRow: () => SessionRow,
 	ToolCallNotFoundError: () => ToolCallNotFoundError,
-	defaultLayer: () => defaultLayer$2,
+	defaultLayer: () => defaultLayer,
 	entryStates: () => entryStates,
 	entryTypes: () => entryTypes,
 	layer: () => layer$23,
@@ -1603,9 +1790,10 @@ const layer$23 = Layer.effect(Service$14, Effect.gen(function* () {
 			id,
 			spaceId: input.spaceId,
 			parentId: Option.fromUndefinedOr(input.parentId),
-			slug: input.slug,
+			slug: yield* create$3(id),
 			directory: input.directory,
 			hostDir: Option.fromUndefinedOr(input.hostDir),
+			config: Option.none(),
 			title: input.title,
 			tag: Option.fromUndefinedOr(input.tag),
 			metadata: Option.fromUndefinedOr(input.metadata),
@@ -1948,9 +2136,10 @@ const layer$23 = Layer.effect(Service$14, Effect.gen(function* () {
 				id: newSessionId,
 				spaceId: source.value.spaceId,
 				parentId: Option.some(source.value.id),
-				slug: input.slug,
+				slug: yield* create$3(newSessionId),
 				directory: source.value.directory,
 				hostDir: source.value.hostDir,
+				config: source.value.config,
 				title: input.title ?? source.value.title,
 				tag: input.tag === void 0 ? source.value.tag : Option.some(input.tag),
 				metadata: source.value.metadata,
@@ -2045,6 +2234,21 @@ const layer$23 = Layer.effect(Service$14, Effect.gen(function* () {
 		if (Option.isNone(updated)) return yield* Effect.die(/* @__PURE__ */ new Error("session link did not persist"));
 		return updated.value;
 	});
+	const retitle = Effect.fn("Session.retitle")(function* (sessionId, title) {
+		return (yield* sql`
+				UPDATE session SET title = ${title}
+				WHERE id = ${sessionId} AND title = ${DEFAULT_TITLE}
+				RETURNING id
+			`.pipe(Effect.orDie)).length > 0;
+	});
+	const encodeConfig = Schema.encodeEffect(Schema.fromJsonString(Config$1));
+	const configure = Effect.fn("Session.configure")(function* (sessionId, config) {
+		const patch = yield* encodeConfig(config);
+		yield* sql`
+				UPDATE session SET config = json_patch(COALESCE(config, '{}'), ${patch})
+				WHERE id = ${sessionId}
+			`;
+	}, Effect.orDie);
 	const relink = Effect.fn("Session.relink")(function* (input) {
 		const reject = (reason) => new RelinkError({
 			sessionId: input.sessionId,
@@ -2104,6 +2308,8 @@ const layer$23 = Layer.effect(Service$14, Effect.gen(function* () {
 	return Service$14.of({
 		create,
 		link,
+		retitle,
+		configure,
 		get,
 		space,
 		list,
@@ -2122,7 +2328,7 @@ const layer$23 = Layer.effect(Service$14, Effect.gen(function* () {
 		setLabel
 	});
 }));
-const defaultLayer$2 = layer$23.pipe(Layer.provide(defaultLayer$3));
+const defaultLayer = layer$23.pipe(Layer.provide(defaultLayer$1));
 //#endregion
 //#region src/context/errors.ts
 var ContextDecodeError = class extends Schema.TaggedError()("ContextDecodeError", {
@@ -3857,17 +4063,6 @@ const make$9 = () => {
 	}) };
 };
 //#endregion
-//#region src/sandbox/sandbox.ts
-/**
-* Assemble a local backend into a sandbox with a **real host shell** — the
-* right choice whenever commands must invoke actual binaries (`git`, package
-* managers). For a sandbox whose shell should stay inside the VFS, use
-* `EnvBash.services` instead, which wires just-bash over the same tree.
-*/
-const services = (backend, identity) => Layer.provideMerge(io_exports.SandboxIO.mount(identity), Layer.provideMerge(Layer.merge(layer$21, layer$18()), backend));
-/** Default sandbox: the real OS filesystem and processes, mounted at `cwd`. */
-const defaultLayer$1 = (cwd) => services(layer$20(), io_exports.SandboxIO.host(cwd));
-//#endregion
 //#region src/git/git.ts
 var AppProcessError = class extends Schema.TaggedError()("AppProcessError", {
 	command: Schema.String,
@@ -4351,16 +4546,13 @@ var location_exports = /* @__PURE__ */ __exportAll({
 	Info: () => Info$1,
 	Location: () => location_exports,
 	NotDirectoryError: () => NotDirectoryError,
-	Ref: () => Ref$2,
 	Service: () => Service$8,
-	defaultLayer: () => defaultLayer,
 	layer: () => layer$11,
-	layerMounted: () => layerMounted,
-	layerWith: () => layerWith
+	layerMounted: () => layerMounted
 });
-const layer$11 = (ref = {}) => Layer.effect(Service, Effect.gen(function* () {
+const layer$11 = () => Layer.effect(Service, Effect.gen(function* () {
 	const instance = yield* io_exports.SandboxIO.Current;
-	const directory = schema_exports$9.AbsolutePath.make(ref.directory ?? instance.cwd);
+	const directory = schema_exports$9.AbsolutePath.make(instance.cwd);
 	const resolved = yield* (yield* Service$9).resolveOrCreate(directory);
 	return Service.of(new Info({
 		directory: resolved.directory,
@@ -4373,9 +4565,7 @@ const layer$11 = (ref = {}) => Layer.effect(Service, Effect.gen(function* () {
 * folded in. What remains is exactly the mount and the database — for callers
 * that already hold both, such as the runner and `Session.create`.
 */
-const layerMounted = (ref = {}) => layer$11(ref).pipe(Layer.provide(layer$12.pipe(Layer.provide(Layer.mergeAll(layer$14, layer$13, layer$24)), Layer.provide(layer$15))));
-const layerWith = (ref, sandbox) => layerMounted(ref).pipe(Layer.provide(sandbox), Layer.provide(defaultLayer$3));
-const defaultLayer = (ref, path) => layerWith(ref, defaultLayer$1(path));
+const layerMounted = () => layer$11().pipe(Layer.provide(layer$12.pipe(Layer.provide(Layer.mergeAll(layer$14, layer$13, layer$24)), Layer.provide(layer$15))));
 //#endregion
 //#region src/runner/run.ts
 var run_exports = /* @__PURE__ */ __exportAll({
@@ -4870,91 +5060,340 @@ const layer$9 = (definitions = Definitions) => Layer.sync(Service$4, () => {
 	});
 });
 //#endregion
-//#region src/model/catalog.ts
-var catalog_exports = /* @__PURE__ */ __exportAll({
-	ModelCatalog: () => catalog_exports,
-	RefreshError: () => RefreshError,
-	filename: () => filename,
+//#region src/settings/schema.ts
+var schema_exports$3 = /* @__PURE__ */ __exportAll({});
+import * as import__codeworksh_plugin_settings from "@codeworksh/plugin/settings";
+__reExport(schema_exports$3, import__codeworksh_plugin_settings);
+//#endregion
+//#region src/settings/merge.ts
+/**
+* A plain string-keyed record: what a settings patch merges, and what a plugin's `options` block
+* has to be. A Map, a typed array or a class instance is an object to `typeof` and not one of
+* these — `Object.freeze` alone does not tell them apart, and it throws on some of them.
+*/
+const isRecord$1 = (value) => Predicate.isObject(value) && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const copy = (value) => {
+	if (Array.isArray(value)) return value.map(copy);
+	return isRecord$1(value) ? merge({}, value) : value;
+};
+/** Null/undefined properties are absent, objects merge, and arrays replace. Never mutates inputs. */
+function merge(base, ...patches) {
+	const result = /* @__PURE__ */ new Map();
+	for (const patch of [base, ...patches]) {
+		if (patch === void 0) continue;
+		for (const [key, value] of Object.entries(patch)) {
+			if (value === null || value === void 0) continue;
+			const previous = result.get(key);
+			result.set(key, isRecord$1(previous) && isRecord$1(value) ? merge(previous, value) : copy(value));
+		}
+	}
+	return Object.fromEntries(result);
+}
+/** Normalize nullable properties before schema validation, without changing array positions. */
+const normalize$1 = copy;
+//#endregion
+//#region src/settings/settings.ts
+var settings_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service$3,
+	Settings: () => settings_exports,
+	SettingsError: () => SettingsError,
+	defaults: () => schema_exports$3.defaults,
 	layer: () => layer$8,
-	loadError: () => loadError,
-	models: () => models,
-	providers: () => providers,
-	refresh: () => refresh$1,
-	sync: () => sync,
-	ttlConfig: () => ttlConfig
+	load: () => load$3,
+	modules: () => modules,
+	parse: () => parse$2,
+	paths: () => paths,
+	projectRoot: () => projectRoot,
+	userConfigDir: () => userConfigDir
 });
-const filename = "models.gen.json";
-/** How old the catalog may get before a check downloads a new one. */
-const ttlConfig = Config.Duration("CODEWORK_MODELS_TTL").pipe(Config.withDefault(Duration.minutes(15)));
-/** How often a server looks at the file. A look is a `stat`; only a stale file costs a download. */
-const checkEvery = Duration.minutes(1);
-var RefreshError = class extends Schema.TaggedError()("ModelCatalog.RefreshError", {
+/**
+* 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.
+*/
+const userConfigDir = (raw, hostCwd) => hostPath.resolve(hostCwd, expandTilde(raw, hostPath));
+/** The settings files a directory may hold, in the order it is searched. */
+const settingsIn = (directory) => [hostPath.join(directory, "settings.jsonc"), hostPath.join(directory, "settings.json")];
+/** A directory and every ancestor above it, nearest first. */
+const ancestors = (from) => {
+	const chain = [];
+	for (let directory = from;; directory = hostPath.dirname(directory)) {
+		chain.push(directory);
+		if (hostPath.dirname(directory) === directory) return chain;
+	}
+};
+const isDirectory = (path) => fileSystem.stat(path).pipe(Effect.map((info) => info.type === "Directory"), Effect.orElseSucceed(() => false));
+/**
+* The project a directory is in: the nearest ancestor holding a `.codework` **directory**.
+*
+* This is git's rule. `~/workspace/app/.codework` makes `~/workspace/app` a project, and
+* `~/workspace/app/packages/fubar` is inside it. Nearest wins outright -- the walk stops at the
+* first marker, so an inner project is never merged with an outer one.
+*
+* The marker is the directory, not a file in it. An empty `.codework/` is still a project root,
+* which is the point: creating the directory is how a person says "a project begins here", and it
+* has to mean that before any settings exist. It also makes the question one `stat` per ancestor
+* whose answer does not change as files come and go inside.
+*
+* `<home>` is skipped. `~/.codework` is the user layer, not a project; without this, running
+* anywhere under `$HOME` would find it as one and read the user layer twice -- and since plugin
+* entries accumulate across layers, every user plugin would load twice.
+*/
+const projectRoot = Effect.fn("Settings.projectRoot")(function* (from, home) {
+	const userConfig = hostPath.resolve(home);
+	for (const directory of ancestors(hostPath.resolve(from))) {
+		const marker = hostPath.join(directory, appConfigDir);
+		if (hostPath.resolve(marker) === userConfig) continue;
+		if (yield* isDirectory(marker)) return directory;
+	}
+});
+/**
+* Ordered layers, each a group of candidates where the first file that exists is selected -- a
+* group never contributes more than one file.
+*
+* `.jsonc` is the canonical spelling: these files are written by hand and read as JSONC, so the
+* extension says what the file is and an editor validates it as such. `.json` remains a fallback
+* everywhere, tried second, because the parser reads either and a file already named that must
+* keep working.
+*
+* `root` is an already-discovered project root ({@link projectRoot}), not a directory to search
+* from: the walk is a `stat` per ancestor and belongs with the other I/O. `undefined` contributes
+* no project layer at all, which is what a session with no host directory gets.
+*/
+function paths(input) {
+	return [settingsIn(input.userConfigDir ?? input.home), input.root === void 0 ? [] : settingsIn(hostPath.join(input.root, appConfigDir))];
+}
+var SettingsError = class extends Schema.TaggedError()("SettingsError", {
 	path: Schema.String,
+	reason: Schema.Literals([
+		"read",
+		"parse",
+		"decode"
+	]),
 	detail: Schema.String
 }) {
 	get message() {
-		return `failed to refresh the model catalog at ${this.path}: ${this.detail}`;
+		return `${this.path}: ${this.reason}: ${this.detail}`;
 	}
 };
-/** Point aikit at `<home>/models.gen.json`, which `CODEWORK_MODELS_FILE` overrides. */
-const use = (home) => {
-	const own = hostPath.resolve(home, filename);
-	Model$1.configureCatalog(own);
-	const path = Model$1.catalogPath();
-	return {
-		path,
-		pinned: path !== own
-	};
+/** `line:column`, 1-based, for a parser offset into the source. */
+const at = (source, offset) => {
+	const before = source.slice(0, offset).split("\n");
+	return `${before.length}:${(before.at(-1)?.length ?? 0) + 1}`;
 };
-const modified = (path) => fileSystem.stat(path).pipe(Effect.map((info) => Option.map(info.mtime, (date) => date.getTime())), Effect.orElseSucceed(() => Option.none()));
-const stale = Effect.fn("ModelCatalog.stale")(function* (path) {
-	const mtime = yield* modified(path);
-	if (Option.isNone(mtime)) return true;
-	const ttl = yield* ttlConfig;
-	return (yield* Clock.currentTimeMillis) - mtime.value >= Duration.toMillis(ttl);
-});
-const download$1 = (path) => Effect.tryPromise({
-	try: () => generateModels({ path }),
-	catch: (cause) => new RefreshError({
-		path,
-		detail: cause instanceof Error ? cause.message : String(cause)
-	})
-});
-/** Download a new catalog for the home when it is missing, older than the TTL, or `force` asks. */
-const refresh$1 = Effect.fn("ModelCatalog.refresh")(function* (home, options = {}) {
-	const { path } = use(home);
-	if (options.force !== true && !(yield* stale(path))) return {
-		path,
-		refreshed: false
-	};
-	yield* download$1(path);
-	return {
-		path,
-		refreshed: true
-	};
-});
 /**
-* The automatic check: refresh a stale catalog unless it is pinned, and never fail. A failed
-* download leaves the old file in place; a missing one surfaces later as a
-* `Runner.ModelCatalogError` from whatever needed it.
+* Decode failures name the field, and explain it only with a message a schema check wrote. Effect's
+* defaults quote the rejected value, and in a settings file that value can be a secret, so any
+* other failure reads "invalid value".
 */
-const check$1 = Effect.fn("ModelCatalog.check")(function* ({ path, pinned }) {
-	if (pinned || !(yield* stale(path))) return;
-	yield* download$1(path);
-});
-const quietly = (effect) => effect.pipe(Effect.asVoid, Effect.catch((error) => Effect.logWarning(`model catalog: ${error.message}`)));
-/** Check the home's catalog once, for a command that runs and exits; returns the file aikit reads. */
-const sync = Effect.fn("ModelCatalog.sync")(function* (home) {
-	const target = use(home);
-	yield* quietly(check$1(target));
-	return target.path;
+const decodeFormatter = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (issue) => {
+	const message = "annotations" in issue ? issue.annotations?.message : void 0;
+	return typeof message === "string" ? message.replaceAll(/\s*\n\s*/g, " ") : "invalid value";
+} });
+const parse$2 = Effect.fn("Settings.parse")(function* (path, source) {
+	const errors = [];
+	const json = parse(source, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	const first = errors[0];
+	if (first !== void 0) return yield* new SettingsError({
+		path,
+		reason: "parse",
+		detail: `${printParseErrorCode(first.error)} at ${at(source, first.offset)}`
+	});
+	const document = normalize$1(json);
+	if (Predicate.isObject(document) && Predicate.isObject(json) && "plugins" in json) Object.assign(document, { plugins: json.plugins });
+	return yield* Schema.decodeUnknownEffect(schema_exports$3.Patch)(document).pipe(Effect.mapError((error) => new SettingsError({
+		path,
+		reason: "decode",
+		detail: decodeFormatter(error.issue).issues.map((issue) => `${issue.path?.map((part) => typeof part === "object" ? String(part.key) : part).join(".") ?? "settings"}: ${issue.message}`).join("; ")
+	})));
 });
+var Service$3 = class extends Context.Service()("@codeworksh/harness/settings/settings/Service") {};
 /**
-* 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.
+* Anchor relative plugin entries to the file that declared them.
+*
+* A reference is otherwise resolved against the host startup directory, which is right for
+* a project file sitting in it and meaningless for `~/.codework/settings.json`, where
+* `./plugins/x.ts` would name a different file in every project the process is started in.
+* `file:` URLs, package specs and package names are left exactly as written, and a `plugin`
+* key is an ID rather than a location. A configuration entry's `package` is anchored like a
+* module entry, so a relative path names the same module in both spellings.
 */
-const layer$8 = (options) => Layer.effectDiscard(Effect.gen(function* () {
+const anchored = (entry, file) => {
+	const directory = hostPath.dirname(file);
+	const resolve = (reference) => reference.startsWith("./") || reference.startsWith("../") ? hostPath.resolve(directory, reference) : reference;
+	if (typeof entry === "string") return resolve(entry);
+	return "package" in entry ? {
+		...entry,
+		package: resolve(entry.package)
+	} : entry;
+};
+const anchor$1 = (patch, file) => patch.plugins === void 0 ? patch : {
+	...patch,
+	plugins: patch.plugins.map((entry) => anchored(entry, file))
+};
+const attempt = (path) => fileSystem.readFileString(path).pipe(Effect.mapError((error) => new SettingsError({
+	path,
+	reason: "read",
+	detail: error.reason._tag
+})), Effect.flatMap((source) => parse$2(path, source)));
+/**
+* One read of every layer. Exported for the harness constructor, which needs the plugin
+* selection before any layer is built; everything else goes through `Service`.
+*/
+const load$3 = Effect.fn("Settings.load")(function* (options) {
+	const root = options.hostDir === void 0 ? void 0 : yield* projectRoot(options.hostDir, options.home);
+	const files = paths({
+		home: options.home,
+		root,
+		...options.userConfigDir === void 0 ? {} : { userConfigDir: options.userConfigDir }
+	});
+	let settings = merge(schema_exports$3.defaults);
+	let declared = schema_exports$3.defaults.declared;
+	let models = schema_exports$3.defaults.models;
+	for (const group of files) for (const path of group) {
+		const result = yield* Effect.result(attempt(path));
+		if (Result.isSuccess(result)) {
+			const { models: entries, ...patch } = anchor$1(result.success, path);
+			settings = merge(settings, patch);
+			if (entries !== void 0) models = [...models, ...entries.map((entry) => ({
+				entry,
+				file: path
+			}))];
+			if (result.success.plugins !== void 0) declared = [...declared, ...result.success.plugins.map((written) => ({
+				written,
+				entry: anchored(written, path),
+				file: path
+			}))];
+			break;
+		}
+		const error = result.failure;
+		if (error.reason === "read" && error.detail === "NotFound") continue;
+		return yield* error;
+	}
+	return {
+		...settings,
+		plugins: declared.map((one) => one.entry),
+		declared,
+		models
+	};
+});
+/**
+* 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.
+*/
+const modules = (declared) => {
+	const owners = /* @__PURE__ */ new Map();
+	for (const one of declared) if (typeof one.entry === "string") owners.set(one.entry, one);
+	return owners;
+};
+const layer$8 = (options = {}) => Layer.effect(Service$3, Effect.gen(function* () {
+	const global = yield* Service$17;
+	return Service$3.of({ load: (hostDir) => load$3({
+		...options,
+		home: global.home,
+		hostDir
+	}) });
+}));
+//#endregion
+//#region src/model/catalog.ts
+var catalog_exports = /* @__PURE__ */ __exportAll({
+	Credentials: () => Credentials,
+	ModelCatalog: () => catalog_exports,
+	RefreshError: () => RefreshError,
+	available: () => available,
+	effective: () => effective,
+	entry: () => entry,
+	filename: () => filename,
+	fromSettings: () => fromSettings,
+	layer: () => layer$7,
+	loadError: () => loadError,
+	models: () => models,
+	oauthStorage: () => oauthStorage,
+	providers: () => providers,
+	refresh: () => refresh$1,
+	sync: () => sync,
+	ttlConfig: () => ttlConfig
+});
+const filename = "models.gen.json";
+/** How old the catalog may get before a check downloads a new one. */
+const ttlConfig = Config.Duration("CODEWORK_MODELS_TTL").pipe(Config.withDefault(Duration.minutes(15)));
+/** How often a server looks at the file. A look is a `stat`; only a stale file costs a download. */
+const checkEvery = Duration.minutes(1);
+var RefreshError = class extends Schema.TaggedError()("ModelCatalog.RefreshError", {
+	path: Schema.String,
+	detail: Schema.String
+}) {
+	get message() {
+		return `failed to refresh the model catalog at ${this.path}: ${this.detail}`;
+	}
+};
+/** Point aikit at `<home>/models.gen.json`, which `CODEWORK_MODELS_FILE` overrides. */
+const use = (home) => {
+	const own = hostPath.resolve(home, filename);
+	Model.configureCatalog(own);
+	const path = Model.catalogPath();
+	return {
+		path,
+		pinned: path !== own
+	};
+};
+const modified = (path) => fileSystem.stat(path).pipe(Effect.map((info) => Option.map(info.mtime, (date) => date.getTime())), Effect.orElseSucceed(() => Option.none()));
+const stale = Effect.fn("ModelCatalog.stale")(function* (path) {
+	const mtime = yield* modified(path);
+	if (Option.isNone(mtime)) return true;
+	const ttl = yield* ttlConfig;
+	return (yield* Clock.currentTimeMillis) - mtime.value >= Duration.toMillis(ttl);
+});
+const download$1 = (path) => Effect.tryPromise({
+	try: () => generateModels({ path }),
+	catch: (cause) => new RefreshError({
+		path,
+		detail: cause instanceof Error ? cause.message : String(cause)
+	})
+});
+/** Download a new catalog for the home when it is missing, older than the TTL, or `force` asks. */
+const refresh$1 = Effect.fn("ModelCatalog.refresh")(function* (home, options = {}) {
+	const { path } = use(home);
+	if (options.force !== true && !(yield* stale(path))) return {
+		path,
+		refreshed: false
+	};
+	yield* download$1(path);
+	return {
+		path,
+		refreshed: true
+	};
+});
+/**
+* The automatic check: refresh a stale catalog unless it is pinned, and never fail. A failed
+* download leaves the old file in place; a missing one surfaces later as a
+* `Runner.ModelCatalogError` from whatever needed it.
+*/
+const check$1 = Effect.fn("ModelCatalog.check")(function* ({ path, pinned }) {
+	if (pinned || !(yield* stale(path))) return;
+	yield* download$1(path);
+});
+const quietly = (effect) => effect.pipe(Effect.asVoid, Effect.catch((error) => Effect.logWarning(`model catalog: ${error.message}`)));
+/** Check the home's catalog once, for a command that runs and exits; returns the file aikit reads. */
+const sync = Effect.fn("ModelCatalog.sync")(function* (home) {
+	const target = use(home);
+	yield* quietly(check$1(target));
+	return target.path;
+});
+/**
+* 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.
+*/
+const layer$7 = (options) => Layer.effectDiscard(Effect.gen(function* () {
 	const target = use(options.home);
 	yield* quietly(check$1(target));
 	if (!options.watch) return;
@@ -4963,7 +5402,7 @@ const layer$8 = (options) => Layer.effectDiscard(Effect.gen(function* () {
 	const tick = Effect.gen(function* () {
 		yield* quietly(check$1(target));
 		const mtime = yield* current;
-		if (mtime !== (yield* Ref.getAndSet(seen, mtime))) Model$1.reloadCatalog();
+		if (mtime !== (yield* Ref.getAndSet(seen, mtime))) Model.reloadCatalog();
 	});
 	yield* Effect.forkScoped(tick.pipe(Effect.repeat(Schedule.spaced(checkEvery))));
 }));
@@ -4980,79 +5419,112 @@ const loadError = (cause) => {
 	});
 };
 const catalogError = (cause) => loadError(cause) ?? new ModelCatalogError({
-	path: Model$1.catalogPath(),
+	path: Model.catalogPath(),
 	reason: "unreadable",
 	detail: cause instanceof Error ? cause.message : "failed to load the model catalog"
 });
 const models = Effect.tryPromise({
-	try: () => Model$1.getBuiltInModels(),
+	try: () => Model.getBuiltInModels(),
 	catch: catalogError
 });
 const providers = Effect.tryPromise({
-	try: () => Model$1.getProviders(),
+	try: () => Model.getProviders(),
 	catch: catalogError
 });
-//#endregion
-//#region src/plugin/plugin.ts
-var plugin_exports$1 = /* @__PURE__ */ __exportAll({});
-import * as import__codeworksh_plugin_plugin from "@codeworksh/plugin/plugin";
-__reExport(plugin_exports$1, import__codeworksh_plugin_plugin);
-//#endregion
-//#region src/plugin/builtin/prompt/default.ts
-/** The default coding-agent foundation, used unless `promptCustom` replaces it. */
-const foundation = `You are an expert coding assistant operating inside codework, a coding agent harness.`;
 /**
-* Guidelines that hold regardless of which tools are registered.
-*
-* Kept short on purpose. Every line here is spent on every request, so a line
-* earns its place only if a model measurably behaves worse without it.
+* Where this process reads OAuth logins: `<home>/aikit/auth.json` when a home was chosen,
+* otherwise `undefined`, which lets aikit resolve it (`CODEWORK_CREDENTIALS`, then the default home).
+* One value, so the model calls and {@link available} can never read different files.
 */
-const standingGuidelines = [
-	"Be concise. Report what you did and what you found, not what you are about to do.",
-	"Quote exact paths and command output rather than paraphrasing them.",
-	"If a command fails, read the error before retrying."
-];
-/** Collapse whitespace so two spellings of one guideline dedupe against each other. */
-const normalize$1 = (value) => value.trim().replace(/\s+/g, " ");
+var Credentials = class extends Context.Service()("@codeworksh/harness/model/catalog/Credentials") {};
+/** The storage options an aikit OAuth store takes for {@link Credentials.authFile}. */
+const oauthStorage = (authFile) => authFile === void 0 ? {} : { path: authFile };
+/** Whether an OAuth login is stored for the protocol. Reads the file; never refreshes a token. */
+const loggedIn = (protocol, authFile) => {
+	const storage = oauthStorage(authFile);
+	const store = protocol === "openai-codex" ? new JsonOpenAICodexAuthStorage(storage) : protocol === "github-copilot" ? new JsonGitHubCopilotAuthStorage(storage) : void 0;
+	if (store === void 0) return Effect.succeed(false);
+	return Effect.tryPromise(() => store.get()).pipe(Effect.map((stored) => stored !== void 0), Effect.orElseSucceed(() => false));
+};
 /**
-* Tool-contributed guidelines followed by the standing ones, normalized and
-* deduplicated with first occurrence winning.
-*
-* Tool order is bucket order, which is the same order the index renders in and the
-* same order the provider receives definitions in -- one ordering, not three.
+* A settings entry as the catalog reads it. Settings entries are read exactly like generated ones;
+* the one difference is `provider.key`, written `"${NAME}"`, which becomes the variable name aikit
+* looks up when it calls the model.
 */
-const guidelines = (tools) => {
-	const seen = /* @__PURE__ */ new Set();
-	const collected = [];
-	for (const line of [...tools.flatMap((tool) => tool.promptGuidelines ?? []), ...standingGuidelines]) {
-		const normalized = normalize$1(line);
-		if (normalized.length === 0 || seen.has(normalized)) continue;
-		seen.add(normalized);
-		collected.push(normalized);
+const fromSettings = (entry) => entry.provider.key === void 0 ? entry : {
+	...entry,
+	provider: {
+		...entry.provider,
+		key: (0, schema_exports$3.keyName)(entry.provider.key)
 	}
-	return collected;
 };
+/** The settings entry for a model, if one declares it: the last declaration wins. */
+const entry = (declared, provider, id) => {
+	const found = declared.findLast((one) => one.entry.provider.id === provider && one.entry.id === id);
+	return found === void 0 ? void 0 : fromSettings(found.entry);
+};
+/**
+* The generated catalog with settings entries appended in layer order: a new provider or model is
+* added, and an entry for an existing one replaces it, as a later entry in a generated file would.
+*/
+const effective = Effect.fn("ModelCatalog.effective")(function* (declared) {
+	const catalog = { ...yield* models };
+	for (const { entry: one } of declared) catalog[one.provider.id] = {
+		...catalog[one.provider.id],
+		[one.id]: fromSettings(one)
+	};
+	return catalog;
+});
+const oauthProtocols = /* @__PURE__ */ new Set(["openai-codex", "github-copilot"]);
 /**
-* The rendered tool index.
+* The effective catalog's providers this process has credentials for, optionally only those
+* credentialed one way. `hostDir` selects the project whose settings entries apply; without it,
+* only the user's.
 *
-* `(none)` rather than an omitted section: a model told it has no tools behaves
-* better than one left to infer it from silence.
+* `apiKey`: the provider's `key` or `env` names are set in the host environment (they include the
+* OAuth providers' env tokens). `oauth`: a login is stored in the {@link Credentials} file. `none`:
+* the provider names no key and isn't an OAuth provider. A provider with a key and a login reports
+* `apiKey`, the one a model call uses first.
+*
+* Presence, not validity: nothing is sent over the network, so a revoked key still counts. A
+* client showing a model picker should still add the session's current model.
 */
-const toolIndex = (tools) => {
-	const listed = tools.filter((tool) => tool.promptSnippet !== void 0 && tool.promptSnippet.length > 0);
-	if (listed.length === 0) return "(none)";
-	return listed.map((tool) => `- ${tool.name}: ${tool.promptSnippet}`).join("\n");
-};
-const assemble = (input) => {
-	const sections = [input.promptCustom ?? foundation];
-	sections.push(`Available tools:\n${toolIndex(input.tools)}`);
-	const lines = guidelines(input.tools);
-	if (lines.length > 0) sections.push(`Guidelines:\n${lines.map((line) => `- ${line}`).join("\n")}`);
-	const append = input.promptSystemAppend?.trim();
-	if (append !== void 0 && append.length > 0) sections.push(append);
-	sections.push(`Current working directory: ${input.directory}`);
-	return sections.join("\n\n");
-};
+const available = Effect.fn("ModelCatalog.available")(function* (filter = {}) {
+	const { authFile } = yield* Credentials;
+	const settings = yield* Service$3;
+	const catalog = yield* effective((yield* settings.load(filter.hostDir)).models);
+	const usable = [];
+	for (const [id, entries] of Object.entries(catalog)) {
+		const first = entries === void 0 ? void 0 : Object.values(entries)[0];
+		if (entries === void 0 || first === void 0) continue;
+		const keyless = first.provider.key === void 0 && first.provider.env.length === 0 && !oauthProtocols.has(first.protocol);
+		const credential = getEnvApiKey(first.provider) !== void 0 ? "apiKey" : (yield* loggedIn(first.protocol, authFile)) ? "oauth" : keyless ? "none" : void 0;
+		if (credential === void 0 || filter.credential !== void 0 && filter.credential !== credential) continue;
+		usable.push({
+			id,
+			credential,
+			models: entries
+		});
+	}
+	return usable;
+});
+//#endregion
+//#region src/plugin/plugin.ts
+var plugin_exports$1 = /* @__PURE__ */ __exportAll({});
+import * as import__codeworksh_plugin_plugin from "@codeworksh/plugin/plugin";
+__reExport(plugin_exports$1, import__codeworksh_plugin_plugin);
+//#endregion
+//#region src/plugin/builtin/prompt/default.ts
+/** The default prompt foundation, used unless `promptCustom` replaces it. */
+const foundation = "You are an expert coding assistant operating inside codework, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
+/** Every line here is spent on every request; keep it short. */
+const standingRules = ["Be concise in your responses", "Show file paths clearly when working with files"];
+/** Bash stands in for file tools only until dedicated ones are registered. */
+const toolRules = (names) => names.has("bash") && ![
+	"grep",
+	"find",
+	"ls"
+].some((name) => names.has(name)) ? ["Use bash for file operations like ls, rg, find"] : [];
 /**
 * A caller slot, awaited lazily. A throw or rejection fails the snapshot, which the
 * host attributes to this plugin's id.
@@ -5063,13 +5535,81 @@ const defaultPromptPlugin = (0, plugin_exports$1.define)({
 	kind: "prompt",
 	setup: Effect.fn("DefaultPromptPlugin.setup")(function* (ctx) {
 		const custom = yield* slot(ctx, ctx.config.promptCustom);
-		const append = yield* slot(ctx, ctx.config.promptSystemAppend);
-		ctx.plugin.prompt.set(assemble({
-			tools: ctx.plugin.tools.list(),
-			directory: ctx.location.directory,
-			...custom === void 0 ? {} : { promptCustom: custom },
-			...append === void 0 ? {} : { promptSystemAppend: append }
-		}));
+		const append = (yield* slot(ctx, ctx.config.promptSystemAppend))?.trim();
+		const prompt = ctx.plugin.prompt;
+		prompt.foundation.set(custom ?? foundation);
+		const names = new Set(ctx.plugin.tools.list().map((tool) => tool.name));
+		for (const rule of [...toolRules(names), ...standingRules]) prompt.sections.append(Section.Rules, rule);
+		if (append !== void 0 && append.length > 0) prompt.sections.append(Section.Addendum, append);
+	})
+});
+//#endregion
+//#region src/plugin/builtin/prompt/instruction.ts
+/** First readable match per directory wins. */
+const names = [
+	"AGENTS.override.md",
+	"CLAUDE.override.md",
+	"AGENTS.md",
+	"AGENTS.MD",
+	"CLAUDE.md",
+	"CLAUDE.MD"
+];
+const content = (raw) => {
+	const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+	return text.trim().length === 0 ? void 0 : text;
+};
+const first = Effect.fnUntraced(function* (fs, directory) {
+	for (const name of names) {
+		const path = posix.join(directory, name);
+		if (!(yield* fs.stat(path).pipe(Effect.map((stat) => stat.isFile), Effect.orElseSucceed(() => false)))) continue;
+		const raw = yield* fs.readFile(path).pipe(Effect.tapError((cause) => Effect.logWarning(`could not read instruction file ${path}`, cause)), Effect.option);
+		if (Option.isSome(raw)) return {
+			name,
+			path,
+			content: content(raw.value)
+		};
+	}
+});
+/** Only the path is escaped; file content goes in verbatim. */
+const attribute = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;");
+/**
+* The main checkout's directory when the cwd is in a linked worktree nested inside it (e.g.
+* `repo/.claude/worktrees/x`), so its same-named file is not applied twice. Sibling worktrees,
+* bare layouts and submodules are never shadowed.
+*/
+const shadowing = (location) => {
+	const store = location.project.vcs?.store;
+	if (location.space.kind !== "linked" || store === void 0 || posix.basename(store) !== ".git") return void 0;
+	const main = posix.dirname(store);
+	return location.space.location.startsWith(`${main}/`) ? main : void 0;
+};
+const instructionPlugin = (0, plugin_exports$1.define)({
+	id: "codework.prompt.instruction",
+	kind: "prompt",
+	setup: Effect.fn("InstructionPlugin.setup")(function* (ctx) {
+		const fs = yield* io_exports.SandboxIO.FileSystem;
+		const probed = /* @__PURE__ */ new Map();
+		const at = Effect.fnUntraced(function* (directory) {
+			if (!probed.has(directory)) probed.set(directory, yield* first(fs, directory));
+			return probed.get(directory);
+		});
+		const walked = [];
+		const main = shadowing(ctx.location);
+		const worktree = main === void 0 ? void 0 : yield* at(ctx.location.space.location);
+		let current = ctx.location.directory;
+		while (true) {
+			const here = yield* at(current);
+			const shadowed = current === main && worktree !== void 0 && here?.name === worktree.name;
+			if (here !== void 0 && !shadowed) walked.push(here);
+			const parent = posix.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+		const files = walked.reverse().filter((file) => file.content !== void 0);
+		if (files.length === 0) return;
+		const prompt = ctx.plugin.prompt;
+		prompt.sections.append(Section.ProjectContext, "Project-Specific Instructions & Guidelines:");
+		for (const file of files) prompt.sections.append(Section.ProjectContext, `<project_instructions path="${attribute(file.path)}">\n${file.content}\n</project_instructions>`);
 	})
 });
 //#endregion
@@ -5301,7 +5841,7 @@ var Accumulator = class {
 	ensureTempFile() {
 		if (this.tempFile !== void 0) return Effect.void;
 		return Effect.gen({ self: this }, function* () {
-			const suffix = Encoding.encodeHex(yield* crypto.randomBytes(8));
+			const suffix = Hex.encode(yield* crypto.randomBytes(8));
 			this.tempFilePath = defaultTempFilePath(this.tempFilePrefix, suffix);
 			this.tempFile = yield* fileSystem.open(this.tempFilePath, { flag: "w" });
 			for (const chunk of this.rawChunks) yield* this.tempFile.writeAll(chunk);
@@ -5480,7 +6020,7 @@ const footer = (t, fullOutputPath, lastLineBytes) => {
 };
 /** Write full output to a host temp file (best-effort; undefined on failure). */
 const spillToTempFile = (content) => Effect.gen(function* () {
-	const suffix = Encoding.encodeHex(yield* crypto.randomBytes(6));
+	const suffix = Hex.encode(yield* crypto.randomBytes(6));
 	const path = posix.join(tmpdir(), `codework-bash-${suffix}.log`);
 	yield* fileSystem.writeFileString(path, content);
 	return path;
@@ -5583,36 +6123,13 @@ const bashPlugin = (0, plugin_exports$1.define)({
 //#region src/plugin/builtin.ts
 /**
 * Every plugin the harness ships, and the selection a caller who passes no `plugins` gets. Tool
-* contributors come first so the Prompt plugin that indexes them runs after they registered.
-*/
-const builtins = Object.freeze([bashPlugin, defaultPromptPlugin]);
-//#endregion
-//#region src/settings/merge.ts
-/**
-* A plain string-keyed record: what a settings patch merges, and what a plugin's `options` block
-* has to be. A Map, a typed array or a class instance is an object to `typeof` and not one of
-* these — `Object.freeze` alone does not tell them apart, and it throws on some of them.
+* contributors come first; within the prompt domain, declaration order is run order.
 */
-const isRecord$1 = (value) => Predicate.isObject(value) && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-const copy = (value) => {
-	if (Array.isArray(value)) return value.map(copy);
-	return isRecord$1(value) ? merge({}, value) : value;
-};
-/** Null/undefined properties are absent, objects merge, and arrays replace. Never mutates inputs. */
-function merge(base, ...patches) {
-	const result = /* @__PURE__ */ new Map();
-	for (const patch of [base, ...patches]) {
-		if (patch === void 0) continue;
-		for (const [key, value] of Object.entries(patch)) {
-			if (value === null || value === void 0) continue;
-			const previous = result.get(key);
-			result.set(key, isRecord$1(previous) && isRecord$1(value) ? merge(previous, value) : copy(value));
-		}
-	}
-	return Object.fromEntries(result);
-}
-/** Normalize nullable properties before schema validation, without changing array positions. */
-const normalize = copy;
+const builtins = Object.freeze([
+	bashPlugin,
+	defaultPromptPlugin,
+	instructionPlugin
+]);
 //#endregion
 //#region src/util/module.ts
 /*!
@@ -6169,7 +6686,7 @@ const isPath = (reference) => reference.startsWith("file:") || reference.startsW
 * - a **CLI argument** anchors to the process's startup directory, because that is where the
 *   person typed it.
 */
-const parse$2 = (reference, from) => Effect.gen(function* () {
+const parse$1 = (reference, from) => Effect.gen(function* () {
 	const fail = (reason, message) => new SourceError({
 		reason,
 		reference,
@@ -6386,7 +6903,7 @@ const slugOf = (target) => target.kind === "git" ? target.slug : canonical$1(tar
 */
 const digest = Effect.fn("PluginStore.digest")(function* (target, cache, from) {
 	const source = target.kind === "registry" ? `${yield* registry(target, cache, from)}\0${target.spec}` : target.spec;
-	return Encoding.encodeHex(yield* crypto.digest("SHA-256", new TextEncoder().encode(source)));
+	return Hex.encode(yield* crypto.digest("SHA-256", new TextEncoder().encode(source)));
 });
 const entryDir = Effect.fn("PluginStore.entryDir")(function* (target, cache, from) {
 	const key = yield* digest(target, cache, from);
@@ -6790,7 +7307,7 @@ const localUrl = Effect.fn("PluginLoader.localUrl")(function* (location, origin)
 */
 const install = Effect.fn("PluginLoader.install")(function* (target, cache, origin, options) {
 	const added = yield* add(target, cache, {
-		from: anchor$1(origin.file, options.hostDir),
+		from: anchor(origin.file, options.hostDir),
 		validate: (fetched) => imported(url(fetched.entrypoint), origin, options.import)
 	});
 	return {
@@ -6806,13 +7323,13 @@ const install = Effect.fn("PluginLoader.install")(function* (target, cache, orig
 * package boundary discovered upward from the chain's start -- the root itself -- so anchoring at
 * the file's own directory would miss it. Absent a declaring file the host context stands in.
 */
-const anchor$1 = (file, fallback) => {
+const anchor = (file, fallback) => {
 	if (file === void 0) return fallback;
 	const directory = hostPath.dirname(file);
 	return hostPath.basename(directory) === ".codework" ? hostPath.dirname(directory) : directory;
 };
 /** The default installer, or the one the caller injected. */
-const installer = (target, origin, options) => options.install === void 0 ? install(target, options.cache, origin, options) : options.install(target, options.cache, anchor$1(origin.file, options.hostDir));
+const installer = (target, origin, options) => options.install === void 0 ? install(target, options.cache, origin, options) : options.install(target, options.cache, anchor(origin.file, options.hostDir));
 /** Import a module and confirm it default-exports a plugin. */
 const imported = Effect.fn("PluginLoader.imported")(function* (url, origin, load) {
 	const module = yield* Effect.tryPromise({
@@ -6844,15 +7361,15 @@ const inspect = Effect.fn("PluginLoader.inspect")(function* (reference, options)
 		reference,
 		file: options.file
 	};
-	const target = yield* parse$2(reference, options.hostDir);
-	const loaded = yield* load$3(target, origin, options);
+	const target = yield* parse$1(reference, options.hostDir);
+	const loaded = yield* load$2(target, origin, options);
 	return {
 		id: loaded.plugin.id,
 		...loaded.version === void 0 ? {} : { version: loaded.version },
 		...loaded.name === void 0 ? {} : { name: loaded.name }
 	};
 });
-const load$3 = Effect.fn("PluginLoader.load")(function* (target, origin, options) {
+const load$2 = Effect.fn("PluginLoader.load")(function* (target, origin, options) {
 	const installed = yield* target.kind === "local" ? localUrl(target.path, origin).pipe(Effect.mapError((cause) => sourceFailure(origin, cause))) : installer(target, origin, options).pipe(Effect.mapError((cause) => origin.file === void 0 ? cause : declaredIn(cause, origin.file)));
 	const address = target.kind === "local" && options.reload !== void 0 && options.reload > 0 ? `${installed.url}?reload=${options.reload}` : installed.url;
 	return {
@@ -6870,7 +7387,7 @@ const load$3 = Effect.fn("PluginLoader.load")(function* (target, origin, options
 * are one package, and `./plugins/x.ts` is the file it resolves to from the directory that
 * declared it. Pure -- nothing is installed, imported or read.
 */
-const canonical = (reference, hostDir) => Effect.map(parse$2(reference, hostDir), canonical$1);
+const canonical = (reference, hostDir) => Effect.map(parse$1(reference, hostDir), canonical$1);
 //#endregion
 //#region src/plugin/catalog.ts
 /**
@@ -6897,7 +7414,7 @@ const isPatch = (reference) => Predicate.isObject(reference) && !Predicate.isFun
 *
 * Loading is keyed by what a reference resolves to, so naming one module twice imports it once.
 */
-const load$2 = Effect.fn("PluginCatalog.load")(function* (references, options) {
+const load$1 = Effect.fn("PluginCatalog.load")(function* (references, options) {
 	const plugins = /* @__PURE__ */ new Map();
 	const aliases = /* @__PURE__ */ new Map();
 	const versions = /* @__PURE__ */ new Map();
@@ -6932,14 +7449,14 @@ const load$2 = Effect.fn("PluginCatalog.load")(function* (references, options) {
 			remember(plugin, []);
 			continue;
 		}
-		const target = yield* parse$2(reference, options.hostDir);
+		const target = yield* parse$1(reference, options.hostDir);
 		const key = target.kind === "local" ? target.path : target.spec;
 		const already = seen.get(key);
 		if (already !== void 0) {
 			aliases.set(reference, already);
 			continue;
 		}
-		const definition = yield* load$3(target, origin, options);
+		const definition = yield* load$2(target, origin, options);
 		yield* note(definition.plugin, definition.version === void 0 ? key : `${key}@${definition.version}`);
 		const names = target.kind === "local" ? [target.path, ...definition.name === void 0 ? [] : [definition.name]] : [canonical$1(target), target.spec];
 		remember(definition.plugin, [reference, ...names], {
@@ -7061,12 +7578,12 @@ const follow = Effect.fn("PluginCatalog.follow")(function* (references, pool, op
 	for (const reference of references) {
 		if (typeof reference !== "string") continue;
 		const owner = options.declared?.get(reference);
-		const from = anchor$1(owner, options.hostDir);
+		const from = anchor(owner, options.hostDir);
 		const id = pool.aliases.get(reference);
 		if (id !== void 0) {
 			const origin = pool.origins.get(id);
 			if (owner === void 0 || origin?.reference !== reference) continue;
-			if (anchor$1(origin.file, options.hostDir) === from) continue;
+			if (anchor(origin.file, options.hostDir) === from) continue;
 		}
 		if (Option.isSome(yield* filed(reference, from))) {
 			moved = true;
@@ -7075,7 +7592,7 @@ const follow = Effect.fn("PluginCatalog.follow")(function* (references, pool, op
 	}
 	if (!moved) for (const origin of pool.origins.values()) {
 		if (origin.generation === void 0) continue;
-		const current = yield* filed(origin.reference, anchor$1(origin.file, options.hostDir));
+		const current = yield* filed(origin.reference, anchor(origin.file, options.hostDir));
 		if (Option.isSome(current) && current.value.generation !== void 0 && current.value.generation > origin.generation) {
 			moved = true;
 			break;
@@ -7084,7 +7601,7 @@ const follow = Effect.fn("PluginCatalog.follow")(function* (references, pool, op
 	if (!moved) return Option.none();
 	const retained = [];
 	for (const origin of pool.origins.values()) {
-		if (references.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor$1(origin.file, options.hostDir)))) {
+		if (references.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor(origin.file, options.hostDir)))) {
 			retained.push(origin);
 			continue;
 		}
@@ -7094,13 +7611,13 @@ const follow = Effect.fn("PluginCatalog.follow")(function* (references, pool, op
 	const known = /* @__PURE__ */ new Map();
 	for (const origin of retained) if (origin.file !== void 0) known.set(origin.reference, origin.file);
 	for (const [reference, file] of options.declared ?? /* @__PURE__ */ new Map()) known.set(reference, file);
-	return Option.some(yield* load$2(accumulated, {
+	return Option.some(yield* load$1(accumulated, {
 		...options,
 		declared: known
 	}));
 });
 Effect.fn("PluginCatalog.prepare")(function* (references, options) {
-	const pool = yield* load$2(references, options);
+	const pool = yield* load$1(references, options);
 	return (yield* select(references, pool)).selection;
 });
 //#endregion
@@ -7178,7 +7695,7 @@ const make$7 = (options) => Effect.gen(function* () {
 });
 //#endregion
 //#region src/runner/execute.ts
-const layer$7 = Layer.effect(Service$6, Effect.gen(function* () {
+const layer$6 = Layer.effect(Service$6, Effect.gen(function* () {
 	const store = yield* Service$14;
 	const sandbox = yield* Controller;
 	const sql = yield* SqlClient.SqlClient;
@@ -7244,11 +7761,6 @@ const layer$7 = Layer.effect(Service$6, Effect.gen(function* () {
 	});
 }));
 //#endregion
-//#region src/settings/schema.ts
-var schema_exports$3 = /* @__PURE__ */ __exportAll({});
-import * as import__codeworksh_plugin_settings from "@codeworksh/plugin/settings";
-__reExport(schema_exports$3, import__codeworksh_plugin_settings);
-//#endregion
 //#region src/settings/resolve.ts
 const patternMatches = (pattern, id) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`).test(id);
 function collect(settings, provider, id) {
@@ -7287,11 +7799,12 @@ function resolveRequest(block, model) {
 		"toolExecution",
 		"contextWindow",
 		"protocol",
+		"apiKey",
 		"extras"
 	].includes(key)));
 	return {
 		...resolveOptions(block),
-		...Object.keys(bag).length === 0 ? {} : { providerOptions: { [Model$1.optionsKey(model)]: bag } }
+		...Object.keys(bag).length === 0 ? {} : { providerOptions: { [Model.optionsKey(model)]: bag } }
 	};
 }
 /**
@@ -7525,15 +8038,27 @@ const messageFailure = (message) => {
 };
 /** Resolve once before exchange setup; execution reuses this exact instance. */
 const resolve$1 = Effect.fn("LLM.resolve")(function* (input) {
-	const model = yield* Effect.tryPromise({
-		try: () => llm(input.provider, input.model, resolveOverrides(input.settings ?? {})),
+	const overrides = resolveOverrides(input.settings ?? {});
+	const declared = entry(input.models ?? [], input.provider, input.model);
+	const model = declared !== void 0 ? {
+		...declared,
+		...overrides
+	} : yield* Effect.tryPromise({
+		try: () => llm(input.provider, input.model, overrides),
 		catch: (cause) => loadError(cause) ?? providerErrorFromUnknown(input, cause)
 	});
 	if (model === void 0) return yield* new ModelNotFoundError({
 		provider: input.provider,
 		model: input.model
 	});
-	return model;
+	const apiKey = input.settings?.apiKey;
+	return apiKey === void 0 ? model : {
+		...model,
+		provider: {
+			...model.provider,
+			key: (0, schema_exports$3.keyName)(apiKey)
+		}
+	};
 });
 /**
 * Fill in what an OAuth provider needs and the model catalog cannot carry: the
@@ -7542,7 +8067,7 @@ const resolve$1 = Effect.fn("LLM.resolve")(function* (input) {
 * with no stored login resolves to `{}` so aikit reports the missing key.
 */
 const oauthCredentials = async (protocol, options) => {
-	const storage = options.authFile === void 0 ? {} : { path: options.authFile };
+	const storage = oauthStorage(options.authFile);
 	if (protocol === "openai-codex") {
 		const apiKey = await getOpenAICodexApiKey({ storage: new JsonOpenAICodexAuthStorage(storage) });
 		return apiKey === void 0 ? {} : { apiKey };
@@ -7915,20 +8440,109 @@ const make$3 = (tools) => {
 Context.Service()("@codeworksh/harness/tool/registry/ToolRegistry");
 const make$2 = () => {
 	let open = true;
-	let value;
+	let foundation;
+	const sections = /* @__PURE__ */ new Map();
+	const writable = () => {
+		if (!open) throw new Error("prompt registry is closed");
+	};
+	const slot = (section) => {
+		writable();
+		const reason = Section.invalid(section.name);
+		if (reason !== void 0) throw new Error(reason);
+		if (!Section.isFormat(section.format)) throw new Error(`prompt section ${section.name} has an unknown format: ${JSON.stringify(section.format)}`);
+		const builtin = Section.builtins.find((candidate) => candidate.name === section.name);
+		if (builtin !== void 0 && builtin.format !== section.format) throw new Error(`prompt section ${section.name} is built in as "${builtin.format}"`);
+		const existing = sections.get(section.name);
+		if (existing === void 0) {
+			const opened = {
+				format: section.format,
+				entries: []
+			};
+			sections.set(section.name, opened);
+			return opened;
+		}
+		if (existing.format !== section.format) throw new Error(`prompt section ${section.name} is "${existing.format}"; a write as "${section.format}" cannot merge into it`);
+		return existing;
+	};
 	return {
 		registry: Object.freeze({
-			set: (prompt) => {
-				if (!open) throw new Error("prompt registry is closed");
-				value = prompt;
-			},
-			get: () => value
+			foundation: Object.freeze({
+				set: (text) => {
+					writable();
+					foundation = text;
+				},
+				get: () => foundation
+			}),
+			sections: Object.freeze({
+				append: (section, entry) => {
+					slot(section).entries.push(entry);
+				},
+				set: (section, entries) => {
+					slot(section).entries = [...entries];
+				},
+				remove: (section) => {
+					writable();
+					sections.delete(section.name);
+				},
+				get: (section) => {
+					const found = sections.get(section.name);
+					return found === void 0 ? void 0 : Object.freeze([...found.entries]);
+				}
+			})
 		}),
 		close: () => {
 			open = false;
 		},
-		value: () => value
+		snapshot: () => ({
+			foundation,
+			sections: new Map(Array.from(sections, ([name, { format, entries }]) => [name, {
+				format,
+				entries: [...entries]
+			}]))
+		})
+	};
+};
+//#endregion
+//#region src/plugin/prompt/render.ts
+const tag = (name, body) => `<${name}>\n${body}\n</${name}>`;
+/** Two spellings of one list entry dedupe against each other. */
+const normalize = (value) => value.trim().replace(/\s+/g, " ");
+const body = ({ format, entries }) => {
+	if (format === "text") {
+		const kept = entries.filter((entry) => entry.trim().length > 0);
+		return kept.length === 0 ? void 0 : kept.join("\n\n");
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const normalized = normalize(entry);
+		if (normalized.length > 0) seen.add(normalized);
+	}
+	return seen.size === 0 ? void 0 : Array.from(seen, (line) => `- ${line}`).join("\n");
+};
+/** `(none)` rather than no section: a model told it has no tools behaves better than one left guessing. */
+const toolIndex = (tools) => {
+	const listed = tools.filter((tool) => tool.promptSnippet !== void 0 && tool.promptSnippet.length > 0);
+	if (listed.length === 0) return "(none)";
+	return listed.map((tool) => `- ${tool.name}: ${tool.promptSnippet}`).join("\n");
+};
+const render = (input) => {
+	const written = new Map(input.prompt.sections);
+	const guidelines = input.tools.flatMap((tool) => tool.promptGuidelines ?? []);
+	written.set(Section.Rules.name, {
+		format: Section.Rules.format,
+		entries: [...guidelines, ...written.get(Section.Rules.name)?.entries ?? []]
+	});
+	const parts = [input.prompt.foundation ?? "You are an expert coding assistant operating inside codework, a coding agent harness.", tag("tools", toolIndex(input.tools))];
+	const push = (name) => {
+		const section = written.get(name);
+		const rendered = section === void 0 ? void 0 : body(section);
+		if (rendered !== void 0) parts.push(tag(name, rendered));
+		written.delete(name);
 	};
+	for (const section of Section.builtins) push(section.name);
+	parts.push(tag("cwd", input.directory));
+	for (const name of Array.from(written.keys())) push(name);
+	return parts.join("\n\n");
 };
 //#endregion
 //#region src/plugin/tool/registry.ts
@@ -8020,11 +8634,16 @@ const make = () => {
 			prompt: prompt.registry
 		}),
 		close,
-		freeze: () => {
+		freeze: (directory) => {
 			close();
+			const resolved = make$3(tools.entries()).resolve();
 			return {
-				tools: make$3(tools.entries()).resolve(),
-				systemPrompt: prompt.value() ?? "You are an AI agent for CodeWork. CodeWork is the best agent harness for code & work."
+				tools: resolved,
+				systemPrompt: render({
+					prompt: prompt.snapshot(),
+					tools: resolved.defs,
+					directory
+				})
 			};
 		}
 	};
@@ -8069,7 +8688,7 @@ const run = Effect.fn("PluginHost.run")(function* (selection, input) {
 			}));
 		}));
 		return yield* Effect.try({
-			try: buckets.freeze,
+			try: () => buckets.freeze(input.location.directory),
 			catch: (cause) => new SetupError({
 				message: `plugin snapshot freeze failed: ${cause instanceof Error ? cause.message : String(cause)}`,
 				cause
@@ -8079,8 +8698,8 @@ const run = Effect.fn("PluginHost.run")(function* (selection, input) {
 });
 //#endregion
 //#region src/session/runtime.ts
-var Service$3 = class extends Context.Service()("@codeworksh/harness/session/runtime/Service") {};
-const layer$6 = Layer.effect(Service$3, Effect.gen(function* () {
+var Service$2 = class extends Context.Service()("@codeworksh/harness/session/runtime/Service") {};
+const layer$5 = Layer.effect(Service$2, Effect.gen(function* () {
 	const bindings = yield* Ref.make(/* @__PURE__ */ new Map());
 	const get = (sessionId) => Ref.get(bindings).pipe(Effect.map((entries) => Option.fromUndefinedOr(entries.get(sessionId))));
 	const set = (sessionId, value) => Ref.update(bindings, (entries) => {
@@ -8101,7 +8720,7 @@ const layer$6 = Layer.effect(Service$3, Effect.gen(function* () {
 		next.delete(sessionId);
 		return next;
 	});
-	return Service$3.of({
+	return Service$2.of({
 		get,
 		set,
 		update,
@@ -8109,202 +8728,6 @@ const layer$6 = Layer.effect(Service$3, Effect.gen(function* () {
 	});
 }));
 //#endregion
-//#region src/settings/settings.ts
-var settings_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$2,
-	Settings: () => settings_exports,
-	SettingsError: () => SettingsError,
-	defaults: () => schema_exports$3.defaults,
-	layer: () => layer$5,
-	load: () => load$1,
-	modules: () => modules,
-	parse: () => parse$1,
-	paths: () => paths,
-	projectRoot: () => projectRoot,
-	userConfigDir: () => userConfigDir
-});
-/**
-* 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.
-*/
-const userConfigDir = (raw, hostCwd) => hostPath.resolve(hostCwd, expandTilde(raw, hostPath));
-/** The settings files a directory may hold, in the order it is searched. */
-const settingsIn = (directory) => [hostPath.join(directory, "settings.jsonc"), hostPath.join(directory, "settings.json")];
-/** A directory and every ancestor above it, nearest first. */
-const ancestors = (from) => {
-	const chain = [];
-	for (let directory = from;; directory = hostPath.dirname(directory)) {
-		chain.push(directory);
-		if (hostPath.dirname(directory) === directory) return chain;
-	}
-};
-const isDirectory = (path) => fileSystem.stat(path).pipe(Effect.map((info) => info.type === "Directory"), Effect.orElseSucceed(() => false));
-/**
-* The project a directory is in: the nearest ancestor holding a `.codework` **directory**.
-*
-* This is git's rule. `~/workspace/app/.codework` makes `~/workspace/app` a project, and
-* `~/workspace/app/packages/fubar` is inside it. Nearest wins outright -- the walk stops at the
-* first marker, so an inner project is never merged with an outer one.
-*
-* The marker is the directory, not a file in it. An empty `.codework/` is still a project root,
-* which is the point: creating the directory is how a person says "a project begins here", and it
-* has to mean that before any settings exist. It also makes the question one `stat` per ancestor
-* whose answer does not change as files come and go inside.
-*
-* `<home>` is skipped. `~/.codework` is the user layer, not a project; without this, running
-* anywhere under `$HOME` would find it as one and read the user layer twice -- and since plugin
-* entries accumulate across layers, every user plugin would load twice.
-*/
-const projectRoot = Effect.fn("Settings.projectRoot")(function* (from, home) {
-	const userConfig = hostPath.resolve(home);
-	for (const directory of ancestors(hostPath.resolve(from))) {
-		const marker = hostPath.join(directory, appConfigDir);
-		if (hostPath.resolve(marker) === userConfig) continue;
-		if (yield* isDirectory(marker)) return directory;
-	}
-});
-/**
-* Ordered layers, each a group of candidates where the first file that exists is selected -- a
-* group never contributes more than one file.
-*
-* `.jsonc` is the canonical spelling: these files are written by hand and read as JSONC, so the
-* extension says what the file is and an editor validates it as such. `.json` remains a fallback
-* everywhere, tried second, because the parser reads either and a file already named that must
-* keep working.
-*
-* `root` is an already-discovered project root ({@link projectRoot}), not a directory to search
-* from: the walk is a `stat` per ancestor and belongs with the other I/O. `undefined` contributes
-* no project layer at all, which is what a session with no host directory gets.
-*/
-function paths(input) {
-	return [settingsIn(input.userConfigDir ?? input.home), input.root === void 0 ? [] : settingsIn(hostPath.join(input.root, appConfigDir))];
-}
-var SettingsError = class extends Schema.TaggedError()("SettingsError", {
-	path: Schema.String,
-	reason: Schema.Literals([
-		"read",
-		"parse",
-		"decode"
-	]),
-	detail: Schema.String
-}) {
-	get message() {
-		return `${this.path}: ${this.reason}: ${this.detail}`;
-	}
-};
-/** `line:column`, 1-based, for a parser offset into the source. */
-const at = (source, offset) => {
-	const before = source.slice(0, offset).split("\n");
-	return `${before.length}:${(before.at(-1)?.length ?? 0) + 1}`;
-};
-const parse$1 = Effect.fn("Settings.parse")(function* (path, source) {
-	const errors = [];
-	const json = parse(source, errors, {
-		allowTrailingComma: true,
-		disallowComments: false
-	});
-	const first = errors[0];
-	if (first !== void 0) return yield* new SettingsError({
-		path,
-		reason: "parse",
-		detail: `${printParseErrorCode(first.error)} at ${at(source, first.offset)}`
-	});
-	const document = normalize(json);
-	if (Predicate.isObject(document) && Predicate.isObject(json) && "plugins" in json) Object.assign(document, { plugins: json.plugins });
-	return yield* Schema.decodeUnknownEffect(schema_exports$3.Patch)(document).pipe(Effect.mapError((error) => new SettingsError({
-		path,
-		reason: "decode",
-		detail: SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => `${issue.path?.map((part) => typeof part === "object" ? String(part.key) : part).join(".") ?? "settings"}: invalid value`).join("; ")
-	})));
-});
-var Service$2 = class extends Context.Service()("@codeworksh/harness/settings/settings/Service") {};
-/**
-* Anchor relative plugin entries to the file that declared them.
-*
-* A reference is otherwise resolved against the host startup directory, which is right for
-* a project file sitting in it and meaningless for `~/.codework/settings.json`, where
-* `./plugins/x.ts` would name a different file in every project the process is started in.
-* `file:` URLs, package specs and package names are left exactly as written, and a `plugin`
-* key is an ID rather than a location. A configuration entry's `package` is anchored like a
-* module entry, so a relative path names the same module in both spellings.
-*/
-const anchored = (entry, file) => {
-	const directory = hostPath.dirname(file);
-	const resolve = (reference) => reference.startsWith("./") || reference.startsWith("../") ? hostPath.resolve(directory, reference) : reference;
-	if (typeof entry === "string") return resolve(entry);
-	return "package" in entry ? {
-		...entry,
-		package: resolve(entry.package)
-	} : entry;
-};
-const anchor = (patch, file) => patch.plugins === void 0 ? patch : {
-	...patch,
-	plugins: patch.plugins.map((entry) => anchored(entry, file))
-};
-const attempt = (path) => fileSystem.readFileString(path).pipe(Effect.mapError((error) => new SettingsError({
-	path,
-	reason: "read",
-	detail: error.reason._tag
-})), Effect.flatMap((source) => parse$1(path, source)));
-/**
-* One read of every layer. Exported for the harness constructor, which needs the plugin
-* selection before any layer is built; everything else goes through `Service`.
-*/
-const load$1 = Effect.fn("Settings.load")(function* (options) {
-	const root = options.hostDir === void 0 ? void 0 : yield* projectRoot(options.hostDir, options.home);
-	const files = paths({
-		home: options.home,
-		root,
-		...options.userConfigDir === void 0 ? {} : { userConfigDir: options.userConfigDir }
-	});
-	let settings = merge(schema_exports$3.defaults);
-	let declared = schema_exports$3.defaults.declared;
-	for (const group of files) for (const path of group) {
-		const result = yield* Effect.result(attempt(path));
-		if (Result.isSuccess(result)) {
-			const patch = anchor(result.success, path);
-			settings = merge(settings, patch);
-			if (result.success.plugins !== void 0) declared = [...declared, ...result.success.plugins.map((written) => ({
-				written,
-				entry: anchored(written, path),
-				file: path
-			}))];
-			break;
-		}
-		const error = result.failure;
-		if (error.reason === "read" && error.detail === "NotFound") continue;
-		return yield* error;
-	}
-	return {
-		...settings,
-		plugins: declared.map((one) => one.entry),
-		declared
-	};
-});
-/**
-* 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.
-*/
-const modules = (declared) => {
-	const owners = /* @__PURE__ */ new Map();
-	for (const one of declared) if (typeof one.entry === "string") owners.set(one.entry, one);
-	return owners;
-};
-const layer$5 = (options = {}) => Layer.effect(Service$2, Effect.gen(function* () {
-	const global = yield* Service$17;
-	return Service$2.of({ load: (hostDir) => load$1({
-		...options,
-		home: global.home,
-		hostDir
-	}) });
-}));
-//#endregion
 //#region src/state/state.ts
 var state_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
@@ -8354,9 +8777,9 @@ const resolver = (input) => typeof input === "string" ? () => input : input;
 */
 const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effect.undefined) => {
 	return Layer.effect(Service$1, Effect.gen(function* () {
-		const runtime = yield* Service$3;
+		const runtime = yield* Service$2;
 		const sessions = yield* Service$14;
-		const settings = yield* Service$2;
+		const settings = yield* Service$3;
 		const eventRegistry = yield* Service$4;
 		const eventService = yield* Service$16;
 		const events = makeEvents(eventService);
@@ -8409,6 +8832,26 @@ const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effe
 			..."reference" in cause && typeof cause.reference === "string" ? { reference: cause.reference } : {},
 			...sessionId === void 0 ? {} : { sessionId }
 		});
+		/** Settings and composed configuration for a session's next exchange. */
+		const configure = Effect.fnUntraced(function* (sessionId) {
+			const session = Option.getOrUndefined(yield* sessions.get(sessionId));
+			const hostDir = session === void 0 ? void 0 : Option.getOrUndefined(session.hostDir);
+			const chosen = session === void 0 ? {} : Option.getOrElse(session.config, () => ({}));
+			const sessionOptions = {
+				...chosen.model === void 0 ? {} : {
+					provider: chosen.model.provider,
+					model: chosen.model.id
+				},
+				...chosen.thinkingLevel === void 0 ? {} : { thinkingLevel: chosen.thinkingLevel },
+				...Option.getOrElse(yield* runtime.get(sessionId), () => ({}))
+			};
+			const loadedSettings = yield* settings.load(hostDir);
+			return {
+				hostDir,
+				loadedSettings,
+				configured: compose(loadedSettings, options, sessionOptions)
+			};
+		});
 		return Service$1.of({
 			reload: Effect.gen(function* () {
 				const failures = /* @__PURE__ */ new Map();
@@ -8427,12 +8870,16 @@ const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effe
 					failure: first
 				};
 			}),
+			configuration: Effect.fn("State.configuration")(function* (sessionId) {
+				const { configured } = yield* configure(sessionId);
+				return {
+					provider: configured.provider,
+					model: configured.model,
+					thinkingLevel: configured.thinkingLevel
+				};
+			}),
 			snapshot: Effect.fn("State.snapshot")(function* (sessionId) {
-				const sessionOptions = Option.getOrElse(yield* runtime.get(sessionId), () => ({}));
-				const session = yield* sessions.get(sessionId);
-				const hostDir = Option.isNone(session) ? void 0 : Option.getOrUndefined(session.value.hostDir);
-				const loadedSettings = yield* settings.load(hostDir);
-				const configured = compose(loadedSettings, options, sessionOptions);
+				const { hostDir, loadedSettings, configured } = yield* configure(sessionId);
 				const { promptCustom, promptSystemAppend, provider: _provider, model: _model, thinkingLevel: _thinkingLevel, toolExecution: _toolExecution, ...rest } = configured.runtime;
 				const { provider, model, thinkingLevel, toolExecution } = configured;
 				const request = merge(resolveOptions(configured.block), rest);
@@ -8441,7 +8888,8 @@ const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effe
 				const resolvedModel = yield* resolve$1({
 					provider,
 					model,
-					settings: configured.block
+					settings: configured.block,
+					models: loadedSettings.models
 				});
 				const refs = references(loadedSettings);
 				const failed = (cause) => new SnapshotError({
@@ -8460,7 +8908,15 @@ const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effe
 				const chosen = yield* select(refs, loaded).pipe(Effect.mapError(failed));
 				for (const reference of chosen.missing) {
 					const where = loadedSettings.declared.find((one) => typeof one.entry === "string" ? one.entry === reference : "package" in one.entry && one.entry.package === reference);
-					yield* Effect.logWarning(`plugin ${reference} is configured but not loaded — run \`codework plugin install\`${where === void 0 ? "" : ` (declared in ${where.file})`}`);
+					const error = `plugin ${reference} is configured but not loaded — run \`codework plugin install\`${where === void 0 ? "" : ` (declared in ${where.file})`}`;
+					yield* Effect.logWarning(error);
+					yield* eventService.publish(PluginUpdated, {
+						status: "failed",
+						reference,
+						error,
+						...where === void 0 ? {} : { file: where.file },
+						sessionId
+					});
 				}
 				return {
 					sessionId,
@@ -8488,13 +8944,34 @@ const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effe
 					thinkingLevel,
 					request,
 					settings: configured.block,
-					toolExecution
+					toolExecution,
+					retry: loadedSettings.retry
 				};
 			})
 		});
 	}));
 };
 //#endregion
+//#region src/runner/retry.ts
+/**
+* Milliseconds to wait before retry `attempt` (1-based), or `undefined` to give up.
+*
+* Only a provider failure the provider itself calls transient is retried. A quota error is
+* excluded even though it often arrives as a retryable 429: waiting does not refill a quota.
+* Context overflow is a non-retryable 400 and is left to compaction.
+*
+* A server-sent `retry-after` raises the delay, never lowers it. One longer than `maxDelayMs`
+* gives up rather than retrying early into the same rejection.
+*/
+const delay = (policy, attempt, error) => {
+	if (attempt > policy.maxRetries) return void 0;
+	if (!Schema.is(ProviderError)(error) || !error.isRetryable) return void 0;
+	if (error.reason._tag === "Runner.ProviderQuotaError") return void 0;
+	const backoff = Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
+	const requested = error.reason.retryAfter === void 0 ? 0 : Duration.toMillis(error.reason.retryAfter);
+	return requested > policy.maxDelayMs ? void 0 : Math.max(backoff, Math.ceil(requested));
+};
+//#endregion
 //#region src/runner/loop.ts
 const terminalResult = (text) => ({
 	content: [{
@@ -8614,7 +9091,9 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 					sessionId: snapshot.sessionId,
 					messageId,
 					callID: call.callID,
-					name: call.name
+					name: call.name,
+					label: snapshot.tools.defs.find((def) => def.name === call.name)?.label,
+					arguments: call.arguments
 				});
 				const handled = yield* snapshot.tools.handle(call, {
 					sessionId: snapshot.sessionId,
@@ -8661,11 +9140,14 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 		if (leaf !== void 0 && (leaf.stopReason === "stop" || leaf.stopReason === "length")) return { needsContinuation: false };
 		let publisher;
 		let committed = false;
-		return yield* Effect.gen(function* () {
-			yield* events.publish(TurnStarted, {
-				timestamp: yield* DateTime.now,
-				sessionId
-			});
+		let retries = 0;
+		/** Abort the latest attempt's draft, unless its own terminal event already did. */
+		const settleDraft = (cause) => Effect.gen(function* () {
+			if (publisher?.startedMessageId === void 0) return;
+			const stored = yield* sessions.entry(publisher.startedMessageId);
+			if (Option.isSome(stored) && stored.value.entry.state === "draft") yield* publishFailure(stored.value, cause);
+		});
+		const attempt = Effect.gen(function* () {
 			publisher = yield* make$6({ sessionId }).pipe(Effect.provideService(Service$16, events));
 			const terminal = yield* requestLLM({
 				sessionId,
@@ -8689,6 +9171,43 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 					model: snapshot.model
 				}, messageFailure(terminal.message));
 			}
+			return terminal;
+		});
+		const request = () => attempt.pipe(Effect.catch((error) => {
+			const delayMs = delay(snapshot.retry, retries + 1, error);
+			if (delayMs === void 0) return Effect.fail(error);
+			return Effect.gen(function* () {
+				retries += 1;
+				yield* Effect.uninterruptible(settleDraft({
+					_tag: "error",
+					message: error.message
+				}));
+				yield* events.publish(RetryScheduled, {
+					timestamp: yield* DateTime.now,
+					sessionId,
+					attempt: retries,
+					maxRetries: snapshot.retry.maxRetries,
+					delayMs,
+					message: error.message
+				});
+				yield* Effect.sleep(Duration.millis(delayMs));
+				return yield* request();
+			});
+		}));
+		return yield* Effect.gen(function* () {
+			yield* events.publish(TurnStarted, {
+				timestamp: yield* DateTime.now,
+				sessionId
+			});
+			const terminal = yield* request().pipe(Effect.onExit((exit) => retries === 0 ? Effect.void : Effect.gen(function* () {
+				yield* events.publish(RetryFinished, {
+					timestamp: yield* DateTime.now,
+					sessionId,
+					attempt: retries,
+					success: Exit.isSuccess(exit),
+					...Exit.isSuccess(exit) ? {} : { message: Cause.hasInterrupts(exit.cause) ? "interrupted" : errorMessage(exit.cause) }
+				});
+			})));
 			const interrupted = yield* settleTools(snapshot, terminal.message, terminal.reason, () => {
 				committed = true;
 			});
@@ -8697,24 +9216,20 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 				needsContinuation: terminal.reason === "toolUse",
 				messageId: terminal.message.messageId
 			};
-		}).pipe(Effect.catchCause((cause) => {
-			if (committed) return Effect.failCause(cause);
+		}).pipe(Effect.onError((cause) => {
+			if (committed) return Effect.void;
 			const turnCause = Cause.hasInterrupts(cause) ? { _tag: "interrupted" } : {
 				_tag: "error",
 				message: errorMessage(cause)
 			};
-			const record = Effect.gen(function* () {
-				if (publisher?.startedMessageId !== void 0) {
-					const stored = yield* sessions.entry(publisher.startedMessageId);
-					if (Option.isSome(stored) && stored.value.entry.state === "draft") yield* publishFailure(stored.value, turnCause);
-				}
+			return Effect.gen(function* () {
+				yield* settleDraft(turnCause);
 				yield* events.publish(TurnAborted, {
 					timestamp: yield* DateTime.now,
 					sessionId,
 					cause: turnCause
 				});
 			});
-			return Effect.uninterruptible(record).pipe(Effect.andThen(Effect.failCause(cause)));
 		}));
 	});
 	const runTurn = Effect.fn("Loop.runTurn")(function* (promotion, snapshot) {
@@ -8868,10 +9383,7 @@ const layer$2 = Layer.effectDiscard(Effect.gen(function* () {
 			messageId: event.data.messageId,
 			role: "user",
 			time: { created: DateTime.toEpochMillis(event.data.timestamp) },
-			parts: [{
-				type: "text",
-				text: event.data.prompt.text
-			}]
+			parts: [...event.data.prompt.parts]
 		})).pipe(Effect.orDie);
 		yield* sessions.append({
 			id: event.data.messageId,
@@ -8881,7 +9393,13 @@ const layer$2 = Layer.effectDiscard(Effect.gen(function* () {
 			...encoded,
 			...event.metadata === void 0 ? {} : { metadata: event.metadata }
 		}).pipe(Effect.orDie);
+		const title = titleFrom(Prompt.text(event.data.prompt));
+		if (title !== void 0) yield* sessions.retitle(event.data.sessionId, title);
 	}));
+	yield* events.project(ConfigChanged, (event) => {
+		const { sessionId, timestamp: _timestamp, ...config } = event.data;
+		return sessions.configure(sessionId, config);
+	});
 	yield* events.project(LLMStarted, (event) => Effect.gen(function* () {
 		if (event.durable === void 0) return yield* Effect.die("LLMStarted is missing its aggregate sequence");
 		const encoded = yield* encodeAssistant({
@@ -8950,9 +9468,9 @@ var harness_exports = /* @__PURE__ */ __exportAll({
 const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	const hostCwd = options.hostCwd ?? process.cwd();
 	const paths = yield* resolve$3(options.home === void 0 ? {} : { home: hostPath.resolve(hostCwd, expandTilde(options.home, hostPath)) });
-	const global = layerWith$1(paths);
+	const global = layerWith(paths);
 	const settingsOptions = options.userConfigDir === void 0 ? {} : { userConfigDir: userConfigDir(options.userConfigDir, hostCwd) };
-	const config = yield* load$1({
+	const config = yield* load$3({
 		...settingsOptions,
 		home: paths.home
 	});
@@ -8969,12 +9487,12 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	* `hostDir` led to; only the process view falls back to `hostCwd`.
 	*/
 	const hostDirOf = (root) => root ?? hostCwd;
-	const filed = (reference, from) => parse$2(reference, from).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
+	const filed = (reference, from) => parse$1(reference, from).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
 	const resolveOnly = {
 		...catalogOptions,
 		install: required
 	};
-	const pool = yield* Ref.make(yield* load$2(references(config), {
+	const pool = yield* Ref.make(yield* load$1(references(config), {
 		...resolveOnly,
 		declared: declaredIn(config)
 	}));
@@ -8988,7 +9506,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	let reloads = 0;
 	const rebuild = (root, loaded) => Effect.gen(function* () {
 		reloads += 1;
-		const current = yield* load$1({
+		const current = yield* load$3({
 			...settingsOptions,
 			home: paths.home,
 			...root === void 0 ? {} : { hostDir: root }
@@ -8996,7 +9514,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 		const retained = [];
 		const configured = references(current);
 		for (const origin of loaded.origins.values()) {
-			if (configured.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor$1(origin.file, hostDirOf(root))))) {
+			if (configured.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor(origin.file, hostDirOf(root))))) {
 				retained.push(origin);
 				continue;
 			}
@@ -9006,7 +9524,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 		const known = /* @__PURE__ */ new Map();
 		for (const origin of retained) if (origin.file !== void 0) known.set(origin.reference, origin.file);
 		for (const [reference, file] of declaredIn(current)) known.set(reference, file);
-		return yield* load$2(accumulated, {
+		return yield* load$1(accumulated, {
 			...resolveOnly,
 			hostDir: hostDirOf(root),
 			declared: known,
@@ -9021,10 +9539,10 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	const authFile$1 = authFile(options.home === void 0 ? void 0 : paths.home);
 	const open = options.llm ?? openWith(authFile$1 === void 0 ? {} : { authFile: authFile$1 });
 	const loop = layer$3({ request: make$5(open) });
-	return layer$10.pipe(Layer.provideMerge(layer$7.pipe(Layer.provide(loop))), Layer.provideMerge(layer$4({}, pool, references, followStore, rebuild, viewOf)), Layer.provideMerge(layer$5(settingsOptions)), Layer.provideMerge(layer$6), Layer.provideMerge(sandboxes), Layer.provideMerge(layer$22), Layer.provideMerge(layer$1), Layer.provideMerge(layer$25), Layer.provideMerge(layer$9(definitions)), Layer.provideMerge(database), Layer.provideMerge(global), Layer.provideMerge(layer$8({
+	return layer$10.pipe(Layer.provideMerge(layer$6.pipe(Layer.provide(loop))), Layer.provideMerge(layer$4({}, pool, references, followStore, rebuild, viewOf)), Layer.provideMerge(layer$8(settingsOptions)), Layer.provideMerge(layer$5), Layer.provideMerge(sandboxes), Layer.provideMerge(layer$22), Layer.provideMerge(layer$1), Layer.provideMerge(layer$25), Layer.provideMerge(layer$9(definitions)), Layer.provideMerge(database), Layer.provideMerge(global), Layer.provideMerge(layer$7({
 		home: paths.home,
 		watch: options.watchModels ?? false
-	})));
+	})), Layer.provideMerge(Layer.succeed(Credentials, { authFile: authFile$1 })));
 }));
 //#endregion
 //#region src/effect/sandbox.ts
@@ -9151,30 +9669,54 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	SessionMessageSchema: () => schema_exports$4,
 	SessionSchema: () => schema_exports$8,
 	attach: () => attach,
+	configuration: () => configuration,
 	create: () => create$1,
 	get: () => get,
 	link: () => link,
 	relink: () => relink
 });
+/** What stays in this process. The model and thinking level are the session's {@link chosen} config. */
 const runtimeBindings = (input) => ({
 	...input.model?.options,
-	...input.model === void 0 ? {} : {
-		provider: input.model.provider,
-		model: input.model.id
-	},
-	...input.thinkingLevel === void 0 ? {} : { thinkingLevel: input.thinkingLevel },
 	...input.tools?.execution === void 0 ? {} : { toolExecution: input.tools.execution },
 	...input.systemPrompt?.custom === void 0 ? {} : { promptCustom: input.systemPrompt.custom },
 	...input.systemPrompt?.append === void 0 ? {} : { promptSystemAppend: input.systemPrompt.append }
 });
-const promptInput = (input) => {
+/** The keys of the session's durable config this input names. */
+const chosen = (input) => ({
+	...input.model === void 0 ? {} : { model: {
+		provider: input.model.provider,
+		id: input.model.id
+	} },
+	...input.thinkingLevel === void 0 ? {} : { thinkingLevel: input.thinkingLevel }
+});
+/** Records a config choice; the projector merges it into the session row in the same commit. */
+const choose = Effect.fn("Session.choose")(function* (sessionId, input) {
+	const config = chosen(input);
+	if (Object.keys(config).length === 0) return;
+	yield* (yield* Service$16).publish(ConfigChanged, {
+		sessionId,
+		timestamp: yield* DateTime.now,
+		...config
+	});
+});
+const promptInput = Effect.fnUntraced(function* (input) {
 	const value = typeof input === "string" ? { text: input } : input;
+	const parts = "parts" in value ? value.parts : [{
+		type: "text",
+		text: value.text
+	}];
+	if (parts.length === 0) return yield* new InvalidPromptError({ reason: "A prompt needs at least one part" });
+	for (const part of parts) {
+		const problem = part.type === "image" ? imageProblem(part) : void 0;
+		if (problem !== void 0) return yield* new InvalidPromptError({ reason: problem });
+	}
 	return {
-		prompt: Prompt.make({ text: value.text }),
+		prompt: Prompt.make({ parts }),
 		...value.delivery === void 0 ? {} : { delivery: value.delivery },
 		...value.id === void 0 ? {} : { id: value.id }
 	};
-};
+});
 const makeHandle = Effect.fn("Session.makeHandle")(function* (id) {
 	const sessions = yield* Service$14;
 	const control = yield* Service$5;
@@ -9200,14 +9742,14 @@ const makeHandle = Effect.fn("Session.makeHandle")(function* (id) {
 		id,
 		active: control.active.pipe(Effect.map((active) => active.has(id))),
 		info,
-		prompt: (input) => control.prompt({
+		prompt: (input) => promptInput(input).pipe(Effect.flatMap((prompt) => control.prompt({
 			sessionId: id,
-			...promptInput(input)
-		}),
-		run: (input) => control.run({
+			...prompt
+		}))),
+		run: (input) => promptInput(input).pipe(Effect.flatMap((prompt) => control.run({
 			sessionId: id,
-			...promptInput(input)
-		}),
+			...prompt
+		}))),
 		wait: () => control.wait(id),
 		resume: () => control.resume(id),
 		interrupt: () => control.interrupt(id, { awaitSettlement: true }),
@@ -9217,7 +9759,7 @@ const makeHandle = Effect.fn("Session.makeHandle")(function* (id) {
 });
 const create$1 = Effect.fn("Session.create")(function* (input = {}) {
 	const sessions = yield* Service$14;
-	const runtime = yield* Service$3;
+	const runtime = yield* Service$2;
 	const sandboxes = yield* Controller;
 	const id = ID$1.create();
 	const sandboxId = input.sandbox?.id ?? instance_exports.SandboxInstance.ID.local;
@@ -9226,11 +9768,11 @@ const create$1 = Effect.fn("Session.create")(function* (input = {}) {
 		id,
 		spaceId: location.space.id,
 		directory: location.directory,
-		slug: id,
 		title: input.title ?? "Session",
 		...input.hostDir === void 0 ? {} : { hostDir: declaredHostDir(input.hostDir) }
 	});
 	yield* runtime.set(id, runtimeBindings(input));
+	yield* choose(id, input);
 	return yield* makeHandle(id);
 });
 /**
@@ -9296,9 +9838,20 @@ const get = Effect.fn("Session.get")(function* (sessionId) {
 const attach = Effect.fn("Session.attach")(function* (input) {
 	const found = yield* get(input.sessionId);
 	if (Option.isNone(found)) return yield* new SessionNotFoundError({ sessionId: input.sessionId });
-	yield* (yield* Service$3).update(input.sessionId, runtimeBindings(input));
+	yield* (yield* Service$2).update(input.sessionId, runtimeBindings(input));
+	yield* choose(input.sessionId, input);
 	return found.value;
 });
+/**
+* The model and thinking level the session's next exchange runs with. A choice made through
+* {@link create} or {@link attach} is saved with the session and outlives the process; without
+* one, the session follows its settings.
+*/
+const configuration = Effect.fn("Session.configuration")(function* (sessionId) {
+	const sessions = yield* Service$14;
+	if (Option.isNone(yield* sessions.get(sessionId))) return yield* new SessionNotFoundError({ sessionId });
+	return yield* Service$1.use((state) => state.configuration(sessionId));
+});
 //#endregion
 //#region src/plugin/prompt/schema.ts
 var schema_exports$1 = /* @__PURE__ */ __exportAll({});
@@ -9310,11 +9863,12 @@ var plugin_exports = /* @__PURE__ */ __exportAll({
 	InstallError: () => InstallError,
 	LoadError: () => LoadError,
 	Prompt: () => schema_exports$1,
+	Section: () => Section,
 	SetupError: () => SetupError,
 	SourceError: () => SourceError,
 	StoreError: () => StoreError,
 	Tool: () => schema_exports$2,
-	anchor: () => anchor$1,
+	anchor: () => anchor,
 	canonical: () => canonical,
 	check: () => check,
 	define: () => plugin_exports$1.define,
@@ -9322,7 +9876,7 @@ var plugin_exports = /* @__PURE__ */ __exportAll({
 	identity: () => digest,
 	inspect: () => inspect,
 	localName: () => localName,
-	parse: () => parse$2,
+	parse: () => parse$1,
 	probe: () => probe,
 	resolve: () => resolve$2,
 	resolveCached: () => required,