@openscout/scout 0.2.95 → 0.2.96

package/dist/scout-control-plane-web.mjs

@@ -5539,7 +5539,7 @@ var init_sqlite_core = __esm(() => {
 });
 
 // packages/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();
@@ -5611,7 +5611,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" }),
@@ -5627,7 +5630,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(),
@@ -5651,6 +5661,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`)
   ]);
@@ -5670,6 +5681,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", {
@@ -5749,7 +5762,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(),
@@ -5769,7 +5783,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" }),
@@ -5798,7 +5813,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(),
@@ -5830,7 +5940,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(),
@@ -5876,7 +5989,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(),
@@ -6046,7 +6160,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" }),
@@ -6054,7 +6169,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(),
@@ -6256,6 +6372,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,
@@ -6328,6 +6451,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
@@ -6337,6 +6462,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;
@@ -6582,6 +6711,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,
@@ -6989,18 +7205,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
@@ -7009,6 +7281,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
@@ -7055,6 +7329,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
@@ -8630,12 +8908,15 @@ var init_host_integrations = () => {};
 // packages/protocol/src/native-interactions.ts
 var init_native_interactions = () => {};
 
+// packages/protocol/src/session-handle.ts
+var init_session_handle = () => {};
+
 // packages/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",
@@ -8659,6 +8940,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",
@@ -9769,6 +10057,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",
@@ -9837,6 +10126,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();
@@ -15281,6 +15571,9 @@ var init_budget_observations = __esm(() => {
   QUOTA_HISTORY_BUCKET_MS = 60 * 60 * 1000;
 });
 
+// packages/runtime/src/runtime-session-handle.ts
+var init_runtime_session_handle = () => {};
+
 // packages/runtime/src/sqlite-store.ts
 var RUNTIME_SESSION_RETENTION_MS;
 var init_sqlite_store = __esm(() => {
@@ -15292,6 +15585,7 @@ var init_sqlite_store = __esm(() => {
   init_api();
   init_drizzle_schema();
   init_budget_observations();
+  init_runtime_session_handle();
   RUNTIME_SESSION_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 });
 
@@ -32595,10 +32889,12 @@ var init_iroh_bridge = __esm(() => {
 var init_mesh_dial_order = () => {};
 
 // packages/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;
 });
 
 // packages/runtime/src/broker-api.ts
@@ -33406,11 +33702,32 @@ function resolveBundledRuntimeDirFromModuleDir(moduleDir) {
     resolve2(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 = dirname6(bundledPackageDir);
+  if (resolve2(packagesDir, "cli") !== resolve2(bundledPackageDir))
+    return null;
+  const runtimeDir = join8(packagesDir, "runtime");
+  if (!existsSync8(join8(runtimeDir, "src")))
+    return null;
+  if (!isInstalledRuntimePackageDir(runtimeDir))
+    return null;
+  try {
+    const cliPackage = JSON.parse(readFileSync5(join8(bundledPackageDir, "package.json"), "utf8"));
+    const runtimePackage = JSON.parse(readFileSync5(join8(runtimeDir, "package.json"), "utf8"));
+    return cliPackage.name === "@openscout/scout" && runtimePackage.name === "@openscout/runtime" ? runtimeDir : null;
+  } catch {
+    return null;
+  }
+}
 function findWorkspaceRuntimeDir(startDir) {
   let current = resolve2(startDir);
   while (true) {
@@ -54137,6 +54454,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",
@@ -57632,6 +57950,14 @@ function resolveScoutWebBindHost(env) {
   }
   return host;
 }
+function resolveScoutWebLanAccessScope(env) {
+  const scope = env.OPENSCOUT_WEB_LAN_SCOPE?.trim().toLowerCase();
+  if (!scope || scope === "full")
+    return "full";
+  if (scope === "pairing")
+    return "pairing";
+  throw new Error(`Unsupported OPENSCOUT_WEB_LAN_SCOPE: ${scope}`);
+}
 function constantTimeTokenMatch(candidate, expected) {
   if (!candidate)
     return false;
@@ -57673,20 +57999,29 @@ function scoutWebAuthCookie(token, secure) {
 function localInterfaceAddresses() {
   return Object.values(networkInterfaces2()).flatMap((entries) => entries ?? []).map((entry) => entry.address);
 }
-function shouldIssueLocalScoutWebCredential(request, peerAddress, ownAddresses = localInterfaceAddresses()) {
+function isSameMacScoutRequest(request, peerAddress, ownAddresses = localInterfaceAddresses()) {
   if (!peerAddress || !isLoopbackScoutAddress(peerAddress))
     return false;
   if (request.headers.has("forwarded"))
     return false;
-  const forwardedFor = request.headers.get("x-forwarded-for");
-  if (!forwardedFor)
-    return true;
-  if (forwardedFor.includes(","))
-    return false;
-  const clientAddress = normalizeIpAddress(forwardedFor);
-  if (!clientAddress)
-    return false;
-  return isLoopbackScoutAddress(clientAddress) || ownAddresses.some((address) => normalizeIpAddress(address) === clientAddress);
+  const forwardedAddresses = [
+    request.headers.get("x-forwarded-for"),
+    request.headers.get("x-real-ip")
+  ].filter((value) => value !== null);
+  for (const value of forwardedAddresses) {
+    if (value.includes(","))
+      return false;
+    const clientAddress = normalizeIpAddress(value);
+    if (!clientAddress)
+      return false;
+    if (!isLoopbackScoutAddress(clientAddress) && !ownAddresses.some((address) => normalizeIpAddress(address) === clientAddress)) {
+      return false;
+    }
+  }
+  return true;
+}
+function shouldIssueLocalScoutWebCredential(request, peerAddress, ownAddresses = localInterfaceAddresses()) {
+  return isSameMacScoutRequest(request, peerAddress, ownAddresses);
 }
 function normalizeIpAddress(address) {
   const normalized = normalizeHostname(address);
@@ -57728,13 +58063,32 @@ function isLoopbackScoutAddress(address) {
   const mapped = normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized;
   return LOOPBACK_IPV4_HOST_PATTERN.test(mapped);
 }
-function defaultPeerAddress(c) {
+function resolveScoutRequestPeerAddress(c) {
   try {
     return getConnInfo(c).remote.address;
   } catch {
     return;
   }
 }
+function createScoutRequestPeerAddressRegistry() {
+  const peers = new WeakMap;
+  return {
+    remember(request, address) {
+      if (address)
+        peers.set(request, address);
+    },
+    resolve(c) {
+      return peers.get(c.req.raw) ?? resolveScoutRequestPeerAddress(c);
+    }
+  };
+}
+function isScoutWebRequestAllowedFromPeer(request, peerAddress, scope) {
+  if (scope === "full" || isSameMacScoutRequest(request, peerAddress)) {
+    return true;
+  }
+  const url = new URL(request.url);
+  return request.method === "GET" && url.pathname === "/pair" && request.headers.get("upgrade") === null;
+}
 function isTrustedScoutApiRequest(request, options = {}, peerAddress) {
   const requestUrl = new URL(request.url);
   const hostname2 = normalizeHostname(requestUrl.hostname);
@@ -57880,7 +58234,7 @@ function scoutApiPerfReport() {
 }
 function installScoutApiMiddleware(app, label = "api", options = {}) {
   app.use("/api/*", async (c, next) => {
-    const peerAddress = (options.resolvePeerAddress ?? defaultPeerAddress)(c);
+    const peerAddress = (options.resolvePeerAddress ?? resolveScoutRequestPeerAddress)(c);
     if (!isTrustedScoutApiRequest(c.req.raw, options, peerAddress)) {
       return c.json({ error: "forbidden" }, 403);
     }
@@ -58451,6 +58805,19 @@ async function readScoutBrokerHome(baseUrl = resolveScoutBrokerUrl(), options =
     return null;
   }
 }
+async function readScoutConversationProjection(limit = 160, baseUrl = resolveScoutBrokerUrl(), options = {}) {
+  const query = new URLSearchParams({
+    limit: String(Math.min(160, Math.max(1, Math.floor(limit))))
+  });
+  try {
+    return await brokerReadJson(baseUrl, `${scoutBrokerPaths.v1.conversationProjection}?${query}`, {
+      ...options,
+      signal: options.signal ?? AbortSignal.timeout(450)
+    });
+  } catch {
+    return null;
+  }
+}
 async function readScoutBrokerRuntimeCatalog(baseUrl = resolveScoutBrokerUrl()) {
   try {
     return await brokerReadJson(baseUrl, scoutBrokerPaths.v1.runtimeCatalog);
@@ -58458,6 +58825,13 @@ async function readScoutBrokerRuntimeCatalog(baseUrl = resolveScoutBrokerUrl())
     return null;
   }
 }
+async function readScoutBrokerTailDiscovery(baseUrl = resolveScoutBrokerUrl()) {
+  try {
+    return await brokerReadJson(baseUrl, scoutBrokerPaths.v1.tailDiscover);
+  } catch {
+    return null;
+  }
+}
 async function readScoutBrokerSnapshot(baseUrl = resolveScoutBrokerUrl(), options = {}) {
   try {
     return await brokerReadJson(baseUrl, scoutBrokerPaths.v1.snapshot, options);
@@ -58495,26 +58869,24 @@ async function recordScoutBrokerReadCursor(input, baseUrl = resolveScoutBrokerUr
   });
 }
 async function loadScoutBrokerContext(baseUrl = resolveScoutBrokerUrl(), options = {}) {
-  const since = options.since === undefined ? Math.floor((Date.now() - DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS) / DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS) * DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS : options.since;
+  const usesRollingWindow = options.since === undefined;
+  const since = usesRollingWindow ? Math.floor((Date.now() - DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS) / DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS) * DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS : options.since;
   if (options.force) {
     invalidateScoutBrokerContextCache(baseUrl);
   }
   const cacheKey = options.signal ? null : [
     baseUrl,
     resolveBrokerSocketPathForBaseUrl(baseUrl) ?? "http",
-    since ?? "full",
+    usesRollingWindow ? "rolling-24h" : since ?? "full",
     options.scope ?? "default"
   ].join("\x00");
   const now = Date.now();
-  for (const [key, entry] of scoutBrokerContextCache) {
-    if (entry.expiresAt <= now)
+  for (const [key, entry2] of scoutBrokerContextCache) {
+    if (key !== cacheKey && !entry2.inFlight && entry2.expiresAt + SCOUT_BROKER_CONTEXT_STALE_RETENTION_MS <= now) {
       scoutBrokerContextCache.delete(key);
+    }
   }
-  const cached = cacheKey ? scoutBrokerContextCache.get(cacheKey) : null;
-  if (cached && cached.expiresAt > now) {
-    return cached.promise;
-  }
-  const promise = (async () => {
+  const readContext = async () => {
     const health = await readScoutBrokerHealth(baseUrl, { signal: options.signal });
     if (!health.reachable || !health.ok) {
       return null;
@@ -58538,19 +58910,60 @@ async function loadScoutBrokerContext(baseUrl = resolveScoutBrokerUrl(), options
     } catch {
       return null;
     }
-  })();
-  if (cacheKey) {
-    scoutBrokerContextCache.set(cacheKey, {
-      expiresAt: now + SCOUT_BROKER_CONTEXT_CACHE_TTL_MS,
-      promise
-    });
-    promise.then((context) => {
-      if (!context && scoutBrokerContextCache.get(cacheKey)?.promise === promise) {
+  };
+  if (!cacheKey) {
+    return readContext();
+  }
+  const refresh = (entry2, delayMs = 0) => {
+    if (entry2.inFlight)
+      return entry2.inFlight;
+    const attempt = (delayMs > 0 ? new Promise((resolve17) => setTimeout(resolve17, delayMs)) : Promise.resolve()).then(readContext).then((context) => {
+      if (scoutBrokerContextCache.get(cacheKey) !== entry2)
+        return context;
+      if (context) {
+        entry2.value = context;
+        entry2.hasValue = true;
+        entry2.expiresAt = Date.now() + SCOUT_BROKER_CONTEXT_CACHE_TTL_MS;
+      } else if (!entry2.hasValue) {
         scoutBrokerContextCache.delete(cacheKey);
+      } else {
+        entry2.expiresAt = Date.now() + SCOUT_BROKER_CONTEXT_CACHE_TTL_MS;
+      }
+      return context;
+    }).finally(() => {
+      if (scoutBrokerContextCache.get(cacheKey) === entry2) {
+        entry2.inFlight = null;
       }
     });
+    entry2.inFlight = attempt;
+    return attempt;
+  };
+  const cached = scoutBrokerContextCache.get(cacheKey);
+  if (cached) {
+    if (cached.hasValue) {
+      if (cached.expiresAt <= now && !cached.inFlight) {
+        refresh(cached);
+      }
+      return cached.value;
+    }
+    if (options.waitForInitial === false) {
+      refresh(cached, options.initialRefreshDelayMs);
+      return null;
+    }
+    return refresh(cached);
   }
-  return promise;
+  const entry = {
+    expiresAt: now + SCOUT_BROKER_CONTEXT_CACHE_TTL_MS,
+    value: null,
+    hasValue: false,
+    inFlight: null
+  };
+  scoutBrokerContextCache.set(cacheKey, entry);
+  if (options.waitForInitial === false) {
+    refresh(entry, options.initialRefreshDelayMs);
+    return null;
+  }
+  return refresh(entry);
 }
 async function requireScoutBrokerContext(baseUrl = resolveScoutBrokerUrl()) {
   const context = await loadScoutBrokerContext(baseUrl);
@@ -59336,14 +59749,11 @@ async function loadScoutReadCursors(input) {
   return brokerReadJson(input.baseUrl ?? resolveScoutBrokerUrl(), path);
 }
 async function markScoutConversationRead(input) {
-  const broker2 = await loadScoutBrokerContext(input.baseUrl);
-  if (!broker2) {
-    throw new Error("broker unreachable");
-  }
+  const baseUrl = input.baseUrl ?? resolveScoutBrokerUrl();
   const path = `/v1/conversations/${encodeURIComponent(input.conversationId)}/read-cursors`;
-  return brokerPostJson(broker2.baseUrl, path, {
+  return brokerPostJson(baseUrl, path, {
     actorId: input.actorId,
-    readerNodeId: input.readerNodeId ?? broker2.node.id,
+    readerNodeId: input.readerNodeId,
     lastReadMessageId: input.lastReadMessageId,
     lastReadSeq: input.lastReadSeq,
     lastReadAt: input.lastReadAt,
@@ -59507,7 +59917,7 @@ async function loadScoutRelayConfig() {
     return {};
   }
 }
-var DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS, DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS, SCOUT_BROKER_CONTEXT_CACHE_TTL_MS = 5000, scoutBrokerContextCache, ScoutDirectDeliveryUnavailableError, OPERATOR_ID = "operator", SCOPED_ALIAS_POOL, readScoutBrokerNodeIdCoalesced;
+var DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS, DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS, SCOUT_BROKER_CONTEXT_CACHE_TTL_MS = 30000, SCOUT_BROKER_CONTEXT_STALE_RETENTION_MS = 60000, scoutBrokerContextCache, ScoutDirectDeliveryUnavailableError, OPERATOR_ID = "operator", SCOPED_ALIAS_POOL, readScoutBrokerNodeIdCoalesced;
 var init_service = __esm(() => {
   init_src();
   init_setup();
@@ -60886,14 +61296,47 @@ function existingDirectConversationIdsForAgents(agentIds) {
   }
   return conversationIdByAgentId;
 }
+function queryAgentIdsForBoundedRoster(limit) {
+  const database = db2();
+  let recentIds;
+  try {
+    recentIds = database.prepare(RECENT_ENDPOINT_AGENT_IDS_SQL).all(limit);
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.includes("idx_agent_endpoints_roster_recency")) {
+      throw error;
+    }
+    recentIds = database.prepare(RECENT_ENDPOINT_AGENT_IDS_WITHOUT_INDEX_SQL).all(limit);
+  }
+  if (recentIds.length >= limit) {
+    return recentIds.map((row) => row.id);
+  }
+  const endpointUpdatedAtExpression2 = sqlTimestampMsExpression("ep.updated_at");
+  const fallbackIds = database.prepare(`SELECT a.id
+       FROM agents a
+       JOIN actors ac ON ac.id = a.id
+       ${LATEST_AGENT_ENDPOINT_JOIN}
+       WHERE ${activeAgentMetadataPredicate("a")}
+         AND COALESCE(${endpointUpdatedAtExpression2}, 0) <= 0
+       ORDER BY COALESCE(${endpointUpdatedAtExpression2}, 0) DESC, ac.display_name ASC
+       LIMIT ?`).all(limit - recentIds.length);
+  return [...recentIds, ...fallbackIds].map((row) => row.id);
+}
+function queryAgentRowsByIds(agentIds) {
+  if (agentIds.length === 0)
+    return [];
+  return db2().prepare(`${AGENT_ROW_SELECT}
+       WHERE a.id IN (SELECT value FROM json_each(?))
+         AND ${activeAgentMetadataPredicate("a")}
+       ORDER BY COALESCE(${endpointUpdatedAtExpression}, 0) DESC, ac.display_name ASC`).all(JSON.stringify(agentIds));
+}
 function queryAgentIdsByEndpointSessionId() {
-  const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+  const endpointUpdatedAtExpression2 = sqlTimestampMsExpression("ep.updated_at");
   const rows = db2().prepare(`SELECT a.id, ep.session_id
        FROM agents a
        ${LATEST_AGENT_ENDPOINT_JOIN}
        WHERE ep.session_id IS NOT NULL
          AND ${activeAgentMetadataPredicate("a")}
-       ORDER BY COALESCE(${endpointUpdatedAtExpression}, 0) ASC`).all();
+       ORDER BY COALESCE(${endpointUpdatedAtExpression2}, 0) ASC`).all();
   const map = new Map;
   for (const row of rows) {
     const sessionId = row.session_id.trim();
@@ -60905,87 +61348,20 @@ function queryAgentIdsByEndpointSessionId() {
 }
 function queryAgents(limit = 500) {
   const flightPhases = queryAgentFlightPhases();
-  const actorCreatedAtExpression = sqlTimestampMsExpression("ac.created_at");
-  const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
-  const rows = db2().prepare(`SELECT
-         a.id,
-         a.definition_id,
-         a.node_qualifier,
-         a.workspace_qualifier,
-         a.selector,
-         ac.display_name AS name,
-         ac.handle,
-         ${actorCreatedAtExpression} AS actor_created_at,
-         a.agent_class,
-         a.default_selector,
-         a.wake_policy,
-         a.capabilities_json,
-         a.metadata_json,
-         a.authority_node_id,
-         an.name AS authority_node_name,
-         a.home_node_id,
-         hn.name AS home_node_name,
-         a.owner_id,
-         oa.display_name AS owner_name,
-         oa.handle AS owner_handle,
-         ep.harness,
-         ep.transport,
-         ep.state,
-         ep.project_root,
-         ep.cwd,
-         ep.session_id,
-         ep.metadata_json AS endpoint_metadata_json,
-         ${endpointUpdatedAtExpression} AS updated_at
-       FROM agents a
-       JOIN actors ac ON ac.id = a.id
-       LEFT JOIN nodes an ON an.id = a.authority_node_id
-       LEFT JOIN nodes hn ON hn.id = a.home_node_id
-       LEFT JOIN actors oa ON oa.id = a.owner_id
-       ${LATEST_AGENT_ENDPOINT_JOIN}
-       WHERE ${activeAgentMetadataPredicate("a")}
-       ORDER BY COALESCE(${endpointUpdatedAtExpression}, 0) DESC, ac.display_name ASC
-       LIMIT ?`).all(limit);
+  let rows;
+  if (limit < 0) {
+    rows = db2().prepare(`${AGENT_ROW_SELECT}
+         WHERE ${activeAgentMetadataPredicate("a")}
+         ORDER BY COALESCE(${endpointUpdatedAtExpression}, 0) DESC, ac.display_name ASC
+         LIMIT ?`).all(limit);
+  } else {
+    rows = queryAgentRowsByIds(queryAgentIdsForBoundedRoster(limit));
+  }
   return mapAgentRows(rows, flightPhases, existingDirectConversationIdsForAgents(rows.map((row) => row.id)));
 }
 function queryAgentById(agentId) {
   const flightPhases = queryAgentFlightPhases();
-  const actorCreatedAtExpression = sqlTimestampMsExpression("ac.created_at");
-  const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
-  const row = db2().prepare(`SELECT
-         a.id,
-         a.definition_id,
-         a.node_qualifier,
-         a.workspace_qualifier,
-         a.selector,
-         ac.display_name AS name,
-         ac.handle,
-         ${actorCreatedAtExpression} AS actor_created_at,
-         a.agent_class,
-         a.default_selector,
-         a.wake_policy,
-         a.capabilities_json,
-         a.metadata_json,
-         a.authority_node_id,
-         an.name AS authority_node_name,
-         a.home_node_id,
-         hn.name AS home_node_name,
-         a.owner_id,
-         oa.display_name AS owner_name,
-         oa.handle AS owner_handle,
-         ep.harness,
-         ep.transport,
-         ep.state,
-         ep.project_root,
-         ep.cwd,
-         ep.session_id,
-         ep.metadata_json AS endpoint_metadata_json,
-         ${endpointUpdatedAtExpression} AS updated_at
-       FROM agents a
-       JOIN actors ac ON ac.id = a.id
-       LEFT JOIN nodes an ON an.id = a.authority_node_id
-       LEFT JOIN nodes hn ON hn.id = a.home_node_id
-       LEFT JOIN actors oa ON oa.id = a.owner_id
-       ${LATEST_AGENT_ENDPOINT_JOIN}
+  const row = db2().prepare(`${AGENT_ROW_SELECT}
        WHERE a.id = ?
          AND ${activeAgentMetadataPredicate("a")}
        LIMIT 1`).get(agentId);
@@ -61051,12 +61427,70 @@ function mapAgentRows(rows, flightPhases, conversationIdByAgentId) {
     };
   });
 }
+var actorCreatedAtExpression, endpointUpdatedAtExpression, AGENT_ROW_SELECT, RECENT_ENDPOINT_AGENT_IDS_WITHOUT_INDEX_SQL, RECENT_ENDPOINT_AGENT_IDS_SQL;
 var init_agents = __esm(() => {
   init_src();
   init_db2();
   init_parse2();
   init_paths3();
   init_sql_helpers();
+  actorCreatedAtExpression = sqlTimestampMsExpression("ac.created_at");
+  endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+  AGENT_ROW_SELECT = `SELECT
+  a.id,
+  a.definition_id,
+  a.node_qualifier,
+  a.workspace_qualifier,
+  a.selector,
+  ac.display_name AS name,
+  ac.handle,
+  ${actorCreatedAtExpression} AS actor_created_at,
+  a.agent_class,
+  a.default_selector,
+  a.wake_policy,
+  a.capabilities_json,
+  a.metadata_json,
+  a.authority_node_id,
+  an.name AS authority_node_name,
+  a.home_node_id,
+  hn.name AS home_node_name,
+  a.owner_id,
+  oa.display_name AS owner_name,
+  oa.handle AS owner_handle,
+  ep.harness,
+  ep.transport,
+  ep.state,
+  ep.project_root,
+  ep.cwd,
+  ep.session_id,
+  ep.metadata_json AS endpoint_metadata_json,
+  ${endpointUpdatedAtExpression} AS updated_at
+FROM agents a
+JOIN actors ac ON ac.id = a.id
+LEFT JOIN nodes an ON an.id = a.authority_node_id
+LEFT JOIN nodes hn ON hn.id = a.home_node_id
+LEFT JOIN actors oa ON oa.id = a.owner_id
+${LATEST_AGENT_ENDPOINT_JOIN}`;
+  RECENT_ENDPOINT_AGENT_IDS_WITHOUT_INDEX_SQL = (() => {
+    const endpointUpdatedAtExpression2 = sqlTimestampMsExpression("ep.updated_at");
+    const latestEndpointUpdatedAtExpression = sqlTimestampMsCoalesceExpression("ep2.updated_at");
+    return `SELECT a.id
+    FROM agent_endpoints ep
+    JOIN agents a ON a.id = ep.agent_id
+    JOIN actors ac ON ac.id = a.id
+    WHERE ep.id = (
+      SELECT ep2.id
+      FROM agent_endpoints ep2
+      WHERE ep2.agent_id = a.id
+      ORDER BY ${latestEndpointUpdatedAtExpression} DESC
+      LIMIT 1
+    )
+      AND ${endpointUpdatedAtExpression2} > 0
+      AND ${activeAgentMetadataPredicate("a")}
+    ORDER BY ${endpointUpdatedAtExpression2} DESC, ac.display_name ASC
+    LIMIT ?`;
+  })();
+  RECENT_ENDPOINT_AGENT_IDS_SQL = RECENT_ENDPOINT_AGENT_IDS_WITHOUT_INDEX_SQL.replace("FROM agent_endpoints ep", "FROM agent_endpoints ep INDEXED BY idx_agent_endpoints_roster_recency");
 });
 
 // packages/web/server/db/internal/conversation-ids.ts
@@ -61148,7 +61582,11 @@ function queryRecentMessages(limit = 80, opts) {
   const beforeMessage = resolveBeforeMessage(opts?.beforeMessageId, conversationIds, messageCreatedAtExpression);
   const where = sqlJoinClauses([
     transientBrokerWorkingStatusPredicate("m"),
-    conversationIds.length > 0 ? `m.conversation_id IN (${sqlPlaceholders(conversationIds.length)})` : "m.conversation_id LIKE 'c.%' AND length(m.conversation_id) > 2",
+    conversationIds.length > 0 ? `m.conversation_id IN (${sqlPlaceholders(conversationIds.length)})` : `(
+          (m.conversation_id LIKE 'chn-%' AND length(m.conversation_id) > 4)
+          OR (substr(m.conversation_id, 1, 5) = 'chat_' AND length(m.conversation_id) > 5)
+          OR (m.conversation_id LIKE 'c.%' AND length(m.conversation_id) > 2)
+        )`,
     beforeMessage ? `(
           ${messageCreatedAtExpression} < ?
           OR (${messageCreatedAtExpression} = ? AND m.id < ?)
@@ -62747,6 +63185,30 @@ function metadataString8(metadata, key) {
   const value = metadata[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function executionResolutionDimension(resolution, dimension) {
+  const value = resolution?.[dimension];
+  return value?.observed?.trim() || value?.resolved?.trim() || value?.requested?.trim() || null;
+}
+function durableConversationRuntime(row) {
+  if (!row)
+    return null;
+  const execution = parseMetadataJson(row.execution_json);
+  const rawResolution = parseMetadataJson(row.execution_resolution_json);
+  const resolution = rawResolution.schemaVersion === "openscout.execution-resolution.v1" ? rawResolution : null;
+  const flightMetadata = parseMetadataJson(row.flight_metadata_json);
+  const trace = Array.isArray(flightMetadata.sessionTrace) ? [...flightMetadata.sessionTrace].reverse().find((entry) => entry && typeof entry === "object" && !Array.isArray(entry)) : undefined;
+  const traceResolutionRaw = trace?.executionResolution;
+  const traceResolution = traceResolutionRaw && typeof traceResolutionRaw === "object" && !Array.isArray(traceResolutionRaw) && traceResolutionRaw.schemaVersion === "openscout.execution-resolution.v1" ? traceResolutionRaw : null;
+  const effectiveResolution = traceResolution ?? resolution;
+  return {
+    targetAgentId: row.target_agent_id,
+    harness: executionResolutionDimension(effectiveResolution, "harness") ?? metadataString8(trace ?? {}, "harness") ?? metadataString8(execution, "harness"),
+    model: executionResolutionDimension(effectiveResolution, "model") ?? metadataString8(execution, "model"),
+    reasoningEffort: executionResolutionDimension(effectiveResolution, "reasoningEffort") ?? metadataString8(execution, "reasoningEffort"),
+    transport: metadataString8(trace ?? {}, "transport"),
+    sessionId: metadataString8(trace ?? {}, "sessionId") ?? resolution?.sessionId?.trim() ?? metadataString8(execution, "targetSessionId")
+  };
+}
 function formatChannelAlias(value) {
   const trimmed = value.trim();
   if (!trimmed)
@@ -62798,22 +63260,34 @@ function projectSessionConversationRows(rows, opts) {
        AND ${transientBrokerWorkingStatusPredicate("m")}
      ORDER BY ${messageCreatedAtExpression} DESC
      LIMIT 1`);
+  const runtimeStmt = db2().prepare(`SELECT target_agent_id, execution_json, execution_resolution_json, flight_metadata_json
+     FROM invocations
+     WHERE conversation_id = ?
+     ORDER BY ${sqlTimestampMsExpression("created_at")} DESC, id DESC
+     LIMIT 1`);
   const summaries = rows.flatMap((r) => {
     const conversationMetadata = parseMetadataJson(r.metadata_json);
     const participants = memberStmt.all(r.id).map((m) => m.actor_id);
     const agentParticipants = agentMemberStmt.all(r.id);
-    const primaryAgentId = r.kind === "direct" ? pickDirectConversationAgentId(participants, agentParticipants.map((entry) => entry.agent_id)) : agentParticipants.length === 1 ? agentParticipants[0]?.agent_id ?? null : null;
+    const runtime = durableConversationRuntime(runtimeStmt.get(r.id));
+    const runtimeTargetAgentId = runtime?.targetAgentId && agentParticipants.some((entry) => entry.agent_id === runtime.targetAgentId) ? runtime.targetAgentId : null;
+    const primaryAgentId = r.kind === "direct" ? runtimeTargetAgentId ?? pickDirectConversationAgentId(participants, agentParticipants.map((entry) => entry.agent_id)) : agentParticipants.length === 1 ? agentParticipants[0]?.agent_id ?? null : null;
     const primaryAgent = primaryAgentId ? agentParticipants.find((entry) => entry.agent_id === primaryAgentId) ?? null : null;
     const agentId = primaryAgent?.agent_id ?? null;
     let agentName = null;
-    let harness2 = null;
+    let harness2 = runtime?.harness ?? null;
+    let model2 = runtime?.model ?? null;
+    let reasoningEffort = runtime?.reasoningEffort ?? null;
+    let transport = runtime?.transport ?? null;
+    let sessionId = runtime?.sessionId ?? null;
     let harnessSessionId = null;
     let harnessLogPath = null;
     let branch = null;
     let workspaceRoot = null;
     if (primaryAgent) {
       agentName = primaryAgent.display_name;
-      harness2 = primaryAgent.harness;
+      harness2 = harness2 ?? primaryAgent.harness;
+      transport = transport ?? primaryAgent.transport;
       workspaceRoot = compact(primaryAgent.project_root);
       try {
         const meta = primaryAgent.metadata_json ? JSON.parse(primaryAgent.metadata_json) : {};
@@ -62821,13 +63295,19 @@ function projectSessionConversationRows(rows, opts) {
           return [];
         }
         branch = meta.branch ?? meta.workspaceQualifier ?? null;
+        model2 = model2 ?? metadataString8(meta, "model");
+        reasoningEffort = reasoningEffort ?? metadataString8(meta, "reasoningEffort");
       } catch {}
       try {
         const endpointMeta = primaryAgent.endpoint_metadata_json ? JSON.parse(primaryAgent.endpoint_metadata_json) : {};
         harnessSessionId = resolveHarnessSessionId(primaryAgent.transport, primaryAgent.session_id, endpointMeta);
+        sessionId = sessionId ?? harnessSessionId;
+        model2 = model2 ?? metadataString8(endpointMeta, "observedModel") ?? metadataString8(endpointMeta, "model");
+        reasoningEffort = reasoningEffort ?? metadataString8(endpointMeta, "observedReasoningEffort") ?? metadataString8(endpointMeta, "reasoningEffort");
         harnessLogPath = resolveHarnessLogPath(primaryAgent.agent_id, primaryAgent.transport, primaryAgent.session_id, endpointMeta);
       } catch {
         harnessSessionId = resolveHarnessSessionId(primaryAgent.transport, primaryAgent.session_id, undefined);
+        sessionId = sessionId ?? harnessSessionId;
         harnessLogPath = resolveHarnessLogPath(primaryAgent.agent_id, primaryAgent.transport, primaryAgent.session_id, undefined);
       }
     }
@@ -62842,6 +63322,10 @@ function projectSessionConversationRows(rows, opts) {
       agentId,
       agentName,
       harness: harness2,
+      model: model2,
+      reasoningEffort,
+      transport,
+      sessionId,
       harnessSessionId,
       harnessLogPath,
       currentBranch: branch,
@@ -62898,7 +63382,9 @@ function querySessions(limit = 80) {
        FROM messages
        GROUP BY conversation_id
      ) ms ON ms.conversation_id = c.id
-     WHERE c.id LIKE 'c.%' AND length(c.id) > 2
+     WHERE (c.id LIKE 'chn-%' AND length(c.id) > 4)
+        OR (substr(c.id, 1, 5) = 'chat_' AND length(c.id) > 5)
+        OR (c.id LIKE 'c.%' AND length(c.id) > 2)
      ORDER BY COALESCE(ms.last_message_at, ${conversationCreatedAtExpression}, 0) DESC, ${conversationCreatedAtExpression} DESC, c.id ASC
      LIMIT ?`).all(limit);
   return projectSessionConversationRows(rows, {
@@ -62926,6 +63412,7 @@ function querySessionFallbackFromMessages(conversationId) {
        m.actor_id AS agent_id,
        ac.display_name,
        ep.harness,
+       ep.transport,
        ep.project_root,
        ep.session_id,
        ep.metadata_json AS endpoint_metadata_json
@@ -62947,8 +63434,12 @@ function querySessionFallbackFromMessages(conversationId) {
     agentId: agentRow?.agent_id ?? null,
     agentName: agentRow?.display_name ?? null,
     harness: agentRow?.harness ?? null,
-    harnessSessionId: resolveHarnessSessionId(agentRow?.session_id, endpointMetadata),
-    harnessLogPath: agentRow?.agent_id ? resolveHarnessLogPath(agentRow.agent_id, agentRow.harness, agentRow.session_id, endpointMetadata) : null,
+    model: metadataString8(endpointMetadata, "observedModel") ?? metadataString8(endpointMetadata, "model"),
+    reasoningEffort: metadataString8(endpointMetadata, "observedReasoningEffort") ?? metadataString8(endpointMetadata, "reasoningEffort"),
+    transport: agentRow?.transport ?? null,
+    sessionId: resolveHarnessSessionId(agentRow?.transport ?? null, agentRow?.session_id ?? null, endpointMetadata),
+    harnessSessionId: resolveHarnessSessionId(agentRow?.transport ?? null, agentRow?.session_id ?? null, endpointMetadata),
+    harnessLogPath: agentRow?.agent_id ? resolveHarnessLogPath(agentRow.agent_id, agentRow.transport, agentRow.session_id, endpointMetadata) : null,
     currentBranch: metadataString8(endpointMetadata, "branch"),
     preview: previewRow?.body?.trim() || null,
     messageCount: stats.message_count,
@@ -64000,8 +64491,8 @@ function queryFleetAskRows(requesterIds, limit) {
        ep.state AS endpoint_state,
        cr.title AS work_title,
        cr.summary AS work_summary,
+       cr.kind AS record_kind,
        cr.state AS work_state,
-       cr.acceptance_state,
        cr.next_move_owner_id,
        cr.updated_at AS work_updated_at
      FROM invocations inv
@@ -64063,7 +64554,8 @@ function projectFleetAsk(row, requesterIdSet) {
   const queuedUntilOnline = queuedFlight && row.dispatch_outcome_status === "queued_until_online";
   const staleActiveFlight = hasFlight && row.flight_state !== null && !TERMINAL_FLIGHT_STATES.has(row.flight_state) && isStaleActiveFlight(row.started_at, row.created_at);
   const isActiveFlight = hasFlight && row.flight_state !== null && !TERMINAL_FLIGHT_STATES.has(row.flight_state) && !failed && !staleActiveFlight;
-  const awaitingOperator = Boolean(row.next_move_owner_id && requesterIdSet.has(row.next_move_owner_id) || row.acceptance_state === "pending");
+  const attentionEligibleState = row.record_kind === "work_item" && row.work_state !== null && ["open", "working", "waiting", "review"].includes(row.work_state) || row.record_kind === "question" && row.work_state !== null && ["open", "answered"].includes(row.work_state);
+  const awaitingOperator = attentionEligibleState && Boolean(row.next_move_owner_id && requesterIdSet.has(row.next_move_owner_id));
   const updatedAt = normalizeTimestampMs(row.status_ts ?? row.completed_at ?? row.started_at ?? row.work_updated_at ?? row.created_at) ?? Date.now();
   const dismissedAt = normalizeTimestampMs(row.flight_dismissed_at);
   const recoveredAfterFailureAt = normalizeTimestampMs(row.recovered_after_failure_at);
@@ -64076,10 +64568,10 @@ function projectFleetAsk(row, requesterIdSet) {
     status = queuedUntilOnline ? "failed" : "queued";
   } else if (isActiveFlight) {
     status = "working";
-  } else if (awaitingOperator) {
-    status = "needs_attention";
   } else if (failed || staleActiveFlight) {
     status = "failed";
+  } else if (awaitingOperator) {
+    status = "needs_attention";
   } else {
     status = "completed";
   }
@@ -64123,34 +64615,7 @@ function queryFleetAttentionRows(requesterIds, limit) {
          (cr.kind = 'work_item' AND cr.state IN ('open', 'working', 'waiting', 'review'))
          OR (cr.kind = 'question' AND cr.state IN ('open', 'answered'))
        )
-       AND (
-         cr.next_move_owner_id IN (${requesterClause})
-         OR (
-           cr.kind = 'work_item'
-           AND cr.state = 'review'
-           AND cr.acceptance_state = 'pending'
-           AND NOT EXISTS (
-             SELECT 1
-             FROM collaboration_events e
-             WHERE e.record_id = cr.id
-               AND e.created_at > cr.updated_at
-           )
-           AND NOT EXISTS (
-             SELECT 1
-             FROM invocations inv
-             WHERE inv.collaboration_record_id = cr.id
-               AND inv.flight_id IS NOT NULL
-               AND COALESCE(inv.completed_at, inv.started_at, 0) > cr.updated_at
-           )
-           AND NOT EXISTS (
-             SELECT 1
-             FROM messages m
-             WHERE m.conversation_id = cr.conversation_id
-               AND m.actor_id = cr.owner_id
-               AND m.created_at > cr.updated_at
-           )
-         )
-       )
+       AND cr.next_move_owner_id IN (${requesterClause})
        AND NOT EXISTS (
          SELECT 1
          FROM collaboration_events dismissed
@@ -66101,7 +66566,7 @@ var init_service2 = __esm(() => {
 // packages/web/server/service-budgets.ts
 import { createHash as createHash8 } from "crypto";
 import { existsSync as existsSync45, mkdirSync as mkdirSync19, readdirSync as readdirSync12, readFileSync as readFileSync27, renameSync as renameSync7, statSync as statSync18, writeFileSync as writeFileSync17 } from "fs";
-import { open as open2 } from "fs/promises";
+import { open as open2, readdir as readdir4, stat as stat10 } from "fs/promises";
 import { homedir as homedir45 } from "os";
 import { dirname as dirname35, join as join63 } from "path";
 import { createInterface as createInterface2 } from "readline";
@@ -66181,12 +66646,14 @@ async function loadCodexGauge(forceRefresh = false) {
   const root = join63(homeDir(), ".codex", "sessions");
   if (!existsSync45(root))
     return fallback;
-  const recent = findRecentCodexJsonl(root, CODEX_LOOKBACK_DAYS);
-  if (recent.length === 0)
+  const candidates = await findRecentCodexJsonl(root, CODEX_LOOKBACK_DAYS);
+  if (candidates.length === 0)
     return fallback;
-  const observations = (await Promise.all(recent.map((path2) => readLatestCodexRateLimits(path2)))).flat().sort((left, right) => left.capturedAt - right.capturedAt);
+  const observations = (await harvestRecentCodexRateLimits(candidates)).sort((left, right) => left.capturedAt - right.capturedAt);
   if (observations.length === 0)
     return fallback;
+  if (!observations.some(isCodexAccountPoolObservation))
+    return fallback;
   const snapshots = bindingCodexPoolSnapshots(observations.flatMap((observation) => codexQuotaSnapshotsFromObservation(observation.usage, observation.capturedAt)));
   persistQuotaSnapshots(snapshots);
   const persisted = loadPersistedProviderQuotaGauge({
@@ -66243,9 +66710,11 @@ function bindingCodexPoolSnapshots(snapshots) {
     const usedPercent = quotaSnapshotUsage(row)?.fill;
     if (usedPercent === undefined)
       continue;
+    const poolId = poolIdOf(row);
+    const accountPool = isCodexAccountPoolId(poolId);
     const best = bindingPoolByLabel.get(row.label);
-    if (!best || usedPercent > best.usedPercent || usedPercent === best.usedPercent && row.capturedAt > best.capturedAt) {
-      bindingPoolByLabel.set(row.label, { poolId: poolIdOf(row), usedPercent, capturedAt: row.capturedAt });
+    if (!best || usedPercent > best.usedPercent || usedPercent === best.usedPercent && accountPool && !best.accountPool || usedPercent === best.usedPercent && accountPool === best.accountPool && row.capturedAt > best.capturedAt) {
+      bindingPoolByLabel.set(row.label, { poolId, usedPercent, capturedAt: row.capturedAt, accountPool });
     }
   }
   return snapshots.filter((row) => bindingPoolByLabel.get(row.label)?.poolId === poolIdOf(row));
@@ -66262,37 +66731,83 @@ function formatQuotaWindowLabel(windowMinutes, fallback) {
   }
   return `${windowMinutes}m`;
 }
-function findRecentCodexJsonl(root, lookbackDays) {
+async function findRecentCodexJsonl(root, lookbackDays) {
   const cutoffMs = Date.now() - lookbackDays * 86400 * 1000;
   const paths2 = [];
-  const walk = (dir) => {
+  const pending = [root];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    if (!dir)
+      continue;
     let entries2;
     try {
-      entries2 = readdirSync12(dir, { withFileTypes: true });
+      entries2 = await readdir4(dir, { withFileTypes: true });
     } catch {
-      return;
+      continue;
     }
     for (const entry of entries2) {
       const full = join63(dir, entry.name);
       if (entry.isDirectory()) {
-        walk(full);
+        pending.push(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        const stat10 = safeStat(full);
-        if (!stat10 || stat10.mtimeMs < cutoffMs)
-          continue;
-        paths2.push({ path: full, mtimeMs: stat10.mtimeMs });
+        try {
+          const fileStat = await stat10(full);
+          if (fileStat.mtimeMs < cutoffMs)
+            continue;
+          paths2.push({ path: full, mtimeMs: fileStat.mtimeMs });
+        } catch {}
       }
     }
-  };
-  walk(root);
-  return paths2.sort((left, right) => right.mtimeMs - left.mtimeMs).map((entry) => entry.path);
+  }
+  return paths2.sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, CODEX_RECENT_CANDIDATE_LIMIT);
+}
+async function harvestRecentCodexRateLimits(candidates) {
+  const observations = await readCodexCandidateBatch(candidates.slice(0, CODEX_INITIAL_FILE_LIMIT));
+  if (observations.some(isCodexAccountPoolObservation))
+    return observations;
+  const overflow = candidates.slice(CODEX_INITIAL_FILE_LIMIT, CODEX_RECENT_CANDIDATE_LIMIT);
+  for (let index2 = 0;index2 < overflow.length; index2 += CODEX_JSONL_READ_CONCURRENCY) {
+    observations.push(...await readCodexCandidateBatch(overflow.slice(index2, index2 + CODEX_JSONL_READ_CONCURRENCY)));
+    if (observations.some(isCodexAccountPoolObservation))
+      break;
+  }
+  return observations;
+}
+async function readCodexCandidateBatch(candidates) {
+  return (await Promise.all(candidates.map(async (candidate) => {
+    try {
+      return await readLatestCodexRateLimits(candidate.path);
+    } catch {
+      return [];
+    }
+  }))).flat();
+}
+function isCodexAccountPoolObservation(observation) {
+  return isCodexAccountPoolId(observation.usage.limitId);
+}
+function isCodexAccountPoolId(limitId) {
+  const normalized = limitId?.trim().toLowerCase();
+  return !normalized || normalized === "codex";
 }
 async function readLatestCodexRateLimits(path2) {
   const handle = await open2(path2, "r");
   try {
-    const rl = createInterface2({ input: handle.createReadStream({ encoding: "utf8" }) });
+    const fileStat = await handle.stat();
+    const start = Math.max(0, fileStat.size - CODEX_JSONL_TAIL_MAX_BYTES);
+    const rl = createInterface2({
+      input: handle.createReadStream({
+        encoding: "utf8",
+        start,
+        autoClose: false
+      })
+    });
     const latestByPool = new Map;
+    let firstLine = start > 0;
     for await (const line of rl) {
+      if (firstLine) {
+        firstLine = false;
+        continue;
+      }
       if (!line.includes('"rate_limits"'))
         continue;
       try {
@@ -66369,8 +66884,8 @@ function loadClaudeStatuslineQuotaSnapshots() {
 }
 function readClaudeStatuslineHistory(minCapturedAt) {
   const path2 = join63(claudeStatuslineDir(), "claude-history.jsonl");
-  const stat10 = safeStat(path2);
-  if (!stat10)
+  const stat11 = safeStat(path2);
+  if (!stat11)
     return [];
   let content;
   try {
@@ -66378,7 +66893,7 @@ function readClaudeStatuslineHistory(minCapturedAt) {
   } catch {
     return [];
   }
-  if (stat10.size > CLAUDE_STATUSLINE_HISTORY_MAX_BYTES) {
+  if (stat11.size > CLAUDE_STATUSLINE_HISTORY_MAX_BYTES) {
     content = content.slice(-CLAUDE_STATUSLINE_HISTORY_MAX_BYTES);
     const firstNewline = content.indexOf(`
 `);
@@ -67078,11 +67593,11 @@ async function loadGrokGauge() {
 }
 async function loadGrokBillingQuotaSnapshots() {
   const path2 = join63(homeDir(), ".grok", "logs", "unified.jsonl");
-  const stat10 = safeStat(path2);
-  if (!stat10 || stat10.size <= 0)
+  const stat11 = safeStat(path2);
+  if (!stat11 || stat11.size <= 0)
     return [];
-  const length = Math.min(stat10.size, GROK_BILLING_LOG_MAX_BYTES);
-  const start = Math.max(0, stat10.size - length);
+  const length = Math.min(stat11.size, GROK_BILLING_LOG_MAX_BYTES);
+  const start = Math.max(0, stat11.size - length);
   let content = "";
   let handle;
   try {
@@ -67609,11 +68124,13 @@ function persistQuotaSnapshots(snapshots) {
         return;
       statement.run(id, snapshot.source ?? "provider_reported", snapshot.provider ?? null, snapshot.harness ?? null, snapshot.transport ?? null, snapshot.planType ?? null, snapshot.label, snapshot.windowKind ?? null, finiteNumber(snapshot.usedPercent) ?? null, finiteNumber(snapshot.percentRemaining) ?? null, finiteNumber(snapshot.used) ?? null, finiteNumber(snapshot.limitValue) ?? null, finiteNumber(snapshot.resetAt) ?? null, finiteNumber(snapshot.windowMs) ?? null, snapshot.capturedAt, JSON.stringify(metadata ?? {}), createdAt);
     };
-    for (const snapshot of snapshots) {
-      writeSnapshot(quotaSnapshotId(snapshot), snapshot, snapshot.metadata);
-      writeSnapshot(quotaHistorySnapshotId(snapshot), snapshot, quotaHistoryMetadata(snapshot));
-    }
-    pruneHistory.run(createdAt - QUOTA_HISTORY_LOOKBACK_MS - QUOTA_HISTORY_BUCKET_MS2);
+    writer.transaction(() => {
+      for (const snapshot of snapshots) {
+        writeSnapshot(quotaSnapshotId(snapshot), snapshot, snapshot.metadata);
+        writeSnapshot(quotaHistorySnapshotId(snapshot), snapshot, quotaHistoryMetadata(snapshot));
+      }
+      pruneHistory.run(createdAt - QUOTA_HISTORY_LOOKBACK_MS - QUOTA_HISTORY_BUCKET_MS2);
+    })();
   } catch {}
 }
 function quotaSnapshotMayReplace(existing, incoming) {
@@ -67718,7 +68235,7 @@ function safeStat(path2) {
     return null;
   }
 }
-var CACHE_TTL_MS, WEEK_MS, CODEX_LOOKBACK_DAYS = 3, LOCAL_QUOTA_FRESH_MS, REMOTE_QUOTA_FRESH_MS, GH_CLI_TIMEOUT_MS = 4000, KIMI_USAGE_TIMEOUT_MS = 4000, MINIMAX_REMAINS_TIMEOUT_MS = 4000, DB_BUSY_TIMEOUT_MS3 = 2500, QUOTA_HISTORY_BUCKET_MS2, QUOTA_HISTORY_LOOKBACK_MS, QUOTA_HISTORY_ID_PREFIX = "budget:quota:history:", PERSISTED_QUOTA_ROW_LIMIT = 768, CLAUDE_STATUSLINE_HISTORY_MAX_BYTES, GROK_BILLING_LOG_MAX_BYTES, GH_CLI_BIN_ENV = "OPENSCOUT_GH_BIN", GH_RATE_LIMIT_JSON_ENV = "OPENSCOUT_GH_RATE_LIMIT_JSON", KIMI_USAGE_JSON_ENV = "OPENSCOUT_KIMI_USAGE_JSON", CURSOR_STATUS_JSON_ENV = "OPENSCOUT_CURSOR_STATUS_JSON", GROK_USAGE_JSON_ENV = "OPENSCOUT_GROK_USAGE_JSON", MINIMAX_REMAINS_JSON_ENV = "OPENSCOUT_MINIMAX_REMAINS_JSON", DASHBOARD_IMPORT_MAX_CHARS, cached = null, inflightNormal = null, inflightForce = null, quotaWriteDb = null;
+var CACHE_TTL_MS, WEEK_MS, CODEX_LOOKBACK_DAYS = 3, CODEX_JSONL_TAIL_MAX_BYTES, CODEX_INITIAL_FILE_LIMIT = 32, CODEX_RECENT_CANDIDATE_LIMIT = 64, CODEX_JSONL_READ_CONCURRENCY = 8, LOCAL_QUOTA_FRESH_MS, REMOTE_QUOTA_FRESH_MS, GH_CLI_TIMEOUT_MS = 4000, KIMI_USAGE_TIMEOUT_MS = 4000, MINIMAX_REMAINS_TIMEOUT_MS = 4000, DB_BUSY_TIMEOUT_MS3 = 2500, QUOTA_HISTORY_BUCKET_MS2, QUOTA_HISTORY_LOOKBACK_MS, QUOTA_HISTORY_ID_PREFIX = "budget:quota:history:", PERSISTED_QUOTA_ROW_LIMIT = 768, CLAUDE_STATUSLINE_HISTORY_MAX_BYTES, GROK_BILLING_LOG_MAX_BYTES, GH_CLI_BIN_ENV = "OPENSCOUT_GH_BIN", GH_RATE_LIMIT_JSON_ENV = "OPENSCOUT_GH_RATE_LIMIT_JSON", KIMI_USAGE_JSON_ENV = "OPENSCOUT_KIMI_USAGE_JSON", CURSOR_STATUS_JSON_ENV = "OPENSCOUT_CURSOR_STATUS_JSON", GROK_USAGE_JSON_ENV = "OPENSCOUT_GROK_USAGE_JSON", MINIMAX_REMAINS_JSON_ENV = "OPENSCOUT_MINIMAX_REMAINS_JSON", DASHBOARD_IMPORT_MAX_CHARS, cached = null, inflightNormal = null, inflightForce = null, quotaWriteDb = null;
 var init_service_budgets = __esm(() => {
   init_src2();
   init_src();
@@ -67728,6 +68245,7 @@ var init_service_budgets = __esm(() => {
   init_db2();
   CACHE_TTL_MS = 60 * 1000;
   WEEK_MS = 7 * 24 * 3600 * 1000;
+  CODEX_JSONL_TAIL_MAX_BYTES = 2 * 1024 * 1024;
   LOCAL_QUOTA_FRESH_MS = 2 * 60 * 1000;
   REMOTE_QUOTA_FRESH_MS = 5 * 60 * 1000;
   QUOTA_HISTORY_BUCKET_MS2 = 60 * 60 * 1000;
@@ -69159,9 +69677,9 @@ function readFilePreview(input) {
   }
   const { realPath, root } = resolved;
   try {
-    const stat11 = statSync22(realPath);
+    const stat12 = statSync22(realPath);
     const title = realPath === "/" ? "/" : realPath.split("/").pop() || realPath;
-    if (stat11.isDirectory()) {
+    if (stat12.isDirectory()) {
       return {
         ok: true,
         content: {
@@ -69177,7 +69695,7 @@ function readFilePreview(input) {
         }
       };
     }
-    if (!stat11.isFile()) {
+    if (!stat12.isFile()) {
       return { ok: false, status: 415, error: "path is not a file or directory" };
     }
     const mediaType = mediaTypeFor(realPath);
@@ -69194,14 +69712,14 @@ function readFilePreview(input) {
           title,
           mediaType,
           rawUrl,
-          sizeBytes: stat11.size,
+          sizeBytes: stat12.size,
           previewReason: previewReasonFor(mediaType),
           generatedAt: Date.now()
         }
       };
     }
-    const truncated = stat11.size > MAX_PREVIEW_BYTES;
-    const readable = readPreviewBuffer(realPath, Math.min(stat11.size, MAX_PREVIEW_BYTES));
+    const truncated = stat12.size > MAX_PREVIEW_BYTES;
+    const readable = readPreviewBuffer(realPath, Math.min(stat12.size, MAX_PREVIEW_BYTES));
     if (!looksTextual2(realPath, readable)) {
       return {
         ok: true,
@@ -69214,7 +69732,7 @@ function readFilePreview(input) {
           title,
           mediaType,
           rawUrl,
-          sizeBytes: stat11.size,
+          sizeBytes: stat12.size,
           previewReason: previewReasonFor(mediaType),
           generatedAt: Date.now()
         }
@@ -69232,7 +69750,7 @@ function readFilePreview(input) {
         mediaType,
         rawUrl,
         content: readable.toString("utf8"),
-        sizeBytes: stat11.size,
+        sizeBytes: stat12.size,
         truncated,
         generatedAt: Date.now()
       }
@@ -71432,7 +71950,7 @@ __export(exports_agent_definitions, {
   resolveAgentProjectRoot: () => resolveAgentProjectRoot,
   buildAgentDefinitions: () => buildAgentDefinitions
 });
-import { access as access3, readdir as readdir5, readFile as readFile19 } from "fs/promises";
+import { access as access3, readdir as readdir6, readFile as readFile19 } from "fs/promises";
 import { join as join71 } from "path";
 function excerptFromText2(raw2) {
   const trimmed = raw2.trim();
@@ -71476,7 +71994,7 @@ function agentSlugFromHandle(handle, name2) {
   return fromName || null;
 }
 async function listFolderFiles(folderPath, slug) {
-  const entries2 = await readdir5(folderPath, { withFileTypes: true });
+  const entries2 = await readdir6(folderPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries2) {
     if (!entry.isFile())
@@ -71516,7 +72034,7 @@ async function buildAgentDefinitions(input) {
   const selectedSlug = agentSlugFromHandle(input.agentHandle, input.agentName ?? "");
   const folders = [];
   if (agentsRootExists) {
-    const entries2 = await readdir5(agentsRoot, { withFileTypes: true });
+    const entries2 = await readdir6(agentsRoot, { withFileTypes: true });
     for (const entry of entries2) {
       if (!entry.isDirectory() || SKIPPED_NAMES.has(entry.name) || entry.name.startsWith(".")) {
         continue;
@@ -73133,8 +73651,55 @@ function assertIsolatedPairingRunStateWrite(path) {
 }
 
 // packages/web/server/pairing-pair-requests.ts
+var SCOUT_PAIR_CLIENT_HEADER = "x-scout-client";
+var SCOUT_PAIR_RELAY_HEADER = "x-scout-pair-relay";
+
+class PairRequestCapacityError extends Error {
+  retryAfterMs;
+  constructor(retryAfterMs) {
+    super("Too many live pairing requests");
+    this.name = "PairRequestCapacityError";
+    this.retryAfterMs = retryAfterMs;
+  }
+}
+var PAIR_CLIENT_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var PAIR_CLIENT_LABELS = {
+  "scout-ios": "Scout iOS",
+  "scout-macos": "Scout macOS",
+  "talkie-ios": "Talkie iOS",
+  "talkie-macos": "Talkie macOS"
+};
+function parseScoutPairClient(headerValue, userAgent) {
+  const raw2 = headerValue?.trim().toLowerCase() ?? "";
+  if (PAIR_CLIENT_ID_PATTERN.test(raw2))
+    return raw2;
+  const ua = userAgent ?? "";
+  if (/Scout/i.test(ua) && /iPhone|iPad|iOS/i.test(ua))
+    return "scout-ios";
+  if (/Talkie/i.test(ua) && /iPhone|iPad|iOS/i.test(ua))
+    return "talkie-ios";
+  return null;
+}
+function formatScoutPairClient(app) {
+  const id = app?.trim() || null;
+  if (!id)
+    return null;
+  return PAIR_CLIENT_LABELS[id] ?? id;
+}
+function pairRequesterDisplay(req) {
+  const label = req.requesterLabel?.trim() || null;
+  const app = formatScoutPairClient(req.requesterApp);
+  if (label && app)
+    return `${label} \xB7 ${app}`;
+  return label || app || "A device";
+}
 var DEFAULT_TTL_MS = 2 * 60 * 1000;
+var DEFAULT_MAX_LIVE_REQUESTS = 32;
 var SWEEP_INTERVAL_MS = 30 * 1000;
+function boundedMetadata(value, maxLength) {
+  const trimmed = value?.trim() || null;
+  return trimmed ? trimmed.slice(0, maxLength) : null;
+}
 var MAX_PUBLISH_ATTEMPTS = 32;
 var PUBLISH_SPIN_ATTEMPTS = 8;
 var PUBLISH_BACKOFF_CEILING_MS = 8;
@@ -73187,7 +73752,7 @@ function isPairRequest(value) {
   if (!value || typeof value !== "object")
     return false;
   const r = value;
-  return typeof r.token === "string" && r.token.length > 0 && (r.status === "pending" || r.status === "approved" || r.status === "denied") && isNullableString(r.requesterIp) && isNullableString(r.requesterLabel) && isNullableString(r.route) && typeof r.createdAt === "number" && typeof r.updatedAt === "number" && typeof r.expiresAt === "number";
+  return typeof r.token === "string" && r.token.length > 0 && (r.status === "pending" || r.status === "approved" || r.status === "denied") && isNullableString(r.requesterIp) && isNullableString(r.requesterLabel) && (r.requesterApp === undefined || isNullableString(r.requesterApp)) && isNullableString(r.route) && typeof r.createdAt === "number" && typeof r.updatedAt === "number" && typeof r.expiresAt === "number";
 }
 function fileSignature(path) {
   try {
@@ -73209,7 +73774,11 @@ function parseTerminalMarkers(value) {
       continue;
     if (typeof marker.collectAfter !== "number" || !Number.isFinite(marker.collectAfter))
       continue;
-    markers.push({ token: marker.token, collectAfter: marker.collectAfter });
+    markers.push({
+      token: marker.token,
+      collectAfter: marker.collectAfter,
+      ...typeof marker.claimId === "string" && marker.claimId.length > 0 ? { claimId: marker.claimId } : {}
+    });
   }
   return markers;
 }
@@ -73231,6 +73800,8 @@ function createPendingPairRequestStore(options = {}) {
   const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
   const now = options.now ?? (() => Date.now());
   const statePath = options.statePath;
+  const maxLiveRequests = Math.max(1, Math.floor(options.maxLiveRequests ?? DEFAULT_MAX_LIVE_REQUESTS));
+  const renewalWindowMs = Math.max(0, options.renewalWindowMs ?? Math.floor(ttlMs / 2));
   const byToken = new Map;
   let loadedGeneration = null;
   let loadedSignature = null;
@@ -73239,6 +73810,7 @@ function createPendingPairRequestStore(options = {}) {
   const unpersistedUpserts = new Set;
   const unpersistedExpiries = new Map;
   const fulfilledMarkers = new Map;
+  const fulfilledClaims = new Map;
   const unpublishedFulfilled = new Set;
   const lastSeenInShared = new Map;
   const tempPath = statePath ? `${statePath}.${process.pid}.${crypto.randomUUID().slice(0, 8)}.tmp` : null;
@@ -73256,6 +73828,17 @@ function createPendingPairRequestStore(options = {}) {
   function latestGeneration() {
     return statePath ? latestPairRequestGeneration(statePath) : null;
   }
+  function generationHasTerminalClaim(generation, claim) {
+    const raw2 = readFileOrNull(generationPath(generation));
+    if (raw2 === null)
+      return false;
+    try {
+      const parsed = JSON.parse(raw2);
+      return parseTerminalMarkers(parsed.fulfilled).some((marker) => marker.token === claim.token && marker.claimId === claim.claimId);
+    } catch {
+      return false;
+    }
+  }
   function movedOnSince(sighting) {
     if (loadedEpoch !== sighting.epoch)
       return false;
@@ -73267,10 +73850,11 @@ function createPendingPairRequestStore(options = {}) {
   function terminalMarkerHorizon(expiresAt) {
     return Math.max(expiresAt, now()) + ttlMs;
   }
-  function markFulfilled(request) {
+  function markFulfilled(request, claimId) {
     const horizon = terminalMarkerHorizon(request.expiresAt);
     const known = fulfilledMarkers.get(request.token);
     fulfilledMarkers.set(request.token, known === undefined ? horizon : Math.max(known, horizon));
+    fulfilledClaims.set(request.token, claimId);
     if (statePath)
       unpublishedFulfilled.add(request.token);
   }
@@ -73279,8 +73863,10 @@ function createPendingPairRequestStore(options = {}) {
     for (const [token, collectAfter] of fulfilledMarkers) {
       if (unpublishedFulfilled.has(token))
         continue;
-      if (collectAfter < t)
+      if (collectAfter < t) {
         fulfilledMarkers.delete(token);
+        fulfilledClaims.delete(token);
+      }
     }
   }
   function mergeUnpersisted(loaded) {
@@ -73340,6 +73926,8 @@ function createPendingPairRequestStore(options = {}) {
     for (const marker of markers) {
       const known = fulfilledMarkers.get(marker.token);
       fulfilledMarkers.set(marker.token, known === undefined ? marker.collectAfter : Math.max(known, marker.collectAfter));
+      if (marker.claimId !== undefined)
+        fulfilledClaims.set(marker.token, marker.claimId);
     }
     for (const [token, row] of loaded) {
       const known = fulfilledMarkers.get(token);
@@ -73406,7 +73994,10 @@ function createPendingPairRequestStore(options = {}) {
       }
       loadedEpoch = epoch;
       loadedHasTerminalLedger = hasLedger;
-      adopt(rows.filter(isPairRequest), markers);
+      adopt(rows.filter(isPairRequest).map((row) => ({
+        ...row,
+        requesterApp: row.requesterApp ?? null
+      })), markers);
       return;
     }
   }
@@ -73417,7 +74008,7 @@ function createPendingPairRequestStore(options = {}) {
       rmSync5(tempPath, { force: true });
     } catch {}
   }
-  function publish(touched, expired) {
+  function publish(touched, expired, terminalClaim) {
     if (!statePath || !tempPath)
       return "won";
     if (touched.length === 0 && expired.length === 0 && !hasOutstandingWrites())
@@ -73433,7 +74024,11 @@ function createPendingPairRequestStore(options = {}) {
       version: 1,
       epoch,
       requests: [...byToken.values()],
-      fulfilled: [...fulfilledMarkers].map(([token, collectAfter]) => ({ token, collectAfter }))
+      fulfilled: [...fulfilledMarkers].map(([token, collectAfter]) => ({
+        token,
+        collectAfter,
+        ...fulfilledClaims.has(token) ? { claimId: fulfilledClaims.get(token) } : {}
+      }))
     });
     try {
       mkdirSync11(dirname26(statePath), { recursive: true, mode: 448 });
@@ -73454,7 +74049,9 @@ function createPendingPairRequestStore(options = {}) {
     discardTemp();
     if (!landed || signature === null)
       return "lost";
-    if (latestGeneration() !== next) {
+    const frontier = latestGeneration();
+    const inheritedClaim = terminalClaim !== undefined && frontier !== null && frontier > next && generationHasTerminalClaim(frontier, terminalClaim);
+    if (frontier !== next && !inheritedClaim) {
       try {
         if (inodeOf(target2) === ours)
           unlinkSync2(target2);
@@ -73472,7 +74069,7 @@ function createPendingPairRequestStore(options = {}) {
     for (const token of byToken.keys())
       lastSeenInShared.set(token, sighting);
     forgetSightingsWeNoLongerHold();
-    collectSuperseded(next);
+    collectSuperseded(frontier ?? next);
     return "won";
   }
   function collectSuperseded(published) {
@@ -73514,7 +74111,7 @@ function createPendingPairRequestStore(options = {}) {
   function hasOutstandingWrites() {
     return unpersistedUpserts.size > 0 || unpersistedExpiries.size > 0 || unpublishedFulfilled.size > 0;
   }
-  function commit(apply) {
+  function commit(apply, options2 = {}) {
     if (!statePath) {
       pruneExpired();
       collectTerminalMarkers();
@@ -73525,10 +74122,17 @@ function createPendingPairRequestStore(options = {}) {
       const expired = pruneExpired();
       collectTerminalMarkers();
       const { value, touched } = apply();
-      const outcome = publish(touched, expired);
+      const outcome = publish(touched, expired, options2.terminalClaim);
       if (outcome === "won")
         return value;
+      if (outcome === "lost")
+        options2.rollback?.();
       if (outcome === "failed" || attempt >= MAX_PUBLISH_ATTEMPTS) {
+        if (options2.failClosed) {
+          if (outcome === "failed")
+            options2.rollback?.();
+          return options2.failClosed();
+        }
         recordOutstanding(touched, expired);
         return value;
       }
@@ -73556,7 +74160,7 @@ function createPendingPairRequestStore(options = {}) {
       return null;
     const t = now();
     for (const req of byToken.values()) {
-      if (req.requesterIp === requesterIp && req.expiresAt > t && (req.status === "pending" || req.status === "approved")) {
+      if (req.requesterIp === requesterIp && req.expiresAt > t) {
         return req;
       }
     }
@@ -73564,19 +74168,38 @@ function createPendingPairRequestStore(options = {}) {
   }
   return {
     create(input) {
-      const requesterIp = input.requesterIp?.trim() || null;
-      const label = input.requesterLabel?.trim() || null;
+      const requesterIp = boundedMetadata(input.requesterIp, 64);
+      const label = boundedMetadata(input.requesterLabel, 96);
+      const app = boundedMetadata(input.requesterApp, 32);
+      const route = boundedMetadata(input.route, 16);
       const token = crypto.randomUUID();
-      return commit(() => {
+      const result = commit(() => {
         const existing = findReusable(requesterIp);
         if (existing) {
-          existing.updatedAt = now();
-          existing.expiresAt = now() + ttlMs;
-          if (input.route)
-            existing.route = input.route;
-          if (label)
-            existing.requesterLabel = label;
-          return { value: existing, touched: [existing.token] };
+          const t2 = now();
+          const renew = existing.status !== "denied" && existing.expiresAt - t2 <= renewalWindowMs;
+          if (renew) {
+            existing.updatedAt = t2;
+            existing.expiresAt = t2 + ttlMs;
+            if (route)
+              existing.route = route;
+            if (label)
+              existing.requesterLabel = label;
+            if (app)
+              existing.requesterApp = app;
+          }
+          return { value: existing, touched: renew ? [existing.token] : [] };
+        }
+        if (byToken.size >= maxLiveRequests) {
+          const t2 = now();
+          const earliestExpiry = Math.min(...[...byToken.values()].map((request2) => request2.expiresAt));
+          return {
+            value: {
+              capacity: true,
+              retryAfterMs: Math.max(1000, earliestExpiry - t2)
+            },
+            touched: []
+          };
         }
         const t = now();
         const request = {
@@ -73584,7 +74207,8 @@ function createPendingPairRequestStore(options = {}) {
           status: "pending",
           requesterIp,
           requesterLabel: label,
-          route: input.route ?? null,
+          requesterApp: app,
+          route,
           createdAt: t,
           updatedAt: t,
           expiresAt: t + ttlMs
@@ -73592,6 +74216,10 @@ function createPendingPairRequestStore(options = {}) {
         byToken.set(token, request);
         return { value: request, touched: [token] };
       });
+      if ("capacity" in result) {
+        throw new PairRequestCapacityError(result.retryAfterMs);
+      }
+      return result;
     },
     get(token) {
       reload();
@@ -73601,8 +74229,9 @@ function createPendingPairRequestStore(options = {}) {
     touch(token) {
       commit(() => {
         const req = byToken.get(token);
-        const extended = now() + ttlMs;
-        const extend = req !== undefined && (req.status === "pending" || req.status === "approved") && extended > req.expiresAt;
+        const t = now();
+        const extended = t + ttlMs;
+        const extend = req !== undefined && (req.status === "pending" || req.status === "approved") && req.expiresAt - t <= renewalWindowMs && extended > req.expiresAt;
         if (extend && req)
           req.expiresAt = extended;
         return { value: undefined, touched: extend ? [token] : [] };
@@ -73619,24 +74248,55 @@ function createPendingPairRequestStore(options = {}) {
           return { value: null, touched: [] };
         req.status = decision === "approve" ? "approved" : "denied";
         req.updatedAt = now();
-        if (decision === "approve")
-          req.expiresAt = now() + ttlMs;
+        req.expiresAt = now() + ttlMs;
         return { value: req, touched: [token] };
       });
     },
-    fulfill(token) {
-      let delivered = null;
+    fulfill(token, requiredStatus) {
+      let proposal = null;
+      const claim = { token, claimId: crypto.randomUUID() };
+      let previousMarker;
+      let previousClaim;
+      let previouslyUnpublished = false;
+      let previouslyUnpersisted = false;
+      const rollback = () => {
+        if (proposal === null)
+          return;
+        if (previousMarker === undefined)
+          fulfilledMarkers.delete(token);
+        else
+          fulfilledMarkers.set(token, previousMarker);
+        if (previousClaim === undefined)
+          fulfilledClaims.delete(token);
+        else
+          fulfilledClaims.set(token, previousClaim);
+        if (!previouslyUnpublished)
+          unpublishedFulfilled.delete(token);
+        byToken.set(token, proposal);
+        if (previouslyUnpersisted)
+          unpersistedUpserts.add(token);
+        else
+          unpersistedUpserts.delete(token);
+        proposal = null;
+      };
       return commit(() => {
-        if (delivered === null) {
-          const request = byToken.get(token);
-          if (!request || !isLive(request))
-            return { value: null, touched: [] };
-          delivered = { ...request };
+        const request = byToken.get(token);
+        if (!request || !isLive(request) || requiredStatus !== undefined && request.status !== requiredStatus) {
+          return { value: null, touched: [] };
         }
-        markFulfilled(delivered);
+        proposal = { ...request };
+        previousMarker = fulfilledMarkers.get(token);
+        previousClaim = fulfilledClaims.get(token);
+        previouslyUnpublished = unpublishedFulfilled.has(token);
+        previouslyUnpersisted = unpersistedUpserts.has(token);
+        markFulfilled(proposal, claim.claimId);
         byToken.delete(token);
         unpersistedUpserts.delete(token);
-        return { value: delivered, touched: [] };
+        return { value: proposal, touched: [] };
+      }, {
+        rollback,
+        terminalClaim: claim,
+        failClosed: () => null
       });
     },
     dispose() {
@@ -73647,6 +74307,7 @@ function createPendingPairRequestStore(options = {}) {
       unpersistedExpiries.clear();
       unpublishedFulfilled.clear();
       fulfilledMarkers.clear();
+      fulfilledClaims.clear();
       lastSeenInShared.clear();
     }
   };
@@ -73887,7 +74548,8 @@ init_agent_endpoints();
 
 // packages/web/server/core/repo-identity.ts
 init_system_probes();
-var REPO_KEY_TTL_MS = 60000;
+var REPO_KEY_TTL_MS = 10 * 60000;
+var REPO_KEY_PROBE_CONCURRENCY = 4;
 function normalizeGitRemoteUrl(remote) {
   const trimmed = remote?.trim() ?? "";
   if (!trimmed)
@@ -73911,15 +74573,14 @@ function canonicalRepoKey(host, path2) {
 }
 var repoKeyCache = new Map;
 var repoKeyInFlight = new Map;
+var queuedRepoKeyRoots = [];
+var queuedRepoKeyRootSet = new Set;
+var activeRepoKeyProbes = 0;
 async function probeRepoKey(root) {
   const remote = await gitRemoteGetUrlOrigin(root).catch(() => null);
   return normalizeGitRemoteUrl(remote);
 }
-function resolveRepoKeyForRoot(root) {
-  const cached = repoKeyCache.get(root);
-  if (cached && Date.now() - cached.at < REPO_KEY_TTL_MS) {
-    return Promise.resolve(cached.key);
-  }
+function refreshRepoKeyForRoot(root) {
   const inFlight = repoKeyInFlight.get(root);
   if (inFlight)
     return inFlight;
@@ -73933,10 +74594,38 @@ function resolveRepoKeyForRoot(root) {
   repoKeyInFlight.set(root, promise);
   return promise;
 }
-async function resolveRepoKeysByRoot(roots) {
+function drainRepoKeyProbeQueue() {
+  while (activeRepoKeyProbes < REPO_KEY_PROBE_CONCURRENCY) {
+    const root = queuedRepoKeyRoots.shift();
+    if (!root)
+      return;
+    queuedRepoKeyRootSet.delete(root);
+    activeRepoKeyProbes += 1;
+    refreshRepoKeyForRoot(root).catch(() => null).finally(() => {
+      activeRepoKeyProbes -= 1;
+      drainRepoKeyProbeQueue();
+    });
+  }
+}
+function scheduleRepoKeyProbe(root) {
+  if (repoKeyInFlight.has(root) || queuedRepoKeyRootSet.has(root))
+    return;
+  queuedRepoKeyRootSet.add(root);
+  queuedRepoKeyRoots.push(root);
+  drainRepoKeyProbeQueue();
+}
+function cachedRepoKeysByRoot(roots) {
+  const now = Date.now();
   const distinct = [...new Set(roots)];
-  const keys = await Promise.all(distinct.map((root) => resolveRepoKeyForRoot(root)));
-  return new Map(distinct.map((root, index2) => [root, keys[index2] ?? null]));
+  const result = new Map;
+  for (const root of distinct) {
+    const cached = repoKeyCache.get(root);
+    result.set(root, cached?.key ?? null);
+    if (!cached || now - cached.at >= REPO_KEY_TTL_MS) {
+      scheduleRepoKeyProbe(root);
+    }
+  }
+  return result;
 }
 
 // packages/web/server/terminal-session-discovery.ts
@@ -75353,6 +76042,50 @@ init_src();
 init_legacy_ids();
 init_service();
 init_message_pagination();
+function provisionalScoutConversations(snapshot, filters = {}) {
+  const allowedKinds = new Set(filters.kinds ?? DEFAULT_CONVERSATION_KINDS);
+  const query = normalizeQuery(filters.query);
+  const limit = Math.max(1, Math.floor(filters.limit ?? snapshot.items.length));
+  return snapshot.items.filter((item) => item.entityKind === "scout_conversation" && item.visibilityState === "visible" && Boolean(item.conversationId) && allowedKinds.has(item.kind)).filter((item) => !query || [
+    item.title,
+    item.alias,
+    item.agentName,
+    item.preview,
+    item.projectRoot
+  ].some((value) => value?.toLocaleLowerCase().includes(query))).slice(0, limit).map((item) => {
+    const conversationId = item.conversationId;
+    const participantIds = item.kind === "direct" && item.agentId ? ["operator", item.agentId] : [];
+    return {
+      id: conversationId,
+      chatId: conversationId,
+      equivalentConversationIds: [conversationId],
+      kind: item.kind,
+      title: item.title ?? item.agentName ?? item.alias ?? conversationId,
+      alias: item.alias,
+      naturalKey: item.naturalKey,
+      participantIds,
+      participants: [],
+      participantCount: item.participantCount,
+      authorityNodeId: item.authorityNodeId,
+      authorityNodeName: item.authorityNodeName,
+      agentId: item.agentId,
+      agentName: item.agentName,
+      harness: item.harness,
+      model: item.model,
+      reasoningEffort: item.effort,
+      transport: null,
+      sessionId: item.runtimeSessionId,
+      currentBranch: item.currentBranch,
+      parentConversationId: item.parentConversationId,
+      anchorMessageId: item.anchorMessageId,
+      preview: item.preview,
+      messageCount: item.messageCount,
+      lastMessageAt: item.lastMessageAt,
+      workspaceRoot: item.projectRoot,
+      unreadCount: item.unreadCount
+    };
+  });
+}
 var DEFAULT_CONVERSATION_KINDS = [
   "direct",
   "channel",
@@ -75421,6 +76154,53 @@ function metadataObject2(metadata, key) {
 function metadataSessionId(metadata) {
   return metadataString9(metadata, "targetSessionId") ?? metadataString9(metadata, "responderSessionId") ?? metadataString9(metadata, "sessionId") ?? metadataString9(metadata, "externalSessionId") ?? metadataString9(metadata, "threadId") ?? metadataString9(metadataObject2(metadata, "returnAddress"), "sessionId");
 }
+function executionResolutionDimension2(resolution, dimension) {
+  const value = resolution?.[dimension];
+  return value?.observed?.trim() || value?.resolved?.trim() || value?.requested?.trim() || null;
+}
+function executionResolutionFromUnknown(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const resolution = value;
+  return resolution.schemaVersion === "openscout.execution-resolution.v1" ? resolution : null;
+}
+function flightSessionRuntime(flights, sessionId) {
+  for (const flight of [...flights].reverse()) {
+    const rawTrace = flight.metadata?.sessionTrace;
+    if (!Array.isArray(rawTrace))
+      continue;
+    const entries2 = [...rawTrace].reverse();
+    const candidate = entries2.find((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+      const id = metadataString9(entry, "sessionId");
+      return sessionId ? id === sessionId : Boolean(id);
+    });
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+      continue;
+    const record2 = candidate;
+    return {
+      resolution: executionResolutionFromUnknown(record2.executionResolution),
+      harness: metadataString9(record2, "harness"),
+      transport: metadataString9(record2, "transport")
+    };
+  }
+  return null;
+}
+function latestConversationRuntime(input) {
+  const matchingParticipant = input.sessionId ? input.participants.find((participant) => participant.sessionId === input.sessionId) ?? null : null;
+  const matchingInvocation = input.sessionId ? [...input.invocations].reverse().find((invocation2) => invocation2.executionResolution?.sessionId === input.sessionId || invocation2.execution?.targetSessionId === input.sessionId || metadataSessionId(invocation2.metadata) === input.sessionId) ?? null : null;
+  const latestInvocation = input.invocations.at(-1) ?? null;
+  const invocation = matchingInvocation ?? latestInvocation;
+  const trace = flightSessionRuntime(input.flights, input.sessionId);
+  const resolution = matchingInvocation?.executionResolution ?? trace?.resolution ?? invocation?.executionResolution ?? null;
+  return {
+    harness: executionResolutionDimension2(resolution, "harness") ?? trace?.harness ?? matchingParticipant?.harness ?? invocation?.execution?.harness?.trim() ?? input.endpoint?.harness ?? null,
+    model: executionResolutionDimension2(resolution, "model") ?? matchingParticipant?.model ?? invocation?.execution?.model?.trim() ?? metadataString9(input.endpoint?.metadata, "observedModel") ?? metadataString9(input.endpoint?.metadata, "model"),
+    reasoningEffort: executionResolutionDimension2(resolution, "reasoningEffort") ?? matchingParticipant?.reasoningEffort ?? invocation?.execution?.reasoningEffort?.trim() ?? metadataString9(input.endpoint?.metadata, "observedReasoningEffort") ?? metadataString9(input.endpoint?.metadata, "reasoningEffort"),
+    transport: trace?.transport ?? matchingParticipant?.transport ?? input.endpoint?.transport ?? null
+  };
+}
 function formatChannelAlias2(value) {
   const trimmed = value.trim();
   if (!trimmed)
@@ -75751,6 +76531,8 @@ function buildScopedParticipants(snapshot, endpoints, operatorIds, conversationI
       agentId: agent?.id ?? null,
       sessionId: endpoint?.sessionId ?? metadataSessionId(endpoint?.metadata) ?? metadataSessionId(actor?.metadata) ?? (kind === "session" ? participantId : null),
       harness: endpoint?.harness ?? metadataString9(actor?.metadata, "harness"),
+      model: metadataString9(endpoint?.metadata, "observedModel") ?? metadataString9(endpoint?.metadata, "model") ?? metadataString9(actor?.metadata, "model"),
+      reasoningEffort: metadataString9(endpoint?.metadata, "observedReasoningEffort") ?? metadataString9(endpoint?.metadata, "reasoningEffort") ?? metadataString9(actor?.metadata, "reasoningEffort"),
       transport: endpoint?.transport ?? metadataString9(actor?.metadata, "transport"),
       workspaceRoot: endpoint?.projectRoot ?? endpoint?.cwd ?? metadataString9(actor?.metadata, "projectRoot")
     };
@@ -75772,6 +76554,9 @@ function includeConversation(summary, query) {
     summary.title,
     summary.agentId ?? "",
     summary.agentName ?? "",
+    summary.harness ?? "",
+    summary.model ?? "",
+    summary.reasoningEffort ?? "",
     summary.preview ?? "",
     summary.workspaceRoot ?? "",
     ...summary.participantIds,
@@ -75839,6 +76624,10 @@ function coalesceDuplicateNamedChannels(summaries, snapshot, endpoints, operator
       preview: latest.preview,
       lastMessageAt: latest.lastMessageAt,
       sessionId: latest.sessionId ?? canonical2.sessionId,
+      harness: latest.harness ?? canonical2.harness,
+      model: latest.model ?? canonical2.model,
+      reasoningEffort: latest.reasoningEffort ?? canonical2.reasoningEffort,
+      transport: latest.transport ?? canonical2.transport,
       messageCount: Math.max(...group.map((summary) => summary.messageCount)),
       unreadCount: Math.max(...group.map((summary) => summary.unreadCount)),
       ...latestTurn ? { turn: latestTurn } : {}
@@ -75910,6 +76699,13 @@ async function getScoutConversations(filters = {}, brokerContext) {
       }
       const title = agentDisplayName(snapshot, endpointsByAgent, agentId);
       const identityFields2 = conversationIdentityFields2(conversation);
+      const runtime2 = latestConversationRuntime({
+        sessionId,
+        participants,
+        invocations: invocations2,
+        flights,
+        endpoint
+      });
       return [{
         id: conversation.id,
         chatId: conversation.id,
@@ -75924,7 +76720,10 @@ async function getScoutConversations(filters = {}, brokerContext) {
         authorityNodeName: snapshot.nodes?.[conversation.authorityNodeId]?.name ?? null,
         agentId,
         agentName: title,
-        harness: endpoint?.harness ?? null,
+        harness: runtime2.harness,
+        model: runtime2.model,
+        reasoningEffort: runtime2.reasoningEffort,
+        transport: runtime2.transport,
         sessionId,
         currentBranch: metadataString9(endpoint?.metadata, "branch") ?? metadataString9(endpoint?.metadata, "workspaceQualifier") ?? metadataString9(agent?.metadata, "branch") ?? metadataString9(agent?.metadata, "workspaceQualifier"),
         parentConversationId: conversation.parentConversationId ?? null,
@@ -75951,6 +76750,13 @@ async function getScoutConversations(filters = {}, brokerContext) {
       return [];
     }
     const identityFields = conversationIdentityFields2(conversation);
+    const runtime = latestConversationRuntime({
+      sessionId,
+      participants,
+      invocations: invocations2,
+      flights,
+      endpoint: null
+    });
     return [{
       id: conversation.id,
       chatId: conversation.id,
@@ -75965,7 +76771,10 @@ async function getScoutConversations(filters = {}, brokerContext) {
       authorityNodeName: snapshot.nodes?.[conversation.authorityNodeId]?.name ?? null,
       agentId: null,
       agentName: null,
-      harness: null,
+      harness: runtime.harness,
+      model: runtime.model,
+      reasoningEffort: runtime.reasoningEffort,
+      transport: runtime.transport,
       sessionId,
       currentBranch: null,
       parentConversationId: conversation.parentConversationId ?? null,
@@ -75992,15 +76801,17 @@ function capSummaryRoster(summary, operatorIds, endpoints) {
   if (summary.participantIds.length <= CHANNEL_ROSTER_CAP)
     return summary;
   const keep = new Set;
-  for (const id of summary.participantIds) {
-    if (operatorIds.has(id) || participantEndpoint(endpoints, id))
-      keep.add(id);
-  }
-  for (const id of summary.participantIds) {
-    if (keep.size >= CHANNEL_ROSTER_CAP)
-      break;
-    keep.add(id);
-  }
+  const fillFromTier = (matches) => {
+    for (const id of summary.participantIds) {
+      if (keep.size >= CHANNEL_ROSTER_CAP)
+        return;
+      if (matches(id))
+        keep.add(id);
+    }
+  };
+  fillFromTier((id) => operatorIds.has(id));
+  fillFromTier((id) => !operatorIds.has(id) && participantEndpoint(endpoints, id) !== null);
+  fillFromTier(() => true);
   const keptIds = summary.participantIds.filter((id) => keep.has(id));
   const droppedIds = summary.participantIds.filter((id) => !keep.has(id));
   return {
@@ -76009,12 +76820,12 @@ function capSummaryRoster(summary, operatorIds, endpoints) {
     participants: summary.participants.filter((participant) => keep.has(participant.actorId))
   };
 }
-async function getScoutConversationMessages(conversationId, limit = 80, beforeMessageId) {
+async function getScoutConversationMessages(conversationId, limit = 80, beforeMessageId, brokerContext) {
   const normalizedId = conversationId.trim();
   if (!normalizedId || !isOpaqueChannelId(normalizedId)) {
     return [];
   }
-  const broker2 = await loadScoutBrokerContext(undefined, { scope: "conversations" });
+  const broker2 = brokerContext === undefined ? await loadScoutBrokerContext(undefined, { scope: "conversations" }) : brokerContext;
   if (!broker2)
     return null;
   const snapshot = broker2.snapshot;
@@ -76085,6 +76896,7 @@ import { basename as basename20, join as join54, resolve as resolve20 } from "pa
 init_secret_redaction();
 import { basename as basename19 } from "path";
 import { open, stat as stat9 } from "fs/promises";
+import { StringDecoder } from "string_decoder";
 
 // packages/runtime/src/tail/claude-source.ts
 init_user_config();
@@ -78991,8 +79803,10 @@ function readPositiveIntEnv8(name2, fallback) {
   const raw2 = Number.parseInt(process.env[name2] ?? "", 10);
   return Number.isFinite(raw2) && raw2 > 0 ? raw2 : fallback;
 }
-var TAIL_POLL_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_POLL_INTERVAL_MS", 500);
-var HOT_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_HOT_DISCOVERY_INTERVAL_MS", 30000);
+var DEFAULT_TAIL_POLL_INTERVAL_MS = 1e4;
+var DEFAULT_HOT_DISCOVERY_INTERVAL_MS = 60000;
+var TAIL_POLL_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_POLL_INTERVAL_MS", DEFAULT_TAIL_POLL_INTERVAL_MS);
+var HOT_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_HOT_DISCOVERY_INTERVAL_MS", DEFAULT_HOT_DISCOVERY_INTERVAL_MS);
 var DISCOVERY_CACHE_MAX_AGE_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_DISCOVERY_CACHE_MAX_AGE_MS", HOT_DISCOVERY_INTERVAL_MS);
 var SHALLOW_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_SHALLOW_DISCOVERY_INTERVAL_MS", 10 * 60000);
 var DEEP_DISCOVERY_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_DEEP_DISCOVERY_INTERVAL_MS", 60 * 60000);
@@ -79006,23 +79820,42 @@ var RAW_MAX_STRING_LEN = 1000;
 var RAW_MAX_ARRAY_ITEMS = 25;
 var RAW_MAX_OBJECT_KEYS = 50;
 var RECENT_TRANSCRIPT_READ_BYTES = 512 * 1024;
+var WATCHER_READ_BYTES = readPositiveIntEnv8("OPENSCOUT_TAIL_WATCHER_READ_BYTES", 512 * 1024);
+var WATCHER_DRAIN_BYTES = Math.max(WATCHER_READ_BYTES, readPositiveIntEnv8("OPENSCOUT_TAIL_WATCHER_DRAIN_BYTES", 4 * 1024 * 1024));
+var WATCHER_PUMP_CONCURRENCY = readPositiveIntEnv8("OPENSCOUT_TAIL_WATCHER_PUMP_CONCURRENCY", 16);
 var SESSION_TRANSCRIPT_READ_BYTES = 8 * 1024 * 1024;
 var RECENT_TRANSCRIPT_KIND_SCAN_READ_BYTES = 32 * 1024 * 1024;
 var RECENT_TRANSCRIPT_LINES_PER_FILE = 200;
 var RECENT_TRANSCRIPT_KIND_SCAN_MAX_LINES = 65536;
 var RECENT_TRANSCRIPT_MAX_FILES = readPositiveIntEnv8("OPENSCOUT_TAIL_RECENT_TRANSCRIPT_MAX_FILES", 24);
+var INTERNAL_RECONCILE_SESSIONS_PER_SOURCE = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_RECONCILE_SESSIONS_PER_SOURCE", 12);
+var INTERNAL_RECONCILE_LINES_PER_SESSION = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_RECONCILE_LINES_PER_SESSION", 128);
+var INTERNAL_RECONCILE_READ_BYTES = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_RECONCILE_READ_BYTES", 256 * 1024);
+var INTERNAL_HOT_WATCHER_WINDOW_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_HOT_WATCHER_WINDOW_MS", 60000);
+var INTERNAL_IDLE_WATCHER_INTERVAL_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_IDLE_WATCHER_INTERVAL_MS", 15000);
+var INTERNAL_IDLE_WATCHER_BATCH_SIZE = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_IDLE_WATCHER_BATCH_SIZE", 32);
+var INTERNAL_ACTIVE_STALE_AFTER_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_INTERNAL_ACTIVE_STALE_AFTER_MS", 30 * 60000);
+var INTERNAL_STALE_CONFIRMATION_COUNT = 2;
+var AUTHORITATIVE_MISSING_CONFIRMATION_COUNT = 2;
+var INTERNAL_PERSISTED_OBSERVED_SEED_LIMIT = readPositiveIntEnv8("OPENSCOUT_TAIL_PERSISTED_OBSERVED_SEED_LIMIT", 4096);
 var NATIVE_TAIL_SOURCES = new Set(["grok", "kimi", "opencode", "cursor"]);
 var TRANSCRIPT_REPLAY_MEMO_MAX_ENTRIES = readPositiveIntEnv8("OPENSCOUT_TAIL_REPLAY_MEMO_MAX_ENTRIES", 256);
 var TRANSCRIPT_REPLAY_ACTIVE_GRACE_MS = readPositiveIntEnv8("OPENSCOUT_TAIL_REPLAY_MEMO_ACTIVE_GRACE_MS", 2000);
 var transcriptReplayMemo = new Map;
 var transcriptReplayInFlight = new Map;
+var INTERNAL_TAIL_SESSION_OFFLINE_SUMMARY = "session lifecycle \xB7 confirmed offline";
+var INTERNAL_TAIL_SESSION_STALLED_SUMMARY = "session lifecycle \xB7 confirmed stale";
 var sources = [GrokSource, KimiSource, ClaudeSource, CodexSource, CursorSource, OpenCodeSource, PiSource];
 var watchers = new Map;
 var aggregateBuffer = [];
 var assistantBuffer = [];
 var perSessionBuffer = new Map;
 var subscribers = new Set;
+var internalSubscribers = new Set;
+var watcherPumpQueue = [];
+var activeWatcherPumps = 0;
 var knownTranscripts = new Map;
+var persistedObservedSessions = new Map;
 var quietEventLastSeen = new Map;
 var pollTimer = null;
 var hotDiscoveryTimer = null;
@@ -79219,10 +80052,19 @@ function shouldCoalesceQuietTailEvent(event) {
   pruneQuietTailCoalescer(now);
   return false;
 }
-function pushEvent(rawEvent) {
+function pushInternalEvent(rawEvent) {
   const event = compactEvent(rawEvent);
+  for (const subscriber of [...internalSubscribers]) {
+    try {
+      subscriber(event);
+    } catch {}
+  }
+  return event;
+}
+function pushEvent(rawEvent) {
+  const event = pushInternalEvent(rawEvent);
   if (shouldCoalesceQuietTailEvent(event))
-    return;
+    return event;
   aggregateBuffer.push(event);
   if (aggregateBuffer.length > AGGREGATE_BUFFER_LIMIT) {
     aggregateBuffer.splice(0, aggregateBuffer.length - AGGREGATE_BUFFER_LIMIT);
@@ -79247,15 +80089,114 @@ function pushEvent(rawEvent) {
       subscriber(event);
     } catch {}
   }
+  return event;
+}
+function rememberWatcherEvent(watcher, rawEvent, delivery) {
+  if (watcher.emittedEventIds.has(rawEvent.id))
+    return;
+  watcher.emittedEventIds.add(rawEvent.id);
+  const event = delivery === "all" ? pushEvent(rawEvent) : pushInternalEvent(rawEvent);
+  watcher.internalObserved = true;
+  watcher.lastInternalEvent = event;
+  watcher.staleObservations = 0;
+  watcher.lifecycleNotification = "none";
+  const lifecycle = persistedObservedSessions.get(observedSessionLifecycleKey(watcher.source.name, event.sessionId));
+  if (lifecycle) {
+    lifecycle.missingAuthoritativePasses = 0;
+    lifecycle.lifecycleNotification = "none";
+  }
+}
+function observedSessionLifecycleKey(source, sourceSessionId) {
+  return `${source.trim()}\x00${sourceSessionId.trim()}`;
+}
+function persistedSeedEvent(seed) {
+  const source = seed.source.trim();
+  const sourceSessionId = seed.sourceSessionId.trim();
+  const timestamp = Number.isFinite(seed.lastActivityAt) && seed.lastActivityAt > 0 ? seed.lastActivityAt : 0;
+  return {
+    id: `tail-persisted-seed:${source}:${sourceSessionId}:${timestamp}`,
+    ts: timestamp,
+    source,
+    sessionId: sourceSessionId,
+    pid: virtualPidForPath(`${source}:${sourceSessionId}`),
+    parentPid: null,
+    project: seed.project?.trim() ?? "",
+    cwd: seed.cwd?.trim() || seed.projectRoot?.trim() || "",
+    harness: "unattributed",
+    kind: "system",
+    summary: "session lifecycle \xB7 restored persisted active identity",
+    raw: { reason: "persisted_active_seed" }
+  };
+}
+function applyPersistedObservedSeedToWatcher(watcher) {
+  if (watcher.internalObserved)
+    return;
+  const sessionId = watcher.transcript.sessionId?.trim();
+  if (!sessionId)
+    return;
+  const lifecycle = persistedObservedSessions.get(observedSessionLifecycleKey(watcher.source.name, sessionId));
+  if (!lifecycle)
+    return;
+  watcher.internalObserved = true;
+  watcher.lastInternalEvent = persistedSeedEvent(lifecycle.seed);
+  watcher.missingAuthoritativePasses = lifecycle.missingAuthoritativePasses;
+  watcher.lifecycleNotification = lifecycle.lifecycleNotification;
+}
+function watcherSessionId(watcher) {
+  return watcher.lastInternalEvent?.sessionId.trim() || watcher.transcript.sessionId?.trim() || null;
+}
+function notifyWatcherLifecycle(watcher, reason, observedAt) {
+  const nextNotification = reason === "missing" ? "offline" : "stalled";
+  const sessionId = watcherSessionId(watcher);
+  if (!sessionId)
+    return;
+  const lifecycleKey = observedSessionLifecycleKey(watcher.source.name, sessionId);
+  const persistedLifecycle = persistedObservedSessions.get(lifecycleKey);
+  if (!watcher.internalObserved || watcher.lifecycleNotification === nextNotification || watcher.lifecycleNotification === "offline" || persistedLifecycle?.lifecycleNotification === nextNotification || persistedLifecycle?.lifecycleNotification === "offline")
+    return;
+  watcher.lifecycleNotification = nextNotification;
+  if (persistedLifecycle) {
+    persistedLifecycle.lifecycleNotification = nextNotification;
+  }
+  pushInternalEvent({
+    id: `tail-lifecycle:${watcher.source.name}:${sessionId}:${nextNotification}:${observedAt}`,
+    ts: observedAt,
+    source: watcher.source.name,
+    sessionId,
+    pid: watcher.process.pid,
+    parentPid: watcher.process.ppid || null,
+    project: watcher.transcript.project,
+    cwd: watcher.transcript.cwd ?? watcher.process.cwd ?? "",
+    harness: watcher.transcript.harness,
+    kind: "system",
+    summary: reason === "missing" ? INTERNAL_TAIL_SESSION_OFFLINE_SUMMARY : INTERNAL_TAIL_SESSION_STALLED_SUMMARY,
+    raw: { reason }
+  });
+  if (nextNotification === "offline") {
+    persistedObservedSessions.delete(lifecycleKey);
+  }
+}
+function observeWatcherStaleness(watcher, observedAt) {
+  if (watcher.lifecycleNotification !== "none" || !watcher.internalObserved || observedAt - watcher.lastObservedChangeAt < INTERNAL_ACTIVE_STALE_AFTER_MS) {
+    watcher.staleObservations = 0;
+    return;
+  }
+  watcher.staleObservations++;
+  if (watcher.staleObservations >= INTERNAL_STALE_CONFIRMATION_COUNT) {
+    notifyWatcherLifecycle(watcher, "stale", observedAt);
+  }
 }
 async function readNew(handle, fromOffset, fileSize) {
   if (fileSize <= fromOffset) {
-    return { text: "", nextOffset: fromOffset };
+    return { bytes: Buffer.alloc(0), nextOffset: fromOffset };
   }
-  const length = fileSize - fromOffset;
-  const buffer = Buffer.alloc(length);
-  await handle.read(buffer, 0, length, fromOffset);
-  return { text: buffer.toString("utf8"), nextOffset: fileSize };
+  const length = Math.min(fileSize - fromOffset, WATCHER_READ_BYTES);
+  const buffer = Buffer.allocUnsafe(length);
+  const { bytesRead } = await handle.read(buffer, 0, length, fromOffset);
+  return {
+    bytes: buffer.subarray(0, bytesRead),
+    nextOffset: fromOffset + bytesRead
+  };
 }
 async function readTranscriptText(path2, maxBytes = RECENT_TRANSCRIPT_READ_BYTES) {
   let handle = null;
@@ -79275,23 +80216,35 @@ async function readTranscriptText(path2, maxBytes = RECENT_TRANSCRIPT_READ_BYTES
     await handle?.close().catch(() => {});
   }
 }
-async function pumpWatcher(watcher) {
+async function runWatcherPump(watcher, observedAt) {
   let handle = null;
+  watcher.lastPumpAt = observedAt;
   try {
     const stats = await stat9(watcher.transcriptPath);
+    const changed = stats.size !== watcher.lastKnownSize || stats.mtimeMs !== watcher.lastKnownMtimeMs;
+    watcher.lastKnownSize = stats.size;
+    watcher.lastKnownMtimeMs = stats.mtimeMs;
+    if (changed) {
+      watcher.lastObservedChangeAt = observedAt;
+      watcher.staleObservations = 0;
+      watcher.lifecycleNotification = "none";
+    }
     if (stats.size < watcher.offset) {
       watcher.offset = 0;
       watcher.carry = "";
+      watcher.decoder = new StringDecoder("utf8");
       watcher.emittedEventIds.clear();
     }
-    if (stats.size <= watcher.offset)
+    if (stats.size <= watcher.offset) {
+      observeWatcherStaleness(watcher, observedAt);
       return;
+    }
     if (watcher.source.parseFile) {
-      const text5 = await readTranscriptText(watcher.transcriptPath);
+      const text4 = await readTranscriptText(watcher.transcriptPath);
       watcher.offset = stats.size;
-      if (!text5)
+      if (!text4)
         return;
-      const events2 = parsedEventsToArray(watcher.source.parseFile(text5, {
+      const events2 = parsedEventsToArray(watcher.source.parseFile(text4, {
         process: watcher.process,
         transcript: watcher.transcript,
         transcriptPath: watcher.transcriptPath,
@@ -79300,74 +80253,203 @@ async function pumpWatcher(watcher) {
       }));
       watcher.lineCounter += Math.max(1, events2.length);
       for (const event of events2) {
-        if (watcher.emittedEventIds.has(event.id))
-          continue;
-        watcher.emittedEventIds.add(event.id);
-        pushEvent(event);
+        rememberWatcherEvent(watcher, event, "all");
       }
       return;
     }
-    handle = await open(watcher.transcriptPath, "r");
-    const { text: text4, nextOffset } = await readNew(handle, watcher.offset, stats.size);
-    watcher.offset = nextOffset;
-    if (!text4)
-      return;
-    const combined = watcher.carry + text4;
-    const lines = combined.split(`
-`);
-    watcher.carry = lines.pop() ?? "";
-    for (const line of lines) {
-      if (!line)
+    const drainEnd = Math.min(stats.size, watcher.offset + WATCHER_DRAIN_BYTES);
+    while (watcher.offset < drainEnd) {
+      handle = await open(watcher.transcriptPath, "r");
+      const { bytes, nextOffset } = await readNew(handle, watcher.offset, drainEnd);
+      await handle.close();
+      handle = null;
+      if (nextOffset <= watcher.offset)
+        break;
+      watcher.offset = nextOffset;
+      const text4 = watcher.decoder.write(bytes);
+      if (!text4)
         continue;
-      const event = watcher.source.parseLine(line, {
-        process: watcher.process,
-        transcript: watcher.transcript,
-        transcriptPath: watcher.transcriptPath,
-        lineOffset: watcher.lineCounter,
-        state: watcher.state
-      });
-      watcher.lineCounter++;
-      if (event) {
-        if (watcher.emittedEventIds.has(event.id))
+      const combined = watcher.carry + text4;
+      const lines = combined.split(`
+`);
+      watcher.carry = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line)
           continue;
-        watcher.emittedEventIds.add(event.id);
-        pushEvent(event);
+        const event = watcher.source.parseLine(line, {
+          process: watcher.process,
+          transcript: watcher.transcript,
+          transcriptPath: watcher.transcriptPath,
+          lineOffset: watcher.lineCounter,
+          state: watcher.state
+        });
+        watcher.lineCounter++;
+        if (event) {
+          rememberWatcherEvent(watcher, event, "all");
+        }
       }
     }
+    if (stats.size > watcher.offset) {
+      const continuation = setTimeout(() => {
+        pumpWatcher(watcher);
+      }, 0);
+      continuation.unref?.();
+    }
   } catch {} finally {
     await handle?.close().catch(() => {});
   }
 }
-async function pumpAllWatchers() {
-  await Promise.allSettled([...watchers.values()].map(pumpWatcher));
+function scheduleWatcherPump(run) {
+  return new Promise((resolve20, reject) => {
+    const start = () => {
+      activeWatcherPumps++;
+      Promise.resolve().then(run).then(resolve20, reject).finally(() => {
+        activeWatcherPumps--;
+        watcherPumpQueue.shift()?.();
+      });
+    };
+    if (activeWatcherPumps < WATCHER_PUMP_CONCURRENCY) {
+      start();
+    } else {
+      watcherPumpQueue.push(start);
+    }
+  });
+}
+function pumpWatcher(watcher, observedAt = Date.now()) {
+  if (watcher.pumpInFlight) {
+    return watcher.pumpInFlight;
+  }
+  const request = scheduleWatcherPump(() => runWatcherPump(watcher, observedAt));
+  watcher.pumpInFlight = request;
+  request.finally(() => {
+    if (watcher.pumpInFlight === request) {
+      watcher.pumpInFlight = null;
+    }
+  }).catch(() => {});
+  return request;
+}
+function selectWatchersForCurrentDemand(now = Date.now()) {
+  const all = [...watchers.values()];
+  if (subscribers.size > 0)
+    return all;
+  if (internalSubscribers.size === 0)
+    return [];
+  const hot = [];
+  const coldDue = [];
+  for (const watcher of all) {
+    if (now - watcher.lastObservedChangeAt <= INTERNAL_HOT_WATCHER_WINDOW_MS) {
+      hot.push(watcher);
+    } else if (now - watcher.lastPumpAt >= INTERNAL_IDLE_WATCHER_INTERVAL_MS) {
+      coldDue.push(watcher);
+    }
+  }
+  coldDue.sort((left, right) => left.lastPumpAt - right.lastPumpAt);
+  return [...hot, ...coldDue.slice(0, INTERNAL_IDLE_WATCHER_BATCH_SIZE)];
+}
+async function pumpWatchersForCurrentDemand(now = Date.now()) {
+  const selected = selectWatchersForCurrentDemand(now);
+  await Promise.allSettled(selected.map((watcher) => pumpWatcher(watcher, now)));
 }
-async function seedTail(watcher) {
+async function seedTail(watcher, options = { reconcileInternal: false }) {
+  let stats;
   try {
-    const stats = await stat9(watcher.transcriptPath);
-    watcher.offset = watcher.source.parseFile ? 0 : stats.size;
-    if (!watcher.source.parseFile && watcher.source.name === "codex") {
-      const lines = await readRecentTranscriptLines(watcher.transcriptPath, RECENT_TRANSCRIPT_LINES_PER_FILE);
+    stats = await stat9(watcher.transcriptPath);
+  } catch {
+    watcher.offset = 0;
+    return;
+  }
+  const seededAt = Date.now();
+  watcher.offset = options.reconcileInternal || !watcher.source.parseFile ? stats.size : 0;
+  watcher.lastPumpAt = seededAt;
+  watcher.lastKnownSize = stats.size;
+  watcher.lastKnownMtimeMs = stats.mtimeMs;
+  watcher.lastObservedChangeAt = Math.max(watcher.transcript.lastEventAt ?? 0, watcher.transcript.mtimeMs, stats.mtimeMs);
+  try {
+    if (options.reconcileInternal && watcher.source.parseFile) {
+      const text4 = await readTranscriptText(watcher.transcriptPath, INTERNAL_RECONCILE_READ_BYTES);
+      if (!text4)
+        return;
+      const events2 = parsedEventsToArray(watcher.source.parseFile(text4, {
+        process: watcher.process,
+        transcript: watcher.transcript,
+        transcriptPath: watcher.transcriptPath,
+        lineOffset: 0,
+        state: watcher.state
+      }));
+      watcher.lineCounter = Math.max(1, events2.length);
+      for (const event of events2)
+        rememberWatcherEvent(watcher, event, "internal");
+      return;
+    }
+    if (!watcher.source.parseFile && (options.reconcileInternal || watcher.source.name === "codex")) {
+      const lines = await readRecentTranscriptLines(watcher.transcriptPath, options.reconcileInternal ? INTERNAL_RECONCILE_LINES_PER_SESSION : RECENT_TRANSCRIPT_LINES_PER_FILE, options.reconcileInternal ? INTERNAL_RECONCILE_READ_BYTES : RECENT_TRANSCRIPT_READ_BYTES);
       lines.forEach((line, index2) => {
-        watcher.source.parseLine(line, {
+        const parsed = watcher.source.parseLine(line, {
           process: watcher.process,
           transcript: watcher.transcript,
           transcriptPath: watcher.transcriptPath,
           lineOffset: index2,
           state: watcher.state
         });
+        if (options.reconcileInternal && parsed) {
+          rememberWatcherEvent(watcher, parsed, "internal");
+        }
       });
+      watcher.lineCounter = lines.length;
     }
-  } catch {
-    watcher.offset = 0;
+  } catch {}
+}
+function reconcileMissingWatchers(seenSessionKeys, successfullyScannedSources, observedAt) {
+  for (const [sessionKey4, watcher] of watchers) {
+    if (seenSessionKeys.has(sessionKey4)) {
+      watcher.missingAuthoritativePasses = 0;
+      continue;
+    }
+    if (!successfullyScannedSources.has(watcher.source.name))
+      continue;
+    watcher.missingAuthoritativePasses++;
+    if (watcher.missingAuthoritativePasses < AUTHORITATIVE_MISSING_CONFIRMATION_COUNT) {
+      continue;
+    }
+    notifyWatcherLifecycle(watcher, "missing", observedAt);
+    watchers.delete(sessionKey4);
+    knownTranscripts.delete(sessionKey4);
+  }
+}
+function reconcilePersistedObservedSessions(seenLifecycleKeys, successfullyScannedSources, observedAt) {
+  for (const [lifecycleKey, lifecycle] of persistedObservedSessions) {
+    if (seenLifecycleKeys.has(lifecycleKey)) {
+      lifecycle.missingAuthoritativePasses = 0;
+      continue;
+    }
+    if (!successfullyScannedSources.has(lifecycle.seed.source))
+      continue;
+    lifecycle.missingAuthoritativePasses++;
+    if (lifecycle.missingAuthoritativePasses < AUTHORITATIVE_MISSING_CONFIRMATION_COUNT || lifecycle.lifecycleNotification === "offline") {
+      continue;
+    }
+    lifecycle.lifecycleNotification = "offline";
+    const seedEvent = persistedSeedEvent(lifecycle.seed);
+    pushInternalEvent({
+      ...seedEvent,
+      id: `tail-lifecycle:${lifecycle.seed.source}:${lifecycle.seed.sourceSessionId}:offline:${observedAt}`,
+      ts: observedAt,
+      summary: INTERNAL_TAIL_SESSION_OFFLINE_SUMMARY,
+      raw: { reason: "missing" }
+    });
+    persistedObservedSessions.delete(lifecycleKey);
   }
 }
 async function refreshDiscovery(scope = "shallow", options = { pruneMissing: scope !== "hot" }) {
   const allProcesses = [];
   const cachedProcesses = lastDiscovery?.processes ?? [];
   const seenSessionKeys = new Set;
+  const seenObservedLifecycleKeys = new Set;
+  const successfullyScannedSources = new Set;
   const discoveryIssues = [];
   const discoveryIssueKeys = new Set;
   for (const source of sources) {
+    let remainingInternalReconciliations = internalSubscribers.size > 0 ? INTERNAL_RECONCILE_SESSIONS_PER_SOURCE : 0;
     let processes = [];
     if (scope === "hot" && cachedProcesses.length > 0) {
       processes = cachedProcesses.filter((proc) => proc.source === source.name);
@@ -79382,14 +80464,19 @@ async function refreshDiscovery(scope = "shallow", options = { pruneMissing: sco
     let transcripts = [];
     try {
       transcripts = await source.discoverTranscripts(processes, scope);
+      successfullyScannedSources.add(source.name);
     } catch {
       transcripts = [];
     }
-    for (const transcript of transcripts) {
+    for (const transcript of [...transcripts].sort((left, right) => right.mtimeMs - left.mtimeMs)) {
       const primary = processForTranscript(transcript, processes);
       const transcriptPath = transcript.transcriptPath;
       const sessionKey4 = sessionRegistryKey(transcript);
       seenSessionKeys.add(sessionKey4);
+      const sourceSessionId = transcript.sessionId?.trim();
+      if (sourceSessionId) {
+        seenObservedLifecycleKeys.add(observedSessionLifecycleKey(source.name, sourceSessionId));
+      }
       const prior = knownTranscripts.get(sessionKey4);
       if (transcript.source !== "cursor" && prior && prior.transcriptPath !== transcriptPath) {
         const issueKey = `${sessionKey4}\x00${prior.transcriptPath}\x00${transcriptPath}`;
@@ -79417,10 +80504,25 @@ async function refreshDiscovery(scope = "shallow", options = { pruneMissing: sco
           offset: 0,
           lineCounter: 0,
           carry: "",
+          decoder: new StringDecoder("utf8"),
           emittedEventIds: new Set,
-          state: {}
+          state: {},
+          lastPumpAt: 0,
+          lastObservedChangeAt: Math.max(transcript.lastEventAt ?? 0, transcript.mtimeMs),
+          lastKnownSize: transcript.size,
+          lastKnownMtimeMs: transcript.mtimeMs,
+          missingAuthoritativePasses: 0,
+          staleObservations: 0,
+          lifecycleNotification: "none",
+          internalObserved: false,
+          lastInternalEvent: null,
+          pumpInFlight: null
         };
-        await seedTail(watcher);
+        const reconcileInternal = remainingInternalReconciliations > 0;
+        if (reconcileInternal)
+          remainingInternalReconciliations--;
+        await seedTail(watcher, { reconcileInternal });
+        applyPersistedObservedSeedToWatcher(watcher);
         watchers.set(sessionKey4, watcher);
         continue;
       }
@@ -79428,21 +80530,33 @@ async function refreshDiscovery(scope = "shallow", options = { pruneMissing: sco
         watcher.transcriptPath = transcriptPath;
         watcher.lineCounter = 0;
         watcher.carry = "";
+        watcher.decoder = new StringDecoder("utf8");
         watcher.emittedEventIds = new Set;
         watcher.state = {};
-        await seedTail(watcher);
+        watcher.internalObserved = false;
+        watcher.lastInternalEvent = null;
+        const reconcileInternal = remainingInternalReconciliations > 0;
+        if (reconcileInternal)
+          remainingInternalReconciliations--;
+        await seedTail(watcher, { reconcileInternal });
+      }
+      applyPersistedObservedSeedToWatcher(watcher);
+      if (transcript.mtimeMs > watcher.transcript.mtimeMs) {
+        watcher.lastObservedChangeAt = Date.now();
+        watcher.staleObservations = 0;
+        watcher.lifecycleNotification = "none";
+        if (watcher.source.parseFile)
+          watcher.offset = 0;
       }
       watcher.process = primary;
       watcher.transcript = transcript;
+      watcher.missingAuthoritativePasses = 0;
     }
   }
   if (options.pruneMissing) {
-    for (const sessionKey4 of [...watchers.keys()]) {
-      if (!seenSessionKeys.has(sessionKey4)) {
-        watchers.delete(sessionKey4);
-        knownTranscripts.delete(sessionKey4);
-      }
-    }
+    const observedAt = Date.now();
+    reconcileMissingWatchers(seenSessionKeys, successfullyScannedSources, observedAt);
+    reconcilePersistedObservedSessions(seenObservedLifecycleKeys, successfullyScannedSources, observedAt);
   }
   const allTranscripts = [...knownTranscripts.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
   let scoutManaged = 0;
@@ -79486,7 +80600,7 @@ function scheduleDiscovery(scope, options = { pruneMissing: scope !== "hot" }) {
 function ensureLoopRunning() {
   if (!pollTimer) {
     pollTimer = setInterval(() => {
-      pumpAllWatchers();
+      pumpWatchersForCurrentDemand();
     }, TAIL_POLL_INTERVAL_MS);
   }
   if (!hotDiscoveryTimer) {
@@ -79506,7 +80620,7 @@ function ensureLoopRunning() {
   }
 }
 function stopLoopIfIdle() {
-  if (subscribers.size > 0)
+  if (subscribers.size > 0 || internalSubscribers.size > 0)
     return;
   if (pollTimer) {
     clearInterval(pollTimer);
@@ -79525,6 +80639,7 @@ function stopLoopIfIdle() {
     deepDiscoveryTimer = null;
   }
   watchers.clear();
+  persistedObservedSessions.clear();
 }
 function normalizeTailDiscoveryOptions(input = false) {
   if (typeof input === "boolean") {
@@ -79550,18 +80665,19 @@ async function refreshTailDiscovery(scope = "shallow") {
 }
 function subscribeTail(handler) {
   subscribers.add(handler);
+  startTailLoopForSubscriber();
+  return () => {
+    subscribers.delete(handler);
+    stopLoopIfIdle();
+  };
+}
+function startTailLoopForSubscriber() {
   ensureLoopRunning();
   if (watchers.size === 0) {
-    runDiscovery("shallow", { pruneMissing: true }).then(() => pumpAllWatchers()).catch(() => {});
+    runDiscovery("shallow", { pruneMissing: true }).then(() => pumpWatchersForCurrentDemand()).catch(() => {});
   } else {
-    pumpAllWatchers();
+    pumpWatchersForCurrentDemand();
   }
-  return () => {
-    subscribers.delete(handler);
-    if (subscribers.size === 0) {
-      stopLoopIfIdle();
-    }
-  };
 }
 function snapshotRecentEvents(limit = 500) {
   return aggregateBuffer.slice(-limit);
@@ -79755,7 +80871,7 @@ async function readRecentTranscriptEvents(limit = 50, options) {
   const lineLimit = options?.perTranscriptLineLimit ?? RECENT_TRANSCRIPT_LINES_PER_FILE;
   const kinds = options?.kinds?.length ? new Set(options.kinds) : null;
   const kindQuota = kinds ? Math.max(1, options?.perTranscriptKindLimit ?? limit) : undefined;
-  const activeWatchers = [...watchers.values()].sort((left, right) => right.transcript.mtimeMs - left.transcript.mtimeMs).slice(0, transcriptReadLimit);
+  const activeWatchers = [...watchers.values()].filter((watcher) => options?.since === undefined || watcher.transcript.mtimeMs >= options.since).sort((left, right) => right.transcript.mtimeMs - left.transcript.mtimeMs).slice(0, transcriptReadLimit);
   for (const watcher of activeWatchers) {
     seenTranscriptPaths.add(watcher.transcriptPath);
     await appendWatcherTranscriptEvents(events2, seenEvents, watcher, {
@@ -79765,7 +80881,7 @@ async function readRecentTranscriptEvents(limit = 50, options) {
     });
   }
   if (options?.discovery?.transcripts?.length) {
-    const discoveryTranscripts = [...options.discovery.transcripts].filter((transcript) => !seenTranscriptPaths.has(transcript.transcriptPath)).sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, transcriptReadLimit);
+    const discoveryTranscripts = [...options.discovery.transcripts].filter((transcript) => !seenTranscriptPaths.has(transcript.transcriptPath) && (options.since === undefined || transcript.mtimeMs >= options.since)).sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, Math.max(0, transcriptReadLimit - activeWatchers.length));
     for (const transcript of discoveryTranscripts) {
       const parsed = await parseTranscriptSessionEvents(transcript, options.discovery.processes, lineLimit, {
         kinds,
@@ -79778,7 +80894,7 @@ async function readRecentTranscriptEvents(limit = 50, options) {
       seenTranscriptPaths.add(transcript.transcriptPath);
     }
   }
-  return events2.filter((event) => !kinds || kinds.has(event.kind)).sort((left, right) => right.ts - left.ts).slice(0, limit);
+  return events2.filter((event) => (!kinds || kinds.has(event.kind)) && (options?.since === undefined || event.ts >= options.since)).sort((left, right) => right.ts - left.ts).slice(0, limit);
 }
 function normalizeTailSessionRef(value) {
   const trimmed = value?.trim();
@@ -80105,7 +81221,7 @@ function buildObserveDataFromTail(transcript, events2, current) {
 var HISTORY_SNAPSHOT_CACHE_LIMIT = 128;
 var historySnapshotCache = new Map;
 var OBSERVE_SUMMARY_TAIL_SIZE = 8;
-var SESSION_REF_LOOKUP_TTL_MS = 1e4;
+var SESSION_REF_LOOKUP_TTL_MS = 60000;
 var sessionRefLookupCache = null;
 var AMBIGUOUS_TAIL_SESSION_REF = Symbol("ambiguous-tail-session-ref");
 function normalizedComparableString2(value) {
@@ -80194,6 +81310,23 @@ function tailSessionRefTranscripts(discovery, normalizedRef, harness2) {
     return refs.includes(normalizedRef);
   });
 }
+function bestTailSessionRefLookupEntry(transcripts, normalizedRef) {
+  const matches = [];
+  for (const transcript of transcripts) {
+    const adapterType = adapterTypeFromTailSource(transcript.source);
+    if (!adapterType || !supportsHistorySessionSnapshotForPath(transcript.transcriptPath, adapterType)) {
+      continue;
+    }
+    matches.push({
+      refId: normalizedRef,
+      historyPath: transcript.transcriptPath,
+      adapterType,
+      mtimeMs: transcript.mtimeMs,
+      size: transcript.size
+    });
+  }
+  return matches.sort((left, right) => right.mtimeMs - left.mtimeMs)[0] ?? null;
+}
 function hasAmbiguousTailHarness(transcripts) {
   const sources2 = new Set(transcripts.map((transcript) => canonicalSessionHarness(transcript.source) ?? transcript.source.trim().toLowerCase()));
   return sources2.size > 1;
@@ -80270,23 +81403,7 @@ async function findTailSessionRefLookupEntry(normalizedRef, harness2 = null) {
   const transcripts = tailSessionRefTranscripts(discovery, normalizedRef, harness2);
   if (!harness2 && hasAmbiguousTailHarness(transcripts))
     return AMBIGUOUS_TAIL_SESSION_REF;
-  const matches = [];
-  for (const transcript of transcripts) {
-    const adapterType = adapterTypeFromTailSource(transcript.source);
-    if (!adapterType || !supportsHistorySessionSnapshotForPath(transcript.transcriptPath, adapterType)) {
-      continue;
-    }
-    matches.push({
-      refId: normalizedRef,
-      historyPath: transcript.transcriptPath,
-      adapterType,
-      mtimeMs: transcript.mtimeMs,
-      size: transcript.size
-    });
-  }
-  if (matches.length === 0)
-    return null;
-  return matches.sort((left, right) => right.mtimeMs - left.mtimeMs)[0] ?? null;
+  return bestTailSessionRefLookupEntry(transcripts, normalizedRef);
 }
 function historyAdapterAlias(value) {
   const normalized = value?.trim().toLowerCase();
@@ -81707,11 +82824,12 @@ async function loadSessionRefObservePayload(refId) {
     return null;
   }
   let [discovery, brokerContext] = await Promise.all([
-    getTailDiscovery().catch(() => null),
+    readScoutBrokerTailDiscovery().catch(() => null),
     loadScoutBrokerContext().catch(() => null)
   ]);
   let matchingTranscripts = discovery ? tailSessionRefTranscripts(discovery, normalizedRef, requestedHarness) : [];
-  const cachedHistoryEntry = !requestedHarness || requestedHarness === "claude" ? sessionRefLookup().get(normalizedRef) ?? null : null;
+  const discoveredHistoryEntry = bestTailSessionRefLookupEntry(matchingTranscripts, normalizedRef);
+  const cachedHistoryEntry = !discoveredHistoryEntry && matchingTranscripts.length === 0 && (!requestedHarness || requestedHarness === "claude") ? sessionRefLookup().get(normalizedRef) ?? null : null;
   const matchingAgents = queryAgents(200).filter((agent) => normalizeSessionRefId(agent.harnessSessionId) === normalizedRef && sessionHarnessMatches(requestedHarness, agent.harness));
   const matchingAgentOwners = new Set(matchingAgents.map((agent) => agent.id));
   if (matchingAgentOwners.size > 1)
@@ -81778,7 +82896,7 @@ async function loadSessionRefObservePayload(refId) {
   }
   if (!requestedHarness && hasAmbiguousTailHarness(matchingTranscripts))
     return null;
-  const tailHistoryEntry = await findTailSessionRefLookupEntry(normalizedRef, requestedHarness);
+  const tailHistoryEntry = discoveredHistoryEntry ?? await findTailSessionRefLookupEntry(normalizedRef, requestedHarness);
   if (tailHistoryEntry === AMBIGUOUS_TAIL_SESSION_REF)
     return null;
   const historyEntry = tailHistoryEntry ?? (requestedHarness === "claude" || !requestedHarness && (!discovery || matchingTranscripts.length === 0) ? cachedHistoryEntry : null);
@@ -86450,6 +87568,7 @@ var MAX_EVENTS_PER_SESSION = 200;
 var sessions4 = new Map;
 var hosts = new Map;
 var sessionSubscribers = new Map;
+var hostCommandWaiters = new Map;
 var nextHostPollId = 1;
 var DEFAULT_VOICE_SETTINGS = {
   preference: "auto",
@@ -86464,6 +87583,9 @@ function registerScoutVoiceHost(input) {
   const now = Date.now();
   const previous = hosts.get(hostId);
   const instanceId = input.instanceId?.trim() || null;
+  if (previous && previous.instanceId !== instanceId) {
+    finishScoutVoiceHostCommandWaiter(hostId, null);
+  }
   const settings = mergeVoiceSettings(previous?.settings ?? DEFAULT_VOICE_SETTINGS, input.settings);
   hosts.set(hostId, {
     hostId,
@@ -86545,6 +87667,7 @@ function awaitScoutVoiceHostCommand(hostId, timeoutMs = 25000, instanceId, signa
   if (host.instanceId !== normalizedInstanceId) {
     return Promise.resolve({ command: null });
   }
+  finishScoutVoiceHostCommandWaiter(normalizedHostId, null);
   const pollId = nextHostPollId++;
   host.activePollId = pollId;
   touchScoutVoiceHost(normalizedHostId);
@@ -86559,40 +87682,37 @@ function awaitScoutVoiceHostCommand(hostId, timeoutMs = 25000, instanceId, signa
     return Promise.resolve({ command: null });
   }
   return new Promise((resolve23) => {
-    const startedAt = Date.now();
     let settled = false;
+    let timeout = null;
     const finish = (command) => {
       if (settled)
         return;
       settled = true;
-      clearInterval(timer);
+      if (timeout)
+        clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
+      const waiter = hostCommandWaiters.get(normalizedHostId);
+      if (waiter?.pollId === pollId)
+        hostCommandWaiters.delete(normalizedHostId);
       const current = hosts.get(normalizedHostId);
       if (current?.activePollId === pollId)
         current.activePollId = null;
       resolve23({ command });
     };
     const abort = () => finish(null);
-    const timer = setInterval(() => {
+    hostCommandWaiters.set(normalizedHostId, {
+      pollId,
+      instanceId: normalizedInstanceId,
+      finish
+    });
+    timeout = setTimeout(() => {
       const current = hosts.get(normalizedHostId);
-      if (!current) {
-        finish(null);
-        return;
-      }
-      if (current.instanceId !== normalizedInstanceId || current.activePollId !== pollId) {
-        finish(null);
-        return;
-      }
-      current.lastSeenAt = Date.now();
-      if (current.pendingCommands.length > 0) {
-        const command = current.pendingCommands.shift() ?? null;
-        finish(command);
-        return;
+      if (current && current.instanceId === normalizedInstanceId && current.activePollId === pollId) {
+        current.lastSeenAt = Date.now();
       }
-      if (Date.now() - startedAt >= timeoutMs) {
-        finish(null);
-      }
-    }, 100);
+      finish(null);
+    }, timeoutMs);
+    timeout.unref?.();
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted)
       abort();
@@ -86813,6 +87933,22 @@ function queueHostCommand(hostId, command) {
   }
   host.pendingCommands.push(command);
   host.lastSeenAt = Date.now();
+  deliverPendingScoutVoiceHostCommand(host);
+}
+function finishScoutVoiceHostCommandWaiter(hostId, command) {
+  hostCommandWaiters.get(hostId)?.finish(command);
+}
+function deliverPendingScoutVoiceHostCommand(host) {
+  const waiter = hostCommandWaiters.get(host.hostId);
+  if (!waiter)
+    return;
+  if (waiter.instanceId !== host.instanceId || waiter.pollId !== host.activePollId) {
+    waiter.finish(null);
+    return;
+  }
+  const command = host.pendingCommands.shift();
+  if (command)
+    waiter.finish(command);
 }
 function dispatchSessionCommand(session3, command) {
   const hostId = session3.assignedHostId ?? pickLiveVoiceHost()?.hostId;
@@ -87226,6 +88362,127 @@ function defaultVoiceForModel(providers2, modelId2) {
   return firstNonEmptyString7(provider?.env.VOX_MLX_AUDIO_TTS_DEFAULT_VOICE);
 }
 
+// packages/web/server/nvidia-speech.ts
+var NVIDIA_MAGPIE_SPEECH_URL = "https://877104f7-e885-42b9-8de8-f6e4c6303969.invocation.api.nvcf.nvidia.com/v1/audio/synthesize";
+var NVIDIA_MAGPIE_VOICES_URL = "https://877104f7-e885-42b9-8de8-f6e4c6303969.invocation.api.nvcf.nvidia.com/v1/audio/list_voices";
+var NVIDIA_MAGPIE_MODEL = "magpie-tts-multilingual";
+var NVIDIA_MAGPIE_DEFAULT_VOICE = "Magpie-Multilingual.EN-US.Aria";
+var NVIDIA_MAGPIE_TIMEOUT_MS = 60000;
+var NVIDIA_MAGPIE_MAX_CHARACTERS = 2000;
+function resolveNvidiaApiKey(env = process.env) {
+  return firstNonEmptyString8(env.NV_API_KEY, env.NVIDIA_API_KEY);
+}
+function isNvidiaMagpieSpeechModel(modelId2) {
+  return modelId2?.trim() === NVIDIA_MAGPIE_MODEL;
+}
+async function listNvidiaMagpieVoices(input) {
+  const timeout = AbortSignal.timeout(NVIDIA_MAGPIE_TIMEOUT_MS);
+  const signal = input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
+  const response = await fetch(input.endpoint ?? NVIDIA_MAGPIE_VOICES_URL, {
+    method: "GET",
+    headers: { authorization: `Bearer ${input.apiKey}` },
+    signal
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`NVIDIA Magpie voice discovery failed (${response.status})${detail ? `: ${detail.slice(0, 200)}` : ""}`);
+  }
+  const voices = parseNvidiaMagpieVoices(await response.json());
+  if (voices.length === 0) {
+    throw new Error("NVIDIA Magpie voice discovery returned no voices.");
+  }
+  return voices;
+}
+async function synthesizeNvidiaMagpieSpeech(input) {
+  const text4 = Array.from(input.text).slice(0, NVIDIA_MAGPIE_MAX_CHARACTERS).join("");
+  const voiceId = input.voiceId?.trim() || NVIDIA_MAGPIE_DEFAULT_VOICE;
+  const language = magpieLanguageForVoice(voiceId);
+  const form = new FormData;
+  form.set("text", text4);
+  form.set("language", language);
+  form.set("voice", voiceId);
+  form.set("encoding", "LINEAR_PCM");
+  form.set("sample_rate_hz", "44100");
+  const timeout = AbortSignal.timeout(NVIDIA_MAGPIE_TIMEOUT_MS);
+  const signal = input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
+  const response = await fetch(input.endpoint ?? NVIDIA_MAGPIE_SPEECH_URL, {
+    method: "POST",
+    headers: { authorization: `Bearer ${input.apiKey}` },
+    body: form,
+    signal
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`NVIDIA Magpie speech failed (${response.status})${detail ? `: ${detail.slice(0, 200)}` : ""}`);
+  }
+  const audio = new Uint8Array(await response.arrayBuffer());
+  if (audio.byteLength === 0) {
+    throw new Error("NVIDIA Magpie returned no audio.");
+  }
+  const responseContentType = response.headers.get("content-type")?.split(";")[0];
+  return {
+    contentType: responseContentType?.startsWith("audio/") ? responseContentType : "audio/wav",
+    audioBase64: Buffer.from(audio).toString("base64"),
+    modelId: NVIDIA_MAGPIE_MODEL,
+    voiceId,
+    audioBytes: audio.byteLength
+  };
+}
+function magpieLanguageForVoice(voiceId) {
+  const locale = magpieLocaleSegment(voiceId);
+  if (!locale)
+    return "en-US";
+  const [language, region] = locale.split("-");
+  return `${language.toLowerCase()}-${region.toUpperCase()}`;
+}
+function parseNvidiaMagpieVoices(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return [];
+  const ids = new Set;
+  for (const group of Object.values(value)) {
+    if (!group || typeof group !== "object" || Array.isArray(group))
+      continue;
+    const voices = group.voices;
+    if (!Array.isArray(voices))
+      continue;
+    for (const voice of voices) {
+      if (typeof voice !== "string")
+        continue;
+      const id = voice.trim();
+      if (id)
+        ids.add(id);
+    }
+  }
+  return Array.from(ids, voiceDetails).sort((left, right) => left.language.localeCompare(right.language) || left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+function voiceDetails(id) {
+  const parts = id.split(".");
+  const language = magpieLanguageForVoice(id);
+  const localeIndex = parts.findIndex(isLocaleSegment);
+  const nameParts = localeIndex >= 0 ? parts.slice(localeIndex + 1) : [];
+  const name2 = nameParts.length > 0 ? nameParts.join(" \xB7 ") : parts.at(-1) || id;
+  return {
+    id,
+    name: name2,
+    language,
+    isDefault: id === NVIDIA_MAGPIE_DEFAULT_VOICE
+  };
+}
+function magpieLocaleSegment(voiceId) {
+  return voiceId.split(".").find(isLocaleSegment);
+}
+function isLocaleSegment(value) {
+  return /^[a-z]{2,3}-[a-z]{2}$/i.test(value);
+}
+function firstNonEmptyString8(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed)
+      return trimmed;
+  }
+  return;
+}
+
 // packages/web/server/scout-voice.ts
 var SCOUT_VOICE_CLIENT_ID = "openscout-web";
 var DEFAULT_SCOUT_VOICE_ASR_URL = "http://127.0.0.1:43115";
@@ -87268,14 +88525,16 @@ async function getScoutSpeechCatalog(input = {}) {
   let models = [];
   let voices = [];
   let source = "fallback";
-  try {
-    [models, voices] = await Promise.all([
-      listVoxSpeechModels(input.signal),
-      listVoxSpeechVoices(requestedModelId, input.signal)
-    ]);
-    if (models.length > 0)
-      source = "vox";
-  } catch {}
+  if (requestedModelId !== NVIDIA_MAGPIE_MODEL) {
+    try {
+      [models, voices] = await Promise.all([
+        listVoxSpeechModels(input.signal),
+        listVoxSpeechVoices(requestedModelId, input.signal)
+      ]);
+      if (models.length > 0)
+        source = "vox";
+    } catch {}
+  }
   const fallback = fallbackScoutSpeechCatalog(requestedModelId, defaults);
   for (const model2 of fallback.models) {
     if (!models.some((candidate) => candidate.id === model2.id)) {
@@ -87289,6 +88548,25 @@ async function getScoutSpeechCatalog(input = {}) {
     models = models.map((model2) => model2.provider === "openai" ? { ...model2, available: true } : model2);
     voices = voices.map((voice) => voice.provider === "openai" ? { ...voice, available: true } : voice);
   }
+  if (input.directNvidiaAvailable || input.directNvidiaApiKey) {
+    models = models.map((model2) => model2.provider === "nvidia" ? { ...model2, available: true } : model2);
+    voices = voices.map((voice) => voice.provider === "nvidia" ? { ...voice, available: true } : voice);
+  }
+  if (input.directNvidiaApiKey && requestedModelId === NVIDIA_MAGPIE_MODEL) {
+    try {
+      const discovered = await listNvidiaMagpieVoices({
+        apiKey: input.directNvidiaApiKey,
+        signal: input.signal
+      });
+      voices = discovered.map((voice) => ({
+        ...voice,
+        provider: "nvidia",
+        modelId: NVIDIA_MAGPIE_MODEL,
+        available: true
+      }));
+      source = "nvidia-developer-inference";
+    } catch {}
+  }
   return {
     defaultModelId: defaults.modelId,
     ...defaults.voiceId ? { defaultVoiceId: defaults.voiceId } : {},
@@ -87300,7 +88578,8 @@ async function getScoutSpeechCatalog(input = {}) {
 function fallbackScoutSpeechCatalog(modelId2, defaults = resolveScoutSpeechDefaults()) {
   const models = [
     { id: "gpt-4o-mini-tts", name: "GPT-4o mini TTS", provider: "openai", available: true },
-    { id: "eleven_multilingual_v2", name: "Eleven Multilingual v2", provider: "elevenlabs", available: true }
+    { id: "eleven_multilingual_v2", name: "Eleven Multilingual v2", provider: "elevenlabs", available: true },
+    { id: NVIDIA_MAGPIE_MODEL, name: "Magpie TTS Multilingual", provider: "nvidia", available: true }
   ];
   const openAIVoices = ["alloy", "ash", "ballad", "cedar", "coral", "echo", "fable", "marin", "nova", "onyx", "sage", "shimmer", "verse"].map((id) => ({
     id,
@@ -87318,11 +88597,20 @@ function fallbackScoutSpeechCatalog(modelId2, defaults = resolveScoutSpeechDefau
     available: true,
     isDefault: true
   }];
+  const nvidiaVoices = [{
+    id: NVIDIA_MAGPIE_DEFAULT_VOICE,
+    name: "Aria",
+    language: "en-US",
+    provider: "nvidia",
+    modelId: NVIDIA_MAGPIE_MODEL,
+    available: true,
+    isDefault: true
+  }];
   return {
     defaultModelId: defaults.modelId,
     ...defaults.voiceId ? { defaultVoiceId: defaults.voiceId } : {},
     models,
-    voices: modelId2 === "eleven_multilingual_v2" ? elevenLabsVoices : openAIVoices,
+    voices: modelId2 === "eleven_multilingual_v2" ? elevenLabsVoices : modelId2 === NVIDIA_MAGPIE_MODEL ? nvidiaVoices : openAIVoices,
     source: "fallback"
   };
 }
@@ -87337,9 +88625,9 @@ function createScoutVoiceAsrClient(probeTimeout) {
   });
 }
 function resolveScoutVoiceAsrUrl(env = process.env) {
-  return firstNonEmptyString8(env.OPENSCOUT_VOICE_ASR_URL, env.OPENSCOUT_VOICE_BRIDGE_URL, env.VOX_COMPANION_URL) ?? DEFAULT_SCOUT_VOICE_ASR_URL;
+  return firstNonEmptyString9(env.OPENSCOUT_VOICE_ASR_URL, env.OPENSCOUT_VOICE_BRIDGE_URL, env.VOX_COMPANION_URL) ?? DEFAULT_SCOUT_VOICE_ASR_URL;
 }
-function firstNonEmptyString8(...values) {
+function firstNonEmptyString9(...values) {
   for (const value of values) {
     const trimmed = value?.trim();
     if (trimmed)
@@ -87528,9 +88816,9 @@ class ScoutRealtimeVoiceAdmission {
 }
 function resolveScoutRealtimeVoiceConfig(env = process.env) {
   return {
-    model: firstNonEmptyString9(env.OPENSCOUT_REALTIME_MODEL) ?? DEFAULT_REALTIME_MODEL,
-    voice: firstNonEmptyString9(env.OPENSCOUT_REALTIME_VOICE) ?? DEFAULT_REALTIME_VOICE,
-    instructions: firstNonEmptyString9(env.OPENSCOUT_REALTIME_INSTRUCTIONS) ?? SCOUT_REALTIME_INSTRUCTIONS
+    model: firstNonEmptyString10(env.OPENSCOUT_REALTIME_MODEL) ?? DEFAULT_REALTIME_MODEL,
+    voice: firstNonEmptyString10(env.OPENSCOUT_REALTIME_VOICE) ?? DEFAULT_REALTIME_VOICE,
+    instructions: firstNonEmptyString10(env.OPENSCOUT_REALTIME_INSTRUCTIONS) ?? SCOUT_REALTIME_INSTRUCTIONS
   };
 }
 function scoutRealtimeVoiceEnvironmentOverride(env = process.env) {
@@ -87668,7 +88956,7 @@ function positiveInteger3(value, fallback) {
 function secondsUntil(timestamp, now) {
   return Math.max(1, Math.ceil((timestamp - now) / 1000));
 }
-function firstNonEmptyString9(value) {
+function firstNonEmptyString10(value) {
   const trimmed = value?.trim();
   return trimmed || undefined;
 }
@@ -88035,10 +89323,13 @@ function mountScoutVoiceRoutes(app, deps = {}) {
     const directOpenAIAvailable = Boolean(await deps.resolveOpenAIApiKey?.().catch(() => {
       return;
     }) ?? process.env.OPENAI_API_KEY?.trim());
+    const directNvidiaApiKey = resolveNvidiaApiKey();
     return c.json(await getScoutSpeechCatalog({
       modelId: c.req.query("modelId"),
       signal: c.req.raw.signal,
-      directOpenAIAvailable
+      directOpenAIAvailable,
+      directNvidiaAvailable: Boolean(directNvidiaApiKey),
+      directNvidiaApiKey
     }));
   });
   app.post("/api/voice/engage", async (c) => {
@@ -88254,6 +89545,28 @@ function mountScoutVoiceRoutes(app, deps = {}) {
     if (speechTiming === null) {
       return c.json({ error: "speechTiming is invalid" }, 400);
     }
+    const defaults = resolveScoutSpeechDefaults();
+    const requestedModelId = body.modelId ?? defaults.modelId;
+    if (isNvidiaMagpieSpeechModel(requestedModelId)) {
+      const nvidiaApiKey = resolveNvidiaApiKey();
+      if (!nvidiaApiKey) {
+        return c.json({ error: "NV_API_KEY is required for hosted NVIDIA Developer Inference." }, 503);
+      }
+      try {
+        return c.json({
+          ...await synthesizeNvidiaMagpieSpeech({
+            text: text4,
+            apiKey: nvidiaApiKey,
+            voiceId: body.voiceId,
+            signal: c.req.raw.signal
+          }),
+          route: "nvidia-developer-inference"
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "NVIDIA Magpie speech failed";
+        return c.json({ error: message }, 503);
+      }
+    }
     try {
       return c.json(await synthesizeScoutSpeech({
         text: text4,
@@ -88271,13 +89584,12 @@ function mountScoutVoiceRoutes(app, deps = {}) {
         return;
       }) ?? process.env.OPENAI_API_KEY?.trim();
       if (apiKey && !c.req.raw.signal.aborted) {
-        const defaults = resolveScoutSpeechDefaults();
         try {
           return c.json({
             ...await synthesizeOpenAISpeech({
               text: text4,
               apiKey,
-              modelId: body.modelId ?? defaults.modelId,
+              modelId: requestedModelId,
               voiceId: body.voiceId ?? defaults.voiceId,
               speed: body.speed,
               instructions: optionalString(body.instructions),
@@ -89300,8 +90612,8 @@ function normalizeExistingPath(value) {
     return null;
   }
   try {
-    const stat10 = statSync21(absolute);
-    return stat10.isDirectory() ? absolute : dirname37(absolute);
+    const stat11 = statSync21(absolute);
+    return stat11.isDirectory() ? absolute : dirname37(absolute);
   } catch {
     return null;
   }
@@ -90050,8 +91362,8 @@ async function resolveTrustedMaterialPath(work, materialId) {
     if (!pathInsideRoot(realPath, realRoot)) {
       return { ok: false, status: 403, error: "material path is outside its trusted root" };
     }
-    const stat10 = statSync21(realPath);
-    if (!stat10.isFile()) {
+    const stat11 = statSync21(realPath);
+    if (!stat11.isFile()) {
       return { ok: false, status: 415, error: "material is not a file" };
     }
     return { ok: true, material, realPath };
@@ -90065,12 +91377,12 @@ async function readWorkMaterialRaw(work, materialId) {
     return resolved;
   }
   try {
-    const stat10 = statSync21(resolved.realPath);
+    const stat11 = statSync21(resolved.realPath);
     return {
       ok: true,
       realPath: resolved.realPath,
       mediaType: materialMediaType(resolved.realPath),
-      sizeBytes: stat10.size
+      sizeBytes: stat11.size
     };
   } catch {
     return { ok: false, status: 404, error: "material could not be read" };
@@ -90100,8 +91412,8 @@ async function readWorkMaterialContent(work, materialId) {
     if (!pathInsideRoot(realPath, realRoot)) {
       return { ok: false, status: 403, error: "material path is outside its trusted root" };
     }
-    const stat10 = statSync21(realPath);
-    if (!stat10.isFile()) {
+    const stat11 = statSync21(realPath);
+    if (!stat11.isFile()) {
       return { ok: false, status: 415, error: "material is not a file" };
     }
     const buffer = readFileSync29(realPath);
@@ -90133,7 +91445,7 @@ async function readWorkMaterialContent(work, materialId) {
 
 // packages/web/server/plan-documents.ts
 import { createHash as createHash9 } from "crypto";
-import { readdir as readdir4, readFile as readFile17, stat as stat10 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile17, stat as stat11 } from "fs/promises";
 import { homedir as homedir49 } from "os";
 import { basename as basename25, isAbsolute as isAbsolute10, join as join65, relative as relative8, resolve as resolve27 } from "path";
 var HOME3 = homedir49();
@@ -90216,7 +91528,7 @@ async function walkMarkdownFiles(directory, remaining = { count: MAX_FILES_PER_R
     return [];
   let entries2;
   try {
-    entries2 = await readdir4(directory, { withFileTypes: true });
+    entries2 = await readdir5(directory, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT")
       return [];
@@ -90249,7 +91561,7 @@ async function discoverPlanFiles(root) {
   const fromPlanDirs = (await Promise.all(PLAN_SUBDIRECTORIES.map((subdir) => walkMarkdownFiles(join65(root.root, subdir))))).flat();
   let directPlanFiles = [];
   try {
-    const entries2 = await readdir4(root.root, { withFileTypes: true });
+    const entries2 = await readdir5(root.root, { withFileTypes: true });
     directPlanFiles = entries2.filter((entry) => entry.isFile() && /\.plan\.md$/i.test(entry.name)).map((entry) => join65(root.root, entry.name));
   } catch {
     directPlanFiles = [];
@@ -90432,7 +91744,7 @@ function idForPlan(root, filePath) {
   return `plan-doc:${hash}`;
 }
 async function readPlanDocument(root, filePath) {
-  const fileStats = await stat10(filePath).catch(() => null);
+  const fileStats = await stat11(filePath).catch(() => null);
   if (!fileStats || !fileStats.isFile() || fileStats.size > MAX_DOCUMENT_BYTES) {
     return null;
   }
@@ -92101,7 +93413,8 @@ function brokerCardAgentsForWeb(broker2) {
 }
 var AGENT_ATTENTION_TTL_MS2 = 1e4;
 var AGENT_BACKGROUND_REFRESH_DELAY_MS = 500;
-var AGENT_BROKER_CONTEXT_TTL_MS = 5000;
+var AGENT_BROKER_CONTEXT_TTL_MS = 60000;
+var AGENT_BROKER_CONTEXT_COLD_BUDGET_MS = 75;
 var agentAttentionCache = null;
 var agentAttentionInFlight = null;
 function queryAgentAttentionIndex(broker2, capture = defaultCaptureTmuxPane) {
@@ -92151,8 +93464,12 @@ function createAgentBrokerContextReader() {
     return promise;
   };
   return () => {
-    if (!cache)
-      return refresh(0);
+    if (!cache) {
+      return Promise.race([
+        refresh(0),
+        delay2(AGENT_BROKER_CONTEXT_COLD_BUDGET_MS).then(() => null)
+      ]);
+    }
     if (Date.now() - cache.at >= AGENT_BROKER_CONTEXT_TTL_MS && !inFlight) {
       refresh(AGENT_BACKGROUND_REFRESH_DELAY_MS);
     }
@@ -92246,24 +93563,37 @@ function withPinnedMeshPeerAgents(agents, broker2, limit) {
   if (!localNodeId)
     return mostRecentAgents(agents, limit);
   const peerNodeIds = pinnedMeshPeerNodeIds(broker2);
-  const peerAgents = brokerCardAgentsForWeb(broker2).filter((agent) => agent.homeNodeId && peerNodeIds.has(agent.homeNodeId));
+  const representativeCardByNode = new Map;
+  for (const agent of Object.values(broker2.snapshot.agents ?? {})) {
+    const homeNodeId = agent.homeNodeId;
+    if (!homeNodeId || !peerNodeIds.has(homeNodeId) || !isBrokerAgentVisibleInWeb(agent))
+      continue;
+    const existing = representativeCardByNode.get(homeNodeId);
+    if (!existing || (latestBrokerAgentTimestamp(agent, null) ?? 0) > (latestBrokerAgentTimestamp(existing, null) ?? 0)) {
+      representativeCardByNode.set(homeNodeId, agent);
+    }
+  }
+  const peerAgents = [...representativeCardByNode.values()].map((agent) => brokerAgentCardToWebAgent(broker2, agent)).filter((agent) => Boolean(agent)).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0) || left.name.localeCompare(right.name));
   if (peerAgents.length === 0)
     return mostRecentAgents(agents, limit);
   const byId = new Map(agents.map((agent) => [agent.id, agent]));
   for (const peer of peerAgents) {
-    byId.set(peer.id, peer);
+    if (!byId.has(peer.id))
+      byId.set(peer.id, peer);
   }
   const merged = [...byId.values()];
   if (limit === undefined)
     return merged;
-  const limited = mostRecentAgents(merged, limit);
-  const included = new Set(limited.map((agent) => agent.id));
-  for (const peer of peerAgents) {
-    if (!included.has(peer.id)) {
-      limited.push(peer);
-    }
+  const representatives = peerAgents.map((peer) => byId.get(peer.id) ?? peer).slice(0, limit);
+  const included = new Set(representatives.map((agent) => agent.id));
+  const limited = [...representatives];
+  for (const agent of mostRecentAgents(merged, undefined)) {
+    if (limited.length >= limit)
+      break;
+    if (included.add(agent.id))
+      limited.push(agent);
   }
-  return limited;
+  return mostRecentAgents(limited, undefined);
 }
 function agentListSummary(agent) {
   return {
@@ -92313,13 +93643,11 @@ function agentListSummary(agent) {
     createdAt: agent.createdAt
   };
 }
-async function withAgentRepoKeys(agents) {
+function withAgentRepoKeys(agents) {
   const roots = agents.map((agent) => agent.projectRoot).filter((root) => Boolean(root));
   if (roots.length === 0)
     return agents;
-  const keys = await resolveRepoKeysByRoot(roots).catch(() => null);
-  if (!keys)
-    return agents;
+  const keys = cachedRepoKeysByRoot(roots);
   return agents.map((agent) => {
     const repoKey = agent.projectRoot ? keys.get(agent.projectRoot) ?? null : null;
     return repoKey ? { ...agent, repoKey } : agent;
@@ -92403,11 +93731,11 @@ async function queryAgentsIncludingBrokerCards(limit, includeRichBrokerContext =
     const brokerById2 = new Map(brokerAgents2.map((agent) => [agent.id, agent]));
     const mergedAgents2 = agents.map((agent) => mergeBrokerAgentProjection(agent, brokerById2.get(agent.id)));
     const existingIds2 = new Set(mergedAgents2.map((agent) => agent.id));
-    const broker3 = await loadBrokerContext();
-    const roster2 = withPinnedMeshPeerAgents([
+    const attention2 = includeAttention ? await queryAgentAttentionIndex(null, capture) : new Map;
+    const roster2 = mostRecentAgents(applyAgentAttention([
       ...mergedAgents2,
       ...brokerAgents2.filter((agent) => !existingIds2.has(agent.id))
-    ], broker3, limit);
+    ], attention2), limit);
     return withAgentRepoKeys(roster2);
   }
   const broker2 = await loadBrokerContext();
@@ -94039,13 +95367,11 @@ function dedupeHudRunnerProjects(projects) {
   return result;
 }
 async function buildHudRunnerOptions(currentDirectory, input = {}) {
-  const [settingsResult, catalogResult, runtimeCatalogResult] = await Promise.allSettled([
+  const [settingsResult, runtimeCatalogResult] = await Promise.allSettled([
     readOpenScoutSettings({ currentDirectory }),
-    loadHarnessCatalogSnapshot(),
     loadBrokerRuntimeCatalog()
   ]);
   const settings = settingsResult.status === "fulfilled" ? settingsResult.value : null;
-  const catalog = catalogResult.status === "fulfilled" ? catalogResult.value : null;
   const liveRuntimeCatalog = runtimeCatalogResult.status === "fulfilled" ? runtimeCatalogResult.value : null;
   const runtimeCatalog = liveRuntimeCatalog?.catalog ?? SCOUT_RUNTIME_CATALOG;
   const allAgents = queryAgents(50);
@@ -94058,19 +95384,17 @@ async function buildHudRunnerOptions(currentDirectory, input = {}) {
   const configuredDefaultHarness = settings?.agents.defaultHarness?.trim() ?? "";
   const defaultHarness = isScoutRuntimeHarnessEnabled(configuredDefaultHarness, runtimeCatalog) ? configuredDefaultHarness : scoutRuntimeDefaultHarness(runtimeCatalog) ?? "claude";
   const harnessesById = new Map;
-  const readinessByHarness = new Map((catalog?.entries ?? []).map((entry) => [entry.harness, entry]));
   for (const entry of runtimeCatalog.harnesses) {
     if (!entry.enabled || entry.listed === false)
       continue;
-    const readiness = readinessByHarness.get(entry.id);
     harnessesById.set(entry.id, {
       id: entry.id,
       name: entry.id,
       label: entry.label,
       description: null,
-      state: readiness?.readinessReport.state ?? null,
-      ready: readiness?.readinessReport.ready ?? null,
-      detail: readiness?.readinessReport.detail ?? null
+      state: null,
+      ready: null,
+      detail: null
     });
   }
   const projectOptions = allAgents.map((agent) => agent.projectRoot ?? agent.cwd).filter((root) => typeof root === "string" && root.trim().length > 0).map((root) => {
@@ -94266,6 +95590,7 @@ function fallbackOpenScoutHostInfo(options, currentDirectory) {
 async function createOpenScoutWebServer(options) {
   const shellTtl = options.shellStateCacheTtlMs ?? 15000;
   const currentDirectory = options.currentDirectory;
+  const lanAccessScope = options.lanAccessScope ?? resolveScoutWebLanAccessScope(process.env);
   const pendingPairRequests = createPendingPairRequestStore({
     statePath: pairRequestStatePath(localConfigHome())
   });
@@ -94281,8 +95606,28 @@ async function createOpenScoutWebServer(options) {
     startGlobalHeuristicsWatcher();
   }
   const app = new Hono2;
+  app.use("*", async (c, next) => {
+    const peerAddress = (options.resolvePeerAddress ?? resolveScoutRequestPeerAddress)(c);
+    if (!isScoutWebRequestAllowedFromPeer(c.req.raw, peerAddress, lanAccessScope)) {
+      return c.text("Not Found", 404);
+    }
+    await next();
+  });
   installHttpsEdgeSecurityHeaders(app, options.publicOrigin);
   const shellStateCache = createCachedSnapshot(loadOpenScoutWebShellState, shellTtl);
+  const readAgentConfigurationSnapshot = coalesce(() => buildAgentConfigurationSnapshot(currentDirectory), 30000);
+  const runnerOptionsReaders = new Map;
+  const readRunnerOptions = (scope, projectRoot) => {
+    const key = `${scope}\x00${projectRoot}`;
+    let read = runnerOptionsReaders.get(key);
+    if (!read) {
+      if (runnerOptionsReaders.size >= 32)
+        runnerOptionsReaders.clear();
+      read = coalesce(() => buildHudRunnerOptions(currentDirectory, { scope, projectRoot }), 30000);
+      runnerOptionsReaders.set(key, read);
+    }
+    return read();
+  };
   const agentBrokerContextReader = createAgentBrokerContextReader();
   const agentBrokerHomeReader = createAgentBrokerHomeReader();
   const dispatchBrokerSnapshotCache = createCachedSnapshot(async () => {
@@ -94339,7 +95684,8 @@ async function createOpenScoutWebServer(options) {
   installScoutApiMiddleware(app, "openscout-web api", {
     trustedHosts: options.trustedHosts,
     trustedOrigins: options.trustedOrigins,
-    authToken: options.authToken
+    authToken: options.authToken,
+    resolvePeerAddress: options.resolvePeerAddress
   });
   mountScoutDeckSurfaceRoutes(app, {
     currentDirectory,
@@ -94666,33 +96012,68 @@ async function createOpenScoutWebServer(options) {
     const route = c.req.query("route")?.trim().toLowerCase() ?? null;
     const token = c.req.query("token")?.trim() || null;
     const wantsJson = (c.req.header("accept") ?? "").includes("application/json");
-    const state = await loadPairingState(currentDirectory, true);
+    const peerAddress = (options.resolvePeerAddress ?? resolveScoutRequestPeerAddress)(c);
+    const xff = c.req.header("x-forwarded-for");
+    const forwardedIp = (xff ? xff.split(",").at(-1)?.trim() : null) || c.req.header("x-real-ip")?.trim() || null;
+    const loopbackPeer = Boolean(peerAddress && isLoopbackScoutAddress(peerAddress));
+    const sameMacRequest = isSameMacScoutRequest(c.req.raw, peerAddress);
+    const relayedLanRequest = Boolean(loopbackPeer && c.req.header(SCOUT_PAIR_RELAY_HEADER) === "1");
+    const directLanRequest = Boolean(peerAddress && !isLoopbackScoutAddress(peerAddress));
+    const proxiedLanRequest = Boolean(loopbackPeer && !relayedLanRequest && !sameMacRequest);
+    const unidentifiedPairingIngress = !peerAddress;
+    const requiresApproval = relayedLanRequest || directLanRequest || proxiedLanRequest || unidentifiedPairingIngress;
+    const requesterApp = parseScoutPairClient(c.req.header(SCOUT_PAIR_CLIENT_HEADER), c.req.header("user-agent"));
+    const state = await loadPairingState(currentDirectory, false);
     const location = pickPairingLocation(state, route);
-    if (location) {
-      if (token && !pendingPairRequests.fulfill(token)) {
-        return wantsJson ? c.json({ status: "expired", token }, 410) : c.text("Pairing request expired.", 410);
-      }
-      return c.redirect(location, 302);
-    }
     if (token) {
-      const req2 = pendingPairRequests.get(token);
-      if (!req2) {
+      const request2 = pendingPairRequests.get(token);
+      if (!request2) {
         return wantsJson ? c.json({ status: "expired", token }, 410) : c.text("Pairing request expired.", 410);
       }
-      if (req2.status === "denied") {
+      if (request2.status === "denied") {
         return wantsJson ? c.json({ status: "denied", token }, 403) : c.text("Pairing request was denied.", 403);
       }
+      if (location && request2.status === "approved") {
+        if (!pendingPairRequests.fulfill(token, "approved")) {
+          const current = pendingPairRequests.get(token);
+          if (current?.status === "approved" || current?.status === "pending") {
+            return c.json({ status: current.status, token, pollAfterMs: 1200 }, 202);
+          }
+          if (current?.status === "denied") {
+            return wantsJson ? c.json({ status: "denied", token }, 403) : c.text("Pairing request was denied.", 403);
+          }
+          return wantsJson ? c.json({ status: "expired", token }, 410) : c.text("Pairing request expired.", 410);
+        }
+        return c.redirect(location, 302);
+      }
       pendingPairRequests.touch(token);
-      return c.json({ status: req2.status, token, pollAfterMs: 1200 }, 202);
+      return c.json({ status: request2.status, token, pollAfterMs: 1200 }, 202);
     }
-    const xff = c.req.header("x-forwarded-for");
-    const requesterIp = (xff ? xff.split(",")[0]?.trim() : null) || c.req.header("x-real-ip")?.trim() || null;
-    const req = pendingPairRequests.create({
-      requesterIp,
-      requesterLabel: c.req.header("x-scout-device-name")?.trim() || null,
-      route
-    });
-    return wantsJson ? c.json({ status: "pending", token: req.token, pollAfterMs: 1200 }, 202) : c.text(`${SCOUT_PAIRING_DEEP_LINK_SCHEME}://${SCOUT_PAIRING_DEEP_LINK_PATH} pairing requires approval on the Mac.`, 202);
+    if (location && !requiresApproval) {
+      return c.redirect(location, 302);
+    }
+    const requesterIp = unidentifiedPairingIngress ? null : relayedLanRequest || proxiedLanRequest ? forwardedIp : directLanRequest ? peerAddress ?? null : forwardedIp;
+    if (requiresApproval && !requesterIp) {
+      return wantsJson ? c.json({ status: "unavailable" }, 503) : c.text("Unable to identify pairing requester.", 503);
+    }
+    let request;
+    try {
+      request = pendingPairRequests.create({
+        requesterIp,
+        requesterLabel: c.req.header("x-scout-device-name")?.trim() || null,
+        requesterApp,
+        route
+      });
+    } catch (error) {
+      if (!(error instanceof PairRequestCapacityError))
+        throw error;
+      c.header("retry-after", String(Math.ceil(error.retryAfterMs / 1000)));
+      return wantsJson ? c.json({ status: "busy", retryAfterMs: error.retryAfterMs }, 429) : c.text("Too many pairing requests. Try again shortly.", 429);
+    }
+    if (request.status === "denied") {
+      return wantsJson ? c.json({ status: "denied", token: request.token }, 403) : c.text("Pairing request was denied.", 403);
+    }
+    return wantsJson ? c.json({ status: request.status, token: request.token, pollAfterMs: 1200 }, 202) : c.text(`${SCOUT_PAIRING_DEEP_LINK_SCHEME}://${SCOUT_PAIRING_DEEP_LINK_PATH} pairing requires approval on the Mac.`, 202);
   });
   app.get("/api/notifications", (c) => {
     const rawType = c.req.query("type") ?? "";
@@ -94701,7 +96082,7 @@ async function createOpenScoutWebServer(options) {
     const notifications = includePairingRequests ? pendingPairRequests.list().filter((request) => request.status === "pending").map((request) => ({
       id: `pairing_request:${request.token}`,
       type: "pairing_request",
-      title: `${request.requesterLabel?.trim() || "A device"} wants to pair`,
+      title: `${pairRequesterDisplay(request)} wants to pair`,
       body: `On your network${request.requesterIp ? ` \xB7 ${request.requesterIp}` : ""}.`,
       createdAt: request.createdAt,
       updatedAt: request.updatedAt,
@@ -94791,14 +96172,11 @@ async function createOpenScoutWebServer(options) {
   });
   app.get("/api/shell-state", async (c) => c.json(await shellStateCache.get()));
   app.get("/api/shell-state/refresh", async (c) => c.json(await shellStateCache.refresh()));
-  app.get("/api/agent-config/snapshot", async (c) => c.json(await buildAgentConfigurationSnapshot(currentDirectory)));
+  app.get("/api/agent-config/snapshot", async (c) => c.json(await readAgentConfigurationSnapshot()));
   app.get("/api/runner/options", async (c) => {
     const requestedScope = c.req.query("scope");
     const scope = requestedScope === "global" || requestedScope === "project" || requestedScope === "global+project" ? requestedScope : "global+project";
-    return c.json(await buildHudRunnerOptions(currentDirectory, {
-      scope,
-      projectRoot: c.req.query("projectRoot") || currentDirectory
-    }));
+    return c.json(await readRunnerOptions(scope, c.req.query("projectRoot") || currentDirectory));
   });
   const agentsResponseCache = new Map;
   const readAgentsResponse = (limit, summary, attentionRequested) => {
@@ -94807,7 +96185,7 @@ async function createOpenScoutWebServer(options) {
     if (!entry) {
       if (agentsResponseCache.size >= 32)
         agentsResponseCache.clear();
-      entry = coalesce(() => queryAgentsIncludingBrokerCards(limit, !summary || attentionRequested, attentionRequested, options.captureTmuxPane ?? defaultCaptureTmuxPane, agentBrokerContextReader, agentBrokerHomeReader), 3000);
+      entry = coalesce(() => queryAgentsIncludingBrokerCards(limit, !summary, attentionRequested, options.captureTmuxPane ?? defaultCaptureTmuxPane, agentBrokerContextReader, agentBrokerHomeReader), 3000);
       agentsResponseCache.set(key, entry);
     }
     return entry();
@@ -95580,7 +96958,12 @@ async function createOpenScoutWebServer(options) {
     let messages2;
     try {
       parseMessageHistoryCursor(beforeMessageId);
-      const brokerMessages = cId ? await getScoutConversationMessages(cId, limit, beforeMessageId) : null;
+      const brokerContext = cId ? await loadScoutBrokerContext(undefined, {
+        scope: "conversations",
+        waitForInitial: false,
+        initialRefreshDelayMs: 750
+      }).catch(() => null) : null;
+      const brokerMessages = cId ? await getScoutConversationMessages(cId, limit, beforeMessageId, brokerContext) : null;
       if (cId && brokerMessages && brokerMessages.length > 0 && brokerMessages.length < limit) {
         const oldest = brokerMessages[0];
         const seen = new Set(brokerMessages.map((message) => message.id));
@@ -95953,7 +97336,11 @@ async function createOpenScoutWebServer(options) {
     if (flights.length > 0) {
       return c.json(flights);
     }
-    const broker2 = await loadScoutBrokerContext().catch(() => null);
+    const broker2 = await loadScoutBrokerContext(undefined, {
+      scope: "conversations",
+      waitForInitial: false,
+      initialRefreshDelayMs: 750
+    }).catch(() => null);
     return c.json(broker2 ? queryBrokerFlightsForWeb(broker2, query) : flights);
   });
   app.get("/api/follow", (c) => {
@@ -95970,7 +97357,7 @@ async function createOpenScoutWebServer(options) {
       targetAgentId: c.req.query("targetAgentId") || undefined
     }));
   });
-  const readCommsList = async (c) => {
+  const readCommsList = async (c, options2 = {}) => {
     const rawLimit = Number(c.req.query("limit"));
     const rawKinds = c.req.query("kinds")?.trim();
     const filters = {
@@ -95979,11 +97366,43 @@ async function createOpenScoutWebServer(options) {
       kinds: parseConversationKinds(rawKinds),
       machineId: c.req.query("machineId") || undefined
     };
-    const broker2 = await loadScoutBrokerContext(undefined, filters.machineId ? {} : { scope: "conversations" }).catch(() => null);
+    const preferredProjection = options2.preferMaterialized && !filters.machineId ? await readScoutConversationProjection(160) : undefined;
+    if (preferredProjection?.items.some((item) => item.entityKind === "scout_conversation")) {
+      return {
+        items: provisionalScoutConversations(preferredProjection, filters),
+        listReady: true
+      };
+    }
+    const broker2 = await loadScoutBrokerContext(undefined, filters.machineId ? {} : {
+      scope: "conversations",
+      waitForInitial: false,
+      initialRefreshDelayMs: 750
+    }).catch(() => null);
     if (broker2) {
       const items = await getScoutConversations(filters, broker2);
       return { items, listReady: true };
     }
+    if (!filters.machineId) {
+      const launchProjection = preferredProjection === undefined ? await readScoutConversationProjection(Math.min(160, filters.limit ?? 160)) : preferredProjection;
+      if (launchProjection?.items.some((item) => item.entityKind === "scout_conversation")) {
+        return {
+          items: provisionalScoutConversations(launchProjection, filters),
+          listReady: true
+        };
+      }
+      const projected = querySessions(250);
+      if (projected.length > 0) {
+        const query = filters.query?.trim().toLocaleLowerCase() ?? "";
+        const kinds = filters.kinds ? new Set(filters.kinds) : null;
+        const items = projected.filter((item) => !kinds || kinds.has(item.kind)).filter((item) => !query || [
+          item.title,
+          item.alias,
+          item.agentName,
+          item.preview
+        ].some((value) => value?.toLocaleLowerCase().includes(query))).slice(0, filters.limit ?? projected.length);
+        return { items, listReady: true };
+      }
+    }
     const health = await readScoutBrokerHealth(resolveScoutBrokerUrl(), {
       signal: AbortSignal.timeout(2000)
     });
@@ -95996,7 +97415,7 @@ async function createOpenScoutWebServer(options) {
     retryable: true
   }, 503);
   app.get("/api/comms", async (c) => {
-    const { items, listReady } = await readCommsList(c);
+    const { items, listReady } = await readCommsList(c, { preferMaterialized: true });
     if (!listReady) {
       return unavailableConversationList(c);
     }
@@ -96176,10 +97595,10 @@ async function createOpenScoutWebServer(options) {
         session: conversation
       });
     }
-    const parsedRef = parseSessionRouteRef(refId);
-    const harnessSession = parsedRef ? querySessions(200).find((session3) => sessionHarnessMatches(parsedRef.harness, session3.harness) && parseSessionRouteRef(session3.harnessSessionId)?.refId === parsedRef.refId) : null;
     const payload = await loadSessionRefObservePayload(refId);
     if (payload) {
+      const parsedRef = payload.agentId ? parseSessionRouteRef(refId) : null;
+      const harnessSession = parsedRef ? querySessions(200).find((session3) => sessionHarnessMatches(parsedRef.harness, session3.harness) && parseSessionRouteRef(session3.harnessSessionId)?.refId === parsedRef.refId) : null;
       return c.json({
         kind: "observe",
         refId,
@@ -96204,7 +97623,12 @@ async function createOpenScoutWebServer(options) {
       return c.json({ error: "chatId must be an opaque chat id" }, 400);
     }
     const session3 = querySessionById(resolvedChatId);
-    const conversation = await getScoutConversationById(resolvedChatId);
+    const broker2 = session3 ? await loadScoutBrokerContext(undefined, {
+      scope: "conversations",
+      waitForInitial: false,
+      initialRefreshDelayMs: 750
+    }).catch(() => null) : undefined;
+    const conversation = broker2 === null ? null : broker2 ? (await getScoutConversations({ conversationId: resolvedChatId, limit: 1 }, broker2))[0] ?? null : await getScoutConversationById(resolvedChatId);
     if (session3 && conversation) {
       return c.json({ ...session3, ...conversation });
     }
@@ -97093,6 +98517,8 @@ async function createOpenScoutWebServer(options) {
     const limitParam = parseOptionalPositiveInt3(c.req.query("limit"), 500) ?? 500;
     const includeTranscripts = c.req.query("transcripts") === "true" || c.req.query("transcripts") === "1";
     const mode = c.req.query("mode") === "assistant-replies" ? "assistant-replies" : null;
+    const requestedWindowMs = parseOptionalPositiveInt3(c.req.query("windowMs"));
+    const windowMs = requestedWindowMs === undefined ? undefined : Math.min(requestedWindowMs, 86400000);
     const url = new URL(scoutBrokerPaths.v1.tailRecent, resolveScoutBrokerUrl());
     url.searchParams.set("limit", String(limitParam));
     if (includeTranscripts) {
@@ -97101,7 +98527,10 @@ async function createOpenScoutWebServer(options) {
     if (mode) {
       url.searchParams.set("mode", mode);
     }
-    const cacheKey = `limit=${limitParam};transcripts=${includeTranscripts ? "1" : "0"};mode=${mode ?? "all"}`;
+    if (windowMs !== undefined) {
+      url.searchParams.set("windowMs", String(windowMs));
+    }
+    const cacheKey = `limit=${limitParam};transcripts=${includeTranscripts ? "1" : "0"};mode=${mode ?? "all"};window=${windowMs ?? "all"}`;
     let cache = tailRecentCaches.get(cacheKey);
     if (!cache) {
       cache = createBrokerJsonCache();
@@ -97811,6 +99240,7 @@ function startProcessParentWatchdog(expectedParentPidRaw, options = {}) {
 process.title = "scout-web";
 var port = Number.parseInt(process.env.OPENSCOUT_WEB_PORT ?? process.env.SCOUT_WEB_PORT ?? String(resolveWebPort()), 10);
 var hostname2 = resolveScoutWebBindHost(process.env);
+var lanAccessScope = resolveScoutWebLanAccessScope(process.env);
 var webAuthToken = resolveWebAuthToken(process.env);
 var currentDirectory = resolveOpenScoutSetupContextRoot({
   env: process.env,
@@ -97820,6 +99250,7 @@ var shellStateCacheTtlMs = Number.parseInt(process.env.OPENSCOUT_WEB_SHELL_CACHE
 var providerTelemetryBootstrapEnabled = process.env.OPENSCOUT_WEB_PROVIDER_TELEMETRY_BOOTSTRAP?.trim() === "1";
 var startupWarmupEnabled = process.env.OPENSCOUT_WEB_STARTUP_WARMUP?.trim() === "1";
 var routes = resolveOpenScoutWebRoutes(process.env);
+var requestPeerAddresses = createScoutRequestPeerAddressRegistry();
 function resolveStaticRoot2() {
   if (process.env.OPENSCOUT_WEB_STATIC_ROOT?.trim()) {
     return process.env.OPENSCOUT_WEB_STATIC_ROOT.trim();
@@ -97909,6 +99340,7 @@ var web = await createOpenScoutWebServer({
   trustedHosts: applicationServerIdentity.trustedHosts,
   trustedOrigins: applicationServerIdentity.trustedOrigins,
   authToken: webAuthToken,
+  resolvePeerAddress: requestPeerAddresses.resolve,
   runTerminalCommand: async (request) => {
     const relay = await ensureTerminalRelay();
     if (!relay) {
@@ -97948,6 +99380,9 @@ try {
     async fetch(req, server2) {
       const url = new URL(req.url);
       const peerAddress = server2.requestIP(req)?.address;
+      if (!isScoutWebRequestAllowedFromPeer(req, peerAddress, lanAccessScope)) {
+        return new Response("Not Found", { status: 404 });
+      }
       if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
         let upstreamUrl = null;
         const guardsOrigin = url.pathname === routes.terminalRelayPath || url.pathname === routes.tailStreamPath || url.pathname === routes.eventsStreamPath;
@@ -98003,6 +99438,7 @@ try {
           return headers2;
         })()
       }) : req;
+      requestPeerAddresses.remember(honoRequest, peerAddress);
       const response = await honoFetch(honoRequest, server2);
       if (!bootstrapEligible)
         return response;