glimmervoid 0.35.1 → 0.37.0

package/dist/chunks/session-BZbariv5.js

@@ -0,0 +1,1032 @@
+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(),
+	startedAt: z.string().nullish(),
+	checkSuite: z.object({
+		app: z.object({ databaseId: z.number().int().nullish() }).nullish(),
+		workflowRun: z.object({ workflow: z.object({ databaseId: z.number().int().nullish() }) }).nullish()
+	}).nullish()
+});
+var StatusContext = z.object({
+	__typename: z.literal("StatusContext"),
+	context: z.string(),
+	state: z.string()
+});
+var MyPrCheckContext = z.union([CheckRun, StatusContext]);
+var CheckContextsPageInfo = z.object({
+	hasNextPage: z.boolean(),
+	endCursor: z.string().nullable()
+});
+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({
+		id: z.string().regex(NODE_ID_RE).optional(),
+		state: z.enum([
+			"SUCCESS",
+			"FAILURE",
+			"PENDING",
+			"ERROR",
+			"EXPECTED"
+		]).nullable(),
+		contexts: z.object({
+			pageInfo: CheckContextsPageInfo.optional(),
+			nodes: z.array(MyPrCheckContext)
+		})
+	}).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 MyPrCheckContextsResponse = z.object({
+	data: z.object({ node: z.object({ contexts: z.object({
+		pageInfo: CheckContextsPageInfo,
+		nodes: z.array(z.unknown())
+	}).nullable() }).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 CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS = 4e3;
+var CONVERSATION_PERMISSION_HOOK_EVENT = "permissionrequest-conversation";
+var CONVERSATION_TOOL_RESULT_HOOK_EVENT = "posttooluse-conversation";
+var CONVERSATION_QUESTION_MAX_CHARS = 1e3;
+var CONVERSATION_ANSWER_MAX_CHARS = 2e3;
+var ConversationQuestion = z.object({
+	question: z.string().min(1).max(CONVERSATION_QUESTION_MAX_CHARS),
+	header: z.string().max(100).default(""),
+	options: z.array(z.object({
+		label: z.string().min(1).max(200),
+		description: z.string().max(CONVERSATION_QUESTION_MAX_CHARS).default("")
+	})).min(1).max(8),
+	multiSelect: z.boolean().default(false)
+});
+var ConversationApproval = z.object({
+	requestId: z.union([z.string().min(1).max(128), z.number().int()]),
+	kind: z.enum([
+		"command",
+		"fileChange",
+		"permissions",
+		"tool",
+		"question"
+	]),
+	summary: z.string().max(CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS),
+	isSummaryTruncated: z.boolean(),
+	toolName: z.string().max(200).optional(),
+	questions: z.array(ConversationQuestion).min(1).max(4).optional(),
+	alwaysAllowSummary: z.string().max(CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS).optional()
+});
+var ConversationAnswers = z.record(z.string().max(CONVERSATION_QUESTION_MAX_CHARS), z.string().max(CONVERSATION_ANSWER_MAX_CHARS));
+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),
+	isGuarded: 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",
+	"factory-status",
+	"factory-retry"
+];
+var ORCHESTRATOR_AGENT_VERBS = [
+	"dispatch",
+	"reopen",
+	"cancel"
+];
+var AgentFactoryStatusRequest = z.object({ projectId: z.string().trim().min(1).max(128).optional() }).strict();
+var AgentFactoryRetryRequest = z.object({ intentId: z.string().trim().min(1).max(128) }).strict();
+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()),
+	guarded: 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 { repositoryName as $, SshSignReply as A, HEX_SHA_RE as At, MyPrMergeMethod as B, MERGEABLE_LIVE_STATES as Bt, SESSION_DOC_BODY_CAP_BYTES as C, TeamReviewThreadResult as Ct, SessionDoc as D, hasRequiredActionHead as Dt, SSH_SIGN_BODY_CAP_BYTES as E, decisionAsIfApprovalRequired as Et, MyPrAutoRebase as F, repoParts as Ft, MyPrMergeWhenReadyResult as G, MyPrMergeResult as H, STATES as Ht, MyPrCheckContext as I, GithubPollingRefreshRequest as It, MyPrThreadNode as J, MyPrSearchNode as K, MyPrCheckContextsResponse as L, GithubPollingRefreshResult as Lt, TASK_TITLE_CONTROL_CHARACTERS as M, GH_SEGMENT as Mt, TaskTitle as N, NODE_ID_RE as Nt, SessionSnapshot as O, hasStandingViewerApproval as Ot, LinkedPr as P, REPO_SLUG_RE as Pt, SessionPrLinks as Q, MyPrKeepMergeableRequest as R, githubPollingShape as Rt, SESSION_COMMANDS as S, TeamReviewThreadCommentsResponse as St, SIGN_URL_ENV as T, canApproveAfterComment as Tt, MyPrMergeStateResponse as U, MyPrMergeRequest as V, RESTARTABLE_STATES as Vt, MyPrMergeWhenReadyRequest as W, MyPrsState as X, MyPrThreadsResponse as Y, MyPrsStatus as Z, ConversationApprovalDecision as _, TeamReviewActionResult as _t, AgentDispatchRequest as a, PostingPlan as at, PendingWakeup as b, TeamReviewStateEntry as bt, AgentFactoryStatusRequest as c, ReviewChecksState as ct, AgentTicketRequest as d, ReviewFinding as dt, CommitSha as et, CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS as f, ReviewResult as ft, ConversationApproval as g, TeamReviewActionRequest as gt, ConversationAnswers as h, SearchedPr as ht, AgentAttentionRequest as i, GithubReviewState as it, SshSignRequest as j, shortSha as jt, SessionState as k, FULL_SHA_RE as kt, AgentLimitsReply as l, ReviewComment as lt, CONVERSATION_TOOL_RESULT_HOOK_EVENT as m, ReviewVerdict as mt, AGENT_URL_ENV as n, FindingSeverity as nt, AgentEditRequest as o, PrDetail as ot, CONVERSATION_PERMISSION_HOOK_EVENT as p, ReviewThreadId as pt, MyPrSearchResponse as q, ASK_USER_QUESTION_TOOL_NAME as r, GithubReviewDecision as rt, AgentFactoryRetryRequest as s, QueuedReview as st, AGENT_API_VERBS as t, DECIDING_REVIEW_STATES as tt, AgentSpawnRequest as u, ReviewDraft as ut, ConversationQuestion as v, TeamReviewCompareFiles as vt, SESSION_DOC_PATH_MAX_CHARS as w, TeamReviewThreadsRepository as wt, RefinedTaskTitle as x, TeamReviewStatus as xt, ORCHESTRATOR_AGENT_VERBS as y, TeamReviewResolveResponse as yt, MyPrKeepMergeableResult as z, KILLABLE_STATES as zt };