@adhdev/daemon-core 0.9.82-rc.472 → 0.9.82-rc.474

package/dist/mesh/mesh-missions.d.ts

@@ -91,6 +91,18 @@ export declare const GOAL_PREVIEW_MAX = 120;
  * tighter than the dashboard / mesh_mission_list preview (GOAL_PREVIEW_MAX).
  */
 export declare const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
+/**
+ * mesh_mission_list default fold sizes. Without an explicit `statuses` filter the
+ * tool returns non-terminal (active/paused) missions in full detail but folds the
+ * completed/abandoned history into counts + a capped newest-first id list — a mesh
+ * can accumulate hundreds of terminal missions and returning them all (each with a
+ * ledger-scanned stats rollup) blew past the tool payload / token budget and spilled
+ * to a file. When an explicit `statuses` filter IS given, the matching missions are
+ * returned in detail but still bounded by MESH_MISSION_LIST_STATUS_LIMIT so a
+ * status:["completed"] call on a huge history stays bounded (overflow → truncated).
+ */
+export declare const MESH_MISSION_LIST_HISTORY_ID_LIMIT = 30;
+export declare const MESH_MISSION_LIST_STATUS_LIMIT = 50;
 export declare function upsertMeshMission(meshId: string, input: {
     id?: string;
     title: string;
@@ -218,6 +230,49 @@ export declare function listMeshMissionSummaries(meshId: string, options?: {
     verbose?: boolean;
     includeMagi?: boolean;
 }): MeshMissionSummary[] | MeshMissionSlimSummary[];
+/** Shaped mesh_mission_list result: bounded detail list + optional folded history. */
+export interface MeshMissionListResult {
+    /** Detailed (slim or verbose) mission summaries — bounded, newest-first. */
+    missions: MeshMissionSummary[] | MeshMissionSlimSummary[];
+    /**
+     * Completed/abandoned missions folded to counts + ids. Present (default path)
+     * when no explicit status filter is given and terminal missions exist. Null when
+     * an explicit status filter is active (those missions go into `missions`).
+     */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+    /** True when an explicit status filter matched more than `limit` missions. */
+    truncated: boolean;
+    /** Total missions matching the query BEFORE the detail-list cap was applied. */
+    matched: number;
+    /** Newest-first ids of missions dropped by the detail-list cap (truncated path). */
+    overflowIds?: string[];
+}
+/**
+ * mesh_mission_list projection: payload-bounded regardless of mesh mission count.
+ *
+ * Default (no explicit `statuses`): non-terminal missions (active/paused) return in
+ * detail; completed/abandoned missions are folded to counts + a capped id list
+ * (historyFold), NOT emitted one-by-one. This is what keeps the tool from returning
+ * hundreds of terminal missions (each with a ledger stats rollup) and overflowing the
+ * token budget.
+ *
+ * Explicit `statuses` (e.g. ["completed"]): the coordinator asked to see those
+ * missions, so they ARE returned in detail — but still bounded by `limit` (default
+ * MESH_MISSION_LIST_STATUS_LIMIT). Overflow beyond `limit` is reported via
+ * truncated:true + overflowIds rather than silently dropped.
+ *
+ * MAGI + verbose semantics match listMeshMissionSummaries. `withStats` opts each
+ * detailed mission into the ledger-scanned stats rollup (off by default — the tasks
+ * aggregate is enough for a list view).
+ */
+export declare function listMeshMissionsForTool(meshId: string, options?: {
+    statuses?: MeshMissionStatus[];
+    verbose?: boolean;
+    includeMagi?: boolean;
+    withStats?: boolean;
+    limit?: number;
+    historyIdLimit?: number;
+}): MeshMissionListResult;
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.472",
+  "version": "0.9.82-rc.474",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.472",
-    "@adhdev/session-host-core": "0.9.82-rc.472",
+    "@adhdev/mesh-shared": "0.9.82-rc.474",
+    "@adhdev/session-host-core": "0.9.82-rc.474",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/index.ts

@@ -228,8 +228,8 @@ export type { CanonicalMeshToolName } from '@adhdev/mesh-shared';
 
 // ── Mesh Coordinator ──
 export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
-export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
-export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate, MeshStatusMissionsCompact, MeshStatusMissionsHistoryFold } from './mesh/mesh-missions.js';
+export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, listMeshMissionsForTool, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_LIST_HISTORY_ID_LIMIT, MESH_MISSION_LIST_STATUS_LIMIT, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
+export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate, MeshStatusMissionsCompact, MeshStatusMissionsHistoryFold, MeshMissionListResult } from './mesh/mesh-missions.js';
 export { computeMeshTaskStats, computeMeshMissionStats } from './mesh/mesh-task-stats.js';
 export type { MeshTaskStats, MeshMissionStats } from './mesh/mesh-task-stats.js';
 export { deriveMeshReviewInboxItems } from './mesh/mesh-review-inbox.js';
@@ -303,6 +303,11 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // ── Mesh Events ──
 export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, requeueHeldMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent, MeshHeldEventRequeueFilter, MeshHeldEventRequeueResult } from './mesh/mesh-events.js';
+// COORD-EVENT-MISROUTE: coordinator-identity helper so the mcp-server drain path can build a
+// session-scoped drainer identity (identityDeliversTo sibling-session filter) with the same
+// canonical builder daemon-core uses internally, instead of hand-rolling the identity shape.
+export { coordinatorIdentityFromEmitFields } from './mesh/contracts.js';
+export type { CoordinatorIdentity } from './mesh/contracts.js';
 // The coordinator-side preview surfaced from a worker's completion/status event
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile
 // inbox is fed; reused by mesh_read_chat's cache fallback when the live P2P read path

package/src/mesh/mesh-completion-synthesis.ts

@@ -327,7 +327,23 @@ export async function reconcileUnterminatedDirectDispatches(
         }
 
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
-        const coordinatorDaemonId = selfIds.find(id => !!id);
+        // COORD-EVENT-MISROUTE (anchor preservation): the coordinator DAEMON anchor for the
+        // synthesized completion is the daemon that DISPATCHED the task, NOT this reconcile
+        // runner's own daemon. On a REMOTE worker the reconcile loop runs on the WORKER's daemon,
+        // so `selfIds` is the worker daemon — stamping it as targetCoordinatorDaemonId corrupts the
+        // anchor and (when the real coordinator is on another machine) downgrades the completion to
+        // a cross-machine broadcast deliverable to any coordinator. Recover the true anchor:
+        //   1. the live worker session's meshCoordinatorDaemonId relay stamp (set at dispatch,
+        //      the same anchor the worker's own real-emit path reads in mesh-event-forwarding); then
+        //   2. leave it to reconcileDirectDispatchCompletionFromTranscript, which recovers the
+        //      DISPATCHING coordinator daemon from the task_dispatched ledger (authoritative).
+        // Only when NEITHER is available do we fall back to selfIds — a genuinely local,
+        // single-daemon dispatch where self IS the coordinator daemon (unchanged behaviour).
+        const workerSession = components.instanceManager.getInstance(sessionId);
+        const workerCoordinatorDaemonId = readNonEmptyString(
+            (workerSession?.getState()?.settings as Record<string, unknown> | undefined)?.meshCoordinatorDaemonId,
+        );
+        const coordinatorDaemonId = workerCoordinatorDaemonId || selfIds.find(id => !!id);
         try {
             const result = reconcileDirectDispatchCompletionFromTranscript({
                 meshId: mesh.id,
@@ -338,6 +354,8 @@ export async function reconcileUnterminatedDirectDispatches(
                 taskId,
                 finalSummary: evidence.finalSummary,
                 ...(evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {}),
+                // The ledger-recovered dispatching-coordinator daemon (inside the reconcile fn)
+                // takes PRIORITY over this arg; this remains the best-available fallback.
                 ...(coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {}),
                 source: 'daemon_reconcile_transcript_completion',
             });

package/src/mesh/mesh-events-stale.ts

@@ -345,6 +345,18 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     // Absent on legacy rows → undefined → daemon-level routing (unchanged, no regression).
     const targetCoordinatorSessionId = readNonEmptyString(args.targetCoordinatorSessionId)
         || readNonEmptyString(dispatch?.payload?.coordinatorSessionId);
+    // COORD-EVENT-MISROUTE (anchor preservation): the DISPATCHING coordinator's daemon anchor.
+    // Prefer the DISPATCH LEDGER's `coordinatorDaemonId` (the daemon that ISSUED the task) over the
+    // caller-supplied arg — the synth caller (mesh-completion-synthesis) resolves the arg from its
+    // OWN selfIds, which on a remote worker's reconcile is the WORKER daemon, not the coordinator.
+    // Using the worker's self-daemon as the anchor makes coordinatorIdentityFromEmitFields treat
+    // the completion as addressed to the worker daemon; when the coordinator lives on a DIFFERENT
+    // machine that anchor never matches, selfFallback fires and stampPendingEventV2 broadcasts the
+    // completion to ANY coordinator (contracts.ts shouldDeliverPendingEventToCoordinator → true for
+    // broadcast), the cross-machine misroute. The ledger value is the authoritative issuing-daemon
+    // anchor. Absent on legacy rows → fall back to the arg → daemon-level routing (no regression).
+    const targetCoordinatorDaemonId = readNonEmptyString(dispatch?.payload?.coordinatorDaemonId)
+        || readNonEmptyString(args.targetCoordinatorDaemonId);
     queuePendingMeshCoordinatorEvent({
         event: eventName,
         meshId: args.meshId,
@@ -353,7 +365,7 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         metadataEvent,
         coordinatorMessage: buildMeshSystemMessage({ event: eventName, nodeLabel, metadataEvent }),
         queuedAt: Date.now(),
-        ...(readNonEmptyString(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString(args.targetCoordinatorDaemonId) } : {}),
+        ...(targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {}),
         ...(targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}),
     });
 

package/src/mesh/mesh-missions.ts

@@ -120,6 +120,19 @@ export const GOAL_PREVIEW_MAX = 120;
  */
 export const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
 
+/**
+ * mesh_mission_list default fold sizes. Without an explicit `statuses` filter the
+ * tool returns non-terminal (active/paused) missions in full detail but folds the
+ * completed/abandoned history into counts + a capped newest-first id list — a mesh
+ * can accumulate hundreds of terminal missions and returning them all (each with a
+ * ledger-scanned stats rollup) blew past the tool payload / token budget and spilled
+ * to a file. When an explicit `statuses` filter IS given, the matching missions are
+ * returned in detail but still bounded by MESH_MISSION_LIST_STATUS_LIMIT so a
+ * status:["completed"] call on a huge history stays bounded (overflow → truncated).
+ */
+export const MESH_MISSION_LIST_HISTORY_ID_LIMIT = 30;
+export const MESH_MISSION_LIST_STATUS_LIMIT = 50;
+
 function normalizeMissionStatus(value: unknown): MeshMissionStatus {
     return MESH_MISSION_STATUSES.includes(value as MeshMissionStatus)
         ? value as MeshMissionStatus
@@ -542,6 +555,120 @@ export function listMeshMissionSummaries(
     return options?.verbose ? full : full.map(summary => slimMissionSummary(summary));
 }
 
+/** Shaped mesh_mission_list result: bounded detail list + optional folded history. */
+export interface MeshMissionListResult {
+    /** Detailed (slim or verbose) mission summaries — bounded, newest-first. */
+    missions: MeshMissionSummary[] | MeshMissionSlimSummary[];
+    /**
+     * Completed/abandoned missions folded to counts + ids. Present (default path)
+     * when no explicit status filter is given and terminal missions exist. Null when
+     * an explicit status filter is active (those missions go into `missions`).
+     */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+    /** True when an explicit status filter matched more than `limit` missions. */
+    truncated: boolean;
+    /** Total missions matching the query BEFORE the detail-list cap was applied. */
+    matched: number;
+    /** Newest-first ids of missions dropped by the detail-list cap (truncated path). */
+    overflowIds?: string[];
+}
+
+/**
+ * mesh_mission_list projection: payload-bounded regardless of mesh mission count.
+ *
+ * Default (no explicit `statuses`): non-terminal missions (active/paused) return in
+ * detail; completed/abandoned missions are folded to counts + a capped id list
+ * (historyFold), NOT emitted one-by-one. This is what keeps the tool from returning
+ * hundreds of terminal missions (each with a ledger stats rollup) and overflowing the
+ * token budget.
+ *
+ * Explicit `statuses` (e.g. ["completed"]): the coordinator asked to see those
+ * missions, so they ARE returned in detail — but still bounded by `limit` (default
+ * MESH_MISSION_LIST_STATUS_LIMIT). Overflow beyond `limit` is reported via
+ * truncated:true + overflowIds rather than silently dropped.
+ *
+ * MAGI + verbose semantics match listMeshMissionSummaries. `withStats` opts each
+ * detailed mission into the ledger-scanned stats rollup (off by default — the tasks
+ * aggregate is enough for a list view).
+ */
+export function listMeshMissionsForTool(
+    meshId: string,
+    options?: {
+        statuses?: MeshMissionStatus[];
+        verbose?: boolean;
+        includeMagi?: boolean;
+        withStats?: boolean;
+        limit?: number;
+        historyIdLimit?: number;
+    },
+): MeshMissionListResult {
+    const explicitStatuses = options?.statuses && options.statuses.length > 0 ? options.statuses : undefined;
+    const includeMagi = options?.includeMagi === true;
+    const verbose = options?.verbose === true;
+    const withStats = options?.withStats === true;
+    const limit = Math.max(1, options?.limit ?? MESH_MISSION_LIST_STATUS_LIMIT);
+    const historyIdLimit = Math.max(0, options?.historyIdLimit ?? MESH_MISSION_LIST_HISTORY_ID_LIMIT);
+
+    const passesMagi = (m: MeshMissionRecord) => includeMagi || !(m.source === 'magi' && m.status === 'completed');
+    const byUpdatedDesc = (a: MeshMissionRecord, b: MeshMissionRecord) => (b.updatedAt || '').localeCompare(a.updatedAt || '');
+
+    const project = (mission: MeshMissionRecord): MeshMissionSummary | MeshMissionSlimSummary => {
+        let summary = summarizeMeshMission(meshId, mission);
+        if (withStats) {
+            try {
+                summary = { ...summary, stats: computeMeshMissionStats(meshId, mission.id) };
+            } catch { /* stats optional — omit on failure */ }
+        }
+        return verbose ? summary : slimMissionSummary(summary);
+    };
+
+    const foldHistory = (history: MeshMissionRecord[]): MeshStatusMissionsHistoryFold | null => {
+        if (history.length === 0) return null;
+        const byStatus: Record<string, number> = {};
+        for (const m of history) byStatus[m.status] = (byStatus[m.status] ?? 0) + 1;
+        return {
+            count: history.length,
+            byStatus,
+            missionIds: history.slice(0, historyIdLimit).map(m => m.id),
+            note: 'Completed/abandoned missions are folded to counts + ids. Pass status (e.g. status:["completed"]) to list them in detail.',
+        };
+    };
+
+    if (explicitStatuses) {
+        // Explicit filter: return matching missions in detail, capped at `limit`.
+        const matched = getMeshMissions(meshId, explicitStatuses)
+            .filter(passesMagi)
+            .sort(byUpdatedDesc);
+        const shown = matched.slice(0, limit);
+        const overflow = matched.slice(limit);
+        return {
+            missions: shown.map(project) as MeshMissionSummary[] | MeshMissionSlimSummary[],
+            historyFold: null,
+            truncated: overflow.length > 0,
+            matched: matched.length,
+            ...(overflow.length > 0 ? { overflowIds: overflow.map(m => m.id) } : {}),
+        };
+    }
+
+    // Default: detail for non-terminal missions, fold terminal history.
+    const all = getMeshMissions(meshId).filter(passesMagi);
+    const live = all
+        .filter(m => m.status === 'active' || m.status === 'paused')
+        .sort(byUpdatedDesc);
+    const history = all
+        .filter(m => m.status === 'completed' || m.status === 'abandoned')
+        .sort(byUpdatedDesc);
+    const shown = live.slice(0, limit);
+    const overflow = live.slice(limit);
+    return {
+        missions: shown.map(project) as MeshMissionSummary[] | MeshMissionSlimSummary[],
+        historyFold: foldHistory(history),
+        truncated: overflow.length > 0,
+        matched: live.length,
+        ...(overflow.length > 0 ? { overflowIds: overflow.map(m => m.id) } : {}),
+    };
+}
+
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/src/providers/native-history/antigravity-cli-transcript.ts

@@ -861,6 +861,119 @@ function parseConversationDb(
   return messages.length > 0 ? messages : null;
 }
 
+/**
+ * Assemble the history.jsonl user-prompt index for a single session id into a
+ * partial NativeHistorySession (user prompts only — history.jsonl never carries
+ * assistant answers). Returns null when the index has no rows for this session.
+ * Shared by the history.jsonl read case and the .db sibling fallback.
+ */
+function readHistoryJsonlSession(
+  resolvedSessionId: string,
+  workspace?: string,
+): NativeHistorySession | null {
+  if (!isUuidLike(resolvedSessionId)) return null;
+  const rows = readHistoryRows().filter((r) => r.conversationId === resolvedSessionId);
+  if (rows.length === 0) return null;
+
+  rows.sort((a, b) => a.receivedAt - b.receivedAt);
+  const firstWorkspace = workspace || rows.find((r) => r.workspace)?.workspace || '';
+
+  const messages: NativeHistoryMessage[] = [];
+  if (firstWorkspace) {
+    messages.push({
+      ts: new Date(rows[0].receivedAt).toISOString(),
+      receivedAt: rows[0].receivedAt,
+      role: 'system',
+      content: firstWorkspace,
+      kind: 'session_start',
+      agent: 'antigravity-cli',
+      historySessionId: resolvedSessionId,
+      workspace: firstWorkspace,
+    });
+  }
+
+  for (const row of rows) {
+    const msg: NativeHistoryMessage = {
+      ts: new Date(row.receivedAt).toISOString(),
+      receivedAt: row.receivedAt,
+      role: 'user',
+      content: row.display,
+      kind: 'standard',
+      agent: 'antigravity-cli',
+      historySessionId: resolvedSessionId,
+    };
+    if (row.workspace) msg.workspace = row.workspace;
+    messages.push(msg);
+  }
+
+  return {
+    messages,
+    providerSessionId: resolvedSessionId,
+    source: 'provider-native',
+    sourcePath: historyJsonlPath(),
+    sourceMtimeMs: statMtimeMs(historyJsonlPath()),
+    nativeHistoryCoverage: 'partial',
+    partialReason: 'antigravity_cli_history_jsonl_contains_user_prompts_only',
+  };
+}
+
+/**
+ * ANTIGRAVITY-COMPLETION-DASHBOARD-GAP: recover a bound session's transcript
+ * from the legacy sibling sources when its per-session .db read came back empty
+ * (transient WAL lock, assistant step not yet flushed, or a decode miss on a
+ * future step_payload schema). Tried in descending fidelity for the SAME
+ * session id — never cross-binds to another conversation:
+ *   1. brain transcript (full coverage, authoritative when present),
+ *   2. sibling conversations/<uuid>.pb (best-effort raw text),
+ *   3. history.jsonl (partial — user prompts only).
+ * Returns null when no sibling yields any message.
+ */
+function readAntigravitySiblingFallback(
+  sessionId: string,
+  workspace?: string,
+): NativeHistorySession | null {
+  if (!isUuidLike(sessionId)) return null;
+
+  // (1) brain transcript — full coverage when antigravity actually wrote it.
+  const brainPath = findBrainTranscriptPath(sessionId);
+  if (brainPath && statMtimeMs(brainPath) > 0) {
+    const brainMessages = parseBrainTranscript(brainPath, sessionId, workspace);
+    if (brainMessages && brainMessages.length > 0) {
+      return {
+        messages: brainMessages,
+        providerSessionId: sessionId,
+        source: 'provider-native',
+        sourcePath: brainPath,
+        sourceMtimeMs: statMtimeMs(brainPath),
+        nativeHistoryCoverage: 'full',
+        workspace,
+      };
+    }
+  }
+
+  // (2) sibling .pb — best-effort raw text extraction.
+  const pbPath = resolvePathInside(conversationsRoot(), `${sessionId}.pb`);
+  if (pbPath && fs.existsSync(pbPath)) {
+    const pbMessages = parsePbFile(pbPath, sessionId);
+    if (pbMessages && pbMessages.length > 0) {
+      return {
+        messages: pbMessages,
+        providerSessionId: sessionId,
+        source: 'provider-native',
+        sourcePath: pbPath,
+        sourceMtimeMs: statMtimeMs(pbPath),
+        nativeHistoryCoverage: 'best-effort',
+        partialReason: 'antigravity_cli_pb_raw_text_extraction',
+        workspace,
+      };
+    }
+  }
+
+  // (3) history.jsonl — partial (user prompts only). Last resort so the
+  //     dashboard at least shows the prompt when no answer source is readable.
+  return readHistoryJsonlSession(sessionId, workspace);
+}
+
 // ─── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -916,17 +1029,31 @@ export function readSession(
     if (!isUuidLike(dbSessionId)) return null;
 
     const messages = parseConversationDb(sessionPath, dbSessionId, workspace);
-    if (!messages || messages.length === 0) return null;
+    if (messages && messages.length > 0) {
+      return {
+        messages,
+        providerSessionId: dbSessionId,
+        source: 'provider-native',
+        sourcePath: sessionPath,
+        sourceMtimeMs,
+        nativeHistoryCoverage: 'full',
+        workspace,
+      };
+    }
 
-    return {
-      messages,
-      providerSessionId: dbSessionId,
-      source: 'provider-native',
-      sourcePath: sessionPath,
-      sourceMtimeMs,
-      nativeHistoryCoverage: 'full',
-      workspace,
-    };
+    // ANTIGRAVITY-COMPLETION-DASHBOARD-GAP: the bound .db yielded nothing this
+    // read — transient (WAL lock / assistant step not yet flushed) or a decode
+    // miss on a future schema. The dispatcher binds STRAIGHT to <uuid>.db once
+    // the session id is known and never re-resolves to a sibling source, so a
+    // null here previously collapsed the whole read to native-unavailable even
+    // when the SAME session's assistant answer was recoverable from the legacy
+    // brain transcript / .pb / history.jsonl. Fall back across those sibling
+    // sources for the same session id before giving up. This is read-only,
+    // scoped to the bound session, and cannot cross-bind to another conversation.
+    const siblingFallback = readAntigravitySiblingFallback(dbSessionId, workspace);
+    if (siblingFallback) return siblingFallback;
+
+    return null;
   }
 
   // ── Case 2b: .pb conversation file (legacy protobuf) ─────────────────────
@@ -950,52 +1077,7 @@ export function readSession(
 
   // ── Case 3: history.jsonl (user prompts index) ──────────────────────────
   if (path.basename(sessionPath) === 'history.jsonl') {
-    const resolvedSessionId = sessionId || '';
-    if (!resolvedSessionId || !isUuidLike(resolvedSessionId)) return null;
-
-    const rows = readHistoryRows().filter((r) => r.conversationId === resolvedSessionId);
-    if (rows.length === 0) return null;
-
-    rows.sort((a, b) => a.receivedAt - b.receivedAt);
-    const firstWorkspace = workspace || rows.find((r) => r.workspace)?.workspace || '';
-
-    const messages: NativeHistoryMessage[] = [];
-    if (firstWorkspace) {
-      messages.push({
-        ts: new Date(rows[0].receivedAt).toISOString(),
-        receivedAt: rows[0].receivedAt,
-        role: 'system',
-        content: firstWorkspace,
-        kind: 'session_start',
-        agent: 'antigravity-cli',
-        historySessionId: resolvedSessionId,
-        workspace: firstWorkspace,
-      });
-    }
-
-    for (const row of rows) {
-      const msg: NativeHistoryMessage = {
-        ts: new Date(row.receivedAt).toISOString(),
-        receivedAt: row.receivedAt,
-        role: 'user',
-        content: row.display,
-        kind: 'standard',
-        agent: 'antigravity-cli',
-        historySessionId: resolvedSessionId,
-      };
-      if (row.workspace) msg.workspace = row.workspace;
-      messages.push(msg);
-    }
-
-    return {
-      messages,
-      providerSessionId: resolvedSessionId,
-      source: 'provider-native',
-      sourcePath: sessionPath,
-      sourceMtimeMs,
-      nativeHistoryCoverage: 'partial',
-      partialReason: 'antigravity_cli_history_jsonl_contains_user_prompts_only',
-    };
+    return readHistoryJsonlSession(sessionId || '', workspace);
   }
 
   return null;