glimmervoid 0.43.2 → 0.43.4

package/dist/chunks/{agent-setup-cli-NfJQxNdp.js → agent-setup-cli-DAPHGpRA.js}

@@ -1,5 +1,5 @@
 import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
-import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-DPmX1ozS.js";
+import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-2z-LqPHN.js";
 import { p as writeTextAtomicSync } from "./json-file-DFCTvPjj.js";
 import fs from "node:fs";
 import path from "node:path";

package/dist/chunks/{control-messages-CD99vE0V.js → config-D0YwCXFd.js}

@@ -1,4 +1,6 @@
-import { $ as MyPrMergeWhenReadyResult, At as TeamReviewStatus, B as LinkedPr, C as PendingWakeup, D as SESSION_DOC_PATH_MAX_CHARS, Et as TeamReviewActionResult, G as MyPrKeepMergeableRequest, Gt as GithubPollingRefreshRequest, It as hasRequiredActionHead, Jt as githubPollingShape, K as MyPrKeepMergeableResult, Kt as GithubPollingRefreshResult, M as SessionDoc, N as SessionSnapshot, P as SessionState, Q as MyPrMergeWhenReadyRequest, R as TaskTitle, Tt as TeamReviewActionRequest, Ut as REPO_SLUG_RE, V as MyPr, Vt as GH_SEGMENT, X as MyPrMergeResult, Y as MyPrMergeRequest, at as MyPrsStatus, b as ConversationApproval, ct as repositoryName, et as MyPrSearchNode, lt as CommitSha, ot as SessionPrLinks, pt as GithubReviewDecision, qt as GithubPrsFreshness, st as pullRequestKeyFormat, v as CoherenceHooksState, vt as ReviewChecksState, x as ConversationApprovalDecision, y as ConversationAnswers, z as UnseenOutcome } from "./session-BUcx9uJa.js";
+import { $ as MyPrMergeWhenReadyResult, At as TeamReviewStatus, B as LinkedPr, C as PendingWakeup, D as SESSION_DOC_PATH_MAX_CHARS, Et as TeamReviewActionResult, G as MyPrKeepMergeableRequest, Gt as GithubPollingRefreshRequest, It as hasRequiredActionHead, Jt as githubPollingShape, K as MyPrKeepMergeableResult, Kt as GithubPollingRefreshResult, M as SessionDoc, N as SessionSnapshot, P as SessionState, Q as MyPrMergeWhenReadyRequest, R as TaskTitle, Tt as TeamReviewActionRequest, Ut as REPO_SLUG_RE, V as MyPr, Vt as GH_SEGMENT, Wt as repoParts, X as MyPrMergeResult, Y as MyPrMergeRequest, at as MyPrsStatus, b as ConversationApproval, ct as repositoryName, et as MyPrSearchNode, lt as CommitSha, ot as SessionPrLinks, pt as GithubReviewDecision, qt as GithubPrsFreshness, st as pullRequestKeyFormat, v as CoherenceHooksState, vt as ReviewChecksState, x as ConversationApprovalDecision, y as ConversationAnswers, z as UnseenOutcome } from "./session-BUcx9uJa.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import path from "node:path";
 import { z } from "zod";
 //#region shared/contracts/issues.ts
 var IssueRepoSlug = z.string().regex(REPO_SLUG_RE);
@@ -1541,6 +1543,10 @@ var clientVariants = [
 	loose("ping", { requestId }),
 	loose("get-settings", { requestId }),
 	loose("get-agent-logins", { requestId }),
+	loose("start-remote-setup", {
+		agent: ConnectableAgent,
+		requestId
+	}),
 	loose("agent-connect", {
 		agent: ConnectableAgent,
 		action: z.enum(["start", "cancel"]),
@@ -1710,6 +1716,7 @@ Object.freeze([
 	"hooks-report",
 	"save-hook-result",
 	"add-session-result",
+	"start-remote-setup-result",
 	"remove-session-result",
 	"agent-logins",
 	"delete-hook-result",
@@ -1852,6 +1859,13 @@ var serverVariants = [
 		logins: AgentLoginStatuses,
 		error: optionalError
 	}),
+	loose("start-remote-setup-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		sessionId: z.string().optional(),
+		sessionName: z.string().optional()
+	}),
 	loose("delete-hook-result", {
 		requestId,
 		ok: z.boolean(),
@@ -2359,4 +2373,545 @@ var serverVariants = [
 ];
 z.discriminatedUnion("type", serverVariants);
 //#endregion
-export { TASK_TITLE_TIMEOUT_RANGE as $, BRANCH_GC_STALE_DAYS_RANGE as A, GithubIssueResponse as At, POSTHOG_ESCALATION_RANGE as B, comparablePrKey as C, PLAN_RESULT_HOOK_EVENT as Ct, WorkflowsSettingsUpdate as D, parseExitPlanModeHookPayload as Dt, WorkflowsSettings as E, PlanRevision as Et, KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE as F, IssuesStatus as Ft, POSTHOG_MIN_USERS_RANGE as G, POSTHOG_INTERVAL_RANGE as H, MEMORY_RESERVE_MB_RANGE as I, issuePullRequestStateFromGithub as It, POSTHOG_TRAFFIC_COOLDOWN_RANGE as J, POSTHOG_RECURRENCE_WINDOW_RANGE as K, NON_NEGATIVE_NUMBER_RANGE as L, FLYING_ANIMALS_DURATION_RANGE as M, IssueUpdate as Mt, FLYING_ANIMALS_GAP_RANGE as N, IssuesSearchResponse as Nt, WorkflowsState as O, planTitle as Ot, FLYING_ANIMALS_SCALE_RANGE as P, IssuesState as Pt, REPLAY_BUFFER_KB_RANGE as Q, PORT_RANGE as R, GithubPrsFrame as S, PLAN_HOOK_OUTPUT_MAX_CHARS as St, WorkflowLabelName as T, PlanDecision as Tt, POSTHOG_INVESTIGATION_TIMEOUT_RANGE as U, POSTHOG_FIX_TIMEOUT_RANGE as V, POSTHOG_MAX_CONCURRENT_RANGE as W, POSTHOG_TRAFFIC_MULTIPLIER_RANGE as X, POSTHOG_TRAFFIC_MIN_USERS_RANGE as Y, POSTHOG_TRANSIENT_RECURRENCE_RANGE as Z, MinedPrReviewData as _, CoherenceJournalOutput as _t, OPERATOR_ACTIONS_BY_SURFACE as a, VISIONS_COOLDOWN_MS_RANGE as at, GithubPrKey as b, PLAN_BODY_CAP_BYTES as bt, BenchmarkActionRequest as c, VISIONS_MAX_PER_HOUR_RANGE as ct, BenchmarkJudgement as d, WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE as dt, USAGE_BUDGET_RANGE as et, BenchmarkRun as f, UpdateJournal as ft, MergedPrListing as g, TraceRecord as gt, CommitComparison as h, TraceCheckpoint as ht, InstallFlavor as i, VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE as it, FLYING_ANIMALS_DEFAULTS as j, IssueKey as jt, BRANCH_GC_INTERVAL_MS_RANGE as k, GithubIssuePullRequestsRepository as kt, BenchmarkCase as l, VISIONS_QUIET_MS_RANGE as lt, BenchmarkSuite as m, MAX_RAW_LINE_CHARS as mt, ClientMessage as n, USAGE_RETAIN_DAYS_RANGE as nt, OPERATOR_SURFACES as o, VISIONS_DISPATCH_TIMEOUT_RANGE as ot, BenchmarkStatus as p, SessionSetup as pt, POSTHOG_TRAFFIC_BASELINE_RANGE as q, DASHBOARD_VIEWS as r, USAGE_SCAN_INTERVAL_RANGE as rt, pullRequestKeyFromReference as s, VISIONS_INTENT_THREAD_TTL_MS_RANGE as st, CONTROL_FRAME_MAX_BYTES as t, USAGE_INTEGER_RANGES as tt, BenchmarkId as u, WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE as ut, PrCheckoutCaseInput as v, ChangeMap as vt, WorkflowCommentBody as w, PLAN_TOOL_NAME as wt, GithubPrLightSearchNode as x, PLAN_HOOK_EVENT as xt, GithubPrDetailNode as y, changeMapFactId as yt, POSITIVE_NUMBER_RANGE as z };
+//#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 UPDATE_CHANNELS = Object.freeze(["release", "main"]);
+var POST_TURN_CHECK_MODES = Object.freeze(["report", "fix"]);
+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"),
+	viewTabOrder: z.array(z.string({ error: "viewTabOrder must be an array of view ids" }), { error: "viewTabOrder must be an array of view ids" }).optional(),
+	remoteSessions: optionalBoolean("remoteSessions"),
+	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(),
+	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 CODER_WORKSPACE_NAME_RE = /^gv-[0-9a-f]{12}$/;
+var CODER_ENVIRONMENT_NAME_RE = /^[a-z][a-z0-9-]{0,31}$/;
+var CODER_STOP_AFTER_RE = /^[1-9][0-9]*[hm]$/;
+var absolutePosixPath = (field) => z.string({ error: `${field} must be a string` }).refine((value) => path.posix.isAbsolute(value), { error: `${field} must be an absolute path` });
+var positiveInteger = (field) => z.number({ error: `${field} must be a number` }).int({ error: `${field} must be a whole number` }).positive({ error: `${field} must be positive` });
+var PARAMETERS_MESSAGE = "coder.environments[].parameters must map names to strings";
+var CoderEnvironment = z.object({
+	name: z.string({ error: "coder.environments[].name must be a string" }).regex(CODER_ENVIRONMENT_NAME_RE, { error: "coder.environments[].name must be 1 to 32 lowercase letters, digits and dashes, starting with a letter" }),
+	template: z.string({ error: "coder.environments[].template must be a string" }).min(1, { error: "coder.environments[].template must not be empty" }).refine((value) => !value.startsWith("-"), { error: "coder.environments[].template must not start with a dash" }),
+	parameters: z.record(z.string(), z.string({ error: PARAMETERS_MESSAGE }), { error: PARAMETERS_MESSAGE }).optional(),
+	nodePath: absolutePosixPath("coder.environments[].nodePath"),
+	checkoutRoot: absolutePosixPath("coder.environments[].checkoutRoot"),
+	readyUrl: z.url({
+		protocol: /^https?$/,
+		error: "coder.environments[].readyUrl must be an http or https URL"
+	}).optional(),
+	idleStopMinutes: positiveInteger("coder.environments[].idleStopMinutes").optional(),
+	stopAfter: z.string().regex(CODER_STOP_AFTER_RE, { error: "coder.environments[].stopAfter must be a duration like 4h or 90m" }).optional(),
+	maxLive: positiveInteger("coder.environments[].maxLive").optional(),
+	deleteAfterStoppedDays: positiveInteger("coder.environments[].deleteAfterStoppedDays").optional(),
+	hourlyCostUsd: z.number({ error: "coder.environments[].hourlyCostUsd must be a number" }).nonnegative({ error: "coder.environments[].hourlyCostUsd must not be negative" }).optional()
+}).strict();
+var CoderSettings = z.object({
+	appSlug: z.string().optional(),
+	environments: z.array(CoderEnvironment).optional().refine((environments) => {
+		const names = (environments ?? []).map((environment) => environment.name);
+		return new Set(names).size === names.length;
+	}, { error: "coder.environments[].name must be unique" })
+}).loose().optional();
+var PORT_MESSAGE = "projects[].environment.remotePort must be a port from 1 to 65535";
+var ProjectEnvironment = z.object({
+	name: z.string().regex(CODER_ENVIRONMENT_NAME_RE, { error: "projects[].environment.name must name a coder environment" }),
+	workspace: z.string().regex(CODER_WORKSPACE_NAME_RE, { error: "projects[].environment.workspace must be gv- and 12 hex digits" }),
+	remotePort: z.number({ error: PORT_MESSAGE }).int({ error: PORT_MESSAGE }).min(1, { error: PORT_MESSAGE }).max(65535, { error: PORT_MESSAGE }),
+	branch: z.string().refine(isGitBranchName, { error: "projects[].environment.branch must be a git branch name" })
+}).strict();
+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(),
+	environment: ProjectEnvironment.optional()
+}).passthrough();
+var FILE_CONFIG_SHAPE = {
+	...BROWSER_CONFIG_SHAPE,
+	branchGc: optionalLooseObject("branchGc"),
+	coder: CoderSettings,
+	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(", ")}`
+		});
+	}
+	const declaredEnvironmentNames = new Set((config.coder?.environments ?? []).map((environment) => environment.name));
+	for (const [index, project] of config.projects.entries()) {
+		const environmentName = project?.environment?.name;
+		if (environmentName === void 0 || declaredEnvironmentNames.has(environmentName)) continue;
+		ctx.addIssue({
+			code: "custom",
+			path: [
+				"projects",
+				index,
+				"environment",
+				"name"
+			],
+			message: `projects[${index}].environment "${environmentName}" must be declared under coder.environments`
+		});
+	}
+});
+var CONFIG_BLOCK_KEYS = Object.freeze([
+	"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
+export { POSTHOG_TRAFFIC_BASELINE_RANGE as $, CommitComparison as A, IssueUpdate as At, WorkflowLabelName as B, BenchmarkActionRequest as C, PlanDecision as Ct, BenchmarkRun as D, GithubIssuePullRequestsRepository as Dt, BenchmarkJudgement as E, planTitle as Et, GithubPrKey as F, FLYING_ANIMALS_GAP_RANGE as G, WorkflowsState as H, GithubPrLightSearchNode as I, MEMORY_RESERVE_MB_RANGE as J, FLYING_ANIMALS_SCALE_RANGE as K, GithubPrsFrame as L, MinedPrReviewData as M, IssuesState as Mt, PrCheckoutCaseInput as N, IssuesStatus as Nt, BenchmarkStatus as O, GithubIssueResponse as Ot, GithubPrDetailNode as P, issuePullRequestStateFromGithub as Pt, POSTHOG_FIX_TIMEOUT_RANGE as Q, comparablePrKey as R, pullRequestKeyFromReference as S, PLAN_TOOL_NAME as St, BenchmarkId as T, parseExitPlanModeHookPayload as Tt, FLYING_ANIMALS_DEFAULTS as U, WorkflowsSettings as V, FLYING_ANIMALS_DURATION_RANGE as W, PORT_RANGE as X, NON_NEGATIVE_NUMBER_RANGE as Y, POSITIVE_NUMBER_RANGE as Z, ClientMessage as _, changeMapFactId as _t, ConfigUpdate as a, USAGE_INTEGER_RANGES as at, OPERATOR_ACTIONS_BY_SURFACE as b, PLAN_HOOK_OUTPUT_MAX_CHARS as bt, TASK_TITLE_SOURCE_PRIORITY as c, WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE as ct, POST_TURN_CHECK_MODES as d, SessionSetup as dt, POSTHOG_TRAFFIC_MIN_USERS_RANGE as et, UPDATE_CHANNELS as f, MAX_RAW_LINE_CHARS as ft, CONTROL_FRAME_MAX_BYTES as g, ChangeMap as gt, normalizeLegacyConfigNumbers as h, CoherenceJournalOutput as ht, Config as i, USAGE_BUDGET_RANGE as it, MergedPrListing as j, IssuesSearchResponse as jt, BenchmarkSuite as k, IssueKey as kt, configIssueMessage as l, WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE as lt, USAGE_VENDOR_KEYS as m, TraceRecord as mt, BUILTIN_AGENT_IDS as n, REPLAY_BUFFER_KB_RANGE as nt, PersistedTaskTitle as o, USAGE_RETAIN_DAYS_RANGE as ot, USAGE_COST_MODES as p, TraceCheckpoint as pt, KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE as q, BrowserConfig as r, TASK_TITLE_TIMEOUT_RANGE as rt, RUNTIME_CONFIG_SCALAR_KEYS as s, USAGE_SCAN_INTERVAL_RANGE as st, AGENT_ID_SHAPE_MESSAGE as t, POSTHOG_TRAFFIC_MULTIPLIER_RANGE as tt, BranchGcFileSettings as u, UpdateJournal as ut, DASHBOARD_VIEWS as v, PLAN_BODY_CAP_BYTES as vt, BenchmarkCase as w, PlanRevision as wt, OPERATOR_SURFACES as x, PLAN_RESULT_HOOK_EVENT as xt, InstallFlavor as y, PLAN_HOOK_EVENT as yt, WorkflowCommentBody as z };