glimmervoid 0.38.2 → 0.39.0

package/dist/chunks/{contracts-HVCEJfxs.js → contracts-DYQW11de.js}

@@ -1,149 +1,800 @@
-import { $ as SessionPrLinks, A as SessionState, B as MyPrKeepMergeableResult, F as LinkedPr, Ft as REPO_SLUG_RE, G as MyPrMergeWhenReadyRequest, H as MyPrMergeRequest, K as MyPrMergeWhenReadyResult, Lt as GithubPollingRefreshRequest, O as SessionDoc, Ot as hasRequiredActionHead, P as TaskTitle, Q as MyPrsStatus, Rt as GithubPollingRefreshResult, St as TeamReviewStatus, T as SESSION_DOC_PATH_MAX_CHARS, U as MyPrMergeResult, _ as ConversationApproval, _t as TeamReviewActionRequest, g as ConversationAnswers, k as SessionSnapshot, tt as CommitSha, v as ConversationApprovalDecision, vt as TeamReviewActionResult, x as PendingWakeup, z as MyPrKeepMergeableRequest, zt as githubPollingShape } from "./session-BlT68ppa.js";
-import "./browser-config-BrBT8269.js";
-import { _ as isSingleFactoryPathSegment, a as FactoryControlRequest, d as FactoryQueueIntentRequest, f as FactoryQueueIntentResult, h as FactoryState, o as FactoryControlResult, p as FactoryReviewVerdict } from "./factory-D7ryES9n.js";
-import { n as BUILTIN_AGENT_IDS } from "./config-CjawSOBk.js";
+import { $ as CommitSha, B as MyPrMergeRequest, D as SessionSnapshot, E as SessionDoc, Et as hasRequiredActionHead, Ft as GithubPollingRefreshRequest, G as MyPrSearchNode, It as GithubPollingRefreshResult, L as MyPrKeepMergeableRequest, Lt as githubPollingShape, M as TaskTitle, N as LinkedPr, Nt as REPO_SLUG_RE, O as SessionState, Pt as repoParts, Q as repositoryName, R as MyPrKeepMergeableResult, U as MyPrMergeWhenReadyRequest, V as MyPrMergeResult, W as MyPrMergeWhenReadyResult, X as MyPrsStatus, Z as SessionPrLinks, _ as PendingWakeup, bt as TeamReviewStatus, f as CoherenceHooksState, gt as TeamReviewActionResult, h as ConversationApprovalDecision, ht as TeamReviewActionRequest, jt as GH_SEGMENT, m as ConversationApproval, p as ConversationAnswers, x as SESSION_DOC_PATH_MAX_CHARS } from "./session-D2EbiysG.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import path from "node:path";
 import { z } from "zod";
-//#region shared/contracts/factory-decision-log.ts
-var FACTORY_DECISION_OUTPUT_MAX_BYTES = 16384;
-var FactoryDecisionKind = z.enum([
-	"admission",
-	"closeout",
-	"merge",
-	"verification",
-	"exception",
-	"landing",
-	"trust"
+//#region shared/settings-ranges.ts
+var POSITIVE_NUMBER_RANGE = Object.freeze({
+	min: 0,
+	exclusiveMin: true,
+	label: "a positive number"
+});
+var NON_NEGATIVE_NUMBER_RANGE = Object.freeze({
+	min: 0,
+	label: "zero or more"
+});
+var FLYING_ANIMALS_GAP_RANGE = Object.freeze({
+	min: 0,
+	max: 300
+});
+var FLYING_ANIMALS_DURATION_RANGE = Object.freeze({
+	min: 1,
+	max: 60
+});
+var FLYING_ANIMALS_SCALE_RANGE = Object.freeze({
+	min: .5,
+	max: 2
+});
+var FLYING_ANIMALS_DEFAULTS = Object.freeze({
+	flyingAnimalsMinGapSeconds: 20,
+	flyingAnimalsMaxGapSeconds: 40,
+	flyingAnimalsMinDurationSeconds: 6.9,
+	flyingAnimalsMaxDurationSeconds: 11.5,
+	flyingAnimalsScale: 1,
+	flyingAnimalsOnPhone: true
+});
+var REPLAY_BUFFER_KB_RANGE = Object.freeze({
+	min: 64,
+	max: 16384
+});
+var MEMORY_RESERVE_MB_RANGE = Object.freeze({
+	min: 0,
+	max: 65536
+});
+var PORT_RANGE = Object.freeze({
+	min: 0,
+	max: 65535
+});
+var TASK_TITLE_TIMEOUT_RANGE = Object.freeze({
+	min: 0,
+	exclusiveMin: true,
+	max: 2147483647 / 1e3
+});
+var BRANCH_GC_STALE_DAYS_RANGE = POSITIVE_NUMBER_RANGE;
+var BRANCH_GC_INTERVAL_MS_RANGE = POSITIVE_NUMBER_RANGE;
+var VISIONS_QUIET_MS_RANGE = POSITIVE_NUMBER_RANGE;
+var VISIONS_COOLDOWN_MS_RANGE = POSITIVE_NUMBER_RANGE;
+var VISIONS_MAX_PER_HOUR_RANGE = POSITIVE_NUMBER_RANGE;
+var VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE = NON_NEGATIVE_NUMBER_RANGE;
+var VISIONS_DISPATCH_TIMEOUT_RANGE = POSITIVE_NUMBER_RANGE;
+var VISIONS_INTENT_THREAD_TTL_MS_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_INTERVAL_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_MAX_CONCURRENT_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_INVESTIGATION_TIMEOUT_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_MIN_USERS_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_ESCALATION_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_RECURRENCE_WINDOW_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_TRANSIENT_RECURRENCE_RANGE = POSITIVE_NUMBER_RANGE;
+var POSTHOG_FIX_TIMEOUT_RANGE = Object.freeze({
+	min: 60,
+	max: 21600,
+	label: "between 60 and 21600"
+});
+var POSTHOG_TRAFFIC_MULTIPLIER_RANGE = Object.freeze({
+	min: 1,
+	label: "at least 1"
+});
+var POSTHOG_TRAFFIC_MIN_USERS_RANGE = Object.freeze({
+	min: 1,
+	label: "at least 1"
+});
+var POSTHOG_TRAFFIC_COOLDOWN_RANGE = NON_NEGATIVE_NUMBER_RANGE;
+var POSTHOG_TRAFFIC_BASELINE_RANGE = Object.freeze({
+	min: 1,
+	max: 30,
+	label: "between 1 and 30"
+});
+var USAGE_SCAN_INTERVAL_RANGE = Object.freeze({
+	min: 1,
+	max: 1440
+});
+var USAGE_RETAIN_DAYS_RANGE = Object.freeze({
+	min: 1,
+	max: 3650
+});
+var USAGE_WAREHOUSE_RETAIN_DAYS_RANGE = Object.freeze({
+	min: 30,
+	max: 3650
+});
+var USAGE_SESSION_BLOCK_HOURS_RANGE = Object.freeze({
+	min: 1,
+	max: 24
+});
+var USAGE_BUDGET_RANGE = POSITIVE_NUMBER_RANGE;
+var USAGE_INTEGER_RANGES = Object.freeze({
+	scanIntervalMinutes: USAGE_SCAN_INTERVAL_RANGE,
+	retainDays: USAGE_RETAIN_DAYS_RANGE,
+	warehouseRetainDays: USAGE_WAREHOUSE_RETAIN_DAYS_RANGE,
+	sessionBlockHours: USAGE_SESSION_BLOCK_HOURS_RANGE
+});
+var CHANGE_MAP_NARRATOR_TIMEOUT_RANGE = Object.freeze({
+	min: 15,
+	max: 600
+});
+var KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE = Object.freeze({
+	min: 5,
+	max: 120
+});
+var WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE = Object.freeze({
+	min: 1,
+	max: 5
+});
+var WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE = Object.freeze({
+	min: 1,
+	max: 50
+});
+Object.freeze({
+	NON_NEGATIVE_NUMBER_RANGE,
+	FLYING_ANIMALS_GAP_RANGE,
+	FLYING_ANIMALS_DURATION_RANGE,
+	FLYING_ANIMALS_SCALE_RANGE,
+	CHANGE_MAP_NARRATOR_TIMEOUT_RANGE,
+	KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE,
+	PORT_RANGE,
+	POSTHOG_ESCALATION_RANGE,
+	POSTHOG_FIX_TIMEOUT_RANGE,
+	POSTHOG_INTERVAL_RANGE,
+	POSTHOG_INVESTIGATION_TIMEOUT_RANGE,
+	POSTHOG_MAX_CONCURRENT_RANGE,
+	POSTHOG_MIN_USERS_RANGE,
+	POSTHOG_TRAFFIC_BASELINE_RANGE,
+	POSTHOG_TRAFFIC_COOLDOWN_RANGE,
+	POSTHOG_TRAFFIC_MIN_USERS_RANGE,
+	POSTHOG_TRAFFIC_MULTIPLIER_RANGE,
+	REPLAY_BUFFER_KB_RANGE,
+	MEMORY_RESERVE_MB_RANGE,
+	TASK_TITLE_TIMEOUT_RANGE,
+	USAGE_BUDGET_RANGE,
+	USAGE_RETAIN_DAYS_RANGE,
+	USAGE_SCAN_INTERVAL_RANGE,
+	VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE,
+	VISIONS_COOLDOWN_MS_RANGE,
+	VISIONS_DISPATCH_TIMEOUT_RANGE,
+	VISIONS_INTENT_THREAD_TTL_MS_RANGE,
+	VISIONS_MAX_PER_HOUR_RANGE,
+	VISIONS_QUIET_MS_RANGE,
+	WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE,
+	WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE
+});
+//#endregion
+//#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 FactoryDecisionOutcome = z.enum([
-	"refused",
-	"available",
-	"dispatched",
-	"ended",
-	"retry",
-	"block",
-	"merge",
-	"merged",
-	"failed",
-	"stale",
-	"passed",
-	"raised",
-	"stalled",
-	"recovered",
-	"granted"
+var USAGE_VENDOR_KEYS = Object.freeze(["codex", "grok"]);
+var USAGE_BUDGET_KEYS = Object.freeze(["dailyUsd", "monthlyUsd"]);
+//#endregion
+//#region shared/contracts/workflows.ts
+var WORKFLOW_TRIGGERS = Object.freeze([
+	"opened",
+	"checks-failed",
+	"review-requested",
+	"approved",
+	"commented",
+	"merged"
 ]);
-var FactoryDecisionFailureClass = z.enum([
-	"admission",
-	"worker",
-	"fence",
-	"check",
-	"review",
-	"closeout",
-	"verification",
-	"stale",
-	"exception",
-	"stall",
-	"landing"
+var WORKFLOW_ACTION_TYPES = Object.freeze([
+	"notify",
+	"spawn",
+	"label",
+	"comment"
 ]);
-var decisionCheck = z.strictObject({
-	command: z.string(),
-	pass: z.boolean(),
-	output: z.string()
-});
-var decisionFence = z.discriminatedUnion("ok", [z.strictObject({ ok: z.literal(true) }), z.strictObject({
-	ok: z.literal(false),
-	outside: z.array(z.string()),
-	protected: z.array(z.string()),
-	unsupportedProtectedPaths: z.array(z.string())
-})]);
-var decisionFields = {
-	timestamp: z.iso.datetime(),
-	projectId: z.string().min(1).max(128).refine(isSingleFactoryPathSegment),
-	outcome: FactoryDecisionOutcome,
-	workId: z.string().min(1).nullable(),
-	intentId: z.string().min(1).nullable(),
-	sessionId: z.string().min(1).nullable(),
-	attempt: z.number().int().positive().nullable(),
-	durationMs: z.number().int().nonnegative().nullable(),
-	failureClass: FactoryDecisionFailureClass.nullable(),
-	reason: z.string().max(3999).nullable()
+var WORKFLOW_PROMPT_TEMPLATE_MAX_CHARACTERS = 2e4;
+var WORKFLOW_COMMENT_BODY_MAX_CHARACTERS = 65536;
+var WORKFLOW_LABEL_NAME_MAX_CHARACTERS = 50;
+var RULE_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var UNSAFE_LABEL_NAME = /[\x00-\x1f\x7f,]|^-/;
+var integerInRange = (field, range) => {
+	const message = `${field} must be an integer between ${range.min} and ${range.max}`;
+	return z.number({ error: message }).int({ error: message }).min(range.min, { error: message }).max(range.max, { error: message });
 };
-var FactoryDecisionLogLine = z.discriminatedUnion("kind", [
-	z.strictObject({
-		...decisionFields,
-		kind: z.literal("admission"),
-		outcome: z.enum([
-			"refused",
-			"available",
-			"dispatched",
-			"ended",
-			"block"
-		])
-	}),
-	z.strictObject({
-		...decisionFields,
-		kind: z.literal("closeout"),
-		outcome: z.enum([
-			"retry",
-			"block",
-			"merge"
-		]),
-		attempt: z.number().int().positive(),
-		durationMs: z.number().int().nonnegative(),
-		fence: decisionFence.nullable(),
-		checks: z.array(decisionCheck).refine((checks) => checks.reduce((totalBytes, check) => totalBytes + new TextEncoder().encode(check.output).length, 0) <= FACTORY_DECISION_OUTPUT_MAX_BYTES),
-		review: FactoryReviewVerdict.nullable()
-	}),
+var workflowsEnabled = z.boolean({ error: "workflows.enabled must be a boolean" });
+var workflowsMaxConcurrentSessions = integerInRange("workflows.maxConcurrentSessions", WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE);
+var workflowsMaxActionsPerPoll = integerInRange("workflows.maxActionsPerPoll", WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE);
+var nonEmptyList = (field, item) => z.array(item, { error: `${field} must be an array` }).min(1, { error: `${field} must list at least one entry when present` });
+var WorkflowLabelName = z.string({ error: "a workflow label name must be a string" }).trim().min(1, { error: "a workflow label name must not be empty" }).max(WORKFLOW_LABEL_NAME_MAX_CHARACTERS, { error: `a workflow label name must be at most ${WORKFLOW_LABEL_NAME_MAX_CHARACTERS} characters` }).refine((name) => !UNSAFE_LABEL_NAME.test(name), { error: "a workflow label name must not start with a dash or hold a comma or control character" });
+var WorkflowCommentBody = z.string({ error: "a workflow comment body must be a string" }).min(1, { error: "a workflow comment body must not be empty" }).max(WORKFLOW_COMMENT_BODY_MAX_CHARACTERS, { error: `a workflow comment body must be at most ${WORKFLOW_COMMENT_BODY_MAX_CHARACTERS} characters` }).refine((body) => body.trim().length > 0, { error: "a workflow comment body must not be blank" });
+var WorkflowTrigger = z.enum(WORKFLOW_TRIGGERS, { error: `workflows.rules[].trigger must be one of ${WORKFLOW_TRIGGERS.join(", ")}` });
+var WorkflowAction = z.discriminatedUnion("type", [
+	z.strictObject({ type: z.literal("notify") }),
 	z.strictObject({
-		...decisionFields,
-		kind: z.literal("merge"),
-		outcome: z.literal("merged"),
-		mergedSha: z.string().regex(/^[a-f0-9]{40,64}$/)
+		type: z.literal("spawn"),
+		promptTemplate: z.string({ error: "a spawn action needs a promptTemplate string" }).min(1, { error: "a spawn action promptTemplate must not be empty" }).max(WORKFLOW_PROMPT_TEMPLATE_MAX_CHARACTERS, { error: `a spawn action promptTemplate must be at most ${WORKFLOW_PROMPT_TEMPLATE_MAX_CHARACTERS} characters` }).refine((template) => template.trim().length > 0, { error: "a spawn action promptTemplate must not be blank" })
 	}),
 	z.strictObject({
-		...decisionFields,
-		kind: z.literal("verification"),
-		outcome: z.enum([
-			"failed",
-			"stale",
-			"passed"
-		])
+		type: z.literal("label"),
+		name: WorkflowLabelName
 	}),
 	z.strictObject({
-		...decisionFields,
-		kind: z.literal("exception"),
-		outcome: z.enum(["raised", "stalled"])
-	}),
-	z.strictObject({
-		...decisionFields,
-		kind: z.literal("landing"),
-		outcome: z.enum(["failed", "recovered"])
-	}),
-	z.strictObject({
-		...decisionFields,
-		kind: z.literal("trust"),
-		outcome: z.literal("granted")
+		type: z.literal("comment"),
+		body: WorkflowCommentBody
 	})
-]).superRefine((line, context) => {
-	const isFailure = [
-		"refused",
-		"retry",
-		"block",
-		"failed",
-		"stale",
-		"raised",
-		"stalled"
-	].includes(line.outcome);
-	if (isFailure && line.failureClass === null) context.addIssue({
-		code: "custom",
-		path: ["failureClass"],
-		message: "Failure requires a failure class"
-	});
-	if (!isFailure && line.outcome !== "ended" && line.failureClass !== null) context.addIssue({
-		code: "custom",
-		path: ["failureClass"],
-		message: "Success requires a null failure class"
-	});
+], { error: `workflows.rules[].actions[].type must be one of ${WORKFLOW_ACTION_TYPES.join(", ")}` });
+var WorkflowFilters = z.strictObject({
+	mine: z.boolean({ error: "workflows.rules[].filters.mine must be a boolean" }).optional(),
+	teamReviewRequested: z.boolean({ error: "workflows.rules[].filters.teamReviewRequested must be a boolean" }).optional(),
+	authors: nonEmptyList("workflows.rules[].filters.authors", z.string({ error: "workflows.rules[].filters.authors must hold GitHub logins" }).regex(GH_SEGMENT, { error: "workflows.rules[].filters.authors must hold GitHub logins" })).optional(),
+	labels: nonEmptyList("workflows.rules[].filters.labels", WorkflowLabelName).optional(),
+	baseBranches: nonEmptyList("workflows.rules[].filters.baseBranches", z.string({ error: "workflows.rules[].filters.baseBranches must hold branch names" }).min(1, { error: "workflows.rules[].filters.baseBranches must hold branch names" })).optional()
+}, { error: "workflows.rules[].filters must be an object" });
+var WorkflowRuleId = z.string({ error: "workflows.rules[].id must be a string" }).regex(RULE_ID, { error: "workflows.rules[].id must be 1 to 64 lowercase letters, digits and dashes, starting with a letter or digit" });
+var WorkflowRuleEnabled = z.boolean({ error: "workflows.rules[].enabled must be a boolean" });
+var WorkflowRule = z.strictObject({
+	id: WorkflowRuleId,
+	name: z.string({ error: "workflows.rules[].name must be a string" }).trim().min(1, { error: "workflows.rules[].name must not be empty" }).max(80, { error: "workflows.rules[].name must be at most 80 characters" }),
+	enabled: WorkflowRuleEnabled.default(false),
+	repos: nonEmptyList("workflows.rules[].repos", repositoryName),
+	filters: WorkflowFilters.default({}),
+	trigger: WorkflowTrigger,
+	actions: nonEmptyList("workflows.rules[].actions", WorkflowAction)
+}, { error: "workflows.rules[] must be an object" });
+var WorkflowsSettings = z.strictObject({
+	enabled: workflowsEnabled.default(true),
+	maxConcurrentSessions: workflowsMaxConcurrentSessions.default(2),
+	maxActionsPerPoll: workflowsMaxActionsPerPoll.default(20),
+	rules: z.array(WorkflowRule, { error: "workflows.rules must be an array" }).default([])
+}, { error: "workflows must be an object" }).superRefine((settings, ctx) => {
+	const claimedIds = /* @__PURE__ */ new Set();
+	for (const [index, rule] of settings.rules.entries()) {
+		if (!claimedIds.has(rule.id)) {
+			claimedIds.add(rule.id);
+			continue;
+		}
+		ctx.addIssue({
+			code: "custom",
+			path: [
+				"rules",
+				index,
+				"id"
+			],
+			message: `workflows.rules[${index}].id "${rule.id}" is declared more than once`
+		});
+	}
+});
+var WorkflowRuleToggle = z.strictObject({
+	id: WorkflowRuleId,
+	enabled: WorkflowRuleEnabled
+}, { error: "a dashboard update of workflows.rules[] carries only id and enabled" });
+var WorkflowsSettingsUpdate = z.strictObject({
+	enabled: workflowsEnabled.optional(),
+	maxConcurrentSessions: workflowsMaxConcurrentSessions.optional(),
+	maxActionsPerPoll: workflowsMaxActionsPerPoll.optional(),
+	rules: z.array(WorkflowRuleToggle, { error: "workflows.rules must be an array" }).optional()
+}, { error: "a dashboard update of workflows carries only enabled, maxConcurrentSessions, maxActionsPerPoll and rule toggles" });
+var nonnegativeInteger = z.number().int().nonnegative();
+var checksState = z.enum([
+	"SUCCESS",
+	"FAILURE",
+	"PENDING",
+	"ERROR",
+	"EXPECTED"
+]).nullable();
+var WorkflowSearchNode = MyPrSearchNode.extend({
+	author: z.object({ login: z.string() }).nullable(),
+	labels: z.object({ nodes: z.array(z.object({ name: z.string() })) }),
+	comments: z.object({ totalCount: nonnegativeInteger })
 });
+var WorkflowPr = z.strictObject({
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.url(),
+	author: z.string().nullable(),
+	state: z.enum([
+		"OPEN",
+		"MERGED",
+		"CLOSED"
+	]),
+	createdAt: z.string(),
+	mergedAt: z.string().nullable(),
+	isDraft: z.boolean(),
+	isCrossRepository: z.boolean(),
+	baseRefName: z.string(),
+	headRefName: z.string().min(1),
+	headRefOid: CommitSha,
+	labels: z.array(z.string()),
+	commentCount: nonnegativeInteger,
+	reviewRequests: z.array(z.string()),
+	checksState,
+	reviewDecision: z.enum([
+		"APPROVED",
+		"CHANGES_REQUESTED",
+		"REVIEW_REQUIRED"
+	]).nullable()
+});
+var WorkflowRepoSnapshot = z.strictObject({
+	polledAtMs: nonnegativeInteger,
+	prs: z.array(WorkflowPr)
+});
+var WorkflowsState = z.strictObject({ repos: z.record(z.string().regex(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/), WorkflowRepoSnapshot) });
+//#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"),
+	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"]);
@@ -198,21 +849,13 @@ var AiGenerationProperties = z.object({
 	$ai_total_cost_usd: z.number().finite().nonnegative().optional(),
 	agent_adapter: z.enum(TELEMETRY_ADAPTERS)
 }).strict();
-var FactoryDecisionProperties = z.object({
-	kind: FactoryDecisionKind,
-	outcome: FactoryDecisionOutcome,
-	failure_class: FactoryDecisionFailureClass.nullable(),
-	duration_ms: nonNegativeInteger.nullable(),
-	attempt: nonNegativeInteger.nullable()
-}).strict();
 var TELEMETRY_EVENT_SCHEMAS = Object.freeze({
 	app_started: AppStartedProperties,
 	app_active: AppActiveProperties,
 	session_started: SessionStartedProperties,
 	session_ended: SessionEndedProperties,
 	$exception: ExceptionProperties,
-	$ai_generation: AiGenerationProperties,
-	factory_decision: FactoryDecisionProperties
+	$ai_generation: AiGenerationProperties
 });
 Object.freeze([
 	{
@@ -238,10 +881,6 @@ Object.freeze([
 	{
 		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."
-	},
-	{
-		name: "factory_decision",
-		description: "Each time the factory decides something (a dispatch, a close-out attempt, a merge, a watch or verification result, an exception, a landing, a Claude Code folder trust grant): which kind of decision, how it came out, the class of failure when it failed, how long it took and which attempt it was. Never the objective, the reason, check output, a path or a repository name."
 	}
 ]);
 Object.freeze([
@@ -646,6 +1285,148 @@ var ChangeMap = z.strictObject({
 	narratorState: NarratorState,
 	error: z.string().min(1).optional()
 });
+var CoherenceJournalKind = z.enum([
+	"decision",
+	"retraction",
+	"conjecture",
+	"resolution",
+	"dismissal",
+	"defect",
+	"experiment",
+	"close",
+	"unable",
+	"escalation",
+	"acknowledgement",
+	"enactment"
+]);
+var recordHead = {
+	id: z.string().min(1),
+	at: z.iso.datetime(),
+	session: z.string(),
+	agent: z.string(),
+	commit: z.string().nullable(),
+	dirty: z.boolean(),
+	binding: z.string()
+};
+var reference = {
+	of: z.string().min(1),
+	because: z.string()
+};
+var step = z.looseObject({
+	id: z.string(),
+	text: z.string()
+});
+var KnownJournalRecord = z.discriminatedUnion("kind", [
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("decision"),
+		chose: z.string(),
+		over: z.array(z.string()),
+		because: z.string()
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("retraction"),
+		...reference
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("conjecture"),
+		observation: z.string(),
+		couldBe: z.array(z.string()),
+		discriminatedBy: z.string()
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("resolution"),
+		...reference,
+		as: z.string().optional()
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("dismissal"),
+		...reference
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("defect"),
+		what: z.string(),
+		evidence: z.string(),
+		files: z.array(z.string())
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("experiment"),
+		expectation: z.string(),
+		context: z.array(z.string()),
+		actions: z.array(step),
+		criteria: z.array(step)
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("close"),
+		of: z.string(),
+		outcome: z.enum([
+			"success",
+			"failure",
+			"inconclusive"
+		]),
+		results: z.record(z.string(), z.unknown())
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("unable"),
+		what: z.string(),
+		because: z.string()
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("escalation"),
+		what: z.string(),
+		because: z.string()
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("acknowledgement"),
+		...reference
+	}),
+	z.looseObject({
+		...recordHead,
+		kind: z.literal("enactment"),
+		practice: z.string(),
+		results: z.record(z.string(), z.unknown())
+	})
+]);
+var CoherenceJournalRecord = z.union([KnownJournalRecord, z.object({
+	id: z.string().min(1),
+	kind: z.string().min(1).refine((kind) => !CoherenceJournalKind.safeParse(kind).success)
+})]);
+var CoherenceJournalOutput = z.looseObject({
+	branch: z.string().nullable(),
+	escalations: z.array(z.unknown()),
+	records: z.array(CoherenceJournalRecord),
+	citedBy: z.record(z.string(), z.array(z.unknown())),
+	damaged: z.array(z.unknown())
+});
+var CoherenceJournalEntry = z.strictObject({
+	id: z.string().min(1),
+	at: z.iso.datetime().nullable(),
+	kind: z.string().min(1),
+	text: z.string().max(280),
+	detail: z.string().max(280).nullable(),
+	supersedes: z.string().nullable()
+});
+var CoherenceJournalReading = z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	latest: CoherenceJournalEntry.nullable()
+}), z.strictObject({
+	ok: z.literal(false),
+	reason: z.string().min(1).max(200)
+})]);
+var SessionCoherence = z.strictObject({
+	journal: CoherenceJournalReading,
+	updatedAt: z.number().finite()
+});
 //#endregion
 //#region shared/contracts/issues.ts
 var IssueRepoSlug = z.string().regex(REPO_SLUG_RE);
@@ -974,6 +1755,26 @@ var TraceCheckpoint = z.object({
 	subagentOffsetByPath: z.record(z.string().min(1), z.number().int().nonnegative()).default({})
 });
 //#endregion
+//#region shared/contracts/session-setup.ts
+var setupName = z.string().max(16384);
+var setupNames = z.array(setupName).max(4096);
+var SessionSetup = z.object({
+	model: setupName.nullable(),
+	mcpServers: setupNames,
+	plugins: z.array(z.object({
+		name: setupName,
+		skills: setupNames,
+		agents: setupNames
+	})).max(4096),
+	skills: setupNames,
+	agents: setupNames,
+	hookEvents: z.array(z.object({
+		event: setupName,
+		runCount: z.number().int().nonnegative()
+	})).max(4096),
+	hookCommands: z.array(z.string().max(65536)).max(4096)
+});
+//#endregion
 //#region shared/contracts/update-journal.ts
 var UpdateChannel = z.enum(["release", "main"]);
 var UpdateRunState = z.enum([
@@ -1059,6 +1860,13 @@ z.object({
 	args: z.array(z.string()),
 	resolvable: z.boolean().nullable()
 }).strict();
+var TelegramDeliveryStatus = z.object({
+	setupWarning: nullableString,
+	lastFailure: z.object({
+		message: z.string(),
+		failedAt: timestamp
+	}).nullable()
+});
 var SessionCardFields = z.object({
 	id: sessionId,
 	session: z.string(),
@@ -1073,6 +1881,7 @@ var SessionCardFields = z.object({
 	worktree: z.boolean(),
 	workspace: z.boolean().optional(),
 	guarded: z.boolean().optional(),
+	guardrailsReleased: z.boolean().optional(),
 	resumeSessionId: nullableString,
 	ephemeral: z.boolean().optional(),
 	linkedPrs: z.array(LinkedPr).optional()
@@ -1153,7 +1962,9 @@ var clientVariants = [
 		repos: z.array(z.string()).optional(),
 		agent: z.string().optional(),
 		dangerouslySkipPermissions: z.boolean().optional(),
-		unguarded: z.boolean().optional()
+		unguarded: z.boolean().optional(),
+		runInPlace: z.boolean().optional(),
+		requestId
 	}),
 	loose("list-conversations", {
 		id: sessionId,
@@ -1239,14 +2050,6 @@ var clientVariants = [
 		message: "only discard may omit head",
 		path: ["head"]
 	}),
-	loose("factory-queue-intent", {
-		...FactoryQueueIntentRequest.shape,
-		requestId
-	}),
-	loose("factory-control", {
-		...FactoryControlRequest.shape,
-		requestId
-	}),
 	loose("benchmark-action", {
 		...BenchmarkActionRequest.shape,
 		requestId
@@ -1271,6 +2074,7 @@ var clientVariants = [
 		id: z.unknown().optional(),
 		requestId
 	}),
+	loose("telegram-test", { requestId }),
 	loose("request-usage-report", {
 		requestId,
 		days: z.unknown().optional(),
@@ -1313,6 +2117,10 @@ var clientVariants = [
 		id: sessionId,
 		isOn: z.boolean()
 	}),
+	loose("set-session-guardrails", {
+		id: sessionId,
+		isOn: z.boolean()
+	}),
 	loose("conversation-approval", {
 		id: sessionId,
 		requestId: ConversationApproval.shape.requestId,
@@ -1331,6 +2139,14 @@ var clientVariants = [
 		baseHash: z.string().min(1),
 		requestId
 	}),
+	loose("session-coherence-journal", {
+		id: sessionId,
+		requestId
+	}),
+	loose("session-setup", {
+		id: sessionId,
+		requestId
+	}),
 	loose("client-error", ClientErrorReport.shape),
 	loose("dismiss", {
 		id: sessionId,
@@ -1344,6 +2160,7 @@ Object.freeze([
 	"snapshot",
 	"hooks-report",
 	"save-hook-result",
+	"add-session-result",
 	"delete-hook-result",
 	"workspace-repos",
 	"set-workspace-repos-result",
@@ -1356,6 +2173,7 @@ Object.freeze([
 	"session-prs",
 	"session-modified",
 	"session-git",
+	"session-coherence-hooks",
 	"session-agents",
 	"session-wakeup",
 	"session-prompt",
@@ -1381,6 +2199,10 @@ Object.freeze([
 	"session-docs-snapshot",
 	"session-doc-response",
 	"session-doc-save-result",
+	"session-coherence",
+	"session-coherence-snapshot",
+	"session-coherence-journal-response",
+	"session-setup-response",
 	"notify",
 	"update-status",
 	"update-progress",
@@ -1407,8 +2229,6 @@ Object.freeze([
 	"radar-issue-action-result",
 	"team-review-action-result",
 	"benchmark-action-result",
-	"factory-queue-intent-result",
-	"factory-control-result",
 	"my-pr-merge-result",
 	"my-pr-keep-mergeable-result",
 	"my-pr-merge-when-ready-result",
@@ -1416,7 +2236,6 @@ Object.freeze([
 	"radar-archive-investigation-result",
 	"team-review-status",
 	"benchmark-status",
-	"factory-state",
 	"my-prs-status",
 	"issues-status",
 	"usage-sessions",
@@ -1465,6 +2284,12 @@ var serverVariants = [
 		error: optionalError,
 		hook: opaqueObject.optional()
 	}),
+	loose("add-session-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		reason: z.enum(["not-git"]).optional()
+	}),
 	loose("delete-hook-result", {
 		requestId,
 		ok: z.boolean(),
@@ -1493,7 +2318,8 @@ var serverVariants = [
 		event: z.string(),
 		timestamp,
 		skipPerms: z.boolean().optional(),
-		saneYolo: z.boolean().optional()
+		saneYolo: z.boolean().optional(),
+		failureReason: z.string().optional()
 	}),
 	loose("session-added", SessionCardFields.shape),
 	loose("session-modified", SessionCardFields.shape),
@@ -1519,6 +2345,10 @@ var serverVariants = [
 		id: sessionId,
 		worktree: z.boolean()
 	}),
+	loose("session-coherence-hooks", {
+		id: sessionId,
+		coherenceHooks: CoherenceHooksState.nullable()
+	}),
 	loose("session-agents", {
 		id: sessionId,
 		activeAgents: z.number().int().nonnegative(),
@@ -1660,6 +2490,25 @@ var serverVariants = [
 		conflict: z.boolean().optional(),
 		error: optionalError
 	}),
+	loose("session-coherence", {
+		id: sessionId,
+		...SessionCoherence.shape
+	}),
+	loose("session-coherence-snapshot", { sessions: z.record(z.string(), SessionCoherence) }),
+	loose("session-coherence-journal-response", {
+		requestId,
+		id: sessionId,
+		ok: z.boolean(),
+		entries: z.array(CoherenceJournalEntry).max(200),
+		error: optionalError
+	}),
+	loose("session-setup-response", {
+		requestId,
+		id: sessionId,
+		ok: z.boolean(),
+		setup: SessionSetup.optional(),
+		error: optionalError
+	}),
 	loose("notify", {
 		session: z.string(),
 		category: z.string(),
@@ -1712,7 +2561,8 @@ var serverVariants = [
 			root: z.string(),
 			projects: z.array(openObject({
 				name: z.string(),
-				path: z.string()
+				path: z.string(),
+				isGit: z.boolean().optional()
 			}))
 		})),
 		suggestions: z.array(openObject({
@@ -1819,14 +2669,6 @@ var serverVariants = [
 		...TeamReviewActionResult.shape,
 		requestId
 	}),
-	loose("factory-queue-intent-result", {
-		...FactoryQueueIntentResult.shape,
-		requestId
-	}),
-	loose("factory-control-result", {
-		...FactoryControlResult.shape,
-		requestId
-	}),
 	loose("benchmark-action-result", {
 		...BenchmarkActionResult.shape,
 		requestId
@@ -1852,9 +2694,14 @@ var serverVariants = [
 		ok: z.boolean(),
 		error: optionalError
 	}),
+	loose("telegram-test-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		telegramDelivery: TelegramDeliveryStatus.nullable()
+	}),
 	TeamReviewStatus,
 	BenchmarkStatus,
-	loose("factory-state", FactoryState.shape),
 	MyPrsStatus,
 	IssuesStatus,
 	loose("usage-sessions", {
@@ -2015,4 +2862,4 @@ z.object({
 	projects: z.array(z.string()).optional()
 }).passthrough();
 //#endregion
-export { ChangeMap as A, MergedPrListing as B, GithubIssuePullRequestsRepository as C, IssuesSearchResponse as D, IssueUpdate as E, BenchmarkJudgement as F, TELEMETRY_EVENT_SCHEMAS as G, PrCheckoutCaseInput as H, BenchmarkRun as I, FACTORY_DECISION_OUTPUT_MAX_BYTES as J, TELEMETRY_KILL_SWITCH_FLAG as K, BenchmarkStatus as L, BenchmarkActionRequest as M, BenchmarkCase as N, IssuesState as O, BenchmarkId as P, BenchmarkSuite as R, planTitle as S, IssueKey as T, FeatureFlagsResponse as U, MinedPrReviewData as V, PendingCrashReport as W, FactoryDecisionLogLine as Y, PLAN_RESULT_HOOK_EVENT as _, parseDataClientMessage as a, PlanRevision as b, DIFF_ANNOTATION_NOTE_MAX_CHARS as c, MAX_RAW_LINE_CHARS as d, TraceCheckpoint as f, PLAN_HOOK_OUTPUT_MAX_CHARS as g, PLAN_HOOK_EVENT as h, parseDataAttachHistory as i, changeMapFactId as j, IssuesStatus as k, InstallFlavor as l, PLAN_BODY_CAP_BYTES as m, HookEnvelope as n, CONTROL_FRAME_MAX_BYTES as o, TraceRecord as p, TelemetryState as q, DEEP_HISTORY_SCROLLBACK_LINES as r, ClientMessage as s, HTTP_URL_RE as t, UpdateJournal as u, PLAN_TOOL_NAME as v, GithubIssueResponse as w, parseExitPlanModeHookPayload as x, PlanDecision as y, CommitComparison as z };
+export { Config as $, IssuesStatus as A, POSTHOG_TRAFFIC_MULTIPLIER_RANGE as At, BenchmarkSuite as B, planTitle as C, MEMORY_RESERVE_MB_RANGE as Ct, IssueUpdate as D, POSTHOG_FIX_TIMEOUT_RANGE as Dt, IssueKey as E, POSITIVE_NUMBER_RANGE as Et, BenchmarkCase as F, USAGE_RETAIN_DAYS_RANGE as Ft, FeatureFlagsResponse as G, MergedPrListing as H, BenchmarkId as I, USAGE_SCAN_INTERVAL_RANGE as It, TELEMETRY_KILL_SWITCH_FLAG as J, PendingCrashReport as K, BenchmarkJudgement as L, WORKFLOWS_MAX_ACTIONS_PER_POLL_RANGE as Lt, ChangeMap as M, TASK_TITLE_TIMEOUT_RANGE as Mt, changeMapFactId as N, USAGE_BUDGET_RANGE as Nt, IssuesSearchResponse as O, POSTHOG_TRAFFIC_BASELINE_RANGE as Ot, BenchmarkActionRequest as P, USAGE_INTEGER_RANGES as Pt, BrowserConfig as Q, BenchmarkRun as R, WORKFLOWS_MAX_CONCURRENT_SESSIONS_RANGE as Rt, parseExitPlanModeHookPayload as S, KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE as St, GithubIssueResponse as T, PORT_RANGE as Tt, MinedPrReviewData as U, CommitComparison as V, PrCheckoutCaseInput as W, AGENT_ID_SHAPE_MESSAGE as X, TelemetryState as Y, BUILTIN_AGENT_IDS as Z, PLAN_HOOK_OUTPUT_MAX_CHARS as _, CHANGE_MAP_NARRATOR_TIMEOUT_RANGE as _t, parseDataClientMessage as a, BranchGcFileSettings as at, PlanDecision as b, FLYING_ANIMALS_GAP_RANGE as bt, DIFF_ANNOTATION_NOTE_MAX_CHARS as c, UPDATE_CHANNELS as ct, SessionSetup as d, WorkflowSearchNode as dt, ConfigUpdate as et, MAX_RAW_LINE_CHARS as f, WorkflowsSettings as ft, PLAN_HOOK_EVENT as g, normalizeLegacyConfigNumbers as gt, PLAN_BODY_CAP_BYTES as h, USAGE_VENDOR_KEYS as ht, parseDataAttachHistory as i, configIssueMessage as it, CoherenceJournalOutput as j, REPLAY_BUFFER_KB_RANGE as jt, IssuesState as k, POSTHOG_TRAFFIC_MIN_USERS_RANGE as kt, InstallFlavor as l, WorkflowCommentBody as lt, TraceRecord as m, USAGE_COST_MODES as mt, HookEnvelope as n, RUNTIME_CONFIG_SCALAR_KEYS as nt, CONTROL_FRAME_MAX_BYTES as o, CHANGE_MAP_NARRATOR_ENGINES as ot, TraceCheckpoint as p, WorkflowsState as pt, TELEMETRY_EVENT_SCHEMAS as q, DEEP_HISTORY_SCROLLBACK_LINES as r, TASK_TITLE_SOURCE_PRIORITY as rt, ClientMessage as s, POST_TURN_CHECK_MODES as st, HTTP_URL_RE as t, PersistedTaskTitle as tt, UpdateJournal as u, WorkflowLabelName as ut, PLAN_RESULT_HOOK_EVENT as v, FLYING_ANIMALS_DEFAULTS as vt, GithubIssuePullRequestsRepository as w, NON_NEGATIVE_NUMBER_RANGE as wt, PlanRevision as x, FLYING_ANIMALS_SCALE_RANGE as xt, PLAN_TOOL_NAME as y, FLYING_ANIMALS_DURATION_RANGE as yt, BenchmarkStatus as z };