glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/config-store-mm7MgzoL.js

@@ -0,0 +1,1412 @@
+import { n as glimmervoidHomeDir$1, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
+import { I as TELEMETRY_KILL_SWITCH_FLAG, N as FeatureFlagsResponse, R as AGENT_ID_SHAPE_MESSAGE, U as RUNTIME_CONFIG_SCALAR_KEYS, V as Config, W as configIssueMessage, q as BranchGcFileSettings, z as BUILTIN_AGENT_IDS } from "./contracts-DGkKNh9W.js";
+import { r as SOURCE_NAMES } from "./ingest-core-DWI1Mbu4.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { promisify } from "node:util";
+import crypto, { createHash } from "node:crypto";
+//#region shared/paths.ts
+var realpathNative = promisify(fs.realpath.native);
+function canonicalizePath(p) {
+	try {
+		return fs.realpathSync.native(p);
+	} catch {
+		return p;
+	}
+}
+function caseFoldedPathKey(value) {
+	return process.platform === "win32" ? value.toLowerCase() : value;
+}
+function equalsIgnoringCaseOnWindows(a, b) {
+	return caseFoldedPathKey(a) === caseFoldedPathKey(b);
+}
+function isSameDirectoryPath(a, b) {
+	const resolvedA = path.resolve(String(a || ""));
+	const resolvedB = path.resolve(String(b || ""));
+	if (equalsIgnoringCaseOnWindows(resolvedA, resolvedB)) return true;
+	if (process.platform !== "win32" && process.platform !== "darwin") return false;
+	return equalsIgnoringCaseOnWindows(canonicalizePath(resolvedA), canonicalizePath(resolvedB));
+}
+async function comparableDirectoryPath(candidatePath) {
+	const resolvedPath = path.resolve(String(candidatePath || ""));
+	let canonicalPath;
+	try {
+		canonicalPath = await realpathNative(resolvedPath);
+	} catch {
+		canonicalPath = resolvedPath;
+	}
+	if (process.platform !== "win32") return canonicalPath;
+	return canonicalPath.toLowerCase();
+}
+function safePathSegment(value) {
+	return String(value).replace(/[<>:"/\\|?*\x00-\x1f]/g, "-").replace(/[. ]+$/, "") || "_";
+}
+function sanitizeWorktreeName(value) {
+	return String(value || "").replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var DEFAULT_BRANCH_GC_PREFIXES = ["glimmervoid/session/", "worktree-agent-"];
+var DAY_MS = 864e5;
+var STALE_DELETION_REASON = "stale-orphan";
+var UNMERGED_KEPT_REASON = "not-merged-and-unmerged-deletion-off";
+function sessionIdFromBranch(branchName) {
+	if (!branchName.startsWith("glimmervoid/session/")) return null;
+	return branchName.slice(20);
+}
+function usablePrefixes(prefixes) {
+	return prefixes.filter((prefix) => prefix.length > 0);
+}
+function matchedPrefix(name, prefixes) {
+	for (const prefix of usablePrefixes(prefixes)) if (name.startsWith(prefix)) return prefix;
+	return null;
+}
+function protectedBranchNames(integrationTips) {
+	return /* @__PURE__ */ new Set([
+		"main",
+		"master",
+		...integrationTips.map((tip) => tip.branch)
+	]);
+}
+function planBranchGc({ remoteBranches = [], integrationTips = [], liveSessionIds = /* @__PURE__ */ new Set(), prefixes = DEFAULT_BRANCH_GC_PREFIXES, nowMs, staleDays = 14, deleteUnmerged = false }) {
+	const deletions = [];
+	const kept = [];
+	const protectedNames = protectedBranchNames(integrationTips);
+	const staleBeforeMs = nowMs - staleDays * DAY_MS;
+	for (const remoteBranch of remoteBranches) {
+		const { name, tipSha } = remoteBranch;
+		if (matchedPrefix(name, prefixes) === null) {
+			kept.push({
+				name,
+				reason: "foreign-prefix"
+			});
+			continue;
+		}
+		if (protectedNames.has(name)) {
+			kept.push({
+				name,
+				reason: "not-merged-and-fresh"
+			});
+			continue;
+		}
+		const sessionId = sessionIdFromBranch(name);
+		if (sessionId !== null && liveSessionIds.has(sessionId)) {
+			kept.push({
+				name,
+				reason: "live-session"
+			});
+			continue;
+		}
+		if (remoteBranch.mergedIntoIntegration === true) {
+			deletions.push({
+				name,
+				reason: remoteBranch.mergedReason ?? "merged-into-integration",
+				tipSha
+			});
+			continue;
+		}
+		if (!deleteUnmerged) {
+			kept.push({
+				name,
+				reason: UNMERGED_KEPT_REASON
+			});
+			continue;
+		}
+		if (Number.isFinite(remoteBranch.tipCommitTimeMs) && remoteBranch.tipCommitTimeMs < staleBeforeMs) {
+			deletions.push({
+				name,
+				reason: STALE_DELETION_REASON,
+				tipSha
+			});
+			continue;
+		}
+		kept.push({
+			name,
+			reason: "not-merged-and-fresh"
+		});
+	}
+	return {
+		deletions,
+		kept
+	};
+}
+function worktreeIntegrationTips({ projectTips, worktreeOwnTips }) {
+	const tipBySha = /* @__PURE__ */ new Map();
+	for (const tip of [...projectTips, ...worktreeOwnTips]) {
+		if (!tip.sha) continue;
+		if (tipBySha.has(tip.sha)) continue;
+		tipBySha.set(tip.sha, tip);
+	}
+	return [...tipBySha.values()];
+}
+function protectedWorktreeBranchNames(integrationTips, worktrees) {
+	const ownIntegrationBranches = worktrees.map((worktree) => worktree.integrationBranch).filter((branch) => Boolean(branch)).map((branch) => ({ branch }));
+	return protectedBranchNames([...integrationTips, ...ownIntegrationBranches]);
+}
+function planWorktreeGc({ worktrees, liveWorktreePaths, integrationTips, prefixes }) {
+	const removals = [];
+	const kept = [];
+	const protectedNames = protectedWorktreeBranchNames(integrationTips, worktrees);
+	for (const worktree of worktrees) {
+		const decision = (disposition, reason) => ({
+			cwd: worktree.cwd,
+			branch: worktree.branch,
+			disposition,
+			reason
+		});
+		if (worktree.prunable === true) {
+			kept.push(decision("keep", "missing-directory"));
+			continue;
+		}
+		if (worktree.locked) {
+			kept.push(decision("keep", "locked"));
+			continue;
+		}
+		if (liveWorktreePaths.has(worktree.cwd)) {
+			kept.push(decision("keep", "live-session"));
+			continue;
+		}
+		if (protectedNames.has(worktree.branch)) {
+			kept.push(decision("keep", "protected"));
+			continue;
+		}
+		if (matchedPrefix(worktree.branch, prefixes) === null) {
+			kept.push(decision("keep", "foreign-prefix"));
+			continue;
+		}
+		if (worktree.dirty === null) {
+			kept.push(decision("keep", "status-probe-failed"));
+			continue;
+		}
+		if (worktree.dirty) {
+			kept.push(decision("keep", "uncommitted-changes"));
+			continue;
+		}
+		if (worktree.atIntegrationTip === true) {
+			kept.push(decision("keep", "no-commits"));
+			continue;
+		}
+		if (worktree.merged === null) {
+			kept.push(decision("keep", "merge-proof-failed"));
+			continue;
+		}
+		if (worktree.merged !== true) {
+			kept.push(decision("keep", "unmerged"));
+			continue;
+		}
+		removals.push(decision("remove", "merged"));
+	}
+	return {
+		removals,
+		kept
+	};
+}
+//#endregion
+//#region server/core/usage-number-core.ts
+function safeNumber(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+	return value;
+}
+function numberOrNull(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	return value;
+}
+function stringOrNull(value) {
+	if (typeof value !== "string" || value.length === 0) return null;
+	return value;
+}
+function isPlainObject(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region server/core/config-secrets-core.ts
+var ENV_SECRET_BINDINGS = Object.freeze([{
+	blockName: "posthog",
+	secretKey: "apiKey",
+	environmentVariable: "GLIMMERVOID_POSTHOG_API_KEY"
+}, {
+	blockName: "telegram",
+	secretKey: "botToken",
+	environmentVariable: "GLIMMERVOID_TELEGRAM_BOT_TOKEN"
+}]);
+function readEnvSecrets(env) {
+	const resolvedSecrets = [];
+	for (const binding of ENV_SECRET_BINDINGS) {
+		const value = env[binding.environmentVariable];
+		if (typeof value !== "string" || value.length === 0) continue;
+		resolvedSecrets.push({
+			...binding,
+			value
+		});
+	}
+	return resolvedSecrets;
+}
+function copyOfBlock(config, blockName) {
+	const block = config[blockName];
+	if (!isPlainObject(block)) return {};
+	return { ...block };
+}
+function withEnvSecrets(config, envSecrets) {
+	if (envSecrets.length === 0) return config;
+	const overlaid = { ...config };
+	for (const secret of envSecrets) overlaid[secret.blockName] = {
+		...copyOfBlock(overlaid, secret.blockName),
+		[secret.secretKey]: secret.value
+	};
+	return overlaid;
+}
+function withoutEnvSecrets(config, envSecrets) {
+	if (envSecrets.length === 0) return config;
+	const stripped = { ...config };
+	for (const secret of envSecrets) {
+		if (!isPlainObject(stripped[secret.blockName])) continue;
+		const remaining = copyOfBlock(stripped, secret.blockName);
+		delete remaining[secret.secretKey];
+		if (Object.keys(remaining).length === 0) {
+			delete stripped[secret.blockName];
+			continue;
+		}
+		stripped[secret.blockName] = remaining;
+	}
+	return stripped;
+}
+function withSortedKeys(value) {
+	if (Array.isArray(value)) return value.map(withSortedKeys);
+	if (!isPlainObject(value)) return value;
+	const sorted = {};
+	for (const key of Object.keys(value).sort()) sorted[key] = withSortedKeys(value[key]);
+	return sorted;
+}
+function stableConfigKey(value) {
+	return JSON.stringify(withSortedKeys(value));
+}
+//#endregion
+//#region server/core/telemetry-core.ts
+var POSTHOG_INGEST_HOST = "https://us.i.posthog.com";
+var TELEMETRY_BATCH_URL = `${POSTHOG_INGEST_HOST}/batch/`;
+var TELEMETRY_FLAGS_URL = `${POSTHOG_INGEST_HOST}/flags?v=2`;
+var MAX_STACK_LENGTH = 16384;
+var FIRST_RUN_NOTICE = ["Glimmervoid sends anonymous usage and error data to help improve it: app starts, daily activity, session starts and ends with the agent kind, exit kind and duration, errors as their type, error code and scrubbed stack frames, and per session token counts, models and estimated cost. No error messages, paths, repository names, prompts, model output or terminal output.", "Turn it off in Settings > Privacy, or set GLIMMERVOID_TELEMETRY=0 or DO_NOT_TRACK=1."].join("\n");
+var TRUTHY_FLAGS = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"yes"
+]);
+var FALSY_FLAGS = /* @__PURE__ */ new Set([
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+function normalizedFlag(value) {
+	return (value ?? "").trim().toLowerCase();
+}
+function decideTelemetryConsent(env, config) {
+	if (TRUTHY_FLAGS.has(normalizedFlag(env.DO_NOT_TRACK))) return {
+		isEnabled: false,
+		source: "do-not-track"
+	};
+	if (FALSY_FLAGS.has(normalizedFlag(env.GLIMMERVOID_TELEMETRY))) return {
+		isEnabled: false,
+		source: "environment"
+	};
+	if (TRUTHY_FLAGS.has(normalizedFlag(env.CI))) return {
+		isEnabled: false,
+		source: "ci"
+	};
+	if (normalizedFlag(env.NODE_TEST_CONTEXT) !== "") return {
+		isEnabled: false,
+		source: "test-runner"
+	};
+	const configured = config.telemetry?.enabled;
+	if (typeof configured === "boolean") return {
+		isEnabled: configured,
+		source: "config"
+	};
+	return {
+		isEnabled: true,
+		source: "default"
+	};
+}
+function isTelemetryForcedOff(env) {
+	return decideTelemetryConsent(env, { telemetry: { enabled: true } }).isEnabled === false;
+}
+function resolveProjectToken(env) {
+	return env.GLIMMERVOID_TELEMETRY_PROJECT_TOKEN?.trim() || "phc_s68t9vWmeGcrWkx4NkLQaEiVZ9sMBxv8GjQBbAcix2Sf";
+}
+function toForwardSlashes(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
+function isWindowsStylePath(filePath) {
+	return /^[A-Za-z]:\//.test(filePath);
+}
+function comparablePath(filePath) {
+	const forward = toForwardSlashes(filePath).replace(/\/+$/, "");
+	return isWindowsStylePath(forward) ? forward.toLowerCase() : forward;
+}
+function decodedFileUrlPath(fileUrl) {
+	const urlPath = fileUrl.slice(7).replace(/^\/([A-Za-z]:)/, "$1");
+	try {
+		return decodeURIComponent(urlPath);
+	} catch {
+		return urlPath;
+	}
+}
+function stripFileScheme(rawPath) {
+	if (!rawPath.startsWith("file://")) return toForwardSlashes(rawPath);
+	return toForwardSlashes(decodedFileUrlPath(rawPath));
+}
+function relativeUnder(filePath, root) {
+	if (!root) return null;
+	const comparableRoot = comparablePath(root);
+	if (!comparableRoot) return null;
+	if (!comparablePath(filePath).startsWith(`${comparableRoot}/`)) return null;
+	return toForwardSlashes(filePath).slice(comparableRoot.length + 1);
+}
+function scrubLocalPath(rawPath, packageRoot) {
+	const filePath = stripFileScheme(rawPath);
+	if (filePath.startsWith("node:")) return filePath;
+	const underPackage = relativeUnder(filePath, packageRoot);
+	if (underPackage !== null) return underPackage;
+	const nodeModulesAt = filePath.lastIndexOf("/node_modules/");
+	if (nodeModulesAt >= 0) return filePath.slice(nodeModulesAt + 1);
+	return filePath.slice(filePath.lastIndexOf("/") + 1);
+}
+function isInApp(rawPath, packageRoot) {
+	const filePath = stripFileScheme(rawPath);
+	if (filePath.startsWith("node:")) return false;
+	const underPackage = relativeUnder(filePath, packageRoot);
+	if (underPackage === null) return false;
+	return !underPackage.split("/").includes("node_modules");
+}
+var V8_FRAME_WITH_FUNCTION = /^\s*at (.+?) \((.+?):(\d+):(\d+)\)$/;
+var V8_FRAME_ANONYMOUS = /^\s*at (.+?):(\d+):(\d+)$/;
+function matchV8Frame(stackLine) {
+	const named = V8_FRAME_WITH_FUNCTION.exec(stackLine);
+	if (named) return {
+		functionName: named[1].replace(/^async /, ""),
+		filePath: named[2],
+		line: named[3],
+		column: named[4]
+	};
+	const anonymous = V8_FRAME_ANONYMOUS.exec(stackLine);
+	if (!anonymous) return null;
+	return {
+		functionName: "?",
+		filePath: anonymous[1].replace(/^async /, ""),
+		line: anonymous[2],
+		column: anonymous[3]
+	};
+}
+function parseV8StackFrames(stack, packageRoot, platform = "node:javascript") {
+	const frames = [];
+	for (const stackLine of stack.slice(0, MAX_STACK_LENGTH).split("\n")) {
+		const rawFrame = matchV8Frame(stackLine);
+		if (!rawFrame) continue;
+		frames.push({
+			platform,
+			function: rawFrame.functionName.slice(0, 512),
+			filename: scrubLocalPath(rawFrame.filePath, packageRoot).slice(0, 512),
+			lineno: Number(rawFrame.line),
+			colno: Number(rawFrame.column),
+			in_app: isInApp(rawFrame.filePath, packageRoot)
+		});
+		if (frames.length >= 64) break;
+	}
+	return frames.reverse();
+}
+var ERROR_CODE_SHAPE = /^[A-Z][A-Z0-9_]{0,63}$/;
+function safeErrorCode(error) {
+	const code = Reflect.get(error, "code");
+	if (typeof code !== "string") return "";
+	return ERROR_CODE_SHAPE.test(code) ? code : "";
+}
+function errorParts(error) {
+	if (error instanceof Error) return {
+		type: error.name || "Error",
+		code: safeErrorCode(error),
+		stack: error.stack ?? ""
+	};
+	return {
+		type: "NonError",
+		code: "",
+		stack: ""
+	};
+}
+function exceptionPropertiesOf({ type, code, handled, level, frames }) {
+	return {
+		$exception_list: [{
+			type: type.slice(0, 512),
+			value: code,
+			mechanism: {
+				handled,
+				synthetic: false,
+				type: "generic"
+			},
+			stacktrace: {
+				type: "raw",
+				frames
+			}
+		}],
+		$exception_level: level
+	};
+}
+function buildExceptionProperties(error, { handled, packageRoot }) {
+	const parts = errorParts(error);
+	return exceptionPropertiesOf({
+		type: parts.type,
+		code: parts.code,
+		handled,
+		level: handled ? "error" : "fatal",
+		frames: parseV8StackFrames(parts.stack, packageRoot)
+	});
+}
+var BROWSER_FRAME_GECKO = /^\s*([^@]*)@(.+?):(\d+):(\d+)$/;
+var URL_ORIGIN = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/]*/;
+var SAFE_ERROR_TYPE_NAME = /^[A-Za-z_$][\w$]{0,127}$/;
+function isWebUrl(rawUrl) {
+	return /^https?:\/\//i.test(rawUrl);
+}
+function lastPathSegment(urlPath) {
+	return urlPath.slice(urlPath.lastIndexOf("/") + 1);
+}
+function scrubWebPath(webPath) {
+	const nodeModulesAt = webPath.lastIndexOf("/node_modules/");
+	if (nodeModulesAt >= 0) return webPath.slice(nodeModulesAt + 1);
+	if (webPath.startsWith("/@fs/")) return lastPathSegment(webPath);
+	return webPath;
+}
+function urlPathOnly(rawUrl) {
+	const [withoutQueryOrHash] = rawUrl.split(/[?#]/, 1);
+	if (isWebUrl(withoutQueryOrHash)) return scrubWebPath(withoutQueryOrHash.replace(URL_ORIGIN, "") || "/");
+	return lastPathSegment(withoutQueryOrHash);
+}
+function matchBrowserFrame(stackLine) {
+	const v8Frame = matchV8Frame(stackLine);
+	if (v8Frame) return v8Frame;
+	const gecko = BROWSER_FRAME_GECKO.exec(stackLine);
+	if (!gecko) return null;
+	return {
+		functionName: gecko[1] || "?",
+		filePath: gecko[2],
+		line: gecko[3],
+		column: gecko[4]
+	};
+}
+function parseBrowserStackFrames(stack) {
+	const frames = [];
+	for (const stackLine of stack.slice(0, MAX_STACK_LENGTH).split("\n")) {
+		const rawFrame = matchBrowserFrame(stackLine);
+		if (!rawFrame) continue;
+		frames.push({
+			platform: "web:javascript",
+			function: rawFrame.functionName.slice(0, 512),
+			filename: urlPathOnly(rawFrame.filePath).slice(0, 512),
+			lineno: Number(rawFrame.line),
+			colno: Number(rawFrame.column),
+			in_app: isWebUrl(rawFrame.filePath)
+		});
+		if (frames.length >= 64) break;
+	}
+	return frames.reverse();
+}
+function safeErrorTypeName(name) {
+	return SAFE_ERROR_TYPE_NAME.test(name) ? name : "Error";
+}
+function buildBrowserExceptionProperties({ name, stack }) {
+	return exceptionPropertiesOf({
+		type: safeErrorTypeName(name),
+		code: "",
+		handled: false,
+		level: "error",
+		frames: parseBrowserStackFrames(stack)
+	});
+}
+function exceptionFingerprint(properties) {
+	const [exception] = properties.$exception_list;
+	const inAppFrames = exception.stacktrace.frames.filter((frame) => frame.in_app).map((frame) => `${frame.function}@${frame.filename}`);
+	return [exception.type, ...inAppFrames].join("|");
+}
+function isBuiltinAgentId(agentId) {
+	return BUILTIN_AGENT_IDS.some((builtinAgentId) => builtinAgentId === agentId);
+}
+function adapterBucket(agentId) {
+	if (isBuiltinAgentId(agentId)) return agentId;
+	return "custom";
+}
+function classifySessionExit({ exitCode, signal, reason }) {
+	if (reason === "no_output_before_exit") return "no_output";
+	if (signal) return "signal";
+	if (exitCode === 0) return "clean";
+	return "error";
+}
+var AI_PROVIDER_BY_VENDOR = Object.freeze({
+	claude: "anthropic",
+	codex: "openai",
+	grok: "xai"
+});
+var AGENT_ID_BY_VENDOR = Object.freeze({
+	claude: "claude-code",
+	codex: "codex",
+	grok: "grok"
+});
+function aiTraceId(installId, sessionId) {
+	return createHash("sha256").update(`${installId}${sessionId}`).digest("hex");
+}
+function wholeTokenCount(tokens) {
+	return Math.max(0, Math.round(tokens));
+}
+function buildAiGenerationEvent(row, installId) {
+	const properties = {
+		$ai_trace_id: aiTraceId(installId, row.sessionId),
+		$ai_provider: (AI_PROVIDER_BY_VENDOR[row.vendor] ?? row.vendor).slice(0, 64),
+		$ai_model: row.isModelKnown ? row.model.slice(0, 128) : "unknown",
+		$ai_input_tokens: wholeTokenCount(row.input),
+		$ai_output_tokens: wholeTokenCount(row.output),
+		$ai_cache_read_input_tokens: wholeTokenCount(row.cacheRead),
+		$ai_cache_creation_input_tokens: wholeTokenCount(row.cacheCreate),
+		agent_adapter: adapterBucket(AGENT_ID_BY_VENDOR[row.vendor])
+	};
+	if (!row.hasKnownCost) return properties;
+	return {
+		...properties,
+		$ai_total_cost_usd: Math.max(0, row.costUSD)
+	};
+}
+function hasAnyTokens(row) {
+	return row.input + row.output + row.cacheRead + row.cacheCreate > 0;
+}
+function buildAiGenerationEvents(rows, installId) {
+	return rows.filter(hasAnyTokens).map((row) => buildAiGenerationEvent(row, installId));
+}
+function decideRemoteTelemetryState(previous, response) {
+	const parsed = FeatureFlagsResponse.safeParse(response);
+	if (!parsed.success || parsed.data.errorsWhileComputingFlags === true) return previous;
+	const killSwitchFlag = parsed.data.flags[TELEMETRY_KILL_SWITCH_FLAG];
+	if (!killSwitchFlag) return previous;
+	return killSwitchFlag.enabled ? "enabled" : "disabled";
+}
+var POSTHOG_RELEASE_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+function parsePosthogReleaseId(value) {
+	if (typeof value !== "string") return null;
+	return POSTHOG_RELEASE_ID_SHAPE.test(value) ? value : null;
+}
+function decideIsDevInstall({ installFlavor, isBundled, homeDir, defaultHomeDir }) {
+	if (installFlavor === "clone" || !isBundled) return true;
+	return comparablePath(homeDir) !== comparablePath(defaultHomeDir);
+}
+function nodeMajorVersion(nodeVersion) {
+	const major = Number.parseInt(nodeVersion.replace(/^v/, ""), 10);
+	return Number.isFinite(major) ? major : 0;
+}
+//#endregion
+//#region server/core/settings-block-core.ts
+var NO_BLOCKS = Object.freeze({});
+var INGEST_SOURCES_SPEC = Object.freeze({
+	name: "ingest.sources",
+	booleans: Object.freeze([]),
+	blocks: Object.freeze(Object.fromEntries(SOURCE_NAMES.map((source) => [source, Object.freeze({
+		name: `ingest.sources.${source}`,
+		booleans: Object.freeze(["enabled"]),
+		blocks: NO_BLOCKS
+	})])))
+});
+var INGEST_SPEC = Object.freeze({
+	name: "ingest",
+	booleans: Object.freeze(["enabled"]),
+	blocks: Object.freeze({ sources: INGEST_SOURCES_SPEC })
+});
+function validateSettingsBlock(block, spec) {
+	if (block == null) return null;
+	if (!isPlainObject(block)) return `${spec.name} must be an object`;
+	for (const [key, value] of Object.entries(block)) {
+		if (value == null) continue;
+		if (spec.booleans.includes(key)) {
+			if (typeof value !== "boolean") return `${spec.name}.${key} must be a boolean`;
+			continue;
+		}
+		if (Object.hasOwn(spec.blocks, key)) {
+			const error = validateSettingsBlock(value, spec.blocks[key]);
+			if (error) return error;
+			continue;
+		}
+		return `${spec.name}.${key} is not settable from the dashboard`;
+	}
+	return null;
+}
+function pickSettingsBlock(stored, spec) {
+	if (!isPlainObject(stored)) return null;
+	const fields = stored;
+	const out = {};
+	for (const key of spec.booleans) if (fields[key] != null) out[key] = !!fields[key];
+	for (const [key, nested] of Object.entries(spec.blocks)) {
+		const picked = pickSettingsBlock(fields[key], nested);
+		if (picked) out[key] = picked;
+	}
+	return out;
+}
+function mergeSettingsBlock(stored, incoming, spec) {
+	const out = isPlainObject(stored) ? { ...stored } : {};
+	if (!isPlainObject(incoming)) return out;
+	const fields = incoming;
+	for (const key of spec.booleans) if (fields[key] != null) out[key] = !!fields[key];
+	for (const [key, nested] of Object.entries(spec.blocks)) {
+		if (fields[key] == null) continue;
+		out[key] = mergeSettingsBlock(out[key], fields[key], nested);
+	}
+	return out;
+}
+//#endregion
+//#region server/json-file.ts
+var tmpCounter = 0;
+function tmpPathFor(filePath) {
+	tmpCounter += 1;
+	return `${filePath}.tmp.${process.pid}.${tmpCounter}`;
+}
+function writeOptions(mode, encoding) {
+	if (mode == null) return { encoding };
+	return {
+		encoding,
+		mode
+	};
+}
+var RENAME_RETRY_CODES = /* @__PURE__ */ new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+function renameRetryDelayMs(attempt) {
+	return Math.min(10 * 2 ** attempt, 50);
+}
+function isRetryableRename(error, attempt) {
+	if (attempt >= 4) return false;
+	const code = error?.code;
+	return typeof code === "string" && RENAME_RETRY_CODES.has(code);
+}
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameRetryPlan(error, attempt) {
+	if (!isRetryableRename(error, attempt)) return null;
+	return renameRetryDelayMs(attempt);
+}
+function isMissingFileError(error) {
+	const code = error?.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function loadJsonStateFile({ filePath, fsPromises, parse, nowMs }) {
+	let text;
+	try {
+		text = await fsPromises.readFile(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return { status: "missing" };
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	let value;
+	try {
+		value = parse(JSON.parse(text));
+	} catch {
+		value = null;
+	}
+	if (value !== null) return {
+		status: "loaded",
+		value
+	};
+	const movedTo = `${filePath}.corrupt-${nowMs()}`;
+	try {
+		await fsPromises.rename(filePath, movedTo);
+	} catch (error) {
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	return {
+		status: "quarantined",
+		movedTo
+	};
+}
+function renameWithRetrySync(fsSync, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		fsSync.renameSync(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		sleepSync(delayMs);
+	}
+}
+async function renameWithRetry(fsPromises, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		await fsPromises.rename(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		await new Promise((resolve) => {
+			setTimeout(resolve, delayMs);
+		});
+	}
+}
+function writeTextAtomicSync(filePath, content, { mode, encoding = "utf8", mkdir = false, fsSync = fs } = {}) {
+	if (mkdir) fsSync.mkdirSync(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	fsSync.writeFileSync(tmpPath, content, writeOptions(mode, encoding));
+	try {
+		renameWithRetrySync(fsSync, tmpPath, filePath);
+	} catch (error) {
+		fsSync.rmSync(tmpPath, { force: true });
+		throw error;
+	}
+}
+function writeJsonAtomicSync(filePath, value, options) {
+	writeTextAtomicSync(filePath, JSON.stringify(value, null, 2), options);
+}
+async function writeTextAtomic(filePath, content, { mode, encoding = "utf8", mkdir = false, fsPromises = fs.promises } = {}) {
+	if (mkdir) await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	await fsPromises.writeFile(tmpPath, content, writeOptions(mode, encoding));
+	try {
+		await renameWithRetry(fsPromises, tmpPath, filePath);
+	} catch (error) {
+		try {
+			await fsPromises.rm(tmpPath, { force: true });
+		} catch {}
+		throw error;
+	}
+}
+async function writeJsonAtomic(filePath, value, options) {
+	await writeTextAtomic(filePath, JSON.stringify(value, null, 2), options);
+}
+var appendChains = /* @__PURE__ */ new Map();
+function appendChained(filePath, payload, { fsPromises = fs.promises, mkdir = false, encoding = "utf8", mode } = {}) {
+	const next = (appendChains.get(filePath) || Promise.resolve()).then(async () => {
+		if (mkdir) await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+		await fsPromises.appendFile(filePath, payload, writeOptions(mode, encoding));
+	});
+	const settled = next.then(() => {}, () => {});
+	appendChains.set(filePath, settled);
+	settled.then(() => {
+		if (appendChains.get(filePath) === settled) appendChains.delete(filePath);
+	});
+	return next;
+}
+function appendJsonLine(filePath, value, options) {
+	return appendChained(filePath, `${JSON.stringify(value)}\n`, options);
+}
+function appendJsonLines(filePath, values, options) {
+	if (values.length === 0) return Promise.resolve();
+	return appendChained(filePath, values.map((value) => `${JSON.stringify(value)}\n`).join(""), options);
+}
+function createJsonStateWriter({ filePath, fsPromises = fs.promises, warn = () => {} }) {
+	let signature = null;
+	let writeChain = Promise.resolve();
+	async function commit(payload) {
+		try {
+			await writeTextAtomic(filePath, payload, {
+				fsPromises,
+				mkdir: true
+			});
+		} catch (error) {
+			warn(error);
+			signature = null;
+		}
+	}
+	async function write(subject, buildPayload) {
+		const next = JSON.stringify(subject);
+		if (next === signature) return;
+		signature = next;
+		writeChain = writeChain.then(() => commit(buildPayload())).catch(() => {});
+		await writeChain;
+	}
+	function reset() {
+		signature = null;
+	}
+	return {
+		write,
+		reset,
+		idle: () => writeChain
+	};
+}
+function createJsonStateStore({ name, filePath, fsPromises = fs.promises, parse, adopt, nowMs = Date.now, warn = () => {} }) {
+	const writer = filePath ? createJsonStateWriter({
+		filePath,
+		fsPromises,
+		warn: (error) => warn(`${name} write failed`, { error: errorText(error) })
+	}) : null;
+	let isFileReadable = true;
+	let loadPromise = null;
+	function load() {
+		const statePath = filePath;
+		if (!statePath) return Promise.resolve();
+		if (loadPromise) return loadPromise;
+		loadPromise = (async () => {
+			const outcome = await loadJsonStateFile({
+				filePath: statePath,
+				fsPromises,
+				parse,
+				nowMs
+			});
+			if (outcome.status === "unreadable") {
+				isFileReadable = false;
+				loadPromise = null;
+				warn(`${name} unreadable`, {
+					path: statePath,
+					error: errorText(outcome.error)
+				});
+				return;
+			}
+			if (outcome.status === "quarantined") warn(`${name} quarantined`, {
+				path: statePath,
+				movedTo: outcome.movedTo
+			});
+			isFileReadable = true;
+			adopt(outcome.status === "loaded" ? outcome.value : null);
+			writer?.reset();
+		})();
+		return loadPromise;
+	}
+	async function write(subject, buildPayload) {
+		if (!writer || !isFileReadable) return;
+		await writer.write(subject, buildPayload);
+	}
+	return {
+		load,
+		write,
+		idle: () => writer ? writer.idle() : Promise.resolve()
+	};
+}
+//#endregion
+//#region server/config-store.ts
+var DEFAULT_CONFIG = {
+	port: 3e3,
+	autoRecoverSeconds: 3,
+	inputGraceSeconds: 5,
+	promptDetectionMs: 1500,
+	notifyDebounceMs: 3e3,
+	phoneEscalationMs: 3e5,
+	cursorBlink: false,
+	debugMode: false,
+	calmLayout: false,
+	detectBackgroundAgents: true,
+	detectScheduledWakeups: true,
+	replayBufferKB: 512,
+	recordSignals: true,
+	trace: { enabled: true },
+	planReview: { enabled: true },
+	taskTitle: { refiner: {
+		enabled: true,
+		model: "haiku",
+		minIntervalSeconds: 60,
+		timeoutSeconds: 60
+	} },
+	changeMap: { narrator: {
+		enabled: false,
+		engine: "claude",
+		model: "",
+		timeoutSeconds: 90
+	} },
+	agentApi: { enabled: false },
+	telemetry: { enabled: true },
+	checkForUpdates: true,
+	updateChannel: "release",
+	autoResume: true,
+	skipPermissionsByDefault: false,
+	antiSlopPrompt: false,
+	rtk: false,
+	saneYolo: true,
+	telegramNotifications: false,
+	integrationBranch: null,
+	worktreeRoot: "",
+	worktreeShare: [
+		"node_modules",
+		".env",
+		".env.local",
+		".claude"
+	],
+	worktreeAutoRebase: true,
+	worktreeSyncOnStart: true,
+	worktreeRerere: true,
+	branchGc: {
+		enabled: true,
+		worktrees: true,
+		prefixes: [...DEFAULT_BRANCH_GC_PREFIXES],
+		dryRun: false,
+		staleDays: 14,
+		deleteUnmerged: false,
+		intervalMs: 216e5
+	},
+	repoRoots: [],
+	customAgents: [],
+	postTurnChecks: {
+		enabled: true,
+		mode: "report",
+		rules: {
+			trailingWs: true,
+			finalNewline: true,
+			bom: true,
+			slop: false
+		}
+	},
+	remote: {
+		enabled: false,
+		port: null,
+		publicHost: "",
+		allowedOrigins: []
+	},
+	workflows: {
+		enabled: true,
+		maxConcurrentSessions: 2,
+		maxActionsPerPoll: 20,
+		rules: []
+	},
+	projects: []
+};
+var DEFAULT_CONFIG_BY_KEY = DEFAULT_CONFIG;
+var ABORT_CONFIG_SAVE = "abort-config-save";
+function errorCode(error) {
+	const source = error ?? {};
+	if (typeof source.code === "string") return source.code;
+	return typeof source.message === "string" ? source.message : String(error);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function glimmervoidHomeDir() {
+	return glimmervoidHomeDir$1(os.homedir(), process.env);
+}
+function restrictMode(target, mode) {
+	try {
+		fs.chmodSync(target, mode);
+	} catch {}
+}
+function resolveConfigPath() {
+	const homeDir = glimmervoidHomeDir();
+	const decided = decideConfigPath({
+		env: process.env,
+		homeDir
+	}, (candidate) => fs.existsSync(candidate));
+	if (decided.path) return decided.path;
+	if (decided.source === "env") {
+		console.error(`Config file not found: ${decided.envPath}`);
+		process.exit(1);
+	}
+	const homeConfig = decided.homePath;
+	fs.mkdirSync(homeDir, {
+		recursive: true,
+		mode: 448
+	});
+	restrictMode(homeDir, 448);
+	fs.writeFileSync(homeConfig, JSON.stringify(DEFAULT_CONFIG, null, 2), {
+		encoding: "utf8",
+		mode: 384
+	});
+	restrictMode(homeConfig, 384);
+	console.log(`Created default config at ${homeConfig}`);
+	return homeConfig;
+}
+function generateProjectId() {
+	return crypto.randomUUID();
+}
+function validateConfig(candidate) {
+	if (!isPlainObject(candidate)) return {
+		ok: false,
+		errors: ["config must be a plain object"]
+	};
+	const parsedConfig = Config.safeParse(candidate);
+	if (!parsedConfig.success) return {
+		ok: false,
+		errors: parsedConfig.error.issues.map((issue) => {
+			if (issue.code === "custom") return issue.message;
+			const [root, index, field] = issue.path;
+			if (root === "port") return "port must be an integer from 0 to 65535";
+			if (root === "repoRoots" || root === "worktreeShare") return `${root} must be an array of strings`;
+			if (root === "remote") return "remote must be a plain object";
+			if (root !== "projects" && typeof DEFAULT_CONFIG_BY_KEY[String(root)] === "number") return `${String(root)} must be a finite number greater than or equal to 0`;
+			if (root !== "projects") return issue.message;
+			if (typeof index !== "number") return "projects must be an array";
+			if (!field) return `projects[${index}] must be a plain object`;
+			if (field === "agent") return `projects[${index}].agent must be ${AGENT_ID_SHAPE_MESSAGE}`;
+			if (field === "codexBypassHookTrust") return `projects[${index}].codexBypassHookTrust must be a boolean`;
+			return `projects[${index}].${String(field)} must be a string`;
+		})
+	};
+	return {
+		ok: true,
+		config: parsedConfig.data
+	};
+}
+function normalizeConfigFile(candidate) {
+	if (!isPlainObject(candidate)) throw new Error("config must be a plain object");
+	const draft = candidate;
+	for (const [key, fallback] of Object.entries(DEFAULT_CONFIG_BY_KEY)) {
+		if (fallback === null || typeof fallback === "object") continue;
+		if (!Object.hasOwn(draft, key)) continue;
+		const fieldSchema = Config.shape[key];
+		if (!fieldSchema || fieldSchema.safeParse(draft[key]).success) continue;
+		console.warn(`[config] ${key} value ${JSON.stringify(draft[key])} is invalid; using ${JSON.stringify(fallback)}`);
+		draft[key] = fallback;
+	}
+	const validation = validateConfig(draft);
+	if (!validation.ok) throw new Error(`validation failed: ${validation.errors.join("; ")}`);
+	return validation.config;
+}
+function writeBackupContent(backupPath, content) {
+	try {
+		fs.writeFileSync(backupPath, content, {
+			encoding: "utf8",
+			mode: 384
+		});
+		restrictMode(backupPath, 384);
+	} catch (err) {
+		console.warn(`[config] Failed to write backup ${backupPath}:`, errorCode(err));
+	}
+}
+function loadConfigFile(configPath, { exitOnError = true } = {}) {
+	const loadedContent = fs.readFileSync(configPath, "utf8");
+	try {
+		return {
+			config: withEnvSecrets(normalizeConfigFile(JSON.parse(loadedContent)), readEnvSecrets(process.env)),
+			loadedContent
+		};
+	} catch (err) {
+		const invalidBackupPath = `${configPath}.invalid.bak`;
+		try {
+			fs.writeFileSync(invalidBackupPath, loadedContent, {
+				encoding: "utf8",
+				mode: 384
+			});
+			restrictMode(invalidBackupPath, 384);
+		} catch (backupErr) {
+			console.warn(`[config] Failed to save invalid config copy ${invalidBackupPath}:`, errorCode(backupErr));
+		}
+		const message = `[config] Could not load ${configPath}: ${errorMessage(err)}. The broken file was copied to ${invalidBackupPath} when possible. Restore from ${configPath}.boot.bak or ${configPath}.bak, then restart Glimmervoid.`;
+		if (!exitOnError) return {
+			error: err,
+			message,
+			invalidBackupPath
+		};
+		console.error(message);
+		process.exit(1);
+	}
+}
+function topLevelKeyCount(candidate) {
+	if (!isPlainObject(candidate)) return 0;
+	return Object.keys(candidate).length;
+}
+function isSuspectedExternalWipe(candidate, currentConfig) {
+	const currentKeyCount = topLevelKeyCount(currentConfig);
+	if (currentKeyCount === 0) return false;
+	return topLevelKeyCount({
+		...candidate,
+		branchGc: resolveBranchGc(candidate.branchGc)
+	}) * 2 < currentKeyCount;
+}
+function warnInvalidConfig(action, validation) {
+	console.warn(`[config] Refusing to ${action}; validation failed: ${validation.errors.join("; ")}. Recovery sources: config.json.bak and config.json.boot.bak.`);
+}
+function warnSuspectedWipe(action) {
+	console.warn(`[config] Refusing to ${action}; config.json has fewer than half the top-level keys of the in-memory config. This looks like an external wipe. Recovery sources: config.json.bak and config.json.boot.bak.`);
+}
+function ensureProjectIds(projects) {
+	let changed = false;
+	for (const p of projects) if (!p.id) {
+		p.id = generateProjectId();
+		changed = true;
+	}
+	return changed;
+}
+function collectBranchGcIssues(branchGc) {
+	if (!isPlainObject(branchGc)) return {
+		block: { ...DEFAULT_CONFIG.branchGc },
+		issues: []
+	};
+	const accepted = {};
+	const issues = [];
+	for (const [field, value] of Object.entries(branchGc)) {
+		if (!Object.hasOwn(BranchGcFileSettings.shape, field)) {
+			issues.push(`[config] Ignoring unknown branchGc.${field}; it is not a branchGc setting, so the default block applies.`);
+			continue;
+		}
+		const parsed = BranchGcFileSettings.safeParse({ [field]: value });
+		if (!parsed.success) {
+			issues.push(`[config] Ignoring invalid branchGc.${field}; using the default instead: ${configIssueMessage(parsed.error)}`);
+			continue;
+		}
+		accepted[field] = value;
+	}
+	return {
+		block: {
+			...DEFAULT_CONFIG.branchGc,
+			...accepted
+		},
+		issues
+	};
+}
+function resolveBranchGc(branchGc) {
+	return collectBranchGcIssues(branchGc).block;
+}
+function resolveBranchGcAndWarn(branchGc) {
+	const resolved = collectBranchGcIssues(branchGc);
+	for (const issue of resolved.issues) console.warn(issue);
+	return resolved.block;
+}
+var POSTHOG_SETTINGS_KEYS = Object.freeze([
+	"enabled",
+	"recurrenceDedupe",
+	"trafficSpikeEnabled",
+	"autoFix",
+	"host",
+	"repoPath",
+	"projects",
+	"projectMap",
+	"intervalMinutes",
+	"maxConcurrentInvestigations",
+	"investigationTimeoutSeconds",
+	"fixTimeoutSeconds",
+	"minUsersToInvestigate",
+	"userEscalationThreshold",
+	"recurrenceWindowDays",
+	"transientRecurrenceLimit",
+	"trafficSpikeMultiplier",
+	"trafficSpikeMinUsers",
+	"trafficSpikeCooldownMinutes",
+	"trafficSpikeBaselineDays"
+]);
+var POSTHOG_SECRET_KEYS = Object.freeze(["apiKey"]);
+var TELEGRAM_SETTINGS_KEYS = Object.freeze(["chatId"]);
+var TELEGRAM_SECRET_KEYS = Object.freeze(["botToken"]);
+var SECRET_PRESENCE_SUFFIX = "Configured";
+function pickRedactedBlock(stored, allowedKeys, secretKeys) {
+	if (!isPlainObject(stored)) return null;
+	const source = stored;
+	const redacted = {};
+	for (const key of allowedKeys) if (source[key] !== void 0) redacted[key] = source[key];
+	for (const secretKey of secretKeys) {
+		const secret = source[secretKey];
+		redacted[`${secretKey}${SECRET_PRESENCE_SUFFIX}`] = typeof secret === "string" && secret.length > 0;
+	}
+	return redacted;
+}
+function createConfigStore({ settingsDefaults } = {}) {
+	const configPath = resolveConfigPath();
+	const effectiveDefaults = {
+		...DEFAULT_CONFIG,
+		...settingsDefaults || {}
+	};
+	const launchDefaultKeys = new Set(Object.keys(settingsDefaults || {}));
+	const envSecrets = readEnvSecrets(process.env);
+	const loadedConfig = loadConfigFile(configPath);
+	const config = loadedConfig.config;
+	writeBackupContent(`${configPath}.boot.bak`, loadedConfig.loadedContent);
+	config.repoRoots = config.repoRoots || [];
+	config.branchGc = resolveBranchGcAndWarn(config.branchGc);
+	if (Array.isArray(config.projects) && ensureProjectIds(config.projects)) try {
+		writeJsonAtomicSync(configPath, withoutEnvSecrets(config, envSecrets), { mode: 384 });
+		console.log("[config] Auto-assigned IDs to projects missing them");
+	} catch (err) {
+		console.warn("[config] Failed to persist auto-assigned project IDs:", errorMessage(err));
+	}
+	let _lastWrittenContent = null;
+	let _lastAppliedContent = loadedConfig.loadedContent;
+	function save(mutatorFn) {
+		let loaded;
+		try {
+			loaded = loadConfigFile(configPath, { exitOnError: false });
+		} catch (err) {
+			console.warn("[config] Failed to read config.json for save:", errorCode(err));
+			return null;
+		}
+		if ("error" in loaded) {
+			console.warn(loaded.message);
+			return null;
+		}
+		const freshConfig = loaded.config;
+		const freshContent = loaded.loadedContent;
+		const freshValidation = validateConfig(freshConfig);
+		if (!freshValidation.ok) {
+			warnInvalidConfig("save config.json", freshValidation);
+			return null;
+		}
+		if (isSuspectedExternalWipe(freshConfig, config)) {
+			warnSuspectedWipe("save config.json");
+			return null;
+		}
+		if (mutatorFn(freshConfig) === "abort-config-save") return null;
+		const effectiveConfig = withEnvSecrets(freshConfig, envSecrets);
+		const mutatedValidation = validateConfig(effectiveConfig);
+		if (!mutatedValidation.ok) {
+			warnInvalidConfig("save config.json", mutatedValidation);
+			return null;
+		}
+		try {
+			const nextContent = JSON.stringify(withoutEnvSecrets(effectiveConfig, envSecrets), null, 2);
+			if (freshContent !== nextContent) writeBackupContent(`${configPath}.bak`, freshContent);
+			_lastWrittenContent = nextContent;
+			_lastAppliedContent = null;
+			writeTextAtomicSync(configPath, nextContent, { mode: 384 });
+		} catch (err) {
+			console.warn("[config] Failed to write config.json:", errorCode(err));
+			return null;
+		}
+		return mutatedValidation.config;
+	}
+	function getSettings() {
+		return {
+			port: config.port,
+			autoRecoverSeconds: config.autoRecoverSeconds,
+			inputGraceSeconds: config.inputGraceSeconds,
+			promptDetectionMs: config.promptDetectionMs,
+			notifyDebounceMs: config.notifyDebounceMs,
+			phoneEscalationMs: config.phoneEscalationMs ?? DEFAULT_CONFIG.phoneEscalationMs,
+			replayBufferKB: config.replayBufferKB,
+			cursorBlink: config.cursorBlink ?? effectiveDefaults.cursorBlink,
+			debugMode: config.debugMode ?? effectiveDefaults.debugMode,
+			calmLayout: config.calmLayout ?? effectiveDefaults.calmLayout,
+			detectBackgroundAgents: config.detectBackgroundAgents ?? effectiveDefaults.detectBackgroundAgents,
+			recordSignals: config.recordSignals ?? effectiveDefaults.recordSignals,
+			trace: { enabled: config.trace?.enabled ?? DEFAULT_CONFIG.trace.enabled },
+			agentApi: { enabled: config.agentApi?.enabled ?? DEFAULT_CONFIG.agentApi.enabled },
+			telemetry: { enabled: config.telemetry?.enabled ?? DEFAULT_CONFIG.telemetry.enabled },
+			telemetryForcedOff: isTelemetryForcedOff(process.env),
+			antiSlopPrompt: config.antiSlopPrompt ?? effectiveDefaults.antiSlopPrompt,
+			rtk: config.rtk ?? effectiveDefaults.rtk,
+			saneYolo: config.saneYolo ?? effectiveDefaults.saneYolo,
+			checkForUpdates: config.checkForUpdates ?? effectiveDefaults.checkForUpdates,
+			updateChannel: config.updateChannel ?? effectiveDefaults.updateChannel,
+			autoResume: config.autoResume ?? effectiveDefaults.autoResume,
+			skipPermissionsByDefault: config.skipPermissionsByDefault ?? effectiveDefaults.skipPermissionsByDefault,
+			telegramNotifications: config.telegramNotifications ?? effectiveDefaults.telegramNotifications,
+			integrationBranch: config.integrationBranch === void 0 ? effectiveDefaults.integrationBranch : config.integrationBranch,
+			worktreeRoot: config.worktreeRoot ?? effectiveDefaults.worktreeRoot,
+			worktreeShare: config.worktreeShare ?? effectiveDefaults.worktreeShare,
+			repoRoots: config.repoRoots,
+			taskTitle: config.taskTitle ? { ...config.taskTitle } : { ...DEFAULT_CONFIG.taskTitle },
+			changeMap: config.changeMap ? { ...config.changeMap } : null,
+			branchGc: { ...config.branchGc },
+			postTurnChecks: config.postTurnChecks ? { ...config.postTurnChecks } : { ...DEFAULT_CONFIG.postTurnChecks },
+			visions: config.visions ? { ...config.visions } : null,
+			teamReview: config.teamReview ? { ...config.teamReview } : null,
+			benchmarks: config.benchmarks ? { ...config.benchmarks } : null,
+			workflows: config.workflows ?? null,
+			posthog: pickRedactedBlock(config.posthog, POSTHOG_SETTINGS_KEYS, POSTHOG_SECRET_KEYS),
+			usage: config.usage ? { ...config.usage } : null,
+			telegram: pickRedactedBlock(config.telegram, TELEGRAM_SETTINGS_KEYS, TELEGRAM_SECRET_KEYS),
+			ingest: pickSettingsBlock(config.ingest, INGEST_SPEC),
+			projectChoices: (config.projects || []).map((p) => ({
+				id: p.id,
+				name: p.name,
+				path: p.path
+			}))
+		};
+	}
+	function isUnchosenLaunchDefault(target, key, value) {
+		if (!launchDefaultKeys.has(key)) return false;
+		if (key in target) return false;
+		return value === effectiveDefaults[key];
+	}
+	function applySettings(newConfig) {
+		for (const key of RUNTIME_CONFIG_SCALAR_KEYS) {
+			if (key === "integrationBranch") {
+				if (newConfig[key] === void 0) continue;
+				config[key] = newConfig[key] === null || String(newConfig[key]) === "" ? null : String(newConfig[key]);
+				continue;
+			}
+			if (newConfig[key] == null) continue;
+			let nextValue = newConfig[key];
+			if (typeof DEFAULT_CONFIG_BY_KEY[key] === "boolean") nextValue = !!nextValue;
+			if (typeof DEFAULT_CONFIG_BY_KEY[key] === "string") nextValue = String(nextValue);
+			if (typeof nextValue === "boolean" && isUnchosenLaunchDefault(config, key, nextValue)) continue;
+			config[key] = nextValue;
+		}
+		config.repoRoots = newConfig.repoRoots || [];
+		if (newConfig.postTurnChecks != null) config.postTurnChecks = newConfig.postTurnChecks;
+		if (newConfig.worktreeShare != null) config.worktreeShare = newConfig.worktreeShare;
+		if (newConfig.taskTitle != null) config.taskTitle = newConfig.taskTitle;
+		if (newConfig.changeMap != null) config.changeMap = newConfig.changeMap;
+		if (newConfig.branchGc != null) config.branchGc = resolveBranchGc(newConfig.branchGc);
+		if (newConfig.visions != null) config.visions = newConfig.visions;
+		if (newConfig.teamReview != null) config.teamReview = newConfig.teamReview;
+		if (newConfig.benchmarks != null) config.benchmarks = newConfig.benchmarks;
+		if (newConfig.posthog != null) config.posthog = newConfig.posthog;
+		if (newConfig.usage != null) config.usage = newConfig.usage;
+		if (newConfig.telegram != null) config.telegram = newConfig.telegram;
+		if (newConfig.ingest != null) config.ingest = newConfig.ingest;
+		if (newConfig.agentApi != null) config.agentApi = newConfig.agentApi;
+		if (newConfig.telemetry != null) config.telemetry = newConfig.telemetry;
+		if (newConfig.workflows == null) delete config.workflows;
+		if (newConfig.workflows != null) config.workflows = newConfig.workflows;
+		if (newConfig.coder == null) delete config.coder;
+		if (newConfig.coder != null) config.coder = newConfig.coder;
+		config.customAgents = newConfig.customAgents ?? [];
+		config.hooks = Array.isArray(newConfig.hooks) ? newConfig.hooks : [];
+		if (newConfig.port != null && newConfig.port !== config.port) console.log(`[settings] Port changed to ${newConfig.port} - restart required to take effect`);
+	}
+	function watchForChanges(callback) {
+		let reloadTimer = null;
+		let watcher = null;
+		function handleConfigChange(err, data) {
+			if (err) {
+				console.warn("[config] Failed to read config.json:", err.code);
+				return;
+			}
+			if (_lastWrittenContent !== null && data === _lastWrittenContent) return;
+			if (_lastAppliedContent !== null && data === _lastAppliedContent) return;
+			let newConfig;
+			try {
+				newConfig = withEnvSecrets(normalizeConfigFile(JSON.parse(data)), envSecrets);
+			} catch (parseErr) {
+				console.warn("[config] Invalid config.json:", errorMessage(parseErr));
+				return;
+			}
+			newConfig.branchGc = resolveBranchGcAndWarn(newConfig.branchGc);
+			if (isSuspectedExternalWipe(newConfig, config)) {
+				warnSuspectedWipe("reload config.json");
+				return;
+			}
+			_lastAppliedContent = data;
+			_lastWrittenContent = null;
+			callback(newConfig);
+			console.log("[config] Reloaded config.json");
+		}
+		try {
+			const canonicalConfigPath = canonicalizePath(configPath);
+			const watchDir = path.dirname(canonicalConfigPath);
+			const targetName = path.basename(canonicalConfigPath);
+			watcher = fs.watch(watchDir, (_event, filename) => {
+				if (filename != null && !equalsIgnoringCaseOnWindows(path.basename(String(filename)), targetName)) return;
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					fs.readFile(configPath, "utf8", handleConfigChange);
+				}, 500);
+			});
+			console.log("[config] Watching config.json for changes");
+		} catch (watchErr) {
+			console.warn("[config] Failed to watch config.json:", errorMessage(watchErr));
+		}
+		return function stop() {
+			if (reloadTimer) clearTimeout(reloadTimer);
+			if (watcher) try {
+				watcher.close();
+			} catch {}
+			watcher = null;
+		};
+	}
+	return {
+		config,
+		configPath,
+		save,
+		getSettings,
+		applySettings,
+		isUnchosenLaunchDefault,
+		watchForChanges,
+		DEFAULT_CONFIG
+	};
+}
+//#endregion
+export { sanitizeWorktreeName as $, decideTelemetryConsent as A, DEFAULT_BRANCH_GC_PREFIXES as B, adapterBucket as C, classifySessionExit as D, buildExceptionProperties as E, stableConfigKey as F, usablePrefixes as G, planBranchGc as H, isPlainObject as I, caseFoldedPathKey as J, worktreeIntegrationTips as K, numberOrNull as L, nodeMajorVersion as M, parsePosthogReleaseId as N, decideIsDevInstall as O, resolveProjectToken as P, safePathSegment as Q, safeNumber as R, TELEMETRY_FLAGS_URL as S, buildBrowserExceptionProperties as T, planWorktreeGc as U, matchedPrefix as V, sessionIdFromBranch as W, equalsIgnoringCaseOnWindows as X, comparableDirectoryPath as Y, isSameDirectoryPath as Z, INGEST_SPEC as _, ensureProjectIds as a, FIRST_RUN_NOTICE as b, loadConfigFile as c, appendJsonLine as d, appendJsonLines as f, writeJsonAtomicSync as g, writeJsonAtomic as h, createConfigStore as i, exceptionFingerprint as j, decideRemoteTelemetryState as k, resolveConfigPath as l, createJsonStateWriter as m, DEFAULT_CONFIG as n, generateProjectId as o, createJsonStateStore as p, canonicalizePath as q, SECRET_PRESENCE_SUFFIX as r, glimmervoidHomeDir as s, ABORT_CONFIG_SAVE as t, validateConfig as u, mergeSettingsBlock as v, buildAiGenerationEvents as w, TELEMETRY_BATCH_URL as x, validateSettingsBlock as y, stringOrNull as z };