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

package/dist/providers/cli-provider-instance.d.ts

@@ -287,9 +287,21 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pruneRecentUserInputAcks;
     /**
      * Owner token for this session in the antigravity conversation-claim
-     * registry. Derived identically to the dispatcher's read-side token
-     * (workspace + spawn time) so the claims the dispatcher records under this
-     * session are the ones dispose() releases.
+     * registry. Keyed on the daemon instance id — the SAME value the session
+     * registry stores as this session's `sessionId` (see cli-manager
+     * `sessionRegistry.register({ sessionId: cliInstance.instanceId })`) and the
+     * read side hands the dispatcher as `instanceId`. Both sides therefore
+     * derive the identical `iid:<instanceId>` token, so the claims the
+     * dispatcher records under this session are exactly the ones dispose()
+     * releases.
+     *
+     * This must NOT be derived from a spawn timestamp: the instance's
+     * `startedAt`, the adapter's `spawnedAtMs`, and the session registry's
+     * `spawnedAtMs` are three INDEPENDENT `Date.now()` samples for the one
+     * session, so a workspace+spawn-time token computed here would never equal
+     * the read side's — the claim isolation then silently collapses and two
+     * concurrent antigravity sessions cross-bind each other's conversation .db
+     * (coordinator+worker chat crosswire).
      */
     private antigravityClaimOwner;
     dispose(): void;

package/dist/shared-types.d.ts

@@ -183,6 +183,18 @@ export interface DaemonMetadataUpdate {
     userName?: string;
     seq: number;
     timestamp: number;
+    /**
+     * Per-mesh state-change revision counters (meshId → monotonically increasing
+     * integer), bumped whenever the daemon's mesh graph/queue/mission state for that
+     * mesh changes (onMeshStateChange). Lets the dashboard replace its client-side
+     * mesh_status polling with an event-driven background refresh: when the revision
+     * for the mesh it is viewing advances, it re-fetches the aggregate mesh_status
+     * (SWR, keeping the current graph on screen). This is a lightweight nudge — the
+     * full aggregate snapshot is fetched on demand, not embedded here, so the
+     * daemon.metadata payload stays small. Optional/absent for daemons/builds that
+     * don't emit it (the client then keeps its polling fallback).
+     */
+    meshStateRevisions?: Record<string, number>;
 }
 export interface TopicUpdateEnvelopeMap {
     'session.chat_tail': SessionChatTailUpdate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.474",
+  "version": "0.9.82-rc.476",
   "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.474",
-    "@adhdev/session-host-core": "0.9.82-rc.474",
+    "@adhdev/mesh-shared": "0.9.82-rc.476",
+    "@adhdev/session-host-core": "0.9.82-rc.476",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/chat-commands-read.ts

@@ -9,6 +9,7 @@ import type { CliAdapter } from '../cli-adapter-types.js';
 import { flattenContent, type ProviderModule, type ProviderScripts } from '../providers/contracts.js';
 import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import { isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
+import { clearPersistedProviderSessionPins, loadPersistedProviderSessionPins, recordPersistedProviderSessionPin } from '../config/state-store.js';
 import { getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { LOG } from '../logging/logger.js';
 import { recordDebugTrace } from '../logging/debug-trace.js';
@@ -62,22 +63,69 @@ const CLI_NATIVE_TRANSCRIPT_PROVIDERS = new Set(['codex-cli', 'claude-cli', 'her
 // and run the native query normally instead of fail-closing. Refreshed on every
 // successful bind; never lets an empty id clear a known pin. Keyed by mesh
 // session id so pins never alias across distinct sessions sharing a workspace.
+//
+// The map is ALSO mirrored to disk (state.json sessionProviderSessionPins) so a
+// pin survives a daemon restart. Without that, an attach-restored antigravity
+// session (spawnedAtMs=0, so no live spawn floor) that has sat idle past the
+// native reader's recency window can no longer resolve its own conversation .db
+// after the daemon comes back — read_chat falls to the PTY parse and the
+// dashboard shows the user prompt with the assistant tail missing
+// (ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP). The in-memory map stays the hot path;
+// disk is the cold-start hydration source, read lazily on the first miss.
 const lastBoundProviderSessionIdByMeshSession = new Map<string, string>();
+let persistedProviderSessionPinsHydrated = false;
+
+function hydratePersistedProviderSessionPinsOnce(): void {
+    if (persistedProviderSessionPinsHydrated) return;
+    persistedProviderSessionPinsHydrated = true;
+    try {
+        for (const [key, value] of Object.entries(loadPersistedProviderSessionPins())) {
+            // Never let a stale persisted value clobber a fresher in-memory bind
+            // recorded earlier this process lifetime.
+            if (!lastBoundProviderSessionIdByMeshSession.has(key)) {
+                lastBoundProviderSessionIdByMeshSession.set(key, value);
+            }
+        }
+    } catch {
+        // Best-effort: a missing/corrupt state file just means no cold-start pins.
+    }
+}
 
 function recordBoundProviderSessionId(meshSessionId: string | undefined, providerSessionId: string | undefined): void {
     const key = typeof meshSessionId === 'string' ? meshSessionId.trim() : '';
     const value = typeof providerSessionId === 'string' ? providerSessionId.trim() : '';
     if (!key || !value) return;
     lastBoundProviderSessionIdByMeshSession.set(key, value);
+    // Always attempt the disk mirror — recordPersistedProviderSessionPin is itself a
+    // no-op when the ON-DISK value already matches, so it does not rewrite state.json
+    // on steady re-reads, yet it still lands a pin the in-memory map already holds but
+    // disk lost (a prior write clobbered by another state-store writer, or a restart
+    // whose hydration ran before this bind). Gating on the in-memory previous value
+    // let the in-memory and on-disk pin diverge permanently, defeating the persistence.
+    try { recordPersistedProviderSessionPin(key, value); } catch { /* best-effort disk mirror */ }
 }
 
 function getBoundProviderSessionIdPin(meshSessionId: string | undefined): string | undefined {
     const key = typeof meshSessionId === 'string' ? meshSessionId.trim() : '';
     if (!key) return undefined;
+    hydratePersistedProviderSessionPinsOnce();
     const pinned = lastBoundProviderSessionIdByMeshSession.get(key);
     return pinned && pinned.trim() ? pinned.trim() : undefined;
 }
 
+/**
+ * Test-only: clear the in-memory read-pin map and re-arm cold-start hydration so
+ * each test starts from a clean pin state. The on-disk mirror is isolated per
+ * test process via ADHDEV_CONFIG_DIR (test/helpers/setup-env.ts); this resets the
+ * module-level cache that would otherwise leak a pin across tests sharing the
+ * worker. Not part of the runtime contract.
+ */
+export function __resetProviderSessionPinsForTest(): void {
+    lastBoundProviderSessionIdByMeshSession.clear();
+    persistedProviderSessionPinsHydrated = false;
+    try { clearPersistedProviderSessionPins(); } catch { /* best-effort */ }
+}
+
 const warnedLegacyNativeAllowlistHits = new Set<string>();
 function warnLegacyNativeAllowlistHit(providerType: string): void {
     if (warnedLegacyNativeAllowlistHits.has(providerType)) return;
@@ -1095,6 +1143,13 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     // the downstream hasSafeNativeHistoryMapping workspace-overlap gate. Only the
     // read_chat path opts in, and only with a concrete workspace.
     allowWorkspaceLatestFallback?: boolean;
+    // ADHDev session id of the reading session (== the session registry's
+    // sessionId == the provider instance's instanceId). Threaded to the
+    // native-history dispatcher so antigravity's conversation-claim owner token
+    // is keyed on this stable identity and matches the instance-side token —
+    // without it two concurrent antigravity sessions cross-bind each other's
+    // conversation .db.
+    instanceId?: string;
 }): ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' } {
     const canBindFromLiveSession = !args.historySessionId
         && typeof args.sessionStartedAtMs === 'number'
@@ -1146,6 +1201,7 @@ function readCliProviderNativeHistory(agentStr: string, args: {
         excludeInProgressTurn: args.excludeInProgressTurn,
         sessionStartedAtMs: args.sessionStartedAtMs,
         envOverrides: args.envOverrides,
+        instanceId: args.instanceId,
     });
     const boundProviderSessionId = typeof (sessionHistory as any)?.providerSessionId === 'string'
         ? (sessionHistory as any).providerSessionId.trim()
@@ -1541,6 +1597,7 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
                 scripts: provider?.scripts as any,
                 sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                 envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                 pinnedProviderSessionId: getBoundProviderSessionIdPin(args?.targetSessionId),
             })
             : readProviderChatHistory(agentStr, {
@@ -1759,10 +1816,31 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             let nativeHistory: any | null = null;
             let nativeHistoryError: unknown | undefined;
             if (supportsNative) {
+                // Runtime-fallback → pin substitution: nativeHistoryReadSessionId is
+                // the bare runtime/session id when no explicit provider handle was
+                // supplied and none was parsed (antigravity takes no --session-id, so
+                // its this.providerSessionId stays empty and getHistorySessionId falls
+                // back to targetSessionId). That runtime id is not the on-disk
+                // conversations/<uuid>.db name, so a native read keyed on it can never
+                // exact-bind and falls to the recency heuristic — which drops an idle
+                // (or restored, spawnedAtMs=0) session's own store. Prefer a pin (a
+                // real conversation id a prior read resolved for THIS session, now also
+                // persisted across restart) over the runtime id, else drop the runtime
+                // id so readCliProviderNativeHistory's pin / workspace-latest paths can
+                // engage. Mirrors the handleChatHistory path's established handling.
+                const pinnedProviderSessionIdForRead = getBoundProviderSessionIdPin(targetSessionId);
+                const nativeReadSessionIdIsRuntimeFallback = Boolean(
+                    targetSessionId
+                    && nativeHistoryReadSessionId === targetSessionId
+                    && !getExplicitHistorySessionId(args),
+                );
+                const effectiveNativeReadSessionId = nativeReadSessionIdIsRuntimeFallback
+                    ? (pinnedProviderSessionIdForRead || undefined)
+                    : nativeHistoryReadSessionId;
                 try {
                     nativeHistory = readCliProviderNativeHistory(agentStr, {
                         canonicalHistory: provider?.nativeHistory,
-                        historySessionId: nativeHistoryReadSessionId,
+                        historySessionId: effectiveNativeReadSessionId,
                         workspace,
                         offset: 0,
                         limit: nativeHistoryLimit,
@@ -1772,11 +1850,14 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         excludeInProgressTurn: returnedStatus === 'waiting_approval',
                         sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                         envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
-                        pinnedProviderSessionId: getBoundProviderSessionIdPin(targetSessionId),
+                        // Stable per-session identity for antigravity's conversation-claim
+                        // owner token (== session registry sessionId == instance instanceId).
+                        instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
+                        pinnedProviderSessionId: pinnedProviderSessionIdForRead,
                         // Last-resort only when no pin was ever recorded for this
                         // session; the downstream workspace-overlap safety gate
                         // still filters an aliased session out.
-                        allowWorkspaceLatestFallback: !getBoundProviderSessionIdPin(targetSessionId),
+                        allowWorkspaceLatestFallback: !pinnedProviderSessionIdForRead,
                     });
                     // Refresh the per-mesh-session pin whenever a native read
                     // resolves a concrete provider-native session id. A later
@@ -1847,6 +1928,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         excludeInProgressTurn: returnedStatus === 'waiting_approval',
                         sessionStartedAtMs,
                         envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                        instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                     });
                     nativeHistoryError = undefined;
                     nativeMessages = nativeHistory && Array.isArray(nativeHistory.messages)
@@ -2145,6 +2227,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     scripts: provider?.scripts as any,
                     sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                     envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                    instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                     pinnedProviderSessionId: pinnedProviderSessionIdForHistory,
                     // Last-resort only when no pin was ever recorded AND the
                     // runtime fallback did not resolve a real provider session.

package/src/commands/chat-commands.ts

@@ -11,7 +11,7 @@
 export { READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, buildSendInputSignature } from './chat-commands-shared.js';
 export { evaluateReadChatNodeWorkspaceScope } from './chat-commands-scope.js';
 export { sanitizeDebugBundleValue, handleGetChatDebugBundle } from './chat-commands-debug-bundle.js';
-export { handleChatHistory, handleReadChat } from './chat-commands-read.js';
+export { handleChatHistory, handleReadChat, __resetProviderSessionPinsForTest } from './chat-commands-read.js';
 export {
     handleSendChat,
     handleListChats,

package/src/config/chat-history.ts

@@ -1813,10 +1813,12 @@ function callProviderNativeHistoryRead(
     sessionStartedAtMs?: number,
     envOverrides?: Record<string, string>,
     forceRefresh?: boolean,
+    instanceId?: string,
 ): ProviderNativeHistoryReadResult | null {
     const fn = getProviderNativeHistoryScript(scripts, canonicalHistory, 'readSession');
     if (!fn) return null;
     const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || '');
+    const normalizedInstanceId = typeof instanceId === 'string' ? instanceId.trim() : '';
     const result = fn({
         agentType,
         sessionId: normalizedSessionId,
@@ -1831,6 +1833,12 @@ function callProviderNativeHistoryRead(
         // which leaves the guard disarmed so discovery still works.
         providerSessionId: normalizedSessionId,
         historySessionId: normalizedSessionId,
+        // Stable per-session owner key for the antigravity conversation-claim
+        // registry (see dispatcher.resolveAntigravityPath / antigravityOwnerToken).
+        // Equals the session registry's sessionId and the provider instance's
+        // instanceId, so read side and instance side derive the identical claim
+        // owner token and two concurrent antigravity sessions never cross-bind.
+        instanceId: normalizedInstanceId || undefined,
         workspace,
         format: canonicalHistory?.format,
         watchPath: canonicalHistory?.watchPath,
@@ -1838,7 +1846,7 @@ function callProviderNativeHistoryRead(
         sessionStartedAtMs,
         envOverrides,
         forceRefresh: forceRefresh === true,
-        args: { sessionId: normalizedSessionId, historySessionId: normalizedSessionId, workspace, excludeInProgressTurn: excludeInProgressTurn === true, sessionStartedAtMs, envOverrides, forceRefresh: forceRefresh === true },
+        args: { sessionId: normalizedSessionId, historySessionId: normalizedSessionId, instanceId: normalizedInstanceId || undefined, workspace, excludeInProgressTurn: excludeInProgressTurn === true, sessionStartedAtMs, envOverrides, forceRefresh: forceRefresh === true },
     });
     if (!result || typeof result !== 'object') return null;
     const records = normalizeProviderNativeHistoryRecords(agentType, normalizedSessionId, (result as any).messages || (result as any).records);
@@ -1865,11 +1873,12 @@ function buildNativeHistoryReadResult(
     sessionStartedAtMs?: number,
     envOverrides?: Record<string, string>,
     forceRefresh?: boolean,
+    instanceId?: string,
 ): ProviderNativeHistoryReadResult | null {
     const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || '');
     const normalizedWorkspace = typeof workspace === 'string' ? workspace.trim() : '';
     if (!canonicalHistory || (!normalizedSessionId && !normalizedWorkspace) || !isNativeSourceCanonicalHistory(canonicalHistory)) return null;
-    return callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace, excludeInProgressTurn, sessionStartedAtMs, envOverrides, forceRefresh);
+    return callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace, excludeInProgressTurn, sessionStartedAtMs, envOverrides, forceRefresh, instanceId);
 }
 
 function materializeNativeHistoryToMirror(
@@ -1929,6 +1938,13 @@ export function readProviderChatHistory(
         sessionStartedAtMs?: number;
         envOverrides?: Record<string, string>;
         forceRefresh?: boolean;
+        // Daemon instance id of the reading session (== the session registry's
+        // sessionId). Threaded to the native-history dispatcher so the
+        // antigravity conversation-claim owner token is keyed on this stable
+        // per-session identity — identical to the token the provider instance
+        // derives — instead of a spawn timestamp that differs across sample
+        // sites and silently breaks claim isolation.
+        instanceId?: string;
     } = {},
 ): {
     messages: HistoryMessage[];
@@ -1943,7 +1959,7 @@ export function readProviderChatHistory(
     unavailableReason?: string;
 } {
     if (isNativeSourceCanonicalHistory(options.canonicalHistory) && (options.historySessionId || options.workspace)) {
-        const nativeResult = buildNativeHistoryReadResult(agentType, options.canonicalHistory, options.scripts, options.historySessionId, options.workspace, options.excludeInProgressTurn, options.sessionStartedAtMs, options.envOverrides, options.forceRefresh);
+        const nativeResult = buildNativeHistoryReadResult(agentType, options.canonicalHistory, options.scripts, options.historySessionId, options.workspace, options.excludeInProgressTurn, options.sessionStartedAtMs, options.envOverrides, options.forceRefresh, options.instanceId);
         if (!nativeResult) return { messages: [], hasMore: false, source: 'native-unavailable' };
         return {
             ...pageHistoryRecords(agentType, nativeResult.records, options.offset || 0, options.limit || 30, options.excludeRecentCount || 0, options.historyBehavior),

package/src/config/state-store.ts

@@ -26,6 +26,17 @@ export interface DaemonState {
     sessionNotificationDismissals: Record<string, string>;
     /** Current notification unread override ids keyed by stable session target */
     sessionNotificationUnreadOverrides: Record<string, string>;
+    /**
+     * Resolved provider-native conversation id for a live session, keyed by the
+     * ADHDev/mesh session id. Persisted so it survives a daemon restart: a
+     * provider whose on-disk store is keyed by an internally-generated id it
+     * never exposes on the CLI (antigravity — no --session-id) can then exact-bind
+     * its conversation .db after restart instead of re-running the mtime/recency
+     * heuristic, which drops the store once idle and collapses read_chat to the
+     * PTY parse (user echo only, assistant tail lost). Mirrors the in-memory read
+     * pin (chat-commands-read lastBoundProviderSessionIdByMeshSession).
+     */
+    sessionProviderSessionPins: Record<string, string>;
 }
 
 const DEFAULT_STATE: DaemonState = {
@@ -35,6 +46,7 @@ const DEFAULT_STATE: DaemonState = {
     sessionReadMarkers: {},
     sessionNotificationDismissals: {},
     sessionNotificationUnreadOverrides: {},
+    sessionProviderSessionPins: {},
 };
 
 function isPlainObject(value: unknown): value is Record<string, any> {
@@ -77,6 +89,10 @@ function normalizeState(raw: unknown): DaemonState {
         Object.entries(isPlainObject(parsed.sessionNotificationUnreadOverrides) ? parsed.sessionNotificationUnreadOverrides : {})
             .filter(([, value]) => typeof value === 'string' && value.length > 0)
     );
+    const sessionProviderSessionPins = Object.fromEntries(
+        Object.entries(isPlainObject(parsed.sessionProviderSessionPins) ? parsed.sessionProviderSessionPins : {})
+            .filter(([key, value]) => typeof key === 'string' && key.length > 0 && typeof value === 'string' && value.length > 0)
+    );
 
     return {
         recentActivity,
@@ -85,6 +101,7 @@ function normalizeState(raw: unknown): DaemonState {
         sessionReadMarkers,
         sessionNotificationDismissals,
         sessionNotificationUnreadOverrides,
+        sessionProviderSessionPins,
     };
 }
 
@@ -121,3 +138,41 @@ export function saveState(state: DaemonState): void {
 export function resetState(): void {
     saveState({ ...DEFAULT_STATE });
 }
+
+/**
+ * Load the full persisted session→provider-conversation pin map (sessionId →
+ * provider-native conversation id). Survives daemon restart. Empty object when
+ * none recorded or the state file is unreadable.
+ */
+export function loadPersistedProviderSessionPins(): Record<string, string> {
+    return { ...loadState().sessionProviderSessionPins };
+}
+
+/**
+ * Persist one session→provider-conversation pin. Load-mutate-save against the
+ * on-disk state so it survives a daemon restart; a no-op when the value already
+ * matches (avoids rewriting state.json on every read). Never clears a pin with an
+ * empty value.
+ */
+export function recordPersistedProviderSessionPin(sessionId: string, providerSessionId: string): void {
+    const key = typeof sessionId === 'string' ? sessionId.trim() : '';
+    const value = typeof providerSessionId === 'string' ? providerSessionId.trim() : '';
+    if (!key || !value) return;
+    const state = loadState();
+    if (state.sessionProviderSessionPins[key] === value) return;
+    saveState({
+        ...state,
+        sessionProviderSessionPins: { ...state.sessionProviderSessionPins, [key]: value },
+    });
+}
+
+/**
+ * Test-only: drop all persisted session→provider-conversation pins from disk.
+ * Used by tests that assert a clean "no pin" state so a sibling test's write to
+ * the shared per-process ADHDEV_CONFIG_DIR does not leak in.
+ */
+export function clearPersistedProviderSessionPins(): void {
+    const state = loadState();
+    if (Object.keys(state.sessionProviderSessionPins).length === 0) return;
+    saveState({ ...state, sessionProviderSessionPins: {} });
+}

package/src/providers/cli-provider-instance.ts

@@ -1089,12 +1089,24 @@ export class CliProviderInstance implements ProviderInstance {
 
     /**
      * Owner token for this session in the antigravity conversation-claim
-     * registry. Derived identically to the dispatcher's read-side token
-     * (workspace + spawn time) so the claims the dispatcher records under this
-     * session are the ones dispose() releases.
+     * registry. Keyed on the daemon instance id — the SAME value the session
+     * registry stores as this session's `sessionId` (see cli-manager
+     * `sessionRegistry.register({ sessionId: cliInstance.instanceId })`) and the
+     * read side hands the dispatcher as `instanceId`. Both sides therefore
+     * derive the identical `iid:<instanceId>` token, so the claims the
+     * dispatcher records under this session are exactly the ones dispose()
+     * releases.
+     *
+     * This must NOT be derived from a spawn timestamp: the instance's
+     * `startedAt`, the adapter's `spawnedAtMs`, and the session registry's
+     * `spawnedAtMs` are three INDEPENDENT `Date.now()` samples for the one
+     * session, so a workspace+spawn-time token computed here would never equal
+     * the read side's — the claim isolation then silently collapses and two
+     * concurrent antigravity sessions cross-bind each other's conversation .db
+     * (coordinator+worker chat crosswire).
      */
     private antigravityClaimOwner(): string {
-        return antigravityOwnerToken(this.workingDir, this.startedAt);
+        return antigravityOwnerToken(this.workingDir, this.startedAt, this.instanceId);
     }
 
     dispose(): void {

package/src/providers/native-history/dispatcher.ts

@@ -87,6 +87,23 @@ export function createNativeHistoryDispatcher(reader: ReaderId): (input: NativeH
             return null;
         }
 
+        // For antigravity, the authoritative conversation id is the on-disk uuid
+        // embedded in the resolved path (conversations/<uuid>.db or
+        // brain/<uuid>/…/transcript.jsonl), NOT the ADHDev session id the caller
+        // threaded in. Surface that uuid as providerSessionId whenever the reader
+        // did not already return a distinct one, so the read_chat layer can pin
+        // the real conversation and (post-restart) exact-bind straight to it
+        // instead of re-running the mtime/recency heuristic that drops an idle
+        // store (ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP). Other providers keep the
+        // reader's value verbatim.
+        let resolvedProviderSessionId = session.providerSessionId;
+        if (reader === 'antigravity-cli') {
+            const onDiskUuid = extractAntigravityConversationUuid(session.sourcePath || sourcePath);
+            if (onDiskUuid && (!resolvedProviderSessionId || resolvedProviderSessionId === sessionId)) {
+                resolvedProviderSessionId = onDiskUuid;
+            }
+        }
+
         return {
             messages: session.messages.map((m: any) => ({
                 role: normalizeRole(m.role),
@@ -95,7 +112,7 @@ export function createNativeHistoryDispatcher(reader: ReaderId): (input: NativeH
                 kind: typeof m.kind === 'string' ? m.kind : 'standard',
                 workspace: typeof m.workspace === 'string' ? m.workspace : workspace || undefined,
             })),
-            providerSessionId: session.providerSessionId,
+            providerSessionId: resolvedProviderSessionId,
             sourcePath: session.sourcePath,
             sourceMtimeMs: session.sourceMtimeMs,
             nativeHistoryCoverage: (session as any).nativeHistoryCoverage || 'full',
@@ -239,6 +256,27 @@ function resolveRealPath(value: string): string {
     try { return fs.realpathSync(value); } catch { return value; }
 }
 
+/**
+ * Pull the antigravity conversation uuid out of a resolved source path. Both
+ * on-disk layouts embed it: conversations/<uuid>.db and
+ * brain/<uuid>/.system_generated/logs/transcript*.jsonl (and the legacy
+ * conversations/<uuid>.pb). Returns the uuid when a segment matches the
+ * canonical form, else ''.
+ */
+function extractAntigravityConversationUuid(sourcePath: string): string {
+    if (!sourcePath) return '';
+    const segments = sourcePath.split(/[\\/]/);
+    // conversations/<uuid>.db|.pb — the basename minus extension.
+    const base = segments[segments.length - 1] || '';
+    const baseMatch = /^([0-9a-f-]+)\.(?:db|pb)$/i.exec(base);
+    if (baseMatch && isUuidLikeSessionId(baseMatch[1])) return baseMatch[1];
+    // brain/<uuid>/… — the first uuid-like path segment.
+    for (const seg of segments) {
+        if (isUuidLikeSessionId(seg)) return seg;
+    }
+    return '';
+}
+
 /**
  * The daemon may stamp a session's spawn time a hair before the CLI child
  * actually creates its conversation .db, so treat a store born within this
@@ -341,6 +379,19 @@ function pickUnboundConversationDb(
     let entries: fs.Dirent[] = [];
     try { entries = fs.readdirSync(convRoot, { withFileTypes: true }); } catch { return null; }
 
+    // A known spawn floor already pins a candidate to THIS session by birth time
+    // (a store created at/after the session spawned is its own). Once that floor
+    // is available, the recency window is not just unnecessary but harmful: an
+    // antigravity session that has sat idle longer than RECENT_WINDOW_MS still
+    // owns its conversation .db, but the recency cutoff would drop it from the
+    // candidate set, collapsing the read to native_history_empty and forcing the
+    // dashboard onto the PTY parse (user echo only, assistant tail lost —
+    // ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP, most visible right after a daemon
+    // restart clears the in-memory read pin). So only apply the recency cutoff in
+    // the floor-less (legacy/unpinned) discovery path, where it is the sole guard
+    // against binding an unrelated old store. When a floor is known the birth-time
+    // filter below is the authoritative, idle-agnostic owner check.
+    const applyRecencyCutoff = !(sessionFloorMs > 0);
     const recencyCutoff = Date.now() - RECENT_WINDOW_MS;
     const candidates: Array<{ path: string; uuid: string; mtime: number; birth: number }> = [];
     for (const entry of entries) {
@@ -352,7 +403,7 @@ function pickUnboundConversationDb(
         if (isAntigravityConversationClaimedByOther(uuid, owner)) continue;
         const p = path.join(convRoot, entry.name);
         const mtime = safeMtime(p);
-        if (mtime < recencyCutoff) continue;
+        if (applyRecencyCutoff && mtime < recencyCutoff) continue;
         candidates.push({ path: p, uuid, mtime, birth: safeBirthtime(p) });
     }
     if (candidates.length === 0) return null;

package/src/shared-types.ts

@@ -298,6 +298,18 @@ export interface DaemonMetadataUpdate {
     userName?: string;
     seq: number;
     timestamp: number;
+    /**
+     * Per-mesh state-change revision counters (meshId → monotonically increasing
+     * integer), bumped whenever the daemon's mesh graph/queue/mission state for that
+     * mesh changes (onMeshStateChange). Lets the dashboard replace its client-side
+     * mesh_status polling with an event-driven background refresh: when the revision
+     * for the mesh it is viewing advances, it re-fetches the aggregate mesh_status
+     * (SWR, keeping the current graph on screen). This is a lightweight nudge — the
+     * full aggregate snapshot is fetched on demand, not embedded here, so the
+     * daemon.metadata payload stays small. Optional/absent for daemons/builds that
+     * don't emit it (the client then keeps its polling fallback).
+     */
+    meshStateRevisions?: Record<string, number>;
 }
 
 export interface TopicUpdateEnvelopeMap {