@adhdev/daemon-core 0.9.82-rc.475 → 0.9.82-rc.477

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

@@ -20,6 +20,7 @@ import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter, isNativeSourceCanonicalHistory, materializeProviderNativeHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
+import { loadPersistedProviderSessionPins } from '../config/state-store.js';
 import { LOG } from '../logging/logger.js';
 import { recordDebugTrace } from '../logging/debug-trace.js';
 import { shouldCollectTraceCategory } from '../logging/debug-config.js';
@@ -572,7 +573,7 @@ export class CliProviderInstance implements ProviderInstance {
         const canonicalBackedHistory = this.shouldHydrateExistingProviderHistory()
             ? this.syncCanonicalSavedHistoryIfNeeded()
             : false;
-        const statusMessages = canonicalBackedHistory && this.lastPersistedHistoryMessages.length > 0
+        const statusMessages: any[] = canonicalBackedHistory && this.lastPersistedHistoryMessages.length > 0
             ? this.lastPersistedHistoryMessages.map((message) => ({
                 role: message.role,
                 content: message.content,
@@ -582,6 +583,42 @@ export class CliProviderInstance implements ProviderInstance {
             }))
             : mergedMessages;
 
+        // Dashboard-tail repair (native-source providers, e.g. antigravity): the
+        // assistant answer lives only in native-history, so the PTY-parsed
+        // statusMessages end on the user prompt / auto-approve system lines and the
+        // snapshot's preview / lastMessageRole / completionMarker never see the
+        // answer — the session looks stuck on the user turn. We already cached the
+        // real final assistant summary at completion time (lastCompletionSummary),
+        // so append it as the trailing assistant bubble when the current tail has no
+        // assistant message at/after it. Purely additive to the status view; no
+        // per-tick native read, no effect on providers whose PTY carries the
+        // assistant (they surface it themselves and the guard below is a no-op).
+        const adapterOwnsMessagesElsewhereForTail = (this.adapter as any)?.chatMessagesOwnedExternally === true;
+        if (adapterOwnsMessagesElsewhereForTail && this.lastCompletionSummary) {
+            const summary = this.lastCompletionSummary;
+            let hasTrailingAssistant = false;
+            for (let i = statusMessages.length - 1; i >= 0; i -= 1) {
+                const m = statusMessages[i] as { role?: string; kind?: string; receivedAt?: number };
+                const role = typeof m?.role === 'string' ? m.role : '';
+                if (role === 'system') continue;
+                if (typeof m?.kind === 'string' && m.kind === 'tool') continue;
+                // First non-system/non-tool message from the tail: if it's already an
+                // assistant reply not older than our cached summary, the tail is fine.
+                hasTrailingAssistant = role === 'assistant'
+                    && typeof m?.receivedAt === 'number'
+                    && m.receivedAt >= summary.receivedAt - 1000;
+                break;
+            }
+            if (!hasTrailingAssistant) {
+                statusMessages.push({
+                    role: 'assistant',
+                    content: summary.content,
+                    kind: 'standard',
+                    receivedAt: summary.receivedAt,
+                });
+            }
+        }
+
         const dirName = workingDirBasename(this.workingDir);
         const parsedChatStatus = typeof parsedStatus?.status === 'string' && parsedStatus.status.trim()
             ? parsedStatus.status.trim()
@@ -1132,6 +1169,18 @@ export class CliProviderInstance implements ProviderInstance {
     private completedDebounceTimer: NodeJS.Timeout | null = null;
     private completedDebouncePending: CompletedDebouncePending | null = null;
     private lastExternalCompletionProbe: ExternalTranscriptProbe | null = null;
+    /**
+     * The final assistant summary of the last completed turn, cached at
+     * completion-emit time. For a native-source provider (antigravity) whose
+     * assistant answer lives only in native-history — never in the PTY parse that
+     * feeds activeChat.messages — the dashboard's preview / lastMessageRole /
+     * completionMarker would otherwise never see the answer and show the session
+     * stuck on the user prompt. getState() appends this cached assistant bubble to
+     * the status messages when the PTY tail has none, so those fields reflect the
+     * real last answer with ZERO per-tick native reads (the native read already ran
+     * once at completion). Reset on the next turn's start.
+     */
+    private lastCompletionSummary: { content: string; receivedAt: number } | null = null;
 
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
@@ -1219,21 +1268,59 @@ export class CliProviderInstance implements ProviderInstance {
     private readExternalCompletionMessages(): unknown[] | null {
         const adapterOwnsMessagesElsewhere = (this.adapter as any)?.chatMessagesOwnedExternally === true;
         if (!adapterOwnsMessagesElsewhere) return null;
-        if (!this.providerSessionId) return null;
         if (!isNativeSourceCanonicalHistory(this.provider.nativeHistory)) return null;
 
+        // Resolve a CONCRETE native-history handle for this session's OWN
+        // conversation. A provider that exposes its session id on the CLI
+        // (codex/claude/hermes) sets this.providerSessionId. antigravity takes no
+        // --session-id, so this.providerSessionId stays empty — recover the real
+        // on-disk conversation id from the read pin persisted across restart
+        // (state.json sessionProviderSessionPins, keyed by this session's
+        // instanceId — the same map a binding read_chat / mesh_read_chat records
+        // the resolved uuid into). The OLD `if (!this.providerSessionId) return
+        // null` guard blocked antigravity's completion transcript entirely, so its
+        // final-assistant evidence was permanently 'unavailable' and the turn
+        // completion never emitted → the mesh reconcile loop reclaimed the
+        // "delivered but no completion" task and re-dispatched the same MAGI prompt
+        // (ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP, completion side).
+        //
+        // Prefer a concrete handle (providerSessionId, else the persisted pin). When
+        // neither exists yet — a fresh antigravity turn whose conversation has not
+        // been bound by any read_chat — fall through with an EMPTY handle and let the
+        // dispatcher resolve this session's own conversations/<uuid>.db by the
+        // spawn-floor + workspace + instanceId claim. This is safe now that the
+        // claim owner token is single-form iid:<instanceId> (never collapses to '')
+        // and pickUnboundConversationDb picks the oldest store born at/after THIS
+        // session's floor: the probe resolves the session's OWN db under its own
+        // owner token, so it can never steal a sibling's conversation (the earlier
+        // theft required a floor=0 / owner='' collapse that no longer happens). It
+        // means the completion summary is available on the FIRST completion — before
+        // any read_chat has recorded a pin — which the dashboard tail-repair needs.
+        let resolvedHandle = this.providerSessionId || '';
+        if (!resolvedHandle) {
+            try {
+                const pinned = loadPersistedProviderSessionPins()[this.instanceId];
+                if (typeof pinned === 'string' && pinned.trim()) resolvedHandle = pinned.trim();
+            } catch { /* best-effort pin hydration */ }
+        }
+
         if (this.lastExternalCompletionProbe?.sourcePath) {
             try { fs.statSync(this.lastExternalCompletionProbe.sourcePath); } catch { /* best-effort metadata refresh */ }
         }
         const restoredHistory = readProviderChatHistory(this.type, {
             canonicalHistory: this.provider.nativeHistory,
-            historySessionId: this.providerSessionId,
+            historySessionId: resolvedHandle || undefined,
             workspace: this.workingDir,
             offset: 0,
             limit: Number.MAX_SAFE_INTEGER,
             historyBehavior: this.provider.historyBehavior,
             scripts: this.provider.scripts as any,
             sessionStartedAtMs: this.startedAt,
+            // The claim owner token must match read_chat's so the exact-bind on our
+            // own conversation stays idempotent rather than looking foreign, and so
+            // the floor-based resolution above claims THIS session's db under its
+            // own owner (never a sibling's).
+            instanceId: this.instanceId,
             envOverrides: this.spawnedEnvOverrides(),
             forceRefresh: true,
         });
@@ -1249,6 +1336,27 @@ export class CliProviderInstance implements ProviderInstance {
         return restoredHistory.messages;
     }
 
+    /**
+     * The content of the LAST visible assistant bubble in a message list, or ''
+     * when the tail is not an assistant reply. Skips trailing system/tool/activity
+     * bubbles; stops (returns '') at the first user/human message. Used only for
+     * the dashboard tail-repair cache — a display value, not a completion decision.
+     */
+    private lastVisibleAssistantSummary(messages: unknown): string {
+        if (!Array.isArray(messages)) return '';
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+            const m = messages[i] as { role?: string; kind?: string; content?: unknown };
+            const role = typeof m?.role === 'string' ? m.role : '';
+            const kind = typeof m?.kind === 'string' ? m.kind : '';
+            if (role === 'system') continue;
+            if (kind === 'tool' || kind === 'activity') continue;
+            if (role === 'user' || role === 'human') return '';
+            if (role === 'assistant') return flattenContent(m.content as any).trim();
+            return '';
+        }
+        return '';
+    }
+
     private completionFinalAssistantEvidence(parsedMessages: unknown, turnStartedAt?: number): CompletionFinalAssistantEvidence {
         // (FALSEIDLE FixB) UPPER-BOUND turn-end evidence. completionHasFinalAssistantMessage is a
         // pure message-content check ("does the last visible bubble read as a finalized assistant
@@ -1274,8 +1382,22 @@ export class CliProviderInstance implements ProviderInstance {
 
         const externalMessages = this.readExternalCompletionMessages();
         if (externalMessages) {
+            const present = turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
+            // Dashboard tail-repair cache: this runs on EVERY completion check
+            // (mesh AND non-mesh — the non-mesh path suppresses the
+            // generating_completed emit, so completionFinalSummary never runs there
+            // and cannot cache). Cache whenever the external transcript's LAST
+            // visible bubble is an assistant reply — this is a display value only, so
+            // it is intentionally looser than the strict `present` completion gate
+            // (which also requires turnClosed and turn-scoping): the dashboard should
+            // show the answer as soon as native-history has it, even if the FSM has
+            // not yet ratified the turn end. getState() replaces it on the next turn.
+            const lastVisibleAssistant = this.lastVisibleAssistantSummary(externalMessages);
+            if (lastVisibleAssistant) {
+                this.lastCompletionSummary = { content: lastVisibleAssistant, receivedAt: Date.now() };
+            }
             return {
-                present: turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt),
+                present,
                 messages: externalMessages,
                 source: 'external-native',
             };
@@ -1328,7 +1450,15 @@ export class CliProviderInstance implements ProviderInstance {
             // The transcript is authoritative for native-source providers. Use it unless it is
             // empty (not yet written, or no in-turn bubble) — only then fall back to the screen
             // parse, which reflects the LIVE screen (this turn's output), not the stale tail.
-            if (externalSummary) return externalSummary;
+            if (externalSummary) {
+                // Cache the resolved final assistant for the dashboard tail-repair in
+                // getState(). This runs on EVERY completion attempt (including non-mesh
+                // sessions whose generating_completed is suppressed, and short-gen
+                // settle paths), so the dashboard sees the answer even when no
+                // agent:generating_completed is ever emitted. Native read already ran.
+                this.lastCompletionSummary = { content: externalSummary, receivedAt: Date.now() };
+                return externalSummary;
+            }
             return parsedSummary || undefined;
         }
         return parsedSummary || undefined;
@@ -1941,6 +2071,14 @@ export class CliProviderInstance implements ProviderInstance {
         evidenceLevel?: string;
         completionDiagnostic?: Record<string, unknown>;
     }): void {
+        // Cache the final assistant summary so the dashboard snapshot can surface it
+        // for native-source providers whose assistant answer is absent from the PTY
+        // parse (antigravity). completionFinalSummary already read native-history to
+        // produce this, so nothing extra is read here.
+        const summary = typeof opts.finalSummary === 'string' ? opts.finalSummary.trim() : '';
+        if (summary) {
+            this.lastCompletionSummary = { content: summary, receivedAt: opts.timestamp };
+        }
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle: opts.chatTitle,
@@ -2465,6 +2603,11 @@ export class CliProviderInstance implements ProviderInstance {
                 }
 
                 if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                // A genuinely new turn is underway — drop the previous turn's cached
+                // final-summary so the dashboard does not keep showing the old answer
+                // as "done" while the new turn generates. Re-populated when this turn
+                // completes.
+                this.lastCompletionSummary = null;
                 // FALSE-IDLE continuity: entering a busy phase invalidates any
                 // completedDebouncePending armed earlier in this settle window.
                 this.busyEpoch++;

package/src/providers/native-history/antigravity-claim-registry.ts

@@ -51,25 +51,32 @@ function normalizeUuid(uuid: string): string {
 }
 
 /**
- * Derive the per-session owner token. Both the dispatcher (from the read input:
- * workspace + sessionStartedAtMs) and the provider instance (from its
- * workingDir + startedAt, or its instanceId) call this with the same inputs so
- * claims and releases line up. Returns '' when there is no stable identity to
- * key on (e.g. a workspace-less discovery with no spawn time) — the caller then
- * skips claiming but the exclusion checks still run against existing claims.
+ * Derive the per-session owner token, keyed ONLY on the stable instanceId
+ * (== the session registry sessionId == the read path's targetSessionId). Both
+ * the dispatcher (read side) and the provider instance (claim/release side) pass
+ * this same id, so their tokens always agree and the claim isolation holds.
+ *
+ * Returns '' when no instanceId is available — the caller then skips claiming
+ * (the exclusion checks still run against existing claims). This is the SSOT
+ * rule: there is exactly ONE token form. The removed legacy fallback derived a
+ * `spawn:<workspace>:<sessionStartedAtMs>` token from the spawn timestamp when
+ * the instanceId was missing; because one session's spawn time is sampled
+ * independently at three sites (instance startedAt, adapter spawnedAtMs, registry
+ * spawnedAtMs) those never matched, so the SAME session's instance-side and
+ * read-side tokens silently diverged and the claim mutual-exclusion collapsed
+ * (the antigravity conversation crosswire). An empty token (skip-claim) is
+ * strictly safer than a token that disagrees with the same session's other
+ * token. workspace/sessionStartedAtMs are kept in the signature for call-site
+ * compatibility but no longer affect the token.
  */
 export function antigravityOwnerToken(
   workspace: string,
   sessionStartedAtMs: number,
   instanceId?: string,
 ): string {
+  void workspace; void sessionStartedAtMs;
   const iid = typeof instanceId === 'string' ? instanceId.trim() : '';
-  if (iid) return `iid:${iid}`;
-  if (typeof sessionStartedAtMs === 'number' && sessionStartedAtMs > 0) {
-    const ws = String(workspace || '').trim().toLowerCase();
-    return `spawn:${ws}:${sessionStartedAtMs}`;
-  }
-  return '';
+  return iid ? `iid:${iid}` : '';
 }
 
 /**

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
@@ -276,24 +314,51 @@ function resolveAntigravityPath(
     }
 
     // (2) brain/<uuid>/.system_generated/logs/transcript.jsonl (legacy full source).
-    //     Only bind to a brain transcript that is NON-EMPTY: current antigravity
-    //     writes this file but leaves it 0 bytes (all real conversation data now
-    //     lives in the per-session .db), so an empty transcript here would
-    //     otherwise shadow the .db fallback below and return no messages. Skip
-    //     empty transcripts so an unbound read still reaches the .db. Exclude any
+    //     Only bind to a brain transcript that is NON-EMPTY (antigravity may leave
+    //     it 0 bytes when the real data lives in the per-session .db). Exclude any
     //     brain conversation already claimed by a DIFFERENT live session.
+    //
+    //     Selection MUST mirror pickUnboundConversationDb (step 3): when a spawn
+    //     floor is known, a brain dir born at/after the floor is THIS session's own,
+    //     and among those the OLDEST-created wins (the store created first after the
+    //     session started). The previous newest-by-mtime sort silently mis-bound: in
+    //     a MAGI panel every co-located antigravity session (coordinator + replicas)
+    //     has a non-empty brain transcript, and the replica that finished its turn
+    //     last has the newest mtime — so a coordinator's read grabbed the replica's
+    //     transcript here, BEFORE step 3's floor-aware pick could run. That is the
+    //     antigravity coordinator↔replica crosswire, and it lives in THIS step, not
+    //     step 3. Keep newest-by-mtime only in the floor-less legacy path.
     const brainRoot = path.join(agyRoot, 'brain');
     if (fs.existsSync(brainRoot)) {
         const cutoff = spawnAwareCutoff(sessionStartedAtMs);
-        const entries = fs.readdirSync(brainRoot, { withFileTypes: true })
+        const nonEmptyBrain = (uuid: string, p: string): string | null => {
+            const t = path.join(p, '.system_generated', 'logs', 'transcript.jsonl');
+            return (fs.existsSync(t) && safeSize(t) > 0) ? t : null;
+        };
+        const all = fs.readdirSync(brainRoot, { withFileTypes: true })
             .filter(e => e.isDirectory() && isUuidLikeSessionId(e.name))
             .filter(e => !isAntigravityConversationClaimedByOther(e.name, owner))
-            .map(e => ({ uuid: e.name, p: path.join(brainRoot, e.name), mtime: safeMtime(path.join(brainRoot, e.name)) }))
-            .filter(e => e.mtime >= cutoff)
-            .sort((a, b) => b.mtime - a.mtime);
-        for (const e of entries) {
-            const t = path.join(e.p, '.system_generated', 'logs', 'transcript.jsonl');
-            if (fs.existsSync(t) && safeSize(t) > 0) {
+            .map(e => {
+                const p = path.join(brainRoot, e.name);
+                return { uuid: e.name, p, mtime: safeMtime(p), birth: safeBirthtime(p) };
+            })
+            .filter(e => e.mtime >= cutoff);
+        let ordered: Array<{ uuid: string; p: string }> = [];
+        if (sessionStartedAtMs > 0) {
+            // Floor branch: this session's own = born at/after (floor - grace),
+            // oldest-birth first. Mirrors pickUnboundConversationDb exactly so the
+            // two steps can never resolve DIFFERENT conversations for one session.
+            const floor = sessionStartedAtMs - AGY_SPAWN_CLAIM_GRACE_MS;
+            ordered = all
+                .filter(e => (e.birth > 0 ? e.birth : e.mtime) >= floor)
+                .sort((a, b) => (a.birth || a.mtime) - (b.birth || b.mtime));
+        } else {
+            // Floor-less legacy/unpinned discovery: newest-by-mtime (single-session).
+            ordered = [...all].sort((a, b) => b.mtime - a.mtime);
+        }
+        for (const e of ordered) {
+            const t = nonEmptyBrain(e.uuid, e.p);
+            if (t) {
                 if (owner) claimAntigravityConversation(e.uuid, owner);
                 return t;
             }
@@ -341,6 +406,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 +430,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/sessions/registry.ts

@@ -14,6 +14,19 @@ export interface SessionRuntimeTarget {
     /** Wall clock at register time. native-history readers use it as a
      *  cutoff so a fresh session can't show records from a prior one. */
     spawnedAtMs?: number;
+    /**
+     * Authoritative provider-native conversation id for this session (SSOT).
+     * For providers that expose a session id on the CLI (codex/claude/hermes)
+     * this equals that id. For antigravity — which takes no --session-id — this
+     * is the on-disk conversations/<uuid>.db basename, discovered by the
+     * native-history dispatcher and written back here via setProviderSessionId
+     * the first time it resolves. Every downstream reader (read_chat, the
+     * completion probe, the dashboard) should prefer this over re-deriving the
+     * conversation by spawn-floor/mtime heuristics — that re-derivation is the
+     * source of the antigravity conversation crosswire/theft class. Empty until
+     * the first successful native read binds it.
+     */
+    providerSessionId?: string;
 }
 
 export class SessionRegistry {
@@ -23,7 +36,15 @@ export class SessionRegistry {
     private readonly byParentSessionId = new Map<string, Set<string>>();
 
     register(target: SessionRuntimeTarget): void {
+        // Preserve an already-resolved conversation binding across a
+        // re-register (attach-restore, meta refresh): the caller rarely knows
+        // the antigravity conv uuid at register time, so a plain replace would
+        // drop the SSOT binding and force a fresh (crosswire-prone) re-resolve.
+        const priorProviderSessionId = this.bySessionId.get(target.sessionId)?.providerSessionId;
         this.unregister(target.sessionId);
+        if (priorProviderSessionId && !target.providerSessionId) {
+            target = { ...target, providerSessionId: priorProviderSessionId };
+        }
         this.bySessionId.set(target.sessionId, target);
         if (target.cdpManagerKey) this.addIndex(this.byManagerKey, target.cdpManagerKey, target.sessionId);
         if (target.instanceKey) this.addIndex(this.byInstanceKey, target.instanceKey, target.sessionId);
@@ -35,6 +56,23 @@ export class SessionRegistry {
         return this.bySessionId.get(sessionId);
     }
 
+    /**
+     * Record the authoritative provider-native conversation id for a session
+     * (SSOT). Idempotent; a no-op when the session is unknown or the value is
+     * empty or unchanged. Never overwrites a known binding with an empty one.
+     * Returns whether the stored value changed.
+     */
+    setProviderSessionId(sessionId: string | undefined | null, providerSessionId: string | undefined | null): boolean {
+        const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+        const value = typeof providerSessionId === 'string' ? providerSessionId.trim() : '';
+        if (!sid || !value) return false;
+        const target = this.bySessionId.get(sid);
+        if (!target) return false;
+        if (target.providerSessionId === value) return false;
+        target.providerSessionId = value;
+        return true;
+    }
+
     unregister(sessionId: string | undefined | null): void {
         if (!sessionId) return;
         const target = this.bySessionId.get(sessionId);

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 {