glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/contracts-DGkKNh9W.js

@@ -0,0 +1,3020 @@
+import { d as SessionSnapshot, f as SessionState, l as PendingWakeup, m as TaskTitle, s as PendingPromptDetail } from "./session-Cez8aIWg.js";
+import path from "node:path";
+import { z } from "zod";
+//#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 REPLAY_BUFFER_KB_RANGE = Object.freeze({
+	min: 64,
+	max: 16384
+});
+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({
+	FLYING_ANIMALS_GAP_RANGE,
+	FLYING_ANIMALS_DURATION_RANGE,
+	FLYING_ANIMALS_SCALE_RANGE,
+	CHANGE_MAP_NARRATOR_TIMEOUT_RANGE,
+	KEEP_MERGEABLE_TIMEOUT_MINUTES_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,
+	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/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/reviews.ts
+var ReviewsRetry = z.object({
+	attempt: z.number().int().positive(),
+	limit: z.number().int().positive()
+}).refine((retry) => retry.attempt <= retry.limit);
+var reviewsPollingShape = {
+	error: z.string().nullable().optional(),
+	nextAttemptAt: z.number().finite().nonnegative().nullable().optional(),
+	retry: ReviewsRetry.nullable().optional(),
+	isRefreshing: z.boolean().optional(),
+	refreshNotice: z.string().nullable().optional()
+};
+var ReviewsRefreshRequest = z.object({ lane: z.enum(["my-prs", "team-review"]) });
+var ReviewsRefreshResult = z.object({
+	ok: z.boolean(),
+	error: z.string().optional()
+});
+//#endregion
+//#region shared/contracts/team-review.ts
+var CommitSha = z.string().regex(/^[0-9a-f]{40}$/);
+var repoSlug$1 = z.string().regex(/^[^/]+\/[^/]+$/);
+var SearchedPr = z.object({
+	number: z.number().int().positive(),
+	title: z.string(),
+	html_url: z.string(),
+	draft: z.boolean().optional(),
+	created_at: z.string().optional(),
+	updated_at: z.string().optional(),
+	repository_url: z.string(),
+	user: z.object({
+		login: z.string(),
+		type: z.enum(["User", "Bot"])
+	}).passthrough(),
+	pull_request: z.object({}).passthrough()
+}).passthrough();
+var PrDetail = z.object({
+	number: z.number().int().positive(),
+	title: z.string(),
+	body: z.string(),
+	url: z.string(),
+	author: z.object({
+		login: z.string(),
+		is_bot: z.boolean().optional()
+	}).passthrough(),
+	isDraft: z.boolean(),
+	isCrossRepository: z.boolean(),
+	baseRefName: z.string(),
+	baseRefOid: CommitSha,
+	headRefOid: CommitSha,
+	additions: z.number().int().nonnegative(),
+	deletions: z.number().int().nonnegative(),
+	files: z.array(z.object({
+		path: z.string(),
+		additions: z.number().int().nonnegative(),
+		deletions: z.number().int().nonnegative()
+	}).passthrough())
+}).passthrough();
+var ReviewComment = z.object({
+	path: z.string(),
+	line: z.number().int().positive(),
+	side: z.enum(["RIGHT", "LEFT"]).default("RIGHT"),
+	body: z.string()
+});
+var LEGACY_VERDICTS = Object.freeze({
+	STAMP: "APPROVE",
+	COMMENT: "APPROVE WITH NITS",
+	NEEDS_YOU: "REQUEST CHANGES"
+});
+var ReviewVerdict = z.enum([
+	"APPROVE",
+	"APPROVE WITH NITS",
+	"REQUEST CHANGES",
+	"BLOCKED"
+]);
+var storedVerdict = z.preprocess((verdict) => typeof verdict === "string" && Object.hasOwn(LEGACY_VERDICTS, verdict) ? LEGACY_VERDICTS[verdict] : verdict, ReviewVerdict);
+var FindingSeverity = z.enum([
+	"CRITICAL",
+	"HIGH",
+	"MEDIUM",
+	"LOW"
+]);
+var DraftComment = ReviewComment.extend({ severity: FindingSeverity.optional() });
+var ReviewFinding = z.object({
+	path: z.string().min(1),
+	line: z.number().int().positive().nullable(),
+	side: z.enum(["RIGHT", "LEFT"]),
+	severity: FindingSeverity,
+	reviewer: z.string().min(1),
+	disposition: z.enum([
+		"ACTIONABLE",
+		"NIT",
+		"AMBIGUOUS"
+	]).nullable(),
+	body: z.string().min(1)
+});
+var ReviewAssessment = z.object({
+	goal: z.string().default(""),
+	change: z.string(),
+	checked: z.array(z.string()),
+	gaps: z.array(z.string())
+});
+var ReviewResult = z.object({
+	verdict: ReviewVerdict,
+	head: CommitSha,
+	summary: z.string(),
+	assessment: ReviewAssessment.nullable(),
+	findings: z.array(ReviewFinding)
+});
+var PostingPlan = z.object({
+	body: z.string(),
+	commit_id: CommitSha,
+	comments: z.array(z.object({
+		path: z.string().min(1),
+		line: z.number().int().positive(),
+		side: z.enum(["RIGHT", "LEFT"]).default("RIGHT"),
+		body: z.string().min(1)
+	}))
+});
+var PostedReviewEvent = z.enum(["APPROVE", "COMMENT"]);
+var GithubReviewState = z.enum([
+	"APPROVED",
+	"CHANGES_REQUESTED",
+	"COMMENTED"
+]);
+var DECIDING_REVIEW_STATES = /* @__PURE__ */ new Set(["APPROVED", "CHANGES_REQUESTED"]);
+var GithubReviewDecision = z.enum([
+	"APPROVED",
+	"CHANGES_REQUESTED",
+	"REVIEW_REQUIRED"
+]);
+var ReviewChecksState = z.enum([
+	"SUCCESS",
+	"FAILURE",
+	"PENDING",
+	"ERROR",
+	"EXPECTED"
+]);
+var reviewPriorityShape = {
+	requestSource: z.enum(["direct", "team"]).default("team"),
+	isDraft: z.boolean().optional(),
+	checksState: ReviewChecksState.nullable().optional()
+};
+var GithubReview = z.object({
+	login: z.string().min(1),
+	state: GithubReviewState,
+	commit: CommitSha.nullable(),
+	isViewer: z.boolean(),
+	submittedAt: z.string().nullable().optional()
+});
+function decisionAsIfApprovalRequired(githubDecision, opinionatedWriterReviewStates) {
+	if (githubDecision) return githubDecision;
+	if (opinionatedWriterReviewStates.includes("CHANGES_REQUESTED")) return "CHANGES_REQUESTED";
+	if (opinionatedWriterReviewStates.includes("APPROVED")) return "APPROVED";
+	return "REVIEW_REQUIRED";
+}
+function hasStandingViewerApproval(draft) {
+	if (draft.reviewDecision !== "APPROVED") return false;
+	if (draft.requeuedHead !== void 0 && draft.requeuedHead === (draft.liveHead ?? draft.reviewedHead)) return false;
+	return (draft.githubReviews ?? []).some((review) => review.isViewer && review.state === "APPROVED");
+}
+z.object({
+	head: CommitSha,
+	reviews: z.array(GithubReview)
+});
+var PriorReview = z.object({
+	head: CommitSha,
+	verdict: ReviewVerdict,
+	summary: z.string(),
+	body: z.string(),
+	comments: z.array(ReviewComment),
+	wasPosted: z.boolean()
+});
+var ReviewThreadId = z.string().min(1).max(256).regex(/^[A-Za-z0-9_=-]+$/);
+var TeamReviewThreadResult = z.object({
+	addressed: z.boolean(),
+	reason: z.string().trim().min(1).max(4e3)
+}).strict();
+var TeamReviewThreadNode = z.object({
+	id: ReviewThreadId,
+	path: z.string(),
+	line: z.number().int().positive().nullable(),
+	isResolved: z.boolean(),
+	viewerCanResolve: z.boolean(),
+	comments: z.object({
+		pageInfo: z.object({
+			hasNextPage: z.boolean(),
+			endCursor: z.string().nullable().optional()
+		}),
+		nodes: z.array(z.object({
+			body: z.string(),
+			author: z.object({ login: z.string() }).nullable(),
+			viewerDidAuthor: z.boolean(),
+			createdAt: z.string().datetime(),
+			url: z.string().url(),
+			originalCommit: z.object({ oid: CommitSha }).nullable()
+		}))
+	})
+});
+var TeamReviewThreadCommentsResponse = z.object({ data: z.object({ node: z.object({ comments: TeamReviewThreadNode.shape.comments }).nullable() }).nullable() });
+var TeamReviewThreadsRepository = z.object({ pullRequest: z.object({ reviewThreads: z.object({
+	pageInfo: z.object({
+		hasNextPage: z.boolean(),
+		endCursor: z.string().nullable().optional()
+	}),
+	nodes: z.array(TeamReviewThreadNode)
+}) }).nullable() });
+var TeamReviewResolveResponse = z.object({
+	data: z.object({ resolveReviewThread: z.object({ thread: z.object({
+		id: ReviewThreadId,
+		isResolved: z.literal(true)
+	}) }) }).nullable(),
+	errors: z.array(z.unknown()).optional()
+});
+var TeamReviewThread = z.object({
+	id: ReviewThreadId,
+	path: z.string(),
+	line: z.number().int().positive().nullable(),
+	isResolved: z.boolean(),
+	viewerCanResolve: z.boolean(),
+	isNit: z.boolean(),
+	url: z.string().url(),
+	viewerComment: z.string().max(1500).optional(),
+	lastReplyBody: z.string().max(1500).optional(),
+	viewerCommentTruncated: z.boolean().optional(),
+	lastReplyTruncated: z.boolean().optional(),
+	lastReplyAuthor: z.string(),
+	lastReplyAt: z.string().datetime(),
+	judgement: TeamReviewThreadResult.extend({
+		head: CommitSha,
+		judgedAt: z.number().finite(),
+		lastReplyAt: z.string().datetime()
+	}).optional(),
+	resolveError: z.string().optional(),
+	resolveAttemptReplyAt: z.string().optional(),
+	judgeAttempt: z.object({
+		head: CommitSha,
+		lastReplyAt: z.string(),
+		retryAt: z.number().finite()
+	}).optional(),
+	unjudgeable: z.object({
+		head: CommitSha,
+		lastReplyAt: z.string(),
+		reason: z.string().min(1)
+	}).optional()
+});
+var TeamReviewCompareFiles = z.object({
+	merge_base_commit: z.object({ sha: CommitSha }),
+	files: z.array(z.object({
+		filename: z.string(),
+		previous_filename: z.string().optional(),
+		patch: z.string().optional()
+	})).max(300)
+});
+var ViewerThreadTally = z.object({
+	total: z.number().int().nonnegative(),
+	resolved: z.number().int().nonnegative()
+});
+var ReviewDraft = z.object({
+	...reviewPriorityShape,
+	key: z.string(),
+	repo: repoSlug$1,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.string(),
+	author: z.string(),
+	tier: z.enum(["stamp", "full"]),
+	reasons: z.array(z.string()),
+	reviewedHead: CommitSha,
+	verdict: storedVerdict,
+	summary: z.string(),
+	assessment: ReviewAssessment.optional(),
+	body: z.string(),
+	comments: z.array(DraftComment),
+	status: z.enum([
+		"ready",
+		"stale",
+		"posted",
+		"discarded",
+		"error"
+	]),
+	error: z.string().optional(),
+	threads: z.array(TeamReviewThread).optional(),
+	viewerThreads: ViewerThreadTally.optional(),
+	githubReviews: z.array(GithubReview).optional(),
+	reviewDecision: GithubReviewDecision.nullable().optional(),
+	liveHead: CommitSha.optional(),
+	prCreatedAt: z.string().optional(),
+	reviewedAt: z.number().finite().optional(),
+	postedAt: z.number().finite().optional(),
+	postedEvent: PostedReviewEvent.optional(),
+	priorReviewedHead: CommitSha.optional(),
+	requeuedHead: CommitSha.optional()
+});
+function canApproveAfterComment(draft) {
+	return draft.status === "posted" && draft.postedEvent === "COMMENT";
+}
+var TeamReviewAction = z.enum([
+	"approve",
+	"approve-only",
+	"comment",
+	"discard",
+	"requeue",
+	"resolve-thread"
+]);
+var TeamReviewActionRequest = z.object({
+	key: z.string().min(1),
+	head: CommitSha,
+	action: TeamReviewAction,
+	threadId: ReviewThreadId.optional(),
+	body: z.string(),
+	comments: z.array(ReviewComment)
+}).refine((request) => request.action !== "resolve-thread" || request.threadId !== void 0, {
+	message: "resolve-thread requires threadId",
+	path: ["threadId"]
+});
+var TeamReviewActionResult = z.object({
+	key: z.string(),
+	ok: z.boolean(),
+	error: z.string().optional(),
+	warning: z.string().optional()
+});
+var ResumableReview = z.object({
+	sessionId: z.string().min(1),
+	workDir: z.string().min(1),
+	worktreePath: z.string().min(1),
+	head: CommitSha,
+	deadlineAt: z.number(),
+	remainingAwakeMs: z.number().nonnegative().optional(),
+	savedAt: z.number()
+});
+var QueuedReview = z.object({
+	...reviewPriorityShape,
+	reviewDecision: GithubReviewDecision.nullable().optional(),
+	key: z.string(),
+	repo: repoSlug$1,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.string(),
+	author: z.string(),
+	prCreatedAt: z.string().optional()
+});
+var TeamReviewStateEntry = z.object({
+	draft: ReviewDraft.nullable(),
+	reviewedHead: CommitSha.nullable(),
+	inFlight: z.boolean(),
+	skipReason: z.string().nullable(),
+	handReview: QueuedReview.optional(),
+	reviewAttempts: z.number().int().nonnegative().default(0),
+	resumable: ResumableReview.nullable().optional(),
+	reviewedAt: z.number().optional(),
+	threads: z.array(TeamReviewThread).optional(),
+	viewerThreads: ViewerThreadTally.optional(),
+	autoResolvedThreadIds: z.array(ReviewThreadId).optional(),
+	githubReviews: z.array(GithubReview).optional(),
+	reviewDecision: GithubReviewDecision.nullable().optional(),
+	liveHead: CommitSha.optional(),
+	requeuedHead: CommitSha.optional(),
+	priorReview: PriorReview.optional(),
+	discardedReviewHead: CommitSha.optional(),
+	updatedAt: z.number().finite()
+});
+z.record(z.string(), TeamReviewStateEntry);
+var ReviewProgressPhase = z.enum([
+	"preparing",
+	"checkout",
+	"reviewing"
+]);
+var ReviewProgressStep = z.object({
+	at: z.number().finite(),
+	tool: z.string(),
+	detail: z.string()
+});
+var InFlightReview = z.object({
+	...reviewPriorityShape,
+	reviewDecision: GithubReviewDecision.nullable().optional(),
+	key: z.string(),
+	repo: repoSlug$1,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.string(),
+	author: z.string(),
+	tier: z.enum(["stamp", "full"]),
+	reasons: z.array(z.string()),
+	head: CommitSha,
+	phase: ReviewProgressPhase,
+	startedAt: z.number().finite(),
+	deadlineAt: z.number().finite().nullable(),
+	toolCalls: z.number().int().nonnegative(),
+	recentSteps: z.array(ReviewProgressStep),
+	prCreatedAt: z.string().optional(),
+	priorReviewedHead: CommitSha.optional()
+});
+var TeamReviewStatus = z.object({
+	...reviewsPollingShape,
+	type: z.literal("team-review-status"),
+	ts: z.number().finite(),
+	configured: z.boolean(),
+	reason: z.string().nullable().optional(),
+	drafts: z.array(ReviewDraft),
+	inFlight: z.array(InFlightReview),
+	queued: z.array(QueuedReview).default([]),
+	handReview: z.array(QueuedReview).default([]),
+	team: z.object({
+		org: z.string(),
+		slug: z.string(),
+		name: z.string(),
+		avatarUrl: z.string()
+	}).nullable().optional()
+}).passthrough();
+//#endregion
+//#region shared/contracts/my-prs.ts
+var MyPrStage = z.enum([
+	"merged",
+	"draft",
+	"conflicts",
+	"behind",
+	"checks-failing",
+	"changes-requested",
+	"unresolved-threads",
+	"checks-pending",
+	"needs-approval",
+	"ready",
+	"unknown"
+]);
+var nonnegativeInteger$1 = z.number().int().nonnegative();
+var repositoryName = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var pullRequestNumberText = z.string().regex(/^[1-9][0-9]*$/);
+var pullRequestKeyFormat = z.templateLiteral([
+	repositoryName,
+	"#",
+	pullRequestNumberText
+]);
+var keepMergeableAttemptKeyFormat = z.templateLiteral([
+	pullRequestKeyFormat,
+	"@",
+	CommitSha
+]);
+var pullRequestKey = z.string().refine((value) => pullRequestKeyFormat.safeParse(value).success);
+var keepMergeableAttemptKey = z.string().refine((value) => keepMergeableAttemptKeyFormat.safeParse(value).success);
+z.discriminatedUnion("outcome", [z.strictObject({ outcome: z.literal("pushed") }), z.strictObject({
+	outcome: z.enum([
+		"no-change",
+		"failed",
+		"stopped",
+		"timed-out"
+	]),
+	reason: z.string().min(1)
+})]);
+var MyPrKeepMergeableAttempt = z.strictObject({
+	outcome: z.enum([
+		"pushed",
+		"no-change",
+		"failed",
+		"stopped",
+		"timed-out"
+	]),
+	reason: z.string().min(1).optional(),
+	at: z.number().finite()
+});
+var MyPrKeepMergeableAttemptRecord = MyPrKeepMergeableAttempt.extend({
+	key: pullRequestKey,
+	headRefOid: CommitSha,
+	baseRefOid: CommitSha
+});
+var MyPrsState = z.strictObject({
+	keepMergeableKeys: z.array(pullRequestKey),
+	keepMergeableAttemptKeys: z.array(keepMergeableAttemptKey),
+	keepMergeableAttempts: z.array(MyPrKeepMergeableAttemptRecord).default([]),
+	mergeQueueKeys: z.array(pullRequestKey).default([]),
+	keepMergeablePushedHeadKeys: z.array(keepMergeableAttemptKey).default([])
+});
+var MyPrKeepMergeableRequest = z.object({
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	keepMergeable: z.boolean()
+});
+var MyPrToggleResult = z.object({
+	key: z.string(),
+	ok: z.boolean(),
+	error: z.string().optional()
+});
+var MyPrKeepMergeableResult = MyPrToggleResult;
+var MyPrMergeWhenReadyRequest = z.object({
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	mergeWhenReady: z.boolean()
+});
+var MyPrMergeWhenReadyResult = MyPrToggleResult;
+var MyPrMergeMethod = z.enum([
+	"MERGE",
+	"SQUASH",
+	"REBASE"
+]);
+var MyPrThread = z.object({
+	path: z.string(),
+	line: z.number().int().positive().nullable(),
+	isOutdated: z.boolean(),
+	url: z.url(),
+	author: z.string().nullable(),
+	excerpt: z.string(),
+	commentCount: z.number().int().positive(),
+	lastAuthor: z.string().nullable(),
+	lastActivityAt: z.string()
+});
+var MyPrReview = z.object({
+	reviewer: z.string().nullable(),
+	state: z.string(),
+	submittedAt: z.string().nullable()
+});
+var MyPrAutoRebase = z.object({
+	outcome: z.enum(["rebased", "failed"]),
+	at: z.number().finite(),
+	message: z.string()
+});
+var MyPr = z.object({
+	key: z.string(),
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.url(),
+	isDraft: z.boolean(),
+	state: z.enum([
+		"OPEN",
+		"MERGED",
+		"CLOSED"
+	]),
+	createdAt: z.string(),
+	mergedAt: z.string().nullable(),
+	updatedAt: z.string(),
+	baseRefName: z.string(),
+	baseRefOid: CommitSha,
+	headRefName: z.string().min(1),
+	isCrossRepository: z.boolean(),
+	headRefOid: CommitSha,
+	isInMergeQueue: z.boolean(),
+	mergeMethod: MyPrMergeMethod,
+	mergeable: z.enum([
+		"MERGEABLE",
+		"CONFLICTING",
+		"UNKNOWN"
+	]),
+	mergeStateStatus: z.string(),
+	reviewDecision: z.enum([
+		"APPROVED",
+		"CHANGES_REQUESTED",
+		"REVIEW_REQUIRED"
+	]).nullable(),
+	checks: z.object({
+		state: z.enum([
+			"SUCCESS",
+			"FAILURE",
+			"PENDING",
+			"ERROR",
+			"EXPECTED"
+		]).nullable(),
+		failing: z.array(z.string()),
+		pendingCount: nonnegativeInteger$1
+	}),
+	unresolvedThreads: nonnegativeInteger$1,
+	threads: z.array(MyPrThread),
+	behindBy: nonnegativeInteger$1.nullable(),
+	reviewRequests: z.array(z.object({
+		name: z.string(),
+		isTeam: z.boolean(),
+		avatarUrl: z.string().nullable()
+	})),
+	approvals: nonnegativeInteger$1,
+	reviews: z.array(MyPrReview),
+	stage: MyPrStage,
+	autoRebase: MyPrAutoRebase.optional(),
+	keepMergeable: z.boolean().optional(),
+	keepMergeableAttempt: MyPrKeepMergeableAttempt.optional(),
+	isKeepMergeableFixInFlight: z.boolean().optional(),
+	mergeQueuePosition: z.number().int().positive().nullable().optional(),
+	isMergeQueueHeldForRepairPush: z.boolean().optional()
+}).refine((pr) => pr.key === `${pr.repo}#${pr.number}`);
+var MyPrsStatus = z.object({
+	...reviewsPollingShape,
+	type: z.literal("my-prs-status"),
+	ts: z.number().finite(),
+	configured: z.boolean(),
+	reason: z.string().nullable().optional(),
+	viewer: z.string().nullable(),
+	prs: z.array(MyPr),
+	truncatedNote: z.string().nullable().optional(),
+	isKeepMergeableEnabled: z.boolean().optional(),
+	isMergeQueueEnabled: z.boolean().optional()
+}).passthrough();
+var MyPrMergeRequest = z.object({
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	headRefOid: CommitSha
+});
+var MyPrMergeKind = z.enum([
+	"merged",
+	"queued",
+	"auto-merge",
+	"unconfirmed"
+]);
+var MyPrMergeResult = z.object({
+	key: z.string(),
+	ok: z.boolean(),
+	kind: MyPrMergeKind.optional(),
+	error: z.string().optional()
+});
+var CheckRun = z.object({
+	__typename: z.literal("CheckRun"),
+	name: z.string(),
+	conclusion: z.string().nullable(),
+	status: z.string()
+});
+var StatusContext = z.object({
+	__typename: z.literal("StatusContext"),
+	context: z.string(),
+	state: z.string()
+});
+var MyPrSearchNode = z.object({
+	__typename: z.literal("PullRequest"),
+	id: z.string().regex(/^[A-Za-z0-9_=-]+$/),
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.url(),
+	isDraft: z.boolean(),
+	state: z.enum([
+		"OPEN",
+		"MERGED",
+		"CLOSED"
+	]),
+	createdAt: z.string(),
+	mergedAt: z.string().nullable(),
+	updatedAt: z.string(),
+	baseRefName: z.string(),
+	baseRefOid: CommitSha,
+	headRefName: z.string().min(1),
+	isCrossRepository: z.boolean(),
+	headRefOid: CommitSha,
+	isInMergeQueue: z.boolean(),
+	mergeable: z.enum([
+		"MERGEABLE",
+		"CONFLICTING",
+		"UNKNOWN"
+	]),
+	mergeStateStatus: z.string(),
+	reviewDecision: z.enum([
+		"APPROVED",
+		"CHANGES_REQUESTED",
+		"REVIEW_REQUIRED"
+	]).nullable(),
+	repository: z.object({
+		nameWithOwner: repositoryName,
+		viewerDefaultMergeMethod: MyPrMergeMethod
+	}),
+	commits: z.object({ nodes: z.array(z.object({ commit: z.object({ statusCheckRollup: z.object({
+		state: z.enum([
+			"SUCCESS",
+			"FAILURE",
+			"PENDING",
+			"ERROR",
+			"EXPECTED"
+		]).nullable(),
+		contexts: z.object({ nodes: z.array(z.union([CheckRun, StatusContext])) })
+	}).nullable() }) })) }),
+	reviewThreads: z.object({
+		pageInfo: z.object({ hasNextPage: z.boolean() }),
+		nodes: z.array(z.object({ isResolved: z.boolean() }))
+	}),
+	reviewRequests: z.object({ nodes: z.array(z.object({ requestedReviewer: z.discriminatedUnion("__typename", [
+		z.object({
+			__typename: z.literal("User"),
+			login: z.string()
+		}),
+		z.object({
+			__typename: z.literal("Team"),
+			slug: z.string(),
+			avatarUrl: z.string().nullable(),
+			organization: z.object({ login: z.string() })
+		}),
+		z.object({ __typename: z.enum(["Bot", "Mannequin"]) })
+	]).nullable() })) }),
+	latestOpinionatedReviews: z.object({ nodes: z.array(z.object({ state: z.string() })) }),
+	latestReviews: z.object({ nodes: z.array(z.object({
+		state: z.string(),
+		submittedAt: z.string().nullable(),
+		author: z.object({ login: z.string() }).nullable()
+	})) })
+});
+var ThreadCommentAuthor = z.object({ login: z.string() }).nullable();
+var MyPrThreadNode = z.object({
+	isResolved: z.boolean(),
+	isOutdated: z.boolean(),
+	path: z.string(),
+	line: z.number().int().positive().nullable(),
+	firstComment: z.object({
+		totalCount: nonnegativeInteger$1,
+		nodes: z.array(z.object({
+			author: ThreadCommentAuthor,
+			bodyText: z.string(),
+			url: z.url(),
+			createdAt: z.string()
+		}))
+	}),
+	lastComment: z.object({ nodes: z.array(z.object({
+		author: ThreadCommentAuthor,
+		createdAt: z.string()
+	})) })
+});
+var MyPrThreadsResponse = z.object({
+	data: z.object({ repository: z.object({ pullRequest: z.object({ reviewThreads: z.object({
+		pageInfo: z.object({
+			hasNextPage: z.boolean(),
+			endCursor: z.string().nullable()
+		}),
+		nodes: z.array(z.unknown())
+	}) }).nullable() }).nullable() }),
+	errors: z.array(z.unknown()).optional()
+});
+var MyPrMergeStateResponse = z.object({
+	data: z.object({ repository: z.object({ pullRequest: z.object({
+		state: z.string(),
+		isInMergeQueue: z.boolean(),
+		autoMergeRequest: z.object({ enabledAt: z.string().nullable() }).nullable()
+	}).nullable() }).nullable() }),
+	errors: z.array(z.unknown()).optional()
+});
+var MyPrSearchResponse = z.object({
+	data: z.object({
+		open: z.object({
+			issueCount: nonnegativeInteger$1,
+			nodes: z.array(z.unknown())
+		}),
+		merged: z.object({
+			issueCount: nonnegativeInteger$1,
+			nodes: z.array(z.unknown())
+		})
+	}),
+	errors: z.array(z.unknown()).optional()
+});
+//#endregion
+//#region shared/contracts/workflows.ts
+var WORKFLOW_TRIGGERS = Object.freeze([
+	"opened",
+	"checks-failed",
+	"review-requested",
+	"approved",
+	"commented",
+	"merged"
+]);
+var WORKFLOW_ACTION_TYPES = Object.freeze([
+	"notify",
+	"spawn",
+	"label",
+	"comment"
+]);
+var WORKFLOW_PROMPT_TEMPLATE_MAX_CHARACTERS = 2e4;
+var WORKFLOW_COMMENT_BODY_MAX_CHARACTERS = 65536;
+var RULE_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var GITHUB_LOGIN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+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 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(50, { error: `a workflow label name must be at most 50 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({
+		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({
+		type: z.literal("label"),
+		name: WorkflowLabelName
+	}),
+	z.strictObject({
+		type: z.literal("comment"),
+		body: WorkflowCommentBody
+	})
+], { 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(GITHUB_LOGIN, { 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 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 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", {
+		min: 0,
+		exclusiveMin: true,
+		max: 2147483647 / 1e3
+	})
+}, { 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();
+var BRANCH_GC_CONTROL_BOOLEAN_KEYS = Object.freeze(["enabled", "deleteUnmerged"]);
+var BRANCH_GC_CONTROL_NUMERIC_KEYS = Object.freeze(["staleDays", "intervalMs"]);
+var PostTurnChecksSettings = optionalObject("postTurnChecks", { mode: z.enum(["report", "fix"], { 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: optionalNumber("visions.dispatch.quietMs", VISIONS_QUIET_MS_RANGE),
+		cooldownMs: optionalNumber("visions.dispatch.cooldownMs", VISIONS_COOLDOWN_MS_RANGE),
+		maxPerHour: optionalNumber("visions.dispatch.maxPerHour", VISIONS_MAX_PER_HOUR_RANGE),
+		activityMaxPerHour: optionalNumber("visions.dispatch.activityMaxPerHour", VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE),
+		dispatchTimeoutSeconds: optionalNumber("visions.dispatch.dispatchTimeoutSeconds", VISIONS_DISPATCH_TIMEOUT_RANGE)
+	}),
+	intent: optionalObject("visions.intent", { threadTtlMs: optionalNumber("visions.intent.threadTtlMs", VISIONS_INTENT_THREAD_TTL_MS_RANGE) })
+});
+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 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, 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 agentApiShape = { enabled: optionalBoolean("agentApi.enabled") };
+var AgentApiSettings = z.object(agentApiShape, { error: "agentApi must be an object" }).strict().optional();
+var AgentApiFileSettings = z.object(agentApiShape, { error: "agentApi 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(0).max(65535).optional(),
+	autoRecoverSeconds: z.number().finite().nonnegative().optional(),
+	inputGraceSeconds: z.number().finite().nonnegative().optional(),
+	promptDetectionMs: z.number().finite().nonnegative().optional(),
+	notifyDebounceMs: z.number().finite().nonnegative().optional(),
+	phoneEscalationMs: z.number().finite().nonnegative().optional(),
+	replayBufferKB: optionalNumber("replayBufferKB", {
+		...REPLAY_BUFFER_KB_RANGE,
+		min: 0
+	}),
+	cursorBlink: optionalBoolean("cursorBlink"),
+	debugMode: optionalBoolean("debugMode"),
+	calmLayout: optionalBoolean("calmLayout"),
+	detectBackgroundAgents: optionalBoolean("detectBackgroundAgents"),
+	recordSignals: optionalBoolean("recordSignals"),
+	antiSlopPrompt: optionalBoolean("antiSlopPrompt"),
+	rtk: optionalBoolean("rtk"),
+	saneYolo: optionalBoolean("saneYolo"),
+	skipPermissionsByDefault: optionalBoolean("skipPermissionsByDefault"),
+	checkForUpdates: optionalBoolean("checkForUpdates"),
+	updateChannel: z.enum(["release", "main"], { 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,
+	teamReview: TeamReviewSettings,
+	benchmarks: BenchmarksSettings,
+	posthog: PosthogSettings,
+	usage: createUsageSettings(isAbsolutePath),
+	telegram: TelegramSettings,
+	ingest: IngestSettings,
+	agentApi: AgentApiSettings,
+	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,
+	autoRecoverSeconds: z.number({ error: "autoRecoverSeconds must be a positive number" }).finite().positive({ error: "autoRecoverSeconds must be a positive number" }).optional(),
+	inputGraceSeconds: z.number({ error: "inputGraceSeconds must be a positive number" }).finite().positive({ error: "inputGraceSeconds must be a positive number" }).optional(),
+	promptDetectionMs: z.number({ error: "promptDetectionMs must be a positive number" }).finite().positive({ error: "promptDetectionMs must be a positive number" }).optional(),
+	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(),
+	replayBufferKB: optionalNumber("replayBufferKB", REPLAY_BUFFER_KB_RANGE),
+	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 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 ProjectConfig = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	customTitle: TaskTitle.optional(),
+	path: z.string(),
+	repos: z.array(z.string()).min(2).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(),
+	dangerouslySkipPermissions: z.boolean({ error: "projects[].dangerouslySkipPermissions 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"),
+	teamReview: optionalLooseObject("teamReview"),
+	benchmarks: optionalLooseObject("benchmarks"),
+	posthog: optionalLooseObject("posthog"),
+	usage: optionalLooseObject("usage"),
+	telegram: optionalLooseObject("telegram"),
+	ingest: optionalLooseObject("ingest"),
+	workflows: optionalLooseObject("workflows"),
+	agentApi: AgentApiFileSettings,
+	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(", ")}`
+		});
+	}
+});
+Object.freeze(Object.keys(BROWSER_CONFIG_SHAPE));
+var CONFIG_BLOCK_KEYS = Object.freeze([
+	"changeMap",
+	"taskTitle",
+	"branchGc",
+	"postTurnChecks",
+	"visions",
+	"teamReview",
+	"benchmarks",
+	"posthog",
+	"usage",
+	"telegram",
+	"ingest",
+	"agentApi",
+	"telemetry",
+	"workflows",
+	"coder"
+]);
+var CONFIG_SCALAR_KEYS = Object.freeze(Object.keys(BROWSER_CONFIG_SHAPE).filter((key) => {
+	if (CONFIG_BLOCK_KEYS.includes(key)) return false;
+	return key !== "port" && key !== "repoRoots" && key !== "worktreeShare";
+}));
+var RUNTIME_CONFIG_SCALAR_KEYS = Object.freeze([
+	...CONFIG_SCALAR_KEYS,
+	"worktreeAutoRebase",
+	"worktreeSyncOnStart",
+	"worktreeRerere"
+]);
+Object.freeze([
+	"detectScheduledWakeups",
+	"worktreeAutoRebase",
+	"worktreeSyncOnStart",
+	"worktreeRerere",
+	"hooks",
+	"remote",
+	"projects"
+]);
+function configIssueMessage(error) {
+	return error.issues[0]?.message || "settings are invalid";
+}
+//#endregion
+//#region shared/contracts/telemetry.ts
+var TELEMETRY_ADAPTERS = Object.freeze([...BUILTIN_AGENT_IDS, "custom"]);
+var SESSION_EXIT_KINDS = Object.freeze([
+	"clean",
+	"error",
+	"signal",
+	"no_output"
+]);
+var nonNegativeInteger = z.number().int().nonnegative();
+var boundedText = z.string().max(512);
+var AppStartedProperties = z.object({}).strict();
+var AppActiveProperties = z.object({ active_session_count: nonNegativeInteger }).strict();
+var SessionStartedProperties = z.object({ adapter: z.enum(TELEMETRY_ADAPTERS) }).strict();
+var SessionEndedProperties = z.object({
+	adapter: z.enum(TELEMETRY_ADAPTERS),
+	exit_kind: z.enum(SESSION_EXIT_KINDS),
+	duration_seconds: nonNegativeInteger
+}).strict();
+var ExceptionFrame = z.object({
+	platform: z.enum(["node:javascript", "web:javascript"]),
+	function: boundedText,
+	filename: boundedText,
+	lineno: nonNegativeInteger,
+	colno: nonNegativeInteger,
+	in_app: z.boolean()
+}).strict();
+var ExceptionProperties = z.object({
+	$exception_list: z.array(z.object({
+		type: boundedText,
+		value: boundedText,
+		mechanism: z.object({
+			handled: z.boolean(),
+			synthetic: z.boolean(),
+			type: z.literal("generic")
+		}).strict(),
+		stacktrace: z.object({
+			type: z.literal("raw"),
+			frames: z.array(ExceptionFrame).max(64)
+		}).strict()
+	}).strict()).length(1),
+	$exception_level: z.enum(["error", "fatal"])
+}).strict();
+var AiGenerationProperties = z.object({
+	$ai_trace_id: z.string().regex(/^[0-9a-f]{64}$/),
+	$ai_provider: z.string().max(64),
+	$ai_model: z.string().max(128),
+	$ai_input_tokens: nonNegativeInteger,
+	$ai_output_tokens: nonNegativeInteger,
+	$ai_cache_read_input_tokens: nonNegativeInteger.optional(),
+	$ai_cache_creation_input_tokens: nonNegativeInteger.optional(),
+	$ai_total_cost_usd: z.number().finite().nonnegative().optional(),
+	agent_adapter: z.enum(TELEMETRY_ADAPTERS)
+}).strict();
+var TELEMETRY_EVENT_SCHEMAS = Object.freeze({
+	app_started: AppStartedProperties,
+	app_active: AppActiveProperties,
+	session_started: SessionStartedProperties,
+	session_ended: SessionEndedProperties,
+	$exception: ExceptionProperties,
+	$ai_generation: AiGenerationProperties
+});
+Object.freeze([
+	{
+		name: "app_started",
+		description: "The server started listening."
+	},
+	{
+		name: "app_active",
+		description: "Once a day while the server runs, with how many sessions are live."
+	},
+	{
+		name: "session_started",
+		description: "A session spawned, with which kind of agent (any custom agent counts as `custom`)."
+	},
+	{
+		name: "session_ended",
+		description: "A session exited: how it exited and how long it ran, in whole seconds."
+	},
+	{
+		name: "$exception",
+		description: "An error in the server or the dashboard: its type, an error code when it has one, and stack frames with file paths cut to the package or URL path. Never the error message. Each distinct error is sent once per run, and a crash is sent on the next start."
+	},
+	{
+		name: "$ai_generation",
+		description: "Per agent session and model, after each usage scan, for usage recorded in the last 24 hours: token counts, the model name and estimated cost, under a one-way hash of the session. A model name outside the shipped pricing table is sent as unknown. No prompts or output."
+	}
+]);
+Object.freeze([
+	"app_version",
+	"os_platform",
+	"node_major",
+	"install_flavor",
+	"is_bundled",
+	"is_dev_install"
+]);
+Object.freeze(["$release_id"]);
+var TELEMETRY_KILL_SWITCH_FLAG = "telemetry-enabled";
+var FeatureFlagsResponse = z.object({
+	flags: z.object({ [TELEMETRY_KILL_SWITCH_FLAG]: z.object({ enabled: z.boolean() }).passthrough().optional() }).passthrough(),
+	errorsWhileComputingFlags: z.boolean().optional()
+}).passthrough();
+var PendingCrashReport = z.object({
+	timestamp: z.string(),
+	properties: ExceptionProperties
+}).strict();
+var TelemetryState = z.object({
+	installId: z.uuid(),
+	noticeShownAt: z.string().nullable().optional(),
+	remoteDisabled: z.boolean().optional()
+});
+//#endregion
+//#region shared/contracts/benchmark.ts
+var BENCHMARK_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var repoSlug = z.string().regex(/^[^/\s]+\/[^/\s]+$/);
+var timestamp$1 = z.number().finite();
+var nonEmptyText = z.string().min(1);
+var BENCHMARK_INJECTED_ENV_NAMES = Object.freeze(["CLAUDE_CODE_OAUTH_TOKEN"]);
+Object.freeze(["human", "bot"]);
+var BenchmarkId = z.string().regex(BENCHMARK_ID_RE);
+function hasUniqueIds(entries) {
+	return new Set(entries.map((entry) => entry.id)).size === entries.length;
+}
+var BenchmarkCaseSource = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("manual") }), z.strictObject({
+	kind: z.literal("github-merged-prs"),
+	repo: repoSlug,
+	minBodies: z.number().int().min(1),
+	limit: z.number().int().min(1).max(500)
+})]);
+var BenchmarkWorkspace = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("none") }), z.strictObject({ kind: z.literal("pr-checkout") })]);
+var BenchmarkSubjectOutput = z.enum(["review-findings", "json"]);
+var BenchmarkSubject = z.strictObject({
+	promptTemplate: nonEmptyText,
+	output: BenchmarkSubjectOutput,
+	timeoutSeconds: z.number().int().min(30).max(14400)
+});
+var BenchmarkArm = z.strictObject({
+	id: BenchmarkId,
+	env: z.record(z.string().regex(ENV_NAME_RE), z.string()).refine((env) => BENCHMARK_INJECTED_ENV_NAMES.every((name) => !Object.hasOwn(env, name)), { message: `arm env must not set ${BENCHMARK_INJECTED_ENV_NAMES.join(", ")}; Glimmervoid injects it per cell` }).optional(),
+	extraArgs: z.array(z.string()).optional(),
+	setup: z.strictObject({ command: z.array(nonEmptyText).min(1) }).optional()
+});
+var BenchmarkScorer = z.discriminatedUnion("kind", [z.strictObject({
+	kind: z.literal("llm-judge-match"),
+	model: nonEmptyText
+})]);
+var BenchmarkSuite = z.strictObject({
+	id: BenchmarkId,
+	title: nonEmptyText,
+	caseSource: BenchmarkCaseSource,
+	workspace: BenchmarkWorkspace,
+	subject: BenchmarkSubject,
+	arms: z.array(BenchmarkArm).min(2).refine(hasUniqueIds, { message: "arm ids must be unique" }),
+	baselineArm: BenchmarkId,
+	trials: z.number().int().min(1).max(20),
+	scorer: BenchmarkScorer
+}).refine((suite) => suite.arms.some((arm) => arm.id === suite.baselineArm), {
+	message: "baselineArm must name one of the arms",
+	path: ["baselineArm"]
+});
+var BenchmarkReference = z.strictObject({
+	id: BenchmarkId,
+	text: nonEmptyText,
+	tags: z.array(BenchmarkId),
+	path: nonEmptyText.optional(),
+	line: z.number().int().positive().optional()
+});
+var BenchmarkCaseOrigin = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("manual") }), z.strictObject({
+	kind: z.literal("github-pr"),
+	repo: repoSlug,
+	number: z.number().int().positive(),
+	url: nonEmptyText,
+	minedAt: timestamp$1
+})]);
+var BenchmarkCase = z.strictObject({
+	id: BenchmarkId,
+	input: z.record(z.string(), z.unknown()),
+	references: z.array(BenchmarkReference).min(1).refine(hasUniqueIds, { message: "reference ids must be unique" }),
+	source: BenchmarkCaseOrigin
+});
+var PrCheckoutCaseInput = z.object({
+	repo: repoSlug,
+	number: z.number().int().positive(),
+	reviewedSha: CommitSha,
+	baseSha: CommitSha,
+	changedFiles: z.array(nonEmptyText)
+});
+var BenchmarkMatchVerdict = z.enum([
+	"found",
+	"partial",
+	"missed"
+]);
+var BenchmarkJudgement = z.strictObject({
+	referenceId: BenchmarkId,
+	verdict: BenchmarkMatchVerdict,
+	findingIndexes: z.array(z.number().int().nonnegative())
+});
+var BenchmarkCellStatus = z.enum([
+	"scored",
+	"invalid",
+	"error"
+]);
+var BenchmarkCellResult = z.strictObject({
+	caseId: BenchmarkId,
+	armId: BenchmarkId,
+	trial: z.number().int().min(1),
+	status: BenchmarkCellStatus,
+	startedAt: timestamp$1,
+	finishedAt: timestamp$1,
+	degradedReasons: z.array(nonEmptyText),
+	findingCount: z.number().int().nonnegative(),
+	judgements: z.array(BenchmarkJudgement),
+	costUsd: z.number().finite().nonnegative().nullable(),
+	error: nonEmptyText.nullable()
+});
+var BenchmarkRunStatus = z.enum([
+	"running",
+	"completed",
+	"interrupted",
+	"failed"
+]);
+var BenchmarkRun = z.strictObject({
+	id: BenchmarkId,
+	suiteId: BenchmarkId,
+	status: BenchmarkRunStatus,
+	startedAt: timestamp$1,
+	finishedAt: timestamp$1.nullable(),
+	error: nonEmptyText.nullable(),
+	cells: z.array(BenchmarkCellResult)
+});
+var nullableRatio = z.number().min(0).max(1).nullable();
+var BenchmarkArmScore = z.strictObject({
+	trials: z.number().int().nonnegative(),
+	recall: nullableRatio,
+	recallByTag: z.record(BenchmarkId, nullableRatio),
+	degraded: z.number().int().nonnegative(),
+	invalid: z.number().int().nonnegative(),
+	costUsd: z.number().finite().nonnegative().nullable()
+});
+var BenchmarkReportRow = z.strictObject({
+	caseId: BenchmarkId,
+	arms: z.record(BenchmarkId, BenchmarkArmScore),
+	deltaVsBaseline: z.record(BenchmarkId, z.number().min(-1).max(1).nullable())
+});
+var BenchmarkReport = z.strictObject({
+	runId: BenchmarkId,
+	suiteId: BenchmarkId,
+	status: BenchmarkRunStatus,
+	baselineArm: BenchmarkId,
+	armIds: z.array(BenchmarkId),
+	rows: z.array(BenchmarkReportRow),
+	totals: z.record(BenchmarkId, BenchmarkArmScore)
+});
+var BenchmarkAction = z.enum([
+	"mine",
+	"run",
+	"cancel"
+]);
+var BenchmarkActionRequest = z.object({
+	suiteId: BenchmarkId,
+	action: BenchmarkAction
+});
+var BenchmarkActionResult = z.object({
+	suiteId: BenchmarkId,
+	action: BenchmarkAction,
+	ok: z.boolean(),
+	error: z.string().optional(),
+	runId: BenchmarkId.optional()
+});
+var BenchmarkCellPhase = z.enum([
+	"setup",
+	"preflight",
+	"workspace",
+	"subject",
+	"judge"
+]);
+var BenchmarkInFlightCell = z.object({
+	suiteId: BenchmarkId,
+	runId: BenchmarkId,
+	caseId: BenchmarkId.nullable(),
+	armId: BenchmarkId,
+	trial: z.number().int().min(1),
+	phase: BenchmarkCellPhase,
+	cellIndex: z.number().int().nonnegative(),
+	cellCount: z.number().int().positive(),
+	startedAt: timestamp$1
+});
+var BenchmarkSuiteSummary = z.object({
+	id: BenchmarkId,
+	title: z.string(),
+	error: z.string().nullable(),
+	caseCount: z.number().int().nonnegative(),
+	candidateCount: z.number().int().nonnegative(),
+	armIds: z.array(BenchmarkId),
+	baselineArm: BenchmarkId.nullable(),
+	latestReport: BenchmarkReport.nullable()
+});
+var BenchmarkStatus = z.object({
+	type: z.literal("benchmark-status"),
+	ts: timestamp$1,
+	configured: z.boolean(),
+	reason: z.string().nullable(),
+	suites: z.array(BenchmarkSuiteSummary),
+	inFlight: BenchmarkInFlightCell.nullable()
+}).passthrough();
+var githubAuthor = z.object({
+	__typename: z.string(),
+	login: z.string()
+}).nullable();
+var MergedPrListing = z.object({
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: nonEmptyText,
+	mergedAt: z.string().nullable(),
+	reviewThreads: z.object({ totalCount: z.number().int().nonnegative() }),
+	reviews: z.object({ totalCount: z.number().int().nonnegative() })
+});
+var MinedReviewThread = z.object({
+	path: z.string(),
+	line: z.number().int().positive().nullable(),
+	originalLine: z.number().int().positive().nullable(),
+	comments: z.object({ nodes: z.array(z.object({
+		databaseId: z.number().int().positive(),
+		author: githubAuthor,
+		body: z.string(),
+		createdAt: z.string(),
+		originalCommit: z.object({ oid: CommitSha }).nullable()
+	})) })
+});
+var MinedReview = z.object({
+	databaseId: z.number().int().positive(),
+	author: githubAuthor,
+	body: z.string(),
+	submittedAt: z.string().nullable(),
+	commit: z.object({ oid: CommitSha }).nullable()
+});
+var MinedBaseEvent = z.discriminatedUnion("__typename", [z.object({
+	__typename: z.literal("BaseRefChangedEvent"),
+	createdAt: z.string()
+}), z.object({
+	__typename: z.literal("BaseRefForcePushedEvent"),
+	createdAt: z.string(),
+	beforeCommit: z.object({ oid: CommitSha }).nullable()
+})]);
+var MinedPrReviewData = z.object({
+	author: githubAuthor,
+	baseRefOid: CommitSha,
+	reviewThreads: z.object({
+		pageInfo: z.object({ hasNextPage: z.boolean() }),
+		nodes: z.array(MinedReviewThread)
+	}),
+	reviews: z.object({
+		pageInfo: z.object({ hasNextPage: z.boolean() }),
+		nodes: z.array(MinedReview)
+	}),
+	timelineItems: z.object({
+		pageInfo: z.object({ hasNextPage: z.boolean() }),
+		nodes: z.array(MinedBaseEvent)
+	})
+});
+var CommitComparison = z.object({
+	mergeBaseSha: CommitSha,
+	changedFiles: z.array(nonEmptyText),
+	isFileListComplete: z.boolean()
+});
+Object.freeze([
+	"file",
+	"subsystem",
+	"co-change",
+	"hotspot",
+	"blast",
+	"untested",
+	"collision",
+	"link"
+]);
+function changeMapFactId(kind, repoName, ...parts) {
+	return [
+		kind,
+		repoName,
+		...parts
+	].join(":");
+}
+var factId = z.string().min(1);
+var repoPath = z.string().min(1);
+var count = z.number().int().nonnegative();
+var cappedPaths = z.array(repoPath).max(20);
+var ChangedFileStatus = z.enum([
+	"added",
+	"modified",
+	"deleted",
+	"renamed",
+	"untracked"
+]);
+var ChangedFile = z.strictObject({
+	factId,
+	path: repoPath,
+	previousPath: repoPath.optional(),
+	status: ChangedFileStatus,
+	isCommitted: z.boolean()
+});
+var SubsystemFact = z.strictObject({
+	factId,
+	agentsPath: repoPath,
+	title: z.string(),
+	paths: z.array(repoPath).min(1)
+});
+var CoChangeGap = z.strictObject({
+	factId,
+	path: repoPath,
+	partner: repoPath,
+	support: count,
+	confidence: z.number().min(0).max(1)
+});
+var HotspotFact = z.strictObject({
+	factId,
+	path: repoPath,
+	commitCount: count,
+	fixCommitCount: count
+});
+var BlastRadiusFact = z.strictObject({
+	factId,
+	path: repoPath,
+	directDependents: cappedPaths,
+	directDependentCount: count,
+	transitiveDependentCount: count,
+	dependentTests: cappedPaths,
+	dependentTestCount: count
+});
+var UntestedFileFact = z.strictObject({
+	factId,
+	path: repoPath
+});
+var CollisionFact = z.strictObject({
+	factId,
+	path: repoPath,
+	otherSessionId: z.string().min(1),
+	otherSessionName: z.string()
+});
+var CrossRepoLink = z.strictObject({
+	factId,
+	providerRepo: z.string().min(1),
+	packageName: z.string().min(1),
+	packageDir: z.string(),
+	consumerManifest: repoPath,
+	versionSpec: z.string(),
+	isLocalLink: z.boolean(),
+	providerChangedPathCount: count,
+	importers: cappedPaths,
+	importerCount: count,
+	changedImporterCount: count
+});
+var RepoChangeMap = z.strictObject({
+	name: z.string().min(1),
+	root: z.string().min(1),
+	sessionPathPrefix: z.string(),
+	base: z.string().nullable(),
+	files: z.array(ChangedFile),
+	subsystems: z.array(SubsystemFact),
+	coChangeGaps: z.array(CoChangeGap),
+	hotspots: z.array(HotspotFact),
+	blastRadius: z.array(BlastRadiusFact),
+	untestedFiles: z.array(UntestedFileFact),
+	collisions: z.array(CollisionFact),
+	links: z.array(CrossRepoLink),
+	error: z.string().nullable()
+});
+var NarrativeClaim = z.strictObject({
+	text: z.string().min(1).max(600),
+	factIds: z.array(factId).min(1)
+});
+var ChangeNarrative = z.strictObject({
+	factsHash: z.string().min(1),
+	model: z.string().nullable(),
+	claims: z.array(NarrativeClaim).max(12)
+});
+var NarratorState = z.enum([
+	"disabled",
+	"pending",
+	"ready",
+	"failed"
+]);
+var ChangeMap = z.strictObject({
+	sessionId: z.string().min(1),
+	sig: z.string().nullable(),
+	generatedAt: z.number().finite(),
+	repos: z.array(RepoChangeMap),
+	narrative: ChangeNarrative.nullable(),
+	narratorState: NarratorState,
+	error: z.string().min(1).optional()
+});
+var PLAN_FEEDBACK_MAX_CHARS = 2e4;
+var PLAN_COMMENT_MAX_CHARS = 4e3;
+var PLAN_BODY_CAP_BYTES = 524288;
+var PLAN_HOOK_OUTPUT_MAX_CHARS = 1e4;
+var PLAN_HOOK_EVENT = "permissionrequest-plan";
+var PLAN_RESULT_HOOK_EVENT = "posttooluse-plan";
+var PLAN_TOOL_NAME = "ExitPlanMode";
+var HEADING_SCAN_MAX_CHARS = 4096;
+var ATX_HEADING = /^ {0,3}#{1,6}[ \t]+(.*)$/;
+function capPlanTitle(text) {
+	const trimmed = text.trim();
+	if (trimmed.length <= 120) return trimmed;
+	return trimmed.slice(0, 120);
+}
+function withoutClosingHeadingMarks(text) {
+	const trimmed = text.trimEnd();
+	let textEnd = trimmed.length;
+	while (textEnd > 0 && trimmed[textEnd - 1] === "#") textEnd--;
+	if (textEnd === trimmed.length || textEnd === 0) return trimmed;
+	const charBeforeMarks = trimmed[textEnd - 1];
+	if (charBeforeMarks !== " " && charBeforeMarks !== "	") return trimmed;
+	return trimmed.slice(0, textEnd).trimEnd();
+}
+function headingTitle(line) {
+	const heading = ATX_HEADING.exec(line.slice(0, HEADING_SCAN_MAX_CHARS));
+	if (!heading) return "";
+	return withoutClosingHeadingMarks(heading[1]);
+}
+function planTitle(plan) {
+	const lines = typeof plan === "string" ? plan.split(/\r?\n/) : [];
+	for (const line of lines) {
+		const title = headingTitle(line);
+		if (title.length > 0) return capPlanTitle(title);
+	}
+	return capPlanTitle(lines.find((line) => line.trim().length > 0) ?? "");
+}
+var ExitPlanModeInput = z.object({
+	plan: z.string().min(1),
+	planFilePath: z.string().min(1),
+	agent_id: z.string().min(1).optional(),
+	agent_type: z.string().min(1).optional()
+}).passthrough();
+var ExitPlanModeHookPayload = z.object({
+	tool_name: z.literal(PLAN_TOOL_NAME),
+	tool_input: ExitPlanModeInput,
+	agent_id: z.string().min(1).optional(),
+	agent_type: z.string().min(1).optional()
+}).passthrough();
+var ExitPlanModeRequest = z.object({
+	plan: z.string(),
+	planFilePath: z.string(),
+	agentId: z.string().nullable(),
+	agentType: z.string().nullable()
+});
+function parseExitPlanModeHookPayload(body) {
+	const parsed = ExitPlanModeHookPayload.safeParse(body);
+	if (!parsed.success) return null;
+	const input = parsed.data.tool_input;
+	return {
+		plan: input.plan,
+		planFilePath: input.planFilePath,
+		agentId: parsed.data.agent_id ?? input.agent_id ?? null,
+		agentType: parsed.data.agent_type ?? input.agent_type ?? null
+	};
+}
+var PlanRevision = ExitPlanModeRequest.extend({
+	sessionId: z.string().min(1),
+	revision: z.number().int().positive(),
+	receivedAt: z.number().finite()
+});
+var PLAN_REVIEW_STATE_VALUES = Object.freeze([
+	"open",
+	"released",
+	"decided",
+	"closed"
+]);
+var PlanReviewStateValue = z.enum(PLAN_REVIEW_STATE_VALUES);
+var PLAN_DECISION_KINDS = Object.freeze([
+	"approve",
+	"approve-accept-edits",
+	"revise",
+	"terminal"
+]);
+var PlanDecisionKind = z.enum(PLAN_DECISION_KINDS);
+var PlanSectionComment = z.object({
+	heading: z.string().max(PLAN_COMMENT_MAX_CHARS).nullable(),
+	comment: z.string().min(1).max(PLAN_COMMENT_MAX_CHARS)
+});
+var PlanDecision = z.object({
+	id: z.string().min(1),
+	agentId: z.string().nullable(),
+	revision: z.number().int().positive(),
+	decision: PlanDecisionKind,
+	feedback: z.string().max(PLAN_FEEDBACK_MAX_CHARS).optional(),
+	comments: z.array(PlanSectionComment).max(40).optional(),
+	plan: z.string().min(1).max(PLAN_BODY_CAP_BYTES).optional()
+});
+var PlanRevisionSummary = z.object({
+	revision: z.number().int().positive(),
+	receivedAt: z.number().finite(),
+	chars: z.number().int().nonnegative(),
+	title: z.string()
+});
+var PlanReviewOpenRevision = z.object({
+	revision: z.number().int().positive(),
+	since: z.number().finite()
+});
+var PlanReview = z.object({
+	agentId: z.string().nullable(),
+	agentType: z.string().nullable(),
+	revisions: z.array(PlanRevisionSummary),
+	state: PlanReviewStateValue,
+	openRevision: PlanReviewOpenRevision.nullable(),
+	approvedRevision: z.number().int().positive().nullable(),
+	lastDecision: PlanDecisionKind.nullable()
+});
+z.object({ reviews: z.array(PlanReview) });
+var PlanRevisionBody = z.object({
+	agentId: z.string().nullable(),
+	revision: z.number().int().nonnegative(),
+	plan: z.string(),
+	planFilePath: z.string(),
+	receivedAt: z.number().finite()
+});
+var PlanChangedPush = z.object({
+	id: z.string(),
+	agentId: z.string().nullable(),
+	agentType: z.string().nullable(),
+	revision: z.number().int().positive(),
+	receivedAt: z.number().finite(),
+	state: PlanReviewStateValue,
+	lastDecision: PlanDecisionKind.nullable(),
+	approvedRevision: z.number().int().positive().nullable(),
+	chars: z.number().int().nonnegative(),
+	title: z.string(),
+	hasPlan: z.boolean()
+});
+var PlanDraftPush = z.object({
+	id: z.string(),
+	agentId: z.string().nullable(),
+	planFilePath: z.string(),
+	changedAt: z.number().finite()
+});
+var PlanResponseFrame = z.object({
+	id: z.string(),
+	reviews: z.array(PlanReview),
+	body: PlanRevisionBody.nullable()
+});
+//#endregion
+//#region shared/contracts/trace.ts
+var MAX_RAW_LINE_CHARS = 4e3;
+var TraceRecordBase = z.object({
+	ts: z.number().finite(),
+	uuid: z.string().nullable(),
+	parentUuid: z.string().nullable(),
+	vendorSessionId: z.string().min(1),
+	agentId: z.string().min(1).optional(),
+	agentType: z.string().min(1).optional(),
+	transcriptOffset: z.number().int().nonnegative().optional(),
+	truncated: z.boolean().optional()
+});
+var TraceRecord = z.discriminatedUnion("kind", [
+	TraceRecordBase.extend({
+		kind: z.literal("prompt"),
+		text: z.string()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("expansion"),
+		text: z.string(),
+		toolUseId: z.string().min(1).optional()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("thinking"),
+		text: z.string()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("assistant"),
+		text: z.string()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("tool_call"),
+		toolUseId: z.string().min(1),
+		name: z.string().min(1),
+		input: z.unknown()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("tool_result"),
+		toolUseId: z.string().min(1),
+		content: z.string(),
+		isError: z.boolean(),
+		truncated: z.boolean()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("session"),
+		vendor: z.string().min(1),
+		transcriptPath: z.string().min(1),
+		reason: z.string().min(1).optional()
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("notice"),
+		text: z.string().max(MAX_RAW_LINE_CHARS)
+	}),
+	TraceRecordBase.extend({
+		kind: z.literal("raw"),
+		line: z.string().max(MAX_RAW_LINE_CHARS)
+	})
+]);
+var TraceCheckpoint = z.object({
+	transcriptPath: z.string().min(1),
+	vendorSessionId: z.string().min(1),
+	offset: z.number().int().nonnegative(),
+	ingestedSubagentPaths: z.array(z.string().min(1)),
+	offsetByTranscriptPath: z.record(z.string().min(1), z.number().int().nonnegative()).default({}),
+	subagentOffsetByPath: z.record(z.string().min(1), z.number().int().nonnegative()).default({})
+});
+//#endregion
+//#region shared/contracts/update-journal.ts
+var UpdateChannel = z.enum(["release", "main"]);
+var UpdateRunState = z.enum([
+	"idle",
+	"running",
+	"staged",
+	"succeeded",
+	"failed",
+	"discarded",
+	"interrupted"
+]);
+var UpdateStepId = z.enum([
+	"fetch",
+	"stage",
+	"install",
+	"link-deps",
+	"build"
+]);
+var UpdateStepStatus = z.enum([
+	"pending",
+	"running",
+	"succeeded",
+	"failed"
+]);
+var UpdateJournalStep = z.object({
+	id: UpdateStepId,
+	status: UpdateStepStatus,
+	startedAt: z.number().finite().nullable(),
+	finishedAt: z.number().finite().nullable(),
+	outputTail: z.array(z.string())
+}).strict();
+var UpdateJournal = z.object({
+	state: UpdateRunState,
+	fromSha: z.string().nullable(),
+	toSha: z.string().nullable(),
+	toVersion: z.string().nullable(),
+	channel: UpdateChannel,
+	steps: z.array(UpdateJournalStep),
+	activeStep: UpdateStepId.nullable(),
+	reason: z.string().nullable(),
+	startedAt: z.number().finite().nullable(),
+	finishedAt: z.number().finite().nullable(),
+	failedAtHandOff: z.boolean().optional()
+}).strict();
+var UpdateJournalSummary = UpdateJournal.pick({
+	state: true,
+	activeStep: true,
+	reason: true,
+	startedAt: true,
+	finishedAt: true
+});
+//#endregion
+//#region shared/contracts/control-messages.ts
+var requestId = z.string().nullable().optional();
+var sessionId = z.string();
+function loose(type, shape) {
+	return z.looseObject({
+		type: z.literal(type),
+		...shape
+	});
+}
+function openObject(shape = {}) {
+	return z.looseObject(shape);
+}
+var nullableString = z.string().nullable();
+var timestamp = z.number().finite();
+var optionalTimestamp = timestamp.optional();
+var optionalError = nullableString.optional();
+var opaqueObject = openObject();
+var opaqueArray = z.array(z.unknown());
+var planRevisionNumber = z.number().int().positive();
+var trailSteps = z.array(openObject({
+	at: timestamp,
+	tool: z.string(),
+	detail: z.string()
+}));
+z.object({
+	id: z.string(),
+	label: z.string(),
+	command: z.string(),
+	args: z.array(z.string()),
+	resolvable: z.boolean().nullable()
+}).strict();
+var SessionCardFields = z.object({
+	id: sessionId,
+	session: z.string(),
+	taskTitle: TaskTitle.nullable().optional(),
+	taskTitleIsCustom: z.boolean().optional(),
+	path: z.string(),
+	agent: z.string(),
+	state: SessionState,
+	stateSince: timestamp,
+	skipPerms: z.boolean(),
+	saneYolo: z.boolean(),
+	worktree: z.boolean(),
+	workspace: z.boolean().optional(),
+	resumeSessionId: nullableString,
+	ephemeral: z.boolean().optional()
+});
+var githubIssueRow = z.object({
+	number: z.number().int().positive(),
+	title: z.string(),
+	labels: z.array(z.object({
+		name: z.string(),
+		color: z.string()
+	}).passthrough()),
+	url: z.string(),
+	updatedAt: z.string()
+}).passthrough();
+var IssuesReportPush = z.object({
+	ts: timestamp,
+	projectId: z.string(),
+	issues: z.array(githubIssueRow),
+	error: optionalError
+});
+var DIFF_ANNOTATION_NOTE_MAX_CHARS = 1e3;
+var DIFF_ANNOTATION_PATH_RE = new RegExp(`^[^${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}]+$`);
+var DiffAnnotation = z.strictObject({
+	section: z.enum(["committed", "uncommitted"]),
+	path: z.string().min(1).max(400).regex(DIFF_ANNOTATION_PATH_RE),
+	line: z.number().int().positive(),
+	side: z.enum(["old", "new"]),
+	note: z.string().min(1).max(DIFF_ANNOTATION_NOTE_MAX_CHARS)
+});
+var CONTROL_FRAME_MAX_BYTES = 4096 + 2 * (PLAN_BODY_CAP_BYTES + PLAN_FEEDBACK_MAX_CHARS + 80 * PLAN_COMMENT_MAX_CHARS);
+var UpdateApplyRefusal = z.object({
+	reason: z.string(),
+	message: z.string()
+});
+var InstallFlavor = z.enum([
+	"npm-global",
+	"npx",
+	"clone",
+	"unknown"
+]);
+var updateStatusShape = {
+	updateAvailable: z.boolean(),
+	current: nullableString,
+	latest: nullableString,
+	currentSha: nullableString,
+	latestSha: nullableString,
+	releaseUrl: nullableString,
+	command: z.string(),
+	flavor: InstallFlavor,
+	platform: z.string(),
+	installedBranch: nullableString,
+	upstream: nullableString,
+	isTreeClean: z.boolean().nullable(),
+	lastCheckAt: timestamp,
+	channel: UpdateChannel,
+	behindCount: z.number().int().nonnegative().nullable(),
+	reason: nullableString,
+	journalSummary: UpdateJournalSummary.nullable(),
+	applyRefusal: UpdateApplyRefusal.nullable()
+};
+z.object(updateStatusShape);
+Object.freeze([
+	"add-session",
+	"list-conversations",
+	"resume-conversation",
+	"remove-session",
+	"rename-session",
+	"set-session-title",
+	"reorder-sessions",
+	"ping",
+	"get-settings",
+	"update-settings",
+	"scan-repo-roots",
+	"list-agents",
+	"get-posthog-report",
+	"posthog-open-session",
+	"request-issues",
+	"open-issue-session",
+	"posthog-issue-action",
+	"team-review-action",
+	"benchmark-action",
+	"my-pr-merge",
+	"my-pr-keep-mergeable",
+	"my-pr-merge-when-ready",
+	"reviews-refresh",
+	"posthog-archive-investigation",
+	"request-usage-report",
+	"request-hooks-report",
+	"save-hook",
+	"delete-hook",
+	"kill",
+	"start-session",
+	"restart",
+	"force-restart",
+	"dismiss",
+	"sleep",
+	"wake",
+	"merge-session",
+	"finish-session",
+	"merge-continue-session",
+	"discard-session-worktree",
+	"resolve-session-merge",
+	"request-session-diff",
+	"request-change-map",
+	"send-diff-annotations",
+	"request-branch-sync",
+	"resync-branch",
+	"debug-state",
+	"session-trace",
+	"session-plan",
+	"plan-decision",
+	"shutdown",
+	"restart-server",
+	"focus-change",
+	"request-health-snapshot",
+	"update-check",
+	"update-apply",
+	"client-error"
+]);
+var ClientErrorReport = z.object({
+	name: z.string().max(128),
+	stack: z.string().max(8192)
+}).strict();
+var idOnlyClientTypes = [
+	"remove-session",
+	"kill",
+	"start-session",
+	"restart",
+	"force-restart",
+	"dismiss",
+	"sleep",
+	"wake",
+	"merge-session",
+	"finish-session",
+	"merge-continue-session",
+	"discard-session-worktree",
+	"resolve-session-merge",
+	"request-session-diff",
+	"request-change-map",
+	"request-branch-sync",
+	"resync-branch",
+	"debug-state"
+];
+function idOnlyClientVariant(type) {
+	return loose(type, {
+		id: sessionId,
+		force: z.unknown().optional()
+	});
+}
+var idOnlyClientVariants = idOnlyClientTypes.map(idOnlyClientVariant);
+var clientVariants = [
+	loose("add-session", {
+		name: z.string(),
+		path: z.string(),
+		repos: z.array(z.string()).optional(),
+		agent: z.string().optional(),
+		dangerouslySkipPermissions: z.boolean().optional()
+	}),
+	loose("list-conversations", {
+		id: sessionId,
+		requestId
+	}),
+	loose("resume-conversation", {
+		id: sessionId,
+		conversationId: z.string()
+	}),
+	loose("rename-session", {
+		id: sessionId,
+		newName: z.string()
+	}),
+	loose("set-session-title", {
+		id: sessionId,
+		title: TaskTitle
+	}),
+	loose("reorder-sessions", { order: z.array(sessionId) }),
+	loose("ping", { requestId }),
+	loose("get-settings", { requestId }),
+	loose("update-settings", {
+		settings: z.record(z.string(), z.unknown()),
+		requestId
+	}),
+	loose("scan-repo-roots", { requestId }),
+	loose("list-agents", { requestId }),
+	loose("get-posthog-report", {
+		issueId: z.union([z.string(), z.number()]),
+		requestId
+	}),
+	loose("posthog-open-session", {
+		projectId: z.union([z.string(), z.number()]),
+		issueId: z.union([z.string(), z.number()]),
+		requestId
+	}),
+	loose("request-issues", {
+		requestId,
+		projectId: z.string()
+	}),
+	loose("open-issue-session", {
+		requestId,
+		projectId: z.string(),
+		issueNumber: z.number().int().positive()
+	}),
+	loose("posthog-issue-action", {
+		projectId: z.union([z.string(), z.number()]),
+		issueId: z.union([z.string(), z.number()]),
+		action: z.string(),
+		requestId
+	}),
+	loose("team-review-action", {
+		...TeamReviewActionRequest.shape,
+		requestId
+	}),
+	loose("benchmark-action", {
+		...BenchmarkActionRequest.shape,
+		requestId
+	}),
+	loose("my-pr-merge", {
+		...MyPrMergeRequest.shape,
+		requestId
+	}),
+	loose("my-pr-keep-mergeable", {
+		...MyPrKeepMergeableRequest.shape,
+		requestId
+	}),
+	loose("my-pr-merge-when-ready", {
+		...MyPrMergeWhenReadyRequest.shape,
+		requestId
+	}),
+	loose("reviews-refresh", {
+		...ReviewsRefreshRequest.shape,
+		requestId
+	}),
+	loose("posthog-archive-investigation", {
+		id: z.unknown().optional(),
+		requestId
+	}),
+	loose("request-usage-report", {
+		requestId,
+		days: z.unknown().optional(),
+		force: z.unknown().optional()
+	}),
+	loose("request-hooks-report", { requestId }),
+	loose("send-diff-annotations", {
+		id: sessionId,
+		annotations: z.array(DiffAnnotation).min(1).max(50),
+		requestId
+	}),
+	loose("save-hook", {
+		hook: z.record(z.string(), z.unknown()),
+		requestId
+	}),
+	loose("delete-hook", {
+		id: z.string(),
+		requestId
+	}),
+	loose("shutdown"),
+	loose("restart-server"),
+	loose("focus-change", { focused: z.boolean() }),
+	loose("request-health-snapshot"),
+	loose("update-check"),
+	loose("update-apply", {
+		restartWhenStaged: z.boolean().optional(),
+		confirmedSessionIds: z.array(z.string().min(1)).max(1e3).optional()
+	}),
+	loose("session-trace", {
+		id: sessionId,
+		after: z.number().int().nonnegative().default(0),
+		endingAt: z.union([z.number().int().nonnegative(), z.literal("tail")]).optional()
+	}),
+	loose("session-plan", {
+		id: sessionId,
+		agentId: nullableString,
+		revision: planRevisionNumber.optional(),
+		draft: z.boolean().optional()
+	}),
+	loose("plan-decision", PlanDecision.shape),
+	loose("client-error", ClientErrorReport.shape),
+	...idOnlyClientVariants
+];
+var ClientMessage = z.discriminatedUnion("type", clientVariants);
+Object.freeze([
+	"snapshot",
+	"hooks-report",
+	"save-hook-result",
+	"delete-hook-result",
+	"hooks-updated",
+	"state-change",
+	"session-added",
+	"session-removed",
+	"session-renamed",
+	"session-title",
+	"session-modified",
+	"session-git",
+	"session-agents",
+	"session-wakeup",
+	"session-prompt",
+	"session-sleep",
+	"session-wake",
+	"session-merge-status",
+	"session-worktree-blocked",
+	"session-worktree-warning",
+	"session-worktree-ready",
+	"session-diff",
+	"change-map",
+	"send-diff-annotations-result",
+	"branch-sync-status",
+	"session-changed",
+	"post-turn-result",
+	"debug-state-response",
+	"session-trace-response",
+	"session-trace-changed",
+	"session-plan-changed",
+	"session-plan-draft",
+	"session-plan-response",
+	"notify",
+	"update-status",
+	"update-progress",
+	"error",
+	"session-error",
+	"settings",
+	"settings-error",
+	"settings-updated",
+	"pong",
+	"agents-listed",
+	"repo-roots-scanned",
+	"conversations",
+	"resume-conversation-ack",
+	"health-snapshot",
+	"posthog-status",
+	"posthog-investigation-activity",
+	"posthog-investigation-finished",
+	"posthog-report",
+	"posthog-open-session-result",
+	"issues-report",
+	"open-issue-session-result",
+	"posthog-issue-action-result",
+	"team-review-action-result",
+	"benchmark-action-result",
+	"my-pr-merge-result",
+	"my-pr-keep-mergeable-result",
+	"my-pr-merge-when-ready-result",
+	"reviews-refresh-result",
+	"posthog-archive-investigation-result",
+	"team-review-status",
+	"benchmark-status",
+	"my-prs-status",
+	"branch-gc-status",
+	"usage-sessions",
+	"usage-report",
+	"plan-limits",
+	"usage-budget-alert",
+	"visions-findings",
+	"visions-comments",
+	"visions-hand",
+	"visions-intent",
+	"visions-fix",
+	"visions-snapshot",
+	"ingest-activity",
+	"ingest-snapshot",
+	"client-trust",
+	"sessions-reordered",
+	"shutting-down",
+	"restarting"
+]);
+var serverVariants = [
+	loose("snapshot", {
+		sessions: z.array(SessionSnapshot),
+		serverBuild: nullableString
+	}),
+	loose("hooks-report", {
+		requestId,
+		ts: optionalTimestamp,
+		hooks: z.array(opaqueObject).optional(),
+		builtin: z.array(opaqueObject).optional(),
+		events: z.array(openObject({
+			name: z.string(),
+			matcher: nullableString,
+			description: z.string(),
+			http: z.boolean().optional()
+		})).optional(),
+		projects: z.array(openObject({
+			id: z.string(),
+			name: z.string(),
+			agent: z.string()
+		})).optional(),
+		limits: openObject({ maxTimeoutSec: z.number().int().positive() }).optional(),
+		error: optionalError
+	}),
+	loose("save-hook-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		hook: opaqueObject.optional()
+	}),
+	loose("delete-hook-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		id: z.string().optional()
+	}),
+	loose("hooks-updated", { count: z.number().int().nonnegative() }),
+	loose("state-change", {
+		id: sessionId,
+		session: z.string(),
+		from: SessionState,
+		to: SessionState,
+		event: z.string(),
+		timestamp,
+		skipPerms: z.boolean().optional(),
+		saneYolo: z.boolean().optional(),
+		hasEndedTurn: z.boolean().optional()
+	}),
+	loose("session-added", SessionCardFields.shape),
+	loose("session-modified", SessionCardFields.shape),
+	loose("session-removed", {
+		id: sessionId,
+		session: z.string()
+	}),
+	loose("session-renamed", {
+		id: sessionId,
+		oldName: z.string(),
+		newName: z.string()
+	}),
+	loose("session-title", {
+		id: sessionId,
+		taskTitle: TaskTitle.nullable(),
+		isCustom: z.boolean()
+	}),
+	loose("session-git", {
+		id: sessionId,
+		worktree: z.boolean()
+	}),
+	loose("session-agents", {
+		id: sessionId,
+		activeAgents: z.number().int().nonnegative(),
+		awaitingBackgroundTasks: z.boolean(),
+		timestamp
+	}),
+	loose("session-wakeup", {
+		id: sessionId,
+		pendingWakeup: PendingWakeup.nullable(),
+		timestamp
+	}),
+	loose("session-prompt", {
+		id: sessionId,
+		pendingPromptKind: nullableString,
+		pendingPromptDetail: PendingPromptDetail.nullable().optional(),
+		timestamp
+	}),
+	loose("session-sleep"),
+	loose("session-wake"),
+	loose("session-merge-status", {
+		id: sessionId,
+		mergeStatus: z.string(),
+		reason: nullableString,
+		parked: z.boolean(),
+		timestamp
+	}),
+	loose("session-worktree-blocked", {
+		id: sessionId,
+		session: z.string(),
+		branch: nullableString,
+		notice: nullableString,
+		timestamp
+	}),
+	loose("session-worktree-warning", {
+		id: sessionId,
+		session: z.string(),
+		branch: nullableString,
+		notice: nullableString,
+		timestamp
+	}),
+	loose("session-worktree-ready", {
+		id: sessionId,
+		session: z.string(),
+		branch: nullableString,
+		base: nullableString,
+		timestamp
+	}),
+	loose("session-diff", {
+		id: sessionId,
+		committed: openObject({
+			stat: z.string(),
+			diff: z.string()
+		}),
+		uncommitted: openObject({
+			stat: z.string(),
+			diff: z.string()
+		}),
+		hasCommits: z.boolean()
+	}),
+	loose("change-map", {
+		id: sessionId,
+		map: ChangeMap
+	}),
+	loose("send-diff-annotations-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		pending: z.boolean().optional()
+	}),
+	loose("branch-sync-status", {
+		id: sessionId,
+		branch: nullableString,
+		upstream: nullableString,
+		state: z.string(),
+		ahead: z.number().int().nonnegative(),
+		behind: z.number().int().nonnegative(),
+		fetched: z.boolean().nullable(),
+		action: z.string().optional(),
+		error: optionalError
+	}),
+	loose("session-changed", { id: sessionId }),
+	loose("post-turn-result", {
+		id: sessionId,
+		mode: z.string(),
+		skipped: nullableString,
+		filesFixed: z.number().int().nonnegative(),
+		findings: z.array(openObject({
+			file: z.string(),
+			rule: z.string(),
+			count: z.number().int().nonnegative()
+		})),
+		timestamp
+	}),
+	loose("debug-state-response", {
+		id: sessionId,
+		payload: opaqueObject
+	}),
+	loose("session-trace-response", {
+		id: sessionId,
+		records: z.array(TraceRecord),
+		start: z.number().int().nonnegative(),
+		next: z.number().int().nonnegative(),
+		reset: z.boolean(),
+		path: z.string()
+	}),
+	loose("session-trace-changed", { id: sessionId }),
+	loose("session-plan-changed", PlanChangedPush.shape),
+	loose("session-plan-draft", PlanDraftPush.shape),
+	loose("session-plan-response", PlanResponseFrame.shape),
+	loose("notify", {
+		session: z.string(),
+		category: z.string(),
+		message: z.string(),
+		escalationCount: z.number().int().nonnegative(),
+		kind: z.literal("plan").optional()
+	}),
+	loose("update-status", updateStatusShape),
+	loose("update-progress", { journal: UpdateJournal }),
+	loose("error", {
+		id: sessionId.optional(),
+		message: z.string(),
+		requestId,
+		scope: z.string().optional()
+	}),
+	loose("session-error", {
+		id: sessionId.optional(),
+		session: z.string(),
+		message: z.string(),
+		scope: z.string().optional()
+	}),
+	loose("settings", {
+		settings: opaqueObject,
+		requestId
+	}),
+	loose("settings-error", {
+		message: z.string(),
+		requestId
+	}),
+	loose("settings-updated", {
+		settings: opaqueObject,
+		requestId
+	}),
+	loose("pong", { requestId }),
+	loose("agents-listed", {
+		requestId,
+		agents: z.array(openObject({
+			id: z.string(),
+			label: z.string(),
+			resolvable: z.boolean()
+		}))
+	}),
+	loose("repo-roots-scanned", {
+		requestId,
+		directories: z.array(openObject({
+			root: z.string(),
+			projects: z.array(openObject({
+				name: z.string(),
+				path: z.string()
+			}))
+		})),
+		error: z.string().optional()
+	}),
+	loose("conversations", {
+		requestId,
+		id: nullableString,
+		current: nullableString.optional(),
+		conversations: z.array(openObject({
+			id: z.string(),
+			title: z.string(),
+			cwd: z.string(),
+			worktreePath: z.string(),
+			worktreeName: z.string(),
+			gitBranch: nullableString,
+			mtime: timestamp
+		})),
+		error: z.string().optional()
+	}),
+	loose("resume-conversation-ack", {
+		id: sessionId.optional(),
+		resumeSessionId: nullableString.optional(),
+		ok: z.boolean(),
+		error: z.string().optional(),
+		requestId
+	}),
+	loose("health-snapshot", { stats: opaqueObject }),
+	loose("posthog-status", {
+		ts: timestamp,
+		intervalMinutes: z.number(),
+		projects: z.array(opaqueObject),
+		investigations: z.array(opaqueObject)
+	}),
+	loose("posthog-investigation-activity", {
+		projectId: z.union([z.string(), z.number()]),
+		issueId: z.string(),
+		inFlight: z.literal(true),
+		startedAt: timestamp.nullable(),
+		trail: trailSteps
+	}),
+	loose("posthog-investigation-finished", {
+		projectId: z.union([z.string(), z.number()]),
+		issueId: z.string(),
+		verdict: z.string(),
+		summaryLine: nullableString,
+		startedAt: timestamp.nullable(),
+		trail: trailSteps
+	}),
+	loose("posthog-report", {
+		requestId,
+		ok: z.boolean(),
+		found: z.boolean(),
+		issueId: nullableString,
+		format: z.string().optional(),
+		content: z.string().optional(),
+		message: z.string().optional(),
+		error: z.string().optional()
+	}),
+	loose("posthog-open-session-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		sessionId: z.string().optional(),
+		sessionName: z.string().optional(),
+		pending: z.boolean().optional()
+	}),
+	loose("issues-report", {
+		requestId,
+		...IssuesReportPush.shape
+	}),
+	loose("open-issue-session-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		sessionId: z.string().optional(),
+		sessionName: z.string().optional(),
+		pending: z.boolean().optional()
+	}),
+	loose("posthog-issue-action-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		status: nullableString.optional()
+	}),
+	loose("team-review-action-result", {
+		...TeamReviewActionResult.shape,
+		requestId
+	}),
+	loose("benchmark-action-result", {
+		...BenchmarkActionResult.shape,
+		requestId
+	}),
+	loose("my-pr-merge-result", {
+		...MyPrMergeResult.shape,
+		requestId
+	}),
+	loose("my-pr-keep-mergeable-result", {
+		...MyPrKeepMergeableResult.shape,
+		requestId
+	}),
+	loose("my-pr-merge-when-ready-result", {
+		...MyPrMergeWhenReadyResult.shape,
+		requestId
+	}),
+	loose("reviews-refresh-result", {
+		...ReviewsRefreshResult.shape,
+		requestId
+	}),
+	loose("posthog-archive-investigation-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError
+	}),
+	TeamReviewStatus,
+	BenchmarkStatus,
+	MyPrsStatus,
+	loose("branch-gc-status"),
+	loose("usage-sessions", {
+		ts: timestamp,
+		pricingSource: nullableString,
+		sessions: z.array(openObject({
+			id: sessionId,
+			tokens: z.number(),
+			costUSD: z.number(),
+			officialCostUSD: z.number().nullable().optional()
+		}))
+	}),
+	loose("usage-report", {
+		requestId,
+		ts: optionalTimestamp,
+		tz: z.string().optional(),
+		blockHours: z.number().optional(),
+		totals: opaqueObject.optional(),
+		daily: opaqueArray.optional(),
+		models: opaqueArray.optional(),
+		sessions: opaqueArray.optional(),
+		blocks: opaqueArray.optional(),
+		activeBlock: z.unknown().nullable().optional(),
+		anomaly: z.unknown().nullable().optional(),
+		byLane: z.unknown().optional(),
+		planWindowLanes: z.unknown().nullable().optional(),
+		budget: z.unknown().optional(),
+		savings: z.unknown().optional(),
+		tokenLimit: z.unknown().nullable().optional(),
+		pricing: opaqueObject.optional(),
+		scan: opaqueObject.optional(),
+		warning: optionalError,
+		error: optionalError
+	}),
+	loose("plan-limits", {
+		ts: timestamp,
+		fiveHour: z.unknown().nullable(),
+		sevenDay: z.unknown().nullable(),
+		source: z.string()
+	}),
+	loose("usage-budget-alert", {
+		scope: z.string(),
+		periodKey: z.string(),
+		threshold: z.number(),
+		text: z.string(),
+		ts: timestamp
+	}),
+	loose("visions-findings", {
+		uri: z.string(),
+		diagnostics: opaqueArray,
+		ts: timestamp
+	}),
+	loose("visions-comments", {
+		uri: z.string(),
+		comments: opaqueArray,
+		ts: timestamp
+	}),
+	loose("visions-hand", {
+		uri: z.string(),
+		hand: nullableString,
+		ts: timestamp
+	}),
+	loose("visions-intent", {
+		projectId: nullableString,
+		intent: opaqueObject,
+		ts: timestamp
+	}),
+	loose("visions-fix", {
+		uri: z.string(),
+		fix: opaqueObject,
+		ts: timestamp
+	}),
+	loose("visions-snapshot", {
+		documents: z.array(opaqueObject),
+		intent: opaqueObject,
+		fixes: z.array(opaqueObject),
+		ts: timestamp
+	}),
+	loose("ingest-activity", {
+		events: z.array(opaqueObject),
+		overflow: z.number().int().nonnegative(),
+		ts: timestamp
+	}),
+	loose("ingest-snapshot", {
+		events: z.array(opaqueObject),
+		sources: z.unknown(),
+		ts: timestamp
+	}),
+	loose("client-trust", { trust: z.enum(["local", "remote"]) }),
+	loose("sessions-reordered", { order: z.array(sessionId) }),
+	loose("shutting-down"),
+	loose("restarting")
+];
+z.discriminatedUnion("type", serverVariants);
+var viewerCols = z.number().int().min(1).max(500);
+var viewerRows = z.number().int().min(1).max(200);
+var DataClientMessage = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("input"),
+		data: z.string()
+	}),
+	z.object({
+		type: z.literal("claim"),
+		cols: viewerCols,
+		rows: viewerRows
+	}),
+	z.object({ type: z.literal("unview") })
+]);
+z.object({
+	type: z.literal("pty-size"),
+	cols: viewerCols,
+	rows: viewerRows,
+	seq: z.number().int().nonnegative()
+});
+function decodeJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function parseDataClientMessage(raw) {
+	const parsed = DataClientMessage.safeParse(decodeJson(raw));
+	if (!parsed.success) return null;
+	return parsed.data;
+}
+//#endregion
+//#region shared/contracts/hooks.ts
+var HookPayload = z.record(z.string(), z.unknown());
+var HookEnvelope = z.object({
+	glimmervoidId: z.string().min(1),
+	event: z.string().min(1),
+	token: z.string().nullable().optional(),
+	payload: HookPayload
+});
+z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	event: z.string().min(1),
+	matcher: z.string().optional(),
+	type: z.enum(["command", "http"]),
+	command: z.string().optional(),
+	url: z.string().optional(),
+	timeout: z.number().int().positive().optional(),
+	enabled: z.boolean(),
+	projects: z.array(z.string()).optional()
+}).passthrough();
+//#endregion
+export { MyPrKeepMergeableRequest as $, POSTHOG_TRAFFIC_MULTIPLIER_RANGE as $t, MergedPrListing as A, TeamReviewStatus as At, BrowserConfig as B, BRANCH_GC_INTERVAL_MS_RANGE as Bt, BenchmarkCase as C, ReviewThreadId as Ct, BenchmarkStatus as D, TeamReviewCompareFiles as Dt, BenchmarkRun as E, TeamReviewActionRequest as Et, TELEMETRY_EVENT_SCHEMAS as F, decisionAsIfApprovalRequired as Ft, BRANCH_GC_CONTROL_BOOLEAN_KEYS as G, POSTHOG_INTERVAL_RANGE as Gt, ConfigUpdate as H, KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE as Ht, TELEMETRY_KILL_SWITCH_FLAG as I, hasStandingViewerApproval as It, WorkflowCommentBody as J, POSTHOG_MIN_USERS_RANGE as Jt, BRANCH_GC_CONTROL_NUMERIC_KEYS as K, POSTHOG_INVESTIGATION_TIMEOUT_RANGE as Kt, TelemetryState as L, USAGE_BUDGET_KEYS as Lt, PrCheckoutCaseInput as M, TeamReviewThreadResult as Mt, FeatureFlagsResponse as N, TeamReviewThreadsRepository as Nt, BenchmarkSuite as O, TeamReviewResolveResponse as Ot, PendingCrashReport as P, canApproveAfterComment as Pt, WorkflowsState as Q, POSTHOG_TRAFFIC_MIN_USERS_RANGE as Qt, AGENT_ID_SHAPE_MESSAGE as R, USAGE_COST_MODES as Rt, BenchmarkActionRequest as S, ReviewResult as St, BenchmarkJudgement as T, SearchedPr as Tt, RUNTIME_CONFIG_SCALAR_KEYS as U, POSTHOG_ESCALATION_RANGE as Ut, Config as V, BRANCH_GC_STALE_DAYS_RANGE as Vt, configIssueMessage as W, POSTHOG_FIX_TIMEOUT_RANGE as Wt, WorkflowSearchNode as X, POSTHOG_TRAFFIC_BASELINE_RANGE as Xt, WorkflowLabelName as Y, POSTHOG_RECURRENCE_WINDOW_RANGE as Yt, WorkflowsSettings as Z, POSTHOG_TRAFFIC_COOLDOWN_RANGE as Zt, PlanRevision as _, QueuedReview as _t, DIFF_ANNOTATION_NOTE_MAX_CHARS as a, VISIONS_INTENT_THREAD_TTL_MS_RANGE as an, MyPrSearchResponse as at, ChangeMap as b, ReviewDraft as bt, MAX_RAW_LINE_CHARS as c, MyPrsState as ct, PLAN_BODY_CAP_BYTES as d, DECIDING_REVIEW_STATES as dt, POSTHOG_TRANSIENT_RECURRENCE_RANGE as en, MyPrMergeMethod as et, PLAN_HOOK_EVENT as f, FindingSeverity as ft, PlanDecision as g, PrDetail as gt, PLAN_TOOL_NAME as h, PostingPlan as ht, ClientMessage as i, VISIONS_DISPATCH_TIMEOUT_RANGE as in, MyPrSearchNode as it, MinedPrReviewData as j, TeamReviewThreadCommentsResponse as jt, CommitComparison as k, TeamReviewStateEntry as kt, TraceCheckpoint as l, MyPrsStatus as lt, PLAN_RESULT_HOOK_EVENT as m, GithubReviewState as mt, parseDataClientMessage as n, VISIONS_ACTIVITY_MAX_PER_HOUR_RANGE as nn, MyPrMergeStateResponse as nt, InstallFlavor as o, VISIONS_MAX_PER_HOUR_RANGE as on, MyPrThreadNode as ot, PLAN_HOOK_OUTPUT_MAX_CHARS as p, GithubReviewDecision as pt, BranchGcFileSettings as q, POSTHOG_MAX_CONCURRENT_RANGE as qt, CONTROL_FRAME_MAX_BYTES as r, VISIONS_COOLDOWN_MS_RANGE as rn, MyPrMergeWhenReadyRequest as rt, UpdateJournal as s, VISIONS_QUIET_MS_RANGE as sn, MyPrThreadsResponse as st, HookEnvelope as t, USAGE_INTEGER_RANGES as tn, MyPrMergeRequest as tt, TraceRecord as u, CommitSha as ut, parseExitPlanModeHookPayload as v, ReviewChecksState as vt, BenchmarkId as w, ReviewVerdict as wt, changeMapFactId as x, ReviewFinding as xt, planTitle as y, ReviewComment as yt, BUILTIN_AGENT_IDS as z, USAGE_VENDOR_KEYS as zt };