ryco-cli 0.1.26 → 0.1.27

package/dist/{Metrics-DCKbdeoH.cjs → serverSettings-_fgQZNIb.cjs}

@@ -1,11 +1,248 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
+const require_src = require("./src-CBu69HDR.cjs");
+const require_schemaJson = require("./schemaJson-CuhFxa8p.cjs");
 let effect = require("effect");
+let effect_Predicate = require("effect/Predicate");
+effect_Predicate = require_rolldown_runtime.__toESM(effect_Predicate, 1);
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let node_fs = require("node:fs");
+let node_os = require("node:os");
+let node_fs_promises = require("node:fs/promises");
 let effect_Function = require("effect/Function");
+let effect_Semaphore = require("effect/Semaphore");
+effect_Semaphore = require_rolldown_runtime.__toESM(effect_Semaphore, 1);
+require("effect/PlatformError");
+//#region ../../packages/shared/src/Struct.ts
+function deepMerge(current, patch) {
+	if (!effect_Predicate.isObject(current) || !effect_Predicate.isObject(patch)) return patch;
+	const next = { ...current };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === void 0) continue;
+		const existing = next[key];
+		next[key] = effect_Predicate.isObject(existing) && effect_Predicate.isObject(value) ? deepMerge(existing, value) : value;
+	}
+	return next;
+}
+//#endregion
+//#region ../../packages/shared/src/model.ts
+const DEFAULT_PROVIDER_DRIVER_KIND = require_src.ProviderDriverKind.make("codex");
+/**
+* Resolve the human-readable model title used by picker surfaces and durable
+* handoff presentation. Provider catalogs are authoritative when they carry a
+* friendly name; the routing slug remains the deterministic final fallback.
+*/
+function getModelDisplayName(model, options) {
+	const shortName = trimOrNull(model.shortName);
+	const name = trimOrNull(model.name);
+	const slug = trimOrNull(model.slug) ?? model.slug;
+	return options?.preferShortName ? shortName ?? name ?? slug : name ?? shortName ?? slug;
+}
+/** Compose the optional sub-provider prefix exactly as the picker trigger does. */
+function getModelDisplayLabel(model, options) {
+	const title = getModelDisplayName(model, options);
+	const subProvider = trimOrNull(model.subProvider);
+	return subProvider ? `${subProvider} · ${title}` : title;
+}
+function createModelCapabilities(input) {
+	return { optionDescriptors: input.optionDescriptors.map(cloneDescriptor) };
+}
+function getRawSelectionValueById(selections, id) {
+	return (selections?.find((candidate) => candidate.id === id))?.value;
+}
+function getProviderOptionSelectionValue(selections, id) {
+	return getRawSelectionValueById(selections, id);
+}
+function getProviderOptionStringSelectionValue(selections, id) {
+	const value = getProviderOptionSelectionValue(selections, id);
+	return typeof value === "string" ? value : void 0;
+}
+function getProviderOptionBooleanSelectionValue(selections, id) {
+	const value = getProviderOptionSelectionValue(selections, id);
+	return typeof value === "boolean" ? value : void 0;
+}
+function getModelSelectionStringOptionValue(modelSelection, id) {
+	return getProviderOptionStringSelectionValue(modelSelection?.options, id);
+}
+function getModelSelectionBooleanOptionValue(modelSelection, id) {
+	return getProviderOptionBooleanSelectionValue(modelSelection?.options, id);
+}
+function resolveDescriptorChoiceValue(descriptor, raw) {
+	const trimmed = trimOrNull(raw);
+	if (!trimmed) return descriptor.currentValue ?? descriptor.options.find((option) => option.isDefault)?.id;
+	if (descriptor.options.length === 0) return trimmed;
+	if (descriptor.promptInjectedValues?.includes(trimmed) && descriptor.options.some((option) => option.id === trimmed)) return descriptor.options.find((option) => option.isDefault)?.id;
+	if (descriptor.options.some((option) => option.id === trimmed)) return trimmed;
+	return descriptor.currentValue ?? descriptor.options.find((option) => option.isDefault)?.id;
+}
+function cloneDescriptor(descriptor) {
+	return descriptor.type === "select" ? {
+		...descriptor,
+		options: [...descriptor.options],
+		...descriptor.promptInjectedValues ? { promptInjectedValues: [...descriptor.promptInjectedValues] } : {}
+	} : { ...descriptor };
+}
+function cloneSelection(selection) {
+	return { ...selection };
+}
+function withDescriptorCurrentValue(descriptor, rawCurrentValue) {
+	if (descriptor.type === "boolean") {
+		if (typeof rawCurrentValue === "boolean") return {
+			...descriptor,
+			currentValue: rawCurrentValue
+		};
+		return descriptor;
+	}
+	const currentValue = typeof rawCurrentValue === "string" ? resolveDescriptorChoiceValue(descriptor, rawCurrentValue) : resolveDescriptorChoiceValue(descriptor, descriptor.currentValue);
+	if (!currentValue) {
+		const { currentValue: _unusedCurrentValue, ...rest } = descriptor;
+		return rest;
+	}
+	return {
+		...descriptor,
+		currentValue
+	};
+}
+function getProviderOptionDescriptors(input) {
+	const { caps, selections } = input;
+	return (caps.optionDescriptors ?? []).map(cloneDescriptor).map((descriptor) => withDescriptorCurrentValue(descriptor, getRawSelectionValueById(selections, descriptor.id) ?? descriptor.currentValue));
+}
+function getProviderOptionCurrentValue(descriptor) {
+	if (!descriptor) return;
+	if (descriptor.type === "boolean") return descriptor.currentValue;
+	if (descriptor.currentValue) return descriptor.currentValue;
+	return descriptor.options.find((option) => option.isDefault)?.id;
+}
+function normalizeModelSlug(model, provider = DEFAULT_PROVIDER_DRIVER_KIND) {
+	if (typeof model !== "string") return null;
+	const trimmed = model.trim();
+	if (!trimmed) return null;
+	const aliases = require_src.MODEL_SLUG_ALIASES_BY_PROVIDER[provider] ?? {};
+	const aliased = Object.prototype.hasOwnProperty.call(aliases, trimmed) ? aliases[trimmed] : void 0;
+	return typeof aliased === "string" ? aliased : trimmed;
+}
+/** Trim a string, returning null for empty/missing values. */
+function trimOrNull(value) {
+	if (typeof value !== "string") return null;
+	return value.trim() || null;
+}
+function cloneSelections(selections) {
+	return selections.map(cloneSelection);
+}
+function createModelSelection(instanceId, model, options) {
+	const selections = options ? cloneSelections(options) : [];
+	const base = {
+		instanceId,
+		model
+	};
+	return selections.length > 0 ? {
+		...base,
+		options: selections
+	} : base;
+}
+/**
+* Context handoff is a provider-instance boundary. Model and option changes
+* within one configured instance remain on that provider's normal turn path.
+*/
+function modelSelectionRequiresContextHandoff(input) {
+	return input.canonicalSelection.instanceId !== input.targetSelection.instanceId;
+}
+/**
+* Returns the effort value if it is a prompt-injected value according to
+* any select descriptor in the given capabilities, or null otherwise.
+*
+* Unlike a single `find`, this checks every descriptor so that the
+* correct descriptor's `promptInjectedValues` list is consulted even when
+* multiple select descriptors exist.
+*/
+function resolvePromptInjectedEffort(caps, rawEffort) {
+	const trimmed = trimOrNull(rawEffort);
+	if (!trimmed) return null;
+	const descriptors = getProviderOptionDescriptors({ caps });
+	for (const descriptor of descriptors) if (descriptor.type === "select" && descriptor.promptInjectedValues?.includes(trimmed)) return trimmed;
+	return null;
+}
+function applyClaudePromptEffortPrefix(text, effort) {
+	const trimmed = text.trim();
+	if (!trimmed) return trimmed;
+	if (effort !== "ultrathink") return trimmed;
+	if (trimmed.startsWith("Ultrathink:")) return trimmed;
+	return `Ultrathink:\n${trimmed}`;
+}
+//#endregion
+//#region ../../packages/shared/src/serverSettings.ts
+const ServerSettingsJson$1 = require_schemaJson.fromLenientJson(require_src.ServerSettings);
+function normalizePersistedServerSettingString(value) {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function extractPersistedServerObservabilitySettings(input) {
+	return {
+		otlpTracesUrl: normalizePersistedServerSettingString(input.observability?.otlpTracesUrl),
+		otlpMetricsUrl: normalizePersistedServerSettingString(input.observability?.otlpMetricsUrl)
+	};
+}
+function parsePersistedServerObservabilitySettings(raw) {
+	try {
+		return extractPersistedServerObservabilitySettings(effect.Schema.decodeUnknownSync(ServerSettingsJson$1)(raw));
+	} catch {
+		return {
+			otlpTracesUrl: void 0,
+			otlpMetricsUrl: void 0
+		};
+	}
+}
+function shouldReplaceTextGenerationModelSelection(patch) {
+	return Boolean(patch && (patch.instanceId !== void 0 || patch.model !== void 0));
+}
+function mergeModelSelectionOptionsById(input) {
+	if (input.patch === void 0) return input.current ? [...input.current] : void 0;
+	if (input.patch.length === 0) return;
+	const merged = new Map((input.current ?? []).map((selection) => [selection.id, selection.value]));
+	for (const selection of input.patch) merged.set(selection.id, selection.value);
+	return [...merged.entries()].map(([id, value]) => ({
+		id,
+		value
+	}));
+}
+/**
+* Applies a server settings patch while treating textGenerationModelSelection as
+* replace-on-provider/model updates. This prevents stale nested options from
+* surviving a reset patch that intentionally omits options.
+*/
+function applyServerSettingsPatch(current, patch) {
+	const selectionPatch = patch.textGenerationModelSelection;
+	let next = deepMerge(current, patch);
+	if (patch.projectWorktreeRoots !== void 0) {
+		const roots = new Map(Object.entries(current.projectWorktreeRoots));
+		for (const [projectId, root] of Object.entries(patch.projectWorktreeRoots)) if (root === null || root === "") roots.delete(projectId);
+		else roots.set(projectId, root);
+		next = {
+			...next,
+			projectWorktreeRoots: Object.fromEntries(roots)
+		};
+	}
+	const nextWithReplacements = patch.providerInstances !== void 0 ? {
+		...next,
+		providerInstances: patch.providerInstances
+	} : next;
+	if (!selectionPatch) return nextWithReplacements;
+	const instanceId = selectionPatch.instanceId ?? current.textGenerationModelSelection.instanceId;
+	const model = selectionPatch.model ?? current.textGenerationModelSelection.model;
+	const options = shouldReplaceTextGenerationModelSelection(selectionPatch) ? selectionPatch.options : mergeModelSelectionOptionsById({
+		current: current.textGenerationModelSelection.options,
+		patch: selectionPatch.options
+	});
+	return {
+		...nextWithReplacements,
+		textGenerationModelSelection: createModelSelection(instanceId, model, options)
+	};
+}
+//#endregion
 //#region ../../node_modules/.bun/cborg@6.1.2/node_modules/cborg/lib/is.js
 const objectTypeNames = [
 	"Object",
@@ -131,7 +368,7 @@ var Token = class {
 //#endregion
 //#region ../../node_modules/.bun/cborg@6.1.2/node_modules/cborg/lib/byte-utils.js
 const useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
-const textEncoder = new TextEncoder();
+const textEncoder$1 = new TextEncoder();
 /**
 * @typedef {import('../interface.js').ByteView} ByteView
 * @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
@@ -160,7 +397,7 @@ const fromString = useBuffer ? (string) => {
 * @param {string} string
 */
 (string) => {
-	return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
+	return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder$1.encode(string) : utf8ToBytes(string);
 };
 /**
 * Buffer variant not fast enough for what we need
@@ -821,7 +1058,7 @@ function compareBytes(b1, b2) {
 }
 //#endregion
 //#region ../../node_modules/.bun/cborg@6.1.2/node_modules/cborg/lib/3string.js
-const textDecoder = new TextDecoder();
+const textDecoder$1 = new TextDecoder();
 const ASCII_THRESHOLD = 32;
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
@@ -840,12 +1077,12 @@ function toStr(bytes, start, end) {
 		let str = "";
 		for (let i = start; i < end; i++) {
 			const c = bytes[i];
-			if (c & 128) return textDecoder.decode(bytes.subarray(start, end));
+			if (c & 128) return textDecoder$1.decode(bytes.subarray(start, end));
 			str += String.fromCharCode(c);
 		}
 		return str;
 	}
-	return textDecoder.decode(bytes.subarray(start, end));
+	return textDecoder$1.decode(bytes.subarray(start, end));
 }
 /**
 * @param {Uint8Array} data
@@ -1624,7 +1861,7 @@ function makeCborEncoders() {
 const cborEncoders = makeCborEncoders();
 const defaultWriter = new Bl();
 /** @implements {Reference} */
-var Ref = class Ref {
+var Ref$1 = class Ref$1 {
 	/**
 	* @param {object|any[]} obj
 	* @param {Reference|undefined} parent
@@ -1652,7 +1889,7 @@ var Ref = class Ref {
 	*/
 	static createCheck(stack, obj) {
 		if (stack && stack.includes(obj)) throw new Error(`${encodeErrPrefix} object contains circular references`);
-		return new Ref(obj, stack);
+		return new Ref$1(obj, stack);
 	}
 };
 const simpleTokens = {
@@ -1770,7 +2007,7 @@ const typeEncoders = {
 			if (options.addBreakTokens === true) return [simpleTokens.emptyArray, new Token(Type.break)];
 			return simpleTokens.emptyArray;
 		}
-		refStack = Ref.createCheck(refStack, obj);
+		refStack = Ref$1.createCheck(refStack, obj);
 		const entries = [];
 		let i = 0;
 		for (const e of obj) entries[i++] = objectToTokens(e, options, refStack);
@@ -1796,7 +2033,7 @@ const typeEncoders = {
 		let entries;
 		if (maxLength) {
 			entries = new Array(maxLength);
-			refStack = Ref.createCheck(refStack, obj);
+			refStack = Ref$1.createCheck(refStack, obj);
 			const skipUndefined = !isMap && options.ignoreUndefinedProperties;
 			let i = 0;
 			for (const key of keys) {
@@ -1958,7 +2195,7 @@ function directEncodeMap(writer, data, typ, options, refStack) {
 		writer.pushByte(MAJOR_MAP);
 		return;
 	}
-	refStack = Ref.createCheck(refStack, data);
+	refStack = Ref$1.createCheck(refStack, data);
 	const skipUndefined = !isMap && options.ignoreUndefinedProperties;
 	const entries = new Array(maxLength);
 	let length = 0;
@@ -2031,7 +2268,7 @@ function directEncode(writer, data, options, refStack) {
 				writer.pushByte(MAJOR_ARRAY);
 				return;
 			}
-			refStack = Ref.createCheck(refStack, data);
+			refStack = Ref$1.createCheck(refStack, data);
 			directEncodeUintValue(writer, MAJOR_ARRAY, data.length);
 			for (const elem of data) directEncode(writer, elem, options, refStack);
 			return;
@@ -2741,6 +2978,27 @@ const resolveStaticDir = effect.Effect.fn(function* () {
 	if (yield* exists(join(monorepoClient, "index.html")).pipe(effect.Effect.orElseSucceed(() => false))) return monorepoClient;
 });
 //#endregion
+//#region src/workspace/Services/WorkspaceAccessPolicy.ts
+/**
+* WorkspaceAccessPolicy - Process-wide boundary for Ryco-managed workspace paths.
+*
+* This service constrains paths accepted by Ryco RPCs. It does not sandbox child
+* processes such as terminals or coding-agent runtimes.
+*
+* @module WorkspaceAccessPolicy
+*/
+var WorkspaceAccessDeniedError = class extends effect.Schema.TaggedError()("WorkspaceAccessDeniedError", {
+	operation: effect.Schema.String,
+	requestedPath: effect.Schema.String,
+	accessRoot: effect.Schema.String,
+	reason: effect.Schema.Literals(["outsideRoot", "unresolvable"])
+}) {
+	get message() {
+		return `Workspace path is not available for ${this.operation}; access is restricted to '${this.accessRoot}'.`;
+	}
+};
+var WorkspaceAccessPolicy = class extends effect.Context.Service()("ryco/workspace/Services/WorkspaceAccessPolicy") {};
+//#endregion
 //#region src/observability/Attributes.ts
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3008,6 +3266,525 @@ const providerTurnMetricAttributes = (input) => {
 	});
 };
 //#endregion
+//#region src/atomicWrite.ts
+const writeFileStringAtomically = (input) => effect.Effect.scoped(effect.Effect.gen(function* () {
+	const fs = yield* effect.FileSystem.FileSystem;
+	const path = yield* effect.Path.Path;
+	const tempFileId = yield* effect.Effect.sync(() => crypto.randomUUID());
+	const targetDirectory = path.dirname(input.filePath);
+	yield* fs.makeDirectory(targetDirectory, { recursive: true });
+	const tempDirectory = yield* fs.makeTempDirectoryScoped({
+		directory: targetDirectory,
+		prefix: `${path.basename(input.filePath)}.`
+	});
+	const tempPath = path.join(tempDirectory, `${tempFileId}.tmp`);
+	yield* fs.writeFileString(tempPath, input.contents);
+	yield* fs.rename(tempPath, input.filePath);
+}));
+//#endregion
+//#region src/auth/Services/ServerSecretStore.ts
+var SecretStoreError = class extends effect.Data.TaggedError("SecretStoreError") {};
+var ServerSecretStore = class extends effect.Context.Service()("ryco/auth/Services/ServerSecretStore") {};
+//#endregion
+//#region src/auth/Layers/ServerSecretStore.ts
+const makeServerSecretStore = effect.Effect.gen(function* () {
+	const fileSystem = yield* effect.FileSystem.FileSystem;
+	const path = yield* effect.Path.Path;
+	const serverConfig = yield* ServerConfig;
+	yield* fileSystem.makeDirectory(serverConfig.secretsDir, { recursive: true });
+	yield* fileSystem.chmod(serverConfig.secretsDir, 448).pipe(effect.Effect.mapError((cause) => new SecretStoreError({
+		message: `Failed to secure secrets directory ${serverConfig.secretsDir}.`,
+		cause
+	})));
+	const resolveSecretPath = (name) => path.join(serverConfig.secretsDir, `${name}.bin`);
+	const ensureSecretDirectory = (secretPath) => {
+		const directory = path.dirname(secretPath);
+		return fileSystem.makeDirectory(directory, { recursive: true }).pipe(effect.Effect.flatMap(() => fileSystem.chmod(directory, 448)));
+	};
+	const isPlatformError = (u) => effect.Predicate.isTagged(u, "PlatformError");
+	const get = (name) => fileSystem.readFile(resolveSecretPath(name)).pipe(effect.Effect.map((bytes) => Uint8Array.from(bytes)), effect.Effect.catch((cause) => cause.reason._tag === "NotFound" ? effect.Effect.succeed(null) : effect.Effect.fail(new SecretStoreError({
+		message: `Failed to read secret ${name}.`,
+		cause
+	}))));
+	const set = (name, value) => {
+		const secretPath = resolveSecretPath(name);
+		const tempPath = `${secretPath}.${node_crypto.randomUUID()}.tmp`;
+		return effect.Effect.gen(function* () {
+			yield* ensureSecretDirectory(secretPath);
+			yield* fileSystem.writeFile(tempPath, value);
+			yield* fileSystem.chmod(tempPath, 384);
+			yield* fileSystem.rename(tempPath, secretPath);
+			yield* fileSystem.chmod(secretPath, 384);
+		}).pipe(effect.Effect.catch((cause) => fileSystem.remove(tempPath).pipe(effect.Effect.ignore, effect.Effect.flatMap(() => effect.Effect.fail(new SecretStoreError({
+			message: `Failed to persist secret ${name}.`,
+			cause
+		}))))));
+	};
+	const create = (name, value) => {
+		const secretPath = resolveSecretPath(name);
+		return effect.Effect.scoped(effect.Effect.gen(function* () {
+			yield* ensureSecretDirectory(secretPath);
+			const file = yield* fileSystem.open(secretPath, {
+				flag: "wx",
+				mode: 384
+			});
+			yield* file.writeAll(value);
+			yield* file.sync;
+			yield* fileSystem.chmod(secretPath, 384);
+		})).pipe(effect.Effect.mapError((cause) => new SecretStoreError({
+			message: `Failed to persist secret ${name}.`,
+			cause
+		})));
+	};
+	const getOrCreateRandom = (name, bytes) => get(name).pipe(effect.Effect.flatMap((existing) => {
+		if (existing) return effect.Effect.succeed(existing);
+		const generated = node_crypto.randomBytes(bytes);
+		return create(name, generated).pipe(effect.Effect.as(Uint8Array.from(generated)), effect.Effect.catchTag("SecretStoreError", (error) => isPlatformError(error.cause) && error.cause.reason._tag === "AlreadyExists" ? get(name).pipe(effect.Effect.flatMap((created) => created !== null ? effect.Effect.succeed(created) : effect.Effect.fail(new SecretStoreError({ message: `Failed to read secret ${name} after concurrent creation.` })))) : effect.Effect.fail(error)));
+	}));
+	const remove = (name) => fileSystem.remove(resolveSecretPath(name)).pipe(effect.Effect.catch((cause) => cause.reason._tag === "NotFound" ? effect.Effect.void : effect.Effect.fail(new SecretStoreError({
+		message: `Failed to remove secret ${name}.`,
+		cause
+	}))));
+	return {
+		get,
+		set,
+		getOrCreateRandom,
+		remove
+	};
+});
+const ServerSecretStoreLive = effect.Layer.effect(ServerSecretStore, makeServerSecretStore);
+//#endregion
+//#region src/pathExpansion.ts
+/**
+* Expand a leading `~` (or `~/…`, `~\…`) in a user-supplied path to the
+* current user's home directory. Spawned processes don't get shell
+* expansion, so env vars like `CODEX_HOME=~/.codex-work` would be passed
+* verbatim and treated as relative paths by the receiver.
+*
+* Matches the behavior of the other `expandHomePath` helpers in the
+* workspace layers and CLI bootstrap: `~` alone and both `~/` and `~\`
+* separators are handled. Returns the input unchanged if it doesn't
+* start with `~` or is empty. Does not handle `~user` (other-user)
+* expansion.
+*/
+function expandHomePath(value) {
+	if (!value) return value;
+	if (value === "~") return (0, node_os.homedir)();
+	if (value.startsWith("~/") || value.startsWith("~\\")) return (0, node_path.join)((0, node_os.homedir)(), value.slice(2));
+	return value;
+}
+//#endregion
+//#region src/project/worktreeRoot.ts
+var WorktreeRootError = class extends effect.Schema.TaggedError()("WorktreeRootError", { detail: effect.Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** Resolve missing descendants through the nearest existing directory, including symlink aliases.
+* Do not turn permission errors or dangling symlinks into nonexistent ancestors.
+* No directories are created while validating a preference.
+*/
+async function canonicalizeWorktreeDirectory(candidate) {
+	let ancestor = candidate;
+	while (true) try {
+		await (0, node_fs_promises.lstat)(ancestor);
+		const canonical = await (0, node_fs_promises.realpath)(ancestor);
+		if (!(await (0, node_fs_promises.lstat)(canonical)).isDirectory()) throw new Error("Worktree root must be a directory.");
+		await (0, node_fs_promises.access)(canonical, node_fs.constants.W_OK | node_fs.constants.X_OK);
+		return node_path.default.join(canonical, node_path.default.relative(ancestor, candidate));
+	} catch (cause) {
+		if (cause.code !== "ENOENT") throw cause;
+		if (await (0, node_fs_promises.lstat)(ancestor).catch((error) => {
+			if (error.code !== "ENOENT") throw error;
+			return null;
+		}) !== null) throw new Error("Worktree root contains a dangling symlink.", { cause });
+		const parent = node_path.default.dirname(ancestor);
+		if (parent === ancestor) throw cause;
+		ancestor = parent;
+	}
+}
+const validateWorktreeRoot = (value, policy) => effect.Effect.gen(function* () {
+	const trimmed = value.trim();
+	const expanded = expandHomePath(trimmed);
+	if (!trimmed || /[\x00-\x1f\x7f]/.test(trimmed) || !node_path.default.isAbsolute(expanded) || process.platform === "win32" && !/^(?:[A-Za-z]:[\\/]|\\\\[^\\]+\\[^\\]+)/.test(expanded)) return yield* new WorktreeRootError({ detail: "Worktree root must be an absolute directory on this node or start with ~/." });
+	const operation = "worktree root";
+	const authorized = yield* policy.assertPath({
+		path: node_path.default.normalize(expanded),
+		operation
+	}).pipe(effect.Effect.mapError((cause) => new WorktreeRootError({ detail: cause.message })));
+	const canonical = yield* effect.Effect.tryPromise({
+		try: () => canonicalizeWorktreeDirectory(authorized),
+		catch: () => new WorktreeRootError({ detail: "Worktree root must resolve to a writable directory (or have a writable existing parent), without broken symlinks." })
+	});
+	return yield* policy.assertPath({
+		path: canonical,
+		operation
+	}).pipe(effect.Effect.mapError((cause) => new WorktreeRootError({ detail: cause.message })));
+});
+/** Storage selection only: this never grants access to the selected directory's contents. */
+const selectConfiguredWorktreeRoot = (input) => (input.projectId && Object.hasOwn(input.settings.projectWorktreeRoots, input.projectId) ? input.settings.projectWorktreeRoots[input.projectId] : null) || input.settings.worktreeRoot || resolveManagedWorktreesRoot(input.config);
+const resolveConfiguredWorktreeRoot = (input) => validateWorktreeRoot(selectConfiguredWorktreeRoot(input), input.policy);
+//#endregion
+//#region src/workspace/Layers/WorkspaceAccessPolicy.ts
+function isWithinOrEqual(path, root, target) {
+	const relative = path.relative(root, target);
+	return relative.length === 0 || relative === "." || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+const makeWorkspaceAccessPolicy = (configuredRoot) => effect.Effect.gen(function* () {
+	const fileSystem = yield* effect.FileSystem.FileSystem;
+	const path = yield* effect.Path.Path;
+	const accessRoot = configuredRoot === void 0 ? void 0 : yield* fileSystem.realPath(configuredRoot);
+	const denied = (input, reason) => new WorkspaceAccessDeniedError({
+		operation: input.operation,
+		requestedPath: input.path,
+		accessRoot: accessRoot ?? "",
+		reason
+	});
+	const assertInside = (input, target) => {
+		if (accessRoot === void 0 || isWithinOrEqual(path, accessRoot, target)) return effect.Effect.succeed(target);
+		return effect.Effect.fail(denied(input, "outsideRoot"));
+	};
+	const assertExistingPath = effect.Effect.fn("WorkspaceAccessPolicy.assertExistingPath")(function* (input) {
+		const normalized = path.resolve(input.path);
+		if (accessRoot === void 0) return normalized;
+		const canonical = yield* fileSystem.realPath(normalized).pipe(effect.Effect.mapError(() => denied(input, "unresolvable")));
+		return yield* assertInside(input, canonical);
+	});
+	const assertPath = effect.Effect.fn("WorkspaceAccessPolicy.assertPath")(function* (input) {
+		const normalized = path.resolve(input.path);
+		if (accessRoot === void 0) return normalized;
+		let ancestor = normalized;
+		while (!(yield* fileSystem.exists(ancestor).pipe(effect.Effect.orElseSucceed(() => false)))) {
+			const parent = path.dirname(ancestor);
+			if (parent === ancestor) return yield* denied(input, "unresolvable");
+			ancestor = parent;
+		}
+		const canonicalAncestor = yield* fileSystem.realPath(ancestor).pipe(effect.Effect.mapError(() => denied(input, "unresolvable")));
+		const canonicalTarget = path.resolve(canonicalAncestor, path.relative(ancestor, normalized));
+		return yield* assertInside(input, canonicalTarget);
+	});
+	return {
+		accessRoot,
+		isRestricted: accessRoot !== void 0,
+		assertPath,
+		assertExistingPath
+	};
+});
+const WorkspaceAccessPolicyLive = effect.Layer.effect(WorkspaceAccessPolicy, effect.Effect.gen(function* () {
+	const config = yield* ServerConfig;
+	return yield* makeWorkspaceAccessPolicy(config.workspaceAccessRoot);
+}));
+//#endregion
+//#region src/serverSettings.ts
+/**
+* ServerSettings - Server-authoritative settings service.
+*
+* Owns persistence, validation, and change notification of settings that affect
+* server-side behavior (binary paths, streaming mode, env mode, custom models,
+* text generation model selection).
+*
+* Follows the same pattern as `keybindings.ts`: JSON file + Cache + PubSub +
+* Semaphore + FileSystem.watch for concurrency and external edit detection.
+*
+* @module ServerSettings
+*/
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function providerEnvironmentSecretName(input) {
+	return `provider-env-${Buffer.from(input.instanceId, "utf8").toString("base64url")}-${Buffer.from(input.name, "utf8").toString("base64url")}`;
+}
+function redactProviderEnvironmentVariable(variable) {
+	if (!variable.sensitive) {
+		const { valueRedacted: _omit, ...rest } = variable;
+		return rest;
+	}
+	return {
+		...variable,
+		value: "",
+		...variable.value.length > 0 || variable.valueRedacted ? { valueRedacted: true } : {}
+	};
+}
+function redactServerSettingsForClient(settings) {
+	const providerInstances = Object.fromEntries(Object.entries(settings.providerInstances).map(([instanceId, instance]) => [instanceId, instance.environment ? {
+		...instance,
+		environment: instance.environment.map(redactProviderEnvironmentVariable)
+	} : instance]));
+	return {
+		...settings,
+		providerInstances
+	};
+}
+var ServerSettingsService = class ServerSettingsService extends effect.Context.Service()("ryco/serverSettings/ServerSettingsService") {
+	static layerTest = (overrides = {}) => effect.Layer.effect(ServerSettingsService, effect.Effect.gen(function* () {
+		const currentSettingsRef = yield* effect.Ref.make(deepMerge(require_src.DEFAULT_SERVER_SETTINGS, overrides));
+		return {
+			start: effect.Effect.void,
+			ready: effect.Effect.void,
+			getSettings: effect.Ref.get(currentSettingsRef),
+			updateSettings: (patch) => effect.Ref.get(currentSettingsRef).pipe(effect.Effect.flatMap((currentSettings) => effect.Schema.decodeEffect(require_src.ServerSettings)(applyServerSettingsPatch(currentSettings, patch)).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+				settingsPath: "<memory>",
+				detail: `failed to normalize server settings: ${effect.SchemaIssue.makeFormatterDefault()(cause.issue)}`,
+				cause
+			})))), effect.Effect.tap((nextSettings) => effect.Ref.set(currentSettingsRef, nextSettings))),
+			streamChanges: effect.Stream.empty
+		};
+	}));
+};
+const ServerSettingsJson = require_schemaJson.fromLenientJson(require_src.ServerSettings);
+const getLegacyProviderSettings = (settings, provider) => settings.providers[provider];
+/**
+* Ensure the `textGenerationModelSelection` points to an enabled provider.
+* If the selected provider is disabled, fall back to the first enabled
+* provider with its default model.  This is applied at read-time so the
+* persisted preference is preserved for when a provider is re-enabled.
+*/
+function resolveTextGenerationProvider(settings) {
+	const selection = settings.textGenerationModelSelection;
+	const instanceConfig = settings.providerInstances[selection.instanceId];
+	if (instanceConfig !== void 0) return instanceConfig.enabled ?? true ? settings : fallbackTextGenerationProvider(settings);
+	if (require_src.isProviderDriverKind(selection.instanceId) && getLegacyProviderSettings(settings, selection.instanceId)?.enabled) return settings;
+	return fallbackTextGenerationProvider(settings);
+}
+function fallbackTextGenerationProvider(settings) {
+	const fallbackEntry = Object.entries(settings.providers).find(([, provider]) => provider.enabled);
+	const fallback = fallbackEntry ? require_src.ProviderDriverKind.make(fallbackEntry[0]) : void 0;
+	if (!fallback) return settings;
+	const defaultOptions = require_src.DEFAULT_GIT_TEXT_GENERATION_OPTIONS_BY_PROVIDER[fallback];
+	return {
+		...settings,
+		textGenerationModelSelection: {
+			instanceId: require_src.ProviderInstanceId.make(fallback),
+			model: require_src.DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER[fallback] ?? "gpt-5.6-luna",
+			...defaultOptions ? { options: defaultOptions } : {}
+		}
+	};
+}
+const ATOMIC_SETTINGS_KEYS = /* @__PURE__ */ new Set(["textGenerationModelSelection"]);
+function stripDefaultServerSettings(current, defaults) {
+	if (Array.isArray(current) || Array.isArray(defaults)) return effect.Equal.equals(current, defaults) ? void 0 : current;
+	if (current !== null && defaults !== null && typeof current === "object" && typeof defaults === "object") {
+		const currentRecord = current;
+		const defaultsRecord = defaults;
+		const next = {};
+		for (const key of Object.keys(currentRecord)) if (ATOMIC_SETTINGS_KEYS.has(key)) {
+			if (!effect.Equal.equals(currentRecord[key], defaultsRecord[key])) next[key] = currentRecord[key];
+		} else {
+			const stripped = stripDefaultServerSettings(currentRecord[key], defaultsRecord[key]);
+			if (stripped !== void 0) next[key] = stripped;
+		}
+		return Object.keys(next).length > 0 ? next : void 0;
+	}
+	return Object.is(current, defaults) ? void 0 : current;
+}
+const makeServerSettings = effect.Effect.gen(function* () {
+	const { settingsPath, workspaceAccessRoot } = yield* ServerConfig;
+	const worktreeAccessPolicy = yield* makeWorkspaceAccessPolicy(workspaceAccessRoot);
+	const fs = yield* effect.FileSystem.FileSystem;
+	const pathService = yield* effect.Path.Path;
+	const secretStore = yield* ServerSecretStore;
+	const writeSemaphore = yield* effect_Semaphore.make(1);
+	const cacheKey = "settings";
+	const changesPubSub = yield* effect.PubSub.unbounded();
+	const startedRef = yield* effect.Ref.make(false);
+	const startedDeferred = yield* effect.Deferred.make();
+	const watcherScope = yield* effect.Scope.make("sequential");
+	yield* effect.Effect.addFinalizer(() => effect.Scope.close(watcherScope, effect.Exit.void));
+	const emitChange = (settings) => effect.PubSub.publish(changesPubSub, settings).pipe(effect.Effect.asVoid);
+	const readConfigExists = fs.exists(settingsPath).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+		settingsPath,
+		detail: "failed to check settings file existence",
+		cause
+	})));
+	const readRawConfig = fs.readFileString(settingsPath).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+		settingsPath,
+		detail: "failed to read settings file",
+		cause
+	})));
+	const loadSettingsFromDisk = effect.Effect.gen(function* () {
+		if (!(yield* readConfigExists)) return require_src.DEFAULT_SERVER_SETTINGS;
+		const raw = yield* readRawConfig;
+		const decoded = effect.Schema.decodeUnknownExit(ServerSettingsJson)(raw);
+		if (decoded._tag === "Failure") {
+			yield* effect.Effect.logWarning("failed to parse settings.json, using defaults", {
+				path: settingsPath,
+				issues: effect.Cause.pretty(decoded.cause)
+			});
+			return require_src.DEFAULT_SERVER_SETTINGS;
+		}
+		return decoded.value;
+	});
+	const settingsCache = yield* effect.Cache.make({
+		capacity: 1,
+		lookup: () => loadSettingsFromDisk
+	});
+	const getSettingsFromCache = effect.Cache.get(settingsCache, cacheKey);
+	const toSettingsError = (detail, cause) => new require_src.ServerSettingsError({
+		settingsPath,
+		detail,
+		cause
+	});
+	const materializeProviderEnvironmentSecrets = (settings) => effect.Effect.gen(function* () {
+		const providerInstances = { ...settings.providerInstances };
+		for (const [instanceId, instance] of Object.entries(settings.providerInstances)) {
+			if (!instance.environment) continue;
+			const environment = [];
+			for (const variable of instance.environment) {
+				if (!variable.sensitive || !variable.valueRedacted) {
+					environment.push(variable);
+					continue;
+				}
+				const secret = yield* secretStore.get(providerEnvironmentSecretName({
+					instanceId,
+					name: variable.name
+				})).pipe(effect.Effect.mapError((cause) => toSettingsError(`failed to read sensitive environment variable ${variable.name}`, cause)));
+				environment.push({
+					...variable,
+					value: secret ? textDecoder.decode(secret) : ""
+				});
+			}
+			providerInstances[instanceId] = {
+				...instance,
+				environment
+			};
+		}
+		return {
+			...settings,
+			providerInstances
+		};
+	});
+	const persistProviderEnvironmentSecrets = (current, next) => effect.Effect.gen(function* () {
+		const providerInstances = { ...next.providerInstances };
+		const nextSecretKeys = /* @__PURE__ */ new Set();
+		for (const [instanceId, instance] of Object.entries(next.providerInstances)) {
+			if (!instance.environment) continue;
+			const environment = [];
+			for (const variable of instance.environment) {
+				const secretName = providerEnvironmentSecretName({
+					instanceId,
+					name: variable.name
+				});
+				if (!variable.sensitive) {
+					yield* secretStore.remove(secretName).pipe(effect.Effect.mapError((cause) => toSettingsError(`failed to remove environment secret ${variable.name}`, cause)));
+					environment.push(redactProviderEnvironmentVariable(variable));
+					continue;
+				}
+				nextSecretKeys.add(secretName);
+				if (!variable.valueRedacted) {
+					if (variable.value.length > 0) {
+						yield* secretStore.set(secretName, textEncoder.encode(variable.value)).pipe(effect.Effect.mapError((cause) => toSettingsError(`failed to persist environment secret ${variable.name}`, cause)));
+						environment.push({
+							...variable,
+							value: "",
+							valueRedacted: true
+						});
+					} else {
+						yield* secretStore.remove(secretName).pipe(effect.Effect.mapError((cause) => toSettingsError(`failed to remove environment secret ${variable.name}`, cause)));
+						const { valueRedacted: _omit, ...rest } = variable;
+						environment.push(rest);
+					}
+					continue;
+				}
+				environment.push(redactProviderEnvironmentVariable(variable));
+			}
+			providerInstances[instanceId] = {
+				...instance,
+				environment
+			};
+		}
+		for (const [instanceId, instance] of Object.entries(current.providerInstances)) for (const variable of instance.environment ?? []) {
+			if (!variable.sensitive) continue;
+			const secretName = providerEnvironmentSecretName({
+				instanceId,
+				name: variable.name
+			});
+			if (nextSecretKeys.has(secretName)) continue;
+			yield* secretStore.remove(secretName).pipe(effect.Effect.mapError((cause) => toSettingsError(`failed to remove stale environment secret ${variable.name}`, cause)));
+		}
+		return {
+			...next,
+			providerInstances
+		};
+	});
+	const writeSettingsAtomically = (settings) => {
+		const sparseSettings = stripDefaultServerSettings(settings, require_src.DEFAULT_SERVER_SETTINGS) ?? {};
+		return writeFileStringAtomically({
+			filePath: settingsPath,
+			contents: `${JSON.stringify(sparseSettings, null, 2)}\n`
+		}).pipe(effect.Effect.provideService(effect.FileSystem.FileSystem, fs), effect.Effect.provideService(effect.Path.Path, pathService), effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+			settingsPath,
+			detail: "failed to write settings file",
+			cause
+		})));
+	};
+	const revalidateAndEmit = writeSemaphore.withPermits(1)(effect.Effect.gen(function* () {
+		yield* effect.Cache.invalidate(settingsCache, cacheKey);
+		const settings = yield* getSettingsFromCache;
+		yield* emitChange(settings);
+	}));
+	const startWatcher = effect.Effect.gen(function* () {
+		const settingsDir = pathService.dirname(settingsPath);
+		const settingsFile = pathService.basename(settingsPath);
+		const settingsPathResolved = pathService.resolve(settingsPath);
+		yield* fs.makeDirectory(settingsDir, { recursive: true }).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+			settingsPath,
+			detail: "failed to prepare settings directory",
+			cause
+		})));
+		const revalidateAndEmitSafely = revalidateAndEmit.pipe(effect.Effect.ignoreCause({ log: true }));
+		const debouncedSettingsEvents = fs.watch(settingsDir).pipe(effect.Stream.filter((event) => {
+			return event.path === settingsFile || event.path === settingsPath || pathService.resolve(settingsDir, event.path) === settingsPathResolved;
+		}), effect.Stream.debounce(effect.Duration.millis(100)));
+		yield* effect.Stream.runForEach(debouncedSettingsEvents, () => revalidateAndEmitSafely).pipe(effect.Effect.ignoreCause({ log: true }), effect.Effect.forkIn(watcherScope), effect.Effect.asVoid);
+	});
+	return {
+		start: effect.Effect.gen(function* () {
+			if (!(yield* effect.Ref.modify(startedRef, (started) => [!started, true]))) return yield* effect.Deferred.await(startedDeferred);
+			const startup = effect.Effect.gen(function* () {
+				yield* startWatcher;
+				yield* effect.Cache.invalidate(settingsCache, cacheKey);
+				yield* getSettingsFromCache;
+			});
+			const startupExit = yield* effect.Effect.exit(startup);
+			if (startupExit._tag === "Failure") {
+				yield* effect.Deferred.failCause(startedDeferred, startupExit.cause).pipe(effect.Effect.orDie);
+				return yield* effect.Effect.failCause(startupExit.cause);
+			}
+			yield* effect.Deferred.succeed(startedDeferred, void 0).pipe(effect.Effect.orDie);
+		}),
+		ready: effect.Deferred.await(startedDeferred),
+		getSettings: getSettingsFromCache.pipe(effect.Effect.flatMap(materializeProviderEnvironmentSecrets), effect.Effect.map(resolveTextGenerationProvider)),
+		updateSettings: (patch) => writeSemaphore.withPermits(1)(effect.Effect.gen(function* () {
+			const current = yield* getSettingsFromCache;
+			const normalizedPatch = { ...patch };
+			const validateRoot = (root) => validateWorktreeRoot(root, worktreeAccessPolicy).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+				settingsPath,
+				detail: cause.message,
+				cause
+			})));
+			if (patch.worktreeRoot) normalizedPatch.worktreeRoot = yield* validateRoot(patch.worktreeRoot);
+			if (patch.projectWorktreeRoots !== void 0) {
+				const roots = [];
+				for (const [id, root] of Object.entries(patch.projectWorktreeRoots)) roots.push([id, root ? yield* validateRoot(root) : null]);
+				normalizedPatch.projectWorktreeRoots = Object.fromEntries(roots);
+			}
+			const nextPersisted = yield* persistProviderEnvironmentSecrets(current, applyServerSettingsPatch(current, normalizedPatch));
+			const next = yield* effect.Schema.decodeEffect(require_src.ServerSettings)(nextPersisted).pipe(effect.Effect.mapError((cause) => new require_src.ServerSettingsError({
+				settingsPath: "<memory>",
+				detail: `failed to normalize server settings: ${effect.SchemaIssue.makeFormatterDefault()(cause.issue)}`,
+				cause
+			})));
+			yield* writeSettingsAtomically(next);
+			yield* effect.Cache.set(settingsCache, cacheKey, next);
+			yield* emitChange(next);
+			return resolveTextGenerationProvider(yield* materializeProviderEnvironmentSecrets(next));
+		})),
+		get streamChanges() {
+			return effect.Stream.fromPubSub(changesPubSub).pipe(effect.Stream.mapEffect((settings) => materializeProviderEnvironmentSecrets(settings).pipe(effect.Effect.catch((error) => effect.Effect.logWarning("failed to materialize provider environment secrets", { detail: error.detail }).pipe(effect.Effect.as(settings))))), effect.Stream.map(resolveTextGenerationProvider));
+		}
+	};
+});
+const ServerSettingsLive = effect.Layer.effect(ServerSettingsService, makeServerSettings).pipe(effect.Layer.provide(ServerSecretStoreLive));
+//#endregion
 Object.defineProperty(exports, "DEFAULT_PORT", {
 	enumerable: true,
 	get: function() {
@@ -3038,6 +3815,30 @@ Object.defineProperty(exports, "ServerConfig", {
 		return ServerConfig;
 	}
 });
+Object.defineProperty(exports, "ServerSecretStore", {
+	enumerable: true,
+	get: function() {
+		return ServerSecretStore;
+	}
+});
+Object.defineProperty(exports, "ServerSecretStoreLive", {
+	enumerable: true,
+	get: function() {
+		return ServerSecretStoreLive;
+	}
+});
+Object.defineProperty(exports, "ServerSettingsLive", {
+	enumerable: true,
+	get: function() {
+		return ServerSettingsLive;
+	}
+});
+Object.defineProperty(exports, "ServerSettingsService", {
+	enumerable: true,
+	get: function() {
+		return ServerSettingsService;
+	}
+});
 Object.defineProperty(exports, "Tokeniser", {
 	enumerable: true,
 	get: function() {
@@ -3050,6 +3851,24 @@ Object.defineProperty(exports, "Type", {
 		return Type;
 	}
 });
+Object.defineProperty(exports, "WorkspaceAccessPolicy", {
+	enumerable: true,
+	get: function() {
+		return WorkspaceAccessPolicy;
+	}
+});
+Object.defineProperty(exports, "WorkspaceAccessPolicyLive", {
+	enumerable: true,
+	get: function() {
+		return WorkspaceAccessPolicyLive;
+	}
+});
+Object.defineProperty(exports, "applyClaudePromptEffortPrefix", {
+	enumerable: true,
+	get: function() {
+		return applyClaudePromptEffortPrefix;
+	}
+});
 Object.defineProperty(exports, "canonicalizeHubOrigin", {
 	enumerable: true,
 	get: function() {
@@ -3092,6 +3911,12 @@ Object.defineProperty(exports, "contextHandoffsTotal", {
 		return contextHandoffsTotal;
 	}
 });
+Object.defineProperty(exports, "createModelCapabilities", {
+	enumerable: true,
+	get: function() {
+		return createModelCapabilities;
+	}
+});
 Object.defineProperty(exports, "decode", {
 	enumerable: true,
 	get: function() {
@@ -3140,6 +3965,12 @@ Object.defineProperty(exports, "equalNodeIdentityBytes", {
 		return equalNodeIdentityBytes;
 	}
 });
+Object.defineProperty(exports, "expandHomePath", {
+	enumerable: true,
+	get: function() {
+		return expandHomePath;
+	}
+});
 Object.defineProperty(exports, "fingerprintNodePublicKey", {
 	enumerable: true,
 	get: function() {
@@ -3152,6 +3983,48 @@ Object.defineProperty(exports, "formatNodePublicKeyFingerprint", {
 		return formatNodePublicKeyFingerprint;
 	}
 });
+Object.defineProperty(exports, "getModelDisplayLabel", {
+	enumerable: true,
+	get: function() {
+		return getModelDisplayLabel;
+	}
+});
+Object.defineProperty(exports, "getModelSelectionBooleanOptionValue", {
+	enumerable: true,
+	get: function() {
+		return getModelSelectionBooleanOptionValue;
+	}
+});
+Object.defineProperty(exports, "getModelSelectionStringOptionValue", {
+	enumerable: true,
+	get: function() {
+		return getModelSelectionStringOptionValue;
+	}
+});
+Object.defineProperty(exports, "getProviderOptionBooleanSelectionValue", {
+	enumerable: true,
+	get: function() {
+		return getProviderOptionBooleanSelectionValue;
+	}
+});
+Object.defineProperty(exports, "getProviderOptionCurrentValue", {
+	enumerable: true,
+	get: function() {
+		return getProviderOptionCurrentValue;
+	}
+});
+Object.defineProperty(exports, "getProviderOptionDescriptors", {
+	enumerable: true,
+	get: function() {
+		return getProviderOptionDescriptors;
+	}
+});
+Object.defineProperty(exports, "getProviderOptionStringSelectionValue", {
+	enumerable: true,
+	get: function() {
+		return getProviderOptionStringSelectionValue;
+	}
+});
 Object.defineProperty(exports, "gitCommandDuration", {
 	enumerable: true,
 	get: function() {
@@ -3170,6 +4043,12 @@ Object.defineProperty(exports, "increment", {
 		return increment;
 	}
 });
+Object.defineProperty(exports, "makeWorkspaceAccessPolicy", {
+	enumerable: true,
+	get: function() {
+		return makeWorkspaceAccessPolicy;
+	}
+});
 Object.defineProperty(exports, "metricAttributes", {
 	enumerable: true,
 	get: function() {
@@ -3182,12 +4061,24 @@ Object.defineProperty(exports, "metricNames", {
 		return metricNames;
 	}
 });
+Object.defineProperty(exports, "modelSelectionRequiresContextHandoff", {
+	enumerable: true,
+	get: function() {
+		return modelSelectionRequiresContextHandoff;
+	}
+});
 Object.defineProperty(exports, "normalizeHubNodeName", {
 	enumerable: true,
 	get: function() {
 		return normalizeHubNodeName;
 	}
 });
+Object.defineProperty(exports, "normalizeModelSlug", {
+	enumerable: true,
+	get: function() {
+		return normalizeModelSlug;
+	}
+});
 Object.defineProperty(exports, "orchestrationCommandAckDuration", {
 	enumerable: true,
 	get: function() {
@@ -3218,6 +4109,12 @@ Object.defineProperty(exports, "outcomeFromExit", {
 		return outcomeFromExit;
 	}
 });
+Object.defineProperty(exports, "parsePersistedServerObservabilitySettings", {
+	enumerable: true,
+	get: function() {
+		return parsePersistedServerObservabilitySettings;
+	}
+});
 Object.defineProperty(exports, "providerEventLogRecordsDroppedTotal", {
 	enumerable: true,
 	get: function() {
@@ -3296,6 +4193,18 @@ Object.defineProperty(exports, "providerTurnsTotal", {
 		return providerTurnsTotal;
 	}
 });
+Object.defineProperty(exports, "redactServerSettingsForClient", {
+	enumerable: true,
+	get: function() {
+		return redactServerSettingsForClient;
+	}
+});
+Object.defineProperty(exports, "resolveConfiguredWorktreeRoot", {
+	enumerable: true,
+	get: function() {
+		return resolveConfiguredWorktreeRoot;
+	}
+});
 Object.defineProperty(exports, "resolveHubConnectorConfig", {
 	enumerable: true,
 	get: function() {
@@ -3314,6 +4223,12 @@ Object.defineProperty(exports, "resolveNodeE2eePolicyConfig", {
 		return resolveNodeE2eePolicyConfig;
 	}
 });
+Object.defineProperty(exports, "resolvePromptInjectedEffort", {
+	enumerable: true,
+	get: function() {
+		return resolvePromptInjectedEffort;
+	}
+});
 Object.defineProperty(exports, "resolveStaticDir", {
 	enumerable: true,
 	get: function() {
@@ -3386,6 +4301,12 @@ Object.defineProperty(exports, "runtimeQueueRecoveriesTotal", {
 		return runtimeQueueRecoveriesTotal;
 	}
 });
+Object.defineProperty(exports, "selectConfiguredWorktreeRoot", {
+	enumerable: true,
+	get: function() {
+		return selectConfiguredWorktreeRoot;
+	}
+});
 Object.defineProperty(exports, "startupCommandGateEnqueuesTotal", {
 	enumerable: true,
 	get: function() {
@@ -3422,9 +4343,21 @@ Object.defineProperty(exports, "terminalSessionsTotal", {
 		return terminalSessionsTotal;
 	}
 });
+Object.defineProperty(exports, "validateWorktreeRoot", {
+	enumerable: true,
+	get: function() {
+		return validateWorktreeRoot;
+	}
+});
 Object.defineProperty(exports, "withMetrics", {
 	enumerable: true,
 	get: function() {
 		return withMetrics;
 	}
 });
+Object.defineProperty(exports, "writeFileStringAtomically", {
+	enumerable: true,
+	get: function() {
+		return writeFileStringAtomically;
+	}
+});