glimmervoid 0.38.2 → 0.40.0

package/dist/chunks/contracts-CloExMlS.js

@@ -0,0 +1,680 @@
+import { Bt as repoParts, F as TaskTitle, nt as SessionPrLinks } from "./session-BwB43SCa.js";
+import { B as POSTHOG_FIX_TIMEOUT_RANGE, D as BRANCH_GC_INTERVAL_MS_RANGE, F as MEMORY_RESERVE_MB_RANGE, G as POSTHOG_RECURRENCE_WINDOW_RANGE, H as POSTHOG_INVESTIGATION_TIMEOUT_RANGE, J as POSTHOG_TRAFFIC_MIN_USERS_RANGE, K as POSTHOG_TRAFFIC_BASELINE_RANGE, L as PORT_RANGE, O as BRANCH_GC_STALE_DAYS_RANGE, P as KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE, Q as TASK_TITLE_TIMEOUT_RANGE, R as POSITIVE_NUMBER_RANGE, T as WorkflowsSettingsUpdate, U as POSTHOG_MAX_CONCURRENT_RANGE, V as POSTHOG_INTERVAL_RANGE, W as POSTHOG_MIN_USERS_RANGE, X as POSTHOG_TRANSIENT_RECURRENCE_RANGE, Y as POSTHOG_TRAFFIC_MULTIPLIER_RANGE, Z as REPLAY_BUFFER_KB_RANGE, at as VISIONS_DISPATCH_TIMEOUT_RANGE, ct as VISIONS_QUIET_MS_RANGE, et as USAGE_INTEGER_RANGES, it as VISIONS_COOLDOWN_MS_RANGE, k as CHANGE_MAP_NARRATOR_TIMEOUT_RANGE, ot as VISIONS_INTENT_THREAD_TTL_MS_RANGE, q as POSTHOG_TRAFFIC_COOLDOWN_RANGE, rt as VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE, st as VISIONS_MAX_PER_HOUR_RANGE, w as WorkflowsSettings, z as POSTHOG_ESCALATION_RANGE } from "./control-messages-DpBaniJi.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import path from "node:path";
+import { z } from "zod";
+//#region shared/contracts/config-numbers-core.ts
+var POSTHOG_WHOLE_NUMBER_ROUNDING = {
+	maxConcurrentInvestigations: Math.ceil,
+	minUsersToInvestigate: Math.ceil,
+	userEscalationThreshold: Math.ceil,
+	trafficSpikeMinUsers: Math.ceil,
+	trafficSpikeBaselineDays: Math.floor
+};
+var LEGACY_INTEGER_FIELDS = [
+	{
+		path: [
+			"visions",
+			"dispatch",
+			"quietMs"
+		],
+		min: 1,
+		round: Math.floor
+	},
+	{
+		path: [
+			"visions",
+			"dispatch",
+			"cooldownMs"
+		],
+		min: 1,
+		round: Math.floor
+	},
+	{
+		path: [
+			"visions",
+			"dispatch",
+			"maxPerHour"
+		],
+		min: 1,
+		round: Math.floor
+	},
+	{
+		path: [
+			"visions",
+			"dispatch",
+			"activityMaxPerHour"
+		],
+		min: 0,
+		round: Math.floor
+	},
+	{
+		path: [
+			"visions",
+			"dispatch",
+			"dispatchTimeoutSeconds"
+		],
+		min: 1,
+		round: Math.floor
+	},
+	{
+		path: [
+			"visions",
+			"intent",
+			"threadTtlMs"
+		],
+		min: 1,
+		round: Math.floor
+	},
+	...Object.entries(POSTHOG_WHOLE_NUMBER_ROUNDING).map(([key, round]) => ({
+		path: ["posthog", key],
+		min: 1,
+		round
+	}))
+];
+function normalizeIntegerField(config, path, min, round) {
+	let target = config;
+	for (const segment of path.slice(0, -1)) {
+		const block = target[segment];
+		if (!isRecord(block)) return;
+		target[segment] = { ...block };
+		target = target[segment];
+	}
+	const key = path.at(-1);
+	const value = target[key];
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return;
+	if (Number.isInteger(value)) return;
+	target[key] = Math.min(Number.MAX_SAFE_INTEGER, Math.max(min, round(value)));
+}
+function normalizeLegacyConfigNumbers(candidate) {
+	const normalized = { ...candidate };
+	const replayBufferKB = candidate.replayBufferKB;
+	if (typeof replayBufferKB === "number" && Number.isFinite(replayBufferKB) && replayBufferKB >= 0 && replayBufferKB <= REPLAY_BUFFER_KB_RANGE.max) normalized.replayBufferKB = Math.max(REPLAY_BUFFER_KB_RANGE.min, Math.floor(replayBufferKB));
+	for (const { path, min, round } of LEGACY_INTEGER_FIELDS) normalizeIntegerField(normalized, path, min, round);
+	return normalized;
+}
+//#endregion
+//#region shared/usage-config.ts
+var USAGE_COST_MODES = Object.freeze([
+	"auto",
+	"calculate",
+	"display"
+]);
+var USAGE_VENDOR_KEYS = Object.freeze(["codex", "grok"]);
+var USAGE_BUDGET_KEYS = Object.freeze(["dailyUsd", "monthlyUsd"]);
+//#endregion
+//#region shared/contracts/browser-config.ts
+var optionalBoolean = (field) => z.boolean({ error: `${field} must be a boolean` }).optional();
+var optionalString = (field, trim = false) => {
+	const schema = z.string({ error: `${field} must be a string` });
+	return (trim ? schema.transform((value) => value.trim()) : schema).optional();
+};
+var numberRangeLabel = (range) => {
+	if (range.label) return range.label;
+	if (range.max != null) return `between ${range.min} and ${range.max}`;
+	if (range.exclusiveMin) return `greater than ${range.min}`;
+	return `at least ${range.min}`;
+};
+var optionalNumber = (field, range = POSITIVE_NUMBER_RANGE) => z.number({ error: `${field} must be ${numberRangeLabel(range)}` }).finite().refine((value) => !range.exclusiveMin || value > range.min, { message: `${field} must be ${numberRangeLabel(range)}` }).refine((value) => range.exclusiveMin || value >= range.min, { message: `${field} must be ${numberRangeLabel(range)}` }).refine((value) => range.max == null || value <= range.max, { message: `${field} must be ${numberRangeLabel(range)}` }).optional();
+var optionalWholeNumber = (field, range) => optionalNumber(field, range).unwrap().int({ error: `${field} must be a whole number ${numberRangeLabel(range)}` }).optional();
+var optionalInteger = (field, range) => z.number({ error: `${field} must be an integer between ${range.min} and ${range.max}` }).int({ error: `${field} must be an integer between ${range.min} and ${range.max}` }).min(range.min, { error: `${field} must be an integer between ${range.min} and ${range.max}` }).max(range.max, { error: `${field} must be an integer between ${range.min} and ${range.max}` }).optional();
+var optionalObject = (field, shape) => z.object(shape, { error: `${field} must be an object` }).nullable().optional();
+var optionalLooseObject = (field) => z.object({}, { error: `${field} must be an object` }).passthrough().nullable().optional();
+var CHANGE_MAP_NARRATOR_ENGINES = Object.freeze(["claude", "codex"]);
+var UPDATE_CHANNELS = Object.freeze(["release", "main"]);
+var POST_TURN_CHECK_MODES = Object.freeze(["report", "fix"]);
+var ChangeMapSettings = optionalObject("changeMap", { narrator: optionalObject("changeMap.narrator", {
+	enabled: optionalBoolean("changeMap.narrator.enabled"),
+	engine: z.enum(CHANGE_MAP_NARRATOR_ENGINES, { error: `changeMap.narrator.engine must be one of ${CHANGE_MAP_NARRATOR_ENGINES.join(", ")}` }).optional(),
+	model: optionalString("changeMap.narrator.model", true),
+	timeoutSeconds: optionalInteger("changeMap.narrator.timeoutSeconds", CHANGE_MAP_NARRATOR_TIMEOUT_RANGE)
+}) });
+var TaskTitleSettings = z.object({ refiner: z.object({
+	enabled: optionalBoolean("taskTitle.refiner.enabled"),
+	model: optionalString("taskTitle.refiner.model", true),
+	minIntervalSeconds: optionalNumber("taskTitle.refiner.minIntervalSeconds", { min: 0 }),
+	timeoutSeconds: optionalNumber("taskTitle.refiner.timeoutSeconds", TASK_TITLE_TIMEOUT_RANGE)
+}, { error: "taskTitle.refiner must be an object" }).nullable().optional() }, { error: "taskTitle must be an object" }).nullable().optional();
+var BRANCH_GC_SETTINGS_SHAPE = {
+	enabled: optionalBoolean("branchGc.enabled"),
+	worktrees: optionalBoolean("branchGc.worktrees"),
+	prefixes: z.array(z.string({ error: "branchGc.prefixes must be an array of strings" }).min(1, { error: "branchGc.prefixes entries must be non-empty strings" }), { error: "branchGc.prefixes must be an array of strings" }).optional(),
+	dryRun: optionalBoolean("branchGc.dryRun"),
+	staleDays: optionalNumber("branchGc.staleDays", BRANCH_GC_STALE_DAYS_RANGE),
+	deleteUnmerged: optionalBoolean("branchGc.deleteUnmerged"),
+	intervalMs: optionalNumber("branchGc.intervalMs", BRANCH_GC_INTERVAL_MS_RANGE)
+};
+var BranchGcFileSettings = z.object(BRANCH_GC_SETTINGS_SHAPE, { error: "branchGc must be an object" });
+var BranchGcSettings = optionalObject("branchGc", BRANCH_GC_SETTINGS_SHAPE);
+var BranchGcControlSettings = BranchGcFileSettings.omit({
+	prefixes: true,
+	dryRun: true,
+	worktrees: true
+}).nullable().optional();
+Object.freeze(["enabled", "deleteUnmerged"]);
+Object.freeze(["staleDays", "intervalMs"]);
+var PostTurnChecksSettings = optionalObject("postTurnChecks", { mode: z.enum(POST_TURN_CHECK_MODES, { error: "postTurnChecks.mode must be one of report, fix" }).optional() });
+var VisionsSettings = optionalObject("visions", {
+	enabled: optionalBoolean("visions.enabled"),
+	autoFix: optionalBoolean("visions.autoFix"),
+	projects: z.array(z.string({ error: "visions.projects must be an array of strings" }), { error: "visions.projects must be an array of strings" }).optional(),
+	dispatch: optionalObject("visions.dispatch", {
+		enabled: optionalBoolean("visions.dispatch.enabled"),
+		model: optionalString("visions.dispatch.model", true),
+		quietMs: optionalWholeNumber("visions.dispatch.quietMs", VISIONS_QUIET_MS_RANGE),
+		cooldownMs: optionalWholeNumber("visions.dispatch.cooldownMs", VISIONS_COOLDOWN_MS_RANGE),
+		maxPerHour: optionalWholeNumber("visions.dispatch.maxPerHour", VISIONS_MAX_PER_HOUR_RANGE),
+		activityMaxPerHour: optionalWholeNumber("visions.dispatch.activityMaxPerHour", VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE),
+		dispatchTimeoutSeconds: optionalWholeNumber("visions.dispatch.dispatchTimeoutSeconds", VISIONS_DISPATCH_TIMEOUT_RANGE)
+	}),
+	intent: optionalObject("visions.intent", { threadTtlMs: optionalWholeNumber("visions.intent.threadTtlMs", VISIONS_INTENT_THREAD_TTL_MS_RANGE) })
+});
+var GithubSettings = z.object({ teams: z.array(z.string({ error: "github.teams must be an array of org/slug strings" }).refine((team) => repoParts(team) !== null, { message: "github.teams entries must be org/slug with valid GitHub segments" }), { error: "github.teams must be an array of org/slug strings" }).optional() }, { error: "github must be an object" }).nullable().optional();
+var TeamReviewSettings = optionalObject("teamReview", {
+	enabled: optionalBoolean("teamReview.enabled"),
+	autoRebaseMyPrs: optionalBoolean("teamReview.autoRebaseMyPrs"),
+	keepMergeableEnabled: optionalBoolean("teamReview.keepMergeableEnabled"),
+	mergeQueueEnabled: optionalBoolean("teamReview.mergeQueueEnabled"),
+	keepMergeableTimeoutMinutes: optionalInteger("teamReview.keepMergeableTimeoutMinutes", KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE),
+	org: optionalString("teamReview.org", true),
+	team: optionalString("teamReview.team", true),
+	skill: optionalString("teamReview.skill", true),
+	reReviewAfterHours: optionalNumber("teamReview.reReviewAfterHours"),
+	skipIdleAfterDays: optionalNumber("teamReview.skipIdleAfterDays")
+});
+var BenchmarksSettings = optionalObject("benchmarks", { enabled: optionalBoolean("benchmarks.enabled") });
+var CoherenceSettings = optionalObject("coherence", { enabled: optionalBoolean("coherence.enabled") });
+var posthogNumberRanges = {
+	intervalMinutes: POSTHOG_INTERVAL_RANGE,
+	maxConcurrentInvestigations: POSTHOG_MAX_CONCURRENT_RANGE,
+	investigationTimeoutSeconds: POSTHOG_INVESTIGATION_TIMEOUT_RANGE,
+	fixTimeoutSeconds: POSTHOG_FIX_TIMEOUT_RANGE,
+	minUsersToInvestigate: POSTHOG_MIN_USERS_RANGE,
+	userEscalationThreshold: POSTHOG_ESCALATION_RANGE,
+	recurrenceWindowDays: POSTHOG_RECURRENCE_WINDOW_RANGE,
+	transientRecurrenceLimit: POSTHOG_TRANSIENT_RECURRENCE_RANGE,
+	trafficSpikeMultiplier: POSTHOG_TRAFFIC_MULTIPLIER_RANGE,
+	trafficSpikeMinUsers: POSTHOG_TRAFFIC_MIN_USERS_RANGE,
+	trafficSpikeCooldownMinutes: POSTHOG_TRAFFIC_COOLDOWN_RANGE,
+	trafficSpikeBaselineDays: POSTHOG_TRAFFIC_BASELINE_RANGE
+};
+var PosthogSettings = optionalObject("posthog", {
+	enabled: optionalBoolean("posthog.enabled"),
+	recurrenceDedupe: optionalBoolean("posthog.recurrenceDedupe"),
+	trafficSpikeEnabled: optionalBoolean("posthog.trafficSpikeEnabled"),
+	autoFix: optionalBoolean("posthog.autoFix"),
+	host: optionalString("posthog.host", true).refine((value) => value == null || !value || /^https?:\/\//i.test(value), { message: "posthog.host must be an http(s) URL" }),
+	apiKey: optionalString("posthog.apiKey", true),
+	repoPath: optionalString("posthog.repoPath", true),
+	projects: z.union([z.literal("all"), z.array(z.number({ error: "posthog.projects must be \"all\" or an array of positive integer project ids" }).int({ error: "posthog.projects must be \"all\" or an array of positive integer project ids" }).positive({ error: "posthog.projects must be \"all\" or an array of positive integer project ids" }), { error: "posthog.projects must be \"all\" or an array of positive integer project ids" })], { error: "posthog.projects must be \"all\" or an array of positive integer project ids" }).optional(),
+	projectMap: z.record(z.string(), z.unknown(), { error: "posthog.projectMap must be an object" }).optional(),
+	...Object.fromEntries(Object.entries(posthogNumberRanges).map(([key, range]) => [key, Object.hasOwn(POSTHOG_WHOLE_NUMBER_ROUNDING, key) ? optionalWholeNumber(`posthog.${key}`, range) : optionalNumber(`posthog.${key}`, range)]))
+});
+var usageCostModeMessage = `usage.costMode must be one of ${USAGE_COST_MODES.join(", ")}`;
+var usageVendorShape = Object.fromEntries(USAGE_VENDOR_KEYS.map((key) => [key, optionalBoolean(`usage.vendors.${key}`)]));
+var usageBudgetShape = Object.fromEntries(USAGE_BUDGET_KEYS.map((key) => [key, z.number({ error: `usage.budget.${key} must be a positive number or null` }).positive({ error: `usage.budget.${key} must be a positive number or null` }).nullable().optional()]));
+var createUsageSettings = (isAbsolutePath) => optionalObject("usage", {
+	enabled: optionalBoolean("usage.enabled"),
+	fetchPricing: optionalBoolean("usage.fetchPricing"),
+	planLimits: optionalBoolean("usage.planLimits"),
+	rtkSavings: optionalBoolean("usage.rtkSavings"),
+	scanIntervalMinutes: optionalInteger("usage.scanIntervalMinutes", USAGE_INTEGER_RANGES.scanIntervalMinutes),
+	retainDays: optionalInteger("usage.retainDays", USAGE_INTEGER_RANGES.retainDays),
+	warehouseRetainDays: optionalInteger("usage.warehouseRetainDays", USAGE_INTEGER_RANGES.warehouseRetainDays),
+	sessionBlockHours: optionalInteger("usage.sessionBlockHours", USAGE_INTEGER_RANGES.sessionBlockHours),
+	costMode: z.enum(USAGE_COST_MODES, { error: usageCostModeMessage }).optional(),
+	vendors: optionalObject("usage.vendors", usageVendorShape),
+	budget: optionalObject("usage.budget", usageBudgetShape),
+	extraProjectsDirs: z.array(z.string({ error: "usage.extraProjectsDirs must be an array of absolute paths" }), { error: "usage.extraProjectsDirs must be an array of absolute paths" }).transform((directories) => directories.map((directory) => directory.trim())).refine((directories) => directories.every((directory) => directory && isAbsolutePath(directory)), { message: "usage.extraProjectsDirs entries must be absolute paths" }).optional()
+});
+var TelegramSettings = optionalObject("telegram", {
+	botToken: optionalString("telegram.botToken", true),
+	chatId: optionalString("telegram.chatId", true)
+});
+var IngestSettings = z.object({ enabled: optionalBoolean("ingest.enabled") }, { error: "ingest must be an object" }).passthrough().optional();
+var TraceSettings = z.object({ enabled: optionalBoolean("trace.enabled") }, { error: "trace must be an object" }).optional();
+var PlanReviewSettings = z.object({ enabled: optionalBoolean("planReview.enabled") }, { error: "planReview must be an object" }).optional();
+var optionalPathList = (field) => z.array(z.string({ error: `${field} must be an array of paths` }).trim().min(1, { error: `${field} must be an array of paths` }), { error: `${field} must be an array of paths` }).optional();
+var guardrailsShape = {
+	unguardedRepos: optionalPathList("guardrails.unguardedRepos"),
+	blockedPaths: optionalPathList("guardrails.blockedPaths"),
+	unreadablePaths: optionalPathList("guardrails.unreadablePaths")
+};
+var isHomeRelativePath = (entry) => entry === "~" || entry.startsWith("~/") || entry.startsWith("~\\");
+var createGuardrailsSettings = (isAbsolutePath) => z.object({
+	...guardrailsShape,
+	blockedPaths: z.array(z.string({ error: "guardrails.blockedPaths must be an array of paths" }).trim().min(1, { error: "guardrails.blockedPaths must be an array of paths" }).refine((entry) => isHomeRelativePath(entry) || isAbsolutePath(entry), { message: "guardrails.blockedPaths entries must be absolute paths or start with ~/" }), { error: "guardrails.blockedPaths must be an array of paths" }).optional()
+}, { error: "guardrails must be an object" }).strict().optional();
+var GuardrailsFileSettings = z.object(guardrailsShape, { error: "guardrails must be an object" }).passthrough().optional();
+var telemetryShape = { enabled: optionalBoolean("telemetry.enabled") };
+var TelemetrySettings = z.object(telemetryShape, { error: "telemetry must be an object" }).strict().optional();
+var TelemetryFileSettings = z.object(telemetryShape, { error: "telemetry must be an object" }).passthrough().optional();
+var createBrowserConfigShape = (isAbsolutePath) => ({
+	port: z.number().int().min(PORT_RANGE.min).max(PORT_RANGE.max).optional(),
+	notifyDebounceMs: z.number().finite().nonnegative().optional(),
+	phoneEscalationMs: z.number().finite().nonnegative().optional(),
+	replayBufferKB: optionalWholeNumber("replayBufferKB", REPLAY_BUFFER_KB_RANGE),
+	sessionMemoryReserveMB: optionalWholeNumber("sessionMemoryReserveMB", MEMORY_RESERVE_MB_RANGE),
+	cursorBlink: optionalBoolean("cursorBlink"),
+	debugMode: optionalBoolean("debugMode"),
+	conversationView: optionalBoolean("conversationView"),
+	streamerMode: optionalBoolean("streamerMode"),
+	zenView: optionalBoolean("zenView"),
+	detectBackgroundAgents: optionalBoolean("detectBackgroundAgents"),
+	recordSignals: optionalBoolean("recordSignals"),
+	rtk: optionalBoolean("rtk"),
+	saneYolo: optionalBoolean("saneYolo"),
+	skipPermissionsByDefault: optionalBoolean("skipPermissionsByDefault"),
+	checkForUpdates: optionalBoolean("checkForUpdates"),
+	updateChannel: z.enum(UPDATE_CHANNELS, { error: "updateChannel must be one of release, main" }).optional(),
+	autoResume: optionalBoolean("autoResume"),
+	telegramNotifications: optionalBoolean("telegramNotifications"),
+	integrationBranch: optionalString("integrationBranch").nullable(),
+	worktreeRoot: optionalString("worktreeRoot"),
+	worktreeShare: z.array(z.string()).optional(),
+	repoRoots: z.array(z.string()).optional(),
+	changeMap: ChangeMapSettings,
+	taskTitle: TaskTitleSettings,
+	branchGc: BranchGcSettings,
+	postTurnChecks: PostTurnChecksSettings,
+	visions: VisionsSettings,
+	github: GithubSettings,
+	teamReview: TeamReviewSettings,
+	benchmarks: BenchmarksSettings,
+	coherence: CoherenceSettings,
+	posthog: PosthogSettings,
+	usage: createUsageSettings(isAbsolutePath),
+	telegram: TelegramSettings,
+	ingest: IngestSettings,
+	guardrails: createGuardrailsSettings(isAbsolutePath),
+	telemetry: TelemetrySettings,
+	workflows: WorkflowsSettings.nullable().optional()
+});
+var createBrowserConfig = (isAbsolutePath) => z.object(createBrowserConfigShape(isAbsolutePath));
+//#endregion
+//#region shared/contracts/config.ts
+var BrowserConfig = createBrowserConfig(path.isAbsolute);
+var BROWSER_CONFIG_SHAPE = BrowserConfig.shape;
+var ConfigUpdate = z.object({
+	...BROWSER_CONFIG_SHAPE,
+	notifyDebounceMs: z.number({ error: "notifyDebounceMs must be a positive number" }).finite().positive({ error: "notifyDebounceMs must be a positive number" }).optional(),
+	phoneEscalationMs: z.number({ error: "phoneEscalationMs must be a positive number" }).finite().positive({ error: "phoneEscalationMs must be a positive number" }).optional(),
+	branchGc: BranchGcControlSettings,
+	worktreeAutoRebase: optionalBoolean("worktreeAutoRebase"),
+	worktreeSyncOnStart: optionalBoolean("worktreeSyncOnStart"),
+	worktreeRerere: optionalBoolean("worktreeRerere"),
+	workflows: WorkflowsSettingsUpdate.optional()
+}).omit({
+	port: true,
+	worktreeShare: true
+}).strict();
+var AGENT_ID_RE = /^[a-z][a-z0-9-]{1,31}$/;
+var BUILTIN_AGENT_IDS = Object.freeze([
+	"claude-code",
+	"codex",
+	"grok"
+]);
+var AGENT_ID_SHAPE_MESSAGE = "an agent id of 2 to 32 characters of lowercase letters, digits and dashes, starting with a letter";
+var AGENT_COMMAND_BASENAME_RE = /^[A-Za-z0-9._+-]+$/;
+var AGENT_COMMAND_ABSOLUTE_RE = /^(?:\/|[A-Za-z]:[\\/])[A-Za-z0-9._+\-\\/]*[A-Za-z0-9._+-]$/;
+var AGENT_COMMAND_SHAPE_MESSAGE = "a bare command name or an absolute path, built only from letters, digits, dot, underscore, plus, dash and path separators";
+function isSpawnableCommand(command) {
+	if (AGENT_COMMAND_BASENAME_RE.test(command)) return true;
+	return AGENT_COMMAND_ABSOLUTE_RE.test(command);
+}
+var GIT_BRANCH_FORBIDDEN_PUNCTUATION_RE = /[~^:?*[\\]/;
+var GIT_BRANCH_FORBIDDEN_SEQUENCES = [
+	"..",
+	"@{",
+	"//"
+];
+function isControlOrSpaceCharacter(character) {
+	const codePoint = character.charCodeAt(0);
+	return codePoint <= 32 || codePoint === 127;
+}
+function isGitBranchName(name) {
+	if (name === "" || name === "@" || name === "HEAD") return false;
+	if (name.startsWith("-") || name.startsWith("/") || name.endsWith("/") || name.endsWith(".")) return false;
+	if (GIT_BRANCH_FORBIDDEN_SEQUENCES.some((sequence) => name.includes(sequence))) return false;
+	if (GIT_BRANCH_FORBIDDEN_PUNCTUATION_RE.test(name) || [...name].some(isControlOrSpaceCharacter)) return false;
+	return name.split("/").every((component) => !component.startsWith(".") && !component.endsWith(".lock"));
+}
+var CustomAgentDeclaration = z.object({
+	id: z.string({ error: "customAgents[].id must be a string" }).regex(AGENT_ID_RE, { error: `customAgents[].id must be ${AGENT_ID_SHAPE_MESSAGE}` }),
+	label: z.string({ error: "customAgents[].label must be a string" }).min(1, { error: "customAgents[].label must not be empty" }).max(60, { error: "customAgents[].label must be at most 60 characters" }),
+	command: z.string({ error: "customAgents[].command must be a string" }).min(1, { error: "customAgents[].command must not be empty" }).refine((command) => command.trim().length > 0, { error: "customAgents[].command must not be blank" }).refine(isSpawnableCommand, { error: `customAgents[].command must be ${AGENT_COMMAND_SHAPE_MESSAGE}` }),
+	args: z.array(z.string({ error: "customAgents[].args must be an array of strings" }), { error: "customAgents[].args must be an array of strings" }).default([]),
+	idleTitle: z.string({ error: "customAgents[].idleTitle must be a string" }).optional(),
+	busyTitle: z.string({ error: "customAgents[].busyTitle must be a string" }).optional()
+}).strict();
+var CustomAgentDeclarations = z.array(CustomAgentDeclaration, { error: "customAgents must be an array" }).superRefine((declarations, ctx) => {
+	const claimedIds = new Set(BUILTIN_AGENT_IDS);
+	for (const [index, declaration] of declarations.entries()) {
+		if (!claimedIds.has(declaration.id)) {
+			claimedIds.add(declaration.id);
+			continue;
+		}
+		const message = BUILTIN_AGENT_IDS.some((builtinAgentId) => builtinAgentId === declaration.id) ? `customAgents[${index}].id "${declaration.id}" collides with the builtin agent of the same id` : `customAgents[${index}].id "${declaration.id}" is declared more than once`;
+		ctx.addIssue({
+			code: "custom",
+			path: [index, "id"],
+			message
+		});
+	}
+});
+var TaskTitleSources = z.object({
+	customTitle: TaskTitle.nullable().optional(),
+	pendingPromptTitle: TaskTitle.nullable().optional(),
+	refinedTitle: TaskTitle.nullable().optional(),
+	aiTitle: TaskTitle.nullable().optional(),
+	oscTitle: TaskTitle.nullable().optional(),
+	promptTitle: TaskTitle.nullable().optional()
+}).strict();
+var TASK_TITLE_SOURCE_PRIORITY = [
+	"customTitle",
+	"pendingPromptTitle",
+	"refinedTitle",
+	"aiTitle",
+	"oscTitle",
+	"promptTitle"
+];
+var PersistedTaskTitle = z.object({
+	taskTitle: TaskTitle.min(1),
+	isCustom: z.boolean(),
+	sources: TaskTitleSources
+}).strict().refine(({ taskTitle, isCustom, sources }) => {
+	const source = TASK_TITLE_SOURCE_PRIORITY.find((candidate) => sources[candidate]?.trim());
+	if (!source) return false;
+	return sources[source]?.replace(/\s+/g, " ").trim() === taskTitle && isCustom === (source === "customTitle");
+});
+var ProjectConfig = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	customTitle: TaskTitle.optional(),
+	taskTitleState: PersistedTaskTitle.optional().catch(void 0),
+	prLinks: SessionPrLinks.optional().catch(void 0),
+	path: z.string(),
+	repos: z.array(z.string()).min(2).optional(),
+	baseBranch: z.string().refine(isGitBranchName, { error: "projects[].baseBranch must be a git branch name" }).optional(),
+	agent: z.string({ error: "projects[].agent must be a string" }).regex(AGENT_ID_RE, { error: `projects[].agent must be ${AGENT_ID_SHAPE_MESSAGE}` }).optional(),
+	codexBypassHookTrust: z.boolean().optional(),
+	conversationView: z.boolean({ error: "projects[].conversationView must be a boolean" }).optional(),
+	dangerouslySkipPermissions: z.boolean({ error: "projects[].dangerouslySkipPermissions must be a boolean" }).optional(),
+	unguarded: z.boolean({ error: "projects[].unguarded must be a boolean" }).optional()
+}).passthrough();
+var FILE_CONFIG_SHAPE = {
+	...BROWSER_CONFIG_SHAPE,
+	changeMap: ChangeMapSettings,
+	branchGc: optionalLooseObject("branchGc"),
+	coder: z.object({ appSlug: z.string().optional() }).loose().optional(),
+	visions: optionalLooseObject("visions"),
+	github: GithubSettings,
+	teamReview: optionalLooseObject("teamReview"),
+	benchmarks: optionalLooseObject("benchmarks"),
+	coherence: optionalLooseObject("coherence"),
+	posthog: optionalLooseObject("posthog"),
+	usage: optionalLooseObject("usage"),
+	telegram: optionalLooseObject("telegram"),
+	ingest: optionalLooseObject("ingest"),
+	workflows: optionalLooseObject("workflows"),
+	guardrails: GuardrailsFileSettings,
+	telemetry: TelemetryFileSettings,
+	trace: TraceSettings,
+	planReview: PlanReviewSettings,
+	customAgents: CustomAgentDeclarations.optional()
+};
+var Config = z.object({
+	...FILE_CONFIG_SHAPE,
+	detectScheduledWakeups: optionalBoolean("detectScheduledWakeups"),
+	worktreeAutoRebase: optionalBoolean("worktreeAutoRebase"),
+	worktreeSyncOnStart: optionalBoolean("worktreeSyncOnStart"),
+	worktreeRerere: optionalBoolean("worktreeRerere"),
+	postTurnChecks: z.record(z.string(), z.unknown()).optional(),
+	hooks: z.unknown().optional(),
+	remote: z.object({
+		enabled: z.boolean().optional(),
+		port: z.number().int().min(1).max(65535).nullable().optional(),
+		publicHost: z.string().optional(),
+		allowedOrigins: z.array(z.string()).optional(),
+		ownerLogin: z.string().optional()
+	}).passthrough().optional(),
+	projects: z.array(ProjectConfig)
+}).passthrough().superRefine((config, ctx) => {
+	if (!Array.isArray(config.projects)) return;
+	const declaredAgentIds = new Set(BUILTIN_AGENT_IDS);
+	for (const declaration of config.customAgents ?? []) declaredAgentIds.add(declaration.id);
+	for (const [index, project] of config.projects.entries()) {
+		const agent = project?.agent;
+		if (typeof agent !== "string" || !AGENT_ID_RE.test(agent)) continue;
+		if (declaredAgentIds.has(agent)) continue;
+		ctx.addIssue({
+			code: "custom",
+			path: [
+				"projects",
+				index,
+				"agent"
+			],
+			message: `projects[${index}].agent "${agent}" names no known agent; declare it under customAgents or use one of ${[...declaredAgentIds].join(", ")}`
+		});
+	}
+});
+var CONFIG_BLOCK_KEYS = Object.freeze([
+	"changeMap",
+	"taskTitle",
+	"branchGc",
+	"postTurnChecks",
+	"visions",
+	"github",
+	"teamReview",
+	"benchmarks",
+	"coherence",
+	"posthog",
+	"usage",
+	"telegram",
+	"ingest",
+	"guardrails",
+	"telemetry",
+	"workflows",
+	"coder"
+]);
+var CONFIG_SCALAR_KEYS = Object.freeze(Object.keys(BROWSER_CONFIG_SHAPE).filter((key) => {
+	if (CONFIG_BLOCK_KEYS.includes(key)) return false;
+	return key !== "port" && key !== "repoRoots" && key !== "worktreeShare";
+}));
+var RUNTIME_CONFIG_SCALAR_KEYS = Object.freeze([
+	...CONFIG_SCALAR_KEYS,
+	"worktreeAutoRebase",
+	"worktreeSyncOnStart",
+	"worktreeRerere"
+]);
+Object.freeze([
+	"detectScheduledWakeups",
+	"worktreeAutoRebase",
+	"worktreeSyncOnStart",
+	"worktreeRerere",
+	"hooks",
+	"remote",
+	"projects"
+]);
+function configIssueMessage(error) {
+	return error.issues[0]?.message || "settings are invalid";
+}
+//#endregion
+//#region shared/contracts/telemetry.ts
+var TELEMETRY_ADAPTERS = Object.freeze([...BUILTIN_AGENT_IDS, "custom"]);
+var SESSION_EXIT_KINDS = Object.freeze([
+	"clean",
+	"error",
+	"signal",
+	"no_output"
+]);
+var nonNegativeInteger = z.number().int().nonnegative();
+var boundedText = z.string().max(512);
+var AppStartedProperties = z.object({}).strict();
+var AppActiveProperties = z.object({ active_session_count: nonNegativeInteger }).strict();
+var SessionStartedProperties = z.object({ adapter: z.enum(TELEMETRY_ADAPTERS) }).strict();
+var SessionEndedProperties = z.object({
+	adapter: z.enum(TELEMETRY_ADAPTERS),
+	exit_kind: z.enum(SESSION_EXIT_KINDS),
+	duration_seconds: nonNegativeInteger
+}).strict();
+var ExceptionFrame = z.object({
+	platform: z.enum(["node:javascript", "web:javascript"]),
+	function: boundedText,
+	filename: boundedText,
+	lineno: nonNegativeInteger,
+	colno: nonNegativeInteger,
+	in_app: z.boolean()
+}).strict();
+var ExceptionProperties = z.object({
+	$exception_list: z.array(z.object({
+		type: boundedText,
+		value: boundedText,
+		mechanism: z.object({
+			handled: z.boolean(),
+			synthetic: z.boolean(),
+			type: z.literal("generic")
+		}).strict(),
+		stacktrace: z.object({
+			type: z.literal("raw"),
+			frames: z.array(ExceptionFrame).max(64)
+		}).strict()
+	}).strict()).length(1),
+	$exception_level: z.enum(["error", "fatal"])
+}).strict();
+var AiGenerationProperties = z.object({
+	$ai_trace_id: z.string().regex(/^[0-9a-f]{64}$/),
+	$ai_provider: z.string().max(64),
+	$ai_model: z.string().max(128),
+	$ai_input_tokens: nonNegativeInteger,
+	$ai_output_tokens: nonNegativeInteger,
+	$ai_cache_read_input_tokens: nonNegativeInteger.optional(),
+	$ai_cache_creation_input_tokens: nonNegativeInteger.optional(),
+	$ai_total_cost_usd: z.number().finite().nonnegative().optional(),
+	agent_adapter: z.enum(TELEMETRY_ADAPTERS)
+}).strict();
+var TELEMETRY_EVENT_SCHEMAS = Object.freeze({
+	app_started: AppStartedProperties,
+	app_active: AppActiveProperties,
+	session_started: SessionStartedProperties,
+	session_ended: SessionEndedProperties,
+	$exception: ExceptionProperties,
+	$ai_generation: AiGenerationProperties
+});
+Object.freeze([
+	{
+		name: "app_started",
+		description: "The server started listening."
+	},
+	{
+		name: "app_active",
+		description: "Once a day while the server runs, with how many sessions are live."
+	},
+	{
+		name: "session_started",
+		description: "A session spawned, with which kind of agent (any custom agent counts as `custom`)."
+	},
+	{
+		name: "session_ended",
+		description: "A session exited: how it exited and how long it ran, in whole seconds."
+	},
+	{
+		name: "$exception",
+		description: "An error in the server or the dashboard: its type, an error code when it has one, and stack frames with file paths cut to the package or URL path. Never the error message. Each distinct error is sent once per run, and a crash is sent on the next start."
+	},
+	{
+		name: "$ai_generation",
+		description: "Per agent session and model, after each usage scan, for usage recorded in the last 24 hours: token counts, the model name and estimated cost, under a one-way hash of the session. A model name outside the shipped pricing table is sent as unknown. No prompts or output."
+	}
+]);
+Object.freeze([
+	"app_version",
+	"os_platform",
+	"node_major",
+	"install_flavor",
+	"is_bundled",
+	"is_dev_install"
+]);
+Object.freeze(["$release_id"]);
+var TELEMETRY_KILL_SWITCH_FLAG = "telemetry-enabled";
+var FeatureFlagsResponse = z.object({
+	flags: z.object({ [TELEMETRY_KILL_SWITCH_FLAG]: z.object({ enabled: z.boolean() }).passthrough().optional() }).passthrough(),
+	errorsWhileComputingFlags: z.boolean().optional()
+}).passthrough();
+var PendingCrashReport = z.object({
+	timestamp: z.string(),
+	properties: ExceptionProperties
+}).strict();
+var TelemetryState = z.object({
+	installId: z.uuid(),
+	noticeShownAt: z.string().nullable().optional(),
+	remoteDisabled: z.boolean().optional()
+});
+var viewerCols = z.number().int().min(1).max(500);
+var viewerRows = z.number().int().min(1).max(200);
+var DataClientMessage = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("input"),
+		data: z.string()
+	}),
+	z.object({
+		type: z.literal("claim"),
+		cols: viewerCols,
+		rows: viewerRows
+	}),
+	z.object({ type: z.literal("unview") })
+]);
+z.object({
+	type: z.literal("pty-size"),
+	cols: viewerCols,
+	rows: viewerRows,
+	seq: z.number().int().nonnegative()
+});
+var DATA_ATTACH_HISTORY_PARAM = "history";
+var DEEP_HISTORY_SCROLLBACK_LINES = 5e3;
+var DataAttachHistory = z.enum(["screen", "deep"]);
+function decodeJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function parseDataClientMessage(raw) {
+	const parsed = DataClientMessage.safeParse(decodeJson(raw));
+	if (!parsed.success) return null;
+	return parsed.data;
+}
+function parseDataAttachHistory(rawUrl) {
+	if (typeof rawUrl !== "string") return "screen";
+	const queryAt = rawUrl.indexOf("?");
+	if (queryAt === -1) return "screen";
+	const query = new URLSearchParams(rawUrl.slice(queryAt + 1).split("#")[0]);
+	const parsed = DataAttachHistory.safeParse(query.get(DATA_ATTACH_HISTORY_PARAM));
+	if (!parsed.success) return "screen";
+	return parsed.data;
+}
+//#endregion
+//#region shared/contracts/hooks.ts
+var HTTP_URL_RE = /^https?:\/\/\S+$/i;
+var HookPayload = z.record(z.string(), z.unknown());
+var HookEnvelope = z.object({
+	glimmervoidId: z.string().min(1),
+	event: z.string().min(1),
+	token: z.string().nullable().optional(),
+	payload: HookPayload
+});
+z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	event: z.string().min(1),
+	matcher: z.string().optional(),
+	type: z.enum(["command", "http"]),
+	command: z.string().optional(),
+	url: z.string().optional(),
+	timeout: z.number().int().positive().optional(),
+	enabled: z.boolean(),
+	projects: z.array(z.string()).optional()
+}).passthrough();
+//#endregion
+export { UPDATE_CHANNELS as C, normalizeLegacyConfigNumbers as E, POST_TURN_CHECK_MODES as S, USAGE_VENDOR_KEYS as T, RUNTIME_CONFIG_SCALAR_KEYS as _, parseDataClientMessage as a, BranchGcFileSettings as b, TELEMETRY_EVENT_SCHEMAS as c, AGENT_ID_SHAPE_MESSAGE as d, BUILTIN_AGENT_IDS as f, PersistedTaskTitle as g, ConfigUpdate as h, parseDataAttachHistory as i, TELEMETRY_KILL_SWITCH_FLAG as l, Config as m, HookEnvelope as n, FeatureFlagsResponse as o, BrowserConfig as p, DEEP_HISTORY_SCROLLBACK_LINES as r, PendingCrashReport as s, HTTP_URL_RE as t, TelemetryState as u, TASK_TITLE_SOURCE_PRIORITY as v, USAGE_COST_MODES as w, CHANGE_MAP_NARRATOR_ENGINES as x, configIssueMessage as y };