ryco-cli 0.1.26 → 0.1.27

package/dist/{Metrics-C-3MahDy.mjs → serverSettings-C7N2cm7C.mjs}

@@ -1,9 +1,244 @@
 #!/usr/bin/env node
 
-import { Cause, Context, DateTime, Duration, Effect, Exit, FileSystem, Layer, Metric, Path, Schema } from "effect";
-import path from "node:path";
+import { Do as DEFAULT_GIT_TEXT_GENERATION_OPTIONS_BY_PROVIDER, Eo as DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, Hr as ServerSettings, Mo as ProviderInstanceId, Po as isProviderDriverKind, Rr as DEFAULT_SERVER_SETTINGS, Ur as ServerSettingsError, jo as ProviderDriverKind, ko as MODEL_SLUG_ALIASES_BY_PROVIDER } from "./src-D8uCtoDZ.mjs";
+import { r as fromLenientJson } from "./schemaJson-CaG1bOvo.mjs";
+import { Cache, Cause, Context, Data, DateTime, Deferred, Duration, Effect, Equal, Exit, FileSystem, Layer, Metric, Path, Predicate, PubSub, Ref, Schema, SchemaIssue, Scope, Stream } from "effect";
+import * as P from "effect/Predicate";
+import path, { join } from "node:path";
+import * as Crypto from "node:crypto";
 import { createHash, timingSafeEqual } from "node:crypto";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { access, lstat, realpath } from "node:fs/promises";
 import { dual } from "effect/Function";
+import * as Semaphore$1 from "effect/Semaphore";
+import "effect/PlatformError";
+//#region ../../packages/shared/src/Struct.ts
+function deepMerge(current, patch) {
+	if (!P.isObject(current) || !P.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] = P.isObject(existing) && P.isObject(value) ? deepMerge(existing, value) : value;
+	}
+	return next;
+}
+//#endregion
+//#region ../../packages/shared/src/model.ts
+const DEFAULT_PROVIDER_DRIVER_KIND = 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 = 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 = fromLenientJson(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(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",
@@ -129,7 +364,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
@@ -158,7 +393,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
@@ -819,7 +1054,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
@@ -838,12 +1073,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
@@ -2739,6 +2974,27 @@ const resolveStaticDir = Effect.fn(function* () {
 	if (yield* exists(join(monorepoClient, "index.html")).pipe(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 Schema.TaggedError()("WorkspaceAccessDeniedError", {
+	operation: Schema.String,
+	requestedPath: Schema.String,
+	accessRoot: Schema.String,
+	reason: 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 Context.Service()("ryco/workspace/Services/WorkspaceAccessPolicy") {};
+//#endregion
 //#region src/observability/Attributes.ts
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3006,4 +3262,523 @@ const providerTurnMetricAttributes = (input) => {
 	});
 };
 //#endregion
-export { ensureServerDirectories as $, runtimeQueueBlockedDuration as A, startupCommandGateQueueHighWater as B, providerStartupQueueHighWater as C, providerTurnsTotal as D, providerTurnMetricAttributes as E, runtimeQueueHighWater as F, LocalDiagnosticsMetrics as G, terminalRestartsTotal as H, runtimeQueueOverflowsTotal as I, outcomeFromExit as J, LocalDiagnosticsMetricsLive as K, runtimeQueueRecoveriesTotal as L, runtimeQueueDepth as M, runtimeQueueDequeuesTotal as N, rpcRequestDuration as O, runtimeQueueEnqueuesTotal as P, deriveServerPaths as Q, startupCommandGateEnqueuesTotal as R, providerStartupQueueDepth as S, providerTurnDuration as T, terminalSessionsTotal as U, startupCommandGateQueueWaitDuration as V, withMetrics as W, RuntimeMode as X, DEFAULT_PORT as Y, ServerConfig as Z, providerRuntimeEventsTotal as _, contextHandoffsTotal as a, encodeNativeNodeClaimTranscript as at, providerStaleStopTimeoutsTotal as b, increment as c, equalNodeIdentityBytes as ct, orchestrationCommandAckDuration as d, normalizeHubNodeName as dt, resolveHubConnectorConfig as et, orchestrationCommandDuration as f, Tokeniser as ft, providerMetricAttributes as g, Type as gt, providerEventLogRecordsDroppedTotal as h, rfc8949EncodeOptions as ht, contextHandoffPreparationDuration as i, canonicalizeHubOrigin as it, runtimeQueueCoalescedTotal as j, rpcRequestsTotal as k, metricAttributes as l, fingerprintNodePublicKey as lt, orchestrationEventsProcessedTotal as m, encode as mt, contextHandoffContextEntriesTotal as n, resolveNodeE2eePolicyConfig as nt, gitCommandDuration as o, encodeNodeAuthenticationTranscript as ot, orchestrationCommandsTotal as p, decode as pt, compactTraceAttributes as q, contextHandoffDispatchDuration as r, resolveStaticDir as rt, gitCommandsTotal as s, encodeNodeKeyRotationTranscript as st, contextHandoffContextBytesTotal as t, resolveManagedWorktreesRoot as tt, metricNames as u, formatNodePublicKeyFingerprint as ut, providerRuntimeStaleEventsTotal as v, providerStartupQueueWaitDuration as w, providerStartupAdmissionTotal as x, providerSessionsTotal as y, startupCommandGateQueueDepth as z };
+//#region src/atomicWrite.ts
+const writeFileStringAtomically = (input) => Effect.scoped(Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const tempFileId = yield* 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 Data.TaggedError("SecretStoreError") {};
+var ServerSecretStore = class extends Context.Service()("ryco/auth/Services/ServerSecretStore") {};
+//#endregion
+//#region src/auth/Layers/ServerSecretStore.ts
+const makeServerSecretStore = Effect.gen(function* () {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const serverConfig = yield* ServerConfig;
+	yield* fileSystem.makeDirectory(serverConfig.secretsDir, { recursive: true });
+	yield* fileSystem.chmod(serverConfig.secretsDir, 448).pipe(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.flatMap(() => fileSystem.chmod(directory, 448)));
+	};
+	const isPlatformError = (u) => Predicate.isTagged(u, "PlatformError");
+	const get = (name) => fileSystem.readFile(resolveSecretPath(name)).pipe(Effect.map((bytes) => Uint8Array.from(bytes)), Effect.catch((cause) => cause.reason._tag === "NotFound" ? Effect.succeed(null) : Effect.fail(new SecretStoreError({
+		message: `Failed to read secret ${name}.`,
+		cause
+	}))));
+	const set = (name, value) => {
+		const secretPath = resolveSecretPath(name);
+		const tempPath = `${secretPath}.${Crypto.randomUUID()}.tmp`;
+		return 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.catch((cause) => fileSystem.remove(tempPath).pipe(Effect.ignore, Effect.flatMap(() => Effect.fail(new SecretStoreError({
+			message: `Failed to persist secret ${name}.`,
+			cause
+		}))))));
+	};
+	const create = (name, value) => {
+		const secretPath = resolveSecretPath(name);
+		return Effect.scoped(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.mapError((cause) => new SecretStoreError({
+			message: `Failed to persist secret ${name}.`,
+			cause
+		})));
+	};
+	const getOrCreateRandom = (name, bytes) => get(name).pipe(Effect.flatMap((existing) => {
+		if (existing) return Effect.succeed(existing);
+		const generated = Crypto.randomBytes(bytes);
+		return create(name, generated).pipe(Effect.as(Uint8Array.from(generated)), Effect.catchTag("SecretStoreError", (error) => isPlatformError(error.cause) && error.cause.reason._tag === "AlreadyExists" ? get(name).pipe(Effect.flatMap((created) => created !== null ? Effect.succeed(created) : Effect.fail(new SecretStoreError({ message: `Failed to read secret ${name} after concurrent creation.` })))) : Effect.fail(error)));
+	}));
+	const remove = (name) => fileSystem.remove(resolveSecretPath(name)).pipe(Effect.catch((cause) => cause.reason._tag === "NotFound" ? Effect.void : Effect.fail(new SecretStoreError({
+		message: `Failed to remove secret ${name}.`,
+		cause
+	}))));
+	return {
+		get,
+		set,
+		getOrCreateRandom,
+		remove
+	};
+});
+const ServerSecretStoreLive = 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 homedir();
+	if (value.startsWith("~/") || value.startsWith("~\\")) return join(homedir(), value.slice(2));
+	return value;
+}
+//#endregion
+//#region src/project/worktreeRoot.ts
+var WorktreeRootError = class extends Schema.TaggedError()("WorktreeRootError", { detail: 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 lstat(ancestor);
+		const canonical = await realpath(ancestor);
+		if (!(await lstat(canonical)).isDirectory()) throw new Error("Worktree root must be a directory.");
+		await access(canonical, constants.W_OK | constants.X_OK);
+		return path.join(canonical, path.relative(ancestor, candidate));
+	} catch (cause) {
+		if (cause.code !== "ENOENT") throw cause;
+		if (await 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 = path.dirname(ancestor);
+		if (parent === ancestor) throw cause;
+		ancestor = parent;
+	}
+}
+const validateWorktreeRoot = (value, policy) => Effect.gen(function* () {
+	const trimmed = value.trim();
+	const expanded = expandHomePath(trimmed);
+	if (!trimmed || /[\x00-\x1f\x7f]/.test(trimmed) || !path.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: path.normalize(expanded),
+		operation
+	}).pipe(Effect.mapError((cause) => new WorktreeRootError({ detail: cause.message })));
+	const canonical = yield* 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.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.gen(function* () {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* 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.succeed(target);
+		return Effect.fail(denied(input, "outsideRoot"));
+	};
+	const assertExistingPath = 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.mapError(() => denied(input, "unresolvable")));
+		return yield* assertInside(input, canonical);
+	});
+	const assertPath = 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.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.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 = Layer.effect(WorkspaceAccessPolicy, 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 Context.Service()("ryco/serverSettings/ServerSettingsService") {
+	static layerTest = (overrides = {}) => Layer.effect(ServerSettingsService, Effect.gen(function* () {
+		const currentSettingsRef = yield* Ref.make(deepMerge(DEFAULT_SERVER_SETTINGS, overrides));
+		return {
+			start: Effect.void,
+			ready: Effect.void,
+			getSettings: Ref.get(currentSettingsRef),
+			updateSettings: (patch) => Ref.get(currentSettingsRef).pipe(Effect.flatMap((currentSettings) => Schema.decodeEffect(ServerSettings)(applyServerSettingsPatch(currentSettings, patch)).pipe(Effect.mapError((cause) => new ServerSettingsError({
+				settingsPath: "<memory>",
+				detail: `failed to normalize server settings: ${SchemaIssue.makeFormatterDefault()(cause.issue)}`,
+				cause
+			})))), Effect.tap((nextSettings) => Ref.set(currentSettingsRef, nextSettings))),
+			streamChanges: Stream.empty
+		};
+	}));
+};
+const ServerSettingsJson = fromLenientJson(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 (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 ? ProviderDriverKind.make(fallbackEntry[0]) : void 0;
+	if (!fallback) return settings;
+	const defaultOptions = DEFAULT_GIT_TEXT_GENERATION_OPTIONS_BY_PROVIDER[fallback];
+	return {
+		...settings,
+		textGenerationModelSelection: {
+			instanceId: ProviderInstanceId.make(fallback),
+			model: 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 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 (!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.gen(function* () {
+	const { settingsPath, workspaceAccessRoot } = yield* ServerConfig;
+	const worktreeAccessPolicy = yield* makeWorkspaceAccessPolicy(workspaceAccessRoot);
+	const fs = yield* FileSystem.FileSystem;
+	const pathService = yield* Path.Path;
+	const secretStore = yield* ServerSecretStore;
+	const writeSemaphore = yield* Semaphore$1.make(1);
+	const cacheKey = "settings";
+	const changesPubSub = yield* PubSub.unbounded();
+	const startedRef = yield* Ref.make(false);
+	const startedDeferred = yield* Deferred.make();
+	const watcherScope = yield* Scope.make("sequential");
+	yield* Effect.addFinalizer(() => Scope.close(watcherScope, Exit.void));
+	const emitChange = (settings) => PubSub.publish(changesPubSub, settings).pipe(Effect.asVoid);
+	const readConfigExists = fs.exists(settingsPath).pipe(Effect.mapError((cause) => new ServerSettingsError({
+		settingsPath,
+		detail: "failed to check settings file existence",
+		cause
+	})));
+	const readRawConfig = fs.readFileString(settingsPath).pipe(Effect.mapError((cause) => new ServerSettingsError({
+		settingsPath,
+		detail: "failed to read settings file",
+		cause
+	})));
+	const loadSettingsFromDisk = Effect.gen(function* () {
+		if (!(yield* readConfigExists)) return DEFAULT_SERVER_SETTINGS;
+		const raw = yield* readRawConfig;
+		const decoded = Schema.decodeUnknownExit(ServerSettingsJson)(raw);
+		if (decoded._tag === "Failure") {
+			yield* Effect.logWarning("failed to parse settings.json, using defaults", {
+				path: settingsPath,
+				issues: Cause.pretty(decoded.cause)
+			});
+			return DEFAULT_SERVER_SETTINGS;
+		}
+		return decoded.value;
+	});
+	const settingsCache = yield* Cache.make({
+		capacity: 1,
+		lookup: () => loadSettingsFromDisk
+	});
+	const getSettingsFromCache = Cache.get(settingsCache, cacheKey);
+	const toSettingsError = (detail, cause) => new ServerSettingsError({
+		settingsPath,
+		detail,
+		cause
+	});
+	const materializeProviderEnvironmentSecrets = (settings) => 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.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.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.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.mapError((cause) => toSettingsError(`failed to persist environment secret ${variable.name}`, cause)));
+						environment.push({
+							...variable,
+							value: "",
+							valueRedacted: true
+						});
+					} else {
+						yield* secretStore.remove(secretName).pipe(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.mapError((cause) => toSettingsError(`failed to remove stale environment secret ${variable.name}`, cause)));
+		}
+		return {
+			...next,
+			providerInstances
+		};
+	});
+	const writeSettingsAtomically = (settings) => {
+		const sparseSettings = stripDefaultServerSettings(settings, DEFAULT_SERVER_SETTINGS) ?? {};
+		return writeFileStringAtomically({
+			filePath: settingsPath,
+			contents: `${JSON.stringify(sparseSettings, null, 2)}\n`
+		}).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, pathService), Effect.mapError((cause) => new ServerSettingsError({
+			settingsPath,
+			detail: "failed to write settings file",
+			cause
+		})));
+	};
+	const revalidateAndEmit = writeSemaphore.withPermits(1)(Effect.gen(function* () {
+		yield* Cache.invalidate(settingsCache, cacheKey);
+		const settings = yield* getSettingsFromCache;
+		yield* emitChange(settings);
+	}));
+	const startWatcher = 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.mapError((cause) => new ServerSettingsError({
+			settingsPath,
+			detail: "failed to prepare settings directory",
+			cause
+		})));
+		const revalidateAndEmitSafely = revalidateAndEmit.pipe(Effect.ignoreCause({ log: true }));
+		const debouncedSettingsEvents = fs.watch(settingsDir).pipe(Stream.filter((event) => {
+			return event.path === settingsFile || event.path === settingsPath || pathService.resolve(settingsDir, event.path) === settingsPathResolved;
+		}), Stream.debounce(Duration.millis(100)));
+		yield* Stream.runForEach(debouncedSettingsEvents, () => revalidateAndEmitSafely).pipe(Effect.ignoreCause({ log: true }), Effect.forkIn(watcherScope), Effect.asVoid);
+	});
+	return {
+		start: Effect.gen(function* () {
+			if (!(yield* Ref.modify(startedRef, (started) => [!started, true]))) return yield* Deferred.await(startedDeferred);
+			const startup = Effect.gen(function* () {
+				yield* startWatcher;
+				yield* Cache.invalidate(settingsCache, cacheKey);
+				yield* getSettingsFromCache;
+			});
+			const startupExit = yield* Effect.exit(startup);
+			if (startupExit._tag === "Failure") {
+				yield* Deferred.failCause(startedDeferred, startupExit.cause).pipe(Effect.orDie);
+				return yield* Effect.failCause(startupExit.cause);
+			}
+			yield* Deferred.succeed(startedDeferred, void 0).pipe(Effect.orDie);
+		}),
+		ready: Deferred.await(startedDeferred),
+		getSettings: getSettingsFromCache.pipe(Effect.flatMap(materializeProviderEnvironmentSecrets), Effect.map(resolveTextGenerationProvider)),
+		updateSettings: (patch) => writeSemaphore.withPermits(1)(Effect.gen(function* () {
+			const current = yield* getSettingsFromCache;
+			const normalizedPatch = { ...patch };
+			const validateRoot = (root) => validateWorktreeRoot(root, worktreeAccessPolicy).pipe(Effect.mapError((cause) => new 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* Schema.decodeEffect(ServerSettings)(nextPersisted).pipe(Effect.mapError((cause) => new ServerSettingsError({
+				settingsPath: "<memory>",
+				detail: `failed to normalize server settings: ${SchemaIssue.makeFormatterDefault()(cause.issue)}`,
+				cause
+			})));
+			yield* writeSettingsAtomically(next);
+			yield* Cache.set(settingsCache, cacheKey, next);
+			yield* emitChange(next);
+			return resolveTextGenerationProvider(yield* materializeProviderEnvironmentSecrets(next));
+		})),
+		get streamChanges() {
+			return Stream.fromPubSub(changesPubSub).pipe(Stream.mapEffect((settings) => materializeProviderEnvironmentSecrets(settings).pipe(Effect.catch((error) => Effect.logWarning("failed to materialize provider environment secrets", { detail: error.detail }).pipe(Effect.as(settings))))), Stream.map(resolveTextGenerationProvider));
+		}
+	};
+});
+const ServerSettingsLive = Layer.effect(ServerSettingsService, makeServerSettings).pipe(Layer.provide(ServerSecretStoreLive));
+//#endregion
+export { startupCommandGateQueueWaitDuration as $, providerRuntimeStaleEventsTotal as A, parsePersistedServerObservabilitySettings as At, rpcRequestDuration as B, modelSelectionRequiresContextHandoff as Bt, orchestrationCommandAckDuration as C, formatNodePublicKeyFingerprint as Ct, providerEventLogRecordsDroppedTotal as D, encode as Dt, orchestrationEventsProcessedTotal as E, decode as Et, providerStartupQueueHighWater as F, getModelSelectionStringOptionValue as Ft, runtimeQueueDequeuesTotal as G, runtimeQueueBlockedDuration as H, resolvePromptInjectedEffort as Ht, providerStartupQueueWaitDuration as I, getProviderOptionBooleanSelectionValue as It, runtimeQueueOverflowsTotal as J, runtimeQueueEnqueuesTotal as K, providerTurnDuration as L, getProviderOptionCurrentValue as Lt, providerStaleStopTimeoutsTotal as M, createModelCapabilities as Mt, providerStartupAdmissionTotal as N, getModelDisplayLabel as Nt, providerMetricAttributes as O, rfc8949EncodeOptions as Ot, providerStartupQueueDepth as P, getModelSelectionBooleanOptionValue as Pt, startupCommandGateQueueHighWater as Q, providerTurnMetricAttributes as R, getProviderOptionDescriptors as Rt, metricNames as S, fingerprintNodePublicKey as St, orchestrationCommandsTotal as T, Tokeniser as Tt, runtimeQueueCoalescedTotal as U, rpcRequestsTotal as V, normalizeModelSlug as Vt, runtimeQueueDepth as W, startupCommandGateEnqueuesTotal as X, runtimeQueueRecoveriesTotal as Y, startupCommandGateQueueDepth as Z, contextHandoffsTotal as _, canonicalizeHubOrigin as _t, makeWorkspaceAccessPolicy as a, compactTraceAttributes as at, increment as b, encodeNodeKeyRotationTranscript as bt, validateWorktreeRoot as c, DEFAULT_PORT as ct, ServerSecretStore as d, deriveServerPaths as dt, terminalRestartsTotal as et, writeFileStringAtomically as f, ensureServerDirectories as ft, contextHandoffPreparationDuration as g, resolveStaticDir as gt, contextHandoffDispatchDuration as h, resolveNodeE2eePolicyConfig as ht, WorkspaceAccessPolicyLive as i, LocalDiagnosticsMetricsLive as it, providerSessionsTotal as j, applyClaudePromptEffortPrefix as jt, providerRuntimeEventsTotal as k, Type as kt, expandHomePath as l, RuntimeMode as lt, contextHandoffContextEntriesTotal as m, resolveManagedWorktreesRoot as mt, ServerSettingsService as n, withMetrics as nt, resolveConfiguredWorktreeRoot as o, outcomeFromExit as ot, contextHandoffContextBytesTotal as p, resolveHubConnectorConfig as pt, runtimeQueueHighWater as q, redactServerSettingsForClient as r, LocalDiagnosticsMetrics as rt, selectConfiguredWorktreeRoot as s, WorkspaceAccessPolicy as st, ServerSettingsLive as t, terminalSessionsTotal as tt, ServerSecretStoreLive as u, ServerConfig as ut, gitCommandDuration as v, encodeNativeNodeClaimTranscript as vt, orchestrationCommandDuration as w, normalizeHubNodeName as wt, metricAttributes as x, equalNodeIdentityBytes as xt, gitCommandsTotal as y, encodeNodeAuthenticationTranscript as yt, providerTurnsTotal as z, getProviderOptionStringSelectionValue as zt };