glimmervoid 0.35.1 → 0.36.0

package/dist/chunks/session-B8RhqQJe.js

@@ -0,0 +1,986 @@
+import { z } from "zod";
+//#region shared/states.ts
+var STATES = Object.freeze({
+	DORMANT: "DORMANT",
+	INITIALIZING: "INITIALIZING",
+	STARTING: "STARTING",
+	RUNNING: "RUNNING",
+	WAITING: "WAITING",
+	IDLE: "IDLE",
+	COMPLETE: "COMPLETE",
+	DONE: "DONE",
+	FAILED: "FAILED"
+});
+Object.freeze({
+	[STATES.DORMANT]: "Dormant",
+	[STATES.INITIALIZING]: "Preparing",
+	[STATES.STARTING]: "Starting",
+	[STATES.RUNNING]: "Working",
+	[STATES.WAITING]: "Needs Input",
+	[STATES.IDLE]: "Idle",
+	[STATES.COMPLETE]: "Complete",
+	[STATES.DONE]: "Exited",
+	[STATES.FAILED]: "Failed"
+});
+Object.freeze({
+	[STATES.DORMANT]: "○",
+	[STATES.INITIALIZING]: "◌",
+	[STATES.STARTING]: "◐",
+	[STATES.RUNNING]: "●",
+	[STATES.WAITING]: "◆",
+	[STATES.IDLE]: "◍",
+	[STATES.FAILED]: "▲",
+	[STATES.DONE]: "■",
+	[STATES.COMPLETE]: "◇"
+});
+var KILLABLE_STATES = Object.freeze([
+	STATES.INITIALIZING,
+	STATES.STARTING,
+	STATES.RUNNING,
+	STATES.WAITING,
+	STATES.IDLE,
+	STATES.COMPLETE
+]);
+var RESTARTABLE_STATES = Object.freeze([STATES.DONE, STATES.FAILED]);
+var MERGEABLE_LIVE_STATES = Object.freeze([
+	STATES.WAITING,
+	STATES.IDLE,
+	STATES.COMPLETE
+]);
+//#endregion
+//#region shared/contracts/github-polling.ts
+var GithubPollingRetry = z.object({
+	attempt: z.number().int().positive(),
+	limit: z.number().int().positive()
+}).refine((retry) => retry.attempt <= retry.limit);
+var githubPollingShape = {
+	error: z.string().nullable().optional(),
+	nextAttemptAt: z.number().finite().nonnegative().nullable().optional(),
+	retry: GithubPollingRetry.nullable().optional(),
+	isRefreshing: z.boolean().optional(),
+	refreshNotice: z.string().nullable().optional()
+};
+var GithubPollingRefreshRequest = z.object({ lane: z.enum([
+	"my-prs",
+	"team-review",
+	"issues"
+]) });
+var GithubPollingRefreshResult = z.object({
+	ok: z.boolean(),
+	error: z.string().optional()
+});
+//#endregion
+//#region shared/contracts/github-ids.ts
+var GH_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var REPO_SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var NODE_ID_RE = /^[A-Za-z0-9_=-]+$/;
+function repoParts(repo) {
+	const parts = repo.split("/");
+	if (parts.length !== 2 || !parts.every((part) => GH_SEGMENT.test(part))) return null;
+	return [parts[0], parts[1]];
+}
+var HEX_SHA_RE = /^[0-9a-f]{7,40}$/i;
+var FULL_SHA_RE = /^[0-9a-f]{40}$/;
+function shortSha(sha, { chars = 7, validate = false } = {}) {
+	if (typeof sha !== "string" || !sha) return "";
+	if (!validate) return sha.slice(0, chars);
+	const text = sha.trim();
+	if (!HEX_SHA_RE.test(text)) return "";
+	return text.slice(0, chars).toLowerCase();
+}
+//#endregion
+//#region shared/contracts/team-review.ts
+var CommitSha = z.string().regex(FULL_SHA_RE);
+var repoSlug = 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,
+	headRefName: z.string().optional(),
+	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");
+}
+var PriorReview = z.object({
+	head: CommitSha,
+	base: CommitSha.optional(),
+	verdict: ReviewVerdict,
+	summary: z.string(),
+	body: z.string(),
+	comments: z.array(ReviewComment),
+	wasPosted: z.boolean()
+});
+var ReviewThreadId = z.string().min(1).max(256).regex(NODE_ID_RE);
+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,
+	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,
+	reviewedBase: CommitSha.optional(),
+	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"
+]);
+function hasRequiredActionHead(request) {
+	return request.action === "discard" || request.head !== void 0;
+}
+var TeamReviewActionRequest = z.object({
+	key: z.string().min(1),
+	head: CommitSha.optional(),
+	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"]
+}).refine(hasRequiredActionHead, {
+	message: "only discard may omit head",
+	path: ["head"]
+});
+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,
+	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,
+	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({
+	...githubPollingShape,
+	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 = z.number().int().nonnegative();
+var repositoryName = z.string().regex(REPO_SLUG_RE);
+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,
+	consecutiveAttempts: z.number().int().min(1).optional()
+});
+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 LinkedPr = z.strictObject({
+	repo: repositoryName,
+	number: z.number().int().positive(),
+	url: z.url(),
+	source: z.enum([
+		"hook",
+		"sha",
+		"manual"
+	]),
+	linkedAt: z.number().finite()
+});
+var SessionPrLinks = z.strictObject({
+	links: z.array(LinkedPr).max(20),
+	unlinkedKeys: z.array(pullRequestKey).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 MyPrMergeQueueFailure = z.object({
+	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
+	}),
+	unresolvedThreads: nonnegativeInteger,
+	threads: z.array(MyPrThread),
+	behindBy: nonnegativeInteger.nullable(),
+	reviewRequests: z.array(z.object({
+		name: z.string(),
+		isTeam: z.boolean(),
+		avatarUrl: z.string().nullable()
+	})),
+	approvals: nonnegativeInteger,
+	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(),
+	mergeQueueFailure: MyPrMergeQueueFailure.optional()
+}).refine((pr) => pr.key === `${pr.repo}#${pr.number}`);
+var MyPrsStatus = z.object({
+	...githubPollingShape,
+	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(NODE_ID_RE),
+	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,
+		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,
+			nodes: z.array(z.unknown())
+		}),
+		merged: z.object({
+			issueCount: nonnegativeInteger,
+			nodes: z.array(z.unknown())
+		})
+	}),
+	errors: z.array(z.unknown()).optional()
+});
+var TASK_TITLE_CONTROL_CHARACTERS = /[\x00-\x1f\x7f-\x9f]/;
+var TaskTitle = z.string().refine((title) => !TASK_TITLE_CONTROL_CHARACTERS.test(title)).trim().max(120);
+var RefinedTaskTitle = z.object({ title: z.string().nullable() }).strict();
+var SessionState = z.enum(STATES);
+var PendingWakeup = z.object({
+	at: z.number().finite().nullable(),
+	kind: z.string(),
+	reason: z.string().nullable()
+}).passthrough();
+var ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
+var ConversationApproval = z.object({
+	requestId: z.union([z.string().min(1).max(128), z.number().int()]),
+	kind: z.enum([
+		"command",
+		"fileChange",
+		"permissions"
+	]),
+	summary: z.string().max(300),
+	isSummaryTruncated: z.boolean()
+});
+var ConversationApprovalDecision = z.enum([
+	"accept",
+	"acceptForSession",
+	"decline"
+]);
+var SessionSnapshot = z.object({
+	id: z.string(),
+	name: z.string(),
+	taskTitle: TaskTitle.nullable().default(null),
+	taskTitleIsCustom: z.boolean().default(false),
+	path: z.string(),
+	agent: z.string(),
+	state: SessionState,
+	stateSince: z.number(),
+	sleeping: z.boolean(),
+	dangerouslySkipPermissions: z.boolean(),
+	saneYolo: z.boolean().default(false),
+	ephemeral: z.boolean(),
+	isWorktree: z.boolean(),
+	isWorkspace: z.boolean().default(false),
+	resumeSessionId: z.string().nullable(),
+	activeAgents: z.number().int().nonnegative(),
+	awaitingBackgroundTasks: z.boolean(),
+	isCompacting: z.boolean().default(false),
+	pendingWakeup: PendingWakeup.nullable(),
+	pendingPromptKind: z.string().nullable(),
+	conversationApproval: ConversationApproval.nullable().default(null),
+	hasConversationBridge: z.boolean().default(false),
+	isConversationViewOn: z.boolean().default(false),
+	hasPlan: z.boolean().default(false),
+	mergeStatus: z.string().nullable(),
+	mergeReason: z.string().nullable(),
+	worktreeNotice: z.string().nullable(),
+	effectiveBase: z.string().nullable(),
+	linkedPrs: z.array(LinkedPr).default([]),
+	auditLog: z.array(z.unknown())
+}).passthrough();
+var AGENT_URL_ENV = "GLIMMERVOID_AGENT_URL";
+var SIGN_URL_ENV = "GLIMMERVOID_SIGN_URL";
+var SSH_SIGN_BODY_CAP_BYTES = 1048576;
+var SshSignRequest = z.object({
+	namespace: z.literal("git", { error: "namespace must be git" }),
+	publicKey: z.string({ error: "publicKey must be a string" }).min(1, { error: "publicKey must not be empty" }).max(16384, { error: "publicKey must be at most 16384 characters" }),
+	payload: z.base64({ error: "payload must be base64" })
+}).strict();
+var SshSignReply = z.union([z.object({
+	ok: z.literal(true),
+	signature: z.string()
+}).strict(), z.object({
+	ok: z.literal(false),
+	error: z.string()
+}).strict()]);
+var AGENT_API_VERBS = [
+	"spawn",
+	"attention",
+	"board",
+	"dispatch",
+	"reopen",
+	"cancel",
+	"push",
+	"edit",
+	"limits"
+];
+var ORCHESTRATOR_AGENT_VERBS = [
+	"dispatch",
+	"reopen",
+	"cancel"
+];
+var AgentSpawnRequest = z.object({
+	prompt: z.string({ error: "prompt must be a string" }).min(1, { error: "prompt must not be empty" }).max(2e4, { error: "prompt must be at most 20000 characters" }).refine((prompt) => !prompt.trimStart().startsWith("-"), { message: "prompt must not start with a dash, which the agent CLI would read as an option" }),
+	name: z.string({ error: "name must be a string" }).min(1, { error: "name must not be empty" }).max(200, { error: "name must be at most 200 characters" }).optional(),
+	agent: z.string({ error: "agent must be a string" }).min(1, { error: "agent must not be empty" }).max(40, { error: "agent must be at most 40 characters" }).optional()
+}).strict();
+var AgentAttentionRequest = z.object({ note: z.string({ error: "note must be a string" }).min(1, { error: "note must not be empty" }).max(500, { error: "note must be at most 500 characters" }) }).strict();
+z.union([z.object({
+	ok: z.literal(true),
+	pending: z.boolean()
+}).strict(), z.object({
+	ok: z.literal(false),
+	error: z.string()
+}).strict()]);
+z.object({
+	id: SessionSnapshot.shape.id,
+	name: SessionSnapshot.shape.name,
+	agent: SessionSnapshot.shape.agent,
+	state: SessionSnapshot.shape.state,
+	ephemeral: SessionSnapshot.shape.ephemeral
+}).strict();
+var SESSION_DOC_BODY_CAP_BYTES = 262144;
+var SESSION_DOC_PATH_MAX_CHARS = 4096;
+var AgentEditRequest = z.object({ path: z.string({ error: "path must be a string" }).min(1, { error: "path must not be empty" }).max(SESSION_DOC_PATH_MAX_CHARS, { error: `path must be at most ${SESSION_DOC_PATH_MAX_CHARS} characters` }) }).strict();
+var SessionDoc = z.object({
+	path: z.string(),
+	name: z.string(),
+	surfacedAt: z.number().finite()
+}).strict();
+var SESSION_COMMANDS = [
+	"push",
+	"spawn",
+	"attention",
+	"board",
+	"edit"
+];
+var AgentLimitsReply = z.object({
+	commands: z.array(z.object({
+		name: z.enum(SESSION_COMMANDS),
+		answers: z.boolean(),
+		reason: z.string().optional()
+	}).strict()),
+	sandboxed: z.boolean(),
+	deadEnds: z.array(z.object({
+		blocked: z.string(),
+		route: z.string()
+	}).strict())
+}).strict().extend({ ok: z.literal(true) }).strict();
+var AgentDispatchRequest = z.object({
+	workId: z.string().regex(/^wrk-[0-9a-f]{16}$/).optional(),
+	readyIntent: z.string().regex(/^wrk-[0-9a-f]{16}$/).optional()
+}).strict().refine((request) => Boolean(request.workId) !== Boolean(request.readyIntent), "Expected exactly one work id or ready intent");
+var AgentTicketRequest = z.object({ workId: z.string({ error: "workId must be a string" }).regex(/^wrk-[0-9a-f]{16}$/, { error: "workId must match wrk-[0-9a-f]{16}" }) }).strict();
+z.discriminatedUnion("ok", [z.object({
+	ok: z.literal(true),
+	workId: z.string(),
+	state: z.enum(["open", "cancelled"])
+}), z.object({
+	ok: z.literal(false),
+	reason: z.string()
+})]);
+//#endregion
+export { ReviewChecksState as $, MyPrKeepMergeableResult as A, KILLABLE_STATES as At, MyPrThreadsResponse as B, SshSignReply as C, GH_SEGMENT as Ct, LinkedPr as D, GithubPollingRefreshRequest as Dt, TaskTitle as E, repoParts as Et, MyPrMergeWhenReadyRequest as F, CommitSha as G, MyPrsStatus as H, MyPrMergeWhenReadyResult as I, GithubReviewDecision as J, DECIDING_REVIEW_STATES as K, MyPrSearchNode as L, MyPrMergeRequest as M, RESTARTABLE_STATES as Mt, MyPrMergeResult as N, STATES as Nt, MyPrAutoRebase as O, GithubPollingRefreshResult as Ot, MyPrMergeStateResponse as P, QueuedReview as Q, MyPrSearchResponse as R, SessionState as S, shortSha as St, TASK_TITLE_CONTROL_CHARACTERS as T, REPO_SLUG_RE as Tt, SessionPrLinks as U, MyPrsState as V, repositoryName as W, PostingPlan as X, GithubReviewState as Y, PrDetail as Z, SESSION_DOC_PATH_MAX_CHARS as _, decisionAsIfApprovalRequired as _t, AgentDispatchRequest as a, ReviewVerdict as at, SessionDoc as b, FULL_SHA_RE as bt, AgentSpawnRequest as c, TeamReviewActionResult as ct, ConversationApprovalDecision as d, TeamReviewStateEntry as dt, ReviewComment as et, ORCHESTRATOR_AGENT_VERBS as f, TeamReviewStatus as ft, SESSION_DOC_BODY_CAP_BYTES as g, canApproveAfterComment as gt, SESSION_COMMANDS as h, TeamReviewThreadsRepository as ht, AgentAttentionRequest as i, ReviewThreadId as it, MyPrMergeMethod as j, MERGEABLE_LIVE_STATES as jt, MyPrKeepMergeableRequest as k, githubPollingShape as kt, AgentTicketRequest as l, TeamReviewCompareFiles as lt, RefinedTaskTitle as m, TeamReviewThreadResult as mt, AGENT_URL_ENV as n, ReviewFinding as nt, AgentEditRequest as o, SearchedPr as ot, PendingWakeup as p, TeamReviewThreadCommentsResponse as pt, FindingSeverity as q, ASK_USER_QUESTION_TOOL_NAME as r, ReviewResult as rt, AgentLimitsReply as s, TeamReviewActionRequest as st, AGENT_API_VERBS as t, ReviewDraft as tt, ConversationApproval as u, TeamReviewResolveResponse as ut, SIGN_URL_ENV as v, hasRequiredActionHead as vt, SshSignRequest as w, NODE_ID_RE as wt, SessionSnapshot as x, HEX_SHA_RE as xt, SSH_SIGN_BODY_CAP_BYTES as y, hasStandingViewerApproval as yt, MyPrThreadNode as z };