@overdeck/contracts 0.30.0

package/dist/index.mjs

@@ -0,0 +1,4199 @@
+import { Effect, Schema } from "effect";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+//#region src/types.ts
+const IssueId = Schema.String;
+const AgentId = Schema.String;
+const SequenceNumber = Schema.Number;
+const AgentStatus = Schema.Literals([
+	"starting",
+	"running",
+	"stopped",
+	"error",
+	"unknown"
+]);
+const Role = Schema.Literals([
+	"plan",
+	"work",
+	"review",
+	"test",
+	"ship",
+	"flywheel",
+	"strike",
+	"sequencer"
+]);
+const AgentResolution = Schema.Literals([
+	"working",
+	"done",
+	"needs_input",
+	"stuck",
+	"completed",
+	"unclear",
+	"abandoned",
+	"api_error"
+]);
+const ReviewStatusValue = Schema.Literals([
+	"pending",
+	"reviewing",
+	"passed",
+	"failed",
+	"blocked"
+]);
+const TestStatusValue = Schema.Literals([
+	"pending",
+	"testing",
+	"passed",
+	"failed",
+	"skipped",
+	"dispatch_failed"
+]);
+const UatStatusValue = Schema.Literals([
+	"pending",
+	"testing",
+	"passed",
+	"failed"
+]);
+const MergeStatusValue = Schema.Literals([
+	"pending",
+	"queued",
+	"merging",
+	"verifying",
+	"merged",
+	"failed"
+]);
+const VerificationStatusValue = Schema.Literals([
+	"pending",
+	"running",
+	"passed",
+	"failed",
+	"skipped"
+]);
+const KNOWN_HARNESSES = new Set([
+	"claude-code",
+	"pi",
+	"codex"
+]);
+/**
+* Normalize a snapshot's runtime field to a known Harness value.
+* Unknown or missing values fall back to 'claude-code' (the default harness).
+*/
+function getHarness(snapshot) {
+	const raw = snapshot?.runtime;
+	if (raw && KNOWN_HARNESSES.has(raw)) return raw;
+	return "claude-code";
+}
+const Activity = Schema.Literals([
+	"working",
+	"thinking",
+	"waiting",
+	"idle",
+	"stopped"
+]);
+const WaitingReason = Schema.Literals([
+	"tool_permission",
+	"user_question",
+	"disambiguation",
+	"other"
+]);
+const ClaudeChannelPermissionBehavior = Schema.Literals(["allow", "deny"]);
+const ThinkingState = Schema.Struct({
+	since: Schema.String,
+	lastToolAt: Schema.String
+});
+const WaitingState = Schema.Struct({
+	reason: WaitingReason,
+	startedAt: Schema.String,
+	message: Schema.optional(Schema.String),
+	notificationSent: Schema.optional(Schema.Boolean)
+});
+const CHANNEL_REPLY_KIND_VALUES = [
+	"status",
+	"done",
+	"needs_input"
+];
+const MAX_CHANNEL_REPLY_SUMMARY_LENGTH = 4 * 1024;
+const MAX_CHANNEL_REPLY_ARTIFACT_REFS = 20;
+const MAX_CHANNEL_REPLY_ARTIFACT_URI_LENGTH = 512;
+const MAX_CHANNEL_REPLY_ARTIFACT_LABEL_LENGTH = 512;
+const CHANNEL_REPLY_ARTIFACT_URI_PATTERN = /^(?:file:\/\/|https:\/\/|\/)/;
+const ChannelReplyKind = Schema.Literals(CHANNEL_REPLY_KIND_VALUES);
+function isChannelReplyKind(value) {
+	return typeof value === "string" && CHANNEL_REPLY_KIND_VALUES.includes(value);
+}
+const ChannelReplyArtifactRef = Schema.Struct({
+	uri: Schema.String,
+	label: Schema.optional(Schema.String)
+});
+const AgentChannelReply = Schema.Struct({
+	kind: ChannelReplyKind,
+	summary: Schema.String,
+	artifactRefs: Schema.Array(ChannelReplyArtifactRef),
+	reportedAt: Schema.String
+});
+function normalizeChannelReplyPayload(payload, fieldPrefix = "channel_reply") {
+	if (payload === null || typeof payload !== "object") throw new Error(`${fieldPrefix} payload must be an object`);
+	const source = payload;
+	if (!isChannelReplyKind(source.kind)) throw new Error(`${fieldPrefix}.kind must be one of: ${CHANNEL_REPLY_KIND_VALUES.join(", ")}`);
+	if (typeof source.summary !== "string") throw new Error(`${fieldPrefix}.summary must be a non-empty string`);
+	const summary = source.summary.trim();
+	if (summary.length === 0) throw new Error(`${fieldPrefix}.summary must be a non-empty string`);
+	if (summary.length > 4096) throw new Error(`${fieldPrefix}.summary must be at most ${MAX_CHANNEL_REPLY_SUMMARY_LENGTH} characters`);
+	if (source.artifactRefs !== void 0 && !Array.isArray(source.artifactRefs)) throw new Error(`${fieldPrefix}.artifactRefs must be an array when provided`);
+	const rawArtifactRefs = source.artifactRefs ?? [];
+	if (rawArtifactRefs.length > 20) throw new Error(`${fieldPrefix}.artifactRefs must contain at most 20 entries`);
+	const artifactRefs = rawArtifactRefs.map((item, index) => {
+		if (item === null || typeof item !== "object") throw new Error(`${fieldPrefix}.artifactRefs[${index}] must be an object`);
+		const ref = item;
+		if (typeof ref.uri !== "string") throw new Error(`${fieldPrefix}.artifactRefs[${index}].uri must be a non-empty string`);
+		const uri = ref.uri.trim();
+		if (uri.length === 0) throw new Error(`${fieldPrefix}.artifactRefs[${index}].uri must be a non-empty string`);
+		if (uri.length > 512) throw new Error(`${fieldPrefix}.artifactRefs[${index}].uri must be at most 512 characters`);
+		if (!CHANNEL_REPLY_ARTIFACT_URI_PATTERN.test(uri)) throw new Error(`${fieldPrefix}.artifactRefs[${index}].uri must start with file://, https://, or /`);
+		if (ref.label !== void 0 && typeof ref.label !== "string") throw new Error(`${fieldPrefix}.artifactRefs[${index}].label must be a string when provided`);
+		const label = typeof ref.label === "string" ? ref.label.trim() : void 0;
+		if (label !== void 0 && label.length > 512) throw new Error(`${fieldPrefix}.artifactRefs[${index}].label must be at most 512 characters`);
+		return {
+			uri,
+			...label ? { label } : {}
+		};
+	});
+	return {
+		kind: source.kind,
+		summary,
+		artifactRefs
+	};
+}
+const AgentRuntimeSnapshot = Schema.Struct({
+	id: AgentId,
+	activity: Activity,
+	lastActivity: Schema.String,
+	currentTool: Schema.optional(Schema.String),
+	thinking: Schema.optional(ThinkingState),
+	waiting: Schema.optional(WaitingState),
+	claudeSessionId: Schema.optional(Schema.String),
+	sessionModel: Schema.optional(Schema.String),
+	sessionHarness: Schema.optional(Schema.String),
+	model: Schema.optional(Schema.String),
+	lastMessageAt: Schema.optional(Schema.String),
+	channelReply: Schema.optional(AgentChannelReply),
+	resolution: Schema.optional(AgentResolution),
+	resolutionCount: Schema.optional(Schema.Number),
+	resolutionUpdatedAt: Schema.optional(Schema.String),
+	currentIssue: Schema.optional(IssueId),
+	contextSaturatedAt: Schema.optional(Schema.String),
+	updatedAtSequence: SequenceNumber
+});
+const ChannelPermissionRequestSnapshot = Schema.Struct({
+	requestId: Schema.String,
+	agentId: AgentId,
+	issueId: Schema.optional(IssueId),
+	toolName: Schema.String,
+	description: Schema.String,
+	inputPreview: Schema.String,
+	createdAt: Schema.String
+});
+const AgentSnapshot = Schema.Struct({
+	id: AgentId,
+	issueId: IssueId,
+	workspace: Schema.optional(Schema.String),
+	runtime: Schema.optional(Schema.String),
+	model: Schema.optional(Schema.String),
+	status: AgentStatus,
+	startedAt: Schema.optional(Schema.String),
+	lastActivity: Schema.optional(Schema.String),
+	branch: Schema.optional(Schema.String),
+	costSoFar: Schema.optional(Schema.Number),
+	sessionId: Schema.optional(Schema.String),
+	role: Schema.optional(Role),
+	phase: Schema.optional(Schema.String),
+	workType: Schema.optional(Schema.String),
+	roleRunHead: Schema.optional(Schema.String),
+	hasLiveTmuxSession: Schema.optional(Schema.Boolean),
+	stoppedByUser: Schema.optional(Schema.Boolean),
+	paused: Schema.optional(Schema.Boolean),
+	pausedReason: Schema.optional(Schema.String),
+	pausedAt: Schema.optional(Schema.String),
+	troubled: Schema.optional(Schema.Boolean),
+	troubledAt: Schema.optional(Schema.String),
+	consecutiveFailures: Schema.optional(Schema.Number),
+	firstFailureInRunAt: Schema.optional(Schema.String),
+	lastFailureAt: Schema.optional(Schema.String),
+	lastFailureReason: Schema.optional(Schema.String),
+	lastFailureNextRetryAt: Schema.optional(Schema.String),
+	runtimeState: Schema.optional(Schema.String),
+	hasPendingQuestion: Schema.optional(Schema.Boolean),
+	pendingQuestionCount: Schema.optional(Schema.Number),
+	pendingQuestionPrompt: Schema.optional(Schema.String),
+	pendingQuestionReason: Schema.optional(Schema.String),
+	pendingInputCount: Schema.optional(Schema.Number),
+	pendingInputKinds: Schema.optional(Schema.Array(Schema.String)),
+	pendingAskUserQuestion: Schema.optional(Schema.Struct({
+		toolUseId: Schema.String,
+		askedAt: Schema.String,
+		questions: Schema.Array(Schema.Struct({
+			question: Schema.String,
+			header: Schema.optional(Schema.String),
+			multiSelect: Schema.optional(Schema.Boolean),
+			options: Schema.Array(Schema.Struct({
+				label: Schema.String,
+				description: Schema.optional(Schema.String)
+			}))
+		}))
+	})),
+	resolution: Schema.optional(AgentResolution),
+	resolutionCount: Schema.optional(Schema.Number),
+	runtimeSnapshotSequence: Schema.optional(SequenceNumber)
+});
+const ReviewStatusSnapshot = Schema.Struct({
+	issueId: IssueId,
+	reviewStatus: Schema.optional(ReviewStatusValue),
+	testStatus: Schema.optional(TestStatusValue),
+	uatStatus: Schema.optional(UatStatusValue),
+	uatNotes: Schema.optional(Schema.String),
+	mergeStatus: Schema.optional(MergeStatusValue),
+	verificationStatus: Schema.optional(VerificationStatusValue),
+	verificationNotes: Schema.optional(Schema.String),
+	verificationCycleCount: Schema.optional(Schema.Number),
+	readyForMerge: Schema.optional(Schema.Boolean),
+	updatedAt: Schema.optional(Schema.String),
+	prUrl: Schema.optional(Schema.String),
+	/** Persistent stuck flag — set by divergence guard, cleared by /unstick */
+	stuck: Schema.optional(Schema.Boolean),
+	stuckReason: Schema.optional(Schema.String),
+	stuckAt: Schema.optional(Schema.String),
+	stuckDetails: Schema.optional(Schema.String),
+	/** Commit SHA at which review passed; deacon uses this to detect new pushes after review */
+	reviewedAtCommit: Schema.optional(Schema.String),
+	/** Commit SHA at which the pre-review verification gate last passed */
+	lastVerifiedCommit: Schema.optional(Schema.String),
+	/** Current merge pipeline step (granular visibility for the merge step tracker) */
+	mergeStep: Schema.optional(Schema.String),
+	/** PAN-699: timestamp when review agents were dispatched */
+	reviewSpawnedAt: Schema.optional(Schema.String),
+	/** PAN-699: number of test-agent dispatch retries */
+	testRetryCount: Schema.optional(Schema.Number),
+	/** PAN-794: parallel-review re-dispatch retry counter (current recovery cycle) */
+	reviewRetryCount: Schema.optional(Schema.Number),
+	/** PAN-796: review auto-requeue count (circuit breaker threshold) */
+	autoRequeueCount: Schema.optional(Schema.Number),
+	/** PAN-794: ISO timestamp marking the start of the current recovery cycle */
+	recoveryStartedAt: Schema.optional(Schema.String),
+	/** Human-requested patrol opt-out — when true, Deacon ignores this issue. */
+	deaconIgnored: Schema.optional(Schema.Boolean),
+	deaconIgnoredAt: Schema.optional(Schema.String),
+	deaconIgnoredReason: Schema.optional(Schema.String),
+	/** PAN-1691: per-issue auto-merge routing key. undefined = project default, true = auto-merge (fast lane), false = hold for UAT. */
+	autoMerge: Schema.optional(Schema.Boolean),
+	/** Active review orchestrator tmux session name (e.g. agent-pan-540-review). */
+	reviewCoordinatorSessionName: Schema.optional(Schema.String),
+	/** Active review sub-role tmux session names (e.g. agent-pan-540-review-correctness). Discovered at emission time. */
+	reviewSessionNames: Schema.optional(Schema.Array(Schema.String)),
+	/** Per-role review completion status (keyed by role: 'correctness' | 'security' | ...) */
+	reviewSubStatuses: Schema.optional(Schema.Record(Schema.String, Schema.Literals(["running", "done"]))),
+	/** PAN-905: queue position in the merge queue */
+	queuePosition: Schema.optional(Schema.Number),
+	/** PAN-905: currently active specialist (e.g. 'merge-agent') */
+	activeSpecialist: Schema.optional(Schema.String),
+	/** PAN-905: number of merge retries attempted */
+	mergeRetryCount: Schema.optional(Schema.Number),
+	/** PAN-905: free-form notes about the merge attempt */
+	mergeNotes: Schema.optional(Schema.String),
+	/** PAN-905: GitHub-native merge blocker reasons */
+	blockerReasons: Schema.optional(Schema.Array(Schema.Struct({
+		type: Schema.Literals([
+			"failing_checks",
+			"merge_conflict",
+			"unresolved_conversations",
+			"changes_requested",
+			"draft_pr",
+			"not_mergeable"
+		]),
+		summary: Schema.String,
+		details: Schema.optional(Schema.String),
+		detectedAt: Schema.String
+	})))
+});
+const TurnDiffFileChange = Schema.Struct({
+	path: Schema.String,
+	kind: Schema.optional(Schema.String),
+	additions: Schema.optional(Schema.Number),
+	deletions: Schema.optional(Schema.Number)
+});
+const TurnDiffSummary = Schema.Struct({
+	turnId: Schema.String,
+	completedAt: Schema.String,
+	status: Schema.optional(Schema.String),
+	files: Schema.Array(TurnDiffFileChange),
+	checkpointRef: Schema.optional(Schema.String),
+	assistantMessageId: Schema.optional(Schema.String),
+	checkpointTurnCount: Schema.optional(Schema.Number)
+});
+const ScanProgressSnapshot = Schema.Struct({
+	active: Schema.Boolean,
+	mode: Schema.Literals([
+		"targeted",
+		"watched",
+		"system"
+	]),
+	dirs: Schema.Array(Schema.String),
+	dirsProcessed: Schema.Number,
+	dirsTotal: Schema.Number,
+	sessionsFound: Schema.Number,
+	elapsedMs: Schema.Number,
+	inserted: Schema.Number,
+	updated: Schema.Number,
+	skipped: Schema.Number,
+	errors: Schema.Number,
+	durationMs: Schema.Number
+});
+const EnrichStatsSnapshot = Schema.Struct({
+	processed: Schema.Number,
+	totalCost: Schema.Number,
+	failures: Schema.Number,
+	durationMs: Schema.Number
+});
+const EnrichProgressSnapshot = Schema.Struct({
+	sessionId: Schema.Number,
+	level: Schema.Number,
+	model: Schema.String,
+	cost: Schema.Number,
+	success: Schema.Boolean,
+	error: Schema.optional(Schema.String),
+	timestamp: Schema.String
+});
+const EmbedProgressSnapshot = Schema.Struct({
+	sessionId: Schema.Number,
+	model: Schema.String,
+	success: Schema.Boolean,
+	error: Schema.optional(Schema.String),
+	timestamp: Schema.String
+});
+const DashboardSnapshot = Schema.Struct({
+	sequence: SequenceNumber,
+	agents: Schema.Array(AgentSnapshot),
+	specialists: Schema.Array(Schema.Unknown),
+	reviewStatuses: Schema.Array(ReviewStatusSnapshot),
+	issues: Schema.Array(Schema.Unknown),
+	resources: Schema.optional(Schema.Unknown),
+	memory: Schema.optional(Schema.Unknown),
+	agentRuntimeById: Schema.optional(Schema.Record(Schema.String, AgentRuntimeSnapshot)),
+	channelPermissionRequests: Schema.optional(Schema.Array(ChannelPermissionRequestSnapshot)),
+	scanProgress: Schema.optional(Schema.NullOr(ScanProgressSnapshot)),
+	enrichStats: Schema.optional(Schema.NullOr(EnrichStatsSnapshot)),
+	enrichProgressBySessionId: Schema.optional(Schema.Record(Schema.String, EnrichProgressSnapshot)),
+	embedProgressBySessionId: Schema.optional(Schema.Record(Schema.String, EmbedProgressSnapshot)),
+	timestamp: Schema.String
+});
+const WorkspaceDetail = Schema.Struct({
+	workspace: Schema.Unknown,
+	reviewStatus: Schema.Unknown,
+	planning: Schema.Unknown,
+	costs: Schema.Unknown,
+	agentOutput: Schema.Array(Schema.String)
+});
+const ResourceStats = Schema.Struct({ containers: Schema.Array(Schema.Struct({
+	name: Schema.String,
+	cpu: Schema.optional(Schema.String),
+	mem: Schema.optional(Schema.String),
+	status: Schema.optional(Schema.String)
+})) });
+const SessionNodePresence = Schema.Literals([
+	"active",
+	"idle",
+	"suspended",
+	"ended"
+]);
+const SessionNodeType = Schema.Literals([
+	"planning",
+	"work",
+	"strike",
+	"review",
+	"reviewer",
+	"test",
+	"ship",
+	"merge",
+	"legacy"
+]);
+const ReviewerRoundSummary = Schema.Struct({
+	round: Schema.Number,
+	status: Schema.optional(Schema.String),
+	reviewResult: Schema.optional(Schema.String),
+	startedAt: Schema.optional(Schema.String),
+	endedAt: Schema.optional(Schema.String),
+	durationSec: Schema.optional(Schema.Number),
+	cost: Schema.optional(Schema.Number),
+	findings: Schema.optional(Schema.Number),
+	summary: Schema.optional(Schema.String)
+});
+const ReviewerRoundMetadata = Schema.Struct({
+	roundCount: Schema.Number,
+	latestRound: Schema.Number,
+	latestStatus: Schema.optional(Schema.String),
+	latestReviewResult: Schema.optional(Schema.String),
+	history: Schema.Array(ReviewerRoundSummary)
+});
+const SessionNode = Schema.Struct({
+	type: SessionNodeType,
+	role: Schema.optional(Schema.String),
+	sessionId: Schema.String,
+	tmuxSession: Schema.optional(Schema.String),
+	model: Schema.String,
+	harness: Schema.optional(Schema.String),
+	startedAt: Schema.String,
+	endedAt: Schema.optional(Schema.String),
+	duration: Schema.NullOr(Schema.Number),
+	status: AgentStatus,
+	hasJsonl: Schema.optional(Schema.Boolean),
+	transcript: Schema.optional(Schema.String),
+	presence: SessionNodePresence,
+	awaitingInput: Schema.optional(Schema.Boolean),
+	awaitingInputPrompt: Schema.optional(Schema.String),
+	awaitingInputReason: Schema.optional(Schema.String),
+	roundMetadata: Schema.optional(ReviewerRoundMetadata),
+	deliveryMethod: Schema.optional(Schema.Literals([
+		"auto",
+		"channels",
+		"tmux"
+	])),
+	paused: Schema.optional(Schema.Boolean),
+	pausedReason: Schema.optional(Schema.String),
+	pausedAt: Schema.optional(Schema.String)
+});
+const FeatureNode = Schema.Struct({
+	issueId: IssueId,
+	title: Schema.String,
+	sessions: Schema.Array(SessionNode)
+});
+const ProjectSessionTree = Schema.Struct({
+	projectKey: Schema.String,
+	features: Schema.Array(FeatureNode)
+});
+/** Snapshot of a discovered session for RPC responses and frontend display */
+const DiscoveredSessionSnapshot = Schema.Struct({
+	id: Schema.Number,
+	jsonlPath: Schema.String,
+	sessionId: Schema.optional(Schema.String),
+	workspacePath: Schema.optional(Schema.String),
+	workspaceHash: Schema.optional(Schema.String),
+	messageCount: Schema.Number,
+	firstTs: Schema.optional(Schema.String),
+	lastTs: Schema.optional(Schema.String),
+	modelsUsed: Schema.Array(Schema.String),
+	primaryModel: Schema.optional(Schema.String),
+	tokenInput: Schema.Number,
+	tokenOutput: Schema.Number,
+	estimatedCost: Schema.Number,
+	toolsUsed: Schema.Array(Schema.String),
+	filesTouched: Schema.Array(Schema.String),
+	tags: Schema.Array(Schema.String),
+	summary: Schema.optional(Schema.String),
+	summaryDetailed: Schema.optional(Schema.String),
+	enrichmentLevel: Schema.Number,
+	enrichmentModel: Schema.optional(Schema.String),
+	enrichedAt: Schema.optional(Schema.String),
+	enrichmentFailed: Schema.Boolean,
+	overdeckManaged: Schema.Boolean,
+	panIssueId: Schema.optional(Schema.String),
+	panAgentId: Schema.optional(Schema.String),
+	scannedAt: Schema.String
+});
+/** Filter parameters for conversation search */
+const ConversationFilter = Schema.Struct({
+	workspacePath: Schema.optional(Schema.String),
+	primaryModel: Schema.optional(Schema.String),
+	managed: Schema.optional(Schema.Boolean),
+	unmanaged: Schema.optional(Schema.Boolean),
+	since: Schema.optional(Schema.String),
+	before: Schema.optional(Schema.String),
+	after: Schema.optional(Schema.String),
+	minCost: Schema.optional(Schema.Number),
+	maxCost: Schema.optional(Schema.Number),
+	minMessages: Schema.optional(Schema.Number),
+	tags: Schema.optional(Schema.Array(Schema.String)),
+	tools: Schema.optional(Schema.Array(Schema.String)),
+	files: Schema.optional(Schema.Array(Schema.String)),
+	issueId: Schema.optional(Schema.String),
+	enrichmentLevel: Schema.optional(Schema.Number),
+	enriched: Schema.optional(Schema.Boolean),
+	notEnriched: Schema.optional(Schema.Boolean),
+	query: Schema.optional(Schema.String),
+	semantic: Schema.optional(Schema.Boolean),
+	similarTo: Schema.optional(Schema.Number),
+	limit: Schema.optional(Schema.Number),
+	offset: Schema.optional(Schema.Number),
+	format: Schema.optional(Schema.Literals([
+		"table",
+		"json",
+		"brief",
+		"ids"
+	]))
+});
+/** Aggregate cost breakdown for conversations */
+const ConversationCostSummary = Schema.Struct({
+	groupBy: Schema.Literals([
+		"workspace",
+		"model",
+		"day",
+		"month"
+	]),
+	entries: Schema.Array(Schema.Struct({
+		key: Schema.String,
+		totalCost: Schema.Number,
+		sessionCount: Schema.Number,
+		totalTokensIn: Schema.Number,
+		totalTokensOut: Schema.Number
+	})),
+	grandTotal: Schema.Number,
+	totalTokensIn: Schema.Number,
+	totalTokensOut: Schema.Number
+});
+/** Scan result summary */
+const ScanResult = Schema.Struct({
+	inserted: Schema.Number,
+	updated: Schema.Number,
+	skipped: Schema.Number,
+	errors: Schema.Number,
+	durationMs: Schema.Number
+});
+//#endregion
+//#region src/memory.ts
+const MemoryIdentity = Schema.Struct({
+	projectId: Schema.String,
+	workspaceId: Schema.String,
+	issueId: IssueId,
+	runId: Schema.String,
+	sessionId: Schema.String,
+	agentRole: Role,
+	agentHarness: Schema.String
+});
+const MemoryTokenUsage = Schema.Struct({
+	prompt: Schema.Number,
+	completion: Schema.Number,
+	total: Schema.Number
+});
+const MemoryObservation = Schema.Struct({
+	id: Schema.String,
+	timestamp: Schema.String,
+	projectId: Schema.String,
+	workspaceId: Schema.String,
+	issueId: IssueId,
+	runId: Schema.String,
+	sessionId: Schema.String,
+	agentRole: Role,
+	agentHarness: Schema.String,
+	gitBranch: Schema.String,
+	sourceTranscriptOffset: Schema.Number,
+	actionStatus: Schema.NullOr(Schema.String),
+	narrative: Schema.String,
+	summary: Schema.String,
+	files: Schema.Array(Schema.String),
+	tags: Schema.Array(Schema.String),
+	tokens: MemoryTokenUsage,
+	model: Schema.String
+});
+const MemoryStatusPhase = Schema.Literals([
+	"exploring",
+	"planning",
+	"building",
+	"verifying",
+	"cleaning",
+	"shipping"
+]);
+const MemoryStatus = Schema.Struct({
+	name: Schema.String,
+	headline: Schema.String,
+	summary: Schema.String,
+	goal: Schema.NullOr(Schema.String),
+	phase: MemoryStatusPhase,
+	accomplished: Schema.Array(Schema.String),
+	decided: Schema.Array(Schema.String),
+	open: Schema.Array(Schema.String),
+	nextSteps: Schema.Array(Schema.String),
+	confidence: Schema.Number,
+	workingSet: Schema.Array(Schema.String),
+	tags: Schema.Array(Schema.String)
+});
+const PendingTurn = Schema.Struct({
+	id: Schema.String,
+	createdAt: Schema.String,
+	identity: MemoryIdentity,
+	trigger: Schema.Literals([
+		"stop-hook",
+		"poller",
+		"reconciliation",
+		"manual"
+	]),
+	transcriptPath: Schema.String,
+	fromOffset: Schema.Number,
+	toOffset: Schema.Number,
+	lastFullLineOffset: Schema.Number,
+	eventsConsumed: Schema.Number,
+	compressedText: Schema.String
+});
+const ResetMarkerScope = Schema.Literals([
+	"project",
+	"workspace",
+	"issue",
+	"session"
+]);
+const ResetMarker = Schema.Struct({
+	id: Schema.String,
+	scope: ResetMarkerScope,
+	scopeId: Schema.String,
+	fromTimestamp: Schema.String,
+	reason: Schema.String,
+	createdAt: Schema.String
+});
+const RagDecisionSource = Schema.Struct({
+	id: Schema.String,
+	docType: Schema.Literals([
+		"observation",
+		"summary",
+		"status",
+		"sibling"
+	]),
+	scope: Schema.String,
+	score: Schema.Number,
+	tokens: Schema.Number
+});
+const RagDecision = Schema.Struct({
+	id: Schema.String,
+	timestamp: Schema.String,
+	identity: MemoryIdentity,
+	surface: Schema.Literals(["spawn", "user-prompt"]),
+	outcome: Schema.Literals([
+		"injected",
+		"skipped",
+		"no-hits",
+		"expansion-failed",
+		"context-too-large",
+		"budget-truncated"
+	]),
+	query: Schema.String,
+	expandedTerms: Schema.Array(Schema.String),
+	allocations: Schema.Struct({
+		status: Schema.Number,
+		observations: Schema.Number,
+		summaries: Schema.Number,
+		sibling: Schema.Number
+	}),
+	sources: Schema.Array(RagDecisionSource),
+	reason: Schema.NullOr(Schema.String)
+});
+const ExtractionProviderTarget = Schema.Struct({
+	provider: Schema.String,
+	model: Schema.String
+});
+const ExtractionProviderConfig = Schema.Struct({
+	provider: Schema.String,
+	model: Schema.String,
+	providerEnvVar: Schema.optional(Schema.String),
+	modelEnvVar: Schema.optional(Schema.String),
+	perDayCostCapUsd: Schema.Number,
+	fallbackChain: Schema.Array(ExtractionProviderTarget)
+});
+//#endregion
+//#region src/events.ts
+/** App-level liveness frame for the /ws/rpc domain-events stream. */
+const SystemHeartbeatEvent = Schema.Struct({
+	type: Schema.Literal("system.heartbeat"),
+	timestamp: Schema.String,
+	payload: Schema.Struct({ ts: Schema.Number })
+});
+/** Replaces socket.io `agents:changed` (event: 'started') */
+const AgentStartedEvent = Schema.Struct({
+	type: Schema.Literal("agent.started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: IssueId,
+		agent: AgentSnapshot
+	})
+});
+/** Replaces socket.io `agents:changed` (event: 'stopped') */
+const AgentStoppedEvent = Schema.Struct({
+	type: Schema.Literal("agent.stopped"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: IssueId,
+		sessionId: Schema.optional(Schema.String)
+	})
+});
+const AgentHeartbeatDeadEvent = Schema.Struct({
+	type: Schema.Literal("agent.heartbeat_dead"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: Schema.optional(IssueId),
+		sessionId: Schema.optional(Schema.String)
+	})
+});
+/** Role lifecycle — work agent completed implementation and is ready for review. */
+const WorkCompletedEvent = Schema.Struct({
+	type: Schema.Literal("work.completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		agentId: Schema.optional(AgentId)
+	})
+});
+/** Role lifecycle — generic agent completion signal, normalized by Cloister by role. */
+const AgentCompletedEvent = Schema.Struct({
+	type: Schema.Literal("agent.completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		agentId: Schema.optional(AgentId),
+		role: Schema.optional(Role)
+	})
+});
+/** Role lifecycle — review approved the branch and testing should start. */
+const ReviewApprovedEvent = Schema.Struct({
+	type: Schema.Literal("review.approved"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** Role lifecycle — tests passed and shipping should prepare the branch. */
+const TestPassedEvent = Schema.Struct({
+	type: Schema.Literal("test.passed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** Replaces socket.io `godview:status-change` */
+const AgentStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("agent.status_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: Schema.optional(IssueId),
+		status: AgentStatus,
+		previousStatus: Schema.optional(AgentStatus),
+		hasLiveTmuxSession: Schema.optional(Schema.Boolean),
+		stoppedByUser: Schema.optional(Schema.Boolean),
+		stoppedByPause: Schema.optional(Schema.Boolean),
+		paused: Schema.optional(Schema.Boolean),
+		pausedReason: Schema.optional(Schema.NullOr(Schema.String)),
+		pausedAt: Schema.optional(Schema.NullOr(Schema.String)),
+		troubled: Schema.optional(Schema.Boolean),
+		troubledAt: Schema.optional(Schema.NullOr(Schema.String)),
+		consecutiveFailures: Schema.optional(Schema.Number),
+		firstFailureInRunAt: Schema.optional(Schema.NullOr(Schema.String)),
+		lastFailureAt: Schema.optional(Schema.NullOr(Schema.String)),
+		lastFailureReason: Schema.optional(Schema.NullOr(Schema.String)),
+		lastFailureNextRetryAt: Schema.optional(Schema.NullOr(Schema.String)),
+		kickoffDelivered: Schema.optional(Schema.Boolean),
+		hostOverride: Schema.optional(Schema.Boolean),
+		role: Schema.optional(Role),
+		model: Schema.optional(Schema.String),
+		workspace: Schema.optional(Schema.String),
+		sessionId: Schema.optional(Schema.String),
+		lastActivity: Schema.optional(Schema.String),
+		lastResumeAt: Schema.optional(Schema.String),
+		stoppedAt: Schema.optional(Schema.String),
+		branch: Schema.optional(Schema.String),
+		costSoFar: Schema.optional(Schema.Number),
+		phase: Schema.optional(Schema.String),
+		workType: Schema.optional(Schema.String),
+		roleRunHead: Schema.optional(Schema.String),
+		flywheelRunId: Schema.optional(Schema.String),
+		reviewSubRole: Schema.optional(Schema.String),
+		reviewRunId: Schema.optional(Schema.String),
+		reviewOutputPath: Schema.optional(Schema.String),
+		reviewSynthesisAgentId: Schema.optional(Schema.String),
+		reviewDeadlineAt: Schema.optional(Schema.String),
+		reviewMonitorSignaled: Schema.optional(Schema.String),
+		reviewRetryAttempt: Schema.optional(Schema.Number),
+		inspectSubRole: Schema.optional(Schema.String),
+		deliveryMethod: Schema.optional(Schema.String),
+		supervisorEnabled: Schema.optional(Schema.Boolean),
+		channelsEnabled: Schema.optional(Schema.Boolean)
+	})
+});
+/** Replaces socket.io `godview:agent-output` */
+const AgentOutputReceivedEvent = Schema.Struct({
+	type: Schema.Literal("agent.output_received"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		lines: Schema.Array(Schema.String)
+	})
+});
+/** New — agent enrichment fields updated (PAN-440) */
+const AgentEnrichmentChangedEvent = Schema.Struct({
+	type: Schema.Literal("agent.enrichment_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		role: Schema.optional(Role),
+		hasPendingQuestion: Schema.optional(Schema.Boolean),
+		pendingQuestionCount: Schema.optional(Schema.Number),
+		pendingQuestionPrompt: Schema.optional(Schema.String),
+		pendingQuestionReason: Schema.optional(Schema.String),
+		pendingInputCount: Schema.optional(Schema.Number),
+		pendingInputKinds: Schema.optional(Schema.Array(Schema.String)),
+		pendingAskUserQuestion: Schema.optional(Schema.Struct({
+			toolUseId: Schema.String,
+			askedAt: Schema.String,
+			questions: Schema.Array(Schema.Struct({
+				question: Schema.String,
+				header: Schema.optional(Schema.String),
+				multiSelect: Schema.optional(Schema.Boolean),
+				options: Schema.Array(Schema.Struct({
+					label: Schema.String,
+					description: Schema.optional(Schema.String)
+				}))
+			}))
+		})),
+		resolution: Schema.optional(AgentResolution),
+		resolutionCount: Schema.optional(Schema.Number)
+	})
+});
+/** New — agent created in database */
+const AgentCreatedEvent = Schema.Struct({
+	type: Schema.Literal("agent.created"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: IssueId,
+		agent: AgentSnapshot
+	})
+});
+const AgentActivityChangedEvent = Schema.Struct({
+	type: Schema.Literal("agent.activity_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		activity: Activity,
+		currentTool: Schema.optional(Schema.String)
+	})
+});
+const AgentThinkingStartedEvent = Schema.Struct({
+	type: Schema.Literal("agent.thinking_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		lastToolAt: Schema.String
+	})
+});
+const AgentThinkingStoppedEvent = Schema.Struct({
+	type: Schema.Literal("agent.thinking_stopped"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		resolvedBy: Schema.Literals([
+			"tool",
+			"waiting",
+			"idle",
+			"stopped"
+		])
+	})
+});
+const AgentWaitingStartedEvent = Schema.Struct({
+	type: Schema.Literal("agent.waiting_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		reason: WaitingReason,
+		message: Schema.optional(Schema.String)
+	})
+});
+const AgentWaitingClearedEvent = Schema.Struct({
+	type: Schema.Literal("agent.waiting_cleared"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		clearedBy: Schema.Literals([
+			"user_response",
+			"timeout",
+			"stopped",
+			"tool_resumed"
+		])
+	})
+});
+const AgentPermissionRequestedEvent = Schema.Struct({
+	type: Schema.Literal("agent.permission_requested"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: ChannelPermissionRequestSnapshot
+});
+const AgentPermissionResolvedEvent = Schema.Struct({
+	type: Schema.Literal("agent.permission_resolved"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		requestId: Schema.String,
+		agentId: AgentId,
+		issueId: Schema.optional(IssueId),
+		behavior: ClaudeChannelPermissionBehavior
+	})
+});
+const AgentMessageReceivedEvent = Schema.Struct({
+	type: Schema.Literal("agent.message_received"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		direction: Schema.Literals(["to_agent", "from_agent"]),
+		source: Schema.Literals([
+			"user",
+			"cloister",
+			"specialist",
+			"automated"
+		])
+	})
+});
+const AgentChannelReplyEvent = Schema.Struct({
+	type: Schema.Literal("agent.channel_reply"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		reply: AgentChannelReply
+	})
+});
+const AgentModelSetEvent = Schema.Struct({
+	type: Schema.Literal("agent.model_set"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		model: Schema.String,
+		claudeSessionId: Schema.optional(Schema.String),
+		sessionModel: Schema.optional(Schema.String),
+		sessionHarness: Schema.optional(Schema.String)
+	})
+});
+const AgentCurrentIssueSetEvent = Schema.Struct({
+	type: Schema.Literal("agent.current_issue_set"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		currentIssue: Schema.optional(IssueId)
+	})
+});
+const AgentContextSaturationChangedEvent = Schema.Struct({
+	type: Schema.Literal("agent.context_saturation_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		contextSaturatedAt: Schema.optional(Schema.String)
+	})
+});
+const AgentResolutionChangedEvent = Schema.Struct({
+	type: Schema.Literal("agent.resolution_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		resolution: AgentResolution,
+		resolutionCount: Schema.Number
+	})
+});
+/**
+* Bootstrap-only event emitted by AgentStateService when it seeds a runtime
+* snapshot during bootstrap (reconstruction from sources, PAN-1920). Not
+* emitted by hooks.
+*/
+const AgentStateRestoredEvent = Schema.Struct({
+	type: Schema.Literal("agent.state_restored"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		snapshot: AgentRuntimeSnapshot
+	})
+});
+/** Emitted when a turn diff checkpoint is captured and diff computed */
+const AgentTurnDiffCompletedEvent = Schema.Struct({
+	type: Schema.Literal("agent.turn_diff_completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		turnId: Schema.String,
+		completedAt: Schema.String,
+		files: Schema.Array(Schema.Struct({
+			path: Schema.String,
+			kind: Schema.optional(Schema.String),
+			additions: Schema.optional(Schema.Number),
+			deletions: Schema.optional(Schema.Number)
+		})),
+		checkpointRef: Schema.optional(Schema.String),
+		assistantMessageId: Schema.optional(Schema.String),
+		checkpointTurnCount: Schema.optional(Schema.Number)
+	})
+});
+/** Replaces socket.io `planning:started` */
+const PlanningStartedEvent = Schema.Struct({
+	type: Schema.Literal("planning.started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		sessionName: Schema.String,
+		harness: Schema.optional(Schema.String)
+	})
+});
+/** Replaces socket.io `planning:failed` */
+const PlanningFailedEvent = Schema.Struct({
+	type: Schema.Literal("planning.failed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		error: Schema.String
+	})
+});
+/** Replaces socket.io `planning:sync` */
+const PlanningSyncEvent = Schema.Struct({
+	type: Schema.Literal("planning.sync"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		status: Schema.String,
+		progress: Schema.optional(Schema.Number),
+		message: Schema.optional(Schema.String)
+	})
+});
+/** Replaces socket.io `plan:item-status-changed` */
+const PlanItemStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("plan.item_status_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		itemId: Schema.String,
+		status: Schema.String
+	})
+});
+/** Replaces socket.io `plan:subitem-status-changed` */
+const PlanSubitemStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("plan.subitem_status_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		itemId: Schema.String,
+		subItemId: Schema.String,
+		status: Schema.String
+	})
+});
+/** Replaces socket.io `plan:items-unblocked` */
+const PlanItemsUnblockedEvent = Schema.Struct({
+	type: Schema.Literal("plan.items_unblocked"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		items: Schema.Array(Schema.String)
+	})
+});
+/** Replaces socket.io `pipeline:status` */
+const PipelineStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("pipeline.status_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		status: ReviewStatusSnapshot
+	})
+});
+/** Replaces socket.io `merge:ready` */
+const MergeReadyEvent = Schema.Struct({
+	type: Schema.Literal("merge.ready"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — review status changed */
+const ReviewStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("review.status_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		status: ReviewStatusSnapshot
+	})
+});
+/** New — review specialist dispatched */
+const PipelineReviewStartedEvent = Schema.Struct({
+	type: Schema.Literal("pipeline.review-started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — review specialist finished (passed or failed) */
+const PipelineReviewCompletedEvent = Schema.Struct({
+	type: Schema.Literal("pipeline.review-completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		passed: Schema.Boolean
+	})
+});
+/** New — test specialist dispatched */
+const PipelineTestStartedEvent = Schema.Struct({
+	type: Schema.Literal("pipeline.test-started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — test specialist finished (passed or failed) */
+const PipelineTestCompletedEvent = Schema.Struct({
+	type: Schema.Literal("pipeline.test-completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		passed: Schema.Boolean
+	})
+});
+const OperatorInterventionEvent = Schema.Struct({
+	type: Schema.Literal("operator.intervention"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		kind: Schema.Literals([
+			"tell",
+			"pause",
+			"restart",
+			"manual_edit",
+			"deep_wipe",
+			"unpause",
+			"untroubled"
+		]),
+		source: Schema.String
+	})
+});
+const SubstrateBugFiledEvent = Schema.Struct({
+	type: Schema.Literal("substrate.bug_filed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		runId: Schema.optional(Schema.String),
+		filedBy: Schema.Literals(["agent", "operator"]),
+		discoveredIn: Schema.optional(IssueId),
+		severity: Schema.Literals([
+			"P0",
+			"P1",
+			"P2"
+		])
+	})
+});
+/**
+* PAN-915 — reviewer session received a new prompt (spawn or resume of a
+* canonical PAN-830 session). Drives event-driven `reviewSubStatuses[role] =
+* 'running'` and tracking of `reviewSessionNames` without polling tmux.
+*/
+const ReviewReviewerStartedEvent = Schema.Struct({
+	type: Schema.Literal("review.reviewer_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		role: Schema.String,
+		sessionName: Schema.String
+	})
+});
+/**
+* PAN-915 — reviewer wrote its output file (round complete for that role).
+* Updates `reviewSubStatuses[role] = 'done'` event-driven.
+*/
+const ReviewReviewerCompletedEvent = Schema.Struct({
+	type: Schema.Literal("review.reviewer_completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		role: Schema.String
+	})
+});
+/**
+* Review specialist timeout telemetry. Emitted once per timed-out reviewer wait
+* attempt so operators can distinguish transient auto-retries from terminal
+* review failures.
+*/
+const ReviewSpecialistTimedOutEvent = Schema.Struct({
+	type: Schema.Literal("review.specialist.timed_out"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		role: Schema.String,
+		sessionName: Schema.String,
+		attempt: Schema.Number,
+		maxRetries: Schema.Number,
+		willRetry: Schema.Boolean
+	})
+});
+/**
+* PAN-915 — review coordinator session spawned. Surfaces in the dashboard so
+* the kanban card can show "review in progress" the instant the coordinator
+* starts, not after the first reviewer finishes.
+*/
+const ReviewCoordinatorStartedEvent = Schema.Struct({
+	type: Schema.Literal("review.coordinator_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		sessionName: Schema.String
+	})
+});
+/** Review coordinator died before writing a terminal exit marker. */
+const ReviewCoordinatorDiedEvent = Schema.Struct({
+	type: Schema.Literal("review.coordinator.died"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		sessionName: Schema.String,
+		reason: Schema.String
+	})
+});
+const SpecialistLifecycleState = Schema.Literals([
+	"active",
+	"sleeping",
+	"uninitialized"
+]);
+/** New — role-backed specialist became active */
+const SpecialistStartedEvent = Schema.Struct({
+	type: Schema.Literal("specialist.started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		name: Role,
+		state: SpecialistLifecycleState,
+		isRunning: Schema.Boolean,
+		currentIssue: Schema.optional(Schema.String),
+		lastWake: Schema.optional(Schema.String)
+	})
+});
+/** New — role-backed specialist completed work */
+const SpecialistCompletedEvent = Schema.Struct({
+	type: Schema.Literal("specialist.completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		name: Role,
+		issueId: Schema.optional(IssueId)
+	})
+});
+/** New — role-backed specialist failed */
+const SpecialistFailedEvent = Schema.Struct({
+	type: Schema.Literal("specialist.failed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		name: Role,
+		issueId: Schema.optional(IssueId),
+		error: Schema.String
+	})
+});
+/** Replaces socket.io `resources:updated` */
+const ResourcesUpdatedEvent = Schema.Struct({
+	type: Schema.Literal("resources.updated"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ resources: ResourceStats })
+});
+const SystemHealthSeverityChangedEvent = Schema.Struct({
+	type: Schema.Literal("system.health_severity_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		previousSeverity: Schema.String,
+		severity: Schema.String,
+		reasons: Schema.Array(Schema.String),
+		leakedSpecialistCount: Schema.Number
+	})
+});
+/** Replaces socket.io `issues:snapshot` */
+const IssuesSnapshotEvent = Schema.Struct({
+	type: Schema.Literal("issues.snapshot"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issues: Schema.Array(Schema.Unknown) })
+});
+/** Replaces socket.io `issues:updated` */
+const IssuesUpdatedEvent = Schema.Struct({
+	type: Schema.Literal("issues.updated"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: Schema.optional(IssueId) })
+});
+/** Patch a single issue's status in the read model without a full snapshot refresh. */
+const IssueStatusChangedEvent = Schema.Struct({
+	type: Schema.Literal("issue.statusChanged"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		status: Schema.String,
+		canonicalStatus: Schema.String,
+		labels: Schema.optional(Schema.Array(Schema.String))
+	})
+});
+/** Replaces socket.io `godview:activity` */
+const ActivityUpdatedEvent = Schema.Struct({
+	type: Schema.Literal("activity.updated"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ events: Schema.Array(Schema.Unknown) })
+});
+/** Individual activity log entry — emitted by merge-agent, cloister, specialists (PAN-520) */
+const ActivityEntryEvent = Schema.Struct({
+	type: Schema.Literal("activity.entry"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		id: Schema.String,
+		source: Schema.String,
+		level: Schema.String,
+		message: Schema.String,
+		details: Schema.optional(Schema.String),
+		issueId: Schema.optional(IssueId),
+		/** Dashboard route the feed navigates to on click (e.g. /conv/<name>, /flywheel). */
+		link: Schema.optional(Schema.String)
+	})
+});
+/** Detailed activity log — auto-generated from domain state changes */
+const ActivityDetailedEvent = Schema.Struct({
+	type: Schema.Literal("activity.detailed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		id: Schema.String,
+		source: Schema.String,
+		level: Schema.String,
+		message: Schema.String,
+		details: Schema.optional(Schema.String),
+		issueId: Schema.optional(IssueId),
+		triggeringEvent: Schema.optional(Schema.String)
+	})
+});
+/** TTS activity log — upleveled utterances for text-to-speech */
+const ActivityTtsEvent = Schema.Struct({
+	type: Schema.Literal("activity.tts"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		id: Schema.String,
+		utterance: Schema.String,
+		priority: Schema.optional(Schema.Number),
+		issueId: Schema.optional(IssueId),
+		source: Schema.optional(Schema.String),
+		eventType: Schema.optional(Schema.String)
+	})
+});
+/** Dashboard is restarting (post-merge deploy, pan restart, etc.) (PAN-520) */
+const DashboardLifecycleStartedEvent = Schema.Struct({
+	type: Schema.Literal("dashboard.lifecycle_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		reason: Schema.String,
+		issueId: Schema.optional(IssueId),
+		trigger: Schema.String
+	})
+});
+/** Dashboard restarted successfully after a lifecycle event (PAN-520) */
+const DashboardLifecycleCompletedEvent = Schema.Struct({
+	type: Schema.Literal("dashboard.lifecycle_completed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		reason: Schema.String,
+		issueId: Schema.optional(IssueId),
+		durationMs: Schema.Number
+	})
+});
+/** Dashboard restart failed (PAN-520) */
+const DashboardLifecycleFailedEvent = Schema.Struct({
+	type: Schema.Literal("dashboard.lifecycle_failed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		reason: Schema.String,
+		issueId: Schema.optional(IssueId),
+		error: Schema.String
+	})
+});
+/** Replaces socket.io `shadow:inference-update` */
+const ShadowInferenceUpdateEvent = Schema.Struct({
+	type: Schema.Literal("shadow.inference_update"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		content: Schema.String
+	})
+});
+/** New — workspace worktree created (before planning.started) */
+const WorkspaceCreatedEvent = Schema.Struct({
+	type: Schema.Literal("workspace.created"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		workspacePath: Schema.String
+	})
+});
+/** New — deep-wipe started (transitional state for UI spinner) */
+const WorkspaceWipeStartedEvent = Schema.Struct({
+	type: Schema.Literal("workspace.wipe_started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — deep-wipe completed, workspace fully destroyed */
+const WorkspaceDestroyedEvent = Schema.Struct({
+	type: Schema.Literal("workspace.destroyed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — cleanup-workspace completed, workspace directory removed */
+const WorkspaceDeletedEvent = Schema.Struct({
+	type: Schema.Literal("workspace.deleted"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ issueId: IssueId })
+});
+/** New — planning aborted, workspace returned to idle state */
+const WorkspaceAbortedEvent = Schema.Struct({
+	type: Schema.Literal("workspace.aborted"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		issueId: IssueId,
+		sessionName: Schema.optional(Schema.String)
+	})
+});
+const MemoryObservationCreatedEvent = Schema.Struct({
+	type: Schema.Literal("memory.observation_created"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ observation: MemoryObservation })
+});
+const MemoryStatusUpdatedEvent = Schema.Struct({
+	type: Schema.Literal("memory.status_updated"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		identity: Schema.Struct({
+			projectId: Schema.String,
+			workspaceId: Schema.String,
+			issueId: IssueId
+		}),
+		status: MemoryStatus,
+		previousStatus: Schema.optional(MemoryStatus)
+	})
+});
+const MemoryRollupTriggeredEvent = Schema.Struct({
+	type: Schema.Literal("memory.rollup_triggered"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		projectId: Schema.String,
+		workspaceId: Schema.String,
+		issueId: IssueId,
+		pendingCount: Schema.Number,
+		turnIds: Schema.Array(Schema.String),
+		threshold: Schema.Number
+	})
+});
+const MemoryResetMarkerCreatedEvent = Schema.Struct({
+	type: Schema.Literal("memory.reset_marker_created"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ marker: ResetMarker })
+});
+const MemoryHealthChangedEvent = Schema.Struct({
+	type: Schema.Literal("memory.health_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		projectId: Schema.String,
+		issueId: IssueId,
+		status: Schema.Literals([
+			"healthy",
+			"degraded",
+			"failing"
+		]),
+		reason: Schema.NullOr(Schema.String),
+		detail: Schema.optional(Schema.String),
+		ragDecision: Schema.optional(RagDecision)
+	})
+});
+/** New — cost event recorded in the store */
+const CostEventRecordedEvent = Schema.Struct({
+	type: Schema.Literal("cost.event_recorded"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		agentId: AgentId,
+		issueId: IssueId,
+		cost: Schema.Number,
+		inputTokens: Schema.Number,
+		outputTokens: Schema.Number
+	})
+});
+/** Emitted (in-memory only, not persisted) when a Overdeck-native compaction starts or completes. */
+const ConversationCompactingChangedEvent = Schema.Struct({
+	type: Schema.Literal("conversation.compacting_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		conversationName: Schema.String,
+		compacting: Schema.Boolean
+	})
+});
+/** Emitted (in-memory only) when a new conversation row is created, so the
+* sidebar list can refresh immediately instead of waiting for its poll tick. */
+const ConversationCreatedEvent = Schema.Struct({
+	type: Schema.Literal("conversation.created"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({ conversationName: Schema.String })
+});
+/** Emitted (in-memory only) when a PermissionRequest hook fires or resolves for a conversation. */
+const ConversationPermissionChangedEvent = Schema.Struct({
+	type: Schema.Literal("conversation.permission_changed"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		conversationName: Schema.String,
+		waiting: Schema.Boolean,
+		toolName: Schema.optional(Schema.String)
+	})
+});
+/** Scan started */
+const ScanStartedEvent = Schema.Struct({
+	type: Schema.Literal("scan.started"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		mode: Schema.Literals([
+			"targeted",
+			"watched",
+			"system"
+		]),
+		dirs: Schema.Array(Schema.String)
+	})
+});
+/** Scan progress tick */
+const ScanProgressEvent = Schema.Struct({
+	type: Schema.Literal("scan.progress"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		dirsProcessed: Schema.Number,
+		dirsTotal: Schema.Number,
+		sessionsFound: Schema.Number,
+		elapsedMs: Schema.Number
+	})
+});
+/** Scan completed */
+const ScanCompleteEvent = Schema.Struct({
+	type: Schema.Literal("scan.complete"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		inserted: Schema.Number,
+		updated: Schema.Number,
+		skipped: Schema.Number,
+		errors: Schema.Number,
+		durationMs: Schema.Number
+	})
+});
+/** Per-session enrichment progress */
+const EnrichProgressEvent = Schema.Struct({
+	type: Schema.Literal("enrich.progress"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		sessionId: Schema.Number,
+		level: Schema.Number,
+		model: Schema.String,
+		cost: Schema.Number,
+		success: Schema.Boolean,
+		error: Schema.optional(Schema.String)
+	})
+});
+/** Enrichment batch completed */
+const EnrichCompleteEvent = Schema.Struct({
+	type: Schema.Literal("enrich.complete"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		processed: Schema.Number,
+		totalCost: Schema.Number,
+		failures: Schema.Number,
+		durationMs: Schema.Number
+	})
+});
+/** Per-session embedding progress */
+const EmbedProgressEvent = Schema.Struct({
+	type: Schema.Literal("embed.progress"),
+	sequence: SequenceNumber,
+	timestamp: Schema.String,
+	payload: Schema.Struct({
+		sessionId: Schema.Number,
+		model: Schema.String,
+		success: Schema.Boolean,
+		error: Schema.optional(Schema.String)
+	})
+});
+/** All domain events — the shape streamed via subscribeDomainEvents RPC */
+const DomainEvent = Schema.Union([
+	SystemHeartbeatEvent,
+	AgentCreatedEvent,
+	AgentEnrichmentChangedEvent,
+	AgentStartedEvent,
+	AgentStoppedEvent,
+	AgentHeartbeatDeadEvent,
+	WorkCompletedEvent,
+	AgentCompletedEvent,
+	ReviewApprovedEvent,
+	TestPassedEvent,
+	AgentStatusChangedEvent,
+	AgentOutputReceivedEvent,
+	AgentActivityChangedEvent,
+	AgentThinkingStartedEvent,
+	AgentThinkingStoppedEvent,
+	AgentWaitingStartedEvent,
+	AgentWaitingClearedEvent,
+	AgentPermissionRequestedEvent,
+	AgentPermissionResolvedEvent,
+	AgentMessageReceivedEvent,
+	AgentChannelReplyEvent,
+	AgentModelSetEvent,
+	AgentCurrentIssueSetEvent,
+	AgentContextSaturationChangedEvent,
+	AgentResolutionChangedEvent,
+	AgentStateRestoredEvent,
+	AgentTurnDiffCompletedEvent,
+	PlanningStartedEvent,
+	PlanningFailedEvent,
+	PlanningSyncEvent,
+	PlanItemStatusChangedEvent,
+	PlanSubitemStatusChangedEvent,
+	PlanItemsUnblockedEvent,
+	PipelineStatusChangedEvent,
+	MergeReadyEvent,
+	ReviewStatusChangedEvent,
+	PipelineReviewStartedEvent,
+	PipelineReviewCompletedEvent,
+	PipelineTestStartedEvent,
+	PipelineTestCompletedEvent,
+	OperatorInterventionEvent,
+	SubstrateBugFiledEvent,
+	ReviewReviewerStartedEvent,
+	ReviewReviewerCompletedEvent,
+	ReviewSpecialistTimedOutEvent,
+	ReviewCoordinatorStartedEvent,
+	ReviewCoordinatorDiedEvent,
+	SpecialistStartedEvent,
+	SpecialistCompletedEvent,
+	SpecialistFailedEvent,
+	ResourcesUpdatedEvent,
+	SystemHealthSeverityChangedEvent,
+	IssuesSnapshotEvent,
+	IssuesUpdatedEvent,
+	IssueStatusChangedEvent,
+	ActivityUpdatedEvent,
+	ActivityEntryEvent,
+	ActivityDetailedEvent,
+	ActivityTtsEvent,
+	ShadowInferenceUpdateEvent,
+	MemoryObservationCreatedEvent,
+	MemoryStatusUpdatedEvent,
+	MemoryRollupTriggeredEvent,
+	MemoryResetMarkerCreatedEvent,
+	MemoryHealthChangedEvent,
+	CostEventRecordedEvent,
+	WorkspaceCreatedEvent,
+	WorkspaceWipeStartedEvent,
+	WorkspaceDestroyedEvent,
+	WorkspaceDeletedEvent,
+	WorkspaceAbortedEvent,
+	DashboardLifecycleStartedEvent,
+	DashboardLifecycleCompletedEvent,
+	DashboardLifecycleFailedEvent,
+	ConversationCompactingChangedEvent,
+	ConversationCreatedEvent,
+	ConversationPermissionChangedEvent,
+	ScanStartedEvent,
+	ScanProgressEvent,
+	ScanCompleteEvent,
+	EnrichProgressEvent,
+	EnrichCompleteEvent,
+	EmbedProgressEvent
+]);
+//#endregion
+//#region src/editor.ts
+const EDITORS = [
+	{
+		id: "cursor",
+		label: "Cursor",
+		command: "cursor",
+		supportsGoto: true
+	},
+	{
+		id: "windsurf",
+		label: "Windsurf",
+		command: "windsurf",
+		supportsGoto: true
+	},
+	{
+		id: "trae",
+		label: "Trae",
+		command: "trae",
+		supportsGoto: true
+	},
+	{
+		id: "kiro",
+		label: "Kiro",
+		command: "kiro",
+		supportsGoto: true
+	},
+	{
+		id: "vscode",
+		label: "VS Code",
+		command: "code",
+		supportsGoto: true
+	},
+	{
+		id: "vscode-insiders",
+		label: "VS Code Insiders",
+		command: "code-insiders",
+		supportsGoto: true
+	},
+	{
+		id: "vscodium",
+		label: "VSCodium",
+		command: "codium",
+		supportsGoto: true
+	},
+	{
+		id: "zed",
+		label: "Zed",
+		command: "zed",
+		supportsGoto: false
+	},
+	{
+		id: "antigravity",
+		label: "Antigravity",
+		command: "agy",
+		supportsGoto: false
+	},
+	{
+		id: "idea",
+		label: "IntelliJ IDEA",
+		command: "idea",
+		supportsGoto: true
+	},
+	{
+		id: "aqua",
+		label: "Aqua",
+		command: "aqua",
+		supportsGoto: true
+	},
+	{
+		id: "clion",
+		label: "CLion",
+		command: "clion",
+		supportsGoto: true
+	},
+	{
+		id: "datagrip",
+		label: "DataGrip",
+		command: "datagrip",
+		supportsGoto: true
+	},
+	{
+		id: "dataspell",
+		label: "DataSpell",
+		command: "dataspell",
+		supportsGoto: true
+	},
+	{
+		id: "goland",
+		label: "GoLand",
+		command: "goland",
+		supportsGoto: true
+	},
+	{
+		id: "phpstorm",
+		label: "PhpStorm",
+		command: "phpstorm",
+		supportsGoto: true
+	},
+	{
+		id: "pycharm",
+		label: "PyCharm",
+		command: "pycharm",
+		supportsGoto: true
+	},
+	{
+		id: "rider",
+		label: "Rider",
+		command: "rider",
+		supportsGoto: true
+	},
+	{
+		id: "rubymine",
+		label: "RubyMine",
+		command: "rubymine",
+		supportsGoto: true
+	},
+	{
+		id: "rustrover",
+		label: "RustRover",
+		command: "rustrover",
+		supportsGoto: true
+	},
+	{
+		id: "webstorm",
+		label: "WebStorm",
+		command: "webstorm",
+		supportsGoto: true
+	},
+	{
+		id: "file-manager",
+		label: "File Manager",
+		command: null,
+		supportsGoto: false
+	}
+];
+const EditorIdSchema = Schema.Literals([
+	"cursor",
+	"windsurf",
+	"trae",
+	"kiro",
+	"vscode",
+	"vscode-insiders",
+	"vscodium",
+	"zed",
+	"antigravity",
+	"idea",
+	"aqua",
+	"clion",
+	"datagrip",
+	"dataspell",
+	"goland",
+	"phpstorm",
+	"pycharm",
+	"rider",
+	"rubymine",
+	"rustrover",
+	"webstorm",
+	"file-manager"
+]);
+const OpenInEditorInput = Schema.Struct({
+	cwd: Schema.String,
+	editor: EditorIdSchema
+});
+//#endregion
+//#region src/flywheel.ts
+const FlywheelRunId = Schema.String.check(Schema.isPattern(/^RUN-\d+$/));
+const FlywheelHttpUrl = Schema.String.check(Schema.isPattern(/^https?:\/\/\S+$/i));
+const FlywheelHarness = Schema.Literals([
+	"claude-code",
+	"pi",
+	"codex"
+]);
+const FlywheelEffort = Schema.Literals([
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+]);
+const FlywheelOrchestrator = Schema.Struct({
+	harness: FlywheelHarness,
+	model: Schema.String,
+	effort: FlywheelEffort,
+	ctxPercent: Schema.Number
+});
+const FlywheelHeadline = Schema.Struct({
+	bugsFixed: Schema.Number,
+	swarmItemsMerged: Schema.Number,
+	swarmItemsTotal: Schema.Number,
+	prsMerged: Schema.Number,
+	awaitingUat: Schema.Number
+});
+/**
+* Pipeline verbs and the merge-queue contract (PAN-1736):
+*
+* `computeMergeQueue` treats an item as AT THE MERGE GATE when its verb is
+* "shipping" OR "merging" — both are natural emissions for a merge-ready
+* issue, and orchestrators have used each. Emitting any OTHER verb for an
+* issue that is ready_for_merge in the review DB silently drops it from the
+* merge queue and from UAT batch assembly (PAN-1737). RUN-18 shipped an
+* empty queue with five ready issues exactly this way.
+*
+* If you add a verb that can describe a merge-ready issue, extend
+* MERGE_GATE_VERBS in src/lib/flywheel-merge-order.ts in the same change.
+*/
+const FlywheelPipelineVerb = Schema.Literals([
+	"planning",
+	"working",
+	"reviewing",
+	"testing",
+	"shipping",
+	"merging",
+	"blocked",
+	"parked"
+]);
+const FlywheelPipelineStatus = Schema.Literals([
+	"queued",
+	"running",
+	"blocked",
+	"passed",
+	"failed",
+	"merged",
+	"parked"
+]);
+const FlywheelPipelineItem = Schema.Struct({
+	issueId: Schema.String,
+	title: Schema.String,
+	verb: FlywheelPipelineVerb,
+	status: FlywheelPipelineStatus,
+	progressPercent: Schema.optional(Schema.Number),
+	agentId: Schema.optional(Schema.String),
+	pr: Schema.optional(Schema.Number),
+	mergeOrder: Schema.optional(Schema.Number),
+	conflictsWith: Schema.optional(Schema.Array(Schema.String))
+});
+const FlywheelSubstrateBugStatus = Schema.Literals([
+	"filed",
+	"fixed",
+	"workaround"
+]);
+const FlywheelSubstrateBug = Schema.Struct({
+	issueId: Schema.String,
+	title: Schema.String,
+	status: FlywheelSubstrateBugStatus,
+	commitSha: Schema.optional(Schema.String),
+	url: Schema.optional(FlywheelHttpUrl)
+});
+const FlywheelAgentStatus = Schema.Literals([
+	"starting",
+	"running",
+	"waiting",
+	"idle",
+	"stopped",
+	"error"
+]);
+const FlywheelAgent = Schema.Struct({
+	id: Schema.String,
+	label: Schema.String,
+	status: FlywheelAgentStatus,
+	issueId: Schema.optional(Schema.String),
+	role: Schema.optional(Schema.String),
+	model: Schema.optional(Schema.String),
+	ctxPercent: Schema.optional(Schema.Number),
+	currentAction: Schema.optional(Schema.String)
+});
+const FlywheelParkedItem = Schema.Struct({
+	issueId: Schema.String,
+	title: Schema.String,
+	reason: Schema.String,
+	parkedAt: Schema.optional(Schema.String)
+});
+const FlywheelSuggestionAction = Schema.Literals([
+	"start",
+	"resume",
+	"plan",
+	"review",
+	"merge",
+	"unblock",
+	"park",
+	"investigate",
+	"wait"
+]);
+const FlywheelSuggestionPriority = Schema.Literals([
+	"urgent",
+	"high",
+	"medium",
+	"low"
+]);
+const FlywheelSuggestion = Schema.Struct({
+	action: FlywheelSuggestionAction,
+	issueId: Schema.optional(Schema.String),
+	rationale: Schema.String,
+	priority: FlywheelSuggestionPriority
+});
+const FlywheelSystemStatus = Schema.Struct({
+	mainHead: Schema.String,
+	ramUsedMb: Schema.Number,
+	ramTotalMb: Schema.Number,
+	swapUsedMb: Schema.Number,
+	swapTotalMb: Schema.Number,
+	agentsActive: Schema.Number,
+	agentsCap: Schema.Number
+});
+const FlywheelStatus = Schema.Struct({
+	runId: FlywheelRunId,
+	startedAt: Schema.String,
+	elapsedMs: Schema.Number,
+	orchestrator: FlywheelOrchestrator,
+	headline: FlywheelHeadline,
+	activePipeline: Schema.Array(FlywheelPipelineItem),
+	substrateBugs: Schema.Array(FlywheelSubstrateBug),
+	agents: Schema.Array(FlywheelAgent),
+	parked: Schema.Array(FlywheelParkedItem),
+	suggestions: Schema.Array(FlywheelSuggestion).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+	system: FlywheelSystemStatus,
+	openQuestions: Schema.Array(Schema.String),
+	ticks: Schema.Number,
+	lastTickAt: Schema.String
+});
+//#endregion
+//#region src/rpc.ts
+const WS_METHODS = {
+	scanConversations: "pan.scanConversations",
+	searchConversations: "pan.searchConversations",
+	listDiscoveredSessions: "pan.listDiscoveredSessions",
+	getDiscoveredSession: "pan.getDiscoveredSession",
+	enrichSessions: "pan.enrichSessions",
+	embedSessions: "pan.embedSessions",
+	getConversationCost: "pan.getConversationCost",
+	getConversationCostByWorkspace: "pan.getConversationCostByWorkspace",
+	getConversationStats: "pan.getConversationStats",
+	subscribeDomainEvents: "pan.subscribeDomainEvents",
+	subscribeIssueEvents: "pan.subscribeIssueEvents",
+	subscribeTerminal: "pan.subscribeTerminal",
+	subscribeAgentOutput: "pan.subscribeAgentOutput",
+	subscribeConversationMessages: "pan.subscribeConversationMessages",
+	subscribeProjectSessionTree: "pan.subscribeProjectSessionTree",
+	subscribeFlywheelStatus: "pan.subscribeFlywheelStatus",
+	getSnapshot: "pan.getSnapshot",
+	replayEvents: "pan.replayEvents",
+	getWorkspaceDetail: "pan.getWorkspaceDetail",
+	readWorkspaceFile: "pan.readWorkspaceFile",
+	resolveFilePathExists: "pan.resolveFilePathExists",
+	terminalOpen: "pan.terminalOpen",
+	terminalWrite: "pan.terminalWrite",
+	terminalResize: "pan.terminalResize",
+	terminalClose: "pan.terminalClose",
+	startPlanning: "pan.startPlanning",
+	startAgent: "pan.startAgent",
+	deepWipe: "pan.deepWipe",
+	sendTerminalInput: "pan.sendTerminalInput",
+	resizeTerminal: "pan.resizeTerminal",
+	shellOpenInEditor: "pan.shellOpenInEditor",
+	getAvailableEditors: "pan.getAvailableEditors"
+};
+var PanRpcError = class extends Schema.TaggedErrorClass()("PanRpcError", {
+	message: Schema.String,
+	code: Schema.optional(Schema.String)
+}) {};
+const TerminalOutput = Schema.Struct({
+	sessionName: Schema.String,
+	data: Schema.String
+});
+const AgentOutput = Schema.Struct({
+	agentId: Schema.String,
+	line: Schema.String
+});
+const ProposedPlan = Schema.Struct({
+	id: Schema.String,
+	plan: Schema.String,
+	planFilePath: Schema.optional(Schema.String),
+	status: Schema.Literals([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	createdAt: Schema.String,
+	resolvedAt: Schema.optional(Schema.String)
+});
+const CompactBoundary = Schema.Struct({
+	id: Schema.String,
+	timestamp: Schema.String,
+	trigger: Schema.optional(Schema.String),
+	preTokens: Schema.optional(Schema.Number),
+	model: Schema.optional(Schema.String)
+});
+const ContextUsage = Schema.Struct({
+	activeBytes: Schema.Number,
+	estimatedTokens: Schema.Number,
+	contextWindow: Schema.Number,
+	percentUsed: Schema.Number,
+	/**
+	* Optional breakdown of the last assistant turn — surfaced by the click
+	* popover on the ContextWindowMeter so users can see WHY the meter says
+	* what it does. Computed by `computeContextUsage()` from JSONL `usage`.
+	*/
+	lastInputTokens: Schema.optional(Schema.Number),
+	lastCacheReadTokens: Schema.optional(Schema.Number),
+	lastCacheCreationTokens: Schema.optional(Schema.Number),
+	/** Highest input_tokens ever observed in this window — triggers 1M detection. */
+	maxObservedInputTokens: Schema.optional(Schema.Number),
+	/** Model the most recent assistant turn ran under (from JSONL). */
+	lastModel: Schema.optional(Schema.NullOr(Schema.String)),
+	/** ISO timestamp of the most recent assistant turn. */
+	lastTurnAt: Schema.optional(Schema.NullOr(Schema.String))
+});
+const ChatMessage = Schema.Struct({
+	id: Schema.String,
+	role: Schema.Literals([
+		"user",
+		"assistant",
+		"system"
+	]),
+	text: Schema.String,
+	turnId: Schema.optional(Schema.String),
+	createdAt: Schema.String,
+	completedAt: Schema.optional(Schema.String),
+	streaming: Schema.optional(Schema.Boolean),
+	sequence: Schema.optional(Schema.Number)
+});
+const WorkLogEntry = Schema.Struct({
+	id: Schema.String,
+	createdAt: Schema.String,
+	label: Schema.String,
+	detail: Schema.optional(Schema.String),
+	/** Tool result output (populated when tool_result is received). */
+	result: Schema.optional(Schema.String),
+	command: Schema.optional(Schema.String),
+	changedFiles: Schema.optional(Schema.Array(Schema.String)),
+	tone: Schema.Literals([
+		"thinking",
+		"tool",
+		"info",
+		"error"
+	]),
+	toolTitle: Schema.optional(Schema.String),
+	/** Raw tool_use input dict — drives per-tool expanded rendering (PAN-1459). */
+	toolInput: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	sequence: Schema.optional(Schema.Number)
+});
+const ConversationEvent = Schema.Union([Schema.Struct({
+	kind: Schema.Literal("messages"),
+	messages: Schema.Array(ChatMessage),
+	workLog: Schema.Array(WorkLogEntry),
+	streaming: Schema.Boolean,
+	snapshot: Schema.optional(Schema.Boolean),
+	proposedPlan: Schema.optional(ProposedPlan),
+	compactBoundaries: Schema.optional(Schema.Array(CompactBoundary)),
+	contextUsage: Schema.optional(Schema.NullOr(ContextUsage))
+}), Schema.Struct({ kind: Schema.Literal("discovering") })]);
+const SessionTreeDelta = Schema.Struct({
+	kind: Schema.Literals([
+		"session_added",
+		"session_removed",
+		"presence_changed",
+		"status_changed"
+	]),
+	issueId: Schema.String,
+	sessionId: Schema.String,
+	presence: Schema.optional(SessionNodePresence),
+	status: Schema.optional(AgentStatus),
+	timestamp: Schema.String
+});
+/** 1. Subscribe to the live domain event stream (stream) */
+const SubscribeDomainEventsRpc = Rpc.make(WS_METHODS.subscribeDomainEvents, {
+	payload: Schema.Struct({}),
+	success: DomainEvent,
+	stream: true
+});
+/** 1b. Subscribe to the live domain event stream for one issue (stream) */
+const SubscribeIssueEventsRpc = Rpc.make(WS_METHODS.subscribeIssueEvents, {
+	payload: Schema.Struct({ issueId: IssueId }),
+	success: DomainEvent,
+	stream: true
+});
+/** 2. Subscribe to raw terminal output for a tmux session (stream) */
+const SubscribeTerminalRpc = Rpc.make(WS_METHODS.subscribeTerminal, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		cols: Schema.Number,
+		rows: Schema.Number
+	}),
+	success: TerminalOutput,
+	error: PanRpcError,
+	stream: true
+});
+/** 3. Subscribe to buffered agent stdout (stream) */
+const SubscribeAgentOutputRpc = Rpc.make(WS_METHODS.subscribeAgentOutput, {
+	payload: Schema.Struct({ agentId: Schema.String }),
+	success: AgentOutput,
+	error: PanRpcError,
+	stream: true
+});
+/** 4. Get current dashboard snapshot (unary) */
+const GetSnapshotRpc = Rpc.make(WS_METHODS.getSnapshot, {
+	payload: Schema.Struct({}),
+	success: DashboardSnapshot,
+	error: PanRpcError
+});
+/** 5. Replay events since a given sequence number (unary) */
+const ReplayEventsRpc = Rpc.make(WS_METHODS.replayEvents, {
+	payload: Schema.Struct({ fromSequence: SequenceNumber }),
+	success: Schema.Array(DomainEvent),
+	error: PanRpcError
+});
+/** 6. Open a terminal session / attach PTY (unary) */
+const TerminalOpenRpc = Rpc.make(WS_METHODS.terminalOpen, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		cols: Schema.Number,
+		rows: Schema.Number
+	}),
+	success: Schema.Struct({ sessionName: Schema.String }),
+	error: PanRpcError
+});
+/** 7. Write data to a terminal session (unary) */
+const TerminalWriteRpc = Rpc.make(WS_METHODS.terminalWrite, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		data: Schema.String
+	}),
+	error: PanRpcError
+});
+/** 8. Resize a terminal session (unary) */
+const TerminalResizeRpc = Rpc.make(WS_METHODS.terminalResize, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		cols: Schema.Number,
+		rows: Schema.Number
+	}),
+	error: PanRpcError
+});
+/** 9. Close a terminal session (unary) */
+const TerminalCloseRpc = Rpc.make(WS_METHODS.terminalClose, {
+	payload: Schema.Struct({ sessionName: Schema.String }),
+	error: PanRpcError
+});
+/** 10. Get batched workspace detail (unary) — replaces 5 separate HTTP calls */
+const GetWorkspaceDetailRpc = Rpc.make(WS_METHODS.getWorkspaceDetail, {
+	payload: Schema.Struct({ issueId: IssueId }),
+	success: WorkspaceDetail,
+	error: PanRpcError
+});
+const ReadWorkspaceFileInput = Schema.Struct({
+	issueId: IssueId,
+	relativePath: Schema.String,
+	line: Schema.optional(Schema.Number),
+	contextLines: Schema.optional(Schema.Number)
+});
+const ReadWorkspaceFileResult = Schema.Struct({
+	text: Schema.String,
+	lang: Schema.String,
+	truncated: Schema.Boolean,
+	totalLines: Schema.Number
+});
+/** 10b. Read a workspace file for inline previews (unary) */
+const ReadWorkspaceFileRpc = Rpc.make(WS_METHODS.readWorkspaceFile, {
+	payload: ReadWorkspaceFileInput,
+	success: ReadWorkspaceFileResult,
+	error: PanRpcError
+});
+/**
+* 10c. Resolve whether a file path candidate exists on disk (PAN-1457).
+*
+* Used by MarkdownFileLink to decide whether a path-like token in chat
+* markdown should render as a clickable chip. Returns exists=false for
+* phantom paths (`conv/2209`, `users/foo`) and exists=true with kind for
+* real files and directories (including bare directory references like
+* `src/components/Foo` that the regex heuristic alone cannot validate).
+*
+* Security:
+*   - Pure stat — never reads file contents, never enumerates directories.
+*   - Relative paths resolve under cwd; absolute paths are statted directly.
+*   - Caller is responsible for sending only paths surfaced from their own
+*     conversation context; the resolver does not gate by issueId because
+*     chat happens outside any single workspace.
+*/
+const ResolveFilePathExistsInput = Schema.Struct({
+	cwd: Schema.String,
+	path: Schema.String
+});
+const ResolveFilePathExistsResult = Schema.Struct({
+	exists: Schema.Boolean,
+	kind: Schema.NullOr(Schema.Literals(["file", "dir"]))
+});
+const ResolveFilePathExistsRpc = Rpc.make(WS_METHODS.resolveFilePathExists, {
+	payload: ResolveFilePathExistsInput,
+	success: ResolveFilePathExistsResult,
+	error: PanRpcError
+});
+/** 11. Start planning for an issue (command) */
+const StartPlanningRpc = Rpc.make(WS_METHODS.startPlanning, {
+	payload: Schema.Struct({
+		issueId: IssueId,
+		options: Schema.optional(Schema.Unknown)
+	}),
+	success: Schema.Struct({ queued: Schema.Boolean }),
+	error: PanRpcError
+});
+/** 12. Start a work agent for an issue (command) */
+const StartAgentRpc = Rpc.make(WS_METHODS.startAgent, {
+	payload: Schema.Struct({
+		issueId: IssueId,
+		options: Schema.optional(Schema.Unknown)
+	}),
+	success: Schema.Struct({ agentId: Schema.String }),
+	error: PanRpcError
+});
+/** 13. Deep-wipe a workspace (destructive command — requires explicit confirmation) */
+const DeepWipeRpc = Rpc.make(WS_METHODS.deepWipe, {
+	payload: Schema.Struct({
+		issueId: IssueId,
+		deleteWorkspace: Schema.optional(Schema.Boolean)
+	}),
+	success: Schema.Struct({ wiped: Schema.Boolean }),
+	error: PanRpcError
+});
+/** 14. Send input to a terminal session (command) */
+const SendTerminalInputRpc = Rpc.make(WS_METHODS.sendTerminalInput, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		data: Schema.String
+	}),
+	error: PanRpcError
+});
+/** 15. Resize a terminal session (command) */
+const ResizeTerminalRpc = Rpc.make(WS_METHODS.resizeTerminal, {
+	payload: Schema.Struct({
+		sessionName: Schema.String,
+		cols: Schema.Number,
+		rows: Schema.Number
+	}),
+	error: PanRpcError
+});
+/** 16. Subscribe to structured conversation messages from a JSONL session file (stream, PAN-451) */
+const SubscribeConversationMessagesRpc = Rpc.make(WS_METHODS.subscribeConversationMessages, {
+	payload: Schema.Struct({ conversationName: Schema.String }),
+	success: ConversationEvent,
+	error: PanRpcError,
+	stream: true
+});
+/** 17. Subscribe to live session tree deltas for a project (stream, PAN-821) */
+const SubscribeProjectSessionTreeRpc = Rpc.make(WS_METHODS.subscribeProjectSessionTree, {
+	payload: Schema.Struct({ projectKey: Schema.String }),
+	success: SessionTreeDelta,
+	error: PanRpcError,
+	stream: true
+});
+/** 18. Subscribe to latest Flywheel status snapshots (stream) */
+const SubscribeFlywheelStatusRpc = Rpc.make(WS_METHODS.subscribeFlywheelStatus, {
+	payload: Schema.Struct({}),
+	success: Schema.NullOr(FlywheelStatus),
+	error: PanRpcError,
+	stream: true
+});
+/** 19. Open a workspace in an editor (PAN-966) */
+const ShellOpenInEditorRpc = Rpc.make(WS_METHODS.shellOpenInEditor, {
+	payload: OpenInEditorInput,
+	error: PanRpcError
+});
+/** 19. Get available (installed) editors (PAN-966) */
+const GetAvailableEditorsRpc = Rpc.make(WS_METHODS.getAvailableEditors, {
+	success: Schema.Struct({
+		editors: Schema.Array(EditorIdSchema),
+		/**
+		* Default cwd to open when no project/workspace is selected — the
+		* "devroot" fallback. `~/Projects` if it exists, else `$HOME`.
+		*/
+		defaultCwd: Schema.String
+	}),
+	error: PanRpcError
+});
+const DiscoveredSessionListResult = Schema.Struct({
+	sessions: Schema.Array(DiscoveredSessionSnapshot),
+	count: Schema.Number,
+	total: Schema.Number
+});
+const DiscoveredSessionSearchResult = Schema.Struct({
+	sessions: Schema.Array(DiscoveredSessionSnapshot),
+	total: Schema.Number,
+	mode: Schema.String,
+	durationMs: Schema.Number,
+	error: Schema.optional(Schema.String)
+});
+const DiscoveredSessionStatsResult = Schema.Struct({
+	total: Schema.Number,
+	enriched: Schema.Number,
+	embedded: Schema.Number,
+	managedCount: Schema.Number,
+	embeddingModels: Schema.optional(Schema.Array(Schema.Struct({
+		model: Schema.String,
+		embedded: Schema.Number
+	})))
+});
+const ConversationCostTotals = Schema.Struct({
+	sessionCount: Schema.Number,
+	totalCost: Schema.Number,
+	totalTokensIn: Schema.Number,
+	totalTokensOut: Schema.Number
+});
+/** Scan conversations (trigger discovery) */
+const ScanConversationsRpc = Rpc.make(WS_METHODS.scanConversations, {
+	payload: Schema.Struct({
+		mode: Schema.Literals([
+			"targeted",
+			"watched",
+			"system"
+		]),
+		dirs: Schema.optional(Schema.Array(Schema.String)),
+		dryRun: Schema.optional(Schema.Boolean)
+	}),
+	success: ScanResult,
+	error: PanRpcError
+});
+/** Search discovered sessions with filters + optional FTS query */
+const SearchConversationsRpc = Rpc.make(WS_METHODS.searchConversations, {
+	payload: ConversationFilter,
+	success: DiscoveredSessionSearchResult,
+	error: PanRpcError
+});
+/** List discovered sessions (recent, with optional managed/unmanaged filter) */
+const ListDiscoveredSessionsRpc = Rpc.make(WS_METHODS.listDiscoveredSessions, {
+	payload: ConversationFilter,
+	success: DiscoveredSessionListResult,
+	error: PanRpcError
+});
+/** Get a single discovered session by ID */
+const GetDiscoveredSessionRpc = Rpc.make(WS_METHODS.getDiscoveredSession, {
+	payload: Schema.Struct({ id: Schema.Number }),
+	success: DiscoveredSessionSnapshot,
+	error: PanRpcError
+});
+/** Enrich sessions by ID or filter */
+const EnrichSessionsRpc = Rpc.make(WS_METHODS.enrichSessions, {
+	payload: Schema.Struct({
+		ids: Schema.optional(Schema.Array(Schema.Number)),
+		filter: Schema.optional(ConversationFilter),
+		level: Schema.Literals([
+			1,
+			2,
+			3
+		]),
+		model: Schema.optional(Schema.String),
+		fullTranscript: Schema.optional(Schema.Boolean),
+		customPrompt: Schema.optional(Schema.String),
+		upgrade: Schema.optional(Schema.Boolean),
+		limit: Schema.optional(Schema.Number),
+		confirmed: Schema.optional(Schema.Boolean),
+		force: Schema.optional(Schema.Boolean)
+	}),
+	success: Schema.Struct({
+		processed: Schema.Number,
+		totalCost: Schema.Number,
+		failures: Schema.Number
+	}),
+	error: PanRpcError
+});
+/** Generate or update embeddings for enriched sessions */
+const EmbedSessionsRpc = Rpc.make(WS_METHODS.embedSessions, {
+	payload: Schema.Struct({
+		ids: Schema.optional(Schema.Array(Schema.Number)),
+		regenerate: Schema.optional(Schema.Boolean)
+	}),
+	success: Schema.Struct({
+		total: Schema.Number,
+		embedded: Schema.Number,
+		model: Schema.String
+	}),
+	error: PanRpcError
+});
+/** Aggregate cost totals for discovered sessions */
+const GetConversationCostRpc = Rpc.make(WS_METHODS.getConversationCost, {
+	payload: ConversationFilter,
+	success: ConversationCostTotals,
+	error: PanRpcError
+});
+/** Aggregate workspace cost totals for the full filtered corpus */
+const GetConversationCostByWorkspaceRpc = Rpc.make(WS_METHODS.getConversationCostByWorkspace, {
+	payload: ConversationFilter,
+	success: ConversationCostSummary,
+	error: PanRpcError
+});
+/** Discovery index statistics */
+const GetConversationStatsRpc = Rpc.make(WS_METHODS.getConversationStats, {
+	payload: Schema.Struct({}),
+	success: DiscoveredSessionStatsResult,
+	error: PanRpcError
+});
+/** All Overdeck WebSocket RPC methods */
+const PanRpcGroup = RpcGroup.make(SubscribeDomainEventsRpc, SubscribeIssueEventsRpc, SubscribeTerminalRpc, SubscribeAgentOutputRpc, GetSnapshotRpc, ReplayEventsRpc, GetWorkspaceDetailRpc, ReadWorkspaceFileRpc, ResolveFilePathExistsRpc, TerminalOpenRpc, TerminalWriteRpc, TerminalResizeRpc, TerminalCloseRpc, StartPlanningRpc, StartAgentRpc, DeepWipeRpc, SendTerminalInputRpc, ResizeTerminalRpc, SubscribeConversationMessagesRpc, SubscribeProjectSessionTreeRpc, SubscribeFlywheelStatusRpc, ShellOpenInEditorRpc, GetAvailableEditorsRpc, ScanConversationsRpc, SearchConversationsRpc, ListDiscoveredSessionsRpc, GetDiscoveredSessionRpc, EnrichSessionsRpc, EmbedSessionsRpc, GetConversationCostRpc, GetConversationCostByWorkspaceRpc, GetConversationStatsRpc);
+//#endregion
+//#region src/event-reducers.ts
+const INITIAL_READ_MODEL_STATE = {
+	sequence: 0,
+	agentsById: {},
+	agentRuntimeById: {},
+	reviewStatusByIssueId: {},
+	resources: null,
+	agentOutputById: {},
+	issuesRaw: [],
+	recentActivity: [],
+	detailedActivity: [],
+	ttsActivity: [],
+	shadowInferenceByIssueId: {},
+	turnDiffSummariesByAgentId: {},
+	channelPermissionRequestsById: {},
+	channelPermissionRequestIdsByAgentId: {},
+	resolvedChannelPermissionDecisionsById: {},
+	resolvedChannelPermissionDecisionIdsByAgentId: {},
+	conversationsCompactingByName: {},
+	conversationsAwaitingPermissionByName: {},
+	conversationsListRevision: 0,
+	observationsByIssueId: {},
+	statusByIssueId: {},
+	rollupsByIssueId: {},
+	resetMarkersByScopeId: {},
+	healthByIssueId: {},
+	scanProgress: null,
+	enrichStats: null,
+	enrichProgressBySessionId: {},
+	embedProgressBySessionId: {},
+	agentIdBySessionId: {},
+	dashboardLifecycle: {
+		active: false,
+		reason: null,
+		issueId: null,
+		trigger: null,
+		startedAt: null,
+		completedAt: null,
+		failedAt: null,
+		error: null
+	}
+};
+const MAX_AGENT_OUTPUT_LINES = 200;
+const MAX_ACTIVITY_ENTRIES = 50;
+const MAX_DETAILED_ENTRIES = 200;
+const MAX_TTS_ENTRIES = 50;
+const MAX_SESSION_PROGRESS_ENTRIES = 100;
+const DEFAULT_MAX_TURN_DIFF_SUMMARIES_PER_AGENT = 200;
+const DEFAULT_MAX_MEMORY_OBSERVATIONS_PER_ISSUE = 50;
+function getMaxMemoryObservationsPerIssue() {
+	const raw = globalThis.process?.env?.OVERDECK_MEMORY_OBSERVATION_LIMIT;
+	const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : 50;
+}
+function trimMemoryObservations(observations) {
+	const max = getMaxMemoryObservationsPerIssue();
+	return observations.length > max ? observations.slice(-max) : observations;
+}
+function getMaxTurnDiffSummariesPerAgent() {
+	const raw = globalThis.process?.env?.OVERDECK_TURN_DIFF_SUMMARY_LIMIT;
+	const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : 200;
+}
+function isTerminalTurnDiffSummaryStatus(status) {
+	return status === "stopped" || status === "done" || status === "archived" || status === "closed";
+}
+function trimTurnDiffSummaries(summaries) {
+	const max = getMaxTurnDiffSummariesPerAgent();
+	return summaries.length > max ? summaries.slice(-max) : summaries;
+}
+function upsertBoundedSessionProgress(bySessionId, progress) {
+	const existing = bySessionId[progress.sessionId];
+	const entries = Object.values(bySessionId);
+	if (existing || entries.length < MAX_SESSION_PROGRESS_ENTRIES) return {
+		...bySessionId,
+		[progress.sessionId]: progress
+	};
+	const keep = entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp)).slice(-(MAX_SESSION_PROGRESS_ENTRIES - 1));
+	const next = {};
+	for (const entry of [...keep, progress]) next[entry.sessionId] = entry;
+	return next;
+}
+function omitTurnDiffSummariesForAgent(turnDiffSummariesByAgentId, agentId) {
+	const { [agentId]: _removed, ...rest } = turnDiffSummariesByAgentId ?? {};
+	return rest;
+}
+/** Remove all entries in agentIdBySessionId that point to the given agentId. */
+function removeAgentFromSessionIndex(agentIdBySessionId, agentId) {
+	const next = {};
+	for (const [sessionId, id] of Object.entries(agentIdBySessionId ?? {})) if (id !== agentId) next[sessionId] = id;
+	return next;
+}
+function defaultRuntimeSnapshot(agentId, timestamp, sequence) {
+	return {
+		id: agentId,
+		activity: "idle",
+		lastActivity: timestamp,
+		updatedAtSequence: sequence
+	};
+}
+/**
+* Bump runtimeSnapshotSequence on the corresponding AgentSnapshot (if present)
+* so low-frequency subscribers can cheaply detect a runtime change. No-op if
+* the agent has no lifecycle snapshot yet (a runtime event arrived before
+* agent.created — unusual but defensive).
+*/
+function bumpRuntimeSnapshotSequence(agentsById, agentId, sequence) {
+	const agent = agentsById[agentId];
+	if (!agent) return agentsById;
+	return {
+		...agentsById,
+		[agentId]: {
+			...agent,
+			runtimeSnapshotSequence: sequence
+		}
+	};
+}
+function syncSnapshot(state, snapshot) {
+	const agentsById = {};
+	for (const agent of snapshot.agents) agentsById[agent.id] = agent;
+	const reviewStatusByIssueId = {};
+	for (const rs of snapshot.reviewStatuses) reviewStatusByIssueId[rs.issueId] = rs;
+	const channelPermissionRequestsById = {};
+	const channelPermissionRequestIdsByAgentId = {};
+	for (const request of snapshot.channelPermissionRequests ?? []) {
+		channelPermissionRequestsById[request.requestId] = request;
+		const existing = channelPermissionRequestIdsByAgentId[request.agentId] ?? [];
+		channelPermissionRequestIdsByAgentId[request.agentId] = [...existing, request.requestId];
+	}
+	const memory = snapshot.memory;
+	const agentIdBySessionId = {};
+	for (const agent of snapshot.agents) if (agent.sessionId) agentIdBySessionId[agent.sessionId] = agent.id;
+	for (const [agentId, runtime] of Object.entries(snapshot.agentRuntimeById ?? {})) if (runtime.claudeSessionId) agentIdBySessionId[runtime.claudeSessionId] = agentId;
+	return {
+		...state,
+		sequence: snapshot.sequence,
+		agentsById,
+		reviewStatusByIssueId,
+		agentRuntimeById: snapshot.agentRuntimeById ?? state.agentRuntimeById,
+		channelPermissionRequestsById,
+		channelPermissionRequestIdsByAgentId,
+		resolvedChannelPermissionDecisionsById: {},
+		resolvedChannelPermissionDecisionIdsByAgentId: {},
+		resources: snapshot.resources ?? null,
+		issuesRaw: snapshot.issues ?? state.issuesRaw,
+		observationsByIssueId: memory?.observationsByIssueId ?? state.observationsByIssueId,
+		statusByIssueId: memory?.statusByIssueId ?? state.statusByIssueId,
+		rollupsByIssueId: memory?.rollupsByIssueId ?? state.rollupsByIssueId,
+		resetMarkersByScopeId: memory?.resetMarkersByScopeId ?? state.resetMarkersByScopeId,
+		healthByIssueId: memory?.healthByIssueId ?? state.healthByIssueId,
+		scanProgress: snapshot.scanProgress ?? null,
+		enrichStats: snapshot.enrichStats ?? null,
+		enrichProgressBySessionId: snapshot.enrichProgressBySessionId ?? {},
+		embedProgressBySessionId: snapshot.embedProgressBySessionId ?? {},
+		agentIdBySessionId
+	};
+}
+function applyEvent(state, event) {
+	switch (event.type) {
+		case "agent.created": {
+			const existing = state.agentsById[event.payload.agentId];
+			const agent = event.payload.agent;
+			const nextAgentIdBySessionId = agent.sessionId ? {
+				...state.agentIdBySessionId,
+				[agent.sessionId]: agent.id
+			} : state.agentIdBySessionId;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[event.payload.agentId]: existing ? {
+						...existing,
+						...agent
+					} : agent
+				},
+				agentIdBySessionId: nextAgentIdBySessionId
+			};
+		}
+		case "agent.started": {
+			const agent = event.payload.agent;
+			const nextAgentIdBySessionId = agent.sessionId ? {
+				...state.agentIdBySessionId,
+				[agent.sessionId]: agent.id
+			} : state.agentIdBySessionId;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[event.payload.agentId]: agent
+				},
+				agentIdBySessionId: nextAgentIdBySessionId
+			};
+		}
+		case "agent.enrichment_changed": {
+			const agent = state.agentsById[event.payload.agentId];
+			if (!agent) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[event.payload.agentId]: {
+						...agent,
+						role: event.payload.role ?? agent.role,
+						hasPendingQuestion: event.payload.hasPendingQuestion ?? false,
+						pendingQuestionCount: event.payload.pendingQuestionCount ?? 0,
+						pendingQuestionPrompt: event.payload.pendingQuestionPrompt,
+						pendingQuestionReason: event.payload.pendingQuestionReason,
+						pendingInputCount: event.payload.pendingInputCount,
+						pendingInputKinds: event.payload.pendingInputKinds,
+						pendingAskUserQuestion: event.payload.pendingAskUserQuestion,
+						resolution: event.payload.resolution,
+						resolutionCount: event.payload.resolutionCount
+					}
+				}
+			};
+		}
+		case "agent.stopped": {
+			const { [event.payload.agentId]: _removed, ...rest } = state.agentsById;
+			const runtimeById = state.agentRuntimeById ?? {};
+			const prevRuntime = runtimeById[event.payload.agentId];
+			const nextRuntimeById = prevRuntime ? {
+				...runtimeById,
+				[event.payload.agentId]: {
+					...prevRuntime,
+					activity: "stopped",
+					currentTool: void 0,
+					thinking: void 0,
+					waiting: void 0,
+					channelReply: void 0,
+					lastActivity: event.timestamp,
+					updatedAtSequence: event.sequence
+				}
+			} : runtimeById;
+			const permissionRequestIdsByAgentId = state.channelPermissionRequestIdsByAgentId ?? {};
+			const pendingIds = permissionRequestIdsByAgentId[event.payload.agentId] ?? [];
+			const nextPermissionRequestsById = { ...state.channelPermissionRequestsById };
+			for (const requestId of pendingIds) delete nextPermissionRequestsById[requestId];
+			const { [event.payload.agentId]: _removedPendingIds, ...restPendingIds } = permissionRequestIdsByAgentId;
+			const resolvedDecisionIdsByAgentId = state.resolvedChannelPermissionDecisionIdsByAgentId ?? {};
+			const resolvedIds = resolvedDecisionIdsByAgentId[event.payload.agentId] ?? [];
+			const nextResolvedDecisionsById = { ...state.resolvedChannelPermissionDecisionsById ?? {} };
+			for (const requestId of resolvedIds) delete nextResolvedDecisionsById[requestId];
+			const { [event.payload.agentId]: _removedResolvedIds, ...restResolvedIds } = resolvedDecisionIdsByAgentId;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: rest,
+				agentRuntimeById: nextRuntimeById,
+				channelPermissionRequestsById: nextPermissionRequestsById,
+				channelPermissionRequestIdsByAgentId: restPendingIds,
+				resolvedChannelPermissionDecisionsById: nextResolvedDecisionsById,
+				resolvedChannelPermissionDecisionIdsByAgentId: restResolvedIds,
+				turnDiffSummariesByAgentId: omitTurnDiffSummariesForAgent(state.turnDiffSummariesByAgentId, event.payload.agentId),
+				agentIdBySessionId: removeAgentFromSessionIndex(state.agentIdBySessionId, event.payload.agentId)
+			};
+		}
+		case "agent.status_changed": {
+			const agent = state.agentsById[event.payload.agentId];
+			if (!agent) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const nextTurnDiffSummariesByAgentId = isTerminalTurnDiffSummaryStatus(event.payload.status) ? omitTurnDiffSummariesForAgent(state.turnDiffSummariesByAgentId, event.payload.agentId) : state.turnDiffSummariesByAgentId;
+			const nextAgent = (() => {
+				const base = {
+					...agent,
+					status: event.payload.status
+				};
+				for (const field of [
+					"hasLiveTmuxSession",
+					"stoppedByUser",
+					"stoppedByPause",
+					"paused",
+					"pausedReason",
+					"pausedAt",
+					"troubled",
+					"troubledAt",
+					"consecutiveFailures",
+					"firstFailureInRunAt",
+					"lastFailureAt",
+					"lastFailureReason",
+					"lastFailureNextRetryAt",
+					"kickoffDelivered",
+					"hostOverride",
+					"role",
+					"model",
+					"workspace",
+					"sessionId",
+					"lastActivity",
+					"lastResumeAt",
+					"stoppedAt",
+					"branch",
+					"costSoFar",
+					"phase",
+					"workType",
+					"roleRunHead",
+					"flywheelRunId",
+					"reviewSubRole",
+					"reviewRunId",
+					"reviewOutputPath",
+					"reviewSynthesisAgentId",
+					"reviewDeadlineAt",
+					"reviewMonitorSignaled",
+					"reviewRetryAttempt",
+					"inspectSubRole",
+					"deliveryMethod",
+					"supervisorEnabled",
+					"channelsEnabled"
+				]) if (field in event.payload) {
+					const value = event.payload[field];
+					if (value === null || value === void 0) delete base[field];
+					else base[field] = value;
+				}
+				if (event.payload.status !== "running" && event.payload.status !== "starting") {
+					delete base["hasPendingQuestion"];
+					delete base["pendingQuestionCount"];
+					delete base["pendingQuestionPrompt"];
+					delete base["pendingQuestionReason"];
+					delete base["pendingInputCount"];
+					delete base["pendingInputKinds"];
+					delete base["pendingAskUserQuestion"];
+				}
+				return base;
+			})();
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[event.payload.agentId]: nextAgent
+				},
+				turnDiffSummariesByAgentId: nextTurnDiffSummariesByAgentId
+			};
+		}
+		case "agent.heartbeat_dead": {
+			const agent = state.agentsById[event.payload.agentId];
+			if (!agent) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const runtimeById = state.agentRuntimeById ?? {};
+			const prevRuntime = runtimeById[event.payload.agentId];
+			const nextRuntimeById = prevRuntime ? {
+				...runtimeById,
+				[event.payload.agentId]: {
+					...prevRuntime,
+					activity: "stopped",
+					currentTool: void 0,
+					thinking: void 0,
+					waiting: void 0,
+					channelReply: void 0,
+					lastActivity: event.timestamp,
+					updatedAtSequence: event.sequence
+				}
+			} : runtimeById;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[event.payload.agentId]: {
+						...agent,
+						status: "error"
+					}
+				},
+				agentRuntimeById: nextRuntimeById
+			};
+		}
+		case "agent.output_received": {
+			const updated = [...state.agentOutputById[event.payload.agentId] ?? [], ...event.payload.lines].slice(-MAX_AGENT_OUTPUT_LINES);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentOutputById: {
+					...state.agentOutputById,
+					[event.payload.agentId]: updated
+				}
+			};
+		}
+		case "pipeline.status_changed":
+		case "review.status_changed": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence),
+			reviewStatusByIssueId: {
+				...state.reviewStatusByIssueId,
+				[event.payload.issueId]: event.payload.status
+			}
+		};
+		case "review.reviewer_started": {
+			const { issueId, role, sessionName } = event.payload;
+			const existing = state.reviewStatusByIssueId[issueId];
+			const prevSubs = existing?.reviewSubStatuses ?? {};
+			const prevNames = existing?.reviewSessionNames ?? [];
+			const nextNames = prevNames.includes(sessionName) ? prevNames : [...prevNames, sessionName];
+			const nextStatus = {
+				...existing ?? { issueId },
+				reviewSubStatuses: {
+					...prevSubs,
+					[role]: "running"
+				},
+				reviewSessionNames: nextNames
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				reviewStatusByIssueId: {
+					...state.reviewStatusByIssueId,
+					[issueId]: nextStatus
+				}
+			};
+		}
+		case "review.reviewer_completed": {
+			const { issueId, role } = event.payload;
+			const existing = state.reviewStatusByIssueId[issueId];
+			if (!existing) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const prevSubs = existing.reviewSubStatuses ?? {};
+			const nextStatus = {
+				...existing,
+				reviewSubStatuses: {
+					...prevSubs,
+					[role]: "done"
+				}
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				reviewStatusByIssueId: {
+					...state.reviewStatusByIssueId,
+					[issueId]: nextStatus
+				}
+			};
+		}
+		case "review.specialist.timed_out": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "review.coordinator_started": {
+			const { issueId, sessionName } = event.payload;
+			const nextStatus = {
+				...state.reviewStatusByIssueId[issueId] ?? { issueId },
+				reviewCoordinatorSessionName: sessionName
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				reviewStatusByIssueId: {
+					...state.reviewStatusByIssueId,
+					[issueId]: nextStatus
+				}
+			};
+		}
+		case "review.coordinator.died": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "pipeline.review-started":
+		case "pipeline.review-completed":
+		case "pipeline.test-started":
+		case "pipeline.test-completed": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "merge.ready": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "specialist.started":
+		case "specialist.completed":
+		case "specialist.failed": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "resources.updated": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence),
+			resources: event.payload.resources
+		};
+		case "issues.snapshot": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence),
+			issuesRaw: event.payload.issues
+		};
+		case "issues.updated": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "issue.statusChanged": {
+			const { issueId, status, canonicalStatus, labels } = event.payload;
+			const updatedIssues = state.issuesRaw.map((issue) => {
+				if (issue["identifier"] === issueId || issue["id"] === issueId) {
+					const patch = {
+						...issue,
+						status,
+						canonicalStatus,
+						state: canonicalStatus
+					};
+					if (labels) patch.labels = labels;
+					return patch;
+				}
+				return issue;
+			});
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				issuesRaw: updatedIssues
+			};
+		}
+		case "activity.updated": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence),
+			recentActivity: event.payload.events.slice(0, MAX_ACTIVITY_ENTRIES)
+		};
+		case "shadow.inference_update": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence),
+			shadowInferenceByIssueId: {
+				...state.shadowInferenceByIssueId,
+				[event.payload.issueId]: event.payload.content
+			}
+		};
+		case "planning.started": {
+			const sessionName = event.payload.sessionName;
+			const issueId = event.payload.issueId;
+			if (sessionName) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: {
+					...state.agentsById,
+					[sessionName]: {
+						...state.agentsById[sessionName],
+						id: sessionName,
+						issueId,
+						status: "running",
+						startedAt: event.timestamp,
+						runtime: event.payload.harness ?? "claude-code",
+						role: "plan"
+					}
+				}
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+		}
+		case "workspace.created": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "workspace.wipe_started": {
+			const { issueId } = event.payload;
+			const updatedIssues = state.issuesRaw.map((issue) => {
+				if (issue["identifier"] === issueId || issue["id"] === issueId) return {
+					...issue,
+					canonicalStatus: "wiping",
+					state: "wiping"
+				};
+				return issue;
+			});
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				issuesRaw: updatedIssues
+			};
+		}
+		case "workspace.destroyed":
+		case "workspace.deleted": {
+			const { issueId } = event.payload;
+			const removedAgentIds = Object.entries(state.agentsById).filter(([, agent]) => agent.issueId === issueId).map(([agentId]) => agentId);
+			const updatedAgents = Object.fromEntries(Object.entries(state.agentsById).filter(([, agent]) => agent.issueId !== issueId));
+			let nextTurnDiffSummariesByAgentId = state.turnDiffSummariesByAgentId;
+			let nextAgentIdBySessionId = state.agentIdBySessionId;
+			for (const agentId of removedAgentIds) {
+				nextTurnDiffSummariesByAgentId = omitTurnDiffSummariesForAgent(nextTurnDiffSummariesByAgentId, agentId);
+				nextAgentIdBySessionId = removeAgentFromSessionIndex(nextAgentIdBySessionId, agentId);
+			}
+			const updatedIssues = state.issuesRaw.map((issue) => {
+				if (issue["identifier"] === issueId || issue["id"] === issueId) return {
+					...issue,
+					status: "Todo",
+					canonicalStatus: "todo",
+					state: "todo"
+				};
+				return issue;
+			});
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: updatedAgents,
+				turnDiffSummariesByAgentId: nextTurnDiffSummariesByAgentId,
+				agentIdBySessionId: nextAgentIdBySessionId,
+				issuesRaw: updatedIssues
+			};
+		}
+		case "workspace.aborted": {
+			const { issueId, sessionName } = event.payload;
+			let updatedAgents;
+			let nextTurnDiffSummariesByAgentId = state.turnDiffSummariesByAgentId;
+			let nextAgentIdBySessionId = state.agentIdBySessionId;
+			if (sessionName) {
+				const { [sessionName]: _removed, ...rest } = state.agentsById;
+				updatedAgents = rest;
+				nextTurnDiffSummariesByAgentId = omitTurnDiffSummariesForAgent(nextTurnDiffSummariesByAgentId, sessionName);
+				nextAgentIdBySessionId = removeAgentFromSessionIndex(nextAgentIdBySessionId, sessionName);
+			} else {
+				const removedAgentIds = Object.entries(state.agentsById).filter(([, agent]) => agent.issueId === issueId).map(([agentId]) => agentId);
+				updatedAgents = Object.fromEntries(Object.entries(state.agentsById).filter(([, agent]) => agent.issueId !== issueId));
+				for (const agentId of removedAgentIds) {
+					nextTurnDiffSummariesByAgentId = omitTurnDiffSummariesForAgent(nextTurnDiffSummariesByAgentId, agentId);
+					nextAgentIdBySessionId = removeAgentFromSessionIndex(nextAgentIdBySessionId, agentId);
+				}
+			}
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentsById: updatedAgents,
+				turnDiffSummariesByAgentId: nextTurnDiffSummariesByAgentId,
+				agentIdBySessionId: nextAgentIdBySessionId
+			};
+		}
+		case "planning.failed":
+		case "planning.sync":
+		case "plan.item_status_changed":
+		case "plan.subitem_status_changed":
+		case "plan.items_unblocked":
+		case "operator.intervention":
+		case "substrate.bug_filed":
+		case "cost.event_recorded": return {
+			...state,
+			sequence: Math.max(state.sequence, event.sequence)
+		};
+		case "memory.observation_created": {
+			const observation = event.payload.observation;
+			const existing = state.observationsByIssueId[observation.issueId] ?? [];
+			const index = existing.findIndex((entry) => entry.id === observation.id);
+			const updated = trimMemoryObservations(index === -1 ? [...existing, observation] : existing.map((entry, entryIndex) => entryIndex === index ? observation : entry));
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				observationsByIssueId: {
+					...state.observationsByIssueId,
+					[observation.issueId]: updated
+				}
+			};
+		}
+		case "memory.status_updated": {
+			const { identity, status } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				statusByIssueId: {
+					...state.statusByIssueId,
+					[identity.issueId]: status
+				}
+			};
+		}
+		case "memory.rollup_triggered": {
+			const trigger = {
+				projectId: event.payload.projectId,
+				workspaceId: event.payload.workspaceId,
+				issueId: event.payload.issueId,
+				pendingTurns: [],
+				pendingCount: event.payload.pendingCount,
+				threshold: event.payload.threshold,
+				triggeredAt: event.timestamp
+			};
+			const updated = [...state.rollupsByIssueId[event.payload.issueId] ?? [], trigger].slice(-10);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				rollupsByIssueId: {
+					...state.rollupsByIssueId,
+					[event.payload.issueId]: updated
+				}
+			};
+		}
+		case "memory.reset_marker_created": {
+			const { marker } = event.payload;
+			const key = `${marker.scope}:${marker.scopeId}`;
+			const existing = state.resetMarkersByScopeId[key] ?? [];
+			const index = existing.findIndex((entry) => entry.id === marker.id);
+			const updated = index === -1 ? [...existing, marker] : existing.map((entry, entryIndex) => entryIndex === index ? marker : entry);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				resetMarkersByScopeId: {
+					...state.resetMarkersByScopeId,
+					[key]: updated
+				}
+			};
+		}
+		case "memory.health_changed": {
+			const health = {
+				projectId: event.payload.projectId,
+				issueId: event.payload.issueId,
+				status: event.payload.status,
+				reason: event.payload.reason,
+				...event.payload.detail !== void 0 ? { detail: event.payload.detail } : {},
+				...event.payload.ragDecision !== void 0 ? { ragDecision: event.payload.ragDecision } : {},
+				updatedAt: event.timestamp
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				healthByIssueId: {
+					...state.healthByIssueId,
+					[event.payload.issueId]: health
+				}
+			};
+		}
+		case "agent.activity_changed": {
+			const { agentId, activity, currentTool } = event.payload;
+			const prev = state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence);
+			const next = {
+				...prev,
+				activity,
+				currentTool: activity === "working" ? currentTool : void 0,
+				thinking: activity === "thinking" ? prev.thinking : void 0,
+				waiting: activity === "waiting" ? prev.waiting : void 0,
+				channelReply: activity === "working" ? void 0 : prev.channelReply,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.thinking_started": {
+			const { agentId, lastToolAt } = event.payload;
+			const next = {
+				...state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence),
+				activity: "thinking",
+				currentTool: void 0,
+				thinking: {
+					since: event.timestamp,
+					lastToolAt
+				},
+				waiting: void 0,
+				channelReply: void 0,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.thinking_stopped": {
+			const { agentId } = event.payload;
+			const prev = state.agentRuntimeById[agentId];
+			if (!prev) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const next = {
+				...prev,
+				thinking: void 0,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.waiting_started": {
+			const { agentId, reason, message } = event.payload;
+			const next = {
+				...state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence),
+				activity: "waiting",
+				currentTool: void 0,
+				thinking: void 0,
+				waiting: {
+					reason,
+					startedAt: event.timestamp,
+					message
+				},
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.waiting_cleared": {
+			const { agentId } = event.payload;
+			const prev = state.agentRuntimeById[agentId];
+			if (!prev) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const next = {
+				...prev,
+				waiting: void 0,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.permission_requested": {
+			const request = event.payload;
+			const permissionRequestIdsByAgentId = state.channelPermissionRequestIdsByAgentId ?? {};
+			const resolvedDecisionsById = state.resolvedChannelPermissionDecisionsById ?? {};
+			const resolvedDecisionIdsByAgentId = state.resolvedChannelPermissionDecisionIdsByAgentId ?? {};
+			const nextPendingIds = permissionRequestIdsByAgentId[request.agentId] ?? [];
+			const resolvedDecision = resolvedDecisionsById[request.requestId];
+			const nextResolvedDecisionsById = { ...resolvedDecisionsById };
+			const nextResolvedIdsByAgentId = { ...resolvedDecisionIdsByAgentId };
+			if (resolvedDecision) {
+				delete nextResolvedDecisionsById[request.requestId];
+				const filteredResolvedIds = (nextResolvedIdsByAgentId[resolvedDecision.agentId] ?? []).filter((id) => id !== request.requestId);
+				if (filteredResolvedIds.length > 0) nextResolvedIdsByAgentId[resolvedDecision.agentId] = filteredResolvedIds;
+				else delete nextResolvedIdsByAgentId[resolvedDecision.agentId];
+			}
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				channelPermissionRequestsById: {
+					...state.channelPermissionRequestsById,
+					[request.requestId]: request
+				},
+				channelPermissionRequestIdsByAgentId: {
+					...permissionRequestIdsByAgentId,
+					[request.agentId]: nextPendingIds.includes(request.requestId) ? nextPendingIds : [...nextPendingIds, request.requestId]
+				},
+				resolvedChannelPermissionDecisionsById: nextResolvedDecisionsById,
+				resolvedChannelPermissionDecisionIdsByAgentId: nextResolvedIdsByAgentId
+			};
+		}
+		case "agent.permission_resolved": {
+			const { [event.payload.requestId]: _removed, ...rest } = state.channelPermissionRequestsById;
+			const nextPendingIdsByAgentId = { ...state.channelPermissionRequestIdsByAgentId ?? {} };
+			const filteredPendingIds = (nextPendingIdsByAgentId[event.payload.agentId] ?? []).filter((id) => id !== event.payload.requestId);
+			if (filteredPendingIds.length > 0) nextPendingIdsByAgentId[event.payload.agentId] = filteredPendingIds;
+			else delete nextPendingIdsByAgentId[event.payload.agentId];
+			const resolvedDecisionIdsByAgentId = state.resolvedChannelPermissionDecisionIdsByAgentId ?? {};
+			const nextResolvedIds = resolvedDecisionIdsByAgentId[event.payload.agentId] ?? [];
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				channelPermissionRequestsById: rest,
+				channelPermissionRequestIdsByAgentId: nextPendingIdsByAgentId,
+				resolvedChannelPermissionDecisionsById: {
+					...state.resolvedChannelPermissionDecisionsById ?? {},
+					[event.payload.requestId]: {
+						requestId: event.payload.requestId,
+						agentId: event.payload.agentId,
+						issueId: event.payload.issueId,
+						behavior: event.payload.behavior
+					}
+				},
+				resolvedChannelPermissionDecisionIdsByAgentId: {
+					...resolvedDecisionIdsByAgentId,
+					[event.payload.agentId]: nextResolvedIds.includes(event.payload.requestId) ? nextResolvedIds : [...nextResolvedIds, event.payload.requestId]
+				}
+			};
+		}
+		case "agent.message_received": {
+			const { agentId, direction } = event.payload;
+			const prev = state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence);
+			const next = {
+				...prev,
+				lastMessageAt: event.timestamp,
+				channelReply: direction === "to_agent" ? void 0 : prev.channelReply,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.channel_reply": {
+			const { agentId, reply } = event.payload;
+			const prev = state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence);
+			const next = {
+				...prev,
+				channelReply: {
+					...reply,
+					reportedAt: event.timestamp
+				},
+				resolution: reply.kind === "done" ? "done" : reply.kind === "needs_input" ? "needs_input" : prev.resolution,
+				resolutionUpdatedAt: reply.kind === "done" || reply.kind === "needs_input" ? event.timestamp : prev.resolutionUpdatedAt,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.model_set": {
+			const { agentId, model, claudeSessionId, sessionModel, sessionHarness } = event.payload;
+			const prev = state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence);
+			const next = {
+				...prev,
+				model,
+				claudeSessionId: claudeSessionId ?? prev.claudeSessionId,
+				sessionModel: sessionModel ?? prev.sessionModel,
+				sessionHarness: sessionHarness ?? prev.sessionHarness,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			let nextAgentIdBySessionId = state.agentIdBySessionId;
+			if (claudeSessionId && claudeSessionId !== prev.claudeSessionId) {
+				nextAgentIdBySessionId = {
+					...state.agentIdBySessionId,
+					[claudeSessionId]: agentId
+				};
+				if (prev.claudeSessionId && state.agentIdBySessionId[prev.claudeSessionId] === agentId) {
+					const { [prev.claudeSessionId]: _removed, ...rest } = state.agentIdBySessionId;
+					nextAgentIdBySessionId = {
+						...rest,
+						[claudeSessionId]: agentId
+					};
+				}
+			}
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence),
+				agentIdBySessionId: nextAgentIdBySessionId
+			};
+		}
+		case "agent.current_issue_set": {
+			const { agentId, currentIssue } = event.payload;
+			const next = {
+				...state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence),
+				currentIssue,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.context_saturation_changed": {
+			const { agentId, contextSaturatedAt } = event.payload;
+			const next = {
+				...state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence),
+				contextSaturatedAt,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.resolution_changed": {
+			const { agentId, resolution, resolutionCount } = event.payload;
+			const next = {
+				...state.agentRuntimeById[agentId] ?? defaultRuntimeSnapshot(agentId, event.timestamp, event.sequence),
+				resolution,
+				resolutionCount,
+				resolutionUpdatedAt: event.timestamp,
+				lastActivity: event.timestamp,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "agent.state_restored": {
+			const { agentId, snapshot } = event.payload;
+			const next = {
+				...snapshot,
+				updatedAtSequence: event.sequence
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				agentRuntimeById: {
+					...state.agentRuntimeById,
+					[agentId]: next
+				},
+				agentsById: bumpRuntimeSnapshotSequence(state.agentsById, agentId, event.sequence)
+			};
+		}
+		case "activity.entry": {
+			const entry = event.payload;
+			const updated = [{
+				id: entry.id,
+				timestamp: event.timestamp,
+				...entry
+			}, ...state.recentActivity].slice(0, MAX_ACTIVITY_ENTRIES);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				recentActivity: updated
+			};
+		}
+		case "activity.detailed": {
+			const entry = event.payload;
+			const updated = [{
+				id: entry.id,
+				timestamp: event.timestamp,
+				...entry
+			}, ...state.detailedActivity].slice(0, MAX_DETAILED_ENTRIES);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				detailedActivity: updated
+			};
+		}
+		case "activity.tts": {
+			const entry = event.payload;
+			const updated = [{
+				id: entry.id,
+				timestamp: event.timestamp,
+				...entry
+			}, ...state.ttsActivity].slice(0, MAX_TTS_ENTRIES);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				ttsActivity: updated
+			};
+		}
+		case "dashboard.lifecycle_started": {
+			const { reason, issueId, trigger } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				dashboardLifecycle: {
+					active: true,
+					reason,
+					issueId,
+					trigger,
+					startedAt: event.timestamp,
+					completedAt: null,
+					failedAt: null,
+					error: null
+				}
+			};
+		}
+		case "dashboard.lifecycle_completed": {
+			const { reason, issueId } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				dashboardLifecycle: {
+					...state.dashboardLifecycle,
+					active: false,
+					reason: reason ?? state.dashboardLifecycle.reason,
+					issueId: issueId ?? state.dashboardLifecycle.issueId,
+					completedAt: event.timestamp
+				}
+			};
+		}
+		case "dashboard.lifecycle_failed": {
+			const { reason, issueId, error } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				dashboardLifecycle: {
+					...state.dashboardLifecycle,
+					active: false,
+					reason: reason ?? state.dashboardLifecycle.reason,
+					issueId: issueId ?? state.dashboardLifecycle.issueId,
+					failedAt: event.timestamp,
+					error
+				}
+			};
+		}
+		case "agent.turn_diff_completed": {
+			const p = event.payload;
+			const existing = state.turnDiffSummariesByAgentId[p.agentId] ?? [];
+			const summary = {
+				turnId: p.turnId,
+				completedAt: p.completedAt,
+				files: p.files,
+				checkpointRef: p.checkpointRef,
+				assistantMessageId: p.assistantMessageId ?? void 0,
+				checkpointTurnCount: p.checkpointTurnCount
+			};
+			const idx = existing.findIndex((s) => s.turnId === p.turnId);
+			const updated = trimTurnDiffSummaries(idx >= 0 ? existing.map((s, i) => i === idx ? summary : s) : [...existing, summary]);
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				turnDiffSummariesByAgentId: {
+					...state.turnDiffSummariesByAgentId,
+					[p.agentId]: updated
+				}
+			};
+		}
+		case "conversation.compacting_changed": {
+			const { conversationName, compacting } = event.payload;
+			if (!compacting) {
+				const { [conversationName]: _removed, ...rest } = state.conversationsCompactingByName;
+				return {
+					...state,
+					conversationsCompactingByName: rest
+				};
+			}
+			return {
+				...state,
+				conversationsCompactingByName: {
+					...state.conversationsCompactingByName,
+					[conversationName]: true
+				}
+			};
+		}
+		case "conversation.created": return {
+			...state,
+			conversationsListRevision: state.conversationsListRevision + 1
+		};
+		case "conversation.permission_changed": {
+			const { conversationName, waiting } = event.payload;
+			if (!waiting) {
+				const { [conversationName]: _removed, ...rest } = state.conversationsAwaitingPermissionByName;
+				return {
+					...state,
+					conversationsAwaitingPermissionByName: rest
+				};
+			}
+			return {
+				...state,
+				conversationsAwaitingPermissionByName: {
+					...state.conversationsAwaitingPermissionByName,
+					[conversationName]: true
+				}
+			};
+		}
+		case "scan.started": {
+			const { mode, dirs } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				scanProgress: {
+					active: true,
+					mode,
+					dirs,
+					dirsProcessed: 0,
+					dirsTotal: 0,
+					sessionsFound: 0,
+					elapsedMs: 0,
+					inserted: 0,
+					updated: 0,
+					skipped: 0,
+					errors: 0,
+					durationMs: 0
+				}
+			};
+		}
+		case "scan.progress": {
+			if (!state.scanProgress) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const { dirsProcessed, dirsTotal, sessionsFound, elapsedMs } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				scanProgress: {
+					...state.scanProgress,
+					dirsProcessed,
+					dirsTotal,
+					sessionsFound,
+					elapsedMs
+				}
+			};
+		}
+		case "scan.complete": {
+			if (!state.scanProgress) return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence)
+			};
+			const { inserted, updated, skipped, errors, durationMs } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				scanProgress: {
+					...state.scanProgress,
+					active: false,
+					inserted,
+					updated,
+					skipped,
+					errors,
+					durationMs
+				}
+			};
+		}
+		case "enrich.progress": {
+			const { sessionId, level, model, cost, success, error } = event.payload;
+			const prev = state.enrichStats ?? {
+				processed: 0,
+				totalCost: 0,
+				failures: 0,
+				durationMs: 0
+			};
+			const progress = {
+				sessionId,
+				level,
+				model,
+				cost,
+				success,
+				error,
+				timestamp: event.timestamp
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				enrichStats: {
+					processed: prev.processed + 1,
+					totalCost: prev.totalCost + (success ? cost : 0),
+					failures: prev.failures + (success ? 0 : 1),
+					durationMs: 0
+				},
+				enrichProgressBySessionId: upsertBoundedSessionProgress(state.enrichProgressBySessionId, progress)
+			};
+		}
+		case "enrich.complete": {
+			const { processed, totalCost, failures, durationMs } = event.payload;
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				enrichStats: {
+					processed,
+					totalCost,
+					failures,
+					durationMs
+				},
+				enrichProgressBySessionId: {}
+			};
+		}
+		case "embed.progress": {
+			const { sessionId, model, success, error } = event.payload;
+			const progress = {
+				sessionId,
+				model,
+				success,
+				error,
+				timestamp: event.timestamp
+			};
+			return {
+				...state,
+				sequence: Math.max(state.sequence, event.sequence),
+				embedProgressBySessionId: upsertBoundedSessionProgress(state.embedProgressBySessionId, progress)
+			};
+		}
+		default: return state;
+	}
+}
+function applyEvents(state, events) {
+	return events.reduce(applyEvent, state);
+}
+//#endregion
+//#region src/flywheel-stats.ts
+const FlywheelStatsCriterionStatus = Schema.Literals([
+	"green",
+	"yellow",
+	"red",
+	"insufficient_data"
+]);
+const FlywheelStatsTrend = Schema.Literals([
+	"up",
+	"down",
+	"flat"
+]);
+const FlywheelStatsCriterionValueObject = Schema.Record(Schema.String, Schema.Json);
+const FlywheelStatsCriterionValue = Schema.Union([Schema.Number, FlywheelStatsCriterionValueObject]);
+const FlywheelStatsCriterion = Schema.Struct({
+	label: Schema.String,
+	value: FlywheelStatsCriterionValue,
+	target: FlywheelStatsCriterionValue,
+	status: FlywheelStatsCriterionStatus,
+	trend: Schema.optional(FlywheelStatsTrend),
+	sampleSize: Schema.Number,
+	dataSufficient: Schema.Boolean
+});
+const FlywheelStatsCriteria = Schema.Struct({
+	c1_bugRate: FlywheelStatsCriterion,
+	c2_p0Bugs: FlywheelStatsCriterion,
+	c3_passRate: FlywheelStatsCriterion,
+	c4_mttr: FlywheelStatsCriterion,
+	c5_intervention: FlywheelStatsCriterion,
+	c6_timeConsistency: FlywheelStatsCriterion,
+	c7_flake: FlywheelStatsCriterion
+});
+const FlywheelStats = Schema.Struct({
+	window: Schema.String,
+	generatedAt: Schema.String,
+	criteria: FlywheelStatsCriteria
+});
+const decodeFlywheelStats = Schema.decodeUnknownSync(FlywheelStats);
+const encodeFlywheelStats = Schema.encodeSync(FlywheelStats);
+//#endregion
+//#region src/context-layers.ts
+const CONTEXT_LAYER_KINDS = [
+	"global",
+	"project",
+	"workspace"
+];
+const CONTEXT_PREVIEW_HARNESSES = [
+	"claude-code",
+	"pi",
+	"codex"
+];
+const ContextLayerKind = Schema.Literals(CONTEXT_LAYER_KINDS);
+const ContextPreviewHarness = Schema.Literals(CONTEXT_PREVIEW_HARNESSES);
+const ContextProjectSummary = Schema.Struct({
+	projectKey: Schema.String,
+	name: Schema.String,
+	path: Schema.String,
+	issuePrefix: Schema.optional(Schema.String),
+	tracker: Schema.optional(Schema.Literals([
+		"linear",
+		"github",
+		"gitlab",
+		"rally"
+	])),
+	workspaceRoot: Schema.optional(Schema.String)
+});
+const ContextWorkspaceSummary = Schema.Struct({
+	projectKey: Schema.String,
+	path: Schema.String,
+	name: Schema.String,
+	issueId: Schema.optional(Schema.String),
+	branch: Schema.optional(Schema.String)
+});
+const ContextLayerBase = {
+	file: Schema.String,
+	exists: Schema.Boolean,
+	content: Schema.String,
+	editable: Schema.Boolean
+};
+const GlobalContextLayerRecord = Schema.Struct({
+	kind: Schema.Literal("global"),
+	...ContextLayerBase
+});
+const ProjectContextLayerRecord = Schema.Struct({
+	kind: Schema.Literal("project"),
+	projectKey: Schema.String,
+	...ContextLayerBase
+});
+const WorkspaceContextLayerRecord = Schema.Struct({
+	kind: Schema.Literal("workspace"),
+	projectKey: Schema.String,
+	workspacePath: Schema.String,
+	...ContextLayerBase
+});
+const ContextEditableLayerRecord = Schema.Union([
+	GlobalContextLayerRecord,
+	ProjectContextLayerRecord,
+	WorkspaceContextLayerRecord
+]);
+const GlobalContextLayerTarget = Schema.Struct({ kind: Schema.Literal("global") });
+const ProjectContextLayerTarget = Schema.Struct({
+	kind: Schema.Literal("project"),
+	projectKey: Schema.String
+});
+const WorkspaceContextLayerTarget = Schema.Struct({
+	kind: Schema.Literal("workspace"),
+	projectKey: Schema.String,
+	workspacePath: Schema.String
+});
+const ContextLayerTarget = Schema.Union([
+	GlobalContextLayerTarget,
+	ProjectContextLayerTarget,
+	WorkspaceContextLayerTarget
+]);
+const ContextLayerDraft = Schema.Struct({
+	target: ContextLayerTarget,
+	content: Schema.String
+});
+/**
+* A rendered output file `pan sync` writes a Overdeck-managed region into
+* (e.g. ~/.claude/CLAUDE.md, a project's CLAUDE.md or AGENTS.md). Distinct from
+* the editable *layer source* files — this describes the injection *target* so
+* the dashboard can show the user exactly where context lands and reassure them
+* their own content is preserved.
+*/
+const ContextSyncTarget = Schema.Struct({
+	harness: ContextPreviewHarness,
+	layerKind: Schema.Literals(["global", "project"]),
+	projectKey: Schema.optional(Schema.String),
+	/** Short human label, e.g. "Claude Code · global". */
+	label: Schema.String,
+	/** Resolved absolute path of the target file. */
+	path: Schema.String,
+	exists: Schema.Boolean,
+	/** True when the file already contains a Overdeck-managed region. */
+	hasManagedRegion: Schema.Boolean,
+	/** True when the file has hand-authored content outside the managed region. */
+	hasUserContent: Schema.Boolean
+});
+const ContextLayersResponse = Schema.Struct({
+	operation: Schema.Literal("load"),
+	projects: Schema.Array(ContextProjectSummary),
+	workspaces: Schema.Array(ContextWorkspaceSummary),
+	layers: Schema.Array(ContextEditableLayerRecord),
+	/** Injection targets `pan sync` writes managed regions into. */
+	targets: Schema.Array(ContextSyncTarget)
+});
+const ContextPreviewRequest = Schema.Struct({
+	operation: Schema.Literal("preview"),
+	selectedLayer: ContextLayerTarget,
+	drafts: Schema.Array(ContextLayerDraft)
+});
+const ContextHarnessPreviews = Schema.Struct({
+	"claude-code": Schema.String,
+	pi: Schema.String,
+	codex: Schema.String,
+	fullPrompt: Schema.String
+});
+const ContextPreviewDiagnostic = Schema.Struct({
+	level: Schema.Literals([
+		"info",
+		"warning",
+		"error"
+	]),
+	message: Schema.String,
+	layer: Schema.optional(ContextLayerTarget)
+});
+const ContextPreviewResponse = Schema.Struct({
+	operation: Schema.Literal("preview"),
+	previews: ContextHarnessPreviews,
+	diagnostics: Schema.Array(ContextPreviewDiagnostic)
+});
+const ContextLayerSaveRequest = Schema.Struct({
+	operation: Schema.Literal("save"),
+	target: ContextLayerTarget,
+	content: Schema.String
+});
+const ContextLayerSaveResponse = Schema.Struct({
+	operation: Schema.Literal("save"),
+	layer: ContextEditableLayerRecord,
+	savedAt: Schema.String
+});
+const ContextSyncRequest = Schema.Struct({ operation: Schema.Literal("sync") });
+const ContextSyncResponse = Schema.Struct({
+	operation: Schema.Literal("sync"),
+	success: Schema.Boolean,
+	exitCode: Schema.optional(Schema.Number),
+	stdout: Schema.String,
+	stderr: Schema.String,
+	syncedAt: Schema.String
+});
+//#endregion
+//#region src/artifacts.ts
+const ArtifactId = Schema.String;
+const ArtifactSlug = Schema.String;
+const ArtifactHash = Schema.String;
+const ArtifactAgentRole = Schema.Literals([
+	"plan",
+	"work",
+	"review",
+	"test",
+	"ship",
+	"flywheel",
+	"user"
+]);
+const ArtifactAgentHarness = Schema.Literals([
+	"claude-code",
+	"pi",
+	"codex",
+	"user"
+]);
+const ArtifactLifecycleState = Schema.Literals([
+	"published",
+	"pending_changes",
+	"unshared"
+]);
+const ArtifactValidationCode = Schema.Literals([
+	"invalid_file_type",
+	"not_a_file",
+	"size_limit_exceeded",
+	"forbidden_asset_url",
+	"secret_detected",
+	"secret_allowed",
+	"high_entropy_string",
+	"inline_event_handler",
+	"missing_image_alt"
+]);
+const ArtifactValidationFinding = Schema.Struct({
+	code: ArtifactValidationCode,
+	message: Schema.String,
+	line: Schema.optional(Schema.Number),
+	column: Schema.optional(Schema.Number),
+	rule: Schema.optional(Schema.String),
+	strict: Schema.optional(Schema.Boolean)
+});
+const ArtifactValidationResult = Schema.Struct({
+	ok: Schema.Boolean,
+	filePath: Schema.optional(Schema.String),
+	size: Schema.Number,
+	hash: ArtifactHash,
+	strict: Schema.Boolean,
+	errors: Schema.Array(ArtifactValidationFinding),
+	warnings: Schema.Array(ArtifactValidationFinding)
+});
+const ArtifactMetadata = Schema.Struct({
+	artifactId: ArtifactId,
+	slug: ArtifactSlug,
+	issueId: Schema.optional(Schema.NullOr(Schema.String)),
+	workspaceId: Schema.optional(Schema.NullOr(Schema.String)),
+	agentRole: Schema.optional(Schema.NullOr(ArtifactAgentRole)),
+	agentHarness: Schema.optional(Schema.NullOr(ArtifactAgentHarness)),
+	runId: Schema.optional(Schema.NullOr(Schema.String)),
+	sessionId: Schema.optional(Schema.NullOr(Schema.String)),
+	filePath: Schema.String,
+	currentHash: ArtifactHash,
+	lastPublishedHash: Schema.optional(Schema.NullOr(ArtifactHash)),
+	supersedes: Schema.optional(Schema.NullOr(ArtifactId)),
+	title: Schema.optional(Schema.NullOr(Schema.String)),
+	description: Schema.optional(Schema.NullOr(Schema.String)),
+	createdAt: Schema.String,
+	publishedAt: Schema.optional(Schema.NullOr(Schema.String)),
+	unsharedAt: Schema.optional(Schema.NullOr(Schema.String))
+});
+const ArtifactUrls = Schema.Struct({
+	wrapperUrl: Schema.String,
+	rawUrl: Schema.String
+});
+const ArtifactStatusResponse = Schema.Struct({
+	artifact: Schema.optional(ArtifactMetadata),
+	filePath: Schema.String,
+	currentHash: ArtifactHash,
+	lastPublishedHash: Schema.optional(Schema.NullOr(ArtifactHash)),
+	pendingChanges: Schema.Boolean,
+	validation: Schema.optional(ArtifactValidationResult)
+});
+const ArtifactCreateResponse = Schema.Struct({
+	artifact: ArtifactMetadata,
+	urls: ArtifactUrls,
+	validation: ArtifactValidationResult,
+	published: Schema.Boolean
+});
+const ArtifactPublishResponse = Schema.Struct({
+	artifact: ArtifactMetadata,
+	urls: ArtifactUrls,
+	validation: ArtifactValidationResult,
+	published: Schema.Boolean,
+	pendingChanges: Schema.Boolean
+});
+const ArtifactUnshareResponse = Schema.Struct({
+	artifact: ArtifactMetadata,
+	unshared: Schema.Boolean
+});
+const ArtifactListEntry = Schema.Struct({
+	artifact: ArtifactMetadata,
+	urls: ArtifactUrls,
+	status: ArtifactLifecycleState,
+	pendingChanges: Schema.Boolean,
+	thumbnailUrl: Schema.optional(Schema.String)
+});
+const ArtifactListResponse = Schema.Struct({ artifacts: Schema.Array(ArtifactListEntry) });
+const ArtifactDetailResponse = Schema.Struct({
+	artifact: ArtifactMetadata,
+	urls: ArtifactUrls,
+	status: ArtifactLifecycleState,
+	pendingChanges: Schema.Boolean
+});
+const WorkspaceArtifactsResponse = Schema.Struct({
+	issueId: Schema.optional(Schema.String),
+	workspaceId: Schema.optional(Schema.String),
+	artifacts: Schema.Array(ArtifactListEntry)
+});
+//#endregion
+//#region src/feature-registry.ts
+const FeatureRegistryStatus = Schema.Literals([
+	"active",
+	"archived",
+	"merged",
+	"deferred"
+]);
+const FeatureRegistryEntry = Schema.Struct({
+	featureId: Schema.String,
+	featureName: Schema.String,
+	description: Schema.NullOr(Schema.String),
+	owningWorkspaceId: Schema.NullOr(Schema.String),
+	owningIssueId: Schema.NullOr(Schema.String),
+	owningAgentId: Schema.NullOr(Schema.String),
+	status: FeatureRegistryStatus,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	tags: Schema.Array(Schema.String)
+});
+//#endregion
+export { Activity, ActivityDetailedEvent, ActivityEntryEvent, ActivityTtsEvent, ActivityUpdatedEvent, AgentActivityChangedEvent, AgentChannelReply, AgentChannelReplyEvent, AgentCompletedEvent, AgentContextSaturationChangedEvent, AgentCreatedEvent, AgentCurrentIssueSetEvent, AgentEnrichmentChangedEvent, AgentHeartbeatDeadEvent, AgentId, AgentMessageReceivedEvent, AgentModelSetEvent, AgentOutput, AgentOutputReceivedEvent, AgentPermissionRequestedEvent, AgentPermissionResolvedEvent, AgentResolution, AgentResolutionChangedEvent, AgentRuntimeSnapshot, AgentSnapshot, AgentStartedEvent, AgentStateRestoredEvent, AgentStatus, AgentStatusChangedEvent, AgentStoppedEvent, AgentThinkingStartedEvent, AgentThinkingStoppedEvent, AgentTurnDiffCompletedEvent, AgentWaitingClearedEvent, AgentWaitingStartedEvent, ArtifactAgentHarness, ArtifactAgentRole, ArtifactCreateResponse, ArtifactDetailResponse, ArtifactHash, ArtifactId, ArtifactLifecycleState, ArtifactListEntry, ArtifactListResponse, ArtifactMetadata, ArtifactPublishResponse, ArtifactSlug, ArtifactStatusResponse, ArtifactUnshareResponse, ArtifactUrls, ArtifactValidationCode, ArtifactValidationFinding, ArtifactValidationResult, CHANNEL_REPLY_KIND_VALUES, CONTEXT_LAYER_KINDS, CONTEXT_PREVIEW_HARNESSES, ChannelPermissionRequestSnapshot, ChannelReplyArtifactRef, ChannelReplyKind, ChatMessage, ClaudeChannelPermissionBehavior, CompactBoundary, ContextEditableLayerRecord, ContextHarnessPreviews, ContextLayerDraft, ContextLayerKind, ContextLayerSaveRequest, ContextLayerSaveResponse, ContextLayerTarget, ContextLayersResponse, ContextPreviewDiagnostic, ContextPreviewHarness, ContextPreviewRequest, ContextPreviewResponse, ContextProjectSummary, ContextSyncRequest, ContextSyncResponse, ContextSyncTarget, ContextUsage, ContextWorkspaceSummary, ConversationCompactingChangedEvent, ConversationCostSummary, ConversationCreatedEvent, ConversationEvent, ConversationFilter, ConversationPermissionChangedEvent, CostEventRecordedEvent, DEFAULT_MAX_MEMORY_OBSERVATIONS_PER_ISSUE, DEFAULT_MAX_TURN_DIFF_SUMMARIES_PER_AGENT, DashboardLifecycleCompletedEvent, DashboardLifecycleFailedEvent, DashboardLifecycleStartedEvent, DashboardSnapshot, DeepWipeRpc, DiscoveredSessionSnapshot, DomainEvent, EDITORS, EditorIdSchema, EmbedProgressEvent, EmbedProgressSnapshot, EmbedSessionsRpc, EnrichCompleteEvent, EnrichProgressEvent, EnrichProgressSnapshot, EnrichSessionsRpc, EnrichStatsSnapshot, ExtractionProviderConfig, ExtractionProviderTarget, FeatureNode, FeatureRegistryEntry, FeatureRegistryStatus, FlywheelAgent, FlywheelAgentStatus, FlywheelEffort, FlywheelHarness, FlywheelHeadline, FlywheelHttpUrl, FlywheelOrchestrator, FlywheelParkedItem, FlywheelPipelineItem, FlywheelPipelineStatus, FlywheelPipelineVerb, FlywheelRunId, FlywheelStats, FlywheelStatsCriteria, FlywheelStatsCriterion, FlywheelStatsCriterionStatus, FlywheelStatsCriterionValue, FlywheelStatsCriterionValueObject, FlywheelStatsTrend, FlywheelStatus, FlywheelSubstrateBug, FlywheelSubstrateBugStatus, FlywheelSuggestion, FlywheelSuggestionAction, FlywheelSuggestionPriority, FlywheelSystemStatus, GetAvailableEditorsRpc, GetConversationCostByWorkspaceRpc, GetConversationCostRpc, GetConversationStatsRpc, GetDiscoveredSessionRpc, GetSnapshotRpc, GetWorkspaceDetailRpc, GlobalContextLayerRecord, GlobalContextLayerTarget, INITIAL_READ_MODEL_STATE, IssueId, IssueStatusChangedEvent, IssuesSnapshotEvent, IssuesUpdatedEvent, ListDiscoveredSessionsRpc, MAX_CHANNEL_REPLY_ARTIFACT_LABEL_LENGTH, MAX_CHANNEL_REPLY_ARTIFACT_REFS, MAX_CHANNEL_REPLY_ARTIFACT_URI_LENGTH, MAX_CHANNEL_REPLY_SUMMARY_LENGTH, MemoryHealthChangedEvent, MemoryIdentity, MemoryObservation, MemoryObservationCreatedEvent, MemoryResetMarkerCreatedEvent, MemoryRollupTriggeredEvent, MemoryStatus, MemoryStatusPhase, MemoryStatusUpdatedEvent, MemoryTokenUsage, MergeReadyEvent, MergeStatusValue, OpenInEditorInput, OperatorInterventionEvent, PanRpcError, PanRpcGroup, PendingTurn, PipelineReviewCompletedEvent, PipelineReviewStartedEvent, PipelineStatusChangedEvent, PipelineTestCompletedEvent, PipelineTestStartedEvent, PlanItemStatusChangedEvent, PlanItemsUnblockedEvent, PlanSubitemStatusChangedEvent, PlanningFailedEvent, PlanningStartedEvent, PlanningSyncEvent, ProjectContextLayerRecord, ProjectContextLayerTarget, ProjectSessionTree, ProposedPlan, RagDecision, RagDecisionSource, ReadWorkspaceFileInput, ReadWorkspaceFileResult, ReadWorkspaceFileRpc, ReplayEventsRpc, ResetMarker, ResetMarkerScope, ResizeTerminalRpc, ResolveFilePathExistsInput, ResolveFilePathExistsResult, ResolveFilePathExistsRpc, ResourceStats, ResourcesUpdatedEvent, ReviewApprovedEvent, ReviewCoordinatorDiedEvent, ReviewCoordinatorStartedEvent, ReviewReviewerCompletedEvent, ReviewReviewerStartedEvent, ReviewSpecialistTimedOutEvent, ReviewStatusChangedEvent, ReviewStatusSnapshot, ReviewStatusValue, ReviewerRoundMetadata, ReviewerRoundSummary, Role, ScanCompleteEvent, ScanConversationsRpc, ScanProgressEvent, ScanProgressSnapshot, ScanResult, ScanStartedEvent, SearchConversationsRpc, SendTerminalInputRpc, SequenceNumber, SessionNode, SessionNodePresence, SessionNodeType, SessionTreeDelta, ShadowInferenceUpdateEvent, ShellOpenInEditorRpc, SpecialistCompletedEvent, SpecialistFailedEvent, SpecialistStartedEvent, StartAgentRpc, StartPlanningRpc, SubscribeAgentOutputRpc, SubscribeConversationMessagesRpc, SubscribeDomainEventsRpc, SubscribeFlywheelStatusRpc, SubscribeIssueEventsRpc, SubscribeProjectSessionTreeRpc, SubscribeTerminalRpc, SubstrateBugFiledEvent, SystemHealthSeverityChangedEvent, SystemHeartbeatEvent, TerminalCloseRpc, TerminalOpenRpc, TerminalOutput, TerminalResizeRpc, TerminalWriteRpc, TestPassedEvent, TestStatusValue, ThinkingState, TurnDiffFileChange, TurnDiffSummary, UatStatusValue, VerificationStatusValue, WS_METHODS, WaitingReason, WaitingState, WorkCompletedEvent, WorkLogEntry, WorkspaceAbortedEvent, WorkspaceArtifactsResponse, WorkspaceContextLayerRecord, WorkspaceContextLayerTarget, WorkspaceCreatedEvent, WorkspaceDeletedEvent, WorkspaceDestroyedEvent, WorkspaceDetail, WorkspaceWipeStartedEvent, applyEvent, applyEvents, decodeFlywheelStats, encodeFlywheelStats, getHarness, getMaxMemoryObservationsPerIssue, getMaxTurnDiffSummariesPerAgent, isChannelReplyKind, isTerminalTurnDiffSummaryStatus, normalizeChannelReplyPayload, omitTurnDiffSummariesForAgent, syncSnapshot, trimMemoryObservations, trimTurnDiffSummaries };
+
+//# sourceMappingURL=index.mjs.map