@openscout/scout 0.2.95 → 0.2.96

package/dist/pairing-runtime-controller.mjs

@@ -2677,12 +2677,15 @@ var init_host_integrations = () => {};
 // ../protocol/src/native-interactions.ts
 var init_native_interactions = () => {};
 
+// ../protocol/src/session-handle.ts
+var init_session_handle = () => {};
+
 // ../protocol/src/runtime-catalog.generated.ts
 var SCOUT_RUNTIME_CATALOG_DATA;
 var init_runtime_catalog_generated = __esm(() => {
   SCOUT_RUNTIME_CATALOG_DATA = {
     schemaVersion: "openscout.runtime-catalog.v1",
-    revision: "2026-08-18.1",
+    revision: "2026-09-01.1",
     harnesses: [
       {
         id: "claude",
@@ -2706,6 +2709,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",
@@ -3379,6 +3389,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",
@@ -3447,6 +3458,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();
@@ -22839,11 +22851,32 @@ function resolveBundledRuntimeDirFromModuleDir(moduleDir) {
     resolve5(moduleDir, "..", "..")
   ];
   for (const candidate of candidates) {
-    if (isInstalledRuntimePackageDir(candidate))
-      return candidate;
+    if (!isInstalledRuntimePackageDir(candidate))
+      continue;
+    const sourceWorkspaceRuntime = resolveSourceWorkspaceRuntimeDir(candidate);
+    if (sourceWorkspaceRuntime)
+      return sourceWorkspaceRuntime;
+    return candidate;
   }
   return null;
 }
+function resolveSourceWorkspaceRuntimeDir(bundledPackageDir) {
+  const packagesDir = dirname9(bundledPackageDir);
+  if (resolve5(packagesDir, "cli") !== resolve5(bundledPackageDir))
+    return null;
+  const runtimeDir = join19(packagesDir, "runtime");
+  if (!existsSync18(join19(runtimeDir, "src")))
+    return null;
+  if (!isInstalledRuntimePackageDir(runtimeDir))
+    return null;
+  try {
+    const cliPackage = JSON.parse(readFileSync8(join19(bundledPackageDir, "package.json"), "utf8"));
+    const runtimePackage = JSON.parse(readFileSync8(join19(runtimeDir, "package.json"), "utf8"));
+    return cliPackage.name === "@openscout/scout" && runtimePackage.name === "@openscout/runtime" ? runtimeDir : null;
+  } catch {
+    return null;
+  }
+}
 function findWorkspaceRuntimeDir(startDir) {
   let current = resolve5(startDir);
   while (true) {
@@ -35518,7 +35551,10 @@ var agentsTable = sqliteTable("agents", {
   advertiseScope: text("advertise_scope").notNull(),
   ownerId: text("owner_id"),
   metadataJson: text("metadata_json")
-});
+}, (table) => [
+  index("idx_agents_home_node_id").on(table.homeNodeId),
+  index("idx_agents_authority_node_id").on(table.authorityNodeId)
+]);
 var agentEndpointsTable = sqliteTable("agent_endpoints", {
   id: text("id").primaryKey(),
   agentId: text("agent_id").notNull().references(() => agentsTable.id, { onDelete: "cascade" }),
@@ -35534,7 +35570,14 @@ var agentEndpointsTable = sqliteTable("agent_endpoints", {
   metadataJson: text("metadata_json"),
   updatedAt: integer("updated_at").notNull().default(epochMsNow)
 }, (table) => [
-  index("idx_agent_endpoints_agent_updated_at").on(table.agentId, desc(table.updatedAt))
+  index("idx_agent_endpoints_agent_updated_at").on(table.agentId, desc(table.updatedAt)),
+  index("idx_agent_endpoints_roster_recency").on(desc(sql`CASE
+      WHEN ${table.updatedAt} IS NULL THEN NULL
+      WHEN CAST(${table.updatedAt} AS REAL) < 1000000000000
+        THEN CAST(CAST(${table.updatedAt} AS REAL) * 1000 AS INTEGER)
+      ELSE CAST(${table.updatedAt} AS INTEGER)
+    END`), table.agentId),
+  index("idx_agent_endpoints_node_id").on(table.nodeId)
 ]);
 var runtimeSessionsTable = sqliteTable("runtime_sessions", {
   id: text("id").primaryKey(),
@@ -35558,6 +35601,7 @@ var runtimeSessionsTable = sqliteTable("runtime_sessions", {
 }, (table) => [
   index("idx_runtime_sessions_agent_last_seen").on(table.agentId, desc(table.lastSeenAt)),
   index("idx_runtime_sessions_endpoint_last_seen").on(table.endpointId, desc(table.lastSeenAt)),
+  index("idx_runtime_sessions_node_id").on(table.nodeId),
   index("idx_runtime_sessions_external").on(table.externalSessionId),
   index("idx_runtime_sessions_expires").on(table.expiresAt).where(sql`expires_at IS NOT NULL`)
 ]);
@@ -35577,6 +35621,8 @@ var runtimeSessionAliasesTable = sqliteTable("runtime_session_aliases", {
   primaryKey({ columns: [table.alias, table.sessionId] }),
   index("idx_runtime_session_aliases_alias").on(table.alias, desc(table.lastSeenAt)),
   index("idx_runtime_session_aliases_session").on(table.sessionId),
+  index("idx_runtime_session_aliases_endpoint").on(table.endpointId),
+  index("idx_runtime_session_aliases_node_id").on(table.nodeId),
   index("idx_runtime_session_aliases_expires").on(table.expiresAt).where(sql`expires_at IS NOT NULL`)
 ]);
 var routeAliasBindingsTable = sqliteTable("route_alias_bindings", {
@@ -35656,7 +35702,8 @@ var conversationMembersTable = sqliteTable("conversation_members", {
   actorId: text("actor_id").notNull().references(() => actorsTable.id, { onDelete: "cascade" }),
   role: text("role")
 }, (table) => [
-  primaryKey({ columns: [table.conversationId, table.actorId] })
+  primaryKey({ columns: [table.conversationId, table.actorId] }),
+  index("idx_conversation_members_actor").on(table.actorId, table.conversationId)
 ]);
 var messagesTable = sqliteTable("messages", {
   id: text("id").primaryKey(),
@@ -35676,7 +35723,8 @@ var messagesTable = sqliteTable("messages", {
 }, (table) => [
   index("idx_messages_conversation_created_at").on(table.conversationId, table.createdAt),
   index("idx_messages_created_at").on(desc(table.createdAt)),
-  index("idx_messages_actor_created_at").on(table.actorId, desc(table.createdAt))
+  index("idx_messages_actor_created_at").on(table.actorId, desc(table.createdAt)),
+  index("idx_messages_origin_node_id").on(table.originNodeId)
 ]);
 var messageMentionsTable = sqliteTable("message_mentions", {
   messageId: text("message_id").notNull().references(() => messagesTable.id, { onDelete: "cascade" }),
@@ -35705,7 +35753,102 @@ var conversationReadCursorsTable = sqliteTable("conversation_read_cursors", {
   metadataJson: text("metadata_json")
 }, (table) => [
   primaryKey({ columns: [table.conversationId, table.actorId] }),
-  index("idx_read_cursors_conversation_updated_at").on(table.conversationId, desc(table.updatedAt))
+  index("idx_read_cursors_conversation_updated_at").on(table.conversationId, desc(table.updatedAt)),
+  index("idx_read_cursors_reader_node_id").on(table.readerNodeId)
+]);
+var 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()
+});
+var 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()
+}, (table) => [
+  check("conversation_projection_meta_singleton_check", sql`${table.singleton} = 1`)
+]);
+var 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()
+}, (table) => [
+  check("conversation_projection_items_entity_kind_check", sql`${table.entityKind} IN ('scout_conversation', 'observed_session')`),
+  check("conversation_projection_items_visibility_check", sql`${table.visibilityState} IN ('visible', 'hidden')`),
+  index("idx_conversation_projection_recent").on(table.visibilityState, desc(table.lastActivityAt), table.feedId),
+  index("idx_conversation_projection_project_recent").on(table.projectRoot, table.visibilityState, desc(table.lastActivityAt)),
+  index("idx_conversation_projection_engaged").on(table.visibilityState, desc(table.lastEngagedAt), desc(table.lastActivityAt), table.feedId),
+  index("idx_conversation_projection_source_fresh").on(table.visibilityState, desc(table.sourceFreshAt)),
+  index("idx_conversation_projection_runtime_session").on(table.entityKind, table.runtimeSessionId),
+  index("idx_conversation_projection_source_session").on(table.entityKind, table.sourceSessionId),
+  uniqueIndex("idx_conversation_projection_conversation").on(table.conversationId).where(sql`conversation_id IS NOT NULL`)
+]);
+var 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()
+}, (table) => [
+  index("idx_conversation_projection_message_facts_conversation").on(table.conversationId, table.createdAt, table.messageId)
+]);
+var 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")
+});
+var 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()
+}, (table) => [
+  primaryKey({ columns: [table.source, table.sourceSessionId] }),
+  index("idx_conversation_projection_sources_feed").on(table.feedId)
+]);
+var 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()
+}, (table) => [
+  index("idx_conversation_projection_events_projection_seq").on(table.projectionId, table.seq),
+  index("idx_conversation_projection_events_ts").on(table.ts)
 ]);
 var invocationsTable = sqliteTable("invocations", {
   id: text("id").primaryKey(),
@@ -35737,7 +35880,10 @@ var invocationsTable = sqliteTable("invocations", {
   executionResolutionJson: text("execution_resolution_json")
 }, (table) => [
   index("idx_invocations_target_created_at").on(table.targetAgentId, table.createdAt),
-  index("idx_invocations_requester_created_at").on(table.requesterId, desc(table.createdAt))
+  index("idx_invocations_requester_created_at").on(table.requesterId, desc(table.createdAt)),
+  index("idx_invocations_conversation_created_at").on(table.conversationId, desc(table.createdAt)),
+  index("idx_invocations_requester_node_id").on(table.requesterNodeId),
+  index("idx_invocations_target_node_id").on(table.targetNodeId)
 ]);
 var flightsTable = sqliteTable("flights", {
   id: text("id").primaryKey(),
@@ -35783,7 +35929,8 @@ var deliveriesTable = sqliteTable("deliveries", {
   createdAt: integer("created_at").notNull().default(epochMsNow)
 }, (table) => [
   index("idx_deliveries_status_transport").on(table.status, table.transport),
-  index("idx_deliveries_created_at").on(desc(table.createdAt))
+  index("idx_deliveries_created_at").on(desc(table.createdAt)),
+  index("idx_deliveries_target_node_id").on(table.targetNodeId)
 ]);
 var deliveryAttemptsTable = sqliteTable("delivery_attempts", {
   id: text("id").primaryKey(),
@@ -35953,7 +36100,8 @@ var threadEventsTable = sqliteTable("thread_events", {
 }, (table) => [
   unique2().on(table.conversationId, table.seq),
   index("idx_thread_events_conversation_seq").on(table.conversationId, desc(table.seq)),
-  index("idx_thread_events_conversation_ts").on(table.conversationId, desc(table.ts))
+  index("idx_thread_events_conversation_ts").on(table.conversationId, desc(table.ts)),
+  index("idx_thread_events_authority_node_id").on(table.authorityNodeId)
 ]);
 var threadCursorsTable = sqliteTable("thread_cursors", {
   conversationId: text("conversation_id").notNull().references(() => conversationsTable.id, { onDelete: "cascade" }),
@@ -35961,7 +36109,8 @@ var threadCursorsTable = sqliteTable("thread_cursors", {
   lastAppliedSeq: integer("last_applied_seq").notNull(),
   updatedAt: integer("updated_at").notNull()
 }, (table) => [
-  primaryKey({ columns: [table.conversationId, table.authorityNodeId] })
+  primaryKey({ columns: [table.conversationId, table.authorityNodeId] }),
+  index("idx_thread_cursors_authority_node_id").on(table.authorityNodeId)
 ]);
 var scoutDispatchesTable = sqliteTable("scout_dispatches", {
   id: text("id").primaryKey(),
@@ -36189,6 +36338,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
@@ -36198,6 +36349,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;
@@ -36420,6 +36575,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,
@@ -36827,18 +37069,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
@@ -36847,6 +37145,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
@@ -36893,6 +37193,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
@@ -50353,12 +50657,24 @@ var meshPeerFetch = createMeshPeerFetch();
 init_tailscale();
 // ../runtime/src/iroh-bridge.ts
 init_support_paths();
+
+// ../runtime/src/mesh-forwarding.ts
+var MAX_PEER_AGENT_SNAPSHOT_BYTES = 2 * 1024 * 1024;
 // ../runtime/src/mesh-rendezvous.ts
 init_src();
 init_broker_process_manager();
 init_open_scout_network();
 var DEFAULT_RENDEZVOUS_TTL_MS = 60000;
 var DEFAULT_RENDEZVOUS_INTERVAL_MS = 30000;
+
+class MeshRendezvousPublishError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "MeshRendezvousPublishError";
+  }
+}
 function resolveMeshRendezvousPublishConfig(env = process.env, options = {}) {
   const explicitUrl = env.OPENSCOUT_MESH_RENDEZVOUS_URL?.trim();
   if (explicitUrl?.toLowerCase() === "false" || explicitUrl === "0") {
@@ -50372,6 +50688,10 @@ function resolveMeshRendezvousPublishConfig(env = process.env, options = {}) {
   }
   const token = env.OPENSCOUT_MESH_RENDEZVOUS_TOKEN?.trim() || undefined;
   const sessionToken = env.OPENSCOUT_MESH_RENDEZVOUS_SESSION?.trim() || undefined;
+  const allowAnonymous = readBooleanFlag(env.OPENSCOUT_MESH_RENDEZVOUS_ALLOW_ANONYMOUS);
+  if (!token && !sessionToken && !allowAnonymous) {
+    return;
+  }
   return {
     url: rawUrl.replace(/\/$/, ""),
     token,
@@ -50413,15 +50733,16 @@ async function publishMeshRendezvousPresence(node, options) {
   });
   if (!response.ok) {
     const detail = await response.text().catch(() => "");
-    throw new Error(`rendezvous publish failed: ${response.status} ${response.statusText}${detail ? ` ${detail}` : ""}`);
+    throw new MeshRendezvousPublishError(response.status, `rendezvous publish failed: ${response.status} ${response.statusText}${detail ? ` ${detail}` : ""}`);
   }
   return true;
 }
 function startMeshRendezvousPublisher(node, options) {
   let stopped2 = false;
+  let suspendedForAuth = false;
   let inFlight = null;
   const publishNow = async () => {
-    if (stopped2)
+    if (stopped2 || suspendedForAuth)
       return;
     if (inFlight) {
       await inFlight;
@@ -50432,6 +50753,11 @@ function startMeshRendezvousPublisher(node, options) {
         options.logger?.log(`[openscout-runtime] published mesh rendezvous presence to ${options.config.url}`);
       }
     }).catch((error) => {
+      if (error instanceof MeshRendezvousPublishError && (error.status === 401 || error.status === 403)) {
+        suspendedForAuth = true;
+        options.logger?.warn(`[openscout-runtime] mesh rendezvous authentication rejected; publishing is suspended until restart: ${error.message}`);
+        return;
+      }
       options.logger?.warn(`[openscout-runtime] mesh rendezvous publish failed: ${error instanceof Error ? error.message : String(error)}`);
     }).finally(() => {
       inFlight = null;
@@ -50493,6 +50819,9 @@ function readPositiveInteger(value, fallback2) {
   const parsed = Number.parseInt(value ?? "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback2;
 }
+function readBooleanFlag(value) {
+  return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? "");
+}
 
 // ../runtime/src/index.ts
 init_node_identity();
@@ -54697,6 +55026,7 @@ var pairingLog = {
 };
 
 // ../web/server/core/pairing/runtime/relay/relay.ts
+init_local_config();
 var BRIDGE_ABSENCE_GRACE_MS = 30000;
 var ROOM_IDLE_TIMEOUT_MS = 60000;
 function startRelay(port, options = {}) {
@@ -54713,6 +55043,9 @@ function startRelay(port, options = {}) {
     } : {},
     fetch(req, server2) {
       const url = new URL(req.url);
+      if (url.pathname === "/pair" && req.method === "GET") {
+        return proxyPairHttp(req, url, options.pairHttpOrigin, server2.requestIP(req)?.address);
+      }
       if (url.pathname === "/resolve" && req.method === "POST") {
         return handleResolve(req, roomByBridgeKey, rooms);
       }
@@ -54856,6 +55189,46 @@ function startRelay(port, options = {}) {
     }
   };
 }
+async function proxyPairHttp(req, url, pairHttpOrigin, clientIp) {
+  const origin = pairHttpOrigin === undefined ? `http://127.0.0.1:${resolveWebPort()}` : pairHttpOrigin?.trim() || null;
+  if (!origin) {
+    return new Response("Pairing HTTP is not configured", { status: 503 });
+  }
+  const target2 = new URL("/pair", origin);
+  target2.search = url.search;
+  const headers2 = new Headers;
+  for (const name2 of ["accept", "user-agent", "x-scout-client", "x-scout-device-name"]) {
+    const value = req.headers.get(name2);
+    if (value)
+      headers2.set(name2, value);
+  }
+  headers2.set("x-scout-pair-relay", "1");
+  if (clientIp) {
+    headers2.set("x-forwarded-for", clientIp);
+    headers2.set("x-real-ip", clientIp);
+  }
+  try {
+    const response = await fetch(target2, {
+      method: "GET",
+      headers: headers2,
+      redirect: "manual",
+      signal: AbortSignal.timeout(3000)
+    });
+    const out = new Headers;
+    const location = response.headers.get("location");
+    if (location)
+      out.set("location", location);
+    const cacheControl = response.headers.get("cache-control");
+    if (cacheControl)
+      out.set("cache-control", cacheControl);
+    const contentType = response.headers.get("content-type");
+    if (contentType)
+      out.set("content-type", contentType);
+    return new Response(response.body, { status: response.status, headers: out });
+  } catch {
+    return new Response("Pairing service unreachable", { status: 502 });
+  }
+}
 async function handleResolve(req, roomByBridgeKey, rooms) {
   try {
     const body = await req.json();
@@ -59215,7 +59588,8 @@ var SCOUT_API_LOG_ALL = process.env.SCOUT_PERF_LOG_API === "1";
 // ../web/server/core/broker/service.ts
 var DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS = 24 * 60 * 60 * 1000;
 var DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS = 60 * 1000;
-var SCOUT_BROKER_CONTEXT_CACHE_TTL_MS = 5000;
+var SCOUT_BROKER_CONTEXT_CACHE_TTL_MS = 30000;
+var SCOUT_BROKER_CONTEXT_STALE_RETENTION_MS = 60000;
 var scoutBrokerContextCache = new Map;
 function invalidateScoutBrokerContextCache(baseUrl) {
   const prefix = [baseUrl, resolveBrokerSocketPathForBaseUrl(baseUrl) ?? "http"].join("\x00") + "\x00";
@@ -59532,26 +59906,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;
@@ -59575,19 +59947,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((resolve15) => setTimeout(resolve15, 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);
@@ -60674,14 +61087,71 @@ function staleFlightActivityPredicate(alias) {
 }
 
 // ../web/server/db/agents.ts
+var actorCreatedAtExpression = sqlTimestampMsExpression("ac.created_at");
+var endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+var 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}`;
+var 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 ?`;
+})();
+var 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");
 function queryAgentIdsByEndpointSessionId() {
-  const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+  const endpointUpdatedAtExpression2 = sqlTimestampMsExpression("ep.updated_at");
   const rows = db().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();
@@ -60865,8 +61335,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
@@ -60928,7 +61398,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);
@@ -60941,10 +61412,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";
   }
@@ -60988,34 +61459,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
@@ -61088,7 +61532,7 @@ function resolveAgentConversationId(agentId) {
   return recent?.conversation_id ?? null;
 }
 function queryMobileAgentDetail(agentId) {
-  const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+  const endpointUpdatedAtExpression2 = sqlTimestampMsExpression("ep.updated_at");
   const row = db().prepare(`SELECT
        a.id,
        ac.display_name,
@@ -61102,7 +61546,7 @@ function queryMobileAgentDetail(agentId) {
        ep.project_root,
        ep.cwd,
        ep.session_id,
-       ${endpointUpdatedAtExpression} AS updated_at
+       ${endpointUpdatedAtExpression2} AS updated_at
      FROM agents a
      JOIN actors ac ON ac.id = a.id
      ${LATEST_AGENT_ENDPOINT_JOIN}
@@ -61246,7 +61690,7 @@ init_pi_rpc();
 init_system_probes();
 import { createHash as createHash6 } from "crypto";
 import { existsSync as existsSync35, mkdirSync as mkdirSync16, readdirSync as readdirSync5, readFileSync as readFileSync21, renameSync as renameSync5, statSync as statSync10, writeFileSync as writeFileSync12 } from "fs";
-import { open } from "fs/promises";
+import { open, readdir as readdir4, stat as stat6 } from "fs/promises";
 import { homedir as homedir33 } from "os";
 import { dirname as dirname21, join as join41 } from "path";
 import { createInterface as createInterface2 } from "readline";
@@ -61254,6 +61698,10 @@ import { Database as Database3 } from "bun:sqlite";
 var CACHE_TTL_MS = 60 * 1000;
 var WEEK_MS = 7 * 24 * 3600 * 1000;
 var CODEX_LOOKBACK_DAYS = 3;
+var CODEX_JSONL_TAIL_MAX_BYTES = 2 * 1024 * 1024;
+var CODEX_INITIAL_FILE_LIMIT = 32;
+var CODEX_RECENT_CANDIDATE_LIMIT = 64;
+var CODEX_JSONL_READ_CONCURRENCY = 8;
 var LOCAL_QUOTA_FRESH_MS = 2 * 60 * 1000;
 var REMOTE_QUOTA_FRESH_MS = 5 * 60 * 1000;
 var GH_CLI_TIMEOUT_MS = 4000;
@@ -61352,12 +61800,14 @@ async function loadCodexGauge(forceRefresh = false) {
   const root = join41(homeDir(), ".codex", "sessions");
   if (!existsSync35(root))
     return fallback2;
-  const recent = findRecentCodexJsonl(root, CODEX_LOOKBACK_DAYS);
-  if (recent.length === 0)
+  const candidates = await findRecentCodexJsonl(root, CODEX_LOOKBACK_DAYS);
+  if (candidates.length === 0)
     return fallback2;
-  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 fallback2;
+  if (!observations.some(isCodexAccountPoolObservation))
+    return fallback2;
   const snapshots = bindingCodexPoolSnapshots(observations.flatMap((observation) => codexQuotaSnapshotsFromObservation(observation.usage, observation.capturedAt)));
   persistQuotaSnapshots(snapshots);
   const persisted = loadPersistedProviderQuotaGauge({
@@ -61414,9 +61864,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));
@@ -61433,37 +61885,83 @@ function formatQuotaWindowLabel(windowMinutes, fallback2) {
   }
   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 entries;
     try {
-      entries = readdirSync5(dir, { withFileTypes: true });
+      entries = await readdir4(dir, { withFileTypes: true });
     } catch {
-      return;
+      continue;
     }
     for (const entry of entries) {
       const full = join41(dir, entry.name);
       if (entry.isDirectory()) {
-        walk(full);
+        pending.push(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        const stat6 = safeStat(full);
-        if (!stat6 || stat6.mtimeMs < cutoffMs)
-          continue;
-        paths2.push({ path: full, mtimeMs: stat6.mtimeMs });
+        try {
+          const fileStat = await stat6(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 open(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 {
@@ -61540,8 +62038,8 @@ function loadClaudeStatuslineQuotaSnapshots() {
 }
 function readClaudeStatuslineHistory(minCapturedAt) {
   const path2 = join41(claudeStatuslineDir(), "claude-history.jsonl");
-  const stat6 = safeStat(path2);
-  if (!stat6)
+  const stat7 = safeStat(path2);
+  if (!stat7)
     return [];
   let content;
   try {
@@ -61549,7 +62047,7 @@ function readClaudeStatuslineHistory(minCapturedAt) {
   } catch {
     return [];
   }
-  if (stat6.size > CLAUDE_STATUSLINE_HISTORY_MAX_BYTES) {
+  if (stat7.size > CLAUDE_STATUSLINE_HISTORY_MAX_BYTES) {
     content = content.slice(-CLAUDE_STATUSLINE_HISTORY_MAX_BYTES);
     const firstNewline = content.indexOf(`
 `);
@@ -62128,11 +62626,11 @@ async function loadGrokGauge() {
 }
 async function loadGrokBillingQuotaSnapshots() {
   const path2 = join41(homeDir(), ".grok", "logs", "unified.jsonl");
-  const stat6 = safeStat(path2);
-  if (!stat6 || stat6.size <= 0)
+  const stat7 = safeStat(path2);
+  if (!stat7 || stat7.size <= 0)
     return [];
-  const length = Math.min(stat6.size, GROK_BILLING_LOG_MAX_BYTES);
-  const start = Math.max(0, stat6.size - length);
+  const length = Math.min(stat7.size, GROK_BILLING_LOG_MAX_BYTES);
+  const start = Math.max(0, stat7.size - length);
   let content = "";
   let handle;
   try {
@@ -62659,11 +63157,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) {
@@ -65834,8 +66334,8 @@ async function handleRPCInner(bridge, req, rpcContext = {}) {
         }
         const root = resolveWorkspaceRoot(configuredRoot);
         const projectPath = resolveWorkspacePath(root, p.path);
-        const stat6 = statSync13(projectPath);
-        if (!stat6.isDirectory()) {
+        const stat7 = statSync13(projectPath);
+        if (!stat7.isDirectory()) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
         const adapterType = p.adapter ?? "claude-code";
@@ -66305,8 +66805,8 @@ function listDirectories(dirPath) {
       continue;
     const fullPath = join46(dirPath, name2);
     try {
-      const stat6 = statSync13(fullPath);
-      if (!stat6.isDirectory())
+      const stat7 = statSync13(fullPath);
+      if (!stat7.isDirectory())
         continue;
       const children = new Set(readdirSync6(fullPath));
       const markers = [];
@@ -80941,8 +81441,8 @@ function listDirectories2(dirPath) {
       continue;
     const fullPath = join47(dirPath, name2);
     try {
-      const stat6 = statSync14(fullPath);
-      if (!stat6.isDirectory())
+      const stat7 = statSync14(fullPath);
+      if (!stat7.isDirectory())
         continue;
       const children = new Set(readdirSync7(fullPath));
       const markers = [];
@@ -81619,8 +82119,8 @@ var workspaceRouter = t.router({
     }
     const root = resolveWorkspaceRoot2(configuredRoot);
     const projectPath = resolveWorkspacePath2(root, input.path);
-    const stat6 = statSync14(projectPath);
-    if (!stat6.isDirectory()) {
+    const stat7 = statSync14(projectPath);
+    if (!stat7.isDirectory()) {
       throw new TRPCError({
         code: "BAD_REQUEST",
         message: "Workspace target is not a directory"