@openscout/scout 0.2.95 → 0.2.96

package/dist/main.mjs

@@ -903,6 +903,11 @@ function buildScoutReturnAddress(input) {
   return next;
 }
 
+// ../protocol/src/conversation-projection.ts
+function scoutConversationFeedId(conversationId) {
+  return `conv:${conversationId}`;
+}
+
 // ../protocol/src/channel-identity.ts
 function mintChannelId(randomUuid) {
   return `${CHAT_ID_PREFIX}${randomUuid().toLowerCase().replace(/-/g, "")}`;
@@ -1589,12 +1594,16 @@ var init_host_integrations = () => {};
 // ../protocol/src/native-interactions.ts
 var init_native_interactions = () => {};
 
+// ../protocol/src/session-handle.ts
+var SCOUT_SESSION_HANDLE_PREFIX = "sess.";
+var init_session_handle = () => {};
+
 // ../protocol/src/runtime-catalog.generated.ts
 var SCOUT_RUNTIME_CATALOG_DATA;
 var init_runtime_catalog_generated = __esm(() => {
   SCOUT_RUNTIME_CATALOG_DATA = {
     schemaVersion: "openscout.runtime-catalog.v1",
-    revision: "2026-08-18.1",
+    revision: "2026-09-01.1",
     harnesses: [
       {
         id: "claude",
@@ -1618,6 +1627,13 @@ var init_runtime_catalog_generated = __esm(() => {
             family: "Opus",
             version: "5"
           },
+          {
+            id: "claude-fable-5",
+            label: "Fable 5",
+            enabled: true,
+            family: "Fable",
+            version: "5"
+          },
           {
             id: "claude-sonnet-4-6",
             label: "Sonnet 4.6",
@@ -2543,6 +2559,7 @@ var init_broker_routes = __esm(() => {
       home: "/v1/home",
       node: "/v1/node",
       snapshot: "/v1/snapshot",
+      conversationProjection: "/v1/conversation-projection",
       capabilities: "/v1/capabilities",
       runtimeCatalog: "/v1/runtime-catalog",
       topologySnapshot: "/v1/topology/snapshot",
@@ -2614,6 +2631,7 @@ var init_src = __esm(() => {
   init_budget();
   init_host_integrations();
   init_native_interactions();
+  init_session_handle();
   init_runtime_profiles();
   init_runtime_execution();
   init_runtime_catalog();
@@ -9590,8 +9608,18 @@ async function maybeReadJsonFromActiveScoutBrokerService(baseUrl, path) {
     return handled(await service.readNode());
   }
   if (url.pathname === "/v1/snapshot") {
+    const requestedScope = url.searchParams.get("scope");
     return handled(await service.readSnapshot({
-      since: parsePositiveInt(url.searchParams.get("since")) ?? null
+      since: parsePositiveInt(url.searchParams.get("since")) ?? null,
+      scope: requestedScope === "conversations" || requestedScope === "agents" ? requestedScope : undefined
+    }));
+  }
+  if (url.pathname === "/v1/conversation-projection") {
+    if (!service.readConversationProjection) {
+      return unhandled();
+    }
+    return handled(await service.readConversationProjection({
+      limit: parseLimit(url.searchParams.get("limit"))
     }));
   }
   if (url.pathname === "/v1/capabilities") {
@@ -12270,11 +12298,32 @@ function resolveBundledRuntimeDirFromModuleDir(moduleDir) {
     resolve6(moduleDir, "..", "..")
   ];
   for (const candidate of candidates) {
-    if (isInstalledRuntimePackageDir(candidate))
-      return candidate;
+    if (!isInstalledRuntimePackageDir(candidate))
+      continue;
+    const sourceWorkspaceRuntime = resolveSourceWorkspaceRuntimeDir(candidate);
+    if (sourceWorkspaceRuntime)
+      return sourceWorkspaceRuntime;
+    return candidate;
   }
   return null;
 }
+function resolveSourceWorkspaceRuntimeDir(bundledPackageDir) {
+  const packagesDir = dirname9(bundledPackageDir);
+  if (resolve6(packagesDir, "cli") !== resolve6(bundledPackageDir))
+    return null;
+  const runtimeDir = join11(packagesDir, "runtime");
+  if (!existsSync9(join11(runtimeDir, "src")))
+    return null;
+  if (!isInstalledRuntimePackageDir(runtimeDir))
+    return null;
+  try {
+    const cliPackage = JSON.parse(readFileSync6(join11(bundledPackageDir, "package.json"), "utf8"));
+    const runtimePackage = JSON.parse(readFileSync6(join11(runtimeDir, "package.json"), "utf8"));
+    return cliPackage.name === "@openscout/scout" && runtimePackage.name === "@openscout/runtime" ? runtimeDir : null;
+  } catch {
+    return null;
+  }
+}
 function findWorkspaceRuntimeDir(startDir) {
   let current = resolve6(startDir);
   while (true) {
@@ -33490,26 +33539,6 @@ var init_local_agents = __esm(() => {
   TMUX_DEFAULT_ROWS = parsePositiveInteger2(process.env.OPENSCOUT_LOCAL_AGENT_TMUX_ROWS, 48);
 });
 
-// ../../apps/desktop/src/core/broker/paths.ts
-var openAiAudioSpeechUrl = "https://api.openai.com/v1/audio/speech";
-var init_paths = __esm(() => {
-  init_src();
-});
-
-// ../../apps/desktop/src/core/broker/ask-metadata.ts
-function buildScoutAskMetadata(input) {
-  return {
-    source: input.source,
-    ...input.workRecordId ? {
-      collaborationRecordId: input.workRecordId,
-      workId: input.workRecordId
-    } : {},
-    ...input.senderContext ? { senderContext: input.senderContext } : {},
-    ...input.workspace ? { askWorkspace: input.workspace } : {},
-    ...input.labels ? { labels: input.labels } : {}
-  };
-}
-
 // ../runtime/src/registry.ts
 function createRuntimeRegistrySnapshot(value = {}) {
   return {
@@ -33532,6 +33561,26 @@ var init_registry3 = __esm(() => {
   TERMINAL_COLLABORATION_STATES = new Set(["done", "cancelled", "closed", "declined"]);
 });
 
+// ../../apps/desktop/src/core/broker/paths.ts
+var openAiAudioSpeechUrl = "https://api.openai.com/v1/audio/speech";
+var init_paths = __esm(() => {
+  init_src();
+});
+
+// ../../apps/desktop/src/core/broker/ask-metadata.ts
+function buildScoutAskMetadata(input) {
+  return {
+    source: input.source,
+    ...input.workRecordId ? {
+      collaborationRecordId: input.workRecordId,
+      workId: input.workRecordId
+    } : {},
+    ...input.senderContext ? { senderContext: input.senderContext } : {},
+    ...input.workspace ? { askWorkspace: input.workspace } : {},
+    ...input.labels ? { labels: input.labels } : {}
+  };
+}
+
 // ../runtime/src/planner.ts
 function createDeliveryId(messageId, targetId, reason, transport) {
   return `del-${messageId}-${targetId}-${reason}-${transport}`;
@@ -37881,7 +37930,7 @@ var init_sqlite_core = __esm(() => {
 });
 
 // ../runtime/src/drizzle-schema.ts
-var epochMsNow, nodesTable, trustedPeersTable, peerNoncesTable, actorsTable, agentsTable, agentEndpointsTable, runtimeSessionsTable, runtimeSessionAliasesTable, routeAliasBindingsTable, routeAliasRevisionsTable, conversationsTable, conversationMembersTable, messagesTable, messageMentionsTable, messageAttachmentsTable, conversationReadCursorsTable, invocationsTable, flightsTable, bindingsTable, deliveriesTable, deliveryAttemptsTable, durableActionsTable, durableAttemptsTable, durableCheckpointsTable, durableSignalsTable, collaborationRecordsTable, collaborationEventsTable, contextBlocksTable, contextPacksTable, eventsTable, threadEventsTable, threadCursorsTable, scoutDispatchesTable, activityItemsTable, budgetUsageEventsTable, budgetQuotaWindowSnapshotsTable, mobilePushRegistrationsTable, briefingsTable, roleAssignmentsTable, missionLogEntriesTable, controlPlaneDrizzleSchema;
+var epochMsNow, nodesTable, trustedPeersTable, peerNoncesTable, actorsTable, agentsTable, agentEndpointsTable, runtimeSessionsTable, runtimeSessionAliasesTable, routeAliasBindingsTable, routeAliasRevisionsTable, conversationsTable, conversationMembersTable, messagesTable, messageMentionsTable, messageAttachmentsTable, conversationReadCursorsTable, brokerJournalProjectionCheckpointsTable, conversationProjectionMetaTable, conversationProjectionItemsTable, conversationProjectionMessageFactsTable, conversationProjectionMessageStatsTable, conversationProjectionSourcesTable, conversationProjectionEventsTable, invocationsTable, flightsTable, bindingsTable, deliveriesTable, deliveryAttemptsTable, durableActionsTable, durableAttemptsTable, durableCheckpointsTable, durableSignalsTable, collaborationRecordsTable, collaborationEventsTable, contextBlocksTable, contextPacksTable, eventsTable, threadEventsTable, threadCursorsTable, scoutDispatchesTable, activityItemsTable, budgetUsageEventsTable, budgetQuotaWindowSnapshotsTable, mobilePushRegistrationsTable, briefingsTable, roleAssignmentsTable, missionLogEntriesTable, controlPlaneDrizzleSchema;
 var init_drizzle_schema = __esm(() => {
   init_drizzle_orm();
   init_sqlite_core();
@@ -37953,7 +38002,10 @@ var init_drizzle_schema = __esm(() => {
     advertiseScope: text("advertise_scope").notNull(),
     ownerId: text("owner_id"),
     metadataJson: text("metadata_json")
-  });
+  }, (table3) => [
+    index("idx_agents_home_node_id").on(table3.homeNodeId),
+    index("idx_agents_authority_node_id").on(table3.authorityNodeId)
+  ]);
   agentEndpointsTable = sqliteTable("agent_endpoints", {
     id: text("id").primaryKey(),
     agentId: text("agent_id").notNull().references(() => agentsTable.id, { onDelete: "cascade" }),
@@ -37969,7 +38021,14 @@ var init_drizzle_schema = __esm(() => {
     metadataJson: text("metadata_json"),
     updatedAt: integer("updated_at").notNull().default(epochMsNow)
   }, (table3) => [
-    index("idx_agent_endpoints_agent_updated_at").on(table3.agentId, desc(table3.updatedAt))
+    index("idx_agent_endpoints_agent_updated_at").on(table3.agentId, desc(table3.updatedAt)),
+    index("idx_agent_endpoints_roster_recency").on(desc(sql`CASE
+      WHEN ${table3.updatedAt} IS NULL THEN NULL
+      WHEN CAST(${table3.updatedAt} AS REAL) < 1000000000000
+        THEN CAST(CAST(${table3.updatedAt} AS REAL) * 1000 AS INTEGER)
+      ELSE CAST(${table3.updatedAt} AS INTEGER)
+    END`), table3.agentId),
+    index("idx_agent_endpoints_node_id").on(table3.nodeId)
   ]);
   runtimeSessionsTable = sqliteTable("runtime_sessions", {
     id: text("id").primaryKey(),
@@ -37993,6 +38052,7 @@ var init_drizzle_schema = __esm(() => {
   }, (table3) => [
     index("idx_runtime_sessions_agent_last_seen").on(table3.agentId, desc(table3.lastSeenAt)),
     index("idx_runtime_sessions_endpoint_last_seen").on(table3.endpointId, desc(table3.lastSeenAt)),
+    index("idx_runtime_sessions_node_id").on(table3.nodeId),
     index("idx_runtime_sessions_external").on(table3.externalSessionId),
     index("idx_runtime_sessions_expires").on(table3.expiresAt).where(sql`expires_at IS NOT NULL`)
   ]);
@@ -38012,6 +38072,8 @@ var init_drizzle_schema = __esm(() => {
     primaryKey({ columns: [table3.alias, table3.sessionId] }),
     index("idx_runtime_session_aliases_alias").on(table3.alias, desc(table3.lastSeenAt)),
     index("idx_runtime_session_aliases_session").on(table3.sessionId),
+    index("idx_runtime_session_aliases_endpoint").on(table3.endpointId),
+    index("idx_runtime_session_aliases_node_id").on(table3.nodeId),
     index("idx_runtime_session_aliases_expires").on(table3.expiresAt).where(sql`expires_at IS NOT NULL`)
   ]);
   routeAliasBindingsTable = sqliteTable("route_alias_bindings", {
@@ -38091,7 +38153,8 @@ var init_drizzle_schema = __esm(() => {
     actorId: text("actor_id").notNull().references(() => actorsTable.id, { onDelete: "cascade" }),
     role: text("role")
   }, (table3) => [
-    primaryKey({ columns: [table3.conversationId, table3.actorId] })
+    primaryKey({ columns: [table3.conversationId, table3.actorId] }),
+    index("idx_conversation_members_actor").on(table3.actorId, table3.conversationId)
   ]);
   messagesTable = sqliteTable("messages", {
     id: text("id").primaryKey(),
@@ -38111,7 +38174,8 @@ var init_drizzle_schema = __esm(() => {
   }, (table3) => [
     index("idx_messages_conversation_created_at").on(table3.conversationId, table3.createdAt),
     index("idx_messages_created_at").on(desc(table3.createdAt)),
-    index("idx_messages_actor_created_at").on(table3.actorId, desc(table3.createdAt))
+    index("idx_messages_actor_created_at").on(table3.actorId, desc(table3.createdAt)),
+    index("idx_messages_origin_node_id").on(table3.originNodeId)
   ]);
   messageMentionsTable = sqliteTable("message_mentions", {
     messageId: text("message_id").notNull().references(() => messagesTable.id, { onDelete: "cascade" }),
@@ -38140,7 +38204,102 @@ var init_drizzle_schema = __esm(() => {
     metadataJson: text("metadata_json")
   }, (table3) => [
     primaryKey({ columns: [table3.conversationId, table3.actorId] }),
-    index("idx_read_cursors_conversation_updated_at").on(table3.conversationId, desc(table3.updatedAt))
+    index("idx_read_cursors_conversation_updated_at").on(table3.conversationId, desc(table3.updatedAt)),
+    index("idx_read_cursors_reader_node_id").on(table3.readerNodeId)
+  ]);
+  brokerJournalProjectionCheckpointsTable = sqliteTable("broker_journal_projection_checkpoints", {
+    projectionId: text("projection_id").primaryKey(),
+    projectionVersion: integer("projection_version").notNull(),
+    barrierId: text("barrier_id").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  });
+  conversationProjectionMetaTable = sqliteTable("conversation_projection_meta", {
+    singleton: integer("singleton").primaryKey(),
+    projectionId: text("projection_id").notNull(),
+    projectionVersion: integer("projection_version").notNull(),
+    headSeq: integer("head_seq").notNull(),
+    minReplayableSeq: integer("min_replayable_seq").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  }, (table3) => [
+    check("conversation_projection_meta_singleton_check", sql`${table3.singleton} = 1`)
+  ]);
+  conversationProjectionItemsTable = sqliteTable("conversation_projection_items", {
+    feedId: text("feed_id").primaryKey(),
+    entityKind: text("entity_kind").notNull(),
+    kind: text("kind").notNull(),
+    conversationId: text("conversation_id"),
+    runtimeSessionId: text("runtime_session_id"),
+    source: text("source"),
+    sourceSessionId: text("source_session_id"),
+    title: text("title"),
+    alias: text("alias"),
+    naturalKey: text("natural_key"),
+    projectRoot: text("project_root"),
+    harness: text("harness"),
+    model: text("model"),
+    effort: text("effort"),
+    agentId: text("agent_id"),
+    agentName: text("agent_name"),
+    currentBranch: text("current_branch"),
+    authorityNodeId: text("authority_node_id"),
+    authorityNodeName: text("authority_node_name"),
+    parentConversationId: text("parent_conversation_id"),
+    anchorMessageId: text("anchor_message_id"),
+    activityState: text("activity_state").notNull(),
+    lastMessageId: text("last_message_id"),
+    lastMessageAt: integer("last_message_at"),
+    lastActivityAt: integer("last_activity_at").notNull(),
+    messageCount: integer("message_count").notNull().default(0),
+    unreadCount: integer("unread_count").notNull().default(0),
+    participantCount: integer("participant_count").notNull().default(0),
+    preview: text("preview"),
+    lastEngagedAt: integer("last_engaged_at"),
+    sourceFreshAt: integer("source_fresh_at"),
+    visibilityState: text("visibility_state").notNull().default("visible"),
+    updatedSeq: integer("updated_seq").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  }, (table3) => [
+    check("conversation_projection_items_entity_kind_check", sql`${table3.entityKind} IN ('scout_conversation', 'observed_session')`),
+    check("conversation_projection_items_visibility_check", sql`${table3.visibilityState} IN ('visible', 'hidden')`),
+    index("idx_conversation_projection_recent").on(table3.visibilityState, desc(table3.lastActivityAt), table3.feedId),
+    index("idx_conversation_projection_project_recent").on(table3.projectRoot, table3.visibilityState, desc(table3.lastActivityAt)),
+    index("idx_conversation_projection_engaged").on(table3.visibilityState, desc(table3.lastEngagedAt), desc(table3.lastActivityAt), table3.feedId),
+    index("idx_conversation_projection_source_fresh").on(table3.visibilityState, desc(table3.sourceFreshAt)),
+    index("idx_conversation_projection_runtime_session").on(table3.entityKind, table3.runtimeSessionId),
+    index("idx_conversation_projection_source_session").on(table3.entityKind, table3.sourceSessionId),
+    uniqueIndex("idx_conversation_projection_conversation").on(table3.conversationId).where(sql`conversation_id IS NOT NULL`)
+  ]);
+  conversationProjectionMessageFactsTable = sqliteTable("conversation_projection_message_facts", {
+    messageId: text("message_id").primaryKey().references(() => messagesTable.id, { onDelete: "cascade" }),
+    conversationId: text("conversation_id").notNull().references(() => conversationsTable.id, { onDelete: "cascade" }),
+    createdAt: integer("created_at").notNull()
+  }, (table3) => [
+    index("idx_conversation_projection_message_facts_conversation").on(table3.conversationId, table3.createdAt, table3.messageId)
+  ]);
+  conversationProjectionMessageStatsTable = sqliteTable("conversation_projection_message_stats", {
+    conversationId: text("conversation_id").primaryKey().references(() => conversationsTable.id, { onDelete: "cascade" }),
+    messageCount: integer("message_count").notNull().default(0),
+    latestMessageId: text("latest_message_id"),
+    latestMessageAt: integer("latest_message_at")
+  });
+  conversationProjectionSourcesTable = sqliteTable("conversation_projection_sources", {
+    source: text("source").notNull(),
+    sourceSessionId: text("source_session_id").notNull(),
+    feedId: text("feed_id").notNull().references(() => conversationProjectionItemsTable.feedId, { onDelete: "cascade" }),
+    firstSeenAt: integer("first_seen_at").notNull(),
+    lastSeenAt: integer("last_seen_at").notNull()
+  }, (table3) => [
+    primaryKey({ columns: [table3.source, table3.sourceSessionId] }),
+    index("idx_conversation_projection_sources_feed").on(table3.feedId)
+  ]);
+  conversationProjectionEventsTable = sqliteTable("conversation_projection_events", {
+    seq: integer("seq").primaryKey({ autoIncrement: true }),
+    projectionId: text("projection_id").notNull(),
+    ts: integer("ts").notNull(),
+    payloadJson: text("payload_json").notNull()
+  }, (table3) => [
+    index("idx_conversation_projection_events_projection_seq").on(table3.projectionId, table3.seq),
+    index("idx_conversation_projection_events_ts").on(table3.ts)
   ]);
   invocationsTable = sqliteTable("invocations", {
     id: text("id").primaryKey(),
@@ -38172,7 +38331,10 @@ var init_drizzle_schema = __esm(() => {
     executionResolutionJson: text("execution_resolution_json")
   }, (table3) => [
     index("idx_invocations_target_created_at").on(table3.targetAgentId, table3.createdAt),
-    index("idx_invocations_requester_created_at").on(table3.requesterId, desc(table3.createdAt))
+    index("idx_invocations_requester_created_at").on(table3.requesterId, desc(table3.createdAt)),
+    index("idx_invocations_conversation_created_at").on(table3.conversationId, desc(table3.createdAt)),
+    index("idx_invocations_requester_node_id").on(table3.requesterNodeId),
+    index("idx_invocations_target_node_id").on(table3.targetNodeId)
   ]);
   flightsTable = sqliteTable("flights", {
     id: text("id").primaryKey(),
@@ -38218,7 +38380,8 @@ var init_drizzle_schema = __esm(() => {
     createdAt: integer("created_at").notNull().default(epochMsNow)
   }, (table3) => [
     index("idx_deliveries_status_transport").on(table3.status, table3.transport),
-    index("idx_deliveries_created_at").on(desc(table3.createdAt))
+    index("idx_deliveries_created_at").on(desc(table3.createdAt)),
+    index("idx_deliveries_target_node_id").on(table3.targetNodeId)
   ]);
   deliveryAttemptsTable = sqliteTable("delivery_attempts", {
     id: text("id").primaryKey(),
@@ -38388,7 +38551,8 @@ var init_drizzle_schema = __esm(() => {
   }, (table3) => [
     unique2().on(table3.conversationId, table3.seq),
     index("idx_thread_events_conversation_seq").on(table3.conversationId, desc(table3.seq)),
-    index("idx_thread_events_conversation_ts").on(table3.conversationId, desc(table3.ts))
+    index("idx_thread_events_conversation_ts").on(table3.conversationId, desc(table3.ts)),
+    index("idx_thread_events_authority_node_id").on(table3.authorityNodeId)
   ]);
   threadCursorsTable = sqliteTable("thread_cursors", {
     conversationId: text("conversation_id").notNull().references(() => conversationsTable.id, { onDelete: "cascade" }),
@@ -38396,7 +38560,8 @@ var init_drizzle_schema = __esm(() => {
     lastAppliedSeq: integer("last_applied_seq").notNull(),
     updatedAt: integer("updated_at").notNull()
   }, (table3) => [
-    primaryKey({ columns: [table3.conversationId, table3.authorityNodeId] })
+    primaryKey({ columns: [table3.conversationId, table3.authorityNodeId] }),
+    index("idx_thread_cursors_authority_node_id").on(table3.authorityNodeId)
   ]);
   scoutDispatchesTable = sqliteTable("scout_dispatches", {
     id: text("id").primaryKey(),
@@ -38598,6 +38763,13 @@ var init_drizzle_schema = __esm(() => {
     messageMentions: messageMentionsTable,
     messageAttachments: messageAttachmentsTable,
     conversationReadCursors: conversationReadCursorsTable,
+    brokerJournalProjectionCheckpoints: brokerJournalProjectionCheckpointsTable,
+    conversationProjectionMeta: conversationProjectionMetaTable,
+    conversationProjectionItems: conversationProjectionItemsTable,
+    conversationProjectionMessageFacts: conversationProjectionMessageFactsTable,
+    conversationProjectionMessageStats: conversationProjectionMessageStatsTable,
+    conversationProjectionSources: conversationProjectionSourcesTable,
+    conversationProjectionEvents: conversationProjectionEventsTable,
     invocations: invocationsTable,
     flights: flightsTable,
     bindings: bindingsTable,
@@ -38667,6 +38839,8 @@ CREATE INDEX IF NOT EXISTS idx_runtime_sessions_agent_last_seen
   ON runtime_sessions (agent_id, last_seen_at DESC);
 CREATE INDEX IF NOT EXISTS idx_runtime_sessions_endpoint_last_seen
   ON runtime_sessions (endpoint_id, last_seen_at DESC);
+CREATE INDEX IF NOT EXISTS idx_runtime_sessions_node_id
+  ON runtime_sessions (node_id);
 CREATE INDEX IF NOT EXISTS idx_runtime_sessions_external
   ON runtime_sessions (external_session_id);
 CREATE INDEX IF NOT EXISTS idx_runtime_sessions_expires
@@ -38676,6 +38850,10 @@ CREATE INDEX IF NOT EXISTS idx_runtime_session_aliases_alias
   ON runtime_session_aliases (alias, last_seen_at DESC);
 CREATE INDEX IF NOT EXISTS idx_runtime_session_aliases_session
   ON runtime_session_aliases (session_id);
+CREATE INDEX IF NOT EXISTS idx_runtime_session_aliases_endpoint
+  ON runtime_session_aliases (endpoint_id);
+CREATE INDEX IF NOT EXISTS idx_runtime_session_aliases_node_id
+  ON runtime_session_aliases (node_id);
 CREATE INDEX IF NOT EXISTS idx_runtime_session_aliases_expires
   ON runtime_session_aliases (expires_at)
   WHERE expires_at IS NOT NULL;
@@ -38938,6 +39116,93 @@ CREATE TABLE IF NOT EXISTS conversation_read_cursors (
   PRIMARY KEY (conversation_id, actor_id)
 );
 
+CREATE TABLE IF NOT EXISTS broker_journal_projection_checkpoints (
+  projection_id TEXT PRIMARY KEY,
+  projection_version INTEGER NOT NULL,
+  barrier_id TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_meta (
+  singleton INTEGER PRIMARY KEY,
+  projection_id TEXT NOT NULL,
+  projection_version INTEGER NOT NULL,
+  head_seq INTEGER NOT NULL,
+  min_replayable_seq INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  CONSTRAINT conversation_projection_meta_singleton_check CHECK (singleton = 1)
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_items (
+  feed_id TEXT PRIMARY KEY,
+  entity_kind TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  conversation_id TEXT,
+  runtime_session_id TEXT,
+  source TEXT,
+  source_session_id TEXT,
+  title TEXT,
+  alias TEXT,
+  natural_key TEXT,
+  project_root TEXT,
+  harness TEXT,
+  model TEXT,
+  effort TEXT,
+  agent_id TEXT,
+  agent_name TEXT,
+  current_branch TEXT,
+  authority_node_id TEXT,
+  authority_node_name TEXT,
+  parent_conversation_id TEXT,
+  anchor_message_id TEXT,
+  activity_state TEXT NOT NULL,
+  last_message_id TEXT,
+  last_message_at INTEGER,
+  last_activity_at INTEGER NOT NULL,
+  message_count INTEGER NOT NULL DEFAULT 0,
+  unread_count INTEGER NOT NULL DEFAULT 0,
+  participant_count INTEGER NOT NULL DEFAULT 0,
+  preview TEXT,
+  last_engaged_at INTEGER,
+  source_fresh_at INTEGER,
+  visibility_state TEXT NOT NULL DEFAULT 'visible',
+  updated_seq INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  CONSTRAINT conversation_projection_items_entity_kind_check
+    CHECK (entity_kind IN ('scout_conversation', 'observed_session')),
+  CONSTRAINT conversation_projection_items_visibility_check
+    CHECK (visibility_state IN ('visible', 'hidden'))
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_message_facts (
+  message_id TEXT PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_message_stats (
+  conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+  message_count INTEGER NOT NULL DEFAULT 0,
+  latest_message_id TEXT,
+  latest_message_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_sources (
+  source TEXT NOT NULL,
+  source_session_id TEXT NOT NULL,
+  feed_id TEXT NOT NULL REFERENCES conversation_projection_items(feed_id) ON DELETE CASCADE,
+  first_seen_at INTEGER NOT NULL,
+  last_seen_at INTEGER NOT NULL,
+  PRIMARY KEY (source, source_session_id)
+);
+
+CREATE TABLE IF NOT EXISTS conversation_projection_events (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  projection_id TEXT NOT NULL,
+  ts INTEGER NOT NULL,
+  payload_json TEXT NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS invocations (
   id TEXT PRIMARY KEY,
   requester_id TEXT NOT NULL REFERENCES actors(id) ON DELETE RESTRICT,
@@ -39345,18 +39610,74 @@ CREATE INDEX IF NOT EXISTS idx_peer_nonces_seen_at
   ON peer_nonces (seen_at);
 CREATE INDEX IF NOT EXISTS idx_agent_endpoints_agent_updated_at
   ON agent_endpoints (agent_id, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_agent_endpoints_roster_recency
+  ON agent_endpoints (
+    CASE
+      WHEN updated_at IS NULL THEN NULL
+      WHEN CAST(updated_at AS REAL) < 1000000000000
+        THEN CAST(CAST(updated_at AS REAL) * 1000 AS INTEGER)
+      ELSE CAST(updated_at AS INTEGER)
+    END DESC,
+    agent_id
+  );
+CREATE INDEX IF NOT EXISTS idx_agents_home_node_id
+  ON agents (home_node_id);
+CREATE INDEX IF NOT EXISTS idx_agents_authority_node_id
+  ON agents (authority_node_id);
+CREATE INDEX IF NOT EXISTS idx_agent_endpoints_node_id
+  ON agent_endpoints (node_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_members_actor
+  ON conversation_members (actor_id, conversation_id);
 CREATE INDEX IF NOT EXISTS idx_messages_conversation_created_at
   ON messages (conversation_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_messages_created_at
   ON messages (created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_messages_actor_created_at
   ON messages (actor_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_messages_origin_node_id
+  ON messages (origin_node_id);
 CREATE INDEX IF NOT EXISTS idx_read_cursors_conversation_updated_at
   ON conversation_read_cursors (conversation_id, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_read_cursors_reader_node_id
+  ON conversation_read_cursors (reader_node_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_recent
+  ON conversation_projection_items (visibility_state, last_activity_at DESC, feed_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_project_recent
+  ON conversation_projection_items (project_root, visibility_state, last_activity_at DESC);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_message_facts_conversation
+  ON conversation_projection_message_facts (conversation_id, created_at, message_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_engaged
+  ON conversation_projection_items (
+    visibility_state,
+    last_engaged_at DESC,
+    last_activity_at DESC,
+    feed_id
+  );
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_source_fresh
+  ON conversation_projection_items (visibility_state, source_fresh_at DESC);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_runtime_session
+  ON conversation_projection_items (entity_kind, runtime_session_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_source_session
+  ON conversation_projection_items (entity_kind, source_session_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_conversation_projection_conversation
+  ON conversation_projection_items (conversation_id)
+  WHERE conversation_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_sources_feed
+  ON conversation_projection_sources (feed_id);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_events_projection_seq
+  ON conversation_projection_events (projection_id, seq);
+CREATE INDEX IF NOT EXISTS idx_conversation_projection_events_ts
+  ON conversation_projection_events (ts);
 CREATE INDEX IF NOT EXISTS idx_invocations_target_created_at
   ON invocations (target_agent_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_invocations_requester_created_at
   ON invocations (requester_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_invocations_conversation_created_at
+  ON invocations (conversation_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_invocations_requester_node_id
+  ON invocations (requester_node_id);
+CREATE INDEX IF NOT EXISTS idx_invocations_target_node_id
+  ON invocations (target_node_id);
 CREATE INDEX IF NOT EXISTS idx_flights_target_state
   ON flights (target_agent_id, state);
 CREATE INDEX IF NOT EXISTS idx_flights_invocation_id
@@ -39365,6 +39686,8 @@ CREATE INDEX IF NOT EXISTS idx_deliveries_status_transport
   ON deliveries (status, transport);
 CREATE INDEX IF NOT EXISTS idx_deliveries_created_at
   ON deliveries (created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_deliveries_target_node_id
+  ON deliveries (target_node_id);
 CREATE INDEX IF NOT EXISTS idx_delivery_attempts_created_at
   ON delivery_attempts (created_at DESC);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_durable_actions_idempotency_key
@@ -39411,6 +39734,10 @@ CREATE INDEX IF NOT EXISTS idx_thread_events_conversation_seq
   ON thread_events (conversation_id, seq DESC);
 CREATE INDEX IF NOT EXISTS idx_thread_events_conversation_ts
   ON thread_events (conversation_id, ts DESC);
+CREATE INDEX IF NOT EXISTS idx_thread_events_authority_node_id
+  ON thread_events (authority_node_id);
+CREATE INDEX IF NOT EXISTS idx_thread_cursors_authority_node_id
+  ON thread_cursors (authority_node_id);
 CREATE INDEX IF NOT EXISTS idx_activity_items_agent_ts
   ON activity_items (agent_id, ts DESC);
 CREATE INDEX IF NOT EXISTS idx_activity_items_actor_ts
@@ -40638,7 +40965,23 @@ CREATE INDEX IF NOT EXISTS idx_activity_items_ts
   ON activity_items(ts DESC);
 CREATE INDEX IF NOT EXISTS idx_conversations_created_at
   ON conversations(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_agent_endpoints_roster_recency
+  ON agent_endpoints (
+    CASE
+      WHEN updated_at IS NULL THEN NULL
+      WHEN CAST(updated_at AS REAL) < 1000000000000
+        THEN CAST(CAST(updated_at AS REAL) * 1000 AS INTEGER)
+      ELSE CAST(updated_at AS INTEGER)
+    END DESC,
+    agent_id
+  );
+`);
+        if (hasColumn(database, "conversations", "authority_node_id")) {
+          database.exec(`
+CREATE INDEX IF NOT EXISTS idx_conversations_authority_node_id
+  ON conversations(authority_node_id);
 `);
+        }
       }
     },
     {
@@ -41014,8 +41357,39 @@ var init_budget_observations2 = __esm(() => {
   QUOTA_HISTORY_BUCKET_MS = 60 * 60 * 1000;
 });
 
-// ../runtime/src/sqlite-store.ts
+// ../runtime/src/runtime-session-handle.ts
 import { createHash as createHash4 } from "crypto";
+function metadataStringValue(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstStringValue(...values) {
+  return values.find((value) => Boolean(value?.trim()))?.trim() ?? null;
+}
+function runtimeSessionPrimaryAlias(endpoint) {
+  const metadata = endpoint.metadata;
+  if (metadata?.cardless === true) {
+    return firstStringValue(metadataStringValue(metadata, "handle"), metadataStringValue(metadata, "externalSessionId"), metadataStringValue(metadata, "threadId"), endpoint.sessionId, endpoint.agentId);
+  }
+  return firstStringValue(metadataStringValue(metadata, "externalSessionId"), metadataStringValue(metadata, "threadId"), metadataStringValue(metadata, "nativeSessionId"), metadataStringValue(metadata, "pairingSessionId"), metadataStringValue(metadata, "sessionId"), endpoint.sessionId, metadataStringValue(metadata, "runtimeSessionId"), metadataStringValue(metadata, "runtimeInstanceId"), metadataStringValue(metadata, "tmuxSession"));
+}
+function runtimeSessionHandleForEndpoint(endpoint, primaryAlias = runtimeSessionPrimaryAlias(endpoint)) {
+  if (!primaryAlias)
+    return null;
+  const resolutionKey = [
+    endpoint.nodeId,
+    endpoint.harness,
+    primaryAlias
+  ].join("\x00");
+  const token = createHash4("sha256").update(resolutionKey).digest("hex").slice(0, 20);
+  return `${SCOUT_SESSION_HANDLE_PREFIX}${token}`;
+}
+var init_runtime_session_handle = __esm(() => {
+  init_src();
+});
+
+// ../runtime/src/sqlite-store.ts
+import { createHash as createHash5 } from "crypto";
 import { mkdirSync as mkdirSync7 } from "fs";
 import { dirname as dirname18 } from "path";
 function parseJson(value, fallback2) {
@@ -41027,6 +41401,16 @@ function parseJson(value, fallback2) {
     return fallback2;
   }
 }
+function isTransientSqliteBusyError(error) {
+  if (typeof error === "object" && error !== null) {
+    const code = error.code;
+    if (code === "SQLITE_BUSY" || code === "SQLITE_LOCKED") {
+      return true;
+    }
+  }
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return message.includes("database is locked") || message.includes("database is busy") || message.includes("sqlite_busy");
+}
 function stringify3(value) {
   return value === undefined ? null : JSON.stringify(value);
 }
@@ -41037,9 +41421,9 @@ function normalizeTimestampMs(value) {
   return epochMs(value);
 }
 function stableHash2(value, length = 20) {
-  return createHash4("sha256").update(value).digest("hex").slice(0, length);
+  return createHash5("sha256").update(value).digest("hex").slice(0, length);
 }
-function metadataStringValue(metadata, key) {
+function metadataStringValue2(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -41056,7 +41440,7 @@ function metadataTimestampValue(metadata, key) {
   }
   return null;
 }
-function firstStringValue(...values) {
+function firstStringValue2(...values) {
   for (const value of values) {
     const trimmed = value?.trim();
     if (trimmed) {
@@ -41274,16 +41658,9 @@ function runtimeSessionAliasFromRow(row) {
 function runtimeSessionMetadata(endpoint) {
   return endpoint.metadata ?? {};
 }
-function endpointRuntimeSessionPrimaryAlias(endpoint) {
-  const metadata = runtimeSessionMetadata(endpoint);
-  if (metadata.cardless === true) {
-    return firstStringValue(metadataStringValue(metadata, "handle"), metadataStringValue(metadata, "externalSessionId"), metadataStringValue(metadata, "threadId"), endpoint.sessionId, endpoint.agentId);
-  }
-  return firstStringValue(metadataStringValue(metadata, "externalSessionId"), metadataStringValue(metadata, "threadId"), metadataStringValue(metadata, "nativeSessionId"), metadataStringValue(metadata, "pairingSessionId"), metadataStringValue(metadata, "sessionId"), endpoint.sessionId, metadataStringValue(metadata, "runtimeSessionId"), metadataStringValue(metadata, "runtimeInstanceId"), metadataStringValue(metadata, "tmuxSession"));
-}
 function endpointRuntimeSessionExternalId(endpoint) {
   const metadata = runtimeSessionMetadata(endpoint);
-  return firstStringValue(metadataStringValue(metadata, "externalSessionId"), metadataStringValue(metadata, "threadId"), metadataStringValue(metadata, "nativeSessionId"), metadataStringValue(metadata, "pairingSessionId"));
+  return firstStringValue2(metadataStringValue2(metadata, "externalSessionId"), metadataStringValue2(metadata, "threadId"), metadataStringValue2(metadata, "nativeSessionId"), metadataStringValue2(metadata, "pairingSessionId"));
 }
 function endpointRuntimeSessionStartedAt(endpoint, fallback2) {
   const metadata = runtimeSessionMetadata(endpoint);
@@ -41299,16 +41676,6 @@ function endpointRuntimeSessionIsTerminal(endpoint) {
 function endpointRuntimeSessionState(endpoint) {
   return endpoint.metadata?.staleLocalRegistration === true ? "superseded" : endpoint.state;
 }
-function endpointRuntimeSessionId(endpoint, primaryAlias) {
-  const key = [
-    endpoint.nodeId,
-    endpoint.agentId,
-    endpoint.harness,
-    endpoint.transport,
-    primaryAlias
-  ].join("\x00");
-  return `sess.${stableHash2(key)}`;
-}
 function endpointRuntimeSessionAliases(endpoint, scoutSessionId) {
   const metadata = runtimeSessionMetadata(endpoint);
   const aliases = [
@@ -41319,12 +41686,12 @@ function endpointRuntimeSessionAliases(endpoint, scoutSessionId) {
     aliases.push({ alias: endpoint.sessionId.trim(), aliasKind: "endpoint_session" });
   }
   for (const entry of RUNTIME_SESSION_ALIAS_METADATA_KEYS) {
-    const value = metadataStringValue(metadata, entry.key);
+    const value = metadataStringValue2(metadata, entry.key);
     if (value) {
       aliases.push({ alias: value, aliasKind: entry.kind });
     }
   }
-  const provisionalHandle = metadataStringValue(metadata, "handle");
+  const provisionalHandle = metadataStringValue2(metadata, "handle");
   if (provisionalHandle) {
     aliases.push({ alias: provisionalHandle, aliasKind: "provisional" });
   }
@@ -41443,6 +41810,7 @@ class SQLiteControlPlaneStore {
   pendingEvents = [];
   flushPendingEventsTimer = null;
   conversationsApi = null;
+  closed = false;
   constructor(dbPath) {
     mkdirSync7(dirname18(dbPath), { recursive: true });
     this.db = openControlPlaneSqliteDatabase(dbPath, { create: true });
@@ -41461,6 +41829,9 @@ class SQLiteControlPlaneStore {
       }
     });
   }
+  get isClosed() {
+    return this.closed;
+  }
   listRuntimeSessions(options = {}) {
     const predicates = [];
     const params = [];
@@ -41717,6 +42088,10 @@ class SQLiteControlPlaneStore {
     };
   }
   close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
     this.flushPendingEvents();
     if (this.flushPendingEventsTimer) {
       clearTimeout(this.flushPendingEventsTimer);
@@ -41731,16 +42106,29 @@ class SQLiteControlPlaneStore {
     }
     const nextBatch = this.pendingEvents;
     this.pendingEvents = [];
-    this.persistEventsBatch(nextBatch);
+    try {
+      this.persistEventsBatch(nextBatch);
+    } catch (error) {
+      this.pendingEvents = [...nextBatch, ...this.pendingEvents];
+      throw error;
+    }
   }
-  schedulePendingEventFlush() {
+  schedulePendingEventFlush(delayMs = 0) {
     if (this.flushPendingEventsTimer) {
       return;
     }
     this.flushPendingEventsTimer = setTimeout(() => {
       this.flushPendingEventsTimer = null;
-      this.flushPendingEvents();
-    }, 0);
+      try {
+        this.flushPendingEvents();
+      } catch (error) {
+        if (isTransientSqliteBusyError(error)) {
+          this.schedulePendingEventFlush(PENDING_EVENT_BUSY_RETRY_MS);
+          return;
+        }
+        throw error;
+      }
+    }, delayMs);
     this.flushPendingEventsTimer.unref?.();
   }
   loadSnapshot() {
@@ -41886,7 +42274,7 @@ class SQLiteControlPlaneStore {
         audience: parseJson(row.audience_json, undefined),
         visibility: row.visibility,
         policy: row.policy,
-        createdAt: row.created_at,
+        createdAt: normalizeTimestampMs(row.created_at) ?? row.created_at,
         metadata: parseJson(row.metadata_json, undefined)
       };
     }
@@ -41992,6 +42380,51 @@ class SQLiteControlPlaneStore {
       activeFlights: this.listConversationThreadFlights(conversation)
     };
   }
+  getConversationThreadLaunchSnapshot(options) {
+    const conversation = this.getConversation(options.conversationId, this.readDb);
+    if (!conversation) {
+      return null;
+    }
+    const requestedLimit = Math.floor(options.limit ?? 64);
+    const limit = Number.isFinite(requestedLimit) ? Math.max(1, Math.min(64, requestedLimit)) : 64;
+    const rows = queryAll(this.readDb, `SELECT
+        m.id,
+        m.actor_id,
+        a.display_name AS actor_name,
+        m.body,
+        m.class,
+        m.created_at
+      FROM messages m
+      LEFT JOIN actors a ON a.id = m.actor_id
+      WHERE m.conversation_id = ?1
+      ORDER BY CASE
+        WHEN m.created_at > 0 AND m.created_at < ${EPOCH_MILLISECONDS_FLOOR}
+          THEN m.created_at * 1000
+        ELSE m.created_at
+      END DESC, m.id DESC
+      LIMIT ?2`, options.conversationId, limit + 1);
+    const hasEarlier = rows.length > limit;
+    const page = rows.slice(0, limit).reverse();
+    return {
+      projectionId: options.projectionId,
+      projectionVersion: options.projectionVersion,
+      sequence: options.sequence,
+      feedId: scoutConversationFeedId(options.conversationId),
+      entityKind: "scout_conversation",
+      conversationId: options.conversationId,
+      cursor: page[0]?.id ?? null,
+      hasEarlier,
+      generatedAt: options.generatedAt ?? currentTimestampMs(),
+      messages: page.map((row) => ({
+        id: row.id,
+        actorId: row.actor_id,
+        actorName: row.actor_name,
+        body: row.body,
+        class: row.class,
+        createdAt: row.created_at
+      }))
+    };
+  }
   upsertThreadCursor(conversationId, authorityNodeId, lastAppliedSeq, updatedAt) {
     this.db.query(`INSERT INTO thread_cursors (
         conversation_id, authority_node_id, last_applied_seq, updated_at
@@ -42202,12 +42635,16 @@ class SQLiteControlPlaneStore {
        WHERE endpoint_id = ?3`).run(expiresAt, observedAt2, endpointId);
   }
   projectRuntimeSessionForEndpoint(endpoint, observedAt2) {
-    const primaryAlias = endpointRuntimeSessionPrimaryAlias(endpoint);
+    const primaryAlias = runtimeSessionPrimaryAlias(endpoint);
     if (!primaryAlias) {
       this.markRuntimeSessionsForEndpointEnded(endpoint.id, null, observedAt2);
       return;
     }
-    const sessionId = endpointRuntimeSessionId(endpoint, primaryAlias);
+    const sessionId = runtimeSessionHandleForEndpoint(endpoint, primaryAlias);
+    if (!sessionId) {
+      this.markRuntimeSessionsForEndpointEnded(endpoint.id, null, observedAt2);
+      return;
+    }
     const lastSeenAt = endpointRuntimeSessionLastSeenAt(endpoint, observedAt2);
     const startedAt = endpointRuntimeSessionStartedAt(endpoint, lastSeenAt);
     const terminal = endpointRuntimeSessionIsTerminal(endpoint);
@@ -42557,10 +42994,23 @@ class SQLiteControlPlaneStore {
           targetAgentId: identity.target_agent_id
         };
       }
-      this.db.query(`INSERT OR REPLACE INTO flights (
+      this.db.query(`INSERT INTO flights (
           id, invocation_id, requester_id, target_agent_id, state, summary, output, error,
           labels_json, metadata_json, started_at, completed_at
-        ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)`).run(recorded.id, recorded.invocationId, recorded.requesterId, recorded.targetAgentId, recorded.state, recorded.summary ?? null, recorded.output ?? null, recorded.error ?? null, stringify3(recorded.labels), stringify3(recorded.metadata), recorded.startedAt ?? null, recorded.completedAt ?? null);
+        ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
+        ON CONFLICT(id) DO UPDATE SET
+          rowid = (SELECT COALESCE(MAX(rowid), 0) + 1 FROM flights),
+          invocation_id = excluded.invocation_id,
+          requester_id = excluded.requester_id,
+          target_agent_id = excluded.target_agent_id,
+          state = excluded.state,
+          summary = excluded.summary,
+          output = excluded.output,
+          error = excluded.error,
+          labels_json = excluded.labels_json,
+          metadata_json = excluded.metadata_json,
+          started_at = excluded.started_at,
+          completed_at = excluded.completed_at`).run(recorded.id, recorded.invocationId, recorded.requesterId, recorded.targetAgentId, recorded.state, recorded.summary ?? null, recorded.output ?? null, recorded.error ?? null, stringify3(recorded.labels), stringify3(recorded.metadata), recorded.startedAt ?? null, recorded.completedAt ?? null);
       this.db.query(`UPDATE invocations SET
            flight_id = ?2, state = ?3, summary = ?4, output = ?5, error = ?6,
            started_at = ?7, completed_at = ?8, flight_metadata_json = ?9
@@ -42740,42 +43190,48 @@ class SQLiteControlPlaneStore {
     }));
   }
   recordDeliveries(deliveries2) {
-    for (const delivery of deliveries2) {
-      this.drizzleDb.insert(deliveriesTable).values({
-        id: delivery.id,
-        messageId: delivery.messageId ?? null,
-        invocationId: delivery.invocationId ?? null,
-        targetId: delivery.targetId,
-        targetNodeId: delivery.targetNodeId ?? null,
-        targetKind: delivery.targetKind,
-        transport: delivery.transport,
-        reason: delivery.reason,
-        policy: delivery.policy,
-        status: delivery.status,
-        bindingId: delivery.bindingId ?? null,
-        leaseOwner: delivery.leaseOwner ?? null,
-        leaseExpiresAt: delivery.leaseExpiresAt ?? null,
-        metadataJson: stringify3(delivery.metadata),
-        createdAt: this.deliveryCreatedAt(delivery)
-      }).onConflictDoUpdate({
-        target: deliveriesTable.id,
-        set: {
-          messageId: delivery.messageId ?? null,
-          invocationId: delivery.invocationId ?? null,
-          targetId: delivery.targetId,
-          targetNodeId: delivery.targetNodeId ?? null,
-          targetKind: delivery.targetKind,
-          transport: delivery.transport,
-          reason: delivery.reason,
-          policy: delivery.policy,
-          status: delivery.status,
-          bindingId: delivery.bindingId ?? null,
-          leaseOwner: delivery.leaseOwner ?? null,
-          leaseExpiresAt: delivery.leaseExpiresAt ?? null,
-          metadataJson: stringify3(delivery.metadata)
-        }
-      }).run();
-    }
+    if (deliveries2.length === 0)
+      return;
+    const statement = this.db.query(`INSERT INTO deliveries (
+        id, message_id, invocation_id, target_id, target_node_id, target_kind,
+        transport, reason, policy, status, binding_id, lease_owner, lease_expires_at,
+        metadata_json, created_at
+      ) VALUES (
+        ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        message_id = excluded.message_id,
+        invocation_id = excluded.invocation_id,
+        target_id = excluded.target_id,
+        target_node_id = excluded.target_node_id,
+        target_kind = excluded.target_kind,
+        transport = excluded.transport,
+        reason = excluded.reason,
+        policy = excluded.policy,
+        status = excluded.status,
+        binding_id = excluded.binding_id,
+        lease_owner = excluded.lease_owner,
+        lease_expires_at = excluded.lease_expires_at,
+        metadata_json = excluded.metadata_json`);
+    this.db.transaction((batch) => {
+      const createdAtBySource = new Map;
+      for (const delivery of batch) {
+        const sourceKey = delivery.messageId || delivery.invocationId ? `${delivery.messageId ?? ""}\x00${delivery.invocationId ?? ""}` : null;
+        let createdAt;
+        if (sourceKey === null) {
+          createdAt = this.deliveryCreatedAt(delivery);
+        } else {
+          const cached = createdAtBySource.get(sourceKey);
+          if (cached !== undefined) {
+            createdAt = cached;
+          } else {
+            createdAt = this.deliveryCreatedAt(delivery);
+            createdAtBySource.set(sourceKey, createdAt);
+          }
+        }
+        statement.run(delivery.id, delivery.messageId ?? null, delivery.invocationId ?? null, delivery.targetId, delivery.targetNodeId ?? null, delivery.targetKind, delivery.transport, delivery.reason, delivery.policy, delivery.status, delivery.bindingId ?? null, delivery.leaseOwner ?? null, delivery.leaseExpiresAt ?? null, stringify3(delivery.metadata), createdAt);
+      }
+    })(deliveries2);
   }
   deliveryCreatedAt(delivery) {
     const messageCreatedAt = delivery.messageId ? queryGet(this.db, "SELECT created_at FROM messages WHERE id = ?1 LIMIT 1", delivery.messageId)?.created_at : null;
@@ -43280,6 +43736,17 @@ class SQLiteControlPlaneStore {
   get writerDb() {
     return this.db;
   }
+  runReplayTransaction(operation) {
+    this.db.transaction(() => {
+      const previousReadDb = this.readDb;
+      this.readDb = this.db;
+      try {
+        operation();
+      } finally {
+        this.readDb = previousReadDb;
+      }
+    })();
+  }
   get readerDb() {
     return this.readDb;
   }
@@ -43563,7 +44030,7 @@ class SQLiteControlPlaneStore {
     this.schedulePendingEventFlush();
   }
 }
-var RUNTIME_SESSION_RETENTION_MS, RUNTIME_SESSION_ALIAS_METADATA_KEYS;
+var PENDING_EVENT_BUSY_RETRY_MS = 25, RUNTIME_SESSION_RETENTION_MS, RUNTIME_SESSION_ALIAS_METADATA_KEYS;
 var init_sqlite_store = __esm(() => {
   init_drizzle_orm();
   init_node_identity();
@@ -43575,6 +44042,7 @@ var init_sqlite_store = __esm(() => {
   init_api();
   init_drizzle_schema();
   init_budget_observations2();
+  init_runtime_session_handle();
   RUNTIME_SESSION_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
   RUNTIME_SESSION_ALIAS_METADATA_KEYS = [
     { key: "sessionId", kind: "metadata_session" },
@@ -43589,7 +44057,7 @@ var init_sqlite_store = __esm(() => {
 });
 
 // ../runtime/src/mesh-peer-auth.ts
-import { createHash as createHash5, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
 function assertNoNewlines(component, name) {
   if (component.includes(`
 `) || component.includes("\r")) {
@@ -43615,7 +44083,7 @@ function peerRequestSigningPayload(input) {
 `);
 }
 function sha256Hex(body) {
-  return createHash5("sha256").update(body).digest("hex");
+  return createHash6("sha256").update(body).digest("hex");
 }
 function signPeerRequest(identity, input) {
   const ts = input.ts ?? Date.now();
@@ -58671,14 +59139,14 @@ var init_x509_es = __esm(() => {
 
 // ../runtime/src/node-tls-identity.ts
 import {
-  createHash as createHash6,
+  createHash as createHash7,
   createPrivateKey as createPrivateKey2,
   createPublicKey as createPublicKey2,
   generateKeyPairSync as generateKeyPairSync2,
   randomBytes as randomBytes3
 } from "crypto";
 function tlsSpkiFingerprintFromDer(spkiDer) {
-  return createHash6("sha256").update(spkiDer).digest("hex");
+  return createHash7("sha256").update(spkiDer).digest("hex");
 }
 function tlsSpkiFingerprintFromCertificateDer(certificateDer) {
   const certificate2 = new X509Certificate(asBufferSource(certificateDer));
@@ -59302,10 +59770,12 @@ var init_mesh_dial_order = __esm(() => {
 });
 
 // ../runtime/src/mesh-forwarding.ts
+var MAX_PEER_AGENT_SNAPSHOT_BYTES;
 var init_mesh_forwarding = __esm(() => {
   init_iroh_bridge();
   init_mesh_peer_client();
   init_mesh_dial_order();
+  MAX_PEER_AGENT_SNAPSHOT_BYTES = 2 * 1024 * 1024;
 });
 
 // ../runtime/src/mesh-rendezvous.ts
@@ -60639,9 +61109,9 @@ var init_eff_short_wordlist = __esm(() => {
 });
 
 // ../runtime/src/mesh-sas.ts
-import { createHash as createHash7, createHmac } from "crypto";
+import { createHash as createHash8, createHmac } from "crypto";
 function createEnrollmentCommitment(nonce, cardSignature) {
-  return createHash7("sha256").update(Buffer.concat([nonce, Buffer.from(cardSignature, "utf8")])).digest("base64");
+  return createHash8("sha256").update(Buffer.concat([nonce, Buffer.from(cardSignature, "utf8")])).digest("base64");
 }
 function verifyEnrollmentCommitment(commitment, nonce, cardSignature) {
   const expected = createEnrollmentCommitment(nonce, cardSignature);
@@ -62068,6 +62538,7 @@ var TERMINAL_ENDPOINT_STATES;
 var init_broker_endpoint_selection = __esm(() => {
   init_a2a_http_endpoint();
   init_local_agent_transports();
+  init_runtime_session_handle();
   TERMINAL_ENDPOINT_STATES = new Set([
     "failed",
     "superseded",
@@ -64470,11 +64941,11 @@ var init_paths2 = __esm(() => {
 
 // ../runtime/src/knowledge/store.ts
 import { existsSync as existsSync31, mkdirSync as mkdirSync10, statSync as statSync8 } from "fs";
-import { createHash as createHash8, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID4 } from "crypto";
 import { dirname as dirname21 } from "path";
 import { Database as Database3 } from "bun:sqlite";
 function ftsRowidForChunk(chunkId) {
-  return createHash8("sha256").update(chunkId).digest().readBigInt64BE(0);
+  return createHash9("sha256").update(chunkId).digest().readBigInt64BE(0);
 }
 function stringify4(value) {
   return JSON.stringify(value ?? null);
@@ -64513,7 +64984,7 @@ function normalizeFtsQueryOr(value) {
   return terms.map(quoteFtsTerm).join(" OR ");
 }
 function textHash(value) {
-  return `sha256:${createHash8("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash9("sha256").update(value).digest("hex")}`;
 }
 function deterministicKnowledgeChunkId(input) {
   return textHash([
@@ -65268,7 +65739,7 @@ var init_store = __esm(() => {
 });
 
 // ../runtime/src/knowledge/session-indexer.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import {
   createReadStream as createReadStream2,
   existsSync as existsSync32,
@@ -65382,7 +65853,7 @@ function discoverRecentSessionFiles(cutoffMs, limit, harnessFilter) {
 async function parseJsonl(file) {
   const maybeYield = createYieldBudget();
   const records = [];
-  const hash = createHash9("sha256");
+  const hash = createHash10("sha256");
   let carry = "";
   let offset = 0;
   let index2 = 0;
@@ -65713,10 +66184,10 @@ function trimOneLine(value, max) {
   return flat.length <= max ? flat : `${flat.slice(0, Math.max(0, max - 3))}...`;
 }
 function hashText(value) {
-  return `sha256:${createHash9("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash10("sha256").update(value).digest("hex")}`;
 }
 function stableId(value, length = 16) {
-  return createHash9("sha256").update(value).digest("hex").slice(0, length);
+  return createHash10("sha256").update(value).digest("hex").slice(0, length);
 }
 function portablePath(filePath) {
   const home = homedir27();
@@ -66568,7 +67039,7 @@ var init_sender = __esm(() => {
 // ../../apps/desktop/src/core/broker/service.ts
 import { mkdir as mkdir11, readFile as readFile15, unlink, writeFile as writeFile10 } from "fs/promises";
 import { basename as basename12, join as join39, resolve as resolve17 } from "path";
-import { createHash as createHash10, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash11, randomUUID as randomUUID5 } from "crypto";
 function relayHubDirectory() {
   return resolveOpenScoutSupportPaths().relayHubDirectory;
 }
@@ -66660,7 +67131,7 @@ function deliveryRequestId(clientMessageId, createdAt) {
   if (!normalized) {
     return `deliver-${createdAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
-  const digest = createHash10("sha256").update(normalized).digest("hex").slice(0, 32);
+  const digest = createHash11("sha256").update(normalized).digest("hex").slice(0, 32);
   return `deliver-client-${digest}`;
 }
 function metadataStringList(metadata, key) {
@@ -68040,10 +68511,6 @@ async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId,
   };
 }
 async function sendScoutMessage(input) {
-  const broker2 = await loadScoutBrokerContext();
-  if (!broker2) {
-    return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
-  }
   const currentDirectory = input.currentDirectory ?? process.cwd();
   const source = input.source?.trim() || "scout-cli";
   const wake = input.wake ?? false;
@@ -68056,15 +68523,19 @@ async function sendScoutMessage(input) {
     source,
     sourceIntent: "tell_wake"
   } : undefined;
-  const senderId = await resolveConversationActorId(broker2.baseUrl, broker2.snapshot, broker2.node.id, input.senderId, currentDirectory);
   const requestedTargetLabel = input.targetLabel?.trim();
   const requestedTargetRef = input.targetRef?.trim();
   if (requestedTargetLabel || requestedTargetRef) {
+    const health = await readScoutBrokerHealth();
+    if (!health.reachable || !health.ok || !health.nodeId) {
+      return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
+    }
+    const senderId2 = await resolveConversationActorId(health.baseUrl, createRuntimeRegistrySnapshot(), health.nodeId, input.senderId, currentDirectory);
     const { target: target2, renderedTarget, isBindingRef } = routeTargetForTargetLabel(requestedTargetLabel ?? "", requestedTargetRef, input.aliasScope);
-    const delivery = await brokerPostDeliver(broker2.baseUrl, {
+    const delivery = await brokerPostDeliver(health.baseUrl, {
       caller: {
-        actorId: senderId,
-        nodeId: broker2.node.id,
+        actorId: senderId2,
+        nodeId: health.nodeId,
         currentDirectory,
         metadata: { source }
       },
@@ -68107,6 +68578,11 @@ async function sendScoutMessage(input) {
       routeKind: delivery.routeKind
     };
   }
+  const broker2 = await loadScoutBrokerContext();
+  if (!broker2) {
+    return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
+  }
+  const senderId = await resolveConversationActorId(broker2.baseUrl, broker2.snapshot, broker2.node.id, input.senderId, currentDirectory);
   const mentionResolution = await resolveMentionTargets(broker2.snapshot, input.body, currentDirectory);
   const selectors = extractAgentSelectors(input.body);
   if (selectors.length === 1 && mentionResolution.resolved.length + mentionResolution.unresolved.length + mentionResolution.ambiguous.length === 1) {
@@ -69582,6 +70058,7 @@ var init_service3 = __esm(() => {
   init_broker_api();
   init_broker_process_manager();
   init_local_agents();
+  init_registry3();
   init_support_paths();
   init_user_config();
   init_paths();
@@ -70509,6 +70986,12 @@ function describeStopStep(step) {
       return `sweep supervised stragglers (${step.pids.length} candidate${step.pids.length === 1 ? "" : "s"})`;
   }
 }
+function ownedSweepSurvivorPids(step, tree) {
+  const candidates = new Set(step.pids);
+  const stillOwned = layerProcesses(tree, step.layers);
+  const reparentedFromThisCheckout = detachedExpectedProcesses(tree).filter((entry) => step.layers.includes(entry.layer));
+  return [...stillOwned, ...reparentedFromThisCheckout].map((entry) => entry.pid).filter((pid) => candidates.has(pid));
+}
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -70578,6 +71061,9 @@ function bootstrapLaunchdJob(plistPath, uid) {
   const ok = (result.status ?? 1) === 0 || /already bootstrapped|Operation already in progress/i.test(detail);
   return { ok, detail };
 }
+function scoutdStartArguments(options = {}) {
+  return options.waitForHealth === false ? ["start", "--no-wait"] : ["start"];
+}
 function chooseLaunchdStartMethod(input) {
   if (input.scoutdPath)
     return "scoutd";
@@ -70597,7 +71083,7 @@ function startLaunchdJob(label, uid, home, options = {}) {
     case "kickstart":
       return { ...kickstartLaunchdJob(label, uid, { restart: options.restart }), method };
     case "scoutd": {
-      const result = spawnSync4(scoutdPath, ["start"], { encoding: "utf8" });
+      const result = spawnSync4(scoutdPath, scoutdStartArguments(options), { encoding: "utf8" });
       const detail = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
       return { ok: (result.status ?? 1) === 0, detail, method };
     }
@@ -70692,6 +71178,7 @@ var init_app_lifecycle = __esm(() => {
 // ../../apps/desktop/src/cli/commands/app.ts
 var exports_app = {};
 __export(exports_app, {
+  startTreeReady: () => startTreeReady,
   selectInstalledAppBundle: () => selectInstalledAppBundle,
   runAppCommand: () => runAppCommand,
   renderAppCommandHelp: () => renderAppCommandHelp,
@@ -70828,6 +71315,13 @@ async function waitFor(paths2, predicate, timeoutMs) {
   }
   return tree;
 }
+function startTreeReady(tree, scope) {
+  const appsReady = tree.layers.app.length > 0 && tree.layers.menu.length > 0;
+  if (!appsReady || scope === "apps") {
+    return appsReady;
+  }
+  return SUPERVISED_LAYERS.every((layer) => tree.layers[layer].length > 0);
+}
 async function stopSuite(paths2, steps, scope) {
   const tree = readTree(paths2);
   const uid = process.getuid?.() ?? 0;
@@ -70838,7 +71332,12 @@ async function stopSuite(paths2, steps, scope) {
       steps.push(result.ok ? label : `${label} \u2014 failed: ${result.detail || "unknown error"}`);
       continue;
     }
-    const { escalated, survivors } = await terminateProcesses(step.pids);
+    let pids = step.pids;
+    if (step.kind === "sweep") {
+      const drainedTree = await waitFor(paths2, (candidate) => ownedSweepSurvivorPids(step, candidate).length === 0, SUPERVISED_DRAIN_TIMEOUT_MS);
+      pids = ownedSweepSurvivorPids(step, drainedTree);
+    }
+    const { escalated, survivors } = await terminateProcesses(pids);
     const notes = [];
     if (escalated.length > 0)
       notes.push(`escalated to SIGKILL: ${escalated.join(", ")}`);
@@ -70851,22 +71350,27 @@ async function stopSuite(paths2, steps, scope) {
 }
 async function startSuite(paths2, steps, scope, options = {}) {
   const uid = process.getuid?.() ?? 0;
+  let supervisedReadiness = null;
   if (scope === "apps") {
     steps.push("skip launchd (--apps-only)");
   } else {
     const label = resolveLaunchdLabel();
     const launched = startLaunchdJob(label, uid, homedir28(), {
       restart: options.restart,
-      serviceRoot: paths2.serviceRoot
+      serviceRoot: paths2.serviceRoot,
+      waitForHealth: false
     });
     steps.push(launched.ok ? `${launched.method} ${label}` : `${launched.method} ${label} \u2014 failed: ${launched.detail || "unknown error"}`);
-    const supervised = await waitFor(paths2, (tree2) => SUPERVISED_LAYERS.every((layer) => tree2.layers[layer].length > 0), READY_TIMEOUT_MS);
-    const missing = SUPERVISED_LAYERS.filter((layer) => supervised.layers[layer].length === 0);
-    steps.push(missing.length === 0 ? "supervised tree ready" : `supervised tree incomplete \u2014 missing ${missing.join(", ")}`);
+    supervisedReadiness = waitFor(paths2, (tree2) => SUPERVISED_LAYERS.every((layer) => tree2.layers[layer].length > 0), SUPERVISED_READY_TIMEOUT_MS);
   }
   const open = spawnSync5("open", [paths2.appBundlePath], { encoding: "utf8" });
   steps.push((open.status ?? 1) === 0 ? `open ${paths2.appBundlePath}` : `open ${paths2.appBundlePath} \u2014 failed: ${(open.stderr ?? "").trim() || "unknown error"}`);
-  const tree = await waitFor(paths2, (candidate) => candidate.layers.app.length > 0 && candidate.layers.menu.length > 0, READY_TIMEOUT_MS);
+  if (supervisedReadiness) {
+    const supervised = await supervisedReadiness;
+    const missing = SUPERVISED_LAYERS.filter((layer) => supervised.layers[layer].length === 0);
+    steps.push(missing.length === 0 ? "supervised tree ready" : `supervised tree still starting \u2014 missing ${missing.join(", ")}`);
+  }
+  const tree = await waitFor(paths2, (candidate) => startTreeReady(candidate, scope), READY_TIMEOUT_MS);
   const appsMissing = LAUNCH_SERVICES_LAYERS.filter((layer) => layer !== "pairing" && tree.layers[layer].length === 0);
   steps.push(appsMissing.length === 0 ? "Scout and embedded ScoutMenu ready" : `apps incomplete \u2014 missing ${appsMissing.join(", ")}`);
   return tree;
@@ -70992,7 +71496,7 @@ async function runAppCommand(context, args) {
     throw new ScoutCliError(result.message);
   }
 }
-var HELP_FLAGS2, INSTALLED_APP_BUNDLE_ID = "app.openscout.scout", INSTALLED_APP_BUNDLE_NAME = "OpenScout.app", READY_TIMEOUT_MS = 30000, POLL_MS = 250;
+var HELP_FLAGS2, INSTALLED_APP_BUNDLE_ID = "app.openscout.scout", INSTALLED_APP_BUNDLE_NAME = "OpenScout.app", READY_TIMEOUT_MS = 30000, SUPERVISED_READY_TIMEOUT_MS = 120000, SUPERVISED_DRAIN_TIMEOUT_MS = 20000, POLL_MS = 250;
 var init_app = __esm(() => {
   init_app_lifecycle();
   init_context();
@@ -100958,7 +101462,7 @@ var init_stdio2 = __esm(() => {
 // ../../apps/desktop/src/shared/product.ts
 var SCOUT_APP_VERSION;
 var init_product = __esm(() => {
-  SCOUT_APP_VERSION = process.env.SCOUT_APP_VERSION?.trim() || "0.2.95";
+  SCOUT_APP_VERSION = process.env.SCOUT_APP_VERSION?.trim() || "0.2.96";
 });
 
 // ../../apps/desktop/src/core/mcp/stdio-server-lifecycle.ts
@@ -102491,7 +102995,13 @@ function renderOpenScoutCaddyfile(config2) {
   const blocks = schemes.flatMap((scheme) => config2.routes.map((route) => route.mode === "vite-dev" ? renderCaddyViteDevRouteBlock(route, scheme) : renderCaddyDefaultRouteBlock(config2, route, scheme, startPage))).join(`
 
 `);
-  return `${blocks}
+  return `{
+  log {
+    level WARN
+  }
+}
+
+${blocks}
 `;
 }
 var init_local_edge = __esm(() => {
@@ -104741,11 +105251,11 @@ function buildFlightCommandResult(flight, env, options = {}) {
   };
 }
 function buildFlightFollowHandles(flight, env) {
-  const conversationId = metadataStringValue2(flight.metadata, "conversationId") ?? metadataReturnAddressStringValue(flight.metadata, "conversationId");
-  const messageId = metadataStringValue2(flight.metadata, "messageId") ?? metadataReturnAddressStringValue(flight.metadata, "replyToMessageId");
-  const workId = metadataStringValue2(flight.metadata, "workId") ?? metadataStringValue2(flight.metadata, "collaborationRecordId");
-  const sessionId = metadataStringValue2(flight.metadata, "sessionId") ?? metadataDispatchAckStringValue(flight.metadata, "sessionId");
-  const bindingRef = metadataStringValue2(flight.metadata, "bindingRef") ?? flight.id.slice(-8);
+  const conversationId = metadataStringValue3(flight.metadata, "conversationId") ?? metadataReturnAddressStringValue(flight.metadata, "conversationId");
+  const messageId = metadataStringValue3(flight.metadata, "messageId") ?? metadataReturnAddressStringValue(flight.metadata, "replyToMessageId");
+  const workId = metadataStringValue3(flight.metadata, "workId") ?? metadataStringValue3(flight.metadata, "collaborationRecordId");
+  const sessionId = metadataStringValue3(flight.metadata, "sessionId") ?? metadataDispatchAckStringValue(flight.metadata, "sessionId");
+  const bindingRef = metadataStringValue3(flight.metadata, "bindingRef") ?? flight.id.slice(-8);
   const origin = resolveScoutWebOrigin(env);
   const links = buildFlightLinks(origin, {
     flightId: flight.id,
@@ -104833,7 +105343,7 @@ function isFlightWaitTimeout(error48) {
 function isTerminalFlightState(state) {
   return state === "completed" || state === "failed" || state === "cancelled";
 }
-function metadataStringValue2(metadata, key) {
+function metadataStringValue3(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -104841,13 +105351,13 @@ function metadataReturnAddressStringValue(metadata, key) {
   const value = metadata?.["returnAddress"];
   if (!value || typeof value !== "object" || Array.isArray(value))
     return null;
-  return metadataStringValue2(value, key);
+  return metadataStringValue3(value, key);
 }
 function metadataDispatchAckStringValue(metadata, key) {
   const value = metadata?.["dispatchAck"];
   if (!value || typeof value !== "object" || Array.isArray(value))
     return null;
-  return metadataStringValue2(value, key);
+  return metadataStringValue3(value, key);
 }
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/g, "");
@@ -105019,16 +105529,33 @@ var init_inbox2 = __esm(() => {
 // ../../apps/desktop/src/cli/commands/install.ts
 var exports_install = {};
 __export(exports_install, {
+  verifyStagedOpenScoutApp: () => verifyStagedOpenScoutApp,
+  verifyDownloadedDmg: () => verifyDownloadedDmg,
+  verifyDownloadedAsset: () => verifyDownloadedAsset,
   runInstallCommand: () => runInstallCommand,
   renderInstallCommandHelp: () => renderInstallCommandHelp,
+  processIdsForInstalledApp: () => processIdsForInstalledApp,
   parseInstallArgs: () => parseInstallArgs,
+  parseGithubAssetDigest: () => parseGithubAssetDigest,
   findAppDmgAsset: () => findAppDmgAsset,
+  OPENSCOUT_SIGNING_TEAM_ID: () => OPENSCOUT_SIGNING_TEAM_ID,
   OPENSCOUT_RELEASE_REPOSITORY: () => OPENSCOUT_RELEASE_REPOSITORY,
-  OPENSCOUT_RELEASE_OWNER: () => OPENSCOUT_RELEASE_OWNER
+  OPENSCOUT_RELEASE_OWNER: () => OPENSCOUT_RELEASE_OWNER,
+  OPENSCOUT_APP_NAME: () => OPENSCOUT_APP_NAME,
+  OPENSCOUT_APP_BUNDLE_ID: () => OPENSCOUT_APP_BUNDLE_ID,
+  DEFAULT_OPENSCOUT_APP_PATH: () => DEFAULT_OPENSCOUT_APP_PATH
 });
 import { spawnSync as spawnSync8 } from "child_process";
-import { existsSync as existsSync39, mkdtempSync, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "fs";
-import { tmpdir } from "os";
+import { createHash as createHash12 } from "crypto";
+import {
+  existsSync as fsExistsSync,
+  mkdirSync as fsMkdirSync,
+  mkdtempSync as fsMkdtempSync,
+  renameSync as fsRenameSync,
+  rmSync as fsRmSync,
+  writeFileSync as fsWriteFileSync
+} from "fs";
+import { tmpdir as osTmpdir } from "os";
 import { join as join48 } from "path";
 function renderInstallCommandHelp() {
   return [
@@ -105043,11 +105570,15 @@ function renderInstallCommandHelp() {
     "",
     "Behavior:",
     "  Downloads the signed + notarized OpenScout.dmg from the GitHub release,",
-    "  installs OpenScout.app (which embeds the menu bar helper) to /Applications,",
-    "  and clears the Gatekeeper quarantine flag so it opens cleanly.",
+    "  verifies the published byte size and sha256 digest when GitHub provides one,",
+    "  then codesign and Gatekeeper-assess the DMG before mounting. OpenScout.app",
+    "  must match the pinned bundle id and Team ID, pass codesign --deep --strict,",
+    "  and pass Gatekeeper execute after staging. A running copy of the installed",
+    "  app is stopped first; replacement is staged and rolled back on failure.",
+    "  Quarantine attributes are not cleared.",
     "",
-    "  The app drives the bundled local runtime from the global scout CLI, so",
-    "  `bun add -g @openscout/scout` is the companion install for the command line."
+    "  The app uses the local scout CLI for the bundled runtime. Install the CLI",
+    "  with `bun add -g @openscout/scout`."
   ].join(`
 `);
 }
@@ -105085,11 +105616,19 @@ function parseInstallArgs(args) {
       continue;
     }
     if (arg.startsWith("--version=")) {
-      options.version = arg.slice("--version=".length);
+      const value = arg.slice("--version=".length);
+      if (!value) {
+        throw new ScoutCliError("--version requires a release tag (e.g. --version v0.2.70)");
+      }
+      options.version = value;
       continue;
     }
     if (arg.startsWith("--tag=")) {
-      options.version = arg.slice("--tag=".length);
+      const value = arg.slice("--tag=".length);
+      if (!value) {
+        throw new ScoutCliError("--tag requires a release tag (e.g. --tag v0.2.70)");
+      }
+      options.version = value;
       continue;
     }
     throw new ScoutCliError(`unknown option for install: ${arg} (try: scout install --help)`);
@@ -105100,6 +105639,13 @@ function stripLeadingV(tag) {
   const trimmed = tag.trim();
   return trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
 }
+function normalizeReleaseVersion(tag) {
+  const version3 = stripLeadingV(tag);
+  if (!/^\d+\.\d+\.\d+$/.test(version3)) {
+    throw new ScoutCliError(`unsupported OpenScout release tag: ${tag}`);
+  }
+  return version3;
+}
 function formatBytes(bytes) {
   if (bytes <= 0)
     return "unknown size";
@@ -105107,20 +105653,130 @@ function formatBytes(bytes) {
     return `${(bytes / 1024).toFixed(0)} KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
-function getInstalledVersion() {
-  if (!existsSync39(INFO_PLIST_PATH))
+function combinedOutput(result) {
+  return `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+}
+function permissionDeniedMessage(destination, detail) {
+  const suffix = detail?.trim() ? `: ${detail.trim()}` : ".";
+  return `could not replace ${destination} (permission denied)${suffix} Grant write access to the destination and retry.`;
+}
+function isPermissionError(error48, result) {
+  const code = error48?.code;
+  if (code === "EACCES" || code === "EPERM")
+    return true;
+  const output = `${error48 instanceof Error ? error48.message : ""} ${result?.stderr ?? ""} ${result?.stdout ?? ""}`.toLowerCase();
+  return output.includes("permission denied") || output.includes("operation not permitted");
+}
+function defaultRun(command, args) {
+  const result = spawnSync8(command, [...args], { encoding: "utf8" });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
+}
+function defaultSleep(ms) {
+  Bun.sleepSync(ms);
+}
+function resolveInstallDependencies(dependencies = {}) {
+  return {
+    platform: dependencies.platform ?? process.platform,
+    fetch: dependencies.fetch ?? fetch,
+    run: dependencies.run ?? defaultRun,
+    existsSync: dependencies.existsSync ?? fsExistsSync,
+    mkdirSync: dependencies.mkdirSync ?? ((path, options) => {
+      fsMkdirSync(path, options);
+    }),
+    mkdtempSync: dependencies.mkdtempSync ?? fsMkdtempSync,
+    writeFileSync: dependencies.writeFileSync ?? ((path, data) => {
+      fsWriteFileSync(path, data);
+    }),
+    rmSync: dependencies.rmSync ?? fsRmSync,
+    renameSync: dependencies.renameSync ?? fsRenameSync,
+    tmpdir: dependencies.tmpdir ?? osTmpdir,
+    sleep: dependencies.sleep ?? defaultSleep,
+    appPath: dependencies.appPath ?? DEFAULT_OPENSCOUT_APP_PATH
+  };
+}
+function requireSuccess(result, message) {
+  if (result.error && result.error.code === "ENOENT") {
+    throw new ScoutCliError(`${message}: ${result.error.message}`);
+  }
+  if ((result.status ?? 1) !== 0) {
+    throw new ScoutCliError(`${message}: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status ?? "unknown"}`}`);
+  }
+  return result;
+}
+function parseGithubAssetDigest(digest) {
+  const trimmed = digest.trim();
+  const separator = trimmed.indexOf(":");
+  if (separator <= 0) {
+    throw new ScoutCliError(`unsupported GitHub asset digest: ${digest}`);
+  }
+  const algorithm = trimmed.slice(0, separator).trim().toLowerCase();
+  const hex4 = trimmed.slice(separator + 1).trim().toLowerCase();
+  if (algorithm !== GITHUB_ASSET_DIGEST_ALGORITHM || !/^[0-9a-f]+$/.test(hex4) || hex4.length !== GITHUB_ASSET_DIGEST_HEX_LENGTH) {
+    throw new ScoutCliError(`unsupported GitHub asset digest: ${digest}`);
+  }
+  return { algorithm, hex: hex4 };
+}
+function verifyDownloadedAsset(buffer, asset) {
+  if (typeof asset.size !== "number" || !Number.isFinite(asset.size) || asset.size < 0) {
+    throw new ScoutCliError(`release asset ${asset.name} is missing an exact byte size`);
+  }
+  if (buffer.byteLength !== asset.size) {
+    throw new ScoutCliError(`download size mismatch for ${asset.name}: expected ${asset.size} bytes, got ${buffer.byteLength}`);
+  }
+  if (buffer.byteLength === 0) {
+    throw new ScoutCliError("download failed: empty response body");
+  }
+  const digest = asset.digest?.trim();
+  if (!digest)
+    return;
+  const parsed = parseGithubAssetDigest(digest);
+  let actual;
+  try {
+    actual = createHash12(parsed.algorithm).update(buffer).digest("hex");
+  } catch {
+    throw new ScoutCliError(`unsupported GitHub asset digest algorithm: ${parsed.algorithm}`);
+  }
+  if (actual !== parsed.hex) {
+    throw new ScoutCliError(`download digest mismatch for ${asset.name}: expected ${digest}, got ${parsed.algorithm}:${actual}`);
+  }
+}
+function findAppDmgAsset(release) {
+  const assets = release.assets ?? [];
+  const versionedName = `OpenScout-${normalizeReleaseVersion(release.tag_name)}.dmg`;
+  const versioned = assets.find((asset) => asset.name === versionedName);
+  if (versioned)
+    return versioned;
+  const latestAlias = assets.find((asset) => asset.name === LATEST_DMG_ALIAS);
+  if (latestAlias)
+    return latestAlias;
+  throw new ScoutCliError(`no OpenScout.app DMG found in release ${release.tag_name}. Assets: ${assets.map((asset) => asset.name).join(", ") || "(none)"}`);
+}
+function infoPlistPath(appPath) {
+  return join48(appPath, "Contents", "Info.plist");
+}
+function readPlistString(deps, plistPath, key) {
+  if (!deps.existsSync(plistPath))
     return null;
-  const result = spawnSync8("defaults", ["read", INFO_PLIST_PATH, "CFBundleShortVersionString"], { encoding: "utf8" });
+  const result = deps.run("plutil", ["-extract", key, "raw", "-o", "-", plistPath]);
   if ((result.status ?? 1) !== 0)
     return null;
-  const version3 = result.stdout.trim();
-  return version3 || null;
+  const value = result.stdout.trim();
+  return value || null;
 }
-async function fetchRelease(version3) {
+function getInstalledVersion(deps) {
+  return readPlistString(deps, infoPlistPath(deps.appPath), "CFBundleShortVersionString");
+}
+async function fetchRelease(version3, deps) {
   const base = `https://api.github.com/repos/${OPENSCOUT_RELEASE_OWNER}/${OPENSCOUT_RELEASE_REPOSITORY}/releases`;
-  const apiUrl = version3 ? `${base}/tags/${version3}` : `${base}/latest`;
+  const apiUrl = version3 ? `${base}/tags/${encodeURIComponent(version3)}` : `${base}/latest`;
   try {
-    const response = await fetch(apiUrl, {
+    const response = await deps.fetch(apiUrl, {
       headers: { Accept: "application/vnd.github+json", "User-Agent": USER_AGENT }
     });
     if (response.ok) {
@@ -105128,30 +105784,15 @@ async function fetchRelease(version3) {
     }
   } catch {}
   const apiPath = version3 ? `repos/${OPENSCOUT_RELEASE_OWNER}/${OPENSCOUT_RELEASE_REPOSITORY}/releases/tags/${version3}` : `repos/${OPENSCOUT_RELEASE_OWNER}/${OPENSCOUT_RELEASE_REPOSITORY}/releases/latest`;
-  const gh = spawnSync8("gh", ["api", apiPath], { encoding: "utf8" });
+  const gh = deps.run("gh", ["api", apiPath]);
   if ((gh.status ?? 1) === 0 && gh.stdout.trim()) {
     return JSON.parse(gh.stdout);
   }
   throw new ScoutCliError(version3 ? `release "${version3}" not found on GitHub (${OPENSCOUT_RELEASE_OWNER}/${OPENSCOUT_RELEASE_REPOSITORY})` : `could not fetch the latest OpenScout release from GitHub (${OPENSCOUT_RELEASE_OWNER}/${OPENSCOUT_RELEASE_REPOSITORY})`);
 }
-function findAppDmgAsset(release) {
-  const assets = release.assets ?? [];
-  const isMenuOnly = (name2) => name2.toLowerCase().startsWith("openscoutmenu");
-  const isDmg = (name2) => name2.toLowerCase().endsWith(".dmg");
-  const versioned = assets.find((asset) => /^openscout-\d/i.test(asset.name) && isDmg(asset.name) && !isMenuOnly(asset.name));
-  if (versioned)
-    return versioned;
-  const latestAlias = assets.find((asset) => asset.name.toLowerCase() === "openscout.dmg");
-  if (latestAlias)
-    return latestAlias;
-  const anyProductDmg = assets.find((asset) => isDmg(asset.name) && !isMenuOnly(asset.name));
-  if (anyProductDmg)
-    return anyProductDmg;
-  throw new ScoutCliError(`no OpenScout.app DMG found in release ${release.tag_name}. Assets: ${assets.map((asset) => asset.name).join(", ") || "(none)"}`);
-}
-async function downloadDmg(asset, destination, context) {
+async function downloadDmg(asset, destination, context, deps) {
   context.stderr(`Downloading ${asset.name} (${formatBytes(asset.size)})\u2026`);
-  const response = await fetch(asset.browser_download_url, {
+  const response = await deps.fetch(asset.browser_download_url, {
     redirect: "follow",
     headers: { "User-Agent": USER_AGENT }
   });
@@ -105159,61 +105800,266 @@ async function downloadDmg(asset, destination, context) {
     throw new ScoutCliError(`download failed: HTTP ${response.status} for ${asset.browser_download_url}`);
   }
   const buffer = Buffer.from(await response.arrayBuffer());
-  if (buffer.length === 0) {
-    throw new ScoutCliError("download failed: empty response body");
+  verifyDownloadedAsset(buffer, asset);
+  deps.writeFileSync(destination, buffer);
+}
+function mountDmg(dmgPath, mountPoint, deps) {
+  deps.mkdirSync(mountPoint, { recursive: true });
+  const result = deps.run("hdiutil", [
+    "attach",
+    dmgPath,
+    "-mountpoint",
+    mountPoint,
+    "-nobrowse",
+    "-readonly",
+    "-noautoopen"
+  ]);
+  if ((result.status ?? 1) !== 0) {
+    throw new ScoutCliError(`could not mount ${dmgPath}: ${result.stderr.trim() || result.stdout.trim() || "hdiutil attach failed"}`);
   }
-  writeFileSync9(destination, buffer);
 }
-function mountDmg(dmgPath) {
-  const result = spawnSync8("hdiutil", ["attach", dmgPath, "-nobrowse", "-noverify", "-noautoopen", "-plist"], { encoding: "utf8" });
-  if ((result.status ?? 1) !== 0) {
-    throw new ScoutCliError(`could not mount ${dmgPath}: ${result.stderr.trim() || "hdiutil attach failed"}`);
+function unmountDmg(mountPoint, deps) {
+  const detached = deps.run("hdiutil", ["detach", mountPoint, "-quiet"]);
+  if ((detached.status ?? 1) === 0)
+    return;
+  deps.run("hdiutil", ["detach", mountPoint, "-force", "-quiet"]);
+}
+function requireMountedOpenScoutApp(mountPoint, deps) {
+  const source = join48(mountPoint, OPENSCOUT_APP_NAME);
+  if (!deps.existsSync(source) || !deps.existsSync(infoPlistPath(source))) {
+    throw new ScoutCliError(`no ${OPENSCOUT_APP_NAME} found in the mounted DMG at ${mountPoint}`);
   }
-  const mountPointMatch = result.stdout.match(/<key>mount-point<\/key>\s*<string>([^<]+)<\/string>/);
-  if (mountPointMatch) {
-    return mountPointMatch[1];
+  return source;
+}
+function codesignField(output, key) {
+  const match = output.match(new RegExp(`^${key}=(.+)$`, "m"));
+  return match ? match[1].trim() : null;
+}
+function verifyDownloadedDmg(dmgPath, deps = {}) {
+  const resolved = resolveInstallDependencies(deps);
+  requireSuccess(resolved.run("codesign", ["--verify", "--strict", dmgPath]), `codesign --verify --strict failed for ${dmgPath}`);
+  requireSuccess(resolved.run("spctl", [
+    "--assess",
+    "--type",
+    "open",
+    "--context",
+    "context:primary-signature",
+    "-vv",
+    dmgPath
+  ]), `Gatekeeper rejected ${dmgPath}`);
+}
+function verifyStagedOpenScoutApp(bundlePath, deps = {}, expectedVersion) {
+  const resolved = resolveInstallDependencies(deps);
+  if (!resolved.existsSync(infoPlistPath(bundlePath))) {
+    throw new ScoutCliError(`${bundlePath} is missing Contents/Info.plist`);
+  }
+  const bundleId = readPlistString(resolved, infoPlistPath(bundlePath), "CFBundleIdentifier");
+  if (bundleId !== OPENSCOUT_APP_BUNDLE_ID) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} bundle id is ${bundleId ?? "(missing)"}; expected ${OPENSCOUT_APP_BUNDLE_ID}`);
+  }
+  const version3 = readPlistString(resolved, infoPlistPath(bundlePath), "CFBundleShortVersionString");
+  if (!version3) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} is missing CFBundleShortVersionString`);
+  }
+  if (expectedVersion && version3 !== expectedVersion) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} version is ${version3}; expected release ${expectedVersion}`);
+  }
+  requireSuccess(resolved.run("codesign", ["--verify", "--deep", "--strict", bundlePath]), `codesign --verify --deep --strict failed for ${bundlePath}`);
+  const details = requireSuccess(resolved.run("codesign", ["-dvv", bundlePath]), `could not read codesign details for ${bundlePath}`);
+  const detailsOutput = combinedOutput(details);
+  const identifier = codesignField(detailsOutput, "Identifier");
+  if (identifier !== OPENSCOUT_APP_BUNDLE_ID) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} signature identifier is ${identifier ?? "(missing)"}; expected ${OPENSCOUT_APP_BUNDLE_ID}`);
+  }
+  const teamId = codesignField(detailsOutput, "TeamIdentifier");
+  if (teamId !== OPENSCOUT_SIGNING_TEAM_ID) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} signing Team ID is ${teamId ?? "(missing)"}; expected ${OPENSCOUT_SIGNING_TEAM_ID}`);
+  }
+  if (!/^Authority=Developer ID Application:/m.test(detailsOutput)) {
+    throw new ScoutCliError(`${OPENSCOUT_APP_NAME} is not signed with Developer ID Application`);
+  }
+  requireSuccess(resolved.run("spctl", ["--assess", "--type", "execute", "-vv", bundlePath]), `Gatekeeper rejected ${bundlePath}`);
+  return version3;
+}
+function copyApp(source, destination, deps) {
+  const copied = deps.run("ditto", [source, destination]);
+  if ((copied.status ?? 1) !== 0) {
+    if (isPermissionError(copied.error, copied)) {
+      throw new ScoutCliError(permissionDeniedMessage(destination, copied.stderr));
+    }
+    throw new ScoutCliError(`could not copy the app to ${destination}: ${copied.stderr.trim() || copied.stdout.trim() || "ditto failed"}`);
+  }
+}
+function moveReplacing(source, destination, deps) {
+  try {
+    deps.renameSync(source, destination);
+    return;
+  } catch (error48) {
+    const code = error48?.code;
+    if (code !== "EXDEV") {
+      if (isPermissionError(error48)) {
+        throw new ScoutCliError(permissionDeniedMessage(destination));
+      }
+      throw new ScoutCliError(`could not move ${source} to ${destination}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
   }
-  throw new ScoutCliError("could not determine the DMG mount point");
+  copyApp(source, destination, deps);
+  deps.rmSync(source, { recursive: true, force: true });
 }
-function unmountDmg(mountPoint) {
-  spawnSync8("hdiutil", ["detach", mountPoint, "-quiet"], { encoding: "utf8" });
+function backupPathFor(appPath) {
+  return `${appPath}${BACKUP_SUFFIX}`;
+}
+function installLockPathFor(appPath) {
+  return `${appPath}${INSTALL_LOCK_SUFFIX}`;
+}
+function acquireInstallLock(deps) {
+  const lockPath = installLockPathFor(deps.appPath);
+  const result = deps.run(SHLOCK_PATH, ["-f", lockPath, "-p", String(process.pid)]);
+  if ((result.status ?? 1) !== 0) {
+    if (isPermissionError(result.error, result)) {
+      throw new ScoutCliError(permissionDeniedMessage(lockPath, result.stderr));
+    }
+    throw new ScoutCliError(`another scout install is already updating ${deps.appPath}. ` + `If no installer is running, remove the stale lock at ${lockPath} and retry.`);
+  }
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    deps.rmSync(lockPath, { force: true });
+  };
 }
-function copyAppFromMount(mountPoint) {
-  const listing = spawnSync8("ls", [mountPoint], { encoding: "utf8" });
-  const appEntry = listing.stdout.split(`
-`).map((line) => line.trim()).find((line) => line === APP_NAME) ?? listing.stdout.split(`
-`).map((line) => line.trim()).find((line) => line.endsWith(".app") && !line.toLowerCase().startsWith("openscoutmenu"));
-  if (!appEntry) {
-    throw new ScoutCliError(`no ${APP_NAME} found in the mounted DMG at ${mountPoint}`);
+function recoverIncompleteInstall(deps) {
+  const backupPath = backupPathFor(deps.appPath);
+  const destExists = deps.existsSync(deps.appPath);
+  const backupExists = deps.existsSync(backupPath);
+  if (!destExists && backupExists) {
+    verifyStagedOpenScoutApp(backupPath, deps);
+    deps.renameSync(backupPath, deps.appPath);
+    return;
   }
-  const source = join48(mountPoint, appEntry);
-  if (existsSync39(APP_PATH)) {
-    const removed = spawnSync8("rm", ["-rf", APP_PATH], { encoding: "utf8" });
-    if ((removed.status ?? 1) !== 0) {
-      throw new ScoutCliError(`could not replace ${APP_PATH} (permission denied?). Try: sudo scout install`);
+  if (destExists && backupExists) {
+    let destinationError = null;
+    try {
+      verifyStagedOpenScoutApp(deps.appPath, deps);
+    } catch (error48) {
+      destinationError = error48;
+    }
+    if (!destinationError) {
+      deps.rmSync(backupPath, { recursive: true, force: true });
+      return;
     }
+    try {
+      verifyStagedOpenScoutApp(backupPath, deps);
+    } catch (backupError) {
+      throw new ScoutCliError(`incomplete prior install found, but neither ${deps.appPath} nor ${backupPath} passed verification: ` + `${destinationError instanceof Error ? destinationError.message : String(destinationError)}; ` + `${backupError instanceof Error ? backupError.message : String(backupError)}`);
+    }
+    deps.rmSync(deps.appPath, { recursive: true, force: true });
+    deps.renameSync(backupPath, deps.appPath);
   }
-  const copied = spawnSync8("cp", ["-R", source, APP_PATH], { encoding: "utf8" });
-  if ((copied.status ?? 1) !== 0) {
-    throw new ScoutCliError(`could not copy the app to ${APP_PATH}: ${copied.stderr.trim() || "permission denied?"}. Try: sudo scout install`);
+}
+function replaceAppTransactionally(stagedPath, deps, expectedVersion) {
+  const backupPath = backupPathFor(deps.appPath);
+  const hadPriorApp = deps.existsSync(deps.appPath);
+  let backedUp = false;
+  let installedVersion = "";
+  try {
+    if (hadPriorApp) {
+      try {
+        deps.renameSync(deps.appPath, backupPath);
+      } catch (error48) {
+        if (isPermissionError(error48)) {
+          throw new ScoutCliError(permissionDeniedMessage(deps.appPath));
+        }
+        throw new ScoutCliError(`could not move the installed app aside: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      }
+      backedUp = true;
+    }
+    moveReplacing(stagedPath, deps.appPath, deps);
+    installedVersion = verifyStagedOpenScoutApp(deps.appPath, deps, expectedVersion);
+  } catch (error48) {
+    if (backedUp) {
+      if (deps.existsSync(deps.appPath)) {
+        deps.rmSync(deps.appPath, { recursive: true, force: true });
+      }
+      if (deps.existsSync(backupPath)) {
+        try {
+          deps.renameSync(backupPath, deps.appPath);
+        } catch {
+          throw new ScoutCliError(`install failed and rollback failed. The previous app is at ${backupPath}. ${error48 instanceof Error ? error48.message : String(error48)}`);
+        }
+      }
+    } else if (!hadPriorApp && deps.existsSync(deps.appPath)) {
+      deps.rmSync(deps.appPath, { recursive: true, force: true });
+    }
+    throw error48;
+  }
+  if (backedUp && deps.existsSync(backupPath)) {
+    deps.rmSync(backupPath, { recursive: true, force: true });
   }
+  if (!installedVersion) {
+    throw new ScoutCliError(`installed ${OPENSCOUT_APP_NAME} has no verified version`);
+  }
+  return installedVersion;
 }
-function removeQuarantine() {
-  spawnSync8("xattr", ["-rd", "com.apple.quarantine", APP_PATH], { encoding: "utf8" });
+function executableIsInsideApp(executable, appPath) {
+  const normalizedApp = appPath.endsWith("/") ? appPath.slice(0, -1) : appPath;
+  return executable === normalizedApp || executable.startsWith(`${normalizedApp}/`);
 }
-function isAppRunning() {
-  return (spawnSync8("pgrep", ["-x", APP_PROCESS_NAME], { encoding: "utf8" }).status ?? 1) === 0;
+function processIdsForInstalledApp(psOutput, appPath) {
+  const pids = [];
+  for (const rawLine of psOutput.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    const match = line.match(/^(\d+)\s+(\S+)/);
+    if (!match)
+      continue;
+    const pid = Number(match[1]);
+    const executable = match[2];
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    if (executableIsInsideApp(executable, appPath))
+      pids.push(pid);
+  }
+  return pids;
 }
-function quitApp() {
-  spawnSync8("osascript", ["-e", `tell application id "${APP_BUNDLE_ID}" to quit`], {
-    encoding: "utf8"
-  });
+function listInstalledAppPids(deps) {
+  const result = deps.run("ps", ["-axo", "pid=,args="]);
+  requireSuccess(result, "could not inspect running OpenScout processes");
+  return processIdsForInstalledApp(result.stdout, deps.appPath);
+}
+function isAppRunning(deps) {
+  return listInstalledAppPids(deps).length > 0;
+}
+function waitUntilStopped2(deps, attempts) {
+  for (let index2 = 0;index2 < attempts; index2 += 1) {
+    if (!isAppRunning(deps))
+      return true;
+    if (index2 + 1 < attempts)
+      deps.sleep(STOP_POLL_MS);
+  }
+  return !isAppRunning(deps);
 }
-function launchApp() {
-  const byId = spawnSync8("open", ["-b", APP_BUNDLE_ID], { encoding: "utf8" });
-  if ((byId.status ?? 1) !== 0) {
-    spawnSync8("open", [APP_PATH], { encoding: "utf8" });
+function stopRunningApp(deps) {
+  const initialPids = listInstalledAppPids(deps);
+  if (initialPids.length === 0)
+    return false;
+  for (const pid of initialPids) {
+    deps.run("kill", [String(pid)]);
   }
+  if (waitUntilStopped2(deps, STOP_POLL_ATTEMPTS))
+    return true;
+  for (const pid of listInstalledAppPids(deps)) {
+    deps.run("kill", ["-9", String(pid)]);
+  }
+  if (waitUntilStopped2(deps, STOP_POLL_ATTEMPTS))
+    return true;
+  throw new ScoutCliError("could not stop OpenScout before replacing it");
+}
+function launchApp(deps) {
+  requireSuccess(deps.run("open", [deps.appPath]), `could not relaunch ${deps.appPath}`);
 }
 function renderInstallResult(result) {
   if (result.action === "check") {
@@ -105227,90 +106073,130 @@ function renderInstallResult(result) {
   }
   return result.message;
 }
-async function runCheck(context, options) {
-  const installed = getInstalledVersion();
-  const release = await fetchRelease(options.version);
-  const target2 = stripLeadingV(release.tag_name);
+async function runCheck(context, options, deps) {
+  const release = await fetchRelease(options.version, deps);
+  const target2 = normalizeReleaseVersion(release.tag_name);
+  let installed = getInstalledVersion(deps);
   let status;
   let message;
-  if (!installed) {
-    status = "not-installed";
-    message = "OpenScout is not installed \u2014 run `scout install`.";
-  } else if (installed === target2) {
-    status = "up-to-date";
-    message = `OpenScout ${installed} is up to date.`;
+  if (!deps.existsSync(deps.appPath)) {
+    if (deps.existsSync(backupPathFor(deps.appPath))) {
+      status = "repair-needed";
+      message = "An interrupted OpenScout install needs repair \u2014 run `scout install --force`.";
+    } else {
+      status = "not-installed";
+      message = "OpenScout is not installed \u2014 run `scout install`.";
+    }
   } else {
-    status = "update-available";
-    message = `Update available: ${installed} \u2192 ${target2}. Run \`scout install\`.`;
+    try {
+      installed = verifyStagedOpenScoutApp(deps.appPath, deps);
+      if (installed === target2) {
+        status = "up-to-date";
+        message = `OpenScout ${installed} is up to date.`;
+      } else {
+        status = "update-available";
+        message = `Update available: ${installed} \u2192 ${target2}. Run \`scout install\`.`;
+      }
+    } catch (error48) {
+      status = "repair-needed";
+      message = `OpenScout needs repair (${error48 instanceof Error ? error48.message : String(error48)}). ` + "Run `scout install --force`.";
+    }
   }
-  context.output.writeValue({ action: "check", status, installed, target: target2, bundlePath: APP_PATH, message }, renderInstallResult);
+  context.output.writeValue({ action: "check", status, installed, target: target2, bundlePath: deps.appPath, message }, renderInstallResult);
 }
-async function runInstallCommand(context, args) {
+async function runInstallCommand(context, args, dependencies = {}) {
   if (HELP_FLAGS9.has(args[0] ?? "")) {
     context.output.writeText(renderInstallCommandHelp());
     return;
   }
-  if (process.platform !== "darwin") {
+  const deps = resolveInstallDependencies(dependencies);
+  if (deps.platform !== "darwin") {
     throw new ScoutCliError("scout install is only supported on macOS.");
   }
   const options = parseInstallArgs(args);
+  if (options.version)
+    normalizeReleaseVersion(options.version);
   if (options.check) {
-    await runCheck(context, options);
+    await runCheck(context, options, deps);
     return;
   }
-  const installedBefore = getInstalledVersion();
   context.stderr(options.version ? `Fetching release ${options.version}\u2026` : "Fetching the latest OpenScout release\u2026");
-  const release = await fetchRelease(options.version);
-  const target2 = stripLeadingV(release.tag_name);
-  if (!options.force && installedBefore && installedBefore === target2) {
+  const release = await fetchRelease(options.version, deps);
+  const target2 = normalizeReleaseVersion(release.tag_name);
+  const releaseInstallLock = acquireInstallLock(deps);
+  try {
+    recoverIncompleteInstall(deps);
+    const hadInstalledApp = deps.existsSync(deps.appPath);
+    const installedBefore = getInstalledVersion(deps);
+    let repairingInstalledApp = false;
+    if (!options.force && installedBefore === target2) {
+      try {
+        const verifiedVersion = verifyStagedOpenScoutApp(deps.appPath, deps, target2);
+        context.output.writeValue({
+          action: "install",
+          status: "up-to-date",
+          installed: verifiedVersion,
+          target: target2,
+          bundlePath: deps.appPath,
+          message: `OpenScout ${target2} is already installed (use --force to reinstall).`
+        }, renderInstallResult);
+        return;
+      } catch (error48) {
+        repairingInstalledApp = true;
+        context.stderr(`Installed OpenScout ${target2} failed verification; repairing it: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      }
+    }
+    const asset = findAppDmgAsset(release);
+    const workDir = deps.mkdtempSync(join48(deps.tmpdir(), "scout-install-"));
+    const dmgPath = join48(workDir, asset.name);
+    const mountPoint = join48(workDir, "mnt");
+    const stagedPath = join48(workDir, OPENSCOUT_APP_NAME);
+    let mounted = false;
+    let wasRunning = false;
+    let installedAfter = "";
+    try {
+      await downloadDmg(asset, dmgPath, context, deps);
+      context.stderr(`Installing OpenScout ${target2} to ${deps.appPath}\u2026`);
+      verifyDownloadedDmg(dmgPath, deps);
+      mountDmg(dmgPath, mountPoint, deps);
+      mounted = true;
+      const source = requireMountedOpenScoutApp(mountPoint, deps);
+      copyApp(source, stagedPath, deps);
+      verifyStagedOpenScoutApp(stagedPath, deps, target2);
+      wasRunning = stopRunningApp(deps);
+      installedAfter = replaceAppTransactionally(stagedPath, deps, target2);
+    } finally {
+      if (mounted)
+        unmountDmg(mountPoint, deps);
+      deps.rmSync(workDir, { recursive: true, force: true });
+    }
+    if (wasRunning && options.restart) {
+      launchApp(deps);
+    }
+    const status = hadInstalledApp ? "updated" : "installed";
+    const relaunchNote = wasRunning ? options.restart ? " (relaunched)" : " (restart OpenScout to use the new version)" : "";
+    let verb = "Installed";
+    if (repairingInstalledApp || hadInstalledApp && !installedBefore) {
+      verb = "Repaired";
+    } else if (installedBefore) {
+      verb = `Updated ${installedBefore} \u2192`;
+    }
     context.output.writeValue({
       action: "install",
-      status: "up-to-date",
-      installed: installedBefore,
+      status,
+      installed: installedAfter,
       target: target2,
-      bundlePath: APP_PATH,
-      message: `OpenScout ${target2} is already installed (use --force to reinstall).`
+      bundlePath: deps.appPath,
+      message: `${verb} OpenScout ${installedAfter} \u2192 ${deps.appPath}${relaunchNote}`
     }, renderInstallResult);
-    return;
-  }
-  const asset = findAppDmgAsset(release);
-  const wasRunning = isAppRunning();
-  const workDir = mkdtempSync(join48(tmpdir(), "scout-install-"));
-  const dmgPath = join48(workDir, asset.name);
-  let mountPoint = null;
-  try {
-    await downloadDmg(asset, dmgPath, context);
-    context.stderr(`Installing OpenScout ${target2} to ${APP_PATH}\u2026`);
-    mountPoint = mountDmg(dmgPath);
-    copyAppFromMount(mountPoint);
   } finally {
-    if (mountPoint)
-      unmountDmg(mountPoint);
-    rmSync5(workDir, { recursive: true, force: true });
-  }
-  removeQuarantine();
-  if (wasRunning && options.restart) {
-    quitApp();
-    launchApp();
-  }
-  const installedAfter = getInstalledVersion() ?? target2;
-  const status = installedBefore ? "updated" : "installed";
-  const relaunchNote = wasRunning ? options.restart ? " (relaunched)" : " (restart OpenScout to use the new version)" : "";
-  const verb = installedBefore ? `Updated ${installedBefore} \u2192` : "Installed";
-  context.output.writeValue({
-    action: "install",
-    status,
-    installed: installedAfter,
-    target: target2,
-    bundlePath: APP_PATH,
-    message: `${verb} OpenScout ${installedAfter} \u2192 ${APP_PATH}${relaunchNote}`
-  }, renderInstallResult);
+    releaseInstallLock();
+  }
 }
-var OPENSCOUT_RELEASE_OWNER = "oscout", OPENSCOUT_RELEASE_REPOSITORY = "scout", APP_NAME = "OpenScout.app", APP_PATH, INFO_PLIST_PATH, APP_BUNDLE_ID = "app.openscout.scout", APP_PROCESS_NAME = "Scout", USER_AGENT = "scout-cli", HELP_FLAGS9;
+var OPENSCOUT_RELEASE_OWNER = "oscout", OPENSCOUT_RELEASE_REPOSITORY = "scout", OPENSCOUT_APP_NAME = "OpenScout.app", OPENSCOUT_APP_BUNDLE_ID = "app.openscout.scout", OPENSCOUT_SIGNING_TEAM_ID = "2U83JFPW66", DEFAULT_OPENSCOUT_APP_PATH, GITHUB_ASSET_DIGEST_ALGORITHM = "sha256", GITHUB_ASSET_DIGEST_HEX_LENGTH = 64, LATEST_DMG_ALIAS = "OpenScout.dmg", USER_AGENT = "scout-cli", BACKUP_SUFFIX = ".openscout-previous", INSTALL_LOCK_SUFFIX = ".openscout-install.lock", SHLOCK_PATH = "/usr/bin/shlock", STOP_POLL_ATTEMPTS = 50, STOP_POLL_MS = 100, HELP_FLAGS9;
 var init_install = __esm(() => {
   init_errors();
-  APP_PATH = `/Applications/${APP_NAME}`;
-  INFO_PLIST_PATH = `${APP_PATH}/Contents/Info.plist`;
+  DEFAULT_OPENSCOUT_APP_PATH = `/Applications/${OPENSCOUT_APP_NAME}`;
   HELP_FLAGS9 = new Set(["help", "--help", "-h"]);
 });
 
@@ -110025,12 +110911,12 @@ function normalizedStringOrNull(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function metadataStringValue3(metadata, key) {
+function metadataStringValue4(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
 function isBuiltInDirectoryAgent(agent) {
-  const definitionId = agent.definitionId || metadataStringValue3(agent.metadata, "definitionId") || agent.id;
+  const definitionId = agent.definitionId || metadataStringValue4(agent.metadata, "definitionId") || agent.id;
   return BUILT_IN_AGENT_DEFINITION_IDS.has(definitionId);
 }
 function rankState(state) {
@@ -113316,7 +114202,7 @@ var init_scout_mcp = __esm(() => {
 
 // ../../apps/desktop/src/cli/commands/mcp-install.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { accessSync as accessSync4, constants as constants4, existsSync as existsSync40 } from "fs";
+import { accessSync as accessSync4, constants as constants4, existsSync as existsSync39 } from "fs";
 import { homedir as homedir31 } from "os";
 import { delimiter as delimiter4, join as join49, resolve as resolve29 } from "path";
 function isExecutable3(filePath) {
@@ -113357,7 +114243,7 @@ function resolveHostExecutable(host, env) {
 }
 function resolveCurrentScoutMcpLaunchCommand(env) {
   const currentScript = process.argv[1];
-  if (currentScript && existsSync40(currentScript) && isExecutable3(process.execPath)) {
+  if (currentScript && existsSync39(currentScript) && isExecutable3(process.execPath)) {
     return {
       command: process.execPath,
       args: [resolve29(currentScript), "mcp"]
@@ -113730,7 +114616,7 @@ __export(exports_menu, {
   parseMenuCommand: () => parseMenuCommand
 });
 import { spawnSync as spawnSync10 } from "child_process";
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { homedir as homedir32 } from "os";
 import { dirname as dirname28, join as join50, resolve as resolve30 } from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
@@ -113820,7 +114706,7 @@ function findRepoMenuHelper(startDirectory) {
   let current = resolve30(startDirectory);
   while (true) {
     const candidate = join50(current, "apps", "macos", "bin", "openscout-menu.ts");
-    if (existsSync41(candidate)) {
+    if (existsSync40(candidate)) {
       return candidate;
     }
     const parent = dirname28(current);
@@ -113830,7 +114716,7 @@ function findRepoMenuHelper(startDirectory) {
     current = parent;
   }
   const sourceRelativeCandidate = fileURLToPath11(new URL("../../../../macos/bin/openscout-menu.ts", import.meta.url).toString());
-  return existsSync41(sourceRelativeCandidate) ? sourceRelativeCandidate : null;
+  return existsSync40(sourceRelativeCandidate) ? sourceRelativeCandidate : null;
 }
 function resolveRepoBundlePath(helperPath) {
   return resolve30(dirname28(helperPath), "..", "dist", "Scout.app", EMBEDDED_MENU_RELATIVE_PATH);
@@ -113862,14 +114748,14 @@ async function stopRunningMenu(helperBundlePath) {
   return survivors.length === 0;
 }
 function resolveInstalledAppBundlePath(env) {
-  const spotlight = runProcess("mdfind", [`kMDItemCFBundleIdentifier == '${APP_BUNDLE_ID2}'`], { env, allowFailure: true });
+  const spotlight = runProcess("mdfind", [`kMDItemCFBundleIdentifier == '${APP_BUNDLE_ID}'`], { env, allowFailure: true });
   const indexedPath = spotlight.stdout.split(`
 `).map((line) => line.trim()).find(Boolean);
   if (indexedPath) {
     return indexedPath;
   }
   for (const candidate of COMMON_APP_BUNDLE_PATHS) {
-    if (existsSync41(candidate)) {
+    if (existsSync40(candidate)) {
       return candidate;
     }
   }
@@ -113957,7 +114843,7 @@ async function runWithRepoHelper(context, helperPath, command) {
     });
   }
   const running = command.action === "quit" ? false : isMenuRunning(bundlePath);
-  const installed = existsSync41(bundlePath) || running;
+  const installed = existsSync40(bundlePath) || running;
   return {
     action: command.action,
     mode: "repo-helper",
@@ -114023,7 +114909,7 @@ async function runMenuCommand(context, args) {
   const result = helperPath ? await runWithRepoHelper(context, helperPath, command) : await runWithInstalledApp(context, command);
   context.output.writeValue(result, renderMenuResult);
 }
-var MENU_BUNDLE_ID = "app.openscout.scout.menu", MENU_PROCESS_NAME = "ScoutMenu", APP_BUNDLE_ID2 = "app.openscout.scout", APP_BUNDLE_NAME = "OpenScout.app", EMBEDDED_MENU_RELATIVE_PATH, HELP_FLAGS14, COMMON_APP_BUNDLE_PATHS;
+var MENU_BUNDLE_ID = "app.openscout.scout.menu", MENU_PROCESS_NAME = "ScoutMenu", APP_BUNDLE_ID = "app.openscout.scout", APP_BUNDLE_NAME = "OpenScout.app", EMBEDDED_MENU_RELATIVE_PATH, HELP_FLAGS14, COMMON_APP_BUNDLE_PATHS;
 var init_menu = __esm(() => {
   init_src3();
   init_app_lifecycle();
@@ -114840,7 +115726,7 @@ function renderMeshNodes(input) {
 var init_mesh = () => {};
 
 // ../../apps/desktop/src/core/mesh/enroll-pending.ts
-import { existsSync as existsSync42, mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname29, join as join51 } from "path";
 function pendingMeshEnrollmentPath(supportDirectory) {
   const dir = supportDirectory ?? resolveOpenScoutSupportPaths().supportDirectory;
@@ -114852,12 +115738,12 @@ function savePendingMeshEnrollment(handshake, supportDirectory) {
   }
   const path = pendingMeshEnrollmentPath(supportDirectory);
   mkdirSync12(dirname29(path), { recursive: true });
-  writeFileSync10(path, `${JSON.stringify(handshake, null, 2)}
+  writeFileSync9(path, `${JSON.stringify(handshake, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function loadPendingMeshEnrollment(supportDirectory) {
   const path = pendingMeshEnrollmentPath(supportDirectory);
-  if (!existsSync42(path)) {
+  if (!existsSync41(path)) {
     return null;
   }
   let parsed;
@@ -114873,8 +115759,8 @@ function loadPendingMeshEnrollment(supportDirectory) {
 }
 function clearPendingMeshEnrollment(supportDirectory) {
   const path = pendingMeshEnrollmentPath(supportDirectory);
-  if (existsSync42(path)) {
-    rmSync6(path);
+  if (existsSync41(path)) {
+    rmSync5(path);
   }
 }
 var PENDING_FILE = "mesh-enroll-pending.json";
@@ -115637,7 +116523,7 @@ var exports_mesh_bridge = {};
 __export(exports_mesh_bridge, {
   runMeshBridgeCommand: () => runMeshBridgeCommand
 });
-import { existsSync as existsSync43, mkdirSync as mkdirSync13, readFileSync as readFileSync21, unlinkSync, writeFileSync as writeFileSync11, chmodSync as chmodSync2 } from "fs";
+import { existsSync as existsSync42, mkdirSync as mkdirSync13, readFileSync as readFileSync21, unlinkSync, writeFileSync as writeFileSync10, chmodSync as chmodSync2 } from "fs";
 import { homedir as homedir33 } from "os";
 import { join as join52 } from "path";
 function supportDirectory() {
@@ -115656,7 +116542,7 @@ function readFlag(args, name2) {
   return args[index2 + 1]?.trim() || undefined;
 }
 function loadConfigFile(path) {
-  if (!existsSync43(path))
+  if (!existsSync42(path))
     return null;
   return JSON.parse(readFileSync21(path, "utf8"));
 }
@@ -115744,7 +116630,7 @@ async function installBridge(context, args) {
     return;
   }
   mkdirSync13(supportDirectory(), { recursive: true });
-  writeFileSync11(configPath, `${JSON.stringify(config2, null, 2)}
+  writeFileSync10(configPath, `${JSON.stringify(config2, null, 2)}
 `);
   chmodSync2(configPath, 384);
   const logDirectory = join52(supportDirectory(), "logs");
@@ -115772,7 +116658,7 @@ async function installBridge(context, args) {
 </dict>
 </plist>
 `;
-  writeFileSync11(launchAgentPlistPath2(), plist);
+  writeFileSync10(launchAgentPlistPath2(), plist);
   const domain2 = `gui/${process.getuid?.() ?? 501}`;
   launchctl(context, ["bootout", `${domain2}/${LAUNCH_AGENT_LABEL}`]);
   const bootstrap = launchctl(context, ["bootstrap", domain2, launchAgentPlistPath2()]);
@@ -115789,7 +116675,7 @@ async function installBridge(context, args) {
 async function uninstallBridge(context) {
   const domain2 = `gui/${process.getuid?.() ?? 501}`;
   launchctl(context, ["bootout", `${domain2}/${LAUNCH_AGENT_LABEL}`]);
-  if (existsSync43(launchAgentPlistPath2())) {
+  if (existsSync42(launchAgentPlistPath2())) {
     unlinkSync(launchAgentPlistPath2());
   }
   context.stdout(`Removed ${LAUNCH_AGENT_LABEL} (config file kept).`);
@@ -115993,7 +116879,7 @@ var init_mesh2 = __esm(() => {
 });
 
 // ../runtime/src/agent-workspace.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import { mkdir as mkdir13 } from "fs/promises";
 import { join as join53 } from "path";
 async function isGitRepo(projectRoot) {
@@ -116017,7 +116903,7 @@ async function createAgentWorkspace(projectRoot, agentName, requestedBranch) {
   validateWorktreeBranch(branch);
   const workspaceDir = join53(projectRoot, SCOUT_WORKSPACES_DIRNAME);
   const workspacePath = join53(workspaceDir, agentName);
-  if (existsSync44(workspacePath)) {
+  if (existsSync43(workspacePath)) {
     return { path: workspacePath, branch };
   }
   await mkdir13(workspaceDir, { recursive: true });
@@ -117734,12 +118620,12 @@ var init_pairing_supervisor = () => {};
 
 // ../../apps/desktop/src/app/host/pairing.ts
 import {
-  existsSync as existsSync45,
+  existsSync as existsSync44,
   mkdirSync as mkdirSync14,
   readFileSync as readFileSync22,
   statSync as statSync12,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir35 } from "os";
 import { join as join55 } from "path";
@@ -117886,7 +118772,7 @@ async function withScoutPairingBridgeClient(port, run2) {
 }
 function loadScoutPairingConfig() {
   const { configPath } = resolveScoutPairingPaths();
-  if (!existsSync45(configPath)) {
+  if (!existsSync44(configPath)) {
     return {};
   }
   try {
@@ -117922,7 +118808,7 @@ function resolveScoutPairingConfig() {
 }
 function readScoutPairingRuntimeSnapshot() {
   const { runtimeStatePath } = resolveScoutPairingPaths();
-  if (!existsSync45(runtimeStatePath)) {
+  if (!existsSync44(runtimeStatePath)) {
     return null;
   }
   try {
@@ -117934,7 +118820,7 @@ function readScoutPairingRuntimeSnapshot() {
 }
 function readScoutPairingRuntimePid() {
   const { runtimePidPath } = resolveScoutPairingPaths();
-  if (!existsSync45(runtimePidPath)) {
+  if (!existsSync44(runtimePidPath)) {
     return null;
   }
   try {
@@ -117986,7 +118872,7 @@ var init_pairing = __esm(() => {
 
 // ../../apps/desktop/src/app/host/agent-session.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import { open as open2 } from "fs/promises";
 import path from "path";
 function compactHomePath2(value) {
@@ -118127,7 +119013,7 @@ async function readAgentSessionLogs(agentId, tailLines) {
   let foundAny = false;
   let targetPath = null;
   for (const filePath of sources) {
-    if (!existsSync46(filePath)) {
+    if (!existsSync45(filePath)) {
       continue;
     }
     foundAny = true;
@@ -121783,7 +122669,7 @@ var init_monitor2 = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/config.ts
-import { existsSync as existsSync47, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync46, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir36 } from "os";
 import path2 from "path";
 function pairingPaths() {
@@ -121800,7 +122686,7 @@ function pairingPaths() {
 }
 function loadPairingConfig() {
   const { configPath } = pairingPaths();
-  if (!existsSync47(configPath)) {
+  if (!existsSync46(configPath)) {
     return {};
   }
   try {
@@ -123904,11 +124790,11 @@ var init_noise = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/security/identity.ts
-import { existsSync as existsSync48, mkdirSync as mkdirSync16, readFileSync as readFileSync24, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync47, mkdirSync as mkdirSync16, readFileSync as readFileSync24, writeFileSync as writeFileSync13 } from "fs";
 import { join as join56 } from "path";
 import { homedir as homedir37 } from "os";
 function loadOrCreateIdentity() {
-  if (existsSync48(IDENTITY_FILE)) {
+  if (existsSync47(IDENTITY_FILE)) {
     return loadIdentity();
   }
   return createAndSaveIdentity();
@@ -123928,11 +124814,11 @@ function createAndSaveIdentity() {
     privateKey: bytesToHex2(keyPair.privateKey),
     createdAt: new Date().toISOString()
   };
-  writeFileSync14(IDENTITY_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+  writeFileSync13(IDENTITY_FILE, JSON.stringify(data, null, 2), { mode: 384 });
   return keyPair;
 }
 function loadTrustedPeers() {
-  if (!existsSync48(TRUSTED_PEERS_FILE))
+  if (!existsSync47(TRUSTED_PEERS_FILE))
     return new Map;
   const data = JSON.parse(readFileSync24(TRUSTED_PEERS_FILE, "utf8"));
   return new Map(data.map((p) => [p.publicKey, p]));
@@ -123941,7 +124827,7 @@ function saveTrustedPeer(peer) {
   const peers = loadTrustedPeers();
   peers.set(peer.publicKey, peer);
   mkdirSync16(PAIRING_DIR, { recursive: true });
-  writeFileSync14(TRUSTED_PEERS_FILE, JSON.stringify([...peers.values()], null, 2), { mode: 384 });
+  writeFileSync13(TRUSTED_PEERS_FILE, JSON.stringify([...peers.values()], null, 2), { mode: 384 });
 }
 function isTrustedPeer(publicKeyHex) {
   return loadTrustedPeers().has(publicKeyHex);
@@ -124146,10 +125032,10 @@ var init_security2 = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime-state.ts
-import { existsSync as existsSync49, mkdirSync as mkdirSync17, readFileSync as readFileSync25, renameSync as renameSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync48, mkdirSync as mkdirSync17, readFileSync as readFileSync25, renameSync as renameSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
 function readPairingRuntimeSnapshot() {
   const { runtimeStatePath } = pairingPaths();
-  if (!existsSync49(runtimeStatePath)) {
+  if (!existsSync48(runtimeStatePath)) {
     return null;
   }
   try {
@@ -124271,11 +125157,11 @@ var init_bridge = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/config.ts
-import { existsSync as existsSync50, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync26 } from "fs";
 import { join as join58 } from "path";
 import { homedir as homedir39 } from "os";
 function loadConfigFile2() {
-  if (!existsSync50(CONFIG_FILE)) {
+  if (!existsSync49(CONFIG_FILE)) {
     return {};
   }
   try {
@@ -124607,7 +125493,7 @@ var init_artifact_presentation = __esm(() => {
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/fileserver.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync51, mkdirSync as mkdirSync19, readFileSync as readFileSync27, realpathSync as realpathSync4, statSync as statSync14, unlinkSync as unlinkSync4, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync19, readFileSync as readFileSync27, realpathSync as realpathSync4, statSync as statSync14, unlinkSync as unlinkSync4, writeFileSync as writeFileSync15 } from "fs";
 import { BlockList, isIP } from "net";
 import { isAbsolute as isAbsolute6, join as join59, relative as relative6, sep as sep4 } from "path";
 import { homedir as homedir40 } from "os";
@@ -124630,7 +125516,7 @@ function storePairingAttachmentBlob(input, options) {
   purgeExpiredPairingAttachments(options.now);
   const id = `att-${randomUUID6()}`;
   const path3 = join59(PAIRING_ATTACHMENT_ROOT, id);
-  writeFileSync16(path3, data, { mode: 384 });
+  writeFileSync15(path3, data, { mode: 384 });
   const now = options.now ?? Date.now();
   const entry = {
     id,
@@ -124678,14 +125564,14 @@ function resolvePairingAttachment(id, now) {
   }
   const known = attachmentBlobs.get(id);
   if (known) {
-    if (known.expiresAt <= now || !existsSync51(known.path)) {
+    if (known.expiresAt <= now || !existsSync50(known.path)) {
       forgetPairingAttachment(id);
       return null;
     }
     return known;
   }
   const rehydrated = readAttachmentSidecar(id);
-  if (!rehydrated || rehydrated.expiresAt <= now || !existsSync51(rehydrated.path)) {
+  if (!rehydrated || rehydrated.expiresAt <= now || !existsSync50(rehydrated.path)) {
     return null;
   }
   attachmentBlobs.set(id, rehydrated);
@@ -124696,7 +125582,7 @@ function attachmentSidecarPath(id) {
 }
 function writeAttachmentSidecar(entry) {
   try {
-    writeFileSync16(attachmentSidecarPath(entry.id), JSON.stringify({
+    writeFileSync15(attachmentSidecarPath(entry.id), JSON.stringify({
       id: entry.id,
       mediaType: entry.mediaType,
       fileName: entry.fileName,
@@ -125444,7 +126330,7 @@ var init_fileserver = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/ssh-terminal-access.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function validateIosGeneratedSshPublicKey(publicKey) {
   const fields = publicKey.trim().split(/\s+/);
   if (fields.length < 2) {
@@ -125605,10 +126491,10 @@ function readSshWireString(buffer, offset) {
   };
 }
 function fingerprintKeyData(keyData) {
-  return `SHA256:${createHash11("sha256").update(Buffer.from(keyData, "base64")).digest("base64").replace(/=+$/, "")}`;
+  return `SHA256:${createHash13("sha256").update(Buffer.from(keyData, "base64")).digest("base64").replace(/=+$/, "")}`;
 }
 function fingerprintUtf8(value) {
-  return `SHA256:${createHash11("sha256").update(value, "utf8").digest("base64").replace(/=+$/, "")}`;
+  return `SHA256:${createHash13("sha256").update(value, "utf8").digest("base64").replace(/=+$/, "")}`;
 }
 function encodeMarkerValue(value) {
   return Buffer.from(value, "utf8").toString("base64url");
@@ -125631,10 +126517,10 @@ var init_ssh_terminal_access = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/mobile-terminal-session.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function mobileTerminalSessionName(sshPublicKey, deviceClass) {
   const normalizedClass = normalizeMobileTerminalDeviceClass(deviceClass);
-  const signature = createHash12("sha256").update(sshPublicKey.trim()).digest("hex").slice(0, 8);
+  const signature = createHash14("sha256").update(sshPublicKey.trim()).digest("hex").slice(0, 8);
   return `scout-${normalizedClass}-${signature}`;
 }
 function provisionedMobileTerminalSessionName(sshPublicKey, deviceClass) {
@@ -125670,23 +126556,23 @@ var init_mobile_terminal_session = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/mobile-terminal-provision.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import {
   chmodSync as chmodSync3,
   closeSync,
-  existsSync as existsSync52,
+  existsSync as existsSync51,
   mkdirSync as mkdirSync20,
   openSync,
   readFileSync as readFileSync28,
   renameSync as renameSync6,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync16
 } from "fs";
 import { homedir as homedir41, hostname as hostname5, userInfo as userInfo2 } from "os";
 import { join as join60 } from "path";
 async function readMobileTerminalStatus(requestedSessionName, deviceId) {
   const authorizedKeysPath = join60(homedir41(), ".ssh", "authorized_keys");
-  const authorizedKeys = existsSync52(authorizedKeysPath) ? readFileSync28(authorizedKeysPath, "utf8") : "";
+  const authorizedKeys = existsSync51(authorizedKeysPath) ? readFileSync28(authorizedKeysPath, "utf8") : "";
   const provisionedSessionName = findSshTerminalSessionForDevice(authorizedKeys, deviceId);
   const sessionName = authorizedMobileTerminalSessionName(requestedSessionName, provisionedSessionName);
   const base = {
@@ -125762,13 +126648,13 @@ async function provisionMobileTerminalAccess(sshPublicKey, deviceId, deviceClass
   const authorizedKeysPath = join60(sshDir, "authorized_keys");
   const hostKeyFingerprint = readRequiredHostKeyFingerprint();
   const result = withAuthorizedKeysLock(sshDir, () => {
-    if (!existsSync52(sshDir)) {
+    if (!existsSync51(sshDir)) {
       mkdirSync20(sshDir, { recursive: true, mode: 448 });
     }
     try {
       chmodSync3(sshDir, 448);
     } catch {}
-    const existing = existsSync52(authorizedKeysPath) ? readFileSync28(authorizedKeysPath, "utf8") : "";
+    const existing = existsSync51(authorizedKeysPath) ? readFileSync28(authorizedKeysPath, "utf8") : "";
     const result2 = provisionSshTerminalAccess({
       authorizedKeys: existing,
       deviceId: id,
@@ -125820,7 +126706,7 @@ function readRequiredHostKeyFingerprint() {
     const keyData = pub.trim().split(/\s+/)[1];
     if (!keyData)
       throw new Error("missing key data");
-    const digest = createHash13("sha256").update(Buffer.from(keyData, "base64")).digest("base64").replace(/=+$/, "");
+    const digest = createHash15("sha256").update(Buffer.from(keyData, "base64")).digest("base64").replace(/=+$/, "");
     return `SHA256:${digest}`;
   } catch (error48) {
     const detail = error48 instanceof Error ? error48.message : String(error48);
@@ -125830,7 +126716,7 @@ function readRequiredHostKeyFingerprint() {
 function writeAuthorizedKeysAtomically(path3, contents) {
   const tmpPath = `${path3}.scout-${process.pid}-${Date.now()}.tmp`;
   try {
-    writeFileSync17(tmpPath, contents, { mode: 384, flag: "wx" });
+    writeFileSync16(tmpPath, contents, { mode: 384, flag: "wx" });
     renameSync6(tmpPath, path3);
   } catch (error48) {
     try {
@@ -125840,7 +126726,7 @@ function writeAuthorizedKeysAtomically(path3, contents) {
   }
 }
 function withAuthorizedKeysLock(sshDir, action) {
-  if (!existsSync52(sshDir)) {
+  if (!existsSync51(sshDir)) {
     mkdirSync20(sshDir, { recursive: true, mode: 448 });
   }
   const lockPath = join60(sshDir, ".scout-authorized-keys.lock");
@@ -130601,6 +131487,9 @@ function startRelay(port, options = {}) {
     } : {},
     fetch(req, server2) {
       const url2 = new URL(req.url);
+      if (url2.pathname === "/pair" && req.method === "GET") {
+        return proxyPairHttp(req, url2, options.pairHttpOrigin, server2.requestIP(req)?.address);
+      }
       if (url2.pathname === "/resolve" && req.method === "POST") {
         return handleResolve(req, roomByBridgeKey, rooms);
       }
@@ -130744,6 +131633,46 @@ function startRelay(port, options = {}) {
     }
   };
 }
+async function proxyPairHttp(req, url2, pairHttpOrigin, clientIp) {
+  const origin = pairHttpOrigin === undefined ? `http://127.0.0.1:${resolveWebPort()}` : pairHttpOrigin?.trim() || null;
+  if (!origin) {
+    return new Response("Pairing HTTP is not configured", { status: 503 });
+  }
+  const target2 = new URL("/pair", origin);
+  target2.search = url2.search;
+  const headers2 = pairProxyHeaders(req, clientIp);
+  try {
+    const response = await fetch(target2, {
+      method: "GET",
+      headers: headers2,
+      redirect: "manual",
+      signal: AbortSignal.timeout(3000)
+    });
+    const out = new Headers;
+    for (const name2 of ["location", "cache-control", "content-type"]) {
+      const value = response.headers.get(name2);
+      if (value)
+        out.set(name2, value);
+    }
+    return new Response(response.body, { status: response.status, headers: out });
+  } catch {
+    return new Response("Pairing service unreachable", { status: 502 });
+  }
+}
+function pairProxyHeaders(req, clientIp) {
+  const headers2 = new Headers;
+  for (const name2 of ["accept", "user-agent", "x-scout-client", "x-scout-device-name"]) {
+    const value = req.headers.get(name2);
+    if (value)
+      headers2.set(name2, value);
+  }
+  headers2.set("x-scout-pair-relay", "1");
+  if (clientIp) {
+    headers2.set("x-forwarded-for", clientIp);
+    headers2.set("x-real-ip", clientIp);
+  }
+  return headers2;
+}
 async function handleResolve(req, roomByBridgeKey, rooms) {
   try {
     const body = await req.json();
@@ -130809,18 +131738,21 @@ function parseRelayEnvelope2(data) {
   }
 }
 var BRIDGE_ABSENCE_GRACE_MS = 30000, ROOM_IDLE_TIMEOUT_MS = 60000;
+var init_relay = __esm(() => {
+  init_local_config();
+});
 
 // ../../apps/desktop/src/core/pairing/runtime/relay-runtime.ts
-import { existsSync as existsSync53, mkdirSync as mkdirSync22 } from "fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync22 } from "fs";
 import { homedir as homedir46, networkInterfaces as networkInterfaces2 } from "os";
 import { join as join63 } from "path";
 async function findStoredTailscaleCert(hostname6) {
-  if (!existsSync53(PAIRING_DIR2)) {
+  if (!existsSync52(PAIRING_DIR2)) {
     return null;
   }
   const certPath = join63(PAIRING_DIR2, `${hostname6}.crt`);
   const keyPath = join63(PAIRING_DIR2, `${hostname6}.key`);
-  if (!existsSync53(certPath) || !existsSync53(keyPath)) {
+  if (!existsSync52(certPath) || !existsSync52(keyPath)) {
     return null;
   }
   if (!await storedCertificateLooksPubliclyTrusted(certPath)) {
@@ -131032,6 +131964,7 @@ var PAIRING_DIR2;
 var init_relay_runtime = __esm(() => {
   init_system_probes();
   init_log2();
+  init_relay();
   PAIRING_DIR2 = join63(homedir46(), ".scout/pairing");
 });
 
@@ -133198,7 +134131,7 @@ __export(exports_session, {
   mergeTerminalSurfaces: () => mergeTerminalSurfaces
 });
 import { spawnSync as spawnSync11 } from "child_process";
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { mkdirSync as mkdirSync23 } from "fs";
 import { homedir as homedir47 } from "os";
 import { basename as basename22, join as join64, resolve as resolve35 } from "path";
@@ -133563,7 +134496,7 @@ function terminalSurfaceKey(surface) {
 function defaultTerminalSessionName(input) {
   const projectName2 = sanitizeTerminalSessionNamePart(basename22(input.cwd) || "workspace", 28);
   const harnessName = sanitizeTerminalSessionNamePart(input.harness, 18);
-  const fingerprint = createHash14("sha1").update(`${input.backend}\x00${input.harness}\x00${input.cwd}\x00${input.sessionId}`).digest("hex").slice(0, 10);
+  const fingerprint = createHash16("sha1").update(`${input.backend}\x00${input.harness}\x00${input.cwd}\x00${input.sessionId}`).digest("hex").slice(0, 10);
   return `scout-${harnessName}-${projectName2}-${fingerprint}`;
 }
 function sanitizeTerminalSessionNamePart(value, maxLength) {
@@ -133932,7 +134865,7 @@ __export(exports_server, {
   normalizeServerOpenPath: () => normalizeServerOpenPath
 });
 import { spawn as spawn10 } from "child_process";
-import { existsSync as existsSync54, mkdirSync as mkdirSync24, openSync as openSync2, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync53, mkdirSync as mkdirSync24, openSync as openSync2, writeFileSync as writeFileSync17 } from "fs";
 import { homedir as homedir48 } from "os";
 import { dirname as dirname31, join as join65, resolve as resolve36 } from "path";
 import { fileURLToPath as fileURLToPath12 } from "url";
@@ -134372,7 +135305,7 @@ async function runScoutLocalEdge(env) {
   const config3 = resolveServerLocalEdgeConfig(env);
   const schemes = config3.scheme === "both" ? ["http", "https"] : [config3.scheme];
   const caddyfilePath = resolveScoutLocalEdgeCaddyfilePath();
-  writeFileSync18(caddyfilePath, renderOpenScoutCaddyfile(config3), "utf8");
+  writeFileSync17(caddyfilePath, renderOpenScoutCaddyfile(config3), "utf8");
   const mdnsProcesses = schemes.flatMap((scheme) => {
     const edgePort = scheme === "https" ? 443 : 80;
     const suffix = scheme.toUpperCase();
@@ -134514,14 +135447,14 @@ __export(exports_setup, {
   runSetupCommand: () => runSetupCommand,
   resolveSetupSourceRoots: () => resolveSetupSourceRoots
 });
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 import { homedir as homedir49 } from "os";
 import { dirname as dirname32, join as join66, resolve as resolve37 } from "path";
 import { createInterface as createInterface4 } from "readline/promises";
 function findGitRoot2(startDirectory) {
   let current = resolve37(startDirectory);
   while (true) {
-    if (existsSync55(join66(current, ".git")))
+    if (existsSync54(join66(current, ".git")))
       return current;
     const parent = dirname32(current);
     if (parent === current)
@@ -134538,7 +135471,7 @@ function suggestProjectSourceRoot(currentDirectory, homeDirectory = homedir49())
     join66(homeDirectory, "Developer"),
     join66(homeDirectory, "Projects")
   ]) {
-    if (existsSync55(candidate))
+    if (existsSync54(candidate))
       return candidate;
   }
   return resolve37(currentDirectory);
@@ -134575,7 +135508,7 @@ async function resolveSetupSourceRoots(context, currentDirectory, sourceRoots, e
 async function runSetupCommand(context, args) {
   const options = parseSetupCommandOptions(args, defaultScoutContextDirectory(context));
   const settings = await readOpenScoutSettings({ currentDirectory: options.currentDirectory });
-  const hasSavedSettings = existsSync55(resolveOpenScoutSupportPaths().settingsPath);
+  const hasSavedSettings = existsSync54(resolveOpenScoutSupportPaths().settingsPath);
   options.sourceRoots = await resolveSetupSourceRoots({ ...context, isTty: context.isTty && Boolean(process.stdin.isTTY) }, options.currentDirectory, options.sourceRoots, {
     roots: hasSavedSettings ? settings.discovery.workspaceRoots : [],
     answeredAt: hasSavedSettings ? settings.onboarding.sourceRootsAnsweredAt : null
@@ -134831,7 +135764,7 @@ function readPositiveIntEnv(name2, fallback2) {
   const raw2 = Number.parseInt(process.env[name2] ?? "", 10);
   return Number.isFinite(raw2) && raw2 > 0 ? raw2 : fallback2;
 }
-var TAIL_POLL_INTERVAL_MS, HOT_DISCOVERY_INTERVAL_MS, DISCOVERY_CACHE_MAX_AGE_MS, SHALLOW_DISCOVERY_INTERVAL_MS, DEEP_DISCOVERY_INTERVAL_MS, QUIET_EVENT_COALESCE_WINDOW_MS, QUIET_EVENT_COALESCE_MAX_KEYS, RECENT_TRANSCRIPT_READ_BYTES, SESSION_TRANSCRIPT_READ_BYTES, RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES, RECENT_TRANSCRIPT_MAX_FILES, NATIVE_TAIL_SOURCES, TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES, TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS, transcriptReplayMemo, transcriptReplayInFlight, watchers, perSessionBuffer, subscribers, knownTranscripts, quietEventLastSeen, GROK_QUIET_PHASES;
+var DEFAULT_TAIL_POLL_INTERVAL_MS = 1e4, DEFAULT_HOT_DISCOVERY_INTERVAL_MS = 60000, TAIL_POLL_INTERVAL_MS, HOT_DISCOVERY_INTERVAL_MS, DISCOVERY_CACHE_MAX_AGE_MS, SHALLOW_DISCOVERY_INTERVAL_MS, DEEP_DISCOVERY_INTERVAL_MS, QUIET_EVENT_COALESCE_WINDOW_MS, QUIET_EVENT_COALESCE_MAX_KEYS, RECENT_TRANSCRIPT_READ_BYTES, WATCHER_READ_BYTES, WATCHER_DRAIN_BYTES, WATCHER_PUMP_CONCURRENCY, SESSION_TRANSCRIPT_READ_BYTES, RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES, RECENT_TRANSCRIPT_MAX_FILES, INTERNAL_RECONCILE_SESSIONS_PER_SOURCE, INTERNAL_RECONCILE_LINES_PER_SESSION, INTERNAL_RECONCILE_READ_BYTES, INTERNAL_HOT_WATCHER_WINDOW_MS, INTERNAL_IDLE_WATCHER_INTERVAL_MS, INTERNAL_IDLE_WATCHER_BATCH_SIZE, INTERNAL_ACTIVE_STALE_AFTER_MS, INTERNAL_PERSISTED_OBSERVED_SEED_LIMIT, NATIVE_TAIL_SOURCES, TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES, TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS, transcriptReplayMemo, transcriptReplayInFlight, watchers, perSessionBuffer, subscribers, internalSubscribers, knownTranscripts, persistedObservedSessions, quietEventLastSeen, GROK_QUIET_PHASES;
 var init_service11 = __esm(() => {
   init_claude_source();
   init_codex_source();
@@ -134840,17 +135773,28 @@ var init_service11 = __esm(() => {
   init_kimi_source();
   init_opencode_source();
   init_pi_source();
-  TAIL_POLL_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_POLL_INTERVAL_MS", 500);
-  HOT_DISCOVERY_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_HOT_DISCOVERY_INTERVAL_MS", 30000);
+  TAIL_POLL_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_POLL_INTERVAL_MS", DEFAULT_TAIL_POLL_INTERVAL_MS);
+  HOT_DISCOVERY_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_HOT_DISCOVERY_INTERVAL_MS", DEFAULT_HOT_DISCOVERY_INTERVAL_MS);
   DISCOVERY_CACHE_MAX_AGE_MS = readPositiveIntEnv("OPENSCOUT_TAIL_DISCOVERY_CACHE_MAX_AGE_MS", HOT_DISCOVERY_INTERVAL_MS);
   SHALLOW_DISCOVERY_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_SHALLOW_DISCOVERY_INTERVAL_MS", 10 * 60000);
   DEEP_DISCOVERY_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_DEEP_DISCOVERY_INTERVAL_MS", 60 * 60000);
   QUIET_EVENT_COALESCE_WINDOW_MS = readPositiveIntEnv("OPENSCOUT_TAIL_QUIET_EVENT_COALESCE_WINDOW_MS", 5000);
   QUIET_EVENT_COALESCE_MAX_KEYS = readPositiveIntEnv("OPENSCOUT_TAIL_QUIET_EVENT_COALESCE_MAX_KEYS", 2000);
   RECENT_TRANSCRIPT_READ_BYTES = 512 * 1024;
+  WATCHER_READ_BYTES = readPositiveIntEnv("OPENSCOUT_TAIL_WATCHER_READ_BYTES", 512 * 1024);
+  WATCHER_DRAIN_BYTES = Math.max(WATCHER_READ_BYTES, readPositiveIntEnv("OPENSCOUT_TAIL_WATCHER_DRAIN_BYTES", 4 * 1024 * 1024));
+  WATCHER_PUMP_CONCURRENCY = readPositiveIntEnv("OPENSCOUT_TAIL_WATCHER_PUMP_CONCURRENCY", 16);
   SESSION_TRANSCRIPT_READ_BYTES = 8 * 1024 * 1024;
   RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES = 32 * 1024 * 1024;
   RECENT_TRANSCRIPT_MAX_FILES = readPositiveIntEnv("OPENSCOUT_TAIL_RECENT_TRANSCRIPT_MAX_FILES", 24);
+  INTERNAL_RECONCILE_SESSIONS_PER_SOURCE = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_RECONCILE_SESSIONS_PER_SOURCE", 12);
+  INTERNAL_RECONCILE_LINES_PER_SESSION = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_RECONCILE_LINES_PER_SESSION", 128);
+  INTERNAL_RECONCILE_READ_BYTES = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_RECONCILE_READ_BYTES", 256 * 1024);
+  INTERNAL_HOT_WATCHER_WINDOW_MS = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_HOT_WATCHER_WINDOW_MS", 60000);
+  INTERNAL_IDLE_WATCHER_INTERVAL_MS = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_IDLE_WATCHER_INTERVAL_MS", 15000);
+  INTERNAL_IDLE_WATCHER_BATCH_SIZE = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_IDLE_WATCHER_BATCH_SIZE", 32);
+  INTERNAL_ACTIVE_STALE_AFTER_MS = readPositiveIntEnv("OPENSCOUT_TAIL_INTERNAL_ACTIVE_STALE_AFTER_MS", 30 * 60000);
+  INTERNAL_PERSISTED_OBSERVED_SEED_LIMIT = readPositiveIntEnv("OPENSCOUT_TAIL_PERSISTED_OBSERVED_SEED_LIMIT", 4096);
   NATIVE_TAIL_SOURCES = new Set(["grok", "kimi", "opencode", "cursor"]);
   TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES = readPositiveIntEnv("OPENSCOUT_TAIL_REPLAY_MEMO_MAX_ENTRIES", 256);
   TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS = readPositiveIntEnv("OPENSCOUT_TAIL_REPLAY_MEMO_ACTIVE_GRACE_MS", 2000);
@@ -134859,7 +135803,9 @@ var init_service11 = __esm(() => {
   watchers = new Map;
   perSessionBuffer = new Map;
   subscribers = new Set;
+  internalSubscribers = new Set;
   knownTranscripts = new Map;
+  persistedObservedSessions = new Map;
   quietEventLastSeen = new Map;
   GROK_QUIET_PHASES = new Set([
     "streaming_reasoning",
@@ -135415,7 +136361,7 @@ __export(exports_tui, {
   parseTuiLaunchOptions: () => parseTuiLaunchOptions
 });
 import { spawnSync as spawnSync12 } from "child_process";
-import { accessSync as accessSync5, constants as constants5, existsSync as existsSync56 } from "fs";
+import { accessSync as accessSync5, constants as constants5, existsSync as existsSync55 } from "fs";
 import { dirname as dirname33, join as join67, resolve as resolve38 } from "path";
 import { fileURLToPath as fileURLToPath13 } from "url";
 function renderTuiCommandHelp() {
@@ -135544,7 +136490,7 @@ function findScoutTuiCheckout(cwd, env) {
   for (const start of starts) {
     let current = resolve38(start);
     while (true) {
-      if (existsSync56(join67(current, "crates/scout-tui/Cargo.toml"))) {
+      if (existsSync55(join67(current, "crates/scout-tui/Cargo.toml"))) {
         return current;
       }
       const parent = dirname33(current);
@@ -135598,7 +136544,7 @@ var exports_up = {};
 __export(exports_up, {
   runUpCommand: () => runUpCommand
 });
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import { resolve as resolve39 } from "path";
 function looksLikePath(value) {
   return value.includes("/") || value.startsWith(".") || value.startsWith("~");
@@ -135707,7 +136653,7 @@ async function runUpCommand(context, args) {
     throw new ScoutCliError(`usage: scout up <name|path> [--name <alias>] [--harness <${SUPPORTED_LOCAL_AGENT_HARNESSES.join("|")}>] [--provider <provider>] [--model <model>] [--reasoning-effort <effort>] [--permission-profile <${formatScoutPermissionProfiles()}>]`);
   }
   let projectPath;
-  if (looksLikePath(target2) || existsSync57(resolve39(target2))) {
+  if (looksLikePath(target2) || existsSync56(resolve39(target2))) {
     projectPath = resolve39(target2);
   } else {
     const resolved = await resolveLocalAgentByName(target2);
@@ -136117,7 +137063,7 @@ var init_whoami = __esm(() => {
 });
 
 // ../../apps/desktop/src/cli/main.ts
-import { existsSync as existsSync58, statSync as statSync17 } from "fs";
+import { existsSync as existsSync57, statSync as statSync17 } from "fs";
 import { join as join70 } from "path";
 import { spawnSync as spawnSync13 } from "child_process";
 import { homedir as homedir50 } from "os";
@@ -136828,7 +137774,7 @@ function getScoutBinPath() {
   if (_scoutBinPath)
     return _scoutBinPath;
   _scoutBinPath = join70(homedir50(), ".bun", "bin", "scout");
-  if (!existsSync58(_scoutBinPath)) {
+  if (!existsSync57(_scoutBinPath)) {
     _scoutBinPath = spawnSync13("which", ["scout"], { encoding: "utf8" }).stdout.trim();
   }
   return _scoutBinPath;