glimmervoid 0.30.0 → 0.31.0

package/dist/chunks/contracts-3LkrilQX.js

@@ -0,0 +1,2078 @@
+import { c as PendingPromptDetail, f as SessionSnapshot, h as TaskTitle, p as SessionState, u as PendingWakeup } from "./session-fc4pFbon.js";
+import { D as MyPrMergeWhenReadyRequest, Dt as CoherenceRisk, Et as CoherenceReadiness, F as CommitSha, O as MyPrMergeWhenReadyResult, P as MyPrsStatus, Q as TeamReviewActionResult, S as MyPrKeepMergeableResult, T as MyPrMergeResult, Tt as CoherenceOrient, Z as TeamReviewActionRequest, _t as ReviewsRefreshResult, gt as ReviewsRefreshRequest, jt as CoherenceWorkState, mt as REPO_SLUG_RE, n as BUILTIN_AGENT_IDS, nt as TeamReviewStatus, vt as reviewsPollingShape, w as MyPrMergeRequest, x as MyPrKeepMergeableRequest } from "./config-W1Sv-iPK.js";
+import { z } from "zod";
+//#region shared/contracts/factory.ts
+var FactoryIssue = z.object({
+	issueId: z.string().min(1),
+	firstSeenMs: z.number().finite(),
+	framePaths: z.array(z.string())
+});
+var FactoryWatchEntry = z.object({
+	workId: z.string().min(1),
+	intentId: z.string().min(1),
+	projectId: z.string().min(1),
+	mergedSha: z.string().regex(/^[a-f0-9]{40,64}$/),
+	mergedAt: z.iso.datetime(),
+	writeScopes: z.array(z.string()),
+	breaches: z.array(FactoryIssue).optional()
+});
+var FactoryHogQLResponse = z.looseObject({ results: z.array(z.unknown()) });
+var FactoryIssueQueryRow = z.object({
+	issueId: z.string().min(1),
+	firstSeen: z.string().min(1),
+	framePaths: z.array(z.string())
+});
+var FactoryConsequences = z.looseObject({ records: z.array(z.looseObject({
+	from: z.object({
+		kind: z.string(),
+		id: z.string()
+	}),
+	relation: z.string(),
+	to: z.object({
+		kind: z.string(),
+		id: z.string()
+	}),
+	session: z.string().optional(),
+	evidence: z.string().optional()
+})) });
+var FactoryProjectState = z.object({
+	projectId: z.string(),
+	projectName: z.string(),
+	headSha: z.string().nullable(),
+	paused: z.boolean(),
+	orchestrator: z.object({
+		sessionId: z.string(),
+		intentId: z.string(),
+		state: SessionState
+	}).nullable(),
+	liveWorkers: z.array(z.object({
+		workId: z.string(),
+		sessionId: z.string()
+	})).optional(),
+	reviewing: z.array(z.string()).optional(),
+	watches: z.array(FactoryWatchEntry).optional(),
+	note: z.string().nullable().optional(),
+	spentTodayUsd: z.number().finite().nonnegative().optional(),
+	dailyBudgetUsd: z.number().finite().nonnegative().nullable().optional(),
+	verifierIntentIds: z.array(z.string()).optional(),
+	error: z.string().nullable(),
+	heading: z.object({
+		action: CoherenceOrient.shape.action,
+		reasons: z.array(z.string())
+	}),
+	orders: z.array(z.object({
+		id: z.string(),
+		objective: z.string(),
+		openedAt: z.iso.datetime(),
+		criteria: z.array(z.string()),
+		boundary: z.string(),
+		risk: CoherenceRisk,
+		state: CoherenceWorkState,
+		readiness: CoherenceReadiness,
+		parent: z.string().nullable(),
+		dependsOn: z.array(z.string()),
+		writeScopes: z.array(z.string()),
+		owner: z.string().nullable(),
+		lastEvent: z.object({
+			event: z.string(),
+			at: z.string(),
+			session: z.string()
+		}).nullable()
+	})),
+	conflicts: z.array(z.object({
+		left: z.string(),
+		right: z.string(),
+		scope: z.string()
+	})),
+	unverifiedCompletedWork: z.array(z.string())
+});
+var FactoryState = z.object({
+	type: z.literal("factory-state"),
+	ts: z.number().finite(),
+	projects: z.array(FactoryProjectState)
+});
+var FACTORY_ERROR_MAX_CHARS = 16384;
+function isSingleFactoryPathSegment(value) {
+	return value !== "." && value !== ".." && !/[/\\]/.test(value);
+}
+var projectId = z.string().trim().min(1).max(128).refine(isSingleFactoryPathSegment, "Invalid factory project id");
+var intentText = z.string().trim().min(1).max(4096);
+var scopeText = z.string().trim().min(1).max(1024);
+var FACTORY_INTENT_TICKET_LIMIT = 32;
+var ticketKey = z.string().trim().min(1).max(64);
+var FactoryIntentTicket = z.object({
+	id: ticketKey,
+	objective: intentText,
+	criteria: z.array(intentText).min(1).max(12),
+	dependsOn: z.array(ticketKey).max(FACTORY_INTENT_TICKET_LIMIT),
+	writeScopes: z.array(scopeText).min(1).max(32)
+});
+var FactoryQueueIntentRequest = z.object({
+	projectId,
+	objective: intentText,
+	criteria: z.array(intentText).min(1).max(12),
+	risk: CoherenceRisk,
+	boundary: intentText,
+	writeScopes: z.array(scopeText).max(32),
+	tickets: z.array(FactoryIntentTicket).min(1).max(FACTORY_INTENT_TICKET_LIMIT).optional()
+});
+var FactoryQueueIntentResult = z.object({
+	projectId: z.string().max(128),
+	ok: z.boolean(),
+	workId: z.string().min(1).max(128).optional(),
+	error: z.string().max(FACTORY_ERROR_MAX_CHARS).optional()
+});
+var FactoryControlRequest = z.object({
+	projectId,
+	action: z.enum(["pause", "resume"])
+});
+var FactoryControlResult = z.object({
+	projectId: z.string().max(128),
+	action: FactoryControlRequest.shape.action,
+	ok: z.boolean(),
+	error: z.string().max(FACTORY_ERROR_MAX_CHARS).optional()
+});
+var FactoryReviewVerdict = z.object({
+	pass: z.boolean(),
+	findings: z.array(z.string())
+}).strict();
+var FactoryReviewerOutput = z.object({
+	type: z.literal("result"),
+	subtype: z.literal("success"),
+	is_error: z.literal(false),
+	structured_output: FactoryReviewVerdict
+});
+var FactoryLaneState = z.object({
+	ledgerPath: z.string().min(1).max(4096).nullable(),
+	ledgerBranch: z.string().min(1).max(1024).nullable(),
+	paused: z.boolean(),
+	watch: z.array(FactoryWatchEntry).optional(),
+	trustedVerifications: z.array(z.object({
+		id: z.string().min(1),
+		sha: z.string().regex(/^[a-f0-9]{40,64}$/)
+	})).optional(),
+	trustedIntentCloses: z.array(z.string().min(1)).optional(),
+	trustedIntentIds: z.array(z.string().min(1)).optional(),
+	intentWriteScopes: z.record(z.string().min(1), z.array(z.string().min(1))).optional(),
+	ticketedIntentIds: z.array(z.string().min(1)).optional(),
+	pendingIntentTickets: z.record(z.string().min(1), z.object({
+		risk: CoherenceRisk,
+		boundary: intentText,
+		tickets: z.array(FactoryIntentTicket).min(1).max(FACTORY_INTENT_TICKET_LIMIT)
+	})).optional(),
+	intentBaseShas: z.record(z.string().min(1), z.string().regex(/^[a-f0-9]{40,64}$/)).optional(),
+	filedBreaches: z.array(z.string().min(1)).optional(),
+	factoryLandedShas: z.array(z.string().regex(/^[a-f0-9]{40,64}$/)).optional()
+});
+var FactoryWorkerEvent = z.object({
+	workId: z.string().min(1),
+	event: z.string().min(1),
+	sessionId: z.string().optional(),
+	detail: z.string().optional()
+});
+z.discriminatedUnion("ok", [z.object({
+	ok: z.literal(true),
+	sessionId: z.string()
+}), z.object({
+	ok: z.literal(false),
+	reason: z.string()
+})]);
+//#endregion
+//#region shared/contracts/factory-decision-log.ts
+var FACTORY_DECISION_OUTPUT_MAX_BYTES = 16384;
+var FactoryDecisionKind = z.enum([
+	"admission",
+	"closeout",
+	"merge",
+	"watch",
+	"verification",
+	"exception",
+	"landing",
+	"trust"
+]);
+var FactoryDecisionOutcome = z.enum([
+	"refused",
+	"available",
+	"dispatched",
+	"ended",
+	"retry",
+	"block",
+	"merge",
+	"merged",
+	"breach",
+	"verified",
+	"verified-unwatched",
+	"failed",
+	"stale",
+	"passed",
+	"raised",
+	"stalled",
+	"recovered",
+	"granted"
+]);
+var FactoryDecisionFailureClass = z.enum([
+	"admission",
+	"worker",
+	"fence",
+	"check",
+	"review",
+	"closeout",
+	"breach",
+	"verification",
+	"stale",
+	"exception",
+	"stall",
+	"landing"
+]);
+var decisionCheck = z.strictObject({
+	command: z.string(),
+	pass: z.boolean(),
+	output: z.string()
+});
+var decisionFence = z.discriminatedUnion("ok", [z.strictObject({ ok: z.literal(true) }), z.strictObject({
+	ok: z.literal(false),
+	outside: z.array(z.string()),
+	protected: z.array(z.string()),
+	unsupportedProtectedPaths: z.array(z.string())
+})]);
+var decisionFields = {
+	timestamp: z.iso.datetime(),
+	projectId: z.string().min(1).max(128).refine(isSingleFactoryPathSegment),
+	outcome: FactoryDecisionOutcome,
+	workId: z.string().min(1).nullable(),
+	intentId: z.string().min(1).nullable(),
+	sessionId: z.string().min(1).nullable(),
+	attempt: z.number().int().positive().nullable(),
+	durationMs: z.number().int().nonnegative().nullable(),
+	failureClass: FactoryDecisionFailureClass.nullable(),
+	reason: z.string().max(1e3).nullable()
+};
+var FactoryDecisionLogLine = z.discriminatedUnion("kind", [
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("admission"),
+		outcome: z.enum([
+			"refused",
+			"available",
+			"dispatched",
+			"ended",
+			"block"
+		])
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("closeout"),
+		outcome: z.enum([
+			"retry",
+			"block",
+			"merge"
+		]),
+		attempt: z.number().int().positive(),
+		durationMs: z.number().int().nonnegative(),
+		fence: decisionFence.nullable(),
+		checks: z.array(decisionCheck).refine((checks) => checks.reduce((totalBytes, check) => totalBytes + new TextEncoder().encode(check.output).length, 0) <= FACTORY_DECISION_OUTPUT_MAX_BYTES),
+		review: FactoryReviewVerdict.nullable()
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("merge"),
+		outcome: z.literal("merged"),
+		mergedSha: z.string().regex(/^[a-f0-9]{40,64}$/)
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("watch"),
+		outcome: z.enum([
+			"breach",
+			"verified",
+			"verified-unwatched"
+		])
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("verification"),
+		outcome: z.enum([
+			"failed",
+			"stale",
+			"passed"
+		])
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("exception"),
+		outcome: z.enum(["raised", "stalled"])
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("landing"),
+		outcome: z.enum(["failed", "recovered"])
+	}),
+	z.strictObject({
+		...decisionFields,
+		kind: z.literal("trust"),
+		outcome: z.literal("granted")
+	})
+]).superRefine((line, context) => {
+	const isFailure = [
+		"refused",
+		"retry",
+		"block",
+		"breach",
+		"failed",
+		"stale",
+		"raised",
+		"stalled"
+	].includes(line.outcome);
+	if (isFailure && line.failureClass === null) context.addIssue({
+		code: "custom",
+		path: ["failureClass"],
+		message: "Failure requires a failure class"
+	});
+	if (!isFailure && line.outcome !== "ended" && line.failureClass !== null) context.addIssue({
+		code: "custom",
+		path: ["failureClass"],
+		message: "Success requires a null failure class"
+	});
+});
+//#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 FactoryDecisionProperties = z.object({
+	kind: FactoryDecisionKind,
+	outcome: FactoryDecisionOutcome,
+	failure_class: FactoryDecisionFailureClass.nullable(),
+	duration_ms: nonNegativeInteger.nullable(),
+	attempt: nonNegativeInteger.nullable()
+}).strict();
+var TELEMETRY_EVENT_SCHEMAS = Object.freeze({
+	app_started: AppStartedProperties,
+	app_active: AppActiveProperties,
+	session_started: SessionStartedProperties,
+	session_ended: SessionEndedProperties,
+	$exception: ExceptionProperties,
+	$ai_generation: AiGenerationProperties,
+	factory_decision: FactoryDecisionProperties
+});
+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."
+	},
+	{
+		name: "factory_decision",
+		description: "Each time the factory decides something (a dispatch, a close-out attempt, a merge, a watch or verification result, an exception, a landing, a Claude Code folder trust grant): which kind of decision, how it came out, the class of failure when it failed, how long it took and which attempt it was. Never the objective, the reason, check output, a path or a repository name."
+	}
+]);
+Object.freeze([
+	"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"]);
+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()
+});
+//#endregion
+//#region shared/contracts/issues.ts
+var IssueRepoSlug = z.string().regex(REPO_SLUG_RE);
+var IssueKey = z.string().regex(new RegExp(`${REPO_SLUG_RE.source.slice(0, -1)}#[1-9][0-9]*$`));
+var IssuePullRequest = z.object({
+	number: z.number().int().positive(),
+	url: z.string().url(),
+	title: z.string(),
+	state: z.enum([
+		"open",
+		"draft",
+		"merged",
+		"closed"
+	])
+});
+var GithubIssuePullRequestsRepository = z.object({ issue: z.object({ closedByPullRequestsReferences: z.object({ nodes: z.array(z.object({
+	number: IssuePullRequest.shape.number,
+	url: IssuePullRequest.shape.url,
+	title: IssuePullRequest.shape.title,
+	state: z.enum([
+		"OPEN",
+		"MERGED",
+		"CLOSED"
+	]),
+	isDraft: z.boolean()
+}).nullable()).max(5) }) }).nullable() });
+var issueFields = {
+	key: z.string(),
+	repo: IssueRepoSlug,
+	number: z.number().int().positive(),
+	title: z.string(),
+	url: z.string().url(),
+	labels: z.array(z.string()),
+	assignees: z.array(z.string()),
+	author: z.string(),
+	comments: z.number().int().nonnegative(),
+	createdAt: z.iso.datetime(),
+	updatedAt: z.iso.datetime()
+};
+var IssueSource = z.enum([
+	"project",
+	"me",
+	"team"
+]);
+var cachedIssueFields = {
+	...issueFields,
+	sources: z.array(IssueSource).nonempty().refine((sources) => new Set(sources).size === sources.length),
+	teams: z.array(IssueRepoSlug),
+	projectId: z.string().nullable(),
+	pullRequests: z.array(IssuePullRequest).max(5).default([])
+};
+var CachedIssueRow = z.object(cachedIssueFields).refine((issue) => issue.key === `${issue.repo}#${issue.number}`);
+var IssueRow = z.object({
+	...cachedIssueFields,
+	sessionId: z.string().nullable().default(null)
+}).refine((issue) => issue.key === `${issue.repo}#${issue.number}`);
+var IssueUpdate = z.object({
+	...issueFields,
+	state: z.enum(["open", "closed"])
+});
+var GithubIssueResponse = z.object({
+	number: issueFields.number,
+	title: issueFields.title,
+	html_url: issueFields.url,
+	state: z.enum(["open", "closed"]),
+	labels: z.array(z.union([z.string(), z.object({ name: z.string() })])),
+	assignees: z.array(z.object({ login: z.string() })),
+	user: z.object({ login: z.string() }).nullable(),
+	comments: issueFields.comments,
+	created_at: issueFields.createdAt,
+	updated_at: issueFields.updatedAt,
+	repository_url: z.string().url().optional(),
+	pull_request: z.unknown().optional()
+});
+var IssuesSearchResponse = z.object({
+	items: z.array(z.unknown()),
+	total_count: z.number().int().nonnegative(),
+	incomplete_results: z.boolean()
+});
+z.object({
+	ok: z.boolean(),
+	items: z.array(IssueUpdate),
+	isComplete: z.boolean(),
+	error: z.string()
+});
+var IssuesState = z.object({
+	issues: z.array(CachedIssueRow),
+	lastSyncAt: z.number().finite().nonnegative().nullable(),
+	perRepoSync: z.record(IssueRepoSlug, z.object({
+		lastSyncAt: z.number().finite().nonnegative().nullable(),
+		ticks: z.number().int().nonnegative(),
+		needsFullReconcile: z.boolean()
+	})),
+	sessionLinks: z.record(IssueKey, z.string()).default({}),
+	pullRequestsFetchedAt: z.record(IssueKey, z.iso.datetime()).default({})
+});
+var IssuesStatus = z.object({
+	type: z.literal("issues-status"),
+	ts: z.number().finite(),
+	configured: z.boolean(),
+	reason: z.string().nullable(),
+	lastSyncAt: z.number().finite().nonnegative().nullable(),
+	issues: z.array(IssueRow),
+	...reviewsPollingShape
+}).passthrough();
+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 parseAtxHeading(line, { overlongLine }) {
+	if (overlongLine === "reject" && line.length > 4096) return null;
+	const heading = ATX_HEADING.exec(line.slice(0, HEADING_SCAN_MAX_CHARS));
+	if (!heading) return null;
+	return {
+		level: heading[1].length,
+		text: withoutClosingHeadingMarks(heading[2])
+	};
+}
+function headingTitle(line) {
+	return parseAtxHeading(line, { overlongLine: "truncate" })?.text ?? "";
+}
+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 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);
+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",
+	"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("issue-detail", {
+		requestId: z.string().min(1),
+		repo: IssueRepoSlug,
+		issueNumber: z.number().int().positive()
+	}),
+	loose("open-issue-session", {
+		requestId,
+		projectId: z.string(),
+		repo: IssueRepoSlug,
+		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("factory-queue-intent", {
+		...FactoryQueueIntentRequest.shape,
+		requestId
+	}),
+	loose("factory-control", {
+		...FactoryControlRequest.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),
+	loose("dismiss", {
+		id: sessionId,
+		force: z.unknown().optional(),
+		expectedState: SessionState.optional()
+	}),
+	...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",
+	"session-diff-error",
+	"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",
+	"issue-detail-result",
+	"open-issue-session-result",
+	"posthog-issue-action-result",
+	"team-review-action-result",
+	"benchmark-action-result",
+	"factory-queue-intent-result",
+	"factory-control-result",
+	"my-pr-merge-result",
+	"my-pr-keep-mergeable-result",
+	"my-pr-merge-when-ready-result",
+	"reviews-refresh-result",
+	"posthog-archive-investigation-result",
+	"team-review-status",
+	"benchmark-status",
+	"factory-state",
+	"my-prs-status",
+	"issues-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", {
+		isCompacting: z.boolean().optional(),
+		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("session-diff-error", {
+		id: sessionId,
+		message: z.string()
+	}),
+	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("issue-detail-result", {
+		requestId: z.string().min(1),
+		ok: z.boolean(),
+		body: z.string().nullable(),
+		error: z.string().nullable()
+	}),
+	loose("open-issue-session-result", {
+		requestId,
+		ok: z.boolean(),
+		error: optionalError,
+		sessionId: z.string().optional(),
+		sessionName: z.string().optional(),
+		pending: z.boolean().optional(),
+		existing: 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("factory-queue-intent-result", {
+		...FactoryQueueIntentResult.shape,
+		requestId
+	}),
+	loose("factory-control-result", {
+		...FactoryControlResult.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,
+	loose("factory-state", FactoryState.shape),
+	MyPrsStatus,
+	IssuesStatus,
+	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 HTTP_URL_RE = /^https?:\/\/\S+$/i;
+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 { FactoryIssueQueryRow as $, BenchmarkActionRequest as A, PrCheckoutCaseInput as B, IssueKey as C, IssuesStatus as D, IssuesState as E, BenchmarkStatus as F, TelemetryState as G, PendingCrashReport as H, BenchmarkSuite as I, FACTORY_ERROR_MAX_CHARS as J, FACTORY_DECISION_OUTPUT_MAX_BYTES as K, CommitComparison as L, BenchmarkId as M, BenchmarkJudgement as N, ChangeMap as O, BenchmarkRun as P, FactoryIssue as Q, MergedPrListing as R, GithubIssueResponse as S, IssuesSearchResponse as T, TELEMETRY_EVENT_SCHEMAS as U, FeatureFlagsResponse as V, TELEMETRY_KILL_SWITCH_FLAG as W, FactoryControlRequest as X, FactoryConsequences as Y, FactoryHogQLResponse as Z, PlanDecision as _, ClientMessage as a, FactoryWorkerEvent as at, planTitle as b, UpdateJournal as c, TraceRecord as d, FactoryLaneState as et, PLAN_BODY_CAP_BYTES as f, PLAN_TOOL_NAME as g, PLAN_RESULT_HOOK_EVENT as h, CONTROL_FRAME_MAX_BYTES as i, FactoryReviewerOutput as it, BenchmarkCase as j, changeMapFactId as k, MAX_RAW_LINE_CHARS as l, PLAN_HOOK_OUTPUT_MAX_CHARS as m, HookEnvelope as n, FactoryQueueIntentRequest as nt, DIFF_ANNOTATION_NOTE_MAX_CHARS as o, isSingleFactoryPathSegment as ot, PLAN_HOOK_EVENT as p, FactoryDecisionLogLine as q, parseDataClientMessage as r, FactoryReviewVerdict as rt, InstallFlavor as s, HTTP_URL_RE as t, FactoryProjectState as tt, TraceCheckpoint as u, PlanRevision as v, IssueUpdate as w, GithubIssuePullRequestsRepository as x, parseExitPlanModeHookPayload as y, MinedPrReviewData as z };