@overdeck/desktop 0.45.21 → 0.45.23

package/server/server.js

@@ -1,107 +1,110 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { $ as MODEL_CAPABILITIES, $n as resolveProjectFromIssueSync, $r as getLegacyHome, A as init_harness_policy, An as getIssuePrefix, At as init_record, B as init_providers, C as init_tier_table, D as validateTieredExecutionConfig, En as findProjectByPathSync, Er as TrackerError, Ft as readIssueRecordSync, Gr as SYNC_SOURCES, Hn as listProjects, I as getBuiltInDefaultHarness, J as DEFAULT_ROLES, Jn as registerProjectSync, Jr as getDocsBudgetStatePath, K as defaultBackgroundAiFeatures, L as getKimiAnthropicBaseUrl, Lr as LOGS_DIR, Nn as getProjectSync, O as canUseHarnessSync, On as findProjectByTeamSync, Or as init_errors, Ot as getIssueWorkspacePath, P as UnknownModelError, Pr as CLAUDE_DIR, Q as resolveModel, Qn as resolveProjectFromIssue, Rr as OVERDECK_HOME, S as TieredExecutionConfigError, Sn as ProjectRenameError, T as resolveTieredExecutionEnabled, Un as listProjectsSync, X as computeModelOrigin, Xr as getDocsIndexPath, Y as DEFAULT_WORKHORSES, Yn as renameProject, Yr as getDocsDisableStatePath, Zn as resolveInfraRepo, Zr as getDocsTelemetryPath, _ as getDefaultDocsConfig, ai as sessionFilePath, an as init_auto_commit, at as modelSupportsImagesSync, br as GitHubApiError, cr as extractPrefixSync, d as loadConfigNoMigration, dr as parseIssueIdSync, dt as PARENT_MODEL_REF, ei as getOverdeckHome, et as MODEL_DEPRECATIONS, f as loadConfigSync, ft as ROLE_EFFORTS, g as mergeConfigs, h as jsYaml, i as getConversationsConfig, in as flushAutoCommits, ir as setProjectSwarmPolicySync, it as init_model_capabilities, kr as AGENTS_DIR, lr as init_issue_id, m as init_js_yaml, mr as require_dist$1, n as clearConfigCache, ni as isDevMode, nt as getModelEffortLevelsSync, o as getGlobalConfigPath, ot as resolveModelIdSync, p as updateConversationsConfig, q as init_registry, qr as encodeClaudeProjectDir, r as getConversationSearchConfigSync, ri as packageRoot, rn as flushAllPendingAutoCommits, rr as setProjectAutoMergeDefaultSync, rt as hasModelCapabilitySync, s as init_load, t as init_config_yaml, ti as init_paths, u as isTldrEnabledSync, ut as COMPLIANCE_MODES, v as getDefaultTtsDaemonConfig, vr as FsError, w as resolveTieredExecutionBlock, wn as extractTeamPrefix, wr as ProcessSpawnError, y as mergeTtsDaemonConfigs, z as getProviderForModelSync, zn as init_projects } from "./config-yaml-Ciyp2mYe.js";
-import { a as shouldRefuseHostDashboardPort, i as readHostDashboardApiPort, n as getDashboardIdentity, r as isNonPrimaryCheckoutRoot } from "./deacon-nudge-log-C5VCKtyi.js";
-import { $ as runInBatches, A as handleConversationDelete, B as stopConversationRuntime, C as isPiControlChannelHarness, D as conversationNeedsRunningRepair, E as validateConversationControlAckOrigin, F as isInsideGitWorkTree, G as cleanupOrphanedConversationAttachments, H as waitForPiTuiReady, I as resolveAllowedHarness, J as extractConversationAttachmentPaths, K as cleanupUnreferencedConversationAttachments, L as shouldReportUnresolvedLiveSession, M as handleConversationResume, N as handleConversationStop, O as conversationSessionAliveFromState, P as handleConversationSwitchModel, Q as removeConversationAttachment, R as spawnConversationSession, S as handleConversationThinkingLevel, T as resolveConversationDeliveryMethod, U as waitForTmuxSession$1, V as tmuxSessionExists, W as cleanupConversationAttachments, X as hasConversationAttachment, Y as getConversationAttachmentsRoot, Z as isManagedConversationAttachmentPath, _ as handleConversationCodexApproval, _t as validateOrigin$1, a as agentsRouteLayer, at as panCliInvocation, b as handleConversationDeliveryMethod, bt as getDefaultCwd, c as hasDashboardInternalToken, ct as resolveAgentHarness, d as rejectUnsafeDashboardMutationRequest, dt as resolveJsonlPath, et as evaluateSpawnGuardrails, f as saveAgentStateAndEmitEvent, ft as resolvePiSessionPath, g as handleConversationAbort, gt as isTrustedOriginForHost, h as deliverConversationViaControlChannel, ht as getHeaderFromMap, j as handleConversationRestartAll, k as handleConversationCreate, l as rejectUnauthorizedDashboardRequest, lt as resolveClaudeSessionId, m as codexConversationPendingInput, mt as waitForSessionRespawn, nt as resolveAgentGitInfo, o as dashboardCsrfToken, p as saveAgentStateAndEmitEventProgram, pt as isRespawnPending, q as ensureConversationAttachmentDir, rt as resolveConversationGitInfo, s as dashboardSessionCookieHeader, st as readLauncherPinnedSessionId, t as specialistsRouteLayer, tt as invalidateAgentsCache, u as rejectUnauthorizedDashboardSessionMintRequest, ut as resolveCodexRolloutPath, v as handleConversationCompact, vt as validateOriginHeaders, w as pickDeliverAs, x as handleConversationPlanAction, xt as jsonResponse, y as handleConversationControlAck, yt as httpHandler, z as startConversationModelBackfill } from "./specialists-DAegTvRt.js";
+import { A as canUseHarnessSync, Br as getOverdeckHome, Cr as LOGS_DIR, D as resolveTieredExecutionEnabled, E as resolveTieredExecutionBlock, Et as getIssueWorkspacePath, Fn as renameProject, Fr as getDocsDisableStatePath, Gr as sessionFilePath, H as init_providers, Hr as isDevMode, Ht as flushAutoCommits, I as UnknownModelError, Ir as getDocsIndexPath, J as defaultBackgroundAiFeatures, Jn as extractPrefixSync, Ln as resolveInfraRepo, Lr as getDocsTelemetryPath, M as init_harness_policy, Nr as encodeClaudeProjectDir, Nt as readIssueRecordSync, On as listProjects, Ot as init_record, Pn as registerProjectSync, Pr as getDocsBudgetStatePath, Q as computeModelOrigin, R as getBuiltInDefaultHarness, Rn as resolveProjectFromIssue, T as init_tier_table, Tn as init_projects, Un as setProjectAutoMergeDefaultSync, Ur as packageRoot, Ut as init_auto_commit, V as getProviderForModelSync, Vr as init_paths, Vt as flushAllPendingAutoCommits, Wn as setProjectSwarmPolicySync, X as DEFAULT_ROLES, Y as init_registry, Yn as init_issue_id, Z as DEFAULT_WORKHORSES, Zn as parseIssueIdSync, _ as getDefaultDocsConfig, at as getModelEffortLevelsSync, br as CLAUDE_DIR, cn as ProjectRenameError, ct as modelSupportsImagesSync, d as loadConfigNoMigration, er as require_dist$1, f as loadConfigSync, fn as findProjectByPathSync, fr as TrackerError, g as mergeConfigs, gn as getIssuePrefix, h as jsYaml, hr as AGENTS_DIR, ht as ROLE_EFFORTS, i as getConversationsConfig, ir as FsError, jr as SYNC_SOURCES, k as validateTieredExecutionConfig, kn as listProjectsSync, lt as resolveModelIdSync, m as init_js_yaml, mn as findProjectByTeamSync, mr as init_errors, mt as PARENT_MODEL_REF, n as clearConfigCache, nt as MODEL_CAPABILITIES, o as getGlobalConfigPath, or as GitHubApiError, ot as hasModelCapabilitySync, p as updateConversationsConfig, pt as COMPLIANCE_MODES, r as getConversationSearchConfigSync, rt as MODEL_DEPRECATIONS, s as init_load, st as init_model_capabilities, t as init_config_yaml, tt as resolveModel, u as isTldrEnabledSync, un as extractTeamPrefix, ur as ProcessSpawnError, v as getDefaultTtsDaemonConfig, w as TieredExecutionConfigError, wr as OVERDECK_HOME, y as mergeTtsDaemonConfigs, yn as getProjectSync, z as getKimiAnthropicBaseUrl, zn as resolveProjectFromIssueSync, zr as getLegacyHome } from "./config-yaml-DvyMuOle.js";
+import { a as shouldRefuseHostDashboardPort, i as readHostDashboardApiPort, n as getDashboardIdentity, r as isNonPrimaryCheckoutRoot } from "./deacon-nudge-log-Bjg8U4Y9.js";
+import { $ as runInBatches, A as handleConversationDelete, B as stopConversationRuntime, C as isPiControlChannelHarness, D as conversationNeedsRunningRepair, E as validateConversationControlAckOrigin, F as isInsideGitWorkTree, G as cleanupOrphanedConversationAttachments, H as waitForPiTuiReady, I as resolveAllowedHarness, J as extractConversationAttachmentPaths, K as cleanupUnreferencedConversationAttachments, L as shouldReportUnresolvedLiveSession, M as handleConversationResume, N as handleConversationStop, O as conversationSessionAliveFromState, P as handleConversationSwitchModel, Q as removeConversationAttachment, R as spawnConversationSession, S as handleConversationThinkingLevel, St as jsonStringResponse, T as resolveConversationDeliveryMethod, U as waitForTmuxSession$1, V as tmuxSessionExists, W as cleanupConversationAttachments, X as hasConversationAttachment, Y as getConversationAttachmentsRoot, Z as isManagedConversationAttachmentPath, _ as handleConversationCodexApproval, _t as validateOrigin$1, a as agentsRouteLayer, at as panCliInvocation, b as handleConversationDeliveryMethod, bt as getDefaultCwd, c as hasDashboardInternalToken, ct as resolveAgentHarness, d as rejectUnsafeDashboardMutationRequest, dt as resolveJsonlPath, et as evaluateSpawnGuardrails, f as saveAgentStateAndEmitEvent, ft as resolvePiSessionPath, g as handleConversationAbort, gt as isTrustedOriginForHost, h as deliverConversationViaControlChannel, ht as getHeaderFromMap, j as handleConversationRestartAll, k as handleConversationCreate, l as rejectUnauthorizedDashboardRequest, lt as resolveClaudeSessionId, m as codexConversationPendingInput, mt as waitForSessionRespawn, nt as resolveAgentGitInfo, o as dashboardCsrfToken, p as saveAgentStateAndEmitEventProgram, pt as isRespawnPending, q as ensureConversationAttachmentDir, rt as resolveConversationGitInfo, s as dashboardSessionCookieHeader, st as readLauncherPinnedSessionId, t as specialistsRouteLayer, tt as invalidateAgentsCache, u as rejectUnauthorizedDashboardSessionMintRequest, ut as resolveCodexRolloutPath, v as handleConversationCompact, vt as validateOriginHeaders, w as pickDeliverAs, x as handleConversationPlanAction, xt as jsonResponse, y as handleConversationControlAck, yt as httpHandler, z as startConversationModelBackfill } from "./specialists-JVO00bs7.js";
 import { a as init_activity_logger, i as emitDashboardLifecycleSync, n as emitActivityEntrySync, r as emitActivityTtsSync } from "./activity-logger-DDlOIAML.js";
-import { A as init_paths$1, O as OVERDECK_MIGRATION_PATH, f as init_infra, i as DbLive, k as getOverdeckDatabasePath, u as TmuxLive } from "./infra-DN2wSxle.js";
+import { A as init_paths$1, O as OVERDECK_MIGRATION_PATH, f as init_infra, i as DbLive, k as getOverdeckDatabasePath, u as TmuxLive } from "./infra-CzaSOgul.js";
 import { n as openDatabase, t as init_driver } from "./driver-CKVGi51s.js";
-import { n as updateIssueRecord, t as init_record_update } from "./record-update-RviRDSNs.js";
-import { C as getWindowDimensions, D as killSession, I as resizeWindow, K as init_ui_theme, M as listSessions, R as sendKeys, T as isHarnessProcessAlive, V as sessionExists, X as buildChildEnvWithoutTmuxSync, Y as buildChildEnvSync, Z as init_child_env, d as ensureManagedTmuxContextOnce, i as capturePane, j as listSessionNames, k as listPaneValues, l as deliveryVerifyLine, n as buildTmuxArgs, o as capturePaneText, q as setUiTheme, s as createSession, w as init_tmux, z as sendKeysAsync } from "./tmux-y1blSxks.js";
-import { a as init_event_store, i as initEventStore, n as getEventStore } from "./event-store-BVnON3vf.js";
-import { _ as FlywheelRunId, a as getHarnessBehavior, b as DomainEvent, c as FlywheelStats, g as WS_METHODS, h as PanRpcGroup, m as PanRpcError, o as ContextLayerSaveRequest, s as ContextPreviewRequest, t as init_src, v as FlywheelStatus, x as MemoryObservation, y as EDITORS } from "./src-Dpq1yFIl.js";
-import { a as fixStuckReadyForMerge, c as init_review_status, i as fixStuckCommentedReviews, l as loadReadyForMergeFlags, n as clearReviewStatus, o as getReviewStatus, r as clearStuckMergeStatuses, s as getReviewStatusSync, u as loadReviewStatuses, v as setReviewStatus, y as setReviewStatusSync } from "./review-status-CCgPVK1h.js";
-import { a as EventStoreService, c as ReadModelService, d as init_read_model, f as toAgentResolution, i as init_issue_lifecycle, l as ReadModelServiceLive, m as toRole, n as IssueLifecycleLive, o as EventStoreServiceLive, p as toAgentStatus, s as init_domain_services, t as IssueLifecycle } from "./issue-lifecycle-B7HZWnTA.js";
-import { c as listAllAgentsSync, n as AgentsResolverLive, o as init_agents } from "./agents-DbrHWunF.js";
-import { i as init_paths$2, l as resolveObservationsFile, r as ensureParentDir, s as resolveIssueMemoryRoot, t as assertMemorySafeSegment } from "./paths-FP8v3lTz.js";
-import { i as recordBriefingSessionStart, n as ensureSessionContextBriefingFile, r as init_briefing_freshness, t as appendFreshBriefingUpdate } from "./briefing-freshness-OouGbJ7d.js";
-import { n as listFeatureRegistryEntries, t as init_feature_registry_storage } from "./feature-registry-storage-BWymOgXE.js";
-import { a as diffAgainstMain, c as diffCheckpoints, d as diffPatchSinceCommit, f as findCommitAtTime, h as listCheckpoints, l as diffFilesAgainstHead, m as init_checkpoint_manager, o as diffAgainstMainFiles, s as diffCheckpointFiles, t as captureCheckpoint, u as diffPatchFilesAgainstHead } from "./checkpoint-manager-D64fCC4p.js";
-import { An as getAgentStateFilePath, Ct as probeTranscriptSince, Dn as getAgentDir, Gn as saveAgentStateSync, Gt as getProviderAuthMode, It as resolveImplicitStaffing, Jt as injectPiConversationMemory, L as messageAgent, Pt as init_staffing, Qn as readAgentHarnessModelRecordSync, R as init_operator_interventions, St as init_transcript_landing, Zn as init_agent_record_sync, _r as init_codex_auth, a as listRunningAgentsSync, ar as normalizeAgentId, cr as waitForReadySignal, dn as getOpenAIAuthStatus, fn as init_openai_auth, gr as checkCodexAuthStatus, gt as deliverAgentMessage, i as listRunningAgents, it as emergencyBrake, jn as getAgentStateSync, kn as getAgentState, lr as getAgentRuntimeState, m as init_tier_supervisor, n as init_queries, nn as init_claude_auth, on as getProviderEnvForModel, ot as init_concurrency, p as deliverCommitForReview, r as listAgentStates, s as init_agents$1, tn as getClaudeAuthStatus, ur as getAgentRuntimeStateSync, v as supervisorAgentId, xt as captureTranscriptUserRecordSnapshot, z as operatorInterventionEvent } from "./queries-B5hl7lMQ.js";
-import { a as getCostForIssueAggregateSync, c as getDailyTrendsSync, d as init_cost_sync, l as getModelRollupSync, n as getBackgroundCostBySourceSync, p as queryCostEventsSync, r as getCavemanExperimentDataSync, s as getCostsByIssueSync, u as getTodayCostSync } from "./cost-sync-DzHP6zaR.js";
-import { c as getAgentsNeedingAttention, d as CostResolverLive, f as CostWriter, l as CostDoorLive, n as readCloisterStateFile, o as generateHealthSummary, s as getAgentHealth, t as getCloisterService, u as CostResolver } from "./service-CqAY8Kmk.js";
-import { t as init_behavior } from "./behavior-Dg-D8eBG.js";
-import { n as AgentStateServiceLive } from "./agent-state-service-6MFQqnFy.js";
-import { a as init_tracker_config, i as initTrackerConfigCache, n as getLinearApiKey, r as getRallyConfig, t as getGitHubConfig } from "./tracker-config-DSFZBdXP.js";
+import { n as updateIssueRecord, t as init_record_update } from "./record-update-Dq0t2uBG.js";
+import { $ as init_child_env, B as sendKeysAsync, C as getWindowDimensions, D as killSession, H as sessionExists, J as init_ui_theme, L as resizeWindow, M as listSessionNames, Q as buildChildEnvWithoutTmuxSync, T as isHarnessProcessAlive, Y as setUiTheme, Z as buildChildEnvSync, d as ensureManagedTmuxContextOnce, i as capturePane, l as deliveryVerifyLine, n as buildTmuxArgs, o as capturePaneText, s as createSession, w as init_tmux, z as sendKeys } from "./tmux-ftABRAmc.js";
+import { a as init_event_store, i as initEventStore, n as getEventStore } from "./event-store-tdiY5eDZ.js";
+import { D as AgentSnapshot, E as AgentRuntimeSnapshot, O as ReviewStatusSnapshot, S as SystemHealthSnapshot, _ as WS_METHODS, b as EDITORS, c as ContextPreviewRequest, g as PanRpcGroup, h as PanRpcError, l as FlywheelStats, n as compareIssueIds, o as getHarnessBehavior, s as ContextLayerSaveRequest, t as init_src, v as FlywheelRunId, w as MemoryObservation, x as DomainEvent, y as FlywheelStatus } from "./src-U7_kTPEE.js";
+import { a as fixStuckCommentedReviews, b as setReviewStatusSync, c as getReviewStatusSync, d as loadReviewStatuses, l as init_review_status, n as clearReviewStatus, o as fixStuckReadyForMerge, p as markWorkspaceStuck, r as clearStuckMergeStatuses, s as getReviewStatus, u as loadReadyForMergeFlags, y as setReviewStatus } from "./review-status-A7quS5KJ.js";
+import { a as EventStoreService, c as ReadModelService, d as init_read_model, f as toAgentResolution, i as init_issue_lifecycle, l as ReadModelServiceLive, m as toRole, n as IssueLifecycleLive, o as EventStoreServiceLive, p as toAgentStatus, s as init_domain_services, t as IssueLifecycle } from "./issue-lifecycle-CreaCkjW.js";
+import { c as listAllAgentsSync, n as AgentsResolverLive, o as init_agents } from "./agents-B4Bjbkfv.js";
+import { i as init_paths$2, l as resolveObservationsFile, r as ensureParentDir, s as resolveIssueMemoryRoot, t as assertMemorySafeSegment } from "./paths-_zEts6wc.js";
+import { i as recordBriefingSessionStart, n as ensureSessionContextBriefingFile, r as init_briefing_freshness, t as appendFreshBriefingUpdate } from "./briefing-freshness-DWdW7vUm.js";
+import { n as listFeatureRegistryEntries, t as init_feature_registry_storage } from "./feature-registry-storage-_wUBRD3J.js";
+import { a as diffAgainstMain, c as diffCheckpoints, d as diffPatchSinceCommit, f as findCommitAtTime, h as listCheckpoints, l as diffFilesAgainstHead, m as init_checkpoint_manager, o as diffAgainstMainFiles, s as diffCheckpointFiles, t as captureCheckpoint, u as diffPatchFilesAgainstHead } from "./checkpoint-manager-DDqcGyu8.js";
+import { Ar as init_codex_auth, Bn as getAgentDir, Cr as getAgentRuntimeStateSync, D as init_tier_supervisor, E as deliverCommitForReview, Ft as init_transcript_landing, Hn as getAgentState, It as probeTranscriptSince, Pt as captureTranscriptUserRecordSnapshot, Q as operatorInterventionEvent, Sr as getAgentRuntimeState, Tn as init_openai_auth, Wn as getAgentStateSync, X as messageAgent, Yt as resolveImplicitStaffing, Z as init_operator_interventions, _t as emergencyBrake, a as listRunningAgentsSync, b as init_agents$1, c as getRuntimeCensus, d as panePidsForSession, dr as readAgentHarnessModelRecordSync, f as refreshRuntimeCensus, hn as init_claude_auth, i as listRunningAgents, in as getProviderAuthMode, ir as saveAgentStateSync, j as supervisorAgentId, kr as checkCodexAuthStatus, kt as deliverAgentMessage, l as getRuntimeCensusSnapshot, mn as getClaudeAuthStatus, n as init_queries, p as runtimeCensusHasHarnessProcess, qt as init_staffing, r as listAgentStates, sn as injectPiConversationMemory, u as init_runtime_census, ur as init_agent_record_sync, vr as normalizeAgentId, wn as getOpenAIAuthStatus, xr as waitForReadySignal, yn as getProviderEnvForModel, yt as init_concurrency } from "./queries-6d7Cdtm7.js";
+import { a as getCostForIssueAggregateSync, c as getDailyTrendsSync, d as init_cost_sync, l as getModelRollupSync, n as getBackgroundCostBySourceSync, p as queryCostEventsSync, r as getCavemanExperimentDataSync, s as getCostsByIssueSync, u as getTodayCostSync } from "./cost-sync-C0VdGme1.js";
+import { c as getAgentsNeedingAttention, d as CostResolverLive, f as CostWriter, l as CostDoorLive, n as readCloisterStateFile, o as generateHealthSummary, s as getAgentHealth, t as getCloisterService, u as CostResolver } from "./service-DCpB_SGd.js";
+import { u as init_agent_runtime_mirror } from "./session-history-CVZDpS3c.js";
+import { t as init_behavior } from "./behavior-B_-4EKF3.js";
+import { n as AgentStateServiceLive } from "./agent-state-service-HoK8U4jW.js";
+import { a as init_tracker_config, i as initTrackerConfigCache, n as getLinearApiKey, r as getRallyConfig, t as getGitHubConfig } from "./tracker-config-B4itFzDo.js";
 import { d as init_typed_errors, i as PlanEmpty, l as WorkspaceCreateError, n as AgentStartError, s as TrackerApiError, t as AgentAlreadyRunning, u as WorkspaceNotFound } from "./typed-errors-2BTMxkZq.js";
-import { i as init_linear_client, r as LinearClientOptionalLive, t as LinearClient } from "./linear-client-BLyN-NiP.js";
-import { i as init_github_client, r as GitHubClientOptionalLive, t as GitHubClient } from "./github-client-Dslipypz.js";
-import { i as init_rally_client, r as RallyClientOptionalLive, t as RallyClient } from "./rally-client-SVbjGvqj.js";
-import { a as resolveTrackerTypeSync, i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-DiceZN3a.js";
-import { a as CacheService, i as startSharedIssueService, n as init_issue_service_singleton, o as init_cache_service, r as issue_service_singleton_exports, s as parseIntegerHeader, t as getSharedIssueService } from "./issue-service-singleton-CPESc4Or.js";
-import { i as ensureInternalTokenSync, s as init_internal_token } from "./internal-token-DhfFiwW7.js";
-import { a as setPipelineHandlerSync, t as init_pipeline_notifier } from "./pipeline-notifier-BM2HLF7B.js";
-import { c as init_review_status_sync, i as getMergeBlockerReconcileCandidates } from "./review-status-sync-jnLgd04F.js";
-import { a as PAN_DIRNAME, d as WORKSPACE_RUNTIME_DIRNAME, f as asPanSpecDocument, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-DqeBMmJN.js";
-import { C as transitionToMerging, _ as markFailed, c as isFlywheelGloballyPaused, d as listDuePendingAutoMerges, f as listProblemAutoMerges, g as markBlocked, n as getActionableAutoMerge, o as init_merge_sync, t as cancelPending, u as listActiveAutoMerges, v as markMerged, x as scheduleAutoMergeWithResult, y as requeueToPending } from "./merge-sync-De1FYva5.js";
-import { C as init_specs, D as writeSpecDocument, O as writeSpecForIssue, a as findWorkspaceDraftPlan, m as readWorkspacePlanSync, o as init_io, p as readWorkspacePlan, r as findPlan, s as isPlanningComplete, u as readPlan, v as init_types$1, x as findSpecByIssue, y as subItemsOf } from "./io-BiM-7Zsx.js";
-import { C as restartCliproxy, S as readPidFile, T as stopCliproxy, b as isCliproxyInstalled, d as getCliproxyAuthDir, o as bridgeCodexAuthToCliproxy, v as init_cliproxy, w as startCliproxy, x as isCliproxyRunning, y as installCliproxy } from "./cliproxy-Dvsr4ZkW.js";
-import { $ as updateConversationForkFallbackReason, A as isAgentConversationName, B as removeFavorite, C as getConversationByTmuxSession, D as importLegacyConversation, F as markConversationEnded, H as setClearedToConvId, I as markConversationRunning, J as setForkRequest, M as listConversations, N as listFavoritedIds, O as incrementForkRetryCount, P as markConversationActive, S as getConversationByName, T as getStuckForks, U as setConversationClaudeSessionId, X as unarchiveConversation, Y as setImportedConversationLinks, Z as updateConversationCost, _ as canRefineTitle, b as getConversationByClaudeSessionId, et as updateConversationTitle, gt as getDiscoveredSessionBySessionId, h as archiveConversation, j as listArchivedConversationsWithEnrichment, k as init_conversations, q as setFavorite, tt as updateForkStatus, v as canReplaceTitle, w as getConversationLedgerCosts, x as getConversationById, y as createConversation, yt as init_discovered_sessions, z as recordConversationHandoff } from "./conversations-BUgGvqVL.js";
-import { n as isBackgroundFeatureEnabled, t as init_features } from "./features--fOza5g5.js";
-import { i as init_settings, r as getMemoryWorkerConcurrency, t as areMemoryObservationsEnabled } from "./settings-DP2OYLXL.js";
-import { i as updateMemoryHealth, n as extractWithProviderPolicy, r as init_health, t as init_providers$1 } from "./providers-d3pwXGVE.js";
-import { i as normalizeModelOverrideSync, n as init_launcher_generator, r as init_model_validation, t as generateLauncherScriptSync } from "./launcher-generator-5DJRiovn.js";
-import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-C2OrLYKL.js";
-import { a as globalContextFile$1, f as resolveProjectContextFile, h as workspaceContextFile, n as codexGlobalContextFile, o as init_layers, p as resolveWorkspaceContextFile, r as ensureProjectLayer } from "./layers-cZx7ibtV.js";
-import { l as init_codex, s as findRolloutPath } from "./codex-D_UBEOwL.js";
-import { f as init_config, m as loadConfigSync$1, s as getDashboardApiUrlSync } from "./config-CrduXs4a.js";
-import { C as setMergeTrainEnabled, S as setFlywheelRequireUatBeforeMerge, b as setFlywheelAutoPickupBacklog, c as isCloisterSpawnsPausedSync, d as isFlywheelAutoPickupBacklog, f as isFlywheelGloballyPaused$1, g as setCloisterSpawnsPausedSync, h as setBootReconciliationDecision, m as isMergeTrainEnabled, o as getSetting, p as isFlywheelRequireUatBeforeMerge, r as getBootReconciliationState, s as init_control_settings, u as isDeaconGloballyPausedSync, v as setDeaconGloballyPausedSync, w as setSetting } from "./control-settings-D_79A6gp.js";
-import { l as init_dag, r as compileGlob } from "./dag-DIji6O2b.js";
-import { a as loadCloisterConfigSync, i as loadCloisterConfig, o as saveCloisterConfigSync, r as init_config$1, s as shouldAutoStart } from "./config-G1TOMJZA.js";
-import { c as isStateMigrated, i as ensureStateWorktree, o as init_state_home, r as clearStateMigrationCache, s as inspectStateMigration } from "./state-home-DixkE-up.js";
-import { i as checkPrdGateSync, t as init_pan_dir } from "./pan-dir-Rw17YjT1.js";
-import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-DMurK4oM.js";
-import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-C9P2iPap.js";
-import { n as require_auth_errors, r as require_token_error, t as require_token_util } from "./token-util-BZaDAQ8S.js";
-import { _ as init_codex_conversation_parser, a as contextUsageFromParseResult, c as parseEntireConversation, d as init_pi_conversation_parser, f as isPiSessionFile, g as parseOhmypiConversationMessages, h as isOhmypiSessionFile, i as computeContextUsage, l as parseFromLastCompactBoundary, m as init_ohmypi_conversation_parser, n as gateSnapshotEmission, o as summarizeConversationActivity, p as parsePiConversationMessages, r as watchConversation, s as parseConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages } from "./conversation-service-DQybSPUK.js";
-import { c as countPendingAskUserQuestionsForAgent, h as detectAwaitingInputFromPaneSync, l as getAgentJsonlMtime, m as detectAwaitingInputForAgent, o as getRuntimeForAgent, p as scanPendingInputsPromise, s as computeAgentEnrichment } from "./stuck-remediation-BWkK_O7A.js";
-import { i as CostThresholdError, l as embed, s as parseRelativeTime } from "./scanner-C4NeC4FE.js";
-import { c as tailEventsSync, n as deduplicateEventsSync, o as readEventsSync } from "./events-CmERlnwn.js";
-import { n as recordBackgroundAiCost, t as init_cost } from "./cost-jJ2cgDcG.js";
-import { a as getByIssueId, i as parseFlywheelStatsWindow, n as derivePipelineRunStatsInputs, o as markFixed, r as computeFlywheelStats, s as upsert } from "./substrate-bug-weights-service-DXd0ID83.js";
-import { c as startUatTrainReconciler, d as openFlywheelRunReportForDashboard, f as pauseFlywheelRunForDashboard, g as runDashboardDbJob, h as startFlywheelRunForDashboard, l as stopUatTrainReconciler, m as resumeFlywheelRunForDashboard, p as readCurrentFlywheelStatusForDashboard, u as abortFlywheelRunForDashboard } from "./uat-train-BpLnp7Cx.js";
-import { C as writeLatestFlywheelStatus, b as resolveLiveFlywheelRunId, g as listFlywheelRuns, h as isFlywheelRunId, p as getFlywheelRunDetail, u as buildClassifyLookups, v as readCurrentLatestFlywheelStatus, x as subscribeLatestFlywheelStatus } from "./flywheel-1Wd8WDlh.js";
-import { C as getWorkspacePathForIssue, S as resolveIssueHeadlineCost, _ as getCostsForIssueSync, b as processPendingFeedbackDeliveries, d as resumeQueuedMerges, f as syncWalFromAllProjects, g as migrateAllSessionsSync, h as reclassifyUnknownCostEventsSync, l as internalEventsRouteLayer, m as reconcilePiTranscripts, p as reconcile$1, t as workspacesRouteLayer, u as eventsRouteLayer, v as rebuildCacheSync, x as getCachedRunningAgents, y as syncCacheSync } from "./workspaces-Dmlh1YXm.js";
-import { At as getSystemHealthSnapshot, Dt as getContainerHistory, Et as formatUptime, F as setAgentStatusChangedNotifier, G as isBootReconciliationCandidate, I as setAgentStoppedNotifier, K as listBootReconciliationCandidates, L as setMergeReadyNotifier, Mt as startSmeeProcessSync, O as loadConfig, Ot as getCurrentDockerStats, Tt as getResourceStacks, jt as isSmeeConfiguredSync, k as loadState, n as assessDeaconPatrolFreshness, q as startBootReconciliation, t as applyBootReconciliationDecision, x as getDeaconLogs, xt as paneShowsClaudeBootBlockingScreen } from "./deacon-1s7bM5zn.js";
-import { l as detectPlatform, u as init_platform } from "./workspace-manager-DsN52IMG.js";
-import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-Wlq5-qgS.js";
-import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-tVGiI5ee.js";
-import { t as init_specialists, z as getReviewerSessionName } from "./specialists-CYRwELzc.js";
-import { c as findPrdAtStatusSync, l as init_prd_locations } from "./archive-planning-BOnwJq8M.js";
-import { a as getShadowState, s as init_shadow_state } from "./shadow-state-a_ztFBJe.js";
-import { A as withConcurrencyLimit, D as createPromiseConcurrencyLimiter, E as verifyAppCanMerge, O as createSettledTtlPromiseCache, d as getPullRequestState, f as init_github_app, k as init_concurrency$1, l as getMergeBackendStatus, p as isGitHubAppConfigured } from "./github-app-B3yfECo8.js";
-import { n as init_issue_closed, t as clearIssueClosedCache } from "./issue-closed-Dfw3QDyZ.js";
-import { b as resolveSwarmPolicy } from "./deacon-swarm-DmA3rJ7k.js";
-import { a as init_boot_gates, i as formatBootGateState, o as resolveBootGates } from "./no-resume-mode-BnInAFKs.js";
-import { c as computeCohort, d as computeStats, f as computeWaves, g as selectNeedsPlanning, h as normalizeGate, l as computeEpicGroups, p as init_pickup, s as classifyIssue, u as computeLanes } from "./pickup-xi3KTLaJ.js";
-import { a as applyIssueObjectionLabel, c as applyIssueReleasedLabel, d as removeIssueBlocksMainLabel, f as removeIssueObjectionLabel, g as removeIssueVetoedLabel, h as removeIssueReleasedLabel, i as applyIssueBlocksMainLabel, l as applyIssueVetoedLabel, m as removeIssueReadyLabel, o as applyIssueParkedLabel, p as removeIssueParkedLabel, s as applyIssueReadyLabel, u as init_label_ops } from "./label-reconciler-CNf3Ylm3.js";
-import { n as parseSequenceMd, r as writeSequenceMd, t as init_sequence_io } from "./sequence-io-Ce-6grIY.js";
-import { a as init_pipeline_membership_gather, c as parseIssueIdFromTextSync, n as resolvePipelineMembership, o as listOpenPullRequestsSnapshot, r as gatherProjectLensSignals, s as init_resource_utils, t as init_pipeline_membership } from "./pipeline-membership-BtKMNY7v.js";
-import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-DIL5_U4c.js";
-import { i as resolveAutoSpawnOnFinalize, o as spawnPlanningSession } from "./spawn-planning-session-AiUSsBnH.js";
-import { d as killRemoteAgent, m as loadRemoteAgentState, o as getRemoteAgentOutput, r as checkRemoteSpendCap, s as init_remote_agents, v as sendToRemoteAgent, y as spawnRemoteAgent } from "./remote-agents-CZ2rc8I0.js";
-import { r as spawnInspectAgent } from "./inspect-agent-DKByUS_F.js";
-import { n as init_github_pr_lookup, r as lookupPullRequestNumberForBranch, t as githubPrLookupSource } from "./github-pr-lookup-DBP0YHMr.js";
-import { a as fetchIssuePullRequestDiff, c as getCachedIssuePrTabResponse, d as setCachedIssuePrTabResponse, i as fetchIssuePullRequestDetails, l as getIssuePrTabCacheGeneration, n as fetchIssueCheckRuns, o as init_pull_requests, r as fetchIssuePullRequest, s as bumpIssuePrTabCacheGeneration, u as init_pr_tab_cache } from "./pull-requests-CjjPj7v6.js";
-import { t as DOD_ROWS } from "./dod-BLphkhjs.js";
-import { t as enrichReviewStatus } from "./review-status-enrichment-DtDRGpst.js";
-import { i as runMemoryFtsTransaction, n as init_fts_db, r as runMemoryFtsStatement, t as closeMemoryFtsDatabases } from "./fts-db-6ponMie2.js";
-import { c as init_pending, l as maybeTriggerStatusRollup, o as readRecentObservations, r as init_rollup, u as writePendingTurn } from "./rollup-CLj_AK9f.js";
-import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-DjxP5g6Y.js";
-import { T as listGitOperationsSync, w as init_git_activity } from "./merge-agent-DnBsms_V.js";
-import { t as readVerificationArtifact } from "./verification-artifact-Dr_0g9nb.js";
-import { t as getAgentCommandSync } from "./settings-D9grjmaP.js";
-import { n as init_review_agent, r as isExtendedReviewEnabled } from "./review-agent-CqSqSHkU.js";
-import { r as isRemoteAvailable, t as createFlyProviderFromConfig } from "./remote-cnoeuDWn.js";
-import { n as init_claude_settings_overlay, t as detectProviderEnvConflicts } from "./claude-settings-overlay-DX-fMFpC.js";
-import { a as init_query_expansion, i as clearQueryExpansionCache, n as init_injection, o as buildMatchQuery, r as injectPromptTimeMemory, s as init_search } from "./injection-DtlT8Akv.js";
-import { _ as init_transcript_adapter, a as generateFallbackSummary, c as handoffPreconditionFallbackReason, d as prependFallbackFocus, f as requestHandoffFromAgent, g as getTranscriptAdapter, i as copySessionFromCompactBoundary, l as init_summary_fork, o as generateSummaryForFork, p as reserveSummaryForkSession, r as authorHandoffExternal, s as handoffFailureReason, u as logHandoffFallback } from "./summary-fork-f3DpgjXh.js";
-import { a as init_conversation_compaction, c as shouldInterceptManualCompact, n as compactConversationNative, o as isCompacting } from "./conversation-compaction-DiuZbIUB.js";
-import { a as init_render, d as validateTemplate, i as hasManagedRegion, l as init_harness, o as userContentOutsideRegion, t as init_context_layers, u as renderForHarness } from "./context-layers-Cg9ZgVfx.js";
-import { r as parseArtifactRef } from "./forge-DBbDpiYc.js";
-import { t as getMergeBlockersPayload } from "./merge-blockers-DhRgh76x.js";
-import { a as spawnSequencerAgent, i as init_sequencer_agent, n as clearFinishedSequencerRun, r as getSequencerRunStatus, t as SEQUENCER_AGENT_ID } from "./sequencer-agent-Bpz0yGmG.js";
-import "./supervisor-Ch8CDuoF.js";
-import { i as listTranscriptCheckpoints, r as getTranscriptCheckpoint$1 } from "./checkpoints-Vh-J15ge.js";
+import { i as init_linear_client, r as LinearClientOptionalLive, t as LinearClient } from "./linear-client-D4zqMnX7.js";
+import { i as init_github_client, r as GitHubClientOptionalLive, t as GitHubClient } from "./github-client--XVlDpwM.js";
+import { i as init_rally_client, r as RallyClientOptionalLive, t as RallyClient } from "./rally-client-B1EJhfV0.js";
+import { a as resolveTrackerTypeSync, i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-tnxxqROg.js";
+import { a as CacheService, i as startSharedIssueService, n as init_issue_service_singleton, o as init_cache_service, r as issue_service_singleton_exports, s as parseIntegerHeader, t as getSharedIssueService } from "./issue-service-singleton-B5ushCvE.js";
+import { i as ensureInternalTokenSync, o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-Bb4XeV2x.js";
+import { a as setPipelineHandlerSync, t as init_pipeline_notifier } from "./pipeline-notifier-D0ykk59O.js";
+import { c as init_review_status_sync, i as getMergeBlockerReconcileCandidates } from "./review-status-sync-BhSQ0d0l.js";
+import { n as init_review_status_source, t as classifyAdvancingSessionLifecycle } from "./review-status-source-CxuEjLGg.js";
+import { a as PAN_DIRNAME, d as WORKSPACE_RUNTIME_DIRNAME, f as asPanSpecDocument, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-hraoaQIp.js";
+import { C as transitionToMerging, _ as markFailed, c as isFlywheelGloballyPaused, d as listDuePendingAutoMerges, f as listProblemAutoMerges, g as markBlocked, n as getActionableAutoMerge, o as init_merge_sync, t as cancelPending, u as listActiveAutoMerges, v as markMerged, x as scheduleAutoMergeWithResult, y as requeueToPending } from "./merge-sync-DZ9dojJn.js";
+import { C as init_specs, D as writeSpecDocument, O as writeSpecForIssue, a as findWorkspaceDraftPlan, m as readWorkspacePlanSync, o as init_io, p as readWorkspacePlan, r as findPlan, s as isPlanningComplete, u as readPlan, v as init_types$1, x as findSpecByIssue, y as subItemsOf } from "./io-B3_AHDfr.js";
+import { C as restartCliproxy, S as readPidFile, T as stopCliproxy, b as isCliproxyInstalled, d as getCliproxyAuthDir, o as bridgeCodexAuthToCliproxy, v as init_cliproxy, w as startCliproxy, x as isCliproxyRunning, y as installCliproxy } from "./cliproxy-Bgb2XCqi.js";
+import { $ as updateConversationForkFallbackReason, A as isAgentConversationName, B as removeFavorite, C as getConversationByTmuxSession, D as importLegacyConversation, F as markConversationEnded, H as setClearedToConvId, I as markConversationRunning, J as setForkRequest, M as listConversations, N as listFavoritedIds, O as incrementForkRetryCount, P as markConversationActive, S as getConversationByName, T as getStuckForks, U as setConversationClaudeSessionId, X as unarchiveConversation, Y as setImportedConversationLinks, Z as updateConversationCost, _ as canRefineTitle, b as getConversationByClaudeSessionId, et as updateConversationTitle, gt as getDiscoveredSessionBySessionId, h as archiveConversation, j as listArchivedConversationsWithEnrichment, k as init_conversations, q as setFavorite, tt as updateForkStatus, v as canReplaceTitle, w as getConversationLedgerCosts, x as getConversationById, y as createConversation, yt as init_discovered_sessions, z as recordConversationHandoff } from "./conversations-DbOs1e9Q.js";
+import { n as isBackgroundFeatureEnabled, t as init_features } from "./features-Dhxz-wLc.js";
+import { i as init_settings, r as getMemoryWorkerConcurrency, t as areMemoryObservationsEnabled } from "./settings-BZ5m1UCl.js";
+import { i as updateMemoryHealth, n as extractWithProviderPolicy, r as init_health, t as init_providers$1 } from "./providers-DV7ec8l7.js";
+import { i as normalizeModelOverrideSync, n as init_launcher_generator, r as init_model_validation, t as generateLauncherScriptSync } from "./launcher-generator-CHVm7bGT.js";
+import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-H_5wHQZQ.js";
+import { a as globalContextFile$1, f as resolveProjectContextFile, h as workspaceContextFile, n as codexGlobalContextFile, o as init_layers, p as resolveWorkspaceContextFile, r as ensureProjectLayer } from "./layers-DzxSTGNA.js";
+import { l as init_codex, s as findRolloutPath } from "./codex-TmSi-yTv.js";
+import { n as init_harness_binary, r as prepareHarnessLaunch } from "./harness-binary-CVio2m-u.js";
+import { f as init_config, m as loadConfigSync$1, s as getDashboardApiUrlSync } from "./config-CCvjQf27.js";
+import { C as setMergeTrainEnabled, S as setFlywheelRequireUatBeforeMerge, b as setFlywheelAutoPickupBacklog, c as isCloisterSpawnsPausedSync, d as isFlywheelAutoPickupBacklog, f as isFlywheelGloballyPaused$1, g as setCloisterSpawnsPausedSync, h as setBootReconciliationDecision, m as isMergeTrainEnabled, o as getSetting, p as isFlywheelRequireUatBeforeMerge, r as getBootReconciliationState, s as init_control_settings, u as isDeaconGloballyPausedSync, v as setDeaconGloballyPausedSync, w as setSetting } from "./control-settings-aP1ANIlI.js";
+import { l as init_dag, r as compileGlob } from "./dag-CdOjJVDT.js";
+import { a as loadCloisterConfigSync, o as saveCloisterConfigSync, r as init_config$1, s as shouldAutoStart } from "./config-DjLOdbgT.js";
+import { c as isStateMigrated, i as ensureStateWorktree, o as init_state_home, r as clearStateMigrationCache, s as inspectStateMigration } from "./state-home-CIGjwNfJ.js";
+import { i as checkPrdGateSync, s as promoteWorkspacePrdDraft, t as init_pan_dir } from "./pan-dir-DeVUgwA7.js";
+import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-D8iNBcux.js";
+import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-CQ_fwUWF.js";
+import { n as require_auth_errors, r as require_token_error, t as require_token_util } from "./token-util-CTmczIfW.js";
+import { A as withConcurrencyLimit, D as createPromiseConcurrencyLimiter, E as verifyAppCanMerge, O as createSettledTtlPromiseCache, d as getPullRequestState, f as init_github_app, k as init_concurrency$1, l as getMergeBackendStatus, p as isGitHubAppConfigured } from "./github-app-CMBdIFBQ.js";
+import { C as getWorkspacePathForIssue, E as stopAgentOutputService, S as resolveIssueHeadlineCost, T as startAgentOutputService, _ as getCostsForIssueSync, b as processPendingFeedbackDeliveries, d as resumeQueuedMerges, f as syncWalFromAllProjects, g as migrateAllSessionsSync, h as reclassifyUnknownCostEventsSync, l as internalEventsRouteLayer, m as reconcilePiTranscripts, p as reconcile$1, t as workspacesRouteLayer, u as eventsRouteLayer, v as rebuildCacheSync, w as retainAgentOutputInterest, x as getCachedRunningAgents, y as syncCacheSync } from "./workspaces-hWvy9eKs.js";
+import { _ as init_codex_conversation_parser, a as contextUsageFromParseResult, c as parseEntireConversation, d as init_pi_conversation_parser, f as isPiSessionFile, g as parseOhmypiConversationMessages, h as isOhmypiSessionFile, i as computeContextUsage, l as parseFromLastCompactBoundary, m as init_ohmypi_conversation_parser, n as gateSnapshotEmission, o as summarizeConversationActivity, p as parsePiConversationMessages, r as watchConversation, s as parseConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages } from "./conversation-service-Du-MTNpJ.js";
+import { c as countPendingAskUserQuestionsForAgent, h as detectAwaitingInputFromPaneSync, l as getAgentJsonlMtime, m as detectAwaitingInputForAgent, o as getRuntimeForAgent, p as scanPendingInputsPromise, s as computeAgentEnrichment } from "./stuck-remediation-CzEov_fq.js";
+import { i as CostThresholdError, l as embed, s as parseRelativeTime } from "./scanner-D2743cp8.js";
+import { c as tailEventsSync, n as deduplicateEventsSync, o as readEventsSync } from "./events-CC1dgUpx.js";
+import { n as recordBackgroundAiCost, t as init_cost } from "./cost-CW4WSe72.js";
+import { a as getByIssueId, i as parseFlywheelStatsWindow, n as derivePipelineRunStatsInputs, o as markFixed, r as computeFlywheelStats, s as upsert } from "./substrate-bug-weights-service-BH66lhm7.js";
+import { c as startUatTrainReconciler, d as openFlywheelRunReportForDashboard, f as pauseFlywheelRunForDashboard, g as runDashboardDbJob, h as startFlywheelRunForDashboard, l as stopUatTrainReconciler, m as resumeFlywheelRunForDashboard, p as readCurrentFlywheelStatusForDashboard, u as abortFlywheelRunForDashboard } from "./uat-train-CuEn0t9M.js";
+import { C as writeLatestFlywheelStatus, b as resolveLiveFlywheelRunId, g as listFlywheelRuns, h as isFlywheelRunId, p as getFlywheelRunDetail, u as buildClassifyLookups, v as readCurrentLatestFlywheelStatus, x as subscribeLatestFlywheelStatus } from "./flywheel-DSSpWmqF.js";
+import { At as getContainerHistory, Ct as paneShowsClaudeBootBlockingScreen, F as setAgentStatusChangedNotifier, Ft as getSystemHealthEvidenceSnapshot, I as setAgentStoppedNotifier, J as startBootReconciliation, K as isBootReconciliationCandidate, L as setMergeReadyNotifier, Lt as isSmeeConfiguredSync, Mt as getAcceptedSystemHealthSnapshot, Nt as getDeployStaleness, O as loadConfig, Ot as getResourceStacks, Rt as startSmeeProcessSync, jt as getCurrentDockerStats, k as loadState, kt as formatUptime, n as assessDeaconPatrolFreshness, q as listBootReconciliationCandidates, t as applyBootReconciliationDecision, x as getDeaconLogs, zt as classifyAgentHealth } from "./deacon-pRnyD5w9.js";
+import { l as detectPlatform, u as init_platform } from "./workspace-manager-hLUv3ADC.js";
+import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-C9b6ccN1.js";
+import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-aQ1IxeI3.js";
+import { V as getReviewerSessionName, t as init_specialists } from "./specialists-DyFeedjn.js";
+import { c as findPrdAnywhereSync, l as init_prd_locations } from "./archive-planning-DYrYojxl.js";
+import { a as getShadowState, s as init_shadow_state } from "./shadow-state-Dh-HzF2J.js";
+import { n as init_issue_closed, t as clearIssueClosedCache } from "./issue-closed-zhdvQicO.js";
+import { b as resolveSwarmPolicy } from "./deacon-swarm-DftYRDo8.js";
+import { a as init_boot_gates, i as formatBootGateState, o as resolveBootGates } from "./no-resume-mode-Cx3K0hHi.js";
+import { _ as selectNeedsPlanning, c as classifyIssue, d as computeLanes, f as computeStats, g as normalizeGate, l as computeCohort, m as init_pickup, p as computeWaves, u as computeEpicGroups } from "./pickup-Dd0Znxxy.js";
+import { a as applyIssueObjectionLabel, c as applyIssueReleasedLabel, d as removeIssueBlocksMainLabel, f as removeIssueObjectionLabel, g as removeIssueVetoedLabel, h as removeIssueReleasedLabel, i as applyIssueBlocksMainLabel, l as applyIssueVetoedLabel, m as removeIssueReadyLabel, o as applyIssueParkedLabel, p as removeIssueParkedLabel, s as applyIssueReadyLabel, u as init_label_ops } from "./label-reconciler-DdWbHEBu.js";
+import { n as parseSequenceMd, r as writeSequenceMd, t as init_sequence_io } from "./sequence-io-Cg0zYj_E.js";
+import { c as init_resource_utils, i as gatherProjectLensSignals, l as parseIssueIdFromTextSync, n as init_pipeline_membership, o as init_pipeline_membership_gather, r as resolvePipelineMembership, s as listOpenPullRequestsSnapshot } from "./pipeline-membership-0HaEGDlH.js";
+import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-CskwzzhL.js";
+import { i as resolveAutoSpawnOnFinalize, o as spawnPlanningSession } from "./spawn-planning-session-DWAorh2B.js";
+import { d as killRemoteAgent, m as loadRemoteAgentState, o as getRemoteAgentOutput, r as checkRemoteSpendCap, s as init_remote_agents, v as sendToRemoteAgent, y as spawnRemoteAgent } from "./remote-agents-nmty1mLu.js";
+import { r as spawnInspectAgent } from "./inspect-agent-DJKLWcVT.js";
+import { n as init_github_pr_lookup, r as lookupPullRequestNumberForBranch, t as githubPrLookupSource } from "./github-pr-lookup-BRbDW-qk.js";
+import { a as fetchIssuePullRequestDiff, c as getCachedIssuePrTabResponse, d as setCachedIssuePrTabResponse, i as fetchIssuePullRequestDetails, l as getIssuePrTabCacheGeneration, n as fetchIssueCheckRuns, o as init_pull_requests, r as fetchIssuePullRequest, s as bumpIssuePrTabCacheGeneration, u as init_pr_tab_cache } from "./pull-requests-CXIhdCYD.js";
+import { t as DOD_ROWS } from "./dod-BrSfUHm0.js";
+import { t as enrichReviewStatus } from "./review-status-enrichment-tbOn_A_u.js";
+import { i as runMemoryFtsTransaction, n as init_fts_db, r as runMemoryFtsStatement, t as closeMemoryFtsDatabases } from "./fts-db-CKgg0VKg.js";
+import { c as init_pending, l as maybeTriggerStatusRollup, o as readRecentObservations, r as init_rollup, u as writePendingTurn } from "./rollup-WA0VD-Rr.js";
+import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-BDtLOIlO.js";
+import { T as listGitOperationsSync, w as init_git_activity } from "./merge-agent-XrB80vfT.js";
+import { t as readVerificationArtifact } from "./verification-artifact-BcnIbigL.js";
+import { t as getAgentCommandSync } from "./settings-ylxwqwQG.js";
+import { n as init_review_agent, r as isExtendedReviewEnabled } from "./review-agent-sKkE1FEL.js";
+import { r as isRemoteAvailable, t as createFlyProviderFromConfig } from "./remote-Br-ZWVIP.js";
+import { n as init_claude_settings_overlay, t as detectProviderEnvConflicts } from "./claude-settings-overlay-CbSz0Dvb.js";
+import { a as init_query_expansion, i as clearQueryExpansionCache, n as init_injection, o as buildMatchQuery, r as injectPromptTimeMemory, s as init_search } from "./injection-DZ0PfYa4.js";
+import { _ as init_transcript_adapter, a as generateFallbackSummary, c as handoffPreconditionFallbackReason, d as prependFallbackFocus, f as requestHandoffFromAgent, g as getTranscriptAdapter, i as copySessionFromCompactBoundary, l as init_summary_fork, o as generateSummaryForFork, p as reserveSummaryForkSession, r as authorHandoffExternal, s as handoffFailureReason, u as logHandoffFallback } from "./summary-fork-DHhJIsAL.js";
+import { a as init_conversation_compaction, c as shouldInterceptManualCompact, n as compactConversationNative, o as isCompacting } from "./conversation-compaction-CNbTLB86.js";
+import { a as init_render, d as validateTemplate, i as hasManagedRegion, l as init_harness, o as userContentOutsideRegion, t as init_context_layers, u as renderForHarness } from "./context-layers-ZYFcWiyc.js";
+import { r as parseArtifactRef } from "./forge-Ch9gCFod.js";
+import { t as getMergeBlockersPayload } from "./merge-blockers-BsFjGrQ8.js";
+import { a as spawnSequencerAgent, i as init_sequencer_agent, n as clearFinishedSequencerRun, r as getSequencerRunStatus, t as SEQUENCER_AGENT_ID } from "./sequencer-agent-BGY8gjg-.js";
+import "./supervisor-BO-Zk_h-.js";
+import { i as listTranscriptCheckpoints, r as getTranscriptCheckpoint$1 } from "./checkpoints-C-AXLfYT.js";
 import { createRequire } from "node:module";
 import * as sp from "node:path";
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
@@ -109,7 +112,7 @@ import { Cause, Context, Data, Duration, Effect, Exit, Fiber, FileSystem, Layer,
 import { createReadStream, createWriteStream, existsSync, fstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 import { basename as basename$1, dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
 import { homedir } from "os";
-import { freemem as freemem$1, homedir as homedir$1, loadavg as loadavg$1, totalmem as totalmem$1, type } from "node:os";
+import { homedir as homedir$1, type } from "node:os";
 import { constants, createReadStream as createReadStream$1, existsSync as existsSync$1, mkdirSync as mkdirSync$1, promises as promises$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, readlinkSync, renameSync as renameSync$1, rmSync as rmSync$1, stat, statSync as statSync$1, symlinkSync as symlinkSync$1, unwatchFile, watch, watchFile } from "node:fs";
 import { FetchHttpClient, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { EventEmitter } from "node:events";
@@ -355,6 +358,24 @@ const ServerConfigLayer = Layer.effect(ServerConfig, Effect.sync(() => {
 	};
 }));
 //#endregion
+//#region dashboard-listening.ts
+let resolveListening;
+let listening = false;
+let listeningPromise = createListeningPromise();
+function createListeningPromise() {
+	return new Promise((resolve) => {
+		resolveListening = resolve;
+	});
+}
+function markDashboardListening() {
+	if (listening) return;
+	listening = true;
+	resolveListening();
+}
+function whenDashboardListening() {
+	return listeningPromise;
+}
+//#endregion
 //#region services/terminal-service.ts
 init_activity_logger();
 init_paths$1();
@@ -688,7 +709,7 @@ const AgentSpawnerLive = Layer.effect(AgentSpawner, Effect.sync(() => ({
 			if (!existsSync$1(workspacePath)) throw new WorkspaceNotFound({ id: issueId });
 			const plan = readWorkspacePlanSync(workspacePath);
 			if (!plan || plan.plan.items.length === 0) throw new PlanEmpty({ id: issueId });
-			const { getAgentState, spawnAgent, normalizeAgentId } = await import("./agents-Czz6R57Z.js");
+			const { getAgentState, spawnAgent, normalizeAgentId } = await import("./agents-FlIgQ3ql.js");
 			const normalizedId = normalizeAgentId(issueId);
 			if ((await Effect.runPromise(getAgentState(normalizedId)))?.status === "running") throw new AgentAlreadyRunning({ id: issueId });
 			return {
@@ -719,7 +740,7 @@ const AgentSpawnerLive = Layer.effect(AgentSpawner, Effect.sync(() => ({
 			const { workspacePath, projectPath, issue } = opts;
 			if (!existsSync$1(workspacePath)) throw new WorkspaceNotFound({ id: issueId });
 			const sessionName = opts.sessionName ?? `planning-${issueId.toLowerCase()}`;
-			const { spawnPlanningSession } = await import("./spawn-planning-session-LFtK2QCE.js");
+			const { spawnPlanningSession } = await import("./spawn-planning-session-KC_UduxD.js");
 			const result = await spawnPlanningSession({
 				issue: {
 					id: issue.id,
@@ -752,14 +773,14 @@ const AgentSpawnerLive = Layer.effect(AgentSpawner, Effect.sync(() => ({
 	}),
 	kill: (agentId) => Effect.tryPromise({
 		try: async () => {
-			const { stopAgent } = await import("./agents-Czz6R57Z.js");
+			const { stopAgent } = await import("./agents-FlIgQ3ql.js");
 			await Effect.runPromise(stopAgent(agentId));
 		},
 		catch: () => void 0
 	}).pipe(Effect.ignore),
 	message: (agentId, msg) => Effect.tryPromise({
 		try: async () => {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-FlIgQ3ql.js");
 			await messageAgent(agentId, msg);
 		},
 		catch: (err) => new AgentStartError({
@@ -770,8 +791,8 @@ const AgentSpawnerLive = Layer.effect(AgentSpawner, Effect.sync(() => ({
 	}),
 	deepWipe: (issueId, opts) => Effect.tryPromise({
 		try: async () => {
-			const { deepWipe } = await import("./workflows-C5c-RPsY.js");
-			const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+			const { deepWipe } = await import("./workflows-D90rMOya.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-9SkRpES9.js");
 			const project = resolveProjectFromIssueSync(issueId);
 			const projectPath = project?.projectPath ?? process.cwd();
 			await Effect.runPromise(deepWipe({
@@ -830,8 +851,8 @@ const WorkspaceServiceLive = Layer.effect(WorkspaceService, Effect.sync(() => {
 				const { workspacePath, branch } = getWorkspacePath(issueId);
 				const issueLower = issueId.toLowerCase();
 				if (existsSync$1(workspacePath)) return workspacePath;
-				const { createWorkspace } = await import("./workspace-manager-CcujONCR.js");
-				const { loadProjectsConfigSync } = await import("./projects-IRHJIPYC.js");
+				const { createWorkspace } = await import("./workspace-manager-ZTdJAy9M.js");
+				const { loadProjectsConfigSync } = await import("./projects-9SkRpES9.js");
 				const { projects } = loadProjectsConfigSync();
 				const project = resolveProjectFromIssueSync(issueId);
 				if (!project) throw new WorkspaceCreateError({
@@ -866,7 +887,7 @@ const WorkspaceServiceLive = Layer.effect(WorkspaceService, Effect.sync(() => {
 				const { workspacePath } = getWorkspacePath(issueId);
 				const issueLower = issueId.toLowerCase();
 				if (!existsSync$1(workspacePath)) throw new WorkspaceNotFound({ id: issueId });
-				const { removeWorkspace } = await import("./workspace-manager-CcujONCR.js");
+				const { removeWorkspace } = await import("./workspace-manager-ZTdJAy9M.js");
 				const project = resolveProjectFromIssueSync(issueId);
 				if (!project) throw new WorkspaceCreateError({
 					id: issueId,
@@ -897,7 +918,7 @@ const WorkspaceServiceLive = Layer.effect(WorkspaceService, Effect.sync(() => {
 			try: async () => {
 				const { workspacePath } = getWorkspacePath(issueId);
 				const issueLower = issueId.toLowerCase();
-				const { stopWorkspaceDocker } = await import("./workspace-manager-CcujONCR.js");
+				const { stopWorkspaceDocker } = await import("./workspace-manager-ZTdJAy9M.js");
 				await Effect.runPromise(stopWorkspaceDocker(workspacePath, issueLower));
 			},
 			catch: () => void 0
@@ -966,7 +987,7 @@ const WorkspaceServiceLive = Layer.effect(WorkspaceService, Effect.sync(() => {
 					join(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml")
 				];
 				if (!composePaths.find((p) => existsSync$1(p))) {
-					const { ensureDevcontainerSync } = await import("./ensure-devcontainer-BA3bICoY.js");
+					const { ensureDevcontainerSync } = await import("./ensure-devcontainer-DRqaAkBR.js");
 					const ensure = ensureDevcontainerSync({
 						workspacePath,
 						issueId
@@ -5451,6 +5472,7 @@ function setupTerminalWebSocket(server) {
 //#endregion
 //#region ../../../node_modules/.bun/@ai-sdk+provider@3.0.10/node_modules/@ai-sdk/provider/dist/index.mjs
 init_briefing_freshness();
+init_agent_runtime_mirror();
 init_behavior();
 init_discovered_sessions();
 init_conversations();
@@ -5460,11 +5482,13 @@ init_openai_auth();
 init_claude_permissions();
 init_claude_auth();
 init_layers();
+init_harness_binary();
 init_codex();
 init_launcher_generator();
 init_transcript_landing();
 init_operator_interventions();
 init_agents$1();
+init_runtime_census();
 var marker$2 = "vercel.ai.error";
 var symbol$3 = Symbol.for(marker$2);
 var _a$5, _b$2;
@@ -15944,7 +15968,7 @@ var require_get_vercel_oidc_token = /* @__PURE__ */ __commonJSMin(((exports, mod
 			err = error;
 		}
 		try {
-			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await import("./token-util-Cg-QnowA.js").then((m) => /* @__PURE__ */ __toESM(m.default)), await import("./token-LUrbM9sU.js").then((m) => /* @__PURE__ */ __toESM(m.default))]);
+			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await import("./token-util-DrHg8abn.js").then((m) => /* @__PURE__ */ __toESM(m.default)), await import("./token-CsOhvw42.js").then((m) => /* @__PURE__ */ __toESM(m.default))]);
 			if (!token || isExpired(getTokenPayload(token), options?.expirationBufferMs)) {
 				await refreshToken(options);
 				token = getVercelOidcTokenSync();
@@ -27778,7 +27802,7 @@ function randomId() {
 function randomNonce() {
 	return Math.floor(Math.random() * 2147483647);
 }
-function finiteNumber(value, fallback) {
+function finiteNumber$1(value, fallback) {
 	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 function normalizeExcalidrawElement(element) {
@@ -27786,12 +27810,12 @@ function normalizeExcalidrawElement(element) {
 		...element,
 		id: typeof element.id === "string" && element.id ? element.id : randomId(),
 		type: typeof element.type === "string" && element.type ? element.type : "rectangle",
-		x: finiteNumber(element.x, 0),
-		y: finiteNumber(element.y, 0),
-		width: Math.max(1, finiteNumber(element.width, 100)),
-		height: Math.max(1, finiteNumber(element.height, 100)),
-		version: Math.max(1, Math.trunc(finiteNumber(element.version, 1))),
-		versionNonce: Math.trunc(finiteNumber(element.versionNonce, randomNonce())),
+		x: finiteNumber$1(element.x, 0),
+		y: finiteNumber$1(element.y, 0),
+		width: Math.max(1, finiteNumber$1(element.width, 100)),
+		height: Math.max(1, finiteNumber$1(element.height, 100)),
+		version: Math.max(1, Math.trunc(finiteNumber$1(element.version, 1))),
+		versionNonce: Math.trunc(finiteNumber$1(element.versionNonce, randomNonce())),
 		isDeleted: element.isDeleted === true
 	};
 	if (Math.abs(normalized.x) > VISIBLE_CANVAS_LIMIT || Math.abs(normalized.y) > VISIBLE_CANVAS_LIMIT) console.warn(`Excalidraw element ${normalized.id} has coordinates outside visible canvas range`);
@@ -28261,7 +28285,7 @@ var GoogleCloudTranscription = class {
 	}
 	async start(apiKey, model) {
 		try {
-			const { SpeechClient } = await import("./src-OLoJhUiJ.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)).then((module) => module.v1p1beta1 ?? module.v1);
+			const { SpeechClient } = await import("./src-CG9mCkP6.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)).then((module) => module.v1p1beta1 ?? module.v1);
 			if (this.closed) return;
 			const stream = new SpeechClient({ apiKey }).streamingRecognize({
 				config: {
@@ -28926,6 +28950,21 @@ function setupAutoPresoWebSocket(server) {
 	});
 }
 //#endregion
+//#region services/agent-output-stream.ts
+function shouldBroadcastDashboardEvent(event) {
+	return event.type !== "agent.output_received";
+}
+/** Dedicated, scoped stream for one agent's ephemeral output. */
+function streamAgentOutput(eventStore, agentId) {
+	return Stream.unwrap(Effect.acquireRelease(Effect.sync(() => retainAgentOutputInterest(agentId)), (release) => Effect.sync(release)).pipe(Effect.map(() => eventStore.streamEvents.pipe(Stream.filter((event) => event.type === "agent.output_received" && event.payload["agentId"] === agentId), Stream.flatMap((event) => {
+		const payload = event.payload;
+		return Stream.fromIterable(payload.lines.map((line) => ({
+			agentId: payload.agentId,
+			line
+		})));
+	})))));
+}
+//#endregion
 //#region services/read-workspace-file.ts
 init_codex_conversation_parser();
 init_ohmypi_conversation_parser();
@@ -28972,7 +29011,7 @@ const LANGUAGE_BY_EXTENSION = {
 function isInsidePath(parent, child) {
 	return child === parent || child.startsWith(`${parent}${sep}`);
 }
-function splitLines$1(text) {
+function splitLines(text) {
 	if (text.length === 0) return [];
 	const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 	return normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
@@ -28986,7 +29025,7 @@ function validateIntegerAtLeast(value, name, min) {
 	return value;
 }
 function selectRequestedLines(text, line, contextLines) {
-	const lines = splitLines$1(text);
+	const lines = splitLines(text);
 	const totalLines = lines.length;
 	if (!line) return {
 		text: contextLines === void 0 ? text : lines.slice(0, contextLines).join("\n"),
@@ -29273,7 +29312,6 @@ function normalizeSessionsFeedFilter(input) {
 */
 init_src();
 init_paths();
-init_tmux();
 init_projects();
 function storedToDomainEvent(stored) {
 	return {
@@ -29286,7 +29324,8 @@ function storedToDomainEvent(stored) {
 const isKnownDomainEvent = Schema.is(DomainEvent);
 function passesDomainEventSchema(event) {
 	if (isKnownDomainEvent(event)) return true;
-	console.error(`[ws-rpc] dropping domain event that fails DomainEvent schema validation — add it to the contracts union: type=${event.type} seq=${event.sequence}`);
+	const candidate = event;
+	console.error(`[ws-rpc] dropping domain event that fails DomainEvent schema validation — add it to the contracts union: type=${String(candidate.type)} seq=${String(candidate.sequence)}`);
 	return false;
 }
 function createSystemHeartbeatEvent() {
@@ -29657,8 +29696,9 @@ function startSharedPresencePoller() {
 	if (sharedPresencePoller.interval) return;
 	const tick = async () => {
 		try {
-			const sessions = await Effect.runPromise(listSessionNames());
-			const current = new Set(sessions.filter((s) => s.trim()));
+			const census = await getRuntimeCensus();
+			if (!census.available) return;
+			const current = new Set(census.sessionNames);
 			for (const s of sharedPresencePoller.knownSessions) if (!current.has(s)) {
 				const issueId = extractIssueIdFromSession(s);
 				if (issueId) {
@@ -29722,7 +29762,7 @@ const PanRpcLayer = PanRpcGroup.toLayer(Effect.gen(function* () {
 		[WS_METHODS.subscribeDomainEvents]: (_input) => {
 			console.log("[ws-rpc] subscribeDomainEvents invoked");
 			const heartbeats = Stream.tick("15 seconds").pipe(Stream.map(createSystemHeartbeatEvent));
-			return eventStore.streamEvents.pipe(Stream.map(storedToDomainEvent), Stream.filter(passesDomainEventSchema), Stream.merge(heartbeats));
+			return eventStore.streamEvents.pipe(Stream.filter(shouldBroadcastDashboardEvent), Stream.map(storedToDomainEvent), Stream.filter(passesDomainEventSchema), Stream.merge(heartbeats));
 		},
 		[WS_METHODS.subscribeFlywheelStatus]: (_input) => Stream.callback((queue) => Effect.acquireRelease(Effect.promise(async () => {
 			const latest = await readCurrentLatestFlywheelStatus({ activeRunId: await runDashboardDbJob("getSetting", "flywheel.active_run_id") });
@@ -29733,16 +29773,10 @@ const PanRpcLayer = PanRpcGroup.toLayer(Effect.gen(function* () {
 		}), (unsubscribe) => Effect.sync(() => unsubscribe()))),
 		[WS_METHODS.subscribeIssueEvents]: (input) => {
 			console.log(`[ws-rpc] subscribeIssueEvents invoked issueId=${input.issueId}`);
-			return eventStore.streamEvents.pipe(Stream.map(storedToDomainEvent), Stream.filter(passesDomainEventSchema), Stream.mapEffect((event) => getCachedAgentIssueLookup(readModel).pipe(Effect.map((lookup) => filterDomainEventForIssue(event, input.issueId, lookup)))), Stream.filter((event) => event !== null));
+			return eventStore.streamEvents.pipe(Stream.filter(shouldBroadcastDashboardEvent), Stream.map(storedToDomainEvent), Stream.filter(passesDomainEventSchema), Stream.mapEffect((event) => getCachedAgentIssueLookup(readModel).pipe(Effect.map((lookup) => filterDomainEventForIssue(event, input.issueId, lookup)))), Stream.filter((event) => event !== null));
 		},
 		[WS_METHODS.subscribeTerminal]: (input) => terminalService.streamSession(input.sessionName, input.cols, input.rows),
-		[WS_METHODS.subscribeAgentOutput]: (input) => eventStore.streamEvents.pipe(Stream.filter((e) => e.type === "agent.output_received" && e.payload["agentId"] === input.agentId), Stream.flatMap((e) => {
-			const payload = e.payload;
-			return Stream.fromIterable(payload.lines.map((line) => ({
-				agentId: payload.agentId,
-				line
-			})));
-		})),
+		[WS_METHODS.subscribeAgentOutput]: (input) => streamAgentOutput(eventStore, input.agentId),
 		[WS_METHODS.getSnapshot]: (_input) => Effect.gen(function* () {
 			const t0 = Date.now();
 			console.log("[ws-rpc] getSnapshot invoked");
@@ -30039,7 +30073,11 @@ const websocketRpcRouteLayer = Layer.unwrap(Effect.gen(function* () {
 	}));
 }));
 //#endregion
-//#region ../../lib/vbrief/quality-lint.ts
+//#region ../../lib/xbrief/quality-lint.ts
+init_internal_token();
+init_pipeline_notifier();
+init_review_status_sync();
+init_review_status();
 init_state_home();
 init_pan_dir();
 init_in_flight_guard();
@@ -30048,7 +30086,7 @@ init_dag();
 init_swarm_readiness();
 var PlanQualityLintError = class extends Error {
 	constructor(issues) {
-		super(`vBRIEF quality lint failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}`);
+		super(`xBRIEF quality lint failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}`);
 		this.issues = issues;
 		this.name = "PlanQualityLintError";
 	}
@@ -30411,28 +30449,80 @@ function assertPlanQuality(doc, options = {}) {
 	return issues;
 }
 //#endregion
+//#region services/resource-discovery-shared.ts
+init_conversations();
+init_runtime_census();
+const execFileAsync$18 = promisify(execFile);
+async function loadTrackerIssues() {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const { getSharedIssueService } = await import("./issue-service-singleton-DabvBWUp.js");
+		const issues = (await getSharedIssueService()).getIssues();
+		for (const issue of issues) if (issue.identifier) map.set(issue.identifier.toUpperCase(), issue);
+	} catch {}
+	return map;
+}
+async function loadDockerContainers() {
+	try {
+		const { stdout } = await execFileAsync$18("docker", [
+			"ps",
+			"--format",
+			"{{.Names}}"
+		], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+async function loadActiveRemoteAgentStates() {
+	try {
+		const { listActiveRemoteAgentStates } = await import("./remote-agents-CRCg1L4H.js");
+		return listActiveRemoteAgentStates();
+	} catch {
+		return [];
+	}
+}
+async function captureSharedResourceSignals() {
+	const [trackerIssues, runtimeCensus, dockerContainers, remoteAgentStates] = await Promise.all([
+		loadTrackerIssues(),
+		getRuntimeCensus(),
+		loadDockerContainers(),
+		loadActiveRemoteAgentStates()
+	]);
+	const tmuxSessions = [...runtimeCensus.sessionNames];
+	let conversations = [];
+	try {
+		conversations = listConversations();
+	} catch {}
+	return {
+		trackerIssues,
+		tmuxSessions,
+		dockerContainers,
+		conversations,
+		remoteAgentStates
+	};
+}
+//#endregion
 //#region review-status.ts
 init_concurrency$1();
 init_github_app();
 init_resource_utils();
 init_pipeline_membership_gather();
-init_review_status();
+init_pipeline_membership();
 //#endregion
 //#region services/pipeline-membership.ts
-init_internal_token();
-init_pipeline_notifier();
-init_review_status_sync();
-init_pipeline_membership();
 const PIPELINE_MEMBERSHIP_TTL_MS = 3e4;
 function createPipelineMembershipService(deps = {
 	gather: gatherProjectLensSignals,
 	now: Date.now
 }) {
 	const cachedGather = createSettledTtlPromiseCache(PIPELINE_MEMBERSHIP_TTL_MS, deps.now);
-	return async (project) => {
-		if (!project.github_repo) return [];
-		return cachedGather(project.path, () => deps.gather(project).then((signals) => signals.map(resolvePipelineMembership)));
-	};
+	const service = async (project) => cachedGather(project.path, () => deps.gather(project).then((signals) => signals.map(resolvePipelineMembership)));
+	service.invalidate = (projectPath) => cachedGather.invalidate(projectPath);
+	return service;
 }
 const getProjectPipelineMembership = createPipelineMembershipService();
 const membershipSnapshots = /* @__PURE__ */ new Map();
@@ -30447,22 +30537,10 @@ function refreshMembershipSnapshot(project, snapshot, getMembership, now) {
 	});
 	return snapshot.refresh;
 }
-/** Return the latest successful snapshot immediately and refresh stale/missing projects in the background. */
-function getPipelineMembershipSnapshotsForProjects(projects, getMembership = getProjectPipelineMembership, now = Date.now) {
+/** Read the latest successful snapshots without scheduling tracker or git work. */
+function readPipelineMembershipSnapshotsForProjects(projects) {
 	return projects.map((project) => {
-		if (!project.github_repo) return {
-			project,
-			error: /* @__PURE__ */ new Error("Pipeline membership unavailable: missing github_repo")
-		};
 		const snapshot = membershipSnapshots.get(project.path);
-		if (!snapshot?.refresh && (!snapshot || now() - snapshot.refreshedAt >= 3e5)) {
-			const current = snapshot ?? {
-				value: [],
-				refreshedAt: 0
-			};
-			membershipSnapshots.set(project.path, current);
-			refreshMembershipSnapshot(project, current, getMembership, now);
-		}
 		return snapshot?.refreshedAt ? {
 			project,
 			memberships: snapshot.value
@@ -30472,34 +30550,26 @@ function getPipelineMembershipSnapshotsForProjects(projects, getMembership = get
 		};
 	});
 }
-/** Await only the first snapshot; later resource refreshes consume stale data while revalidating. */
-async function getPipelineMembershipSnapshotsForResourceDiscovery(projects, getMembership = getProjectPipelineMembership, now = Date.now) {
-	return Promise.all(projects.map(async (project) => {
-		if (!project.github_repo) return {
-			project,
-			error: /* @__PURE__ */ new Error("Pipeline membership unavailable: missing github_repo")
-		};
-		const existing = membershipSnapshots.get(project.path);
-		if (existing?.refreshedAt) {
-			if (now() - existing.refreshedAt >= 3e5) refreshMembershipSnapshot(project, existing, getMembership, now);
-			return {
-				project,
-				memberships: existing.value
-			};
-		}
-		const snapshot = existing ?? {
+/**
+* PAN-2893 — event-driven refresh. Invalidate the per-project TTL cache and
+* force a snapshot re-gather NOW for the given projects, so agent lifecycle
+* changes reach membership consumers without waiting out the 5-minute TTL.
+* Refresh failures keep the last good snapshot (same policy as TTL refreshes).
+*/
+async function refreshMembershipSnapshotsForProjects(projects, getMembership = getProjectPipelineMembership, now = Date.now) {
+	await Promise.all(projects.map(async (project) => {
+		getMembership.invalidate(project.path);
+		const snapshot = membershipSnapshots.get(project.path) ?? {
 			value: [],
 			refreshedAt: 0
 		};
 		membershipSnapshots.set(project.path, snapshot);
+		const inFlight = snapshot.refresh;
+		if (inFlight) {
+			await inFlight;
+			getMembership.invalidate(project.path);
+		}
 		await refreshMembershipSnapshot(project, snapshot, getMembership, now);
-		return snapshot.refreshedAt ? {
-			project,
-			memberships: snapshot.value
-		} : {
-			project,
-			error: /* @__PURE__ */ new Error("Pipeline membership snapshot failed to load")
-		};
 	}));
 }
 function summarizePipelineMembership(membership) {
@@ -30520,16 +30590,15 @@ function unavailablePipelineMembership() {
 }
 //#endregion
 //#region services/resource-discovery.ts
-init_conversations();
+init_src();
 init_projects();
+init_pipeline_membership();
 init_pipeline_membership_gather();
-init_tmux();
-const execFileAsync$18 = promisify(execFile);
-const RESOURCE_DISCOVERY_TTL_MS = 3e4;
+const execFileAsync$17 = promisify(execFile);
 const RECENT_ACTIVITY_WINDOW_MS = 5e3;
+const projectResourceSnapshots = /* @__PURE__ */ new Map();
 let cachedResourceIssues = null;
 let cachedDetailedResourceIssues = null;
-let resourceIssuesRefreshPromise = null;
 function projectPrefixes(project) {
 	const prefixes = /* @__PURE__ */ new Set();
 	if (project.config.issue_prefix) prefixes.add(project.config.issue_prefix.toUpperCase());
@@ -30569,7 +30638,7 @@ function summarizeResourceDetails(details) {
 			state: pr.state,
 			isDraft: pr.isDraft
 		})),
-		hasVbrief: details.vbriefPath !== null,
+		hasXbrief: details.xbriefPath !== null,
 		hasTasks: details.tasksPath !== null,
 		dockerContainerCount: details.dockerContainers.length,
 		actualBranch: details.actualBranch,
@@ -30636,46 +30705,6 @@ const DISCOVERABLE_SESSION_PREFIXES = [
 function isDiscoverableAgentSession(sessionName) {
 	return DISCOVERABLE_SESSION_PREFIXES.some((prefix) => sessionName.startsWith(prefix));
 }
-async function loadTrackerIssues() {
-	const map = /* @__PURE__ */ new Map();
-	try {
-		const { getSharedIssueService } = await import("./issue-service-singleton-D5EB5eYr.js");
-		const issues = (await getSharedIssueService()).getIssues();
-		for (const issue of issues) if (issue.identifier) map.set(issue.identifier.toUpperCase(), issue);
-	} catch {
-		return map;
-	}
-	return map;
-}
-async function loadTmuxSessions() {
-	try {
-		return (await Effect.runPromise(listSessionNames())).map((name) => name.trim()).filter(Boolean);
-	} catch {
-		return [];
-	}
-}
-function loadConversations() {
-	try {
-		return listConversations();
-	} catch {
-		return [];
-	}
-}
-async function loadDockerContainers() {
-	try {
-		const { stdout } = await execFileAsync$18("docker", [
-			"ps",
-			"--format",
-			"{{.Names}}"
-		], {
-			encoding: "utf-8",
-			timeout: 5e3
-		});
-		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-	} catch {
-		return [];
-	}
-}
 async function loadOpenPullRequests(projects) {
 	const pullRequests = /* @__PURE__ */ new Map();
 	await Promise.all(projects.map(async (project) => {
@@ -30706,80 +30735,31 @@ async function loadOpenPullRequests(projects) {
 	for (const [issueId, prs] of pullRequests) pullRequests.set(issueId, sortPullRequests(prs));
 	return pullRequests;
 }
-async function loadProjectBranches(projectPath) {
-	try {
-		const [localFeature, remoteFeature, localBypass, remoteBypass] = await Promise.all([
-			execFileAsync$18("git", [
-				"for-each-ref",
-				"refs/heads/feature/*",
-				"--format=%(refname:short)"
-			], {
-				cwd: projectPath,
-				encoding: "utf-8",
-				timeout: 1e4
-			}).catch(() => ({ stdout: "" })),
-			execFileAsync$18("git", [
-				"for-each-ref",
-				"refs/remotes/origin/feature/*",
-				"--format=%(refname:short)"
-			], {
-				cwd: projectPath,
-				encoding: "utf-8",
-				timeout: 1e4
-			}).catch(() => ({ stdout: "" })),
-			execFileAsync$18("git", [
-				"for-each-ref",
-				"refs/heads/bypass/*",
-				"--format=%(refname:short)"
-			], {
-				cwd: projectPath,
-				encoding: "utf-8",
-				timeout: 1e4
-			}).catch(() => ({ stdout: "" })),
-			execFileAsync$18("git", [
-				"for-each-ref",
-				"refs/remotes/origin/bypass/*",
-				"--format=%(refname:short)"
-			], {
-				cwd: projectPath,
-				encoding: "utf-8",
-				timeout: 1e4
-			}).catch(() => ({ stdout: "" }))
-		]);
-		return {
-			local: [...localFeature.stdout.split("\n").map((line) => line.trim()).filter(Boolean), ...localBypass.stdout.split("\n").map((line) => line.trim()).filter(Boolean)],
-			remote: [...remoteFeature.stdout.split("\n").map((line) => line.trim()).filter(Boolean), ...remoteBypass.stdout.split("\n").map((line) => line.trim()).filter(Boolean)]
-		};
-	} catch {
-		return {
-			local: [],
-			remote: []
-		};
-	}
-}
-async function loadBranchesAheadOfMain(projectPath) {
-	const ahead = /* @__PURE__ */ new Set();
-	const run = async (patterns) => {
-		if (patterns.length === 0) return;
-		try {
-			const { stdout } = await execFileAsync$18("git", [
-				"for-each-ref",
-				"--format=%(refname:short)",
-				...patterns,
-				"--no-merged=main"
-			], {
-				cwd: projectPath,
-				encoding: "utf-8",
-				timeout: 1e4
-			});
-			for (const line of stdout.split("\n")) {
-				const branch = line.trim();
-				if (branch) ahead.add(branch);
-			}
-		} catch {}
+const PROJECT_BRANCH_PATTERNS = [
+	"refs/heads/feature/*",
+	"refs/remotes/origin/feature/*",
+	"refs/heads/bypass/*",
+	"refs/remotes/origin/bypass/*"
+];
+async function loadProjectBranchSnapshot(projectPath) {
+	const run = (extraArgs = []) => execFileAsync$17("git", [
+		"for-each-ref",
+		"--format=%(refname:short)",
+		...extraArgs,
+		...PROJECT_BRANCH_PATTERNS
+	], {
+		cwd: projectPath,
+		encoding: "utf-8",
+		timeout: 1e4
+	}).catch(() => ({ stdout: "" }));
+	const [allRefs, unmergedRefs] = await Promise.all([run(), run(["--no-merged=main"])]);
+	const branches = allRefs.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	const ahead = new Set(unmergedRefs.stdout.split("\n").map((line) => line.trim()).filter(Boolean));
+	return {
+		local: branches.filter((branch) => !branch.startsWith("origin/")),
+		remote: branches.filter((branch) => branch.startsWith("origin/")),
+		ahead
 	};
-	await Promise.all([run(["refs/heads/feature/*", "refs/heads/bypass/*"]), run(["refs/remotes/origin/feature/*", "refs/remotes/origin/bypass/*"])]);
-	return ahead;
 }
 async function scanWorkspace(workspacesDir, workspaceName) {
 	const workspacePath = join(workspacesDir, workspaceName);
@@ -30789,46 +30769,43 @@ async function scanWorkspace(workspacesDir, workspaceName) {
 	const issueMatch = workspaceName.match(/^feature-([a-z]+-\d+)$/i);
 	const issueId = issueMatch ? issueMatch[1].toUpperCase() : null;
 	const specEntry = issueId ? await Effect.runPromise(findSpecByIssue(projectRoot, issueId)).catch(() => null) : null;
-	const vbriefPath = specEntry ? specEntry.path : null;
-	let vbriefMtime = null;
-	if (vbriefPath) try {
-		vbriefMtime = (await stat$1(vbriefPath)).mtimeMs;
+	const xbriefPath = specEntry ? specEntry.path : null;
+	let xbriefMtime = null;
+	if (xbriefPath) try {
+		xbriefMtime = (await stat$1(xbriefPath)).mtimeMs;
 	} catch {
-		vbriefMtime = null;
+		xbriefMtime = null;
 	}
 	return {
 		workspacePath,
 		hasPlanning: workspaceEntries.has(PAN_DIRNAME),
 		hasPrd: panEntries.has("prd.md"),
 		hasState: panEntries.has(PAN_CONTINUE_FILENAME),
-		hasVbrief: vbriefPath !== null,
-		vbriefPath,
-		vbriefMtime,
-		hasTasks: vbriefPath !== null
+		hasXbrief: xbriefPath !== null,
+		xbriefPath,
+		xbriefMtime,
+		hasTasks: xbriefPath !== null
 	};
 }
-async function computeResourceAllocatedIssues() {
-	const projects = listProjectsSync();
-	const [trackerIssues, tmuxSessions, dockerContainers, pullRequests] = await Promise.all([
-		loadTrackerIssues(),
-		loadTmuxSessions(),
-		loadDockerContainers(),
-		loadOpenPullRequests(projects)
-	]);
+async function computeResourceAllocatedIssues(projectConfigs, sharedSignals) {
+	const registeredProjects = listProjectsSync();
+	const projects = projectConfigs.map((config) => registeredProjects.find((entry) => entry.config.path === config.path) ?? {
+		key: config.name ?? config.path,
+		config
+	});
+	const { trackerIssues, tmuxSessions, dockerContainers, conversations, remoteAgentStates } = sharedSignals ?? await captureSharedResourceSignals();
+	const pullRequests = await loadOpenPullRequests(projects);
 	const issueMap = /* @__PURE__ */ new Map();
 	const projectByPrefix = /* @__PURE__ */ new Map();
 	for (const project of projects) for (const prefix of projectPrefixes(project)) projectByPrefix.set(prefix, project);
-	const projectRefFromResolved = (resolvedProject) => ({
-		key: resolvedProject.projectKey,
-		config: {
-			name: resolvedProject.projectName,
-			path: resolvedProject.projectPath
-		}
-	});
+	const projectRefFromResolved = (resolvedProject) => projects.find((project) => project.key === resolvedProject.projectKey || project.config.path === resolvedProject.projectPath) ?? null;
 	const resolveProjectRef = (issueId, preferredProject) => {
 		if (preferredProject) return preferredProject;
 		const resolvedProject = resolveProjectFromIssueSync(issueId);
-		if (resolvedProject) return projectRefFromResolved(resolvedProject);
+		if (resolvedProject) {
+			const project = projectRefFromResolved(resolvedProject);
+			if (project) return project;
+		}
 		const prefix = issueId.toUpperCase().match(/^([A-Z]+)-\d+$/)?.[1] ?? "";
 		return projectByPrefix.get(prefix) ?? null;
 	};
@@ -30861,8 +30838,8 @@ async function computeResourceAllocatedIssues() {
 				localBranches: [],
 				remoteBranches: [],
 				prs: [],
-				vbriefPath: null,
-				vbriefMtime: null,
+				xbriefPath: null,
+				xbriefMtime: null,
 				tasksPath: null,
 				dockerContainers: [],
 				actualBranch: null,
@@ -30895,7 +30872,6 @@ async function computeResourceAllocatedIssues() {
 		issue.resourceSources.add("tmux");
 		if (!issue.resourceDetails.tmuxSessions.includes(sessionName)) issue.resourceDetails.tmuxSessions.push(sessionName);
 	}
-	const conversations = loadConversations();
 	for (const conv of conversations) {
 		if (!conv.issueId || conv.archivedAt) continue;
 		const issue = ensureIssue(conv.issueId);
@@ -30909,21 +30885,18 @@ async function computeResourceAllocatedIssues() {
 			tmuxSession: conv.tmuxSession
 		});
 	}
-	try {
-		const { listActiveRemoteAgentStates } = await import("./remote-agents-BNORDWAX.js");
-		for (const remoteState of listActiveRemoteAgentStates()) {
-			const issue = ensureIssue(remoteState.issueId);
-			if (!issue) continue;
-			issue.resourceSources.add("remote-agent");
-			issue.resourceDetails.remoteAgent = {
-				vmName: remoteState.vmName,
-				status: remoteState.status,
-				model: remoteState.model,
-				startedAt: remoteState.startedAt
-			};
-			if (!issue.agentStatus) issue.agentStatus = "active";
-		}
-	} catch {}
+	for (const remoteState of remoteAgentStates) {
+		const issue = ensureIssue(remoteState.issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("remote-agent");
+		issue.resourceDetails.remoteAgent = {
+			vmName: remoteState.vmName,
+			status: remoteState.status,
+			model: remoteState.model,
+			startedAt: remoteState.startedAt
+		};
+		if (!issue.agentStatus) issue.agentStatus = "active";
+	}
 	for (const containerName of dockerContainers) {
 		const issueId = parseIssueIdFromTextSync(containerName.replace(/feature\//g, "feature-"));
 		if (!issueId) continue;
@@ -30935,8 +30908,7 @@ async function computeResourceAllocatedIssues() {
 	await Promise.all(projects.map(async (project) => {
 		const projectPath = project.config.path;
 		const workspacesDir = join(projectPath, "workspaces");
-		const [workspaceEntries, branches] = await Promise.all([readdir(workspacesDir, { withFileTypes: true }).catch(() => []), loadProjectBranches(projectPath)]);
-		const aheadBranches = await loadBranchesAheadOfMain(projectPath);
+		const [workspaceEntries, branches] = await Promise.all([readdir(workspacesDir, { withFileTypes: true }).catch(() => []), loadProjectBranchSnapshot(projectPath)]);
 		await Promise.all(workspaceEntries.map(async (entry) => {
 			if (!entry.isDirectory() || !entry.name.startsWith("feature-")) return;
 			const issue = ensureIssue(entry.name.replace(/^feature-/, "").toUpperCase(), project);
@@ -30947,10 +30919,10 @@ async function computeResourceAllocatedIssues() {
 			issue.hasPlanning = workspace.hasPlanning;
 			issue.hasPrd = workspace.hasPrd;
 			issue.hasState = workspace.hasState;
-			if (workspace.vbriefPath) {
+			if (workspace.xbriefPath) {
 				issue.resourceSources.add("vbrief");
-				issue.resourceDetails.vbriefPath = workspace.vbriefPath;
-				issue.resourceDetails.vbriefMtime = workspace.vbriefMtime;
+				issue.resourceDetails.xbriefPath = workspace.xbriefPath;
+				issue.resourceDetails.xbriefMtime = workspace.xbriefMtime;
 			}
 			if (workspace.hasTasks) {
 				issue.resourceSources.add("tasks");
@@ -30968,7 +30940,7 @@ async function computeResourceAllocatedIssues() {
 			if (!issue) continue;
 			issue.resourceSources.add("branch");
 			if (!issue.resourceDetails[key].includes(branch)) issue.resourceDetails[key].push(branch);
-			if (aheadBranches.has(branch)) issue.resourceDetails.branchAheadOfMain = true;
+			if (branches.ahead.has(branch)) issue.resourceDetails.branchAheadOfMain = true;
 		}
 	}));
 	for (const [issueId, prs] of pullRequests) {
@@ -30993,14 +30965,18 @@ async function computeResourceAllocatedIssues() {
 		for (const issue of issueMap.values()) issue.readyForMerge = readyForMergeFlags.get(issue.issueId) ?? false;
 	}
 	const memberships = /* @__PURE__ */ new Map();
-	const projectMemberships = await getPipelineMembershipSnapshotsForResourceDiscovery(projects.map((project) => project.config));
-	for (const result of projectMemberships) for (const membership of result.memberships ?? []) {
-		ensureIssue(membership.issueId);
-		memberships.set(membership.issueId, membership);
+	const unavailableProjects = /* @__PURE__ */ new Set();
+	const projectMemberships = readPipelineMembershipSnapshotsForProjects(projects.map((project) => project.config));
+	for (const result of projectMemberships) {
+		if (result.error) unavailableProjects.add(result.project.name);
+		for (const membership of result.memberships ?? []) {
+			ensureIssue(membership.issueId);
+			memberships.set(membership.issueId, membership);
+		}
 	}
 	return [...issueMap.values()].filter((issue) => issue.resourceSources.size > 0).filter((issue) => {
 		const membership = memberships.get(issue.issueId);
-		return membership?.inPipeline === true || membership?.bucket === "clean_terminal" && isLiveResource(issue);
+		return membership?.inPipeline === true || membership?.bucket === "clean_terminal" && isLiveResource(issue) || !membership && unavailableProjects.has(issue.projectName) && isLiveResource(issue);
 	}).map((issue) => {
 		const membership = memberships.get(issue.issueId);
 		const hasTmux = issue.resourceDetails.tmuxSessions.length > 0;
@@ -31029,10 +31005,11 @@ async function computeResourceAllocatedIssues() {
 			resourceSources: new Set([...issue.resourceSources].sort()),
 			resourceDetails: issue.resourceDetails,
 			taskTotals: issue.taskTotals,
-			pipelineBucket: membership.bucket,
-			resourceDrift: !membership.inPipeline
+			pipelineBucket: membership?.bucket,
+			specOnlyPlanned: membership ? membership.bucket === "planned_backlog" && membership.reasons.includes("open issue with an xBRIEF spec but no branch/PR — planned work whose plan encodes code paths that age; needs starting or re-planning") : void 0,
+			resourceDrift: membership ? !membership.inPipeline : void 0
 		};
-	}).sort((a, b) => a.issueId.localeCompare(b.issueId));
+	}).sort((a, b) => compareIssueIds(a.issueId, b.issueId));
 }
 function toPublicResourceIssue(issue) {
 	return {
@@ -31041,28 +31018,42 @@ function toPublicResourceIssue(issue) {
 		resourceDetails: summarizeResourceDetails(issue.resourceDetails)
 	};
 }
-function refreshResourceAllocatedIssues() {
-	if (resourceIssuesRefreshPromise) return resourceIssuesRefreshPromise;
-	resourceIssuesRefreshPromise = computeResourceAllocatedIssues().then((issues) => {
-		cachedDetailedResourceIssues = issues;
-		const publicIssues = issues.map(toPublicResourceIssue);
-		cachedResourceIssues = {
-			value: publicIssues,
-			computedAt: Date.now()
-		};
-		return publicIssues;
-	}).finally(() => {
-		resourceIssuesRefreshPromise = null;
+function rebuildCombinedResourceSnapshot() {
+	const detailed = [...projectResourceSnapshots.values()].flatMap((snapshot) => snapshot.detailed).sort((a, b) => compareIssueIds(a.issueId, b.issueId));
+	const publicIssues = detailed.map(toPublicResourceIssue);
+	cachedDetailedResourceIssues = detailed;
+	cachedResourceIssues = {
+		value: publicIssues,
+		computedAt: Math.max(0, ...[...projectResourceSnapshots.values()].map((snapshot) => snapshot.computedAt))
+	};
+	return publicIssues;
+}
+function publishProjectResourceSnapshot(project, issues) {
+	projectResourceSnapshots.set(project.path, {
+		detailed: issues,
+		public: issues.map(toPublicResourceIssue),
+		computedAt: Date.now()
 	});
-	return resourceIssuesRefreshPromise;
+	rebuildCombinedResourceSnapshot();
 }
-async function getCachedResourceAllocatedIssues() {
-	if (cachedResourceIssues && Date.now() - cachedResourceIssues.computedAt < RESOURCE_DISCOVERY_TTL_MS) return cachedResourceIssues.value;
-	if (cachedResourceIssues) {
-		refreshResourceAllocatedIssues().catch(() => {});
-		return cachedResourceIssues.value;
+/** Refresh only the requested projects, capturing fleet-wide signals once for the batch. */
+async function refreshResourceAllocatedProjects(projects, options = {}) {
+	if (projects.length === 0) return cachedResourceIssues?.value ?? [];
+	const sharedSignals = await captureSharedResourceSignals();
+	const failures = [];
+	for (const project of projects) try {
+		if (options.refreshMembership !== false) await refreshMembershipSnapshotsForProjects([project]);
+		publishProjectResourceSnapshot(project, await computeResourceAllocatedIssues([project], sharedSignals));
+	} catch (error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		failures.push(failure);
+		console.warn(`[resource-discovery] refresh failed for ${project.name ?? project.path}; keeping last-good snapshot:`, failure.message);
 	}
-	return refreshResourceAllocatedIssues();
+	if (failures.length > 0) throw new AggregateError(failures, `${failures.length} project resource refresh(es) failed`);
+	return cachedResourceIssues?.value ?? [];
+}
+async function getCachedResourceAllocatedIssues() {
+	return cachedResourceIssues?.value ?? [];
 }
 function sanitizeResourceAllocatedIssues(issues) {
 	return issues.map((issue) => ({
@@ -31078,7 +31069,7 @@ function sanitizeResourceAllocatedIssues(issues) {
 				state: pr.state,
 				isDraft: pr.isDraft
 			})),
-			hasVbrief: issue.resourceDetails.hasVbrief,
+			hasXbrief: issue.resourceDetails.hasXbrief,
 			hasTasks: issue.resourceDetails.hasTasks,
 			dockerContainerCount: issue.resourceDetails.dockerContainerCount,
 			actualBranch: issue.resourceDetails.actualBranch,
@@ -31101,10 +31092,7 @@ function toPublicResourceDetailIdentifiers(details) {
 async function getResourceDetailIdentifiers(issueId) {
 	const normalizedIssueId = issueId.toUpperCase();
 	const cachedMatch = cachedDetailedResourceIssues?.find((entry) => entry.issueId === normalizedIssueId);
-	if (cachedMatch) return toPublicResourceDetailIdentifiers(cachedMatch.resourceDetails);
-	await refreshResourceAllocatedIssues();
-	const refreshedMatch = cachedDetailedResourceIssues?.find((entry) => entry.issueId === normalizedIssueId);
-	return refreshedMatch ? toPublicResourceDetailIdentifiers(refreshedMatch.resourceDetails) : null;
+	return cachedMatch ? toPublicResourceDetailIdentifiers(cachedMatch.resourceDetails) : null;
 }
 function groupResourceAllocatedIssuesByProject(issues) {
 	const projectTree = /* @__PURE__ */ new Map();
@@ -31122,7 +31110,7 @@ function groupResourceAllocatedIssuesByProject(issues) {
 	}
 	return [...projectTree.values()].map((project) => ({
 		...project,
-		features: project.features.sort((a, b) => a.issueId.localeCompare(b.issueId))
+		features: project.features.sort((a, b) => compareIssueIds(a.issueId, b.issueId))
 	})).sort((a, b) => a.name.localeCompare(b.name));
 }
 //#endregion
@@ -31308,7 +31296,7 @@ function getIssueTasks(id) {
 			};
 		});
 		const doc = workspacePath ? readWorkspacePlanSync(workspacePath) : null;
-		if (!doc) return jsonResponse({ error: `The vBRIEF for ${id} is missing or unreadable.` }, { status: 404 });
+		if (!doc) return jsonResponse({ error: `The xBRIEF for ${id} is missing or unreadable.` }, { status: 404 });
 		const record = projectPath ? readIssueRecordSync({
 			name: resolvedProject?.projectName ?? id,
 			path: projectPath
@@ -31401,11 +31389,12 @@ init_tracker_config();
 init_agents$1();
 init_pan_dir();
 init_projects();
+init_review_status();
 init_remote_agents();
 init_tracker_utils();
 init_tmux();
 init_io();
-const execFileAsync$17 = promisify(execFile);
+const execFileAsync$16 = promisify(execFile);
 function getIssueDataService$9() {
 	return getSharedIssueService();
 }
@@ -31462,12 +31451,12 @@ async function completePlanningArtifacts(options) {
 	const workspacePlanPath = await Effect.runPromise(Effect.gen(function* () {
 		return (yield* findWorkspaceDraftPlan(workspacePath)) ?? (yield* findPlan(workspacePath));
 	}));
-	if (!workspacePlanPath) throw new Error(`No workspace vBRIEF found for ${upperIssueId} at ${workspacePath}/.pan/spec.vbrief.json`);
+	if (!workspacePlanPath) throw new Error(`No workspace xBRIEF found for ${upperIssueId} at ${workspacePath}/.overdeck/spec.vbrief.json`);
 	const workspaceDoc = await Effect.runPromise(readPlan(workspacePlanPath));
 	const workspaceIssueId = workspaceDoc.plan?.id;
-	if (workspaceIssueId && workspaceIssueId.toLowerCase() !== issueLower) throw new Error(`Workspace vBRIEF is for ${workspaceIssueId.toUpperCase()}, not ${upperIssueId}`);
+	if (workspaceIssueId && workspaceIssueId.toLowerCase() !== issueLower) throw new Error(`Workspace xBRIEF is for ${workspaceIssueId.toUpperCase()}, not ${upperIssueId}`);
 	assertPlanQuality(workspaceDoc);
-	emitCompletePlanningPhase(upperIssueId, "specWrite", "start", "writing proposed vBRIEF spec", { projectPath });
+	emitCompletePlanningPhase(upperIssueId, "specWrite", "start", "writing proposed xBRIEF spec", { projectPath });
 	const existingSpec = await Effect.runPromise(findSpecByIssue(projectPath, upperIssueId));
 	let proposed;
 	try {
@@ -31482,7 +31471,7 @@ async function completePlanningArtifacts(options) {
 			path: e.path,
 			filename: e.filename
 		}));
-		emitCompletePlanningPhase(upperIssueId, "specWrite", "success", "proposed vBRIEF spec written", {
+		emitCompletePlanningPhase(upperIssueId, "specWrite", "success", "proposed xBRIEF spec written", {
 			path: proposed.path,
 			filename: proposed.filename
 		});
@@ -31491,7 +31480,7 @@ async function completePlanningArtifacts(options) {
 		throw error;
 	}
 	const planItemCount = workspaceDoc.plan.items?.length ?? 0;
-	if (planItemCount === 0) throw new Error(`The vBRIEF for ${upperIssueId} contains no implementation items.`);
+	if (planItemCount === 0) throw new Error(`The xBRIEF for ${upperIssueId} contains no implementation items.`);
 	return {
 		proposed,
 		taskCount: planItemCount,
@@ -31531,7 +31520,7 @@ async function commitWorkspaceRecordBeforeAutoSpawn(gitRoot, issueId) {
 	} catch {}
 	const recordPath = join(".pan", "records", `${issueLower}.json`);
 	try {
-		const { stdout: statusOut } = await execFileAsync$17("git", [
+		const { stdout: statusOut } = await execFileAsync$16("git", [
 			"status",
 			"--porcelain",
 			"--",
@@ -31541,7 +31530,7 @@ async function commitWorkspaceRecordBeforeAutoSpawn(gitRoot, issueId) {
 			encoding: "utf-8"
 		});
 		if (!statusOut.trim()) return;
-		await execFileAsync$17("git", [
+		await execFileAsync$16("git", [
 			"add",
 			"--",
 			recordPath
@@ -31550,7 +31539,7 @@ async function commitWorkspaceRecordBeforeAutoSpawn(gitRoot, issueId) {
 			encoding: "utf-8"
 		});
 		try {
-			await execFileAsync$17("git", [
+			await execFileAsync$16("git", [
 				"diff",
 				"--cached",
 				"--quiet",
@@ -31562,7 +31551,7 @@ async function commitWorkspaceRecordBeforeAutoSpawn(gitRoot, issueId) {
 			});
 			return;
 		} catch {}
-		await execFileAsync$17("git", [
+		await execFileAsync$16("git", [
 			"commit",
 			"-m",
 			`chore(records): update ${issueId.toUpperCase()} per-issue record before auto-start`,
@@ -31584,25 +31573,59 @@ function getInternalDashboardOrigin() {
 }
 function classifyAutoSpawnSkip(status, body) {
 	const error = typeof body["error"] === "string" ? body["error"] : "";
+	if (status === 401 || status === 403) return "unauthorized";
 	if (body["stackHealth"] || /workspace docker stack/i.test(error)) return "stack-unhealthy";
 	if (body["paused"] === true) return "paused";
 	if (body["troubled"] === true) return "troubled";
 	if (body["guardrails"] || body["requiresAcknowledgement"] === true || status === 409) return "guardrails";
 	return "spawn-failed";
 }
+function resolveCompletePlanningTerminalStatus(autoSpawnRequested, autoSpawnResult) {
+	return autoSpawnRequested && autoSpawnResult?.workAgentSpawned !== true ? "failure" : "success";
+}
+async function recordPlanningAutoHandoffFailure(options) {
+	const skipReason = options.result.workAgentSkipReason ?? "spawn-failed";
+	const error = options.result.workAgentError ?? `Work agent startup failed: ${skipReason}`;
+	const details = {
+		workAgentSkipReason: skipReason,
+		workAgentError: error
+	};
+	await Effect.runPromise(options.eventStore.append({
+		type: "planning.failed",
+		timestamp: (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))(),
+		payload: {
+			issueId: options.issueId,
+			error,
+			stage: "auto-handoff",
+			...details
+		}
+	}));
+	(options.markStuck ?? markWorkspaceStuck)(options.issueId, "planning_auto_handoff_failed", details);
+	(options.emitActivity ?? emitActivityEntrySync)({
+		source: "plan",
+		level: "error",
+		message: `${options.issueId} planning complete, but work-agent startup failed: ${error}`,
+		issueId: options.issueId,
+		details: JSON.stringify(details)
+	});
+	return error;
+}
 async function completePlanningAutoSpawn(options) {
 	if (options.autoSpawn !== true) {
 		emitCompletePlanningPhase(options.issueId, "autoSpawn", "skipped", "autoSpawn not requested");
 		return null;
 	}
 	const dashboardOrigin = options.dashboardOrigin ?? getInternalDashboardOrigin();
+	const internalToken = getInternalTokenSync();
+	const internalTokenHeaders = internalToken ? { [INTERNAL_TOKEN_HEADER]: internalToken } : {};
 	emitCompletePlanningPhase(options.issueId, "autoSpawn", "start", "posting work-agent spawn request", { dashboardOrigin });
 	try {
 		const response = await (options.fetchImpl ?? fetch)(new URL("/api/agents", dashboardOrigin), {
 			method: "POST",
 			headers: {
 				"content-type": "application/json",
-				origin: dashboardOrigin
+				origin: dashboardOrigin,
+				...internalTokenHeaders
 			},
 			body: JSON.stringify({
 				issueId: options.issueId,
@@ -31623,7 +31646,10 @@ async function completePlanningAutoSpawn(options) {
 		if (skipReason === "stack-unhealthy") {
 			const recovery = await (options.fetchImpl ?? fetch)(new URL(`/api/workspaces/${encodeURIComponent(options.issueId)}/rebuild-and-start`, dashboardOrigin), {
 				method: "POST",
-				headers: { origin: dashboardOrigin }
+				headers: {
+					origin: dashboardOrigin,
+					...internalTokenHeaders
+				}
 			});
 			const recoveryBody = await recovery.json().catch(() => ({}));
 			if (recovery.ok && recoveryBody["success"] !== false) {
@@ -31766,6 +31792,19 @@ async function completePlanningForIssue(options) {
 				}
 				emitCompletePlanningPhase(id, "prdGate", "success", `found ${prdGate.path} (${prdGate.lineCount} lines)`);
 			}
+			try {
+				const draftPromotion = await Effect.runPromise(promoteWorkspacePrdDraft({
+					projectRoot: projectPath,
+					workspacePath,
+					issueId: id
+				}));
+				if (draftPromotion.promoted) emitCompletePlanningPhase(id, "prdPromote", "success", `promoted ${draftPromotion.source} -> ${draftPromotion.path}`);
+				else emitCompletePlanningPhase(id, "prdPromote", "skipped", draftPromotion.reason);
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				emitCompletePlanningPhase(id, "prdPromote", "failure", reason);
+				return jsonResponse({ error: `PRD draft promotion failed for ${id.toUpperCase()}: ${reason}` }, { status: 500 });
+			}
 			const workspacePlanPath = await (async () => await Effect.runPromise(findWorkspaceDraftPlan(workspacePath)) ?? await Effect.runPromise(findPlan(workspacePath)))();
 			if (workspacePlanPath) {
 				const workspaceDoc = await Effect.runPromise(readPlan(workspacePlanPath));
@@ -31773,7 +31812,7 @@ async function completePlanningForIssue(options) {
 					assertPlanQuality(workspaceDoc);
 				} catch (error) {
 					if (error instanceof PlanQualityLintError) return jsonResponse({
-						error: "vBRIEF quality lint failed",
+						error: "xBRIEF quality lint failed",
 						qualityIssues: error.issues
 					}, { status: 422 });
 					throw error;
@@ -31790,7 +31829,7 @@ async function completePlanningForIssue(options) {
 				issueId: id
 			});
 			console.log(`[complete-planning] Wrote pan spec to ${proposed.path}`);
-			console.log(`[complete-planning] Finalized ${taskCount} vBRIEF tasks for ${upperIssueId}`);
+			console.log(`[complete-planning] Finalized ${taskCount} xBRIEF tasks for ${upperIssueId}`);
 			const project = findProjectByPathSync(projectPath);
 			const migrated = project ? await isStateMigrated(project) : false;
 			const filesToStage = completePlanningFilesToStage(projectPath, proposed.filename, migrated);
@@ -31798,7 +31837,7 @@ async function completePlanningForIssue(options) {
 			if (migrated) await Effect.runPromise(flushAutoCommits(projectPath));
 			else if (!projectIsGitRepo) console.log(`[complete-planning] Project root ${projectPath} is not a git repository (polyrepo) — pan spec updated on disk but not committed`);
 			else {
-				const { stdout: branchStdout } = await execFileAsync$17("git", [
+				const { stdout: branchStdout } = await execFileAsync$16("git", [
 					"rev-parse",
 					"--abbrev-ref",
 					"HEAD"
@@ -31808,7 +31847,7 @@ async function completePlanningForIssue(options) {
 				});
 				const currentBranch = branchStdout.trim();
 				if (currentBranch === "main") {
-					await execFileAsync$17("git", [
+					await execFileAsync$16("git", [
 						"add",
 						"--",
 						...filesToStage
@@ -31817,7 +31856,7 @@ async function completePlanningForIssue(options) {
 						encoding: "utf-8"
 					});
 					try {
-						await execFileAsync$17("git", [
+						await execFileAsync$16("git", [
 							"diff",
 							"--cached",
 							"--quiet",
@@ -31828,10 +31867,10 @@ async function completePlanningForIssue(options) {
 							encoding: "utf-8"
 						});
 					} catch {
-						await execFileAsync$17("git", [
+						await execFileAsync$16("git", [
 							"commit",
 							"-m",
-							`chore(scope): propose ${upperIssueId} vBRIEF`,
+							`chore(scope): propose ${upperIssueId} xBRIEF`,
 							"--no-verify",
 							"--",
 							...filesToStage
@@ -31841,7 +31880,7 @@ async function completePlanningForIssue(options) {
 						});
 						console.log(`[complete-planning] Committed pan spec on main for ${upperIssueId}`);
 						try {
-							const { stdout: remotes } = await execFileAsync$17("git", ["remote"], {
+							const { stdout: remotes } = await execFileAsync$16("git", ["remote"], {
 								cwd: projectPath,
 								encoding: "utf-8"
 							});
@@ -31854,16 +31893,16 @@ async function completePlanningForIssue(options) {
 					}
 				} else console.log(`[complete-planning] Project root not on main (${currentBranch}) — pan spec updated on disk but not committed on main`);
 			}
-			if (!existsSync$1(join(gitRoot, ".git"))) await execFileAsync$17("git", ["init"], {
+			if (!existsSync$1(join(gitRoot, ".git"))) await execFileAsync$16("git", ["init"], {
 				cwd: gitRoot,
 				encoding: "utf-8"
 			});
-			for (const args of completePlanningWorkspaceGitAddCommands(gitRoot, migrated)) await execFileAsync$17("git", args, {
+			for (const args of completePlanningWorkspaceGitAddCommands(gitRoot, migrated)) await execFileAsync$16("git", args, {
 				cwd: gitRoot,
 				encoding: "utf-8"
 			});
 			try {
-				await execFileAsync$17("git", [
+				await execFileAsync$16("git", [
 					"diff",
 					"--cached",
 					"--quiet"
@@ -31872,7 +31911,7 @@ async function completePlanningForIssue(options) {
 					encoding: "utf-8"
 				});
 			} catch {
-				await execFileAsync$17("git", [
+				await execFileAsync$16("git", [
 					"commit",
 					"-m",
 					`chore(plan): complete planning for ${id}`,
@@ -31883,7 +31922,7 @@ async function completePlanningForIssue(options) {
 				});
 			}
 			try {
-				const { stdout: remotes } = await execFileAsync$17("git", ["remote"], {
+				const { stdout: remotes } = await execFileAsync$16("git", ["remote"], {
 					cwd: gitRoot,
 					encoding: "utf-8"
 				});
@@ -31948,19 +31987,6 @@ async function completePlanningForIssue(options) {
 			});
 		} catch {}
 		invalidateAgentsCache();
-		emitActivityEntrySync({
-			source: "plan",
-			level: "info",
-			message: `${id} planning complete — ready for work`,
-			issueId: id
-		});
-		emitActivityTtsSync({
-			utterance: `${id} planning complete, ready for work`,
-			priority: 2,
-			issueId: id,
-			source: "planning-agent",
-			eventType: "planning.complete"
-		});
 		const effectiveAutoSpawn = autoSpawn || completePlanningLease.autoSpawnRequested();
 		if (effectiveAutoSpawn && workspacePath) await commitWorkspaceRecordBeforeAutoSpawn(workspacePath, id);
 		const autoSpawnResult = await completePlanningAutoSpawnAndKill({
@@ -31969,7 +31995,29 @@ async function completePlanningForIssue(options) {
 			skipKill,
 			sessionName
 		});
-		emitCompletePlanningPhase(id, "terminal", "success", autoSpawnResult?.workAgentSpawned ? "planning complete and work agent spawn requested" : autoSpawnResult?.workAgentSkipReason ?? "planning complete", {
+		const autoHandoffFailed = effectiveAutoSpawn && autoSpawnResult?.workAgentSpawned !== true;
+		let autoHandoffError;
+		if (autoHandoffFailed && autoSpawnResult) autoHandoffError = await recordPlanningAutoHandoffFailure({
+			issueId: id,
+			result: autoSpawnResult,
+			eventStore
+		});
+		else {
+			emitActivityEntrySync({
+				source: "plan",
+				level: "info",
+				message: autoSpawnResult?.workAgentSpawned ? `${id} planning complete — work-agent startup accepted` : `${id} planning complete — ready for work`,
+				issueId: id
+			});
+			emitActivityTtsSync({
+				utterance: autoSpawnResult?.workAgentSpawned ? `${id} planning complete, work agent starting` : `${id} planning complete, ready for work`,
+				priority: 2,
+				issueId: id,
+				source: "planning-agent",
+				eventType: "planning.complete"
+			});
+		}
+		emitCompletePlanningPhase(id, "terminal", resolveCompletePlanningTerminalStatus(effectiveAutoSpawn, autoSpawnResult), autoSpawnResult?.workAgentSpawned ? "planning complete and work agent spawn requested" : autoSpawnResult?.workAgentSkipReason ?? "planning complete", {
 			autoSpawn: effectiveAutoSpawn,
 			workAgentSpawned: autoSpawnResult?.workAgentSpawned ?? false,
 			workAgentSkipReason: autoSpawnResult?.workAgentSkipReason
@@ -31981,7 +32029,7 @@ async function completePlanningForIssue(options) {
 			gitPushed,
 			...taskWarning ? { taskWarning } : {},
 			...autoSpawnResult ?? {},
-			message: autoSpawnResult?.workAgentSpawned ? "Planning complete and work agent spawn requested" : gitPushed ? "Planning complete and pushed to git - ready for execution" : "Planning complete - ready for execution"
+			message: autoHandoffFailed ? `Planning complete, but work-agent startup failed (${autoSpawnResult?.workAgentSkipReason ?? "spawn-failed"}): ${autoHandoffError}` : autoSpawnResult?.workAgentSpawned ? "Planning complete and work agent spawn requested" : gitPushed ? "Planning complete and pushed to git - ready for execution" : "Planning complete - ready for execution"
 		});
 	} finally {
 		completePlanningLease.release();
@@ -32063,7 +32111,7 @@ init_tracker_utils();
 init_agents$1();
 init_issue_id();
 const execAsync$8 = promisify(exec);
-const execFileAsync$16 = promisify(execFile);
+const execFileAsync$15 = promisify(execFile);
 function isGitHubIssue$4(issueId) {
 	const resolved = resolveGitHubIssueSync(issueId);
 	if (resolved.isGitHub) return {
@@ -32102,7 +32150,7 @@ async function closeIssuePullRequest(issueId, reason = "Canceled via Overdeck")
 	if (!githubCheck.isGitHub || !githubCheck.owner || !githubCheck.repo) return ["No GitHub PR to close"];
 	const branchName = `feature/${issueId.toLowerCase()}`;
 	try {
-		const { stdout: prListRaw } = await execFileAsync$16("gh", [
+		const { stdout: prListRaw } = await execFileAsync$15("gh", [
 			"pr",
 			"list",
 			"--repo",
@@ -32121,7 +32169,7 @@ async function closeIssuePullRequest(issueId, reason = "Canceled via Overdeck")
 		});
 		const prNumber = prListRaw.trim();
 		if (!prNumber) return ["No open PR found for branch"];
-		await execFileAsync$16("gh", [
+		await execFileAsync$15("gh", [
 			"pr",
 			"close",
 			prNumber,
@@ -32134,7 +32182,7 @@ async function closeIssuePullRequest(issueId, reason = "Canceled via Overdeck")
 			timeout: 15e3
 		});
 		try {
-			const { setReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+			const { setReviewStatusSync } = await import("./review-status-C6n6-9f_.js");
 			setReviewStatusSync(issueId.toUpperCase(), { prUrl: void 0 });
 		} catch {}
 		return [`Closed PR #${prNumber} on ${githubCheck.owner}/${githubCheck.repo}`];
@@ -32188,7 +32236,7 @@ async function runDestructiveIssueLifecycle(id, mode, opts = {}) {
 	const { ctx, projectConfig } = buildLifecycleContext(id, getIssueDataService$8().getIssueSource(id) ?? void 0);
 	const deleteWorkspace = opts.deleteWorkspace ?? true;
 	cleanupLog.push(...await closeIssuePullRequest(id, mode === "cancel" ? "Canceled via Overdeck" : "Reset to Todo via Overdeck"));
-	const { resetToTodo, cancelIssueWorkflow } = await import("./lifecycle-CE7619Xw.js");
+	const { resetToTodo, cancelIssueWorkflow } = await import("./lifecycle-sycO16hj.js");
 	const workflow = mode === "cancel" ? cancelIssueWorkflow : resetToTodo;
 	const result = await Effect.runPromise(workflow(ctx, {
 		deleteWorkspace,
@@ -32203,16 +32251,16 @@ async function runDestructiveIssueLifecycle(id, mode, opts = {}) {
 	}));
 	cleanupLog.push(...result.steps.flatMap((step) => step.details || [step.error].filter(Boolean)));
 	if (mode === "cancel") try {
-		const { transitionVBriefOnMain } = await import("./lifecycle-io-CUpsxG0p.js");
-		const tx = await Effect.runPromise(transitionVBriefOnMain(ctx.projectPath, id, "cancelled", "cancelled", `scope: cancel ${id.toUpperCase()} vBRIEF`));
-		if (tx.moved) cleanupLog.push(`vBRIEF moved ${tx.fromDir} → cancelled`);
-		if (tx.committed) cleanupLog.push(`Committed vBRIEF cancellation on main`);
+		const { transitionXBriefOnMain } = await import("./lifecycle-io-Bsnr2K4F.js");
+		const tx = await Effect.runPromise(transitionXBriefOnMain(ctx.projectPath, id, "cancelled", "cancelled", `scope: cancel ${id.toUpperCase()} xBRIEF`));
+		if (tx.moved) cleanupLog.push(`xBRIEF moved ${tx.fromDir} → cancelled`);
+		if (tx.committed) cleanupLog.push(`Committed xBRIEF cancellation on main`);
 	} catch (err) {
-		cleanupLog.push(`vBRIEF cancel transition failed (non-fatal): ${err?.message ?? err}`);
+		cleanupLog.push(`xBRIEF cancel transition failed (non-fatal): ${err?.message ?? err}`);
 	}
 	try {
-		const { killAllReviewerSessions } = await import("./review-agent-CSswH985.js");
-		const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+		const { killAllReviewerSessions } = await import("./review-agent-DJRO8EG8.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-9SkRpES9.js");
 		const projectKey = resolveProjectFromIssueSync(id)?.projectKey;
 		if (projectKey) {
 			const { killed } = await Effect.runPromise(killAllReviewerSessions(projectKey, id.toUpperCase()));
@@ -32226,7 +32274,7 @@ async function runDestructiveIssueLifecycle(id, mode, opts = {}) {
 		cleanupLog.push("Cleared review status");
 	} catch {}
 	try {
-		const { resetPostMergeState } = await import("./merge-agent-CnORPiri.js");
+		const { resetPostMergeState } = await import("./merge-agent-BQM3a8z5.js");
 		resetPostMergeState(id);
 		resetPostMergeState(id.toUpperCase());
 		cleanupLog.push("Cleared merge state");
@@ -32246,7 +32294,7 @@ function closeIssueTransition(options) {
 		const { issueId, body, eventStore } = options;
 		const { reason } = body;
 		const projectPath = getProjectPath$3(void 0, extractPrefixSync(issueId) ?? issueId.split("-")[0]);
-		const { close: closeWorkflow } = yield* Effect.promise(() => import("./lifecycle-CE7619Xw.js"));
+		const { close: closeWorkflow } = yield* Effect.promise(() => import("./lifecycle-sycO16hj.js"));
 		const githubCheck = isGitHubIssue$4(issueId);
 		const issueDataService = getIssueDataService$8();
 		const issueSource = issueDataService.getIssueSource(issueId);
@@ -32513,7 +32561,7 @@ function reopenIssueTransition(options) {
 				else clearReviewStatus(id.toUpperCase());
 			} catch {}
 			try {
-				const { resetPostMergeState } = await import("./merge-agent-CnORPiri.js");
+				const { resetPostMergeState } = await import("./merge-agent-BQM3a8z5.js");
 				resetPostMergeState(id);
 				resetPostMergeState(id.toUpperCase());
 			} catch {}
@@ -32577,7 +32625,7 @@ function moveIssueStatus(options) {
 			"done"
 		];
 		if (!targetStatus || !validStatuses.includes(targetStatus)) return jsonResponse({ error: `Invalid targetStatus. Must be one of: ${validStatuses.join(", ")}` }, { status: 400 });
-		const { updateShadowState } = yield* Effect.promise(() => import("./shadow-state-CDxEuPlE.js"));
+		const { updateShadowState } = yield* Effect.promise(() => import("./shadow-state-C2_epgx2.js"));
 		const issueState = {
 			backlog: "open",
 			todo: "open",
@@ -32804,7 +32852,7 @@ async function copySettingsToWorkspace(id) {
 		success: false,
 		error: "Workspace not found"
 	}, { status: 404 });
-	const { copyOverdeckSettingsToWorkspaceSync } = await import("./workspace-manager-CcujONCR.js");
+	const { copyOverdeckSettingsToWorkspaceSync } = await import("./workspace-manager-ZTdJAy9M.js");
 	const result = copyOverdeckSettingsToWorkspaceSync(workspacePath);
 	return jsonResponse({
 		success: result.errors.length === 0 || result.copied.length > 0,
@@ -32835,7 +32883,7 @@ function generateTasksForIssue(id) {
 		const plan = readWorkspacePlanSync(join(projectPath, "workspaces", `feature-${issueLower}`));
 		if (!plan) return jsonResponse({
 			success: false,
-			error: `No vBRIEF spec found on main for ${id} — run planning first.`
+			error: `No xBRIEF spec found on main for ${id} — run planning first.`
 		}, { status: 409 });
 		return jsonResponse({
 			success: true,
@@ -32858,7 +32906,7 @@ init_tracker_utils();
 init_tmux();
 init_typed_errors();
 const execAsync$6 = promisify(exec);
-const execFileAsync$15 = promisify(execFile);
+const execFileAsync$14 = promisify(execFile);
 function getIssueDataService$6() {
 	return getSharedIssueService();
 }
@@ -33158,7 +33206,7 @@ function abortPlanningForIssue(options) {
 						const featureWorkspacePath = join(projectPath, "workspaces", `feature-${issueIdentifier.toLowerCase()}`);
 						const plainWorkspacePath = join(projectPath, "workspaces", issueIdentifier.toLowerCase());
 						if (existsSync$1(existsSync$1(featureWorkspacePath) ? featureWorkspacePath : plainWorkspacePath)) {
-							await execFileAsync$15("pan", [
+							await execFileAsync$14("pan", [
 								"workspace",
 								"destroy",
 								issueIdentifier.toLowerCase(),
@@ -33267,7 +33315,7 @@ function restartFromPlan(options) {
 		});
 		const resetResult = yield* Effect.promise(async () => {
 			try {
-				const { runGitResetHard } = await import("./dangerous-git-ops-BebB-61h.js");
+				const { runGitResetHard } = await import("./dangerous-git-ops-CT-IypG3.js");
 				async function findPlanningCommit(grep, label) {
 					try {
 						const { stdout } = await execAsync$6(`git log --grep="${grep.replace(/"/g, "\\\"")}" --format=%H -1`, {
@@ -33720,7 +33768,7 @@ function closeOutIssue(id, opts = {}) {
 		}
 		const closeOutResult = yield* Effect.promise(async () => {
 			try {
-				const { closeOut } = await import("./lifecycle-CE7619Xw.js");
+				const { closeOut } = await import("./lifecycle-sycO16hj.js");
 				return {
 					ok: true,
 					result: await Effect.runPromise(closeOut(ctx, {
@@ -33809,7 +33857,7 @@ function bulkCloseOut(body) {
 		const invalidIds = issueIds.filter((id) => !isValidIssueId(id));
 		if (invalidIds.length > 0) return jsonResponse({ error: `Invalid issue ID format: ${invalidIds.join(", ")}` }, { status: 400 });
 		const eventStore = yield* EventStoreService;
-		const { closeOut } = yield* Effect.promise(() => import("./lifecycle-CE7619Xw.js"));
+		const { closeOut } = yield* Effect.promise(() => import("./lifecycle-sycO16hj.js"));
 		const issueDataService = getIssueDataService$5();
 		const tasks = [];
 		const agentChecks = yield* withConcurrencyLimit(issueIds.map((id) => Effect.promise(async () => {
@@ -33973,7 +34021,7 @@ init_issue_service_singleton();
 init_domain_services();
 init_linear_client();
 promisify(exec);
-const execFileAsync$14 = promisify(execFile);
+const execFileAsync$13 = promisify(execFile);
 function getIssueDataService$4() {
 	return getSharedIssueService();
 }
@@ -34008,7 +34056,7 @@ const getIssuesRoute = HttpRouter.add("GET", "/api/issues", httpHandler(Effect.g
 		}
 	}
 	const membershipByIssue = /* @__PURE__ */ new Map();
-	const results = getPipelineMembershipSnapshotsForProjects([...projects.values()]);
+	const results = readPipelineMembershipSnapshotsForProjects([...projects.values()]);
 	const successfulPaths = /* @__PURE__ */ new Set();
 	const failedPaths = /* @__PURE__ */ new Set();
 	for (const result of results) {
@@ -34035,8 +34083,8 @@ const getIssueShipLogRoute = HttpRouter.add("GET", "/api/issues/:id/ship-log", h
 	const id = (yield* HttpRouter.params)["id"] ?? "";
 	if (!parseIssueIdSync(id)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	return yield* Effect.promise(async () => {
-		const { getShipLog } = await import("./ship-log-DDcueaIR.js");
-		const { getReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+		const { getShipLog } = await import("./ship-log-ClSMIzZX.js");
+		const { getReviewStatusSync } = await import("./review-status-C6n6-9f_.js");
 		const log = getShipLog(id);
 		const rs = getReviewStatusSync(id);
 		return jsonResponse({
@@ -34051,8 +34099,8 @@ const getIssueVerificationRoute = HttpRouter.add("GET", "/api/issues/:id/verific
 	const id = (yield* HttpRouter.params)["id"] ?? "";
 	if (!parseIssueIdSync(id)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	return yield* Effect.promise(async () => {
-		const { readVerificationArtifact } = await import("./verification-artifact-CrbI4tJE.js");
-		const { getReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+		const { readVerificationArtifact } = await import("./verification-artifact-C-lIHfUa.js");
+		const { getReviewStatusSync } = await import("./review-status-C6n6-9f_.js");
 		const { join } = await import("node:path");
 		const resolved = resolveProjectFromIssueSync(id);
 		const workspacePath = resolved ? join(resolved.projectPath, "workspaces", `feature-${id.toLowerCase()}`) : null;
@@ -34137,7 +34185,7 @@ const postIssueResetToPlannedRoute = HttpRouter.add("POST", "/api/issues/:id/res
 	if (!parseIssueIdSync(id)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	try {
 		const invocation = panCliInvocation(["reset-to-planned", id]);
-		const { stdout } = yield* Effect.promise(() => execFileAsync$14(invocation.command, invocation.args, { encoding: "utf8" }));
+		const { stdout } = yield* Effect.promise(() => execFileAsync$13(invocation.command, invocation.args, { encoding: "utf8" }));
 		invalidateAgentsCache();
 		return jsonResponse({
 			success: true,
@@ -34376,7 +34424,9 @@ const getPipelineMembershipRoute = HttpRouter.add("GET", "/api/pipeline/membersh
 	if (!projectKey) return jsonResponse({ error: "project query parameter is required" }, { status: 400 });
 	const project = getProjectSync(projectKey);
 	if (!project) return jsonResponse({ error: `Project not found: ${projectKey}` }, { status: 404 });
-	return jsonResponse(yield* Effect.promise(() => getProjectPipelineMembership(project)));
+	const snapshot = readPipelineMembershipSnapshotsForProjects([project])[0];
+	if (snapshot?.memberships) return jsonResponse(snapshot.memberships);
+	return jsonResponse({ error: "Pipeline membership snapshot is loading" }, { status: 503 });
 })));
 const getIssueResourceDetailsRoute = HttpRouter.add("GET", "/api/issues/:id/resource-details", httpHandler(Effect.gen(function* () {
 	return yield* getIssueResourceDetails((yield* HttpRouter.params)["id"] ?? "");
@@ -35048,8 +35098,7 @@ const cloisterRouteLayer = Layer.mergeAll(getCloisterStatusRoute, postCloisterSt
 //#region routes/resources/agents-stats.ts
 init_agents$1();
 init_cost_sync();
-init_tmux();
-const execFileAsync$13 = promisify(execFile);
+init_runtime_census();
 const BURN_WINDOW_MS = 1800 * 1e3;
 function buildAgentStatsSnapshot(options) {
 	const nowMs = options.nowMs ?? Date.now();
@@ -35116,27 +35165,19 @@ function getAgentStatsSnapshotEffect(deps = {}) {
 		});
 	});
 }
-function parseProcessTable(psTable) {
-	return psTable.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
-		const match = line.match(/^(\d+)\s+(\d+)\s+([0-9.]+)\s+(\d+)$/);
-		if (!match) return [];
-		return [{
-			pid: Number(match[1]),
-			ppid: Number(match[2]),
-			cpuPercent: Number(match[3]),
-			rssBytes: Number(match[4]) * 1024
-		}];
-	});
-}
 async function readBatchedProcessTable() {
-	const { stdout } = await execFileAsync$13("ps", ["-eo", "pid=,ppid=,pcpu=,rss="], { encoding: "utf8" });
-	return parseProcessTable(stdout);
+	return [...(await getRuntimeCensus()).processesByPid.values()].map((process) => ({
+		pid: process.pid,
+		ppid: process.ppid,
+		cpuPercent: process.cpuPercent,
+		rssBytes: process.rssBytes
+	}));
 }
 function defaultListSessionNames() {
-	return listSessions().pipe(Effect.map((sessions) => sessions.map((session) => session.name)));
+	return Effect.promise(async () => [...(await getRuntimeCensus()).sessionNames]);
 }
 function defaultListPanePids(sessionName) {
-	return listPaneValues(sessionName, "#{pane_pid}").pipe(Effect.map((values) => values.map((value) => Number(value.trim())).filter((value) => Number.isFinite(value) && value > 0)));
+	return Effect.promise(async () => panePidsForSession(await getRuntimeCensus(), sessionName));
 }
 function buildProcessTotalsByRoot(roots, processes) {
 	const processByPid = new Map(processes.map((process) => [process.pid, process]));
@@ -35165,7 +35206,7 @@ function buildProcessTotalsByRoot(roots, processes) {
 		}
 		totals.set(root.rootPid, {
 			processCount: seen.size,
-			cpuPercent: roundOneDecimal$3(cpuPercent),
+			cpuPercent: roundOneDecimal$2(cpuPercent),
 			memoryBytes
 		});
 	}
@@ -35199,7 +35240,7 @@ function getIdleMinutes(lastActivity, nowMs) {
 	if (!Number.isFinite(lastActivityMs)) return 0;
 	return Math.max(0, Math.floor((nowMs - lastActivityMs) / 6e4));
 }
-function roundOneDecimal$3(value) {
+function roundOneDecimal$2(value) {
 	return Math.round(value * 10) / 10;
 }
 function roundCurrency(value) {
@@ -35207,7 +35248,6 @@ function roundCurrency(value) {
 }
 //#endregion
 //#region services/event-loop-monitor.ts
-init_activity_logger();
 const EVENT_LOOP_MONITOR_WINDOW_MS = 6e4;
 let lastSample = {
 	p50: 0,
@@ -35227,7 +35267,6 @@ function sampleEventLoopDelay(histogram, deps = {}) {
 	const warnThresholdMs = deps.warnThresholdMs ?? 100;
 	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
 	const warn = deps.warn ?? ((message) => console.warn(message));
-	const emit = deps.emit ?? emitActivityEntrySync;
 	const sample = {
 		p50: nsToRoundedMs(histogram.percentile(50)),
 		p99: nsToRoundedMs(histogram.percentile(99)),
@@ -35237,16 +35276,7 @@ function sampleEventLoopDelay(histogram, deps = {}) {
 		windowMs: EVENT_LOOP_MONITOR_WINDOW_MS
 	};
 	lastSample = sample;
-	if (sample.p99 > warnThresholdMs) {
-		const message = `Dashboard event loop p99 delay ${sample.p99}ms exceeded ${warnThresholdMs}ms`;
-		warn(`[event-loop-monitor] ${message}`);
-		emit({
-			source: "dashboard",
-			level: "warn",
-			message,
-			details: `p50=${sample.p50}ms p99=${sample.p99}ms max=${sample.max}ms over ${sample.windowMs}ms`
-		});
-	}
+	if (sample.p99 > warnThresholdMs) warn(`[event-loop-monitor] Dashboard event loop p99 delay ${sample.p99}ms exceeded ${warnThresholdMs}ms`);
 	histogram.reset();
 	return sample;
 }
@@ -35357,7 +35387,7 @@ function aggregateSupportFleet(processes) {
 	const supportProcesses = processes.filter(isSupportFleetProcess);
 	const members = supportProcesses.map((process) => process.command);
 	return {
-		cpuPercent: roundOneDecimal$2(supportProcesses.reduce((sum, process) => sum + process.cpuPercent, 0)),
+		cpuPercent: roundOneDecimal$1(supportProcesses.reduce((sum, process) => sum + process.cpuPercent, 0)),
 		memoryBytes: supportProcesses.reduce((sum, process) => sum + process.memoryBytes, 0),
 		memberCount: supportProcesses.length,
 		members
@@ -35384,7 +35414,7 @@ function formatDuration(totalSeconds) {
 	if (minutes > 0) return `${minutes}m ${seconds}s`;
 	return `${seconds}s`;
 }
-function roundOneDecimal$2(value) {
+function roundOneDecimal$1(value) {
 	return Math.round(value * 10) / 10;
 }
 //#endregion
@@ -35410,7 +35440,7 @@ function buildCapacityForecast(stacks, options) {
 		}),
 		headroom: {
 			freeRamBytes: options.hostVitals.mem.availableBytes,
-			loadHeadroom: Math.max(0, 100 - options.hostVitals.cpu.percent)
+			loadHeadroom: options.hostVitals.cpu.percent === null ? null : Math.max(0, 100 - options.hostVitals.cpu.percent)
 		}
 	};
 }
@@ -35481,8 +35511,8 @@ function buildHostProcesses(processes, options = {}) {
 		const row = {
 			...group,
 			pids: group.pids.sort((a, b) => a - b),
-			cpuPercent: roundOneDecimal$1(group.cpuPercent),
-			peakCpuPercent: roundOneDecimal$1(peakCpuPercent),
+			cpuPercent: roundOneDecimal(group.cpuPercent),
+			peakCpuPercent: roundOneDecimal(peakCpuPercent),
 			peakMemoryBytes
 		};
 		if (peakCpuPercent >= burstCpuThreshold) retainedBursts.set(group.id, {
@@ -35557,7 +35587,7 @@ function selectTopRows(rows, limit) {
 	for (const row of [...topByCpu, ...topByMemory]) merged.set(row.id, row);
 	return [...merged.values()].sort((a, b) => b.cpuPercent - a.cpuPercent || b.peakCpuPercent - a.peakCpuPercent).slice(0, limit);
 }
-function roundOneDecimal$1(value) {
+function roundOneDecimal(value) {
 	return Math.round(value * 10) / 10;
 }
 //#endregion
@@ -35575,12 +35605,20 @@ let cachedDockerCounts = {
 	}
 };
 function buildHostVitalsSnapshot(options = {}) {
-	const cpuPercent = roundOneDecimal(options.cpuPercent ?? 0);
-	cpuSpark.push(cpuPercent);
-	cpuSpark = cpuSpark.slice(-CPU_SPARK_MAX);
+	const metrics = options.hostMetrics;
+	const cpuPercent = metrics?.cpuPercent ?? null;
+	if (cpuPercent !== null) {
+		cpuSpark.push(cpuPercent);
+		cpuSpark = cpuSpark.slice(-CPU_SPARK_MAX);
+	}
 	const dockerCounts = options.dockerStale ? cachedDockerCounts : computeDockerCounts(options.containers ?? [], options.networkCount ?? 0, options.networkPoolTotal ?? 31);
 	if (!options.dockerStale) cachedDockerCounts = dockerCounts;
-	const memory = options.mem ?? getDefaultMemoryVitals();
+	const memory = {
+		usedBytes: metrics?.usedMemoryBytes ?? null,
+		availableBytes: metrics?.availableMemoryBytes ?? null,
+		swapUsedBytes: metrics?.swapUsedBytes ?? null,
+		swapTotalBytes: metrics?.swapTotalBytes ?? null
+	};
 	const disk = options.disk ?? {
 		usedBytes: 0,
 		freeBytes: 0,
@@ -35591,7 +35629,11 @@ function buildHostVitalsSnapshot(options = {}) {
 		stale: options.dockerStale === true,
 		cpu: {
 			percent: cpuPercent,
-			load: options.load ?? normalizeLoad(loadavg$1()),
+			load: [
+				metrics?.loadAverage1m ?? null,
+				null,
+				null
+			],
 			spark: [...cpuSpark]
 		},
 		mem: memory,
@@ -35637,26 +35679,6 @@ function computeAgentCounts(agents, fleet, nowMs) {
 		totalUsd: fleet.totalUsd ?? 0
 	};
 }
-function getDefaultMemoryVitals() {
-	const total = totalmem$1();
-	const available = freemem$1();
-	return {
-		usedBytes: Math.max(0, total - available),
-		availableBytes: available,
-		swapUsedBytes: 0,
-		swapTotalBytes: 0
-	};
-}
-function normalizeLoad(load) {
-	return [
-		roundOneDecimal(load[0] ?? 0),
-		roundOneDecimal(load[1] ?? 0),
-		roundOneDecimal(load[2] ?? 0)
-	];
-}
-function roundOneDecimal(value) {
-	return Math.round(value * 10) / 10;
-}
 //#endregion
 //#region routes/resources/limits.ts
 const OOM_WINDOW_MS = 1440 * 60 * 1e3;
@@ -35767,52 +35789,122 @@ function isClosedReviewStatus(issueId) {
 }
 //#endregion
 //#region routes/resources/spawn-gate.ts
-let readSystemHealthSnapshot = () => getSystemHealthSnapshot();
-function mapSpawnGateDecision(decision) {
-	const reason = decision.error ?? decision.warnings[0]?.message ?? "";
+let readSystemHealthEvidenceSnapshot = () => getSystemHealthEvidenceSnapshot();
+function mapSpawnGateDecision(decision, accepted) {
+	if (decision.health.freshness.status !== "fresh") {
+		const reason = decision.health.freshness.status === "stale" ? {
+			code: "admission.snapshot.stale",
+			domain: "admission",
+			severity: "critical",
+			message: decision.error ?? `Spawn gate health is stale: ${decision.health.freshness.reason.message}`
+		} : {
+			code: "admission.snapshot.measuring",
+			domain: "admission",
+			severity: "info",
+			message: decision.error ?? "Spawn gate health is still measuring."
+		};
+		return unavailableSpawnGate(accepted ?? null, reason, decision.warnings);
+	}
+	const admission = accepted?.admission;
+	const state = admission ? strongestAdmissionState(admission.state, decision.blocked ? "blocked" : decision.requiresAcknowledgement ? "soft" : "open") : decision.blocked ? "blocked" : decision.requiresAcknowledgement ? "soft" : "open";
+	const reasons = mergeAdmissionReasons(admission?.reasons ?? [], decision.warnings.map((warning) => ({
+		code: warning.code,
+		domain: "admission",
+		severity: warning.severity,
+		message: warning.message
+	})));
 	return {
-		state: decision.blocked ? "BLOCKED" : decision.requiresAcknowledgement ? "SOFT" : "OPEN",
-		reason,
+		state,
+		reason: decision.error ?? decision.warnings[0]?.message ?? reasons[0]?.message ?? "",
+		reasons,
+		admittedWorkAgentCount: admission?.admittedWorkAgentCount ?? decision.health.summary.workAgentCount,
 		warnings: decision.warnings,
-		pressure: spawnGatePressure(decision)
+		pressure: spawnGatePressure(state)
 	};
 }
-function getSpawnGatePayloadEffect() {
+function getResourcesHealthEvidenceEffect() {
 	return Effect.tryPromise({
-		try: () => readSystemHealthSnapshot(),
+		try: () => readSystemHealthEvidenceSnapshot(),
 		catch: (error) => error
-	}).pipe(Effect.map((health) => mapSpawnGateDecision(evaluateSpawnGuardrails(health))), Effect.catch(() => Effect.succeed({
-		state: "SOFT",
-		reason: "Spawn gate health is unavailable.",
-		warnings: [],
+	}).pipe(Effect.map(({ accepted, compatibility }) => ({
+		accepted,
+		decision: evaluateSpawnGuardrails(compatibility)
+	})), Effect.catch(() => Effect.succeed({
+		accepted: null,
+		decision: null
+	})));
+}
+function getSpawnGatePayloadEffect(evidence) {
+	return (evidence ? Effect.succeed(evidence) : getResourcesHealthEvidenceEffect()).pipe(Effect.map(({ accepted, decision }) => {
+		if (!accepted || !decision) return unavailableSpawnGate(accepted);
+		return mapSpawnGateDecision(decision, accepted);
+	}));
+}
+function unavailableSpawnGate(accepted, unavailableReason, warnings = []) {
+	const reasons = unavailableReason ? [unavailableReason] : accepted?.admission.reasons.length ? [...accepted.admission.reasons] : [{
+		code: "admission.snapshot.unavailable",
+		domain: "admission",
+		severity: "critical",
+		message: "Spawn gate health is unavailable."
+	}];
+	return {
+		state: "unavailable",
+		reason: reasons[0]?.message ?? "Spawn gate health is unavailable.",
+		reasons,
+		admittedWorkAgentCount: accepted?.admission.admittedWorkAgentCount ?? null,
+		warnings,
 		pressure: 0,
 		stale: true
-	})));
+	};
 }
-function spawnGatePressure(decision) {
-	if (decision.blocked) return 100;
-	if (decision.requiresAcknowledgement) return 67;
-	return 12;
+function mergeAdmissionReasons(...reasonGroups) {
+	const seen = /* @__PURE__ */ new Set();
+	return reasonGroups.flatMap((reasons) => reasons).filter((reason) => {
+		const key = `${reason.code}::${reason.message}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function strongestAdmissionState(accepted, enforced) {
+	if (accepted === "unavailable") return accepted;
+	const rank = {
+		open: 0,
+		soft: 1,
+		blocked: 2
+	};
+	return rank[accepted] >= rank[enforced] ? accepted : enforced;
+}
+function spawnGatePressure(state) {
+	if (state === "blocked") return 100;
+	if (state === "soft") return 67;
+	if (state === "open") return 12;
+	return 0;
 }
 //#endregion
 //#region routes/resources/snapshot.ts
 init_agents$1();
-init_tmux();
-/** Build the GET /api/resources response from the SQLite agents table. */
-function getResourcesEffect() {
+init_runtime_census();
+const RESOURCES_SNAPSHOT_INTERVAL_MS = 3e3;
+let resourcesSnapshotJson = null;
+let resourcesSnapshotRefresh = null;
+let resourcesSnapshotTimer = null;
+/** Build the resources payload from cached collectors and the SQLite agents table. */
+function buildResourcesPayloadEffect() {
 	return Effect.gen(function* () {
 		const containers = enrichContainersWithLimits(getCurrentDockerStats());
 		const agentStats = yield* getAgentStatsSnapshotEffect();
-		const spawnGate = yield* getSpawnGatePayloadEffect();
+		const healthEvidence = yield* getResourcesHealthEvidenceEffect();
+		const spawnGate = yield* getSpawnGatePayloadEffect(healthEvidence);
 		const stoppedContainers = [];
-		const sessions = yield* listSessions().pipe(Effect.catch(() => Effect.succeed([])));
-		const tmuxSessionNames = new Set(sessions.map((s) => s.name));
+		const tmuxSessionNames = (yield* Effect.promise(() => getRuntimeCensus()).pipe(Effect.catch(() => Effect.succeed(null))))?.sessionNames ?? /* @__PURE__ */ new Set();
 		const agents = listAgentStates().filter((state) => state.status !== "stopped").map((state) => ({
 			...state,
 			hasLiveTmuxSession: tmuxSessionNames.has(state.id)
 		}));
 		const agentStatsById = new Map(agentStats.agents.map((agent) => [agent.id, agent]));
 		const baseHostVitals = buildHostVitalsSnapshot({
+			hostMetrics: healthEvidence.accepted?.host.metrics,
 			containers,
 			agents: agents.map((agent) => ({
 				id: String(agent.id),
@@ -35830,7 +35922,7 @@ function getResourcesEffect() {
 				reclaimableBytes: reclaim.reclaimTotals.diskBytes
 			}
 		};
-		return jsonResponse({
+		return {
 			agents: agents.map((agent) => ({
 				...agent,
 				resourceStats: agentStatsById.get(String(agent.id)) ?? null
@@ -35849,10 +35941,39 @@ function getResourcesEffect() {
 			stacks,
 			volumes: [],
 			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
+		};
+	});
+}
+function refreshResourcesSnapshot() {
+	if (resourcesSnapshotRefresh) return resourcesSnapshotRefresh;
+	resourcesSnapshotRefresh = Effect.runPromise(buildResourcesPayloadEffect()).then((payload) => {
+		resourcesSnapshotJson = JSON.stringify(payload);
+	}).finally(() => {
+		resourcesSnapshotRefresh = null;
 	});
+	return resourcesSnapshotRefresh;
+}
+function getResourcesSnapshotEffect() {
+	return Effect.sync(() => resourcesSnapshotJson ? jsonStringResponse(resourcesSnapshotJson) : jsonResponse({ error: "Resources snapshot is warming" }, 503));
 }
-const getResourcesRoute = HttpRouter.add("GET", "/api/resources", httpHandler(getResourcesEffect()));
+function startResourcesSnapshotService() {
+	if (resourcesSnapshotTimer) return stopResourcesSnapshotService;
+	refreshResourcesSnapshot().catch((error) => {
+		console.warn("[resources-snapshot] initial refresh failed:", error instanceof Error ? error.message : error);
+	});
+	resourcesSnapshotTimer = setInterval(() => {
+		refreshResourcesSnapshot().catch((error) => {
+			console.warn("[resources-snapshot] refresh failed; keeping last-good snapshot:", error instanceof Error ? error.message : error);
+		});
+	}, RESOURCES_SNAPSHOT_INTERVAL_MS);
+	resourcesSnapshotTimer.unref?.();
+	return stopResourcesSnapshotService;
+}
+function stopResourcesSnapshotService() {
+	if (resourcesSnapshotTimer) clearInterval(resourcesSnapshotTimer);
+	resourcesSnapshotTimer = null;
+}
+const getResourcesRoute = HttpRouter.add("GET", "/api/resources", httpHandler(getResourcesSnapshotEffect()));
 //#endregion
 //#region routes/resources/containers.ts
 init_domain_services();
@@ -38292,7 +38413,7 @@ async function fetchPlanningData(issueId, options = {}) {
 		}
 	} catch {}
 	if (!hasPlanningDir && !hasPanContinue) {
-		const prd = await readPrdContent(findPrdAtStatusSync(projectPath, issueId, "active"));
+		const prd = await readPrdContent(findPrdAnywhereSync(projectPath, issueId));
 		if (prd) {
 			result.prd = prd;
 			result.hasPrd = true;
@@ -38320,16 +38441,11 @@ async function fetchPlanningData(issueId, options = {}) {
 		const fileStat = await stat$1(statusReviewPath).catch(() => null);
 		if (fileStat) result.statusReviewedAt = fileStat.mtime.toISOString();
 	}
-	if (!result.prd) for (const status of [
-		"active",
-		"planned",
-		"completed"
-	]) {
-		const content = await readPrdContent(findPrdAtStatusSync(projectPath, issueId, status));
+	if (!result.prd) {
+		const content = await readPrdContent(findPrdAnywhereSync(projectPath, issueId));
 		if (content) {
 			result.prd = content;
 			result.hasPrd = true;
-			break;
 		}
 	}
 	if (!result.prd && result.state) result.prd = result.state;
@@ -38532,7 +38648,7 @@ ${issueContext ? `\n${issueContext}\n` : ""}
 - Review: ${reviewStatus}
 - Tests: ${testStatus}
 
-## Planning Context (continue.vbrief.json)
+## Planning Context (.overdeck/continue.json)
 ${state ? state.slice(0, 4e3) : "(No planning state available)"}
 
 ## Files Changed
@@ -38574,7 +38690,7 @@ Be specific: reference actual file names, function names, requirement text, disc
 	const { command: cliCmd, args: cliArgs } = getAgentCommandSync(statusModelId);
 	const modelFlag = cliArgs.length > 0 ? ` ${cliArgs.join(" ")}` : "";
 	const promptFile = join(planningDir, ".status-review-prompt.tmp");
-	const { getProviderForModelSync, getProviderEnvSync } = await import("./providers-BqCdTryq.js");
+	const { getProviderForModelSync, getProviderEnvSync } = await import("./providers-DKkBXhxU.js");
 	let providerEnvStr = "";
 	let providerEnv = {};
 	const statusProvider = getProviderForModelSync(statusModelId);
@@ -38657,7 +38773,7 @@ const postMissionControlUploadRoute = HttpRouter.add("POST", "/api/command-deck/
 	let safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "-");
 	let processedContent = content;
 	if (safeName.endsWith(".vtt")) {
-		const { vttToMarkdown } = yield* Effect.promise(() => import("./vtt-parser-3VZKsmSm.js"));
+		const { vttToMarkdown } = yield* Effect.promise(() => import("./vtt-parser-DKpNNW5i.js"));
 		processedContent = vttToMarkdown(content);
 		safeName = safeName.replace(/\.vtt$/, ".md");
 	}
@@ -44484,7 +44600,7 @@ const postRallyValidateRoute = HttpRouter.add("POST", "/api/rally/validate", Eff
 	}, { status: 400 });
 	return yield* Effect.promise(async () => {
 		try {
-			const { RallyRestApi } = await import("./rally-api-CKr0O4DJ.js");
+			const { RallyRestApi } = await import("./rally-api-yjQ0TfHd.js");
 			const api = new RallyRestApi({
 				apiKey,
 				server: server || "https://rally1.rallydev.com"
@@ -44516,15 +44632,9 @@ const postRallyValidateRoute = HttpRouter.add("POST", "/api/rally/validate", Eff
 const trackersRouteLayer = Layer.mergeAll(postTrackersRefreshRoute, getTrackerStatusRoute, postRallyValidateRoute);
 //#endregion
 //#region ../lib/health-filtering.ts
-/**
-* Health filtering logic for dashboard health API
-* Determines which agents should be visible in health checks
-*/
-init_config$1();
 init_tmux();
-const KICKOFF_STALL_GRACE_MS = 300 * 1e3;
 /**
-* Check if agent tmux session is alive
+* Check if agent tmux session is alive.
 */
 const checkAgentHealth = (agentId) => Effect.gen(function* () {
 	if (!(yield* sessionExists(agentId))) return { alive: false };
@@ -44533,133 +44643,196 @@ const checkAgentHealth = (agentId) => Effect.gen(function* () {
 		lastOutput: (yield* capturePane(agentId, 5)).trim()
 	};
 }).pipe(Effect.catch(() => Effect.succeed({ alive: false })));
-/**
-* Determine health status based on activity
-* Returns null if agent should be hidden (completed/stopped/no state.json)
-*
-* `liveSessions` is REQUIRED — pass the session list fetched once per request.
-* Iterating ~150 agent dirs and spawning a tmux subprocess per agent was pinning
-* the dashboard process at 100% CPU on every 5s `/api/health/agents` poll.
-* State is also read before the tmux check so stopped/completed/missing
-* agents short-circuit without any extra work.
-*/
-const determineHealthStatus = (agentId, stateFile, liveSessions) => Effect.gen(function* () {
-	let agentStatus;
-	let lastActivity = null;
-	let contextSaturatedAt;
-	if (!existsSync(stateFile)) return null;
-	const state = yield* Effect.tryPromise({
-		try: () => readFile$1(stateFile, "utf-8").then((content) => JSON.parse(content)),
-		catch: () => null
-	}).pipe(Effect.catch(() => Effect.succeed(null)));
-	if (state === null) return null;
-	agentStatus = state.status;
-	lastActivity = state.lastActivity ? new Date(state.lastActivity) : null;
-	if (!agentStatus) return null;
-	if (agentStatus === "stopped" || agentStatus === "completed") return null;
-	const runtimeFile = stateFile.replace("state.json", "runtime.json");
-	if (existsSync(runtimeFile)) {
-		const runtime = yield* Effect.tryPromise({
-			try: () => readFile$1(runtimeFile, "utf-8").then((content) => JSON.parse(content)),
-			catch: () => null
-		}).pipe(Effect.catch(() => Effect.succeed(null)));
-		if (runtime?.lastActivity) {
-			const runtimeDate = new Date(runtime.lastActivity);
-			if (!lastActivity || runtimeDate > lastActivity) lastActivity = runtimeDate;
-		}
-		if (runtime?.contextSaturatedAt) contextSaturatedAt = runtime.contextSaturatedAt;
-	}
-	if (!liveSessions.has(agentId)) {
-		const STALE_THRESHOLD_MS = ((yield* loadCloisterConfig()).retention?.health_staleness_hours ?? 24) * 60 * 60 * 1e3;
-		if (lastActivity) {
-			if (Date.now() - lastActivity.getTime() > STALE_THRESHOLD_MS) return null;
-		} else return null;
-		return {
-			status: "dead",
-			reason: "Agent crashed unexpectedly"
-		};
-	}
-	if (contextSaturatedAt) return {
-		status: "wedged",
-		reason: "Context window exhausted (400) — recovery in progress"
-	};
-	const startedAtMs = typeof state.startedAt === "string" ? Date.parse(state.startedAt) : NaN;
-	if (state.role === "work" && agentStatus === "running" && state.kickoffDelivered === false && Number.isFinite(startedAtMs) && Date.now() - startedAtMs > KICKOFF_STALL_GRACE_MS) return {
-		status: "stalled",
-		reason: "Work agent running with no kickoff delivered since spawn"
-	};
-	if (lastActivity) {
-		const ageMinutes = (Date.now() - lastActivity.getTime()) / (1e3 * 60);
-		if (ageMinutes > 30) return {
-			status: "stuck",
-			reason: `No activity for ${Math.round(ageMinutes)} minutes`
-		};
-		else if (ageMinutes > 15) return {
-			status: "warning",
-			reason: `Low activity (${Math.round(ageMinutes)} minutes)`
-		};
-	}
-	return { status: "healthy" };
-});
 //#endregion
 //#region routes/misc/health.ts
-init_agents$1();
-init_tmux();
+init_src();
+init_review_status_source();
+init_paths();
+init_runtime_census();
 init_read_model();
-const getSystemHealthRoute = HttpRouter.add("GET", "/api/system/health", httpHandler(Effect.gen(function* () {
-	return jsonResponse(yield* (yield* ReadModelService).getSnapshot.pipe(Effect.flatMap((snapshot) => Effect.promise(() => getSystemHealthSnapshot(snapshot)))));
-})));
-const getGodviewSystemHealthRoute = HttpRouter.add("GET", "/api/godview/system-health", httpHandler(Effect.gen(function* () {
-	const health = yield* (yield* ReadModelService).getSnapshot.pipe(Effect.flatMap((snapshot) => Effect.promise(() => getSystemHealthSnapshot(snapshot))));
+function readHealthSessionNames(readSnapshot = getRuntimeCensusSnapshot) {
+	const census = readSnapshot();
+	if (!census) throw new Error("Runtime census snapshot is warming");
+	return [...census.sessionNames];
+}
+function unavailableSystemHealthResponse() {
 	return jsonResponse({
-		cpu: health.summary.cpuPercent,
-		memPercent: health.summary.memoryUsedPercent,
-		memUsed: health.summary.usedMemoryBytes,
-		memTotal: health.summary.totalMemoryBytes,
-		updatedAt: health.updatedAt
+		status: "unavailable",
+		reasons: [{
+			code: "system.health_snapshot.unavailable",
+			domain: "host",
+			severity: "critical",
+			message: "The accepted system health snapshot could not be produced or decoded."
+		}]
+	}, { status: 503 });
+}
+function decodeAcceptedSystemHealth(value) {
+	const decoded = Schema.decodeUnknownResult(SystemHealthSnapshot)(value);
+	if (decoded._tag === "Failure") throw new Error("The accepted system health snapshot failed shared-contract decoding.");
+	return decoded.success;
+}
+function buildSystemHealthResponse(dependencies) {
+	return dependencies.snapshot.pipe(Effect.map((snapshot) => jsonResponse(decodeAcceptedSystemHealth(snapshot))), Effect.catchCause(() => Effect.succeed(unavailableSystemHealthResponse())));
+}
+function buildGodviewSystemHealthResponse(dependencies) {
+	return dependencies.snapshot.pipe(Effect.map((snapshot) => {
+		const health = decodeAcceptedSystemHealth(snapshot);
+		return jsonResponse({
+			...health,
+			cpu: health.summary.cpuPercent,
+			memPercent: health.summary.memoryUsedPercent,
+			memUsed: health.summary.usedMemoryBytes,
+			memTotal: health.summary.totalMemoryBytes,
+			updatedAt: health.updatedAt
+		});
+	}), Effect.catchCause(() => Effect.succeed(unavailableSystemHealthResponse())));
+}
+const getSystemHealthRoute = HttpRouter.add("GET", "/api/system/health", httpHandler(buildSystemHealthResponse({ snapshot: Effect.promise(() => getAcceptedSystemHealthSnapshot()) })));
+const getGodviewSystemHealthRoute = HttpRouter.add("GET", "/api/godview/system-health", httpHandler(buildGodviewSystemHealthResponse({ snapshot: Effect.promise(() => getAcceptedSystemHealthSnapshot()) })));
+const getDeployStalenessRoute = HttpRouter.add("GET", "/api/deploy/staleness", Effect.promise(async () => jsonResponse(await getDeployStaleness())));
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+async function readAgentHealthObservations(agentId) {
+	if (!/^[A-Za-z0-9._-]+$/.test(agentId) || agentId.includes("..")) return {};
+	const agentDir = join(getOverdeckHome(), "agents", agentId);
+	const observations = {};
+	try {
+		const stored = JSON.parse(await readFile(join(agentDir, "health.json"), "utf-8"));
+		if (stored && typeof stored === "object" && !Array.isArray(stored)) {
+			const record = stored;
+			const consecutiveFailures = finiteNumber(record["consecutiveFailures"]);
+			const killCount = finiteNumber(record["killCount"]);
+			if (consecutiveFailures !== void 0) observations.consecutiveFailures = consecutiveFailures;
+			if (killCount !== void 0) observations.killCount = killCount;
+		}
+	} catch {}
+	try {
+		const raw = (await readFile(join(agentDir, "context-pct"), "utf-8")).trim();
+		const contextPercent = raw === "" ? NaN : Number(raw);
+		if (Number.isFinite(contextPercent)) observations.contextPercent = contextPercent;
+	} catch {}
+	return observations;
+}
+function runtimeHealthState(runtime) {
+	if (!runtime) return null;
+	switch (runtime.activity) {
+		case "working":
+		case "thinking": return {
+			state: "active",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "waiting": return {
+			state: "waiting-on-human",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "idle": return {
+			state: "idle",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "stopped": return {
+			state: "stopped",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+	}
+}
+function decodeReviewStatuses(value) {
+	const statuses = /* @__PURE__ */ new Map();
+	for (const candidate of value ?? []) {
+		const decoded = Schema.decodeUnknownResult(ReviewStatusSnapshot)(candidate);
+		if (decoded._tag === "Success") statuses.set(decoded.success.issueId.toUpperCase(), decoded.success);
+	}
+	return statuses;
+}
+function reviewLifecycle(agent, statuses, tmuxActive) {
+	if (agent.role !== "review" && agent.role !== "test" && agent.role !== "ship") return "unknown";
+	return classifyAdvancingSessionLifecycle(agent.role, statuses.get(agent.issueId.toUpperCase()), tmuxActive);
+}
+function snapshotSource(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("The canonical read model did not return an object.");
+	const candidate = value;
+	if (!Array.isArray(candidate["agents"])) throw new Error("The canonical read model did not return an agent array.");
+	return {
+		agents: candidate["agents"],
+		agentRuntimeById: candidate["agentRuntimeById"],
+		reviewStatuses: Array.isArray(candidate["reviewStatuses"]) ? candidate["reviewStatuses"] : void 0
+	};
+}
+function runtimeRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function projectAgentHealth(snapshotValue, sessionNames, readObservations, nowMs) {
+	const snapshot = snapshotSource(snapshotValue);
+	const liveSessions = new Set(sessionNames);
+	const runtimes = runtimeRecord(snapshot.agentRuntimeById);
+	const reviewStatuses = decodeReviewStatuses(snapshot.reviewStatuses);
+	return Promise.all(snapshot.agents.map(async (candidate, index) => {
+		const decoded = Schema.decodeUnknownResult(AgentSnapshot)(candidate);
+		if (decoded._tag === "Failure") {
+			const candidateId = candidate && typeof candidate === "object" && !Array.isArray(candidate) ? candidate["id"] : void 0;
+			return classifyAgentHealth({
+				agentId: typeof candidateId === "string" ? candidateId : `unavailable-agent-${index + 1}`,
+				persisted: {
+					status: "unavailable",
+					reason: "The canonical agent snapshot could not be decoded."
+				},
+				runtime: null,
+				liveSessions,
+				reviewLifecycle: "unknown",
+				nowMs
+			});
+		}
+		const agent = decoded.success;
+		const runtimeCandidate = Schema.decodeUnknownResult(AgentRuntimeSnapshot)(runtimes[agent.id]);
+		const runtime = runtimeCandidate._tag === "Success" ? runtimeCandidate.success : null;
+		const observations = await readObservations(agent.id).catch(() => ({}));
+		return classifyAgentHealth({
+			agentId: agent.id,
+			persisted: {
+				status: "available",
+				value: {
+					id: agent.id,
+					issueId: agent.issueId,
+					role: agent.role,
+					status: agent.status,
+					startedAt: agent.startedAt,
+					lastActivity: agent.lastActivity,
+					paused: agent.paused,
+					stoppedByUser: agent.stoppedByUser,
+					consecutiveFailures: agent.consecutiveFailures
+				}
+			},
+			runtime: runtimeHealthState(runtime),
+			liveSessions,
+			reviewLifecycle: reviewLifecycle(agent, reviewStatuses, liveSessions.has(agent.id)),
+			observations,
+			nowMs
+		});
+	}));
+}
+function buildHealthAgentsResponse(dependencies) {
+	return Effect.all({
+		snapshot: dependencies.snapshot,
+		sessionNames: dependencies.sessionNames
+	}).pipe(Effect.flatMap(({ snapshot, sessionNames }) => Effect.promise(async () => jsonResponse(await projectAgentHealth(snapshot, sessionNames, dependencies.readObservations ?? readAgentHealthObservations, dependencies.nowMs ?? Date.now())))), Effect.catchCause(() => Effect.succeed(jsonResponse({
+		status: "unavailable",
+		reasons: [{
+			code: "agent.health_snapshot.unavailable",
+			domain: "agent",
+			severity: "critical",
+			message: "The canonical agent health snapshot could not be loaded."
+		}]
+	}, { status: 503 }))));
+}
+const getHealthAgentsRoute = HttpRouter.add("GET", "/api/health/agents", Effect.gen(function* () {
+	return yield* buildHealthAgentsResponse({
+		snapshot: (yield* ReadModelService).getSnapshot,
+		sessionNames: Effect.sync(() => readHealthSessionNames())
 	});
-})));
-const getHealthAgentsRoute = HttpRouter.add("GET", "/api/health/agents", Effect.promise(async () => {
-	try {
-		const agentsDir = join(homedir$1(), ".overdeck", "agents");
-		if (!existsSync$1(agentsDir)) return jsonResponse([]);
-		const agentNames = (await readdir(agentsDir)).filter((name) => name.startsWith("agent-") || name.startsWith("planning-") || name.startsWith("specialist-"));
-		const liveSessions = new Set(await Effect.runPromise(listSessionNames()));
-		return jsonResponse((await Promise.all(agentNames.map(async (name) => {
-			const stateFile = getAgentStateFilePath(name);
-			const healthFile = join(agentsDir, name, "health.json");
-			const healthStatus = await Effect.runPromise(determineHealthStatus(name, stateFile, liveSessions));
-			if (!healthStatus) return null;
-			let storedHealth = {
-				consecutiveFailures: 0,
-				killCount: 0
-			};
-			try {
-				const healthContent = await readFile(healthFile, "utf-8");
-				storedHealth = {
-					...storedHealth,
-					...JSON.parse(healthContent)
-				};
-			} catch {}
-			let contextPercent = null;
-			try {
-				const ctxContent = await readFile(join(agentsDir, name, "context-pct"), "utf-8");
-				contextPercent = parseInt(ctxContent.trim(), 10) || null;
-			} catch {}
-			return {
-				agentId: name,
-				status: healthStatus.status,
-				reason: healthStatus.reason,
-				lastPing: (/* @__PURE__ */ new Date()).toISOString(),
-				consecutiveFailures: storedHealth.consecutiveFailures,
-				killCount: storedHealth.killCount,
-				contextPercent
-			};
-		}))).filter((agent) => agent !== null));
-	} catch (error) {
-		console.error("Error fetching health:", error);
-		return jsonResponse([]);
-	}
 }));
 const postHealthAgentPingRoute = HttpRouter.add("POST", "/api/health/agents/:id/ping", Effect.gen(function* () {
 	const request = yield* HttpServerRequest.HttpServerRequest;
@@ -44681,7 +44854,7 @@ const postHealthAgentPingRoute = HttpRouter.add("POST", "/api/health/agents/:id/
 		}
 	});
 }));
-const healthRouteLayer$1 = Layer.mergeAll(getSystemHealthRoute, getGodviewSystemHealthRoute, getHealthAgentsRoute, postHealthAgentPingRoute);
+const healthRouteLayer$1 = Layer.mergeAll(getSystemHealthRoute, getGodviewSystemHealthRoute, getDeployStalenessRoute, getHealthAgentsRoute, postHealthAgentPingRoute);
 //#endregion
 //#region routes/misc/deacon.ts
 init_control_settings();
@@ -44812,7 +44985,7 @@ const getPlanningStatusRoute = HttpRouter.add("GET", "/api/planning/:issueId/sta
 			const remoteState = loadRemoteAgentState(sessionName);
 			const isRemote = !!remoteState;
 			const vmName = remoteState?.vmName ?? "";
-			const { getAgentStateSync } = await import("./agents-Czz6R57Z.js");
+			const { getAgentStateSync } = await import("./agents-FlIgQ3ql.js");
 			const agentStarting = getAgentStateSync(sessionName)?.status === "starting";
 			let tmuxSessionAlive = false;
 			if (!isRemote) try {
@@ -44932,7 +45105,7 @@ const postPlanningMessageRoute = HttpRouter.add("POST", "/api/planning/:issueId/
 **YOU SHOULD ONLY:**
 - Ask clarifying questions
 - Explore the codebase to understand context
-- Generate planning artifacts (\`.pan/continue.json\`, \`.pan/spec.vbrief.json\`)
+- Generate planning artifacts (\`.overdeck/continue.json\`, \`.overdeck/spec.vbrief.json\`)
 - Present options and tradeoffs
 
 ---
@@ -44954,8 +45127,9 @@ ${message}
 Continue the PLANNING session. Do NOT implement anything.
 `);
 			const agentCwd = workspacePath;
+			const harnessLaunch = await prepareHarnessLaunch("claude-code");
 			if (existsSync$1(outputFile)) await rename(outputFile, join(planningDir, `output-${Date.now()}.jsonl`));
-			const { getAgentCommandSync } = await import("./settings-BaPXXJsT.js");
+			const { getAgentCommandSync } = await import("./settings-D0OSwos5.js");
 			let msgPlanningModel = "claude-sonnet-5";
 			try {
 				msgPlanningModel = resolveModel("plan", void 0, loadConfigSync().config);
@@ -44969,6 +45143,7 @@ Continue the PLANNING session. Do NOT implement anything.
 				role: "plan",
 				workingDir: agentCwd,
 				baseCommand: msgCmdWithArgs,
+				extraEnvExports: [harnessLaunch.pathExport],
 				appendSystemPromptFiles: await claudePlanningSystemPromptFiles(agentCwd),
 				promptInline: `Please read the continuation prompt at ${continuationPromptPath} and continue the planning session.`
 			}), { mode: 493 });
@@ -45076,7 +45251,7 @@ async function getIndexStats(rootPath, isMain) {
 }
 const getTldrStatusRoute = HttpRouter.add("GET", "/api/services/tldr/status", Effect.promise(async () => {
 	try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BJA7TkqS.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-DL566HbH.js");
 		const projectRoot = process.cwd();
 		const venvPath = join(projectRoot, ".venv");
 		const results = [];
@@ -45121,7 +45296,7 @@ const getTldrStatusRoute = HttpRouter.add("GET", "/api/services/tldr/status", Ef
 }));
 const postTldrStartRoute = HttpRouter.add("POST", "/api/services/tldr/start", Effect.promise(async () => {
 	try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BJA7TkqS.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-DL566HbH.js");
 		const projectRoot = process.cwd();
 		const venvPath = join(projectRoot, ".venv");
 		if (!existsSync$1(venvPath)) return jsonResponse({ error: "No .venv found in project root" }, { status: 404 });
@@ -45138,7 +45313,7 @@ const postTldrStartRoute = HttpRouter.add("POST", "/api/services/tldr/start", Ef
 }));
 const postTldrStopRoute = HttpRouter.add("POST", "/api/services/tldr/stop", Effect.promise(async () => {
 	try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BJA7TkqS.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-DL566HbH.js");
 		const projectRoot = process.cwd();
 		const venvPath = join(projectRoot, ".venv");
 		if (!existsSync$1(venvPath)) return jsonResponse({ error: "No .venv found in project root" }, { status: 404 });
@@ -45155,7 +45330,7 @@ const postTldrStopRoute = HttpRouter.add("POST", "/api/services/tldr/stop", Effe
 }));
 const postTldrReloadRoute = HttpRouter.add("POST", "/api/services/tldr/reload", Effect.promise(async () => {
 	try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BJA7TkqS.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-DL566HbH.js");
 		const enabled = isTldrEnabledSync();
 		const projectRoot = process.cwd();
 		const targets = [];
@@ -45343,7 +45518,7 @@ const getVersionRoute = HttpRouter.add("GET", "/api/version", Effect.promise(asy
 	const version = await getOverdeckVersion();
 	let supervisorUrl = null;
 	try {
-		const { getSupervisorUrlSync } = await import("./supervisor-Qy1QecAs.js");
+		const { getSupervisorUrlSync } = await import("./supervisor-BPy-o1A8.js");
 		supervisorUrl = getSupervisorUrlSync();
 	} catch {}
 	return jsonResponse({
@@ -45353,11 +45528,11 @@ const getVersionRoute = HttpRouter.add("GET", "/api/version", Effect.promise(asy
 	});
 }));
 const getPrerequisitesRoute = HttpRouter.add("GET", "/api/prerequisites", Effect.promise(async () => {
-	const { checkSystemPrerequisites } = await import("./system-prerequisites-DkoQBn1q.js");
+	const { checkSystemPrerequisites } = await import("./system-prerequisites-Bza0ffAh.js");
 	return jsonResponse(await checkSystemPrerequisites());
 }));
 const getSetupDiagnosticsRoute = HttpRouter.add("GET", "/api/diagnostics/setup", Effect.promise(async () => {
-	const { collectSetupDiagnostics } = await import("./system-prerequisites-DkoQBn1q.js");
+	const { collectSetupDiagnostics } = await import("./system-prerequisites-Bza0ffAh.js");
 	return jsonResponse(await collectSetupDiagnostics(await getOverdeckVersion()));
 }));
 const getSyncStatusRoute = HttpRouter.add("GET", "/api/sync-status", Effect.sync(() => {
@@ -45537,7 +45712,7 @@ const postShadowMonitorRoute = HttpRouter.add("POST", "/api/shadow/:issueId/moni
 			const projectPath = await getProjectPath(issuePrefix);
 			const workspacePath = join(projectPath, "workspaces", `feature-${issueLower}`);
 			if (!existsSync$1(workspacePath)) return jsonResponse({ error: "Workspace not found" }, { status: 404 });
-			const { gatherArtifacts, generateBasicInference, updateInferenceDocumentSync } = await import("./shadow-engineering-Bi_oIMtF.js");
+			const { gatherArtifacts, generateBasicInference, updateInferenceDocumentSync } = await import("./shadow-engineering-BlxG6Xye.js");
 			const config = {
 				issueId,
 				workspacePath,
@@ -45567,7 +45742,7 @@ const postShadowObserveRoute = HttpRouter.add("POST", "/api/shadow/:issueId/obse
 			if (!existsSync$1(workspacePath)) return jsonResponse({ error: "Workspace not found" }, { status: 404 });
 			const ghConfig = getGitHubConfig();
 			if (!ghConfig) return jsonResponse({ error: "GitHub not configured - Observer requires GitHub" }, { status: 400 });
-			const { runObserverCycle } = await import("./shadow-engineering-Bi_oIMtF.js");
+			const { runObserverCycle } = await import("./shadow-engineering-BlxG6Xye.js");
 			const firstRepo = ghConfig.repos[0];
 			const config = {
 				issueId,
@@ -46103,9 +46278,9 @@ const PAN_COMMANDS = [
 	},
 	{
 		name: "pan plan <id>",
-		description: "Plan an issue (interactive vBRIEF + tasks)",
+		description: "Plan an issue (interactive xBRIEF + tasks)",
 		group: "Issues",
-		keywords: ["planning", "vbrief"]
+		keywords: ["planning", "xbrief"]
 	},
 	{
 		name: "pan plan <id> --auto",
@@ -46807,6 +46982,17 @@ async function diffFilesSinceBase(repoRoot, baseCommit, filePaths) {
 	}
 	return diffs;
 }
+async function diffPatchForFiles(repoRoot, createdAt, filePaths) {
+	const baseCommit = await Effect.runPromise(findCommitAtTime(repoRoot, createdAt));
+	if (!baseCommit) return Effect.runPromise(diffPatchFilesAgainstHead(repoRoot, filePaths));
+	const quotedPaths = filePaths.map((p) => JSON.stringify(p)).join(" ");
+	const { stdout } = await promisify(exec)(`git diff --patch --minimal --no-color ${baseCommit} -- ${quotedPaths}`, {
+		cwd: repoRoot,
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	});
+	return stdout;
+}
 async function getConversationDiffs(name, deps) {
 	try {
 		const conv = lookupConversation(name);
@@ -46852,22 +47038,28 @@ async function getConversationDiffFull(name, deps) {
 		const conv = getConversationByName(name);
 		if (!conv) return result$1({ error: "Conversation not found" }, 404);
 		const cwd = conv.cwd;
-		if (existsSync$1(join(cwd, ".git"))) {
-			const baseCommit = await Effect.runPromise(findCommitAtTime(cwd, conv.createdAt));
-			if (!baseCommit) return result$1({ diff: "" });
-			return result$1({ diff: await Effect.runPromise(diffPatchSinceCommit(cwd, baseCommit)) });
+		const cwdRepoRoot = existsSync$1(join(cwd, ".git")) ? cwd : null;
+		const patches = [];
+		if (cwdRepoRoot) {
+			const baseCommit = await Effect.runPromise(findCommitAtTime(cwdRepoRoot, conv.createdAt));
+			if (baseCommit) {
+				const patch = await Effect.runPromise(diffPatchSinceCommit(cwdRepoRoot, baseCommit));
+				if (patch) patches.push(patch);
+			}
 		}
 		const sessionFile = await deps.resolveSessionFile(conv);
-		if (!sessionFile || !existsSync$1(sessionFile)) return result$1({ diff: "" });
+		if (!sessionFile || !existsSync$1(sessionFile)) return result$1({ diff: patches.join("\n") });
 		const { fileEditsByAssistantId } = await deps.getCachedMessages(sessionFile, false);
-		if (!fileEditsByAssistantId || fileEditsByAssistantId.size === 0) return result$1({ diff: "" });
+		if (!fileEditsByAssistantId || fileEditsByAssistantId.size === 0) return result$1({ diff: patches.join("\n") });
 		const repoRootCache = /* @__PURE__ */ new Map();
 		const filesByRepo = await groupFilesByRepo([...fileEditsByAssistantId.values()].flat(), repoRootCache);
-		const patches = [];
-		for (const [repoRoot, filePaths] of filesByRepo) try {
-			const patch = await Effect.runPromise(diffPatchFilesAgainstHead(repoRoot, filePaths));
-			if (patch) patches.push(patch);
-		} catch {}
+		for (const [repoRoot, filePaths] of filesByRepo) {
+			if (repoRoot === cwdRepoRoot) continue;
+			try {
+				const patch = await diffPatchForFiles(repoRoot, conv.createdAt, filePaths);
+				if (patch) patches.push(patch);
+			} catch {}
+		}
 		return result$1({ diff: patches.join("\n") });
 	} catch (error) {
 		const msg = error instanceof Error ? error.message : String(error);
@@ -46880,35 +47072,34 @@ async function getConversationDiffTurn(name, turnId, fileFilter, deps) {
 		const conv = lookupConversation(name);
 		if (!conv) return result$1({ error: "Conversation not found" }, 404);
 		const cwd = conv.cwd;
-		if (existsSync$1(join(cwd, ".git"))) {
-			const baseCommit = await Effect.runPromise(findCommitAtTime(cwd, conv.createdAt));
-			if (baseCommit) return result$1({
-				turnId,
-				diff: await Effect.runPromise(diffPatchSinceCommit(cwd, baseCommit, fileFilter))
-			});
+		const cwdRepoRoot = existsSync$1(join(cwd, ".git")) ? cwd : null;
+		const patches = [];
+		if (cwdRepoRoot) {
+			const baseCommit = await Effect.runPromise(findCommitAtTime(cwdRepoRoot, conv.createdAt));
+			if (baseCommit) {
+				const patch = await Effect.runPromise(diffPatchSinceCommit(cwdRepoRoot, baseCommit, fileFilter));
+				if (patch) patches.push(patch);
+			}
 		}
 		const assistantId = turnId.startsWith("conv-turn-") ? turnId.slice(10) : turnId;
 		const sessionFile = await deps.resolveSessionFile(conv);
-		if (!sessionFile || !existsSync$1(sessionFile)) return result$1({ diff: "" });
+		if (!sessionFile || !existsSync$1(sessionFile)) return result$1({
+			turnId,
+			diff: patches.join("\n")
+		});
 		const edits = (await deps.getCachedMessages(sessionFile, false)).fileEditsByAssistantId?.get(assistantId);
-		if (!edits || edits.length === 0) return result$1({ diff: "" });
+		if (!edits || edits.length === 0) return result$1({
+			turnId,
+			diff: patches.join("\n")
+		});
 		const filesByRepo = await groupFilesByRepo(edits, /* @__PURE__ */ new Map(), fileFilter);
-		const baseCommitByRepo = /* @__PURE__ */ new Map();
-		const patches = [];
-		for (const [repoRoot, filePaths] of filesByRepo) try {
-			if (!baseCommitByRepo.has(repoRoot)) baseCommitByRepo.set(repoRoot, await Effect.runPromise(findCommitAtTime(repoRoot, conv.createdAt)));
-			const baseCommit = baseCommitByRepo.get(repoRoot) ?? null;
-			let patch;
-			if (baseCommit) {
-				const { stdout } = await promisify(exec)(`git diff --patch --minimal --no-color ${baseCommit} -- ${filePaths.map((p) => JSON.stringify(p)).join(" ")}`, {
-					cwd: repoRoot,
-					encoding: "utf-8",
-					maxBuffer: 50 * 1024 * 1024
-				});
-				patch = stdout;
-			} else patch = await Effect.runPromise(diffPatchFilesAgainstHead(repoRoot, filePaths));
-			if (patch) patches.push(patch);
-		} catch {}
+		for (const [repoRoot, filePaths] of filesByRepo) {
+			if (repoRoot === cwdRepoRoot) continue;
+			try {
+				const patch = await diffPatchForFiles(repoRoot, conv.createdAt, filePaths);
+				if (patch) patches.push(patch);
+			} catch {}
+		}
 		return result$1({
 			turnId,
 			diff: patches.join("\n")
@@ -48735,7 +48926,7 @@ async function refreshMergeStateFromGitHub(issueId, repo, prNumber) {
 		let mergeState;
 		let isDraft;
 		let checksFailed;
-		const { isGitHubAppConfigured, getPullRequestState } = await import("./github-app-CeSVFL6C.js");
+		const { isGitHubAppConfigured, getPullRequestState } = await import("./github-app-CPfoFAdV.js");
 		if (isGitHubAppConfigured()) {
 			const prState = await Effect.runPromise(getPullRequestState(owner, repoName, prNumber));
 			mergeable = prState.mergeable === null ? "UNKNOWN" : prState.mergeable ? "MERGEABLE" : "CONFLICTING";
@@ -48884,8 +49075,8 @@ async function handlePullRequestPromise(payload) {
 	bumpIssuePrTabCacheGeneration(issueId);
 	const repo = payload.repository.full_name;
 	if (payload.action === "closed" && pr.merged === true) try {
-		const { postMergeLifecycle } = await import("./merge-agent-CnORPiri.js");
-		const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+		const { postMergeLifecycle } = await import("./merge-agent-BQM3a8z5.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-9SkRpES9.js");
 		const project = resolveProjectFromIssueSync(issueId);
 		if (project) {
 			const branchName = pr.head.ref;
@@ -50281,7 +50472,7 @@ async function registerProjectFromPath(opts) {
 	registerProjectSync(key, projectConfig);
 	const seededContextLayer = ensureProjectLayer(fullPath);
 	try {
-		const { preTrustDirectorySync } = await import("./workspace-manager-CcujONCR.js");
+		const { preTrustDirectorySync } = await import("./workspace-manager-ZTdJAy9M.js");
 		preTrustDirectorySync(fullPath);
 	} catch {}
 	let hooksInstalled = 0;
@@ -50311,6 +50502,7 @@ init_issue_id();
 init_tmux();
 init_concurrency$1();
 init_read_model();
+init_src();
 init_agents$1();
 init_pan_dir();
 init_io();
@@ -50318,7 +50510,7 @@ init_specs();
 init_paths();
 const execAsync$2 = promisify(exec);
 async function getIssueDataService() {
-	const { getSharedIssueService } = await import("./issue-service-singleton-D5EB5eYr.js");
+	const { getSharedIssueService } = await import("./issue-service-singleton-DabvBWUp.js");
 	return getSharedIssueService();
 }
 /** Returns true if the path exists (any type). */
@@ -50373,9 +50565,9 @@ function getSlotWorkSessionNumber(sessionId, issueLower) {
 	return Number.parseInt(match[1], 10);
 }
 function getSessionTreeWorkspacePath(issueLower, baseWorkspacePath, projectPath, sessionId) {
+	if (sessionId.toLowerCase() === `strike-${issueLower.toLowerCase()}`) return join(projectPath, "workspaces", `feature-${issueLower}-strike`);
 	const slotNumber = getSlotWorkSessionNumber(sessionId, issueLower);
-	if (slotNumber === null) return baseWorkspacePath;
-	return join(projectPath, "workspaces", `feature-${issueLower}-slot-${slotNumber}`);
+	return slotNumber === null ? baseWorkspacePath : join(projectPath, "workspaces", `feature-${issueLower}-slot-${slotNumber}`);
 }
 function compareSessionTreeSessionIds(a, b, issueLower) {
 	const planningAgentId = `planning-${issueLower}`;
@@ -50733,7 +50925,7 @@ async function fetchProjectSessionTree(projectKey, sharedContext) {
 		})), 15));
 		features.push(...results.filter((f) => f !== null));
 	}
-	features.sort((a, b) => a.issueId.localeCompare(b.issueId));
+	features.sort((a, b) => compareIssueIds(a.issueId, b.issueId));
 	return {
 		projectKey,
 		features
@@ -50775,7 +50967,7 @@ const getProjectReleaseStatusRoute = HttpRouter.add("GET", "/api/projects/:proje
 	const projectKey = (yield* HttpRouter.params)["projectKey"] ?? "";
 	return jsonResponse(yield* Effect.tryPromise({
 		try: async () => {
-			const { fetchProjectReleaseStatus } = await import("./project-pipelines-B59NfN44.js");
+			const { fetchProjectReleaseStatus } = await import("./project-pipelines-2sK1apsO.js");
 			return fetchProjectReleaseStatus(projectKey);
 		},
 		catch: (err) => new Error(err instanceof Error ? err.message : String(err))
@@ -51290,7 +51482,7 @@ function fullPromptPreview(previews) {
 		"## Runtime-only sections",
 		"",
 		"- Memory retrieval: injected at agent spawn when enabled; unavailable in this layer editor preview.",
-		"- Issue briefing and vBRIEF excerpts: injected per agent run; unavailable until a specific issue/session is selected.",
+		"- Issue briefing and xBRIEF excerpts: injected per agent run; unavailable until a specific issue/session is selected.",
 		"- Status and tool output: produced during the live session; not part of static context layers."
 	].join("\n");
 }
@@ -51590,6 +51782,35 @@ async function checkCommand(cmd, args = ["--version"]) {
 		return false;
 	}
 }
+const LINUX_PACKAGE_MANAGERS = [
+	"pacman",
+	"dnf",
+	"zypper",
+	"apk",
+	"apt-get"
+];
+async function detectLinuxPackageManager(commandAvailable = checkCommand) {
+	for (const packageManager of LINUX_PACKAGE_MANAGERS) if (await commandAvailable(packageManager)) return packageManager;
+	return null;
+}
+function getLinuxInstallCommand(tool, packageManager) {
+	switch (packageManager) {
+		case "pacman": return `sudo pacman -S --noconfirm ${tool}`;
+		case "dnf": return `sudo dnf install -y ${tool}`;
+		case "zypper": return `sudo zypper install -y ${tool}`;
+		case "apk": return `sudo apk add ${tool}`;
+		case "apt-get": return `sudo apt-get update && sudo apt-get install -y ${tool}`;
+	}
+}
+function getLinuxManualInstallHint(tool, packageManager) {
+	if (packageManager) return getLinuxInstallCommand(tool, packageManager);
+	return `${tool} — download from ${tool === "jq" ? "https://jqlang.github.io/jq/download/" : "https://github.com/tmux/tmux/wiki/Installing"}`;
+}
+async function installLinuxPackage(tool) {
+	const packageManager = await detectLinuxPackageManager();
+	if (!packageManager) throw new Error(`No supported Linux package manager found. Install ${getLinuxManualInstallHint(tool, null)}`);
+	await execAsync$1(getLinuxInstallCommand(tool, packageManager), { timeout: 12e4 });
+}
 async function isToolInstalled(tool) {
 	if (tool === "docker") return checkCommand("docker", ["info"]);
 	if (tool === "traefik") try {
@@ -51632,7 +51853,7 @@ async function installTool(tool) {
 }
 async function installTmux() {
 	if (await Effect.runPromise(detectPlatform()) === "darwin") await execAsync$1("brew install tmux", { timeout: 12e4 });
-	else await execAsync$1("sudo apt-get update && sudo apt-get install -y tmux", { timeout: 12e4 });
+	else await installLinuxPackage("tmux");
 	return {
 		tool: "tmux",
 		success: true,
@@ -51682,7 +51903,7 @@ async function installMkcert() {
 }
 async function installJq() {
 	if (await Effect.runPromise(detectPlatform()) === "darwin") await execAsync$1("brew install jq", { timeout: 12e4 });
-	else await execAsync$1("sudo apt-get update && sudo apt-get install -y jq", { timeout: 12e4 });
+	else await installLinuxPackage("jq");
 	return {
 		tool: "jq",
 		success: true,
@@ -52417,7 +52638,7 @@ function getCheckpointWorker() {
 	return worker;
 }
 async function runInline(operation, payload) {
-	const { claimTranscriptRange, commitTranscriptRange, releaseTranscriptRange, getTranscriptCheckpoint, listTranscriptCheckpoints } = await import("./checkpoints-DwZqT2qQ.js");
+	const { claimTranscriptRange, commitTranscriptRange, releaseTranscriptRange, getTranscriptCheckpoint, listTranscriptCheckpoints } = await import("./checkpoints-CpgCjAlN.js");
 	switch (operation) {
 		case "claimTranscriptRange": return claimTranscriptRange(payload);
 		case "commitTranscriptRange": return commitTranscriptRange(payload);
@@ -53571,7 +53792,7 @@ function buildPendingTurn(input, fromOffset, toOffset, compressed) {
 	};
 }
 async function emitMemoryObservationCreated(observation, timestamp) {
-	const { initEventStore } = await import("./event-store-DABarGNz.js");
+	const { initEventStore } = await import("./event-store-Cr5PQwFC.js");
 	await (await initEventStore()).appendAsync({
 		type: "memory.observation_created",
 		timestamp,
@@ -56583,7 +56804,7 @@ async function getFlywheelConversationPayload() {
 	};
 }
 async function postFlywheelReportPayload() {
-	const { flywheelReportCommand } = await import("./flywheel-DPUc8r3V.js");
+	const { flywheelReportCommand } = await import("./flywheel-DcBkQvgE.js");
 	await flywheelReportCommand({ cwd: process.cwd() });
 	return {
 		status: 200,
@@ -56741,11 +56962,11 @@ const getMergeBlockersRoute = HttpRouter.add("GET", "/api/flywheel/merge-blocker
 async function defaultGetOrderedIssueIds() {
 	const status = await readCurrentFlywheelStatusForDashboard();
 	if (!status) return [];
-	const { computeMergeQueue } = await import("./flywheel-merge-order-CeBuX0EJ.js");
+	const { computeMergeQueue } = await import("./flywheel-merge-order-C-6zRLvM.js");
 	return (await Effect.runPromise(computeMergeQueue(status.activePipeline, process.cwd()).pipe(Effect.provide(layer)))).map((i) => i.issueId);
 }
 async function defaultMergeOne(issueId) {
-	const { triggerMerge } = await import("./merge-ops-BpTtuO8x.js");
+	const { triggerMerge } = await import("./merge-ops-DlB1IM0Y.js");
 	const r = await triggerMerge(issueId);
 	return r.success ? { ok: true } : {
 		ok: false,
@@ -56765,7 +56986,7 @@ async function postFlywheelMergeNextPayload(payload, deps = {}) {
 		body: { error: "n must be a positive integer" }
 	};
 	const issueIds = (await (deps.getOrderedIssueIds ?? defaultGetOrderedIssueIds)()).slice(0, n);
-	const { shipMergeBatch } = await import("./merge-batch-C2w2U2eK.js");
+	const { shipMergeBatch } = await import("./merge-batch-Bwoyr8Je.js");
 	return {
 		status: 200,
 		body: { outcomes: await shipMergeBatch(issueIds, { merge: deps.merge ?? defaultMergeOne }) }
@@ -56922,7 +57143,7 @@ const getFlywheelMergeQueueRoute = HttpRouter.add("GET", "/api/flywheel/merge-qu
 	return yield* Effect.promise(async () => {
 		const status = await readCurrentFlywheelStatusForDashboard();
 		if (!status) return jsonResponse([]);
-		const { computeMergeQueue, resolveMergeQueuePrUrl } = await import("./flywheel-merge-order-CeBuX0EJ.js");
+		const { computeMergeQueue, resolveMergeQueuePrUrl } = await import("./flywheel-merge-order-C-6zRLvM.js");
 		return jsonResponse(await Effect.runPromise(computeMergeQueue(status.activePipeline, process.cwd(), { getPrUrl: resolveMergeQueuePrUrl }).pipe(Effect.provide(layer))));
 	});
 })));
@@ -56936,18 +57157,18 @@ function uatGenerationNameFromParam(param) {
 	return decoded.startsWith("uat/") ? decoded : `uat/${decoded}`;
 }
 const getUatGenerationsRoute = HttpRouter.add("GET", "/api/flywheel/uat-generations", httpHandler(Effect.gen(function* () {
-	const { getUatGenerationsPayload } = yield* Effect.promise(() => import("./uat-train-Wismge7h.js"));
+	const { getUatGenerationsPayload } = yield* Effect.promise(() => import("./uat-train-cKfM-_WW.js"));
 	return jsonResponse(yield* Effect.promise(() => getUatGenerationsPayload()));
 })));
 const getUatCandidateRoute = HttpRouter.add("GET", "/api/flywheel/uat-candidate", httpHandler(Effect.gen(function* () {
-	const { getUatCandidatePayload } = yield* Effect.promise(() => import("./uat-train-Wismge7h.js"));
+	const { getUatCandidatePayload } = yield* Effect.promise(() => import("./uat-train-cKfM-_WW.js"));
 	return jsonResponse(yield* Effect.promise(() => getUatCandidatePayload()));
 })));
 const postUatGenerationStackRoute = HttpRouter.add("POST", "/api/flywheel/uat-generations/:name/stack", httpHandler(Effect.gen(function* () {
 	const authError = rejectUnsafeDashboardMutationRequest(yield* HttpServerRequest.HttpServerRequest);
 	if (authError) return authError;
 	const name = uatGenerationNameFromParam((yield* HttpRouter.params)["name"] ?? "");
-	const { postUatGenerationStackPayload } = yield* Effect.promise(() => import("./uat-train-Wismge7h.js"));
+	const { postUatGenerationStackPayload } = yield* Effect.promise(() => import("./uat-train-cKfM-_WW.js"));
 	const result = yield* Effect.promise(() => postUatGenerationStackPayload(name));
 	if (!result.ok) return jsonResponse({ error: result.error }, { status: result.status });
 	return jsonResponse({
@@ -56959,8 +57180,8 @@ const postUatGenerationPromoteRoute = HttpRouter.add("POST", "/api/flywheel/uat-
 	const authError = rejectUnsafeDashboardMutationRequest(yield* HttpServerRequest.HttpServerRequest);
 	if (authError) return authError;
 	const name = uatGenerationNameFromParam((yield* HttpRouter.params)["name"] ?? "");
-	const { postUatGenerationPromotePayload } = yield* Effect.promise(() => import("./uat-train-Wismge7h.js"));
-	const { firePostMergeLifecycle } = yield* Effect.promise(() => import("./specialists-D0VBf8g_.js"));
+	const { postUatGenerationPromotePayload } = yield* Effect.promise(() => import("./uat-train-cKfM-_WW.js"));
+	const { firePostMergeLifecycle } = yield* Effect.promise(() => import("./specialists-D5fRZXmN.js"));
 	const result = yield* Effect.promise(() => postUatGenerationPromotePayload(name, firePostMergeLifecycle));
 	if (!result.success) return jsonResponse(result, { status: result.reason === "not-found" ? 404 : result.reason === "merge-failed" ? 500 : 409 });
 	return jsonResponse(result);
@@ -56973,7 +57194,7 @@ const postUatGenerationPromoteRoute = HttpRouter.add("POST", "/api/flywheel/uat-
 const postFlywheelAssembleUatRoute = HttpRouter.add("POST", "/api/flywheel/assemble-uat", httpHandler(Effect.gen(function* () {
 	const authError = rejectUnsafeDashboardMutationRequest(yield* HttpServerRequest.HttpServerRequest);
 	if (authError) return authError;
-	const { runUatTrainReconcile } = yield* Effect.promise(() => import("./uat-train-Wismge7h.js"));
+	const { runUatTrainReconcile } = yield* Effect.promise(() => import("./uat-train-cKfM-_WW.js"));
 	return jsonResponse(yield* Effect.promise(() => runUatTrainReconcile({ force: true })));
 })));
 const getFlywheelStateRoute = HttpRouter.add("GET", "/api/flywheel/state", httpHandler(Effect.gen(function* () {
@@ -59796,6 +60017,27 @@ const postTieredCalloutsRoute = HttpRouter.add("POST", "/api/tiered/callouts", h
 })));
 const tieredCalloutsRouteLayer = Layer.mergeAll(postTieredCalloutsRoute);
 //#endregion
+//#region server-bind.ts
+function isAddressInUseError(error) {
+	if (!error || typeof error !== "object") return false;
+	if ("code" in error && error.code === "EADDRINUSE") return true;
+	return "cause" in error && isAddressInUseError(error.cause);
+}
+const BIND_RETRY_DELAY_MS = 250;
+const BIND_RETRY_COUNT = 3;
+function retryDashboardBind(bind, onRetry) {
+	let failures = 0;
+	const observedBind = Effect.tapError(bind, (error) => Effect.sync(() => {
+		failures += 1;
+		if (failures <= BIND_RETRY_COUNT && isAddressInUseError(error)) onRetry?.(failures, BIND_RETRY_DELAY_MS);
+	}));
+	return Effect.retry(observedBind, {
+		times: BIND_RETRY_COUNT,
+		schedule: Schedule.spaced(Duration.millis(BIND_RETRY_DELAY_MS)),
+		while: isAddressInUseError
+	});
+}
+//#endregion
 //#region server.ts
 /**
 * Dashboard HTTP server — Effect-based with dual-runtime support (PAN-428 B5)
@@ -59821,14 +60063,19 @@ init_activity_logger();
 const HttpServerLive = Layer.unwrap(Effect.gen(function* () {
 	const config = yield* ServerConfig;
 	const [NodeHttpServer, NodeHttp] = yield* Effect.all([Effect.promise(() => import("@effect/platform-node/NodeHttpServer")), Effect.promise(() => import("node:http"))]);
-	const nodeServer = NodeHttp.createServer();
-	setupTerminalWebSocket(nodeServer);
-	setupVoiceWebSocket(nodeServer);
-	setupAutoPresoWebSocket(nodeServer);
-	return NodeHttpServer.layer(() => nodeServer, {
+	const bind = retryDashboardBind(NodeHttpServer.make(() => {
+		const nodeServer = NodeHttp.createServer();
+		setupTerminalWebSocket(nodeServer);
+		setupVoiceWebSocket(nodeServer);
+		setupAutoPresoWebSocket(nodeServer);
+		return nodeServer;
+	}, {
 		host: config.host,
 		port: config.port
+	}), (attempt, delayMs) => {
+		console.warn(`[overdeck] HTTP bind failed with EADDRINUSE; retry ${attempt}/3 in ${delayMs}ms`);
 	});
+	return Layer.mergeAll(Layer.effect(HttpServer.HttpServer)(bind), NodeHttpServer.layerHttpServices);
 }));
 const PlatformServicesLive = Layer.unwrap(Effect.gen(function* () {
 	const { layer } = yield* Effect.promise(() => import("@effect/platform-node/NodeServices"));
@@ -59920,6 +60167,7 @@ const makeServerLayer = Layer.unwrap(Effect.gen(function* () {
 	const httpListeningLayer = Layer.effectDiscard(Effect.gen(function* () {
 		yield* HttpServer.HttpServer;
 		yield* Effect.sync(() => {
+			markDashboardListening();
 			console.log(`[boot-timing] HTTP server listening at +${Math.round(performance.now())}ms (since process start)`);
 			console.log(`[overdeck] Dashboard listening on http://${config.host}:${config.port}`);
 			const mode = process.env["OVERDECK_MODE"] === "production" ? "production mode" : "development mode";
@@ -59978,7 +60226,7 @@ function buildAwaitingInputActivityMessage(agentId, issueId, kinds) {
 	const kindList = kinds.length > 0 ? kinds.join(", ") : "input";
 	return issueId ? `${agentId} on ${issueId} is waiting for ${kindList}` : `${agentId} is waiting for ${kindList}`;
 }
-async function pollOnce$1(state) {
+async function pollOnce(state) {
 	let runningAgents;
 	try {
 		runningAgents = await Effect.runPromise(listRunningAgents());
@@ -60108,8 +60356,8 @@ async function pollOnce$1(state) {
 /** Poll interval: 10 seconds (was 3s). The enrichment data changes slowly —
 *  pending questions, resolution state, phase — none of these need sub-second
 *  latency. 10s eliminates ~70% of poller I/O without any user-visible lag. */
-const POLL_INTERVAL_MS$4 = 1e4;
-const serviceState$3 = {
+const POLL_INTERVAL_MS$3 = 1e4;
+const serviceState$2 = {
 	timer: null,
 	lastEnrichment: /* @__PURE__ */ new Map(),
 	lastScan: /* @__PURE__ */ new Map(),
@@ -60117,18 +60365,18 @@ const serviceState$3 = {
 	reconciledAgentIds: /* @__PURE__ */ new Set()
 };
 function startAgentEnrichmentService() {
-	if (serviceState$3.timer !== null) return;
-	serviceState$3.timer = setInterval(() => {
-		pollOnce$1(serviceState$3).catch(() => {});
-	}, POLL_INTERVAL_MS$4);
+	if (serviceState$2.timer !== null) return;
+	serviceState$2.timer = setInterval(() => {
+		pollOnce(serviceState$2).catch(() => {});
+	}, POLL_INTERVAL_MS$3);
 }
 function stopAgentEnrichmentService() {
-	if (serviceState$3.timer !== null) {
-		clearInterval(serviceState$3.timer);
-		serviceState$3.timer = null;
+	if (serviceState$2.timer !== null) {
+		clearInterval(serviceState$2.timer);
+		serviceState$2.timer = null;
 	}
-	serviceState$3.lastEnrichment.clear();
-	serviceState$3.lastScan.clear();
+	serviceState$2.lastEnrichment.clear();
+	serviceState$2.lastScan.clear();
 }
 //#endregion
 //#region services/merge-blocker-reconcile-service.ts
@@ -60148,7 +60396,7 @@ function stopAgentEnrichmentService() {
 * Bounded + cheap: each issue has a throttle. Ready/no-blocker rows use the PAN-1620
 * 3-minute cadence; already-blocked mergeability rows use a 10-minute cadence.
 */
-const POLL_INTERVAL_MS$3 = 6e4;
+const POLL_INTERVAL_MS$2 = 6e4;
 /** Re-check each ready-to-merge PR at most this often, to bound `gh` calls. */
 const RECHECK_INTERVAL_MS = 18e4;
 /** Re-check already-flagged mergeability blockers less often; they are not mergeable yet. */
@@ -60159,7 +60407,7 @@ const MERGEABILITY_BLOCKERS = new Set([
 	"failing_checks"
 ]);
 const MAX_REFRESH_CONCURRENCY = 4;
-const serviceState$2 = {
+const serviceState$1 = {
 	timer: null,
 	lastChecked: /* @__PURE__ */ new Map(),
 	blockerLastChecked: /* @__PURE__ */ new Map(),
@@ -60214,11 +60462,11 @@ async function reconcileOnce(state) {
 	for (const id of [...state.blockerLastChecked.keys()]) if (!hasMergeabilityBlocker(candidateById.get(id)?.blockerReasons)) state.blockerLastChecked.delete(id);
 }
 function startMergeBlockerReconcileService() {
-	if (serviceState$2.timer !== null) return;
-	serviceState$2.timer = setInterval(() => {
-		reconcileOnce(serviceState$2).catch(() => {});
-	}, POLL_INTERVAL_MS$3);
-	serviceState$2.timer.unref?.();
+	if (serviceState$1.timer !== null) return;
+	serviceState$1.timer = setInterval(() => {
+		reconcileOnce(serviceState$1).catch(() => {});
+	}, POLL_INTERVAL_MS$2);
+	serviceState$1.timer.unref?.();
 }
 function enqueueRefresh(state, task) {
 	if (state.refreshInFlight.has(task.issueId)) return;
@@ -60241,6 +60489,174 @@ function drainRefreshQueue(state) {
 	}
 }
 //#endregion
+//#region services/project-resource-refresh-queue.ts
+init_projects();
+const PROJECT_RESOURCE_CONVERGENCE_INTERVAL_MS = 5 * 6e4;
+function createProjectResourceRefreshQueue(deps) {
+	const debounceMs = deps.debounceMs ?? 1e3;
+	const now = deps.now ?? Date.now;
+	const pending = /* @__PURE__ */ new Map();
+	const reasons = /* @__PURE__ */ new Map();
+	const idleWaiters = /* @__PURE__ */ new Set();
+	let activeProjectPaths = [];
+	let timer = null;
+	let running = false;
+	let stopped = false;
+	let lastStartedAt = null;
+	let lastCompletedAt = null;
+	let lastError = null;
+	const isIdle = () => !running && timer === null && pending.size === 0;
+	const resolveIdleWaiters = () => {
+		if (!isIdle()) return;
+		for (const resolve of idleWaiters) resolve();
+		idleWaiters.clear();
+	};
+	const drain = async () => {
+		timer = null;
+		if (running || stopped) return;
+		running = true;
+		try {
+			while (!stopped && pending.size > 0) {
+				const projects = [...pending.values()];
+				const reasonsByProjectPath = /* @__PURE__ */ new Map();
+				for (const project of projects) {
+					reasonsByProjectPath.set(project.path, new Set(reasons.get(project.path) ?? []));
+					reasons.delete(project.path);
+				}
+				pending.clear();
+				activeProjectPaths = projects.map((project) => project.path);
+				lastStartedAt = now();
+				try {
+					await deps.refreshProjects(projects, { reasonsByProjectPath });
+					lastError = null;
+				} catch (error) {
+					lastError = error instanceof Error ? error.message : String(error);
+					console.warn("[project-resource-refresh] batch failed:", lastError);
+				} finally {
+					activeProjectPaths = [];
+					lastCompletedAt = now();
+				}
+			}
+		} finally {
+			running = false;
+			resolveIdleWaiters();
+		}
+	};
+	const schedule = () => {
+		if (stopped || running || timer) return;
+		timer = setTimeout(() => void drain(), debounceMs);
+		timer.unref?.();
+	};
+	const enqueueProject = (project, reason) => {
+		if (stopped) return;
+		pending.set(project.path, project);
+		const projectReasons = reasons.get(project.path) ?? /* @__PURE__ */ new Set();
+		projectReasons.add(reason);
+		reasons.set(project.path, projectReasons);
+		schedule();
+	};
+	return {
+		enqueueProject,
+		enqueueProjects(projects, reason) {
+			for (const project of projects) enqueueProject(project, reason);
+		},
+		whenIdle() {
+			if (isIdle()) return Promise.resolve();
+			return new Promise((resolve) => idleWaiters.add(resolve));
+		},
+		getState() {
+			return {
+				running,
+				activeProjectPaths: [...activeProjectPaths],
+				pendingProjectPaths: [...pending.keys()],
+				lastStartedAt,
+				lastCompletedAt,
+				lastError
+			};
+		},
+		stop() {
+			stopped = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+			pending.clear();
+			reasons.clear();
+			resolveIdleWaiters();
+		}
+	};
+}
+const MEMBERSHIP_REFRESH_REASONS = new Set(["boot-warm", "periodic-convergence"]);
+const projectResourceRefreshQueue = createProjectResourceRefreshQueue({ refreshProjects: (projects, context) => refreshResourceAllocatedProjects(projects, { refreshMembership: [...context.reasonsByProjectPath.values()].some((projectReasons) => [...projectReasons].some((reason) => MEMBERSHIP_REFRESH_REASONS.has(reason))) }) });
+function enqueueProjectsResourceRefresh(projects, reason) {
+	projectResourceRefreshQueue.enqueueProjects(projects, reason);
+}
+function whenProjectResourceRefreshIdle() {
+	return projectResourceRefreshQueue.whenIdle();
+}
+function getProjectResourceRefreshQueueState() {
+	return projectResourceRefreshQueue.getState();
+}
+function stopProjectResourceRefreshQueue() {
+	projectResourceRefreshQueue.stop();
+}
+function startProjectResourceConvergence() {
+	const timer = setInterval(() => {
+		enqueueProjectsResourceRefresh(listProjectsSync().map((entry) => entry.config), "periodic-convergence");
+	}, PROJECT_RESOURCE_CONVERGENCE_INTERVAL_MS);
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+//#endregion
+//#region services/resource-refresh-triggers.ts
+init_agents$1();
+init_projects();
+init_event_store();
+const TRIGGER_EVENT_TYPES = new Set([
+	"agent.created",
+	"agent.started",
+	"agent.stopped",
+	"agent.completed",
+	"agent.heartbeat_dead"
+]);
+function createResourceRefreshTriggers(deps) {
+	const warn = deps.warn ?? ((message) => console.warn(message));
+	return deps.subscribe((event) => {
+		if (!TRIGGER_EVENT_TYPES.has(event.type)) return;
+		const payload = event.payload;
+		let project = null;
+		if (typeof payload?.projectKey === "string") project = deps.projectForKey(payload.projectKey);
+		if (!project && typeof payload?.issueId === "string") project = deps.projectForIssue(payload.issueId);
+		if (!project && typeof payload?.agentId === "string") {
+			const issueId = deps.issueForAgent(payload.agentId);
+			if (issueId) project = deps.projectForIssue(issueId);
+		}
+		if (!project) {
+			warn(`[resource-refresh] skipped ${event.type}: affected project could not be resolved`);
+			return;
+		}
+		deps.enqueueProjects([project], event.type);
+	});
+}
+function startResourceRefreshTriggers() {
+	const entries = () => listProjectsSync();
+	return createResourceRefreshTriggers({
+		subscribe: (fn) => getEventStore().subscribe(fn),
+		projectForIssue: (issueId) => {
+			const resolved = resolveProjectFromIssueSync(issueId);
+			if (!resolved) return null;
+			return entries().find((entry) => entry.key === resolved.projectKey)?.config ?? null;
+		},
+		projectForKey: (projectKey) => entries().find((entry) => entry.key === projectKey)?.config ?? null,
+		issueForAgent: (agentId) => {
+			try {
+				return getAgentStateSync(agentId)?.issueId ?? null;
+			} catch {
+				return null;
+			}
+		},
+		enqueueProjects: enqueueProjectsResourceRefresh
+	});
+}
+//#endregion
 //#region ../../lib/cloister/stale-check-classifier.ts
 /**
 * Pure classification for stale PR checks inherited from a red main branch.
@@ -60426,12 +60842,12 @@ async function rerunFailedRun(repo, runId) {
 //#endregion
 //#region services/stale-check-retrigger-service.ts
 init_review_status_sync();
-const POLL_INTERVAL_MS$2 = 6e4;
+const POLL_INTERVAL_MS$1 = 6e4;
 const MAIN_PROBE_INTERVAL_MS = 3 * 6e4;
 const EVAL_INTERVAL_MS = 10 * 6e4;
 const MAX_RERUNS_PER_TICK = 5;
 const RUN_STATE_RETENTION_MS = 1440 * 6e4;
-const serviceState$1 = {
+const serviceState = {
 	timer: null,
 	repoWindows: /* @__PURE__ */ new Map(),
 	lastEvaluated: /* @__PURE__ */ new Map(),
@@ -60577,120 +60993,21 @@ async function runTickIfIdle(state) {
 	}
 }
 function startStaleCheckRetriggerService() {
-	if (serviceState$1.timer !== null) return;
-	serviceState$1.timer = setInterval(() => void runTickIfIdle(serviceState$1), POLL_INTERVAL_MS$2);
-	serviceState$1.timer.unref?.();
+	if (serviceState.timer !== null) return;
+	serviceState.timer = setInterval(() => void runTickIfIdle(serviceState), POLL_INTERVAL_MS$1);
+	serviceState.timer.unref?.();
 }
 function shouldStartStaleCheckRetriggerService(env = process.env) {
 	return env.OVERDECK_DISABLE_DEACON !== "1";
 }
 function stopStaleCheckRetriggerService() {
-	if (serviceState$1.timer !== null) clearInterval(serviceState$1.timer);
-	serviceState$1.timer = null;
-	serviceState$1.repoWindows.clear();
-	serviceState$1.lastEvaluated.clear();
-	serviceState$1.successfulRunIds.clear();
-	serviceState$1.failedRunsByIssue.clear();
-	serviceState$1.loggedSkips.clear();
-}
-//#endregion
-//#region services/agent-output-service.ts
-/**
-* Agent Output Service (PAN-1221 F3)
-*
-* Background poller that captures tmux pane output for each running agent
-* every ~3 seconds and emits `agent.output_received` domain events when
-* new lines appear.
-*
-* This restores the event-driven output pipeline that DrawerActiveAgent
-* expects — the reducer and WebSocket subscription already exist, but no
-* server code was emitting the events.
-*/
-init_agents$1();
-init_tmux();
-init_concurrency$1();
-init_event_store();
-function splitLines(text) {
-	const lines = text.split("\n");
-	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-	return lines;
-}
-/**
-* Find new lines by looking for the longest suffix of `previous` that matches
-* a prefix of `current`. The non-overlapping prefix of `current` is returned.
-* If there is no overlap, all of `current` is new (pane was cleared or scrolled
-* past the overlap window).
-*/
-function diffLines(previous, current) {
-	if (previous.length === 0) return current;
-	for (let start = 0; start < previous.length; start++) {
-		const suffix = previous.slice(start);
-		if (suffix.length > current.length) continue;
-		if (suffix.every((line, i) => line === current[i])) return current.slice(suffix.length);
-	}
-	return current;
-}
-async function pollOnce(state) {
-	let runningAgents;
-	try {
-		runningAgents = await Effect.runPromise(listRunningAgents());
-	} catch {
-		return;
-	}
-	const eventStore = getEventStore();
-	const activeAgents = runningAgents.filter((a) => a.tmuxActive);
-	await Effect.runPromise(withConcurrencyLimit(activeAgents.map((agent) => Effect.tryPromise({
-		try: async () => {
-			const { id: agentId } = agent;
-			let stdout;
-			try {
-				const remoteState = await readFile(join(homedir$1(), ".overdeck", "agents", agentId, "remote-state.json"), "utf-8").then((text) => JSON.parse(text)).catch(() => null);
-				if (remoteState?.location === "remote" && remoteState?.vmName) {
-					const { getRemoteAgentOutput } = await import("./remote-agents-BNORDWAX.js");
-					stdout = await getRemoteAgentOutput(agentId, remoteState.vmName, 50);
-				} else stdout = await Effect.runPromise(capturePane(agentId, 50));
-			} catch {
-				stdout = await Effect.runPromise(capturePane(agentId, 50).pipe(Effect.catch(() => Effect.succeed(""))));
-			}
-			if (!stdout || stdout.trim() === "" || stdout.trim() === "Session not found") return;
-			const previousOutput = state.lastOutput.get(agentId) ?? "";
-			if (stdout === previousOutput) return;
-			const newLines = diffLines(splitLines(previousOutput), splitLines(stdout));
-			state.lastOutput.set(agentId, stdout);
-			if (newLines.length === 0) return;
-			const event = {
-				type: "agent.output_received",
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				payload: {
-					agentId,
-					lines: newLines
-				}
-			};
-			eventStore.emitOnly(event);
-		},
-		catch: (cause) => cause
-	})), 4));
-	const activeIds = new Set(activeAgents.map((a) => a.id));
-	for (const id of state.lastOutput.keys()) if (!activeIds.has(id)) state.lastOutput.delete(id);
-}
-/** Poll interval: 3 seconds. Output is high-frequency and latency-sensitive. */
-const POLL_INTERVAL_MS$1 = 3e3;
-const serviceState = {
-	timer: null,
-	lastOutput: /* @__PURE__ */ new Map()
-};
-function startAgentOutputService() {
-	if (serviceState.timer !== null) return;
-	serviceState.timer = setInterval(() => {
-		pollOnce(serviceState).catch(() => {});
-	}, POLL_INTERVAL_MS$1);
-}
-function stopAgentOutputService() {
-	if (serviceState.timer !== null) {
-		clearInterval(serviceState.timer);
-		serviceState.timer = null;
-	}
-	serviceState.lastOutput.clear();
+	if (serviceState.timer !== null) clearInterval(serviceState.timer);
+	serviceState.timer = null;
+	serviceState.repoWindows.clear();
+	serviceState.lastEvaluated.clear();
+	serviceState.successfulRunIds.clear();
+	serviceState.failedRunsByIssue.clear();
+	serviceState.loggedSkips.clear();
 }
 //#endregion
 //#region services/conversation-lifecycle.ts
@@ -60710,7 +61027,7 @@ function stopAgentOutputService() {
 * spawn-only.
 */
 init_conversations();
-init_tmux();
+init_runtime_census();
 init_paths();
 init_behavior();
 const POLL_INTERVAL_MS = 1e4;
@@ -60754,12 +61071,10 @@ async function tailFile(path, maxBytes) {
 * a "; "-prefixed suffix for the log line, or "" when nothing is available.
 * Every probe is independently guarded so a diagnostics failure never throws.
 */
-async function captureCorpseDiagnostics(tmuxSession) {
+async function captureCorpseDiagnostics(tmuxSession, census) {
 	const parts = [];
-	try {
-		const status = (await Effect.runPromise(listPaneValues(tmuxSession, "#{pane_dead_status}"))).find((v) => v.trim() !== "")?.trim();
-		if (status) parts.push(`exitStatus=${status}`);
-	} catch {}
+	const status = (census.panesBySession.get(tmuxSession) ?? []).map((pane) => pane.paneDeadStatus).find((value) => value !== null);
+	if (status !== void 0) parts.push(`exitStatus=${status}`);
 	try {
 		const logPath = join$1(getOverdeckHome(), "agents", tmuxSession, "output.log");
 		if (existsSync(logPath)) {
@@ -60779,7 +61094,10 @@ async function pollConversations() {
 	try {
 		const conversations = listConversations();
 		if (conversations.length === 0) return;
-		const aliveSessions = new Set(await Effect.runPromise(listSessionNames()));
+		const census = await getRuntimeCensus();
+		if (!census.available) return;
+		const aliveSessions = new Set(census.sessionNames);
+		let revalidationCensus = null;
 		const endedConversations = [];
 		let sessionGoneCount = 0;
 		let keepAliveCorpseCount = 0;
@@ -60787,8 +61105,8 @@ async function pollConversations() {
 		const now = Date.now();
 		for (const conv of conversations) {
 			if (now - new Date(conv.createdAt).getTime() < SPAWN_GRACE_PERIOD_MS) continue;
-			const sessionGone = !aliveSessions.has(conv.tmuxSession);
-			const harnessGone = !sessionGone && !await isHarnessProcessAlive(conv.tmuxSession);
+			let sessionGone = !aliveSessions.has(conv.tmuxSession);
+			let harnessGone = !sessionGone && !await runtimeCensusHasHarnessProcess(census, conv.tmuxSession);
 			if (!sessionGone && !harnessGone) {
 				if (conv.status === "ended") {
 					console.log(`[conversation-lifecycle] Session ${conv.tmuxSession} alive but row marked ended — resurrecting to active`);
@@ -60801,9 +61119,14 @@ async function pollConversations() {
 			const fresh = getConversationByName(conv.name) ?? conv;
 			const lastAliveSignalMs = Math.max(new Date(fresh.createdAt).getTime() || 0, fresh.lastAttachedAt ? new Date(fresh.lastAttachedAt).getTime() || 0 : 0);
 			if (Date.now() - lastAliveSignalMs < SPAWN_GRACE_PERIOD_MS) continue;
+			revalidationCensus ??= await refreshRuntimeCensus();
+			if (!revalidationCensus.available) continue;
+			sessionGone = !revalidationCensus.sessionNames.has(conv.tmuxSession);
+			harnessGone = !sessionGone && !await runtimeCensusHasHarnessProcess(revalidationCensus, conv.tmuxSession);
+			if (!sessionGone && !harnessGone) continue;
 			if (process.env.DEBUG?.includes("conversation-lifecycle")) console.log(sessionGone ? `[conversation-lifecycle] Session ${conv.tmuxSession} gone — marking ended` : `[conversation-lifecycle] Session ${conv.tmuxSession} alive but harness exited (keep-alive corpse) — marking ended`);
 			if (!sessionGone) {
-				const diag = await captureCorpseDiagnostics(conv.tmuxSession);
+				const diag = await captureCorpseDiagnostics(conv.tmuxSession, revalidationCensus);
 				if (diag) keepAliveCorpseDiagnostics.push(`${conv.tmuxSession}${diag}`);
 			}
 			markConversationEnded(conv.name);
@@ -61458,7 +61781,8 @@ init_event_store();
 init_tracker_config();
 const DEFAULT_INTERVAL_MS = 6e4;
 const DEFAULT_LOOKBACK_MS = 5 * 6e4;
-const BOT_LOGIN = "panopticon-agent[bot]";
+const FLYWHEEL_FILED_BY_TRAILER = "\"Flywheel-Filed-By:\" in:body";
+const LEGACY_BOT_LOGIN = "panopticon-agent[bot]";
 var CacheServiceRateLimitStore = class {
 	cache = null;
 	getCache() {
@@ -61564,14 +61888,14 @@ function createSubstrateBugPoller(options = {}) {
 		const since = isoLookback(now(), lookbackMs);
 		for (const repo of config.repos) try {
 			const repoQualifier = `repo:${repo.owner}/${repo.repo}`;
-			const authorResults = await fetchSearch(config.token, searchQuery([
+			const trailerResults = await fetchSearch(config.token, searchQuery([
 				repoQualifier,
 				"is:issue",
 				"-is:pr",
-				`author:${BOT_LOGIN}`,
+				FLYWHEEL_FILED_BY_TRAILER,
 				`updated:>=${since}`
 			]));
-			if (authorResults === null) return;
+			if (trailerResults === null) return;
 			const substrateResults = await fetchSearch(config.token, searchQuery([
 				repoQualifier,
 				"is:issue",
@@ -61581,12 +61905,12 @@ function createSubstrateBugPoller(options = {}) {
 			]));
 			if (substrateResults === null) return;
 			const byNumber = /* @__PURE__ */ new Map();
-			for (const issue of [...authorResults, ...substrateResults]) byNumber.set(issue.number, issue);
+			for (const issue of [...trailerResults, ...substrateResults]) byNumber.set(issue.number, issue);
 			for (const issue of byNumber.values()) {
 				const issueId = issueIdFor(repo.prefix, issue.number);
 				if (!issueId) continue;
 				const trailer = parseSubstrateBugTrailer(issue.body);
-				const filedBy = trailer.filedBy ?? (issue.user?.login === BOT_LOGIN ? "agent" : "operator");
+				const filedBy = trailer.filedBy ?? (issue.user?.login === LEGACY_BOT_LOGIN ? "agent" : "operator");
 				const labelNames = (issue.labels ?? []).map((label) => typeof label === "string" ? label : label.name ?? "");
 				const affectedCriteria = parseAffectedCriteria(issue.body, labelNames);
 				const existing = repository.getByIssueId(issueId);
@@ -61852,7 +62176,7 @@ const RESTART_MARKER = join$1(homedir(), ".overdeck", "dashboard-restarting.json
 * loads new content-hashed chunk filenames (no ERR_MODULE_NOT_FOUND after rebuild).
 */
 async function defaultLifecycleRunner(pending) {
-	const { postMergeLifecycle, notifyTldrDaemon } = await import("./merge-agent-CnORPiri.js");
+	const { postMergeLifecycle, notifyTldrDaemon } = await import("./merge-agent-BQM3a8z5.js");
 	await postMergeLifecycle(pending.issueId, pending.projectPath, pending.sourceBranch, { skipDeploy: true });
 	if (pending.sourceBranch) await notifyTldrDaemon(pending.projectPath, pending.sourceBranch);
 }
@@ -62173,7 +62497,7 @@ function failureReason(result) {
 	return result.error ?? result.message ?? `merge returned status ${result.statusCode ?? "unknown"}`;
 }
 async function defaultMergeIssue(issueId) {
-	const { triggerMerge } = await import("./merge-ops-BpTtuO8x.js");
+	const { triggerMerge } = await import("./merge-ops-DlB1IM0Y.js");
 	return triggerMerge(issueId);
 }
 function defaultAnnounceFailure(issueId, reason) {
@@ -62401,24 +62725,27 @@ init_projects();
 init_state_home();
 const execFileAsync = promisify(execFile);
 const inFlight = /* @__PURE__ */ new Map();
-async function pathIsGitWorkTree(path) {
+async function pathIsGitWorkTree(path, signal) {
 	try {
+		signal?.throwIfAborted();
 		const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
 			cwd: path,
 			encoding: "utf8",
-			timeout: 15e3
+			timeout: 15e3,
+			signal
 		});
 		return stdout.trim() === "true";
 	} catch {
+		signal?.throwIfAborted();
 		return false;
 	}
 }
 const defaultDependencies = {
 	inspect: inspectStateMigration,
 	ensureWorktree: ensureStateWorktree,
-	migrate: async (projectKey, project) => {
-		const { migrateProjectState } = await import("./state-migrate-_zJJ6XKE.js");
-		await migrateProjectState(projectKey, {}, project);
+	migrate: async (projectKey, project, signal) => {
+		const { migrateProjectState } = await import("./state-migrate-Dkzaxvny.js");
+		await migrateProjectState(projectKey, { signal }, project);
 	},
 	clearCache: clearStateMigrationCache,
 	isGitWorkTree: pathIsGitWorkTree
@@ -62445,24 +62772,28 @@ function blocked(projectKey, error) {
 function worktreeBlockReason(status) {
 	return `The canonical overdeck-state worktree is ${status.status}: ${status.detail}`;
 }
-async function reconcile(projectKey, project, dependencies) {
+async function reconcile(projectKey, project, dependencies, signal) {
 	try {
-		if (!(await dependencies.inspect(project)).migrated) {
+		if (!(await dependencies.inspect(project, { signal })).migrated) {
 			const { repoPath } = resolveInfraRepo(project);
-			if (!await dependencies.isGitWorkTree(repoPath)) return blocked(projectKey, describeUnmigratableProjectPath(projectKey, project, repoPath));
-			await dependencies.migrate(projectKey, project);
+			if (!await dependencies.isGitWorkTree(repoPath, signal)) return blocked(projectKey, describeUnmigratableProjectPath(projectKey, project, repoPath));
+			await dependencies.migrate(projectKey, project, signal);
 			dependencies.clearCache();
-			if (!(await dependencies.inspect(project)).migrated) return blocked(projectKey, "Migration completed without a valid marker on origin/overdeck-state.");
+			if (!(await dependencies.inspect(project, { signal })).migrated) return blocked(projectKey, "Migration completed without a valid marker on origin/overdeck-state.");
 		}
-		const worktree = await dependencies.ensureWorktree(project, { projectKey });
+		const worktree = await dependencies.ensureWorktree(project, {
+			projectKey,
+			signal
+		});
 		if (worktree.status === "dirty" || worktree.status === "error") return blocked(projectKey, worktreeBlockReason(worktree));
-		if (worktree.status === "legacy") return blocked(projectKey, "The remote migration marker is valid but the local state worktree still resolves to the legacy project checkout.");
+		if (worktree.status === "legacy") return blocked(projectKey, worktree.detail);
 		return {
 			status: "ready",
 			projectKey,
 			worktree: worktree.status
 		};
 	} catch (error) {
+		signal.throwIfAborted();
 		return blocked(projectKey, error);
 	}
 }
@@ -62471,12 +62802,39 @@ async function reconcile(projectKey, project, dependencies) {
 * state. Concurrent dashboard/CLI callers on this process share one attempt;
 * the migration command supplies the cross-process lock and no-loss gates.
 */
-function ensureAutomaticStateMigration(projectKey, project, dependencies = defaultDependencies) {
-	const existing = inFlight.get(projectKey);
-	if (existing) return existing;
-	const task = reconcile(projectKey, project, dependencies).finally(() => inFlight.delete(projectKey));
-	inFlight.set(projectKey, task);
-	return task;
+function ensureAutomaticStateMigration(projectKey, project, dependencies = defaultDependencies, signal) {
+	signal?.throwIfAborted();
+	let entry = inFlight.get(projectKey);
+	if (!entry) {
+		const controller = new AbortController();
+		const task = reconcile(projectKey, project, dependencies, controller.signal).finally(() => inFlight.delete(projectKey));
+		entry = {
+			controller,
+			persistentOwner: signal === void 0,
+			waiters: /* @__PURE__ */ new Map(),
+			task
+		};
+		inFlight.set(projectKey, entry);
+	} else if (!signal) entry.persistentOwner = true;
+	if (!signal) return entry.task;
+	const token = Symbol(projectKey);
+	entry.waiters.set(token, false);
+	const maybeAbortSharedMigration = () => {
+		entry?.waiters.set(token, true);
+		if (!entry?.persistentOwner && [...entry.waiters.values()].every(Boolean)) entry.controller.abort(signal.reason);
+	};
+	signal.addEventListener("abort", maybeAbortSharedMigration, { once: true });
+	if (signal.aborted) maybeAbortSharedMigration();
+	return entry.task.then((result) => {
+		signal.throwIfAborted();
+		return result;
+	}, (error) => {
+		signal.throwIfAborted();
+		throw error;
+	}).finally(() => {
+		signal.removeEventListener("abort", maybeAbortSharedMigration);
+		entry?.waiters.delete(token);
+	});
 }
 function formatAutomaticStateMigrationBlock(result) {
 	return `State migration for ${result.projectKey} is blocked: ${result.reason} Overdeck will not start pipeline work because that would write permanent state into the legacy project checkout. Resolve the stated prerequisite, then run "pan sync"; do not commit project-root .pan/ or .beads/ files.`;
@@ -62514,6 +62872,7 @@ function decideDeaconBootGate(migrations) {
 //#region main.ts
 init_issue_service_singleton();
 init_tracker_config();
+init_internal_token();
 init_review_status();
 init_event_store();
 init_activity_logger();
@@ -62528,16 +62887,34 @@ init_projects();
 initDashboardLogFile();
 console.log(`[boot-timing] module graph loaded at +${Math.round(performance.now())}ms (since process start)`);
 console.log(`[overdeck] Boot gates: ${formatBootGateState(resolveBootGates())}`);
-startEventLoopMonitor();
-console.log("[overdeck] Event loop delay monitor started");
 await mkdir(getOverdeckHome(), { recursive: true });
 ensureInternalTokenSync();
-warnIfAutonomousMergeBackendUnavailable();
-warnIfAppCannotMerge();
 await ensureManagedTmuxContextOnce();
 await initTrackerConfigCache().catch((err) => {
 	console.log("[tracker-config] Warning: failed to cache .overdeck.env:", err.message);
 });
+try {
+	const overdeckDbPath = getOverdeckDatabasePath();
+	if (!existsSync$1(overdeckDbPath)) {
+		createOverdeckDatabase({ dbPath: overdeckDbPath });
+		console.log(`[overdeck] Created overdeck.db at ${overdeckDbPath}`);
+	}
+} catch (err) {
+	console.warn("[overdeck] Overdeck db init failed (non-fatal):", err);
+}
+const main = runServer.pipe(Effect.provide(ServerConfigLayer));
+if (typeof Bun !== "undefined") {
+	const { runMain } = await import("@effect/platform-bun/BunRuntime");
+	runMain(main);
+} else {
+	const { runMain } = await import("@effect/platform-node/NodeRuntime");
+	runMain(main);
+}
+await whenDashboardListening();
+startEventLoopMonitor();
+console.log("[overdeck] Event loop delay monitor started");
+warnIfAutonomousMergeBackendUnavailable();
+warnIfAppCannotMerge();
 const isPeerDashboard = process.env.OVERDECK_DISABLE_DEACON === "1";
 if (isPeerDashboard) {
 	startSharedIssueService({ skipPolling: true });
@@ -62575,7 +62952,7 @@ if (shouldStartStaleCheckRetriggerService()) {
 }
 if (process.env.OVERDECK_MODE === "desktop") (async () => {
 	try {
-		const { provisionClaudeHooks } = await import("./claude-hooks-provision-CS5W_dhI.js");
+		const { provisionClaudeHooks } = await import("./claude-hooks-provision-C8wdRnN1.js");
 		const result = await provisionClaudeHooks();
 		if (!result.ok) console.warn(`[overdeck] Claude hook provisioning skipped: ${result.reason}`);
 		else if (result.changed) console.log(`[overdeck] Claude hooks provisioned: ${result.binariesSynced} scripts, registered ${result.registered.length} hook(s)${result.pruned.length ? `, pruned ${result.pruned.length} stale` : ""}`);
@@ -62802,7 +63179,8 @@ setMergeReadyNotifier((issueId) => {
 console.log("[overdeck] Merge-ready notifier → domain events wired");
 startConversationLifecycleService();
 console.log("[overdeck] ConversationLifecycleService started");
-startSubstrateBugPoller();
+if (isPeerDashboard) console.log("[overdeck] SubstrateBugPoller skipped — peer dashboard does not poll trackers");
+else startSubstrateBugPoller();
 if (startUatTrainReconciler()) console.log("[overdeck] UAT batch-train reconciler started");
 else console.log("[overdeck] UAT batch-train reconciler skipped — non-primary dashboard process");
 const attachmentCleanupTimer = setInterval(() => {
@@ -62821,8 +63199,31 @@ startCostReconcileService();
 console.log("[overdeck] Cost reconciler started");
 const conversationSearchWatcher = startConversationSearchWatcher();
 console.log(conversationSearchWatcher ? "[overdeck] Conversation search watcher started" : "[overdeck] Conversation search watcher skipped (conversationSearch.enabled=false)");
+let stopResourceRefreshServices = () => void 0;
 (async () => {
-	(await initEventStore()).subscribe((event) => {
+	const store = await initEventStore();
+	whenDashboardListening().then(async () => {
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		const stopTriggers = startResourceRefreshTriggers();
+		const stopConvergence = startProjectResourceConvergence();
+		const stopResourcesSnapshot = startResourcesSnapshotService();
+		stopResourceRefreshServices = () => {
+			stopTriggers();
+			stopConvergence();
+			stopResourcesSnapshot();
+			stopProjectResourceRefreshQueue();
+		};
+		console.log("[overdeck] Project resource refresh queue and resources snapshot service started");
+		const warmStart = Date.now();
+		enqueueProjectsResourceRefresh(listProjectsSync().map((entry) => entry.config), "boot-warm");
+		await whenProjectResourceRefreshIdle();
+		const queueState = getProjectResourceRefreshQueueState();
+		if (queueState.lastError) console.warn("[overdeck] Boot cache warm completed with errors:", queueState.lastError);
+		else console.log(`[overdeck] Boot cache warm complete in ${Math.round((Date.now() - warmStart) / 1e3)}s`);
+	}).catch((err) => {
+		console.warn("[overdeck] Resource refresh startup failed:", err instanceof Error ? err.message : String(err));
+	});
+	store.subscribe((event) => {
 		if (event.type === "agent.stopped" || event.type === "agent.heartbeat_dead") {
 			const agentId = typeof event.payload.agentId === "string" ? event.payload.agentId : null;
 			if (agentId) reconcileAgentMemory(agentId).catch((err) => console.warn("[memory-reconciliation] agent sweep failed:", err?.message ?? err));
@@ -62878,6 +63279,7 @@ const handleShutdownSignal = async (signal) => {
 	if (forkGrace.count > 0) if (forkGrace.completed) console.log(`[overdeck] Waited for ${forkGrace.count} in-flight fork pipeline(s) before shutdown`);
 	else console.warn(`[overdeck] ${forkGrace.count} in-flight fork pipeline(s) still running after shutdown grace window`);
 	clearInterval(attachmentCleanupTimer);
+	stopResourceRefreshServices();
 	stopAgentEnrichmentService();
 	stopAgentOutputService();
 	stopConversationLifecycleService();
@@ -62893,7 +63295,7 @@ const handleShutdownSignal = async (signal) => {
 	stopRestartAnnouncer();
 	await stopDeaconChild().catch((err) => console.warn("[deacon-supervisor] child shutdown failed:", err?.message ?? err));
 	try {
-		const { killAllGateProcessGroups } = await import("./validation-CUWamZ4X.js");
+		const { killAllGateProcessGroups } = await import("./validation-CIi6pnI2.js");
 		const reaped = killAllGateProcessGroups();
 		if (reaped > 0) console.log(`[overdeck] reaped ${reaped} in-flight gate process group(s)`);
 	} catch (err) {
@@ -62948,7 +63350,7 @@ reconcileStaleGitHubBlockers().then((n) => {
 	}
 }).catch((err) => console.warn(`[overdeck] Startup blocker reconciliation failed: ${err.message}`));
 try {
-	const { resetProcessingToQueued } = await import("./merge-sync-CpGA9Kg7.js");
+	const { resetProcessingToQueued } = await import("./merge-sync-SSv3E-pl.js");
 	const resetCount = resetProcessingToQueued();
 	if (resetCount > 0) {
 		console.log(`[overdeck] Reset ${resetCount} stuck merge queue entries to queued`);
@@ -62970,7 +63372,7 @@ else {
 	console.log("[overdeck] Auto-merge executor started");
 }
 try {
-	const { reconcileInterruptedVerifications } = await import("./verification-runner-Dcksl_P-.js");
+	const { reconcileInterruptedVerifications } = await import("./verification-runner-CDj4lD4t.js");
 	const interrupted = reconcileInterruptedVerifications();
 	if (interrupted > 0) console.log(`[overdeck] recovered ${interrupted} orphaned verification worker(s)`);
 } catch (err) {
@@ -63009,7 +63411,9 @@ if (process.env.OVERDECK_DISABLE_DEACON === "1") {
 				message: summary
 			});
 		}
-		if (startBootReconciliation({ onGraceExpired: applyBootReconciliationDecision }).decision !== "pending") applyBootReconciliationDecision();
+		if (startBootReconciliation({ onGraceExpired: async () => {
+			await applyBootReconciliationDecision();
+		} }).decision !== "pending") applyBootReconciliationDecision();
 		startDeaconChild().catch((err) => {
 			console.error("[overdeck] Cloister auto-start failed:", err);
 			emitActivityEntrySync({
@@ -63059,25 +63463,6 @@ async function pruneClosedIssueReviewStatuses() {
 	} catch {}
 	if (removed > 0) console.log(`[overdeck] Pruned ${removed} stale review-status entr${removed === 1 ? "y" : "ies"} for closed issues`);
 }
-await (async () => {
-	try {
-		const overdeckDbPath = getOverdeckDatabasePath();
-		if (!existsSync$1(overdeckDbPath)) {
-			createOverdeckDatabase({ dbPath: overdeckDbPath });
-			console.log(`[overdeck] Created overdeck.db at ${overdeckDbPath}`);
-		}
-	} catch (err) {
-		console.warn("[overdeck] Overdeck db init failed (non-fatal):", err);
-	}
-})();
-const main = runServer.pipe(Effect.provide(ServerConfigLayer));
-if (typeof Bun !== "undefined") {
-	const { runMain } = await import("@effect/platform-bun/BunRuntime");
-	runMain(main);
-} else {
-	const { runMain } = await import("@effect/platform-node/NodeRuntime");
-	runMain(main);
-}
 //#endregion
 export {};