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

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -11,6 +11,14 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
 } | {
     success: boolean;
     forwarded: number;
+    suppressed: boolean;
+    autoApprovingWorkerApproval: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed?: undefined;
+    autoApprovingWorkerApproval?: undefined;
     error?: undefined;
 } | {
     success: boolean;

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

@@ -308,6 +308,18 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebounceTimer;
     private completedDebouncePending;
     private lastExternalCompletionProbe;
+    /**
+     * 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;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
     private recordPendingTranscriptProbe;
@@ -321,6 +333,13 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     private spawnedEnvOverrides;
     private readExternalCompletionMessages;
+    /**
+     * 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;
     private completionFinalAssistantEvidence;
     private completionFinalSummary;
     private buildCompletedFinalizationDiagnostic;

package/dist/providers/native-history/antigravity-claim-registry.d.ts

@@ -1,12 +1,23 @@
 /** A claim older than this with no refresh is reclaimable (owner presumed dead). */
 export declare const CLAIM_STALE_MS: number;
 /**
- * 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 declare function antigravityOwnerToken(workspace: string, sessionStartedAtMs: number, instanceId?: string): string;
 /**

package/dist/sessions/registry.d.ts

@@ -13,6 +13,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 declare class SessionRegistry {
     private readonly bySessionId;
@@ -21,6 +34,13 @@ export declare class SessionRegistry {
     private readonly byParentSessionId;
     register(target: SessionRuntimeTarget): void;
     get(sessionId: string | undefined | null): SessionRuntimeTarget | undefined;
+    /**
+     * 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;
     unregister(sessionId: string | undefined | null): void;
     unregisterByManagerKey(managerKey: string): void;
     unregisterByInstanceKey(instanceKey: string): void;

package/package.json

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

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

@@ -91,10 +91,18 @@ function hydratePersistedProviderSessionPinsOnce(): void {
     }
 }
 
-function recordBoundProviderSessionId(meshSessionId: string | undefined, providerSessionId: string | undefined): void {
+function recordBoundProviderSessionId(h: CommandHelpers, 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;
+    // SSOT: the session registry entry (keyed by sessionId == instanceId) is the
+    // authoritative sessionId → conversation-uuid record. Writing it here — the
+    // moment a native read resolves the real conversation id — makes
+    // getHistorySessionId return it directly on every subsequent read, so the
+    // conversation is exact-bound instead of re-resolved by the spawn-floor/mtime
+    // heuristic (the crosswire/theft source). The pin below stays as the durable
+    // cross-restart mirror (the registry is in-memory and cleared on restart).
+    try { h.ctx?.sessionRegistry?.setProviderSessionId?.(key, value); } catch { /* best-effort SSOT write-back */ }
     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
@@ -1084,6 +1092,28 @@ function hasSafeNativeHistoryMapping(args: {
 // other. historySessionId (the provider-native session key) is required to
 // establish ownership. hasSafeNativeHistoryMapping() enforces the same
 // invariant after the read; both guards must hold for native history to be used.
+/**
+ * The session id a native-history read should be scoped to: the explicit
+ * targetSessionId when the caller named one (reading a specific/worker
+ * session), otherwise the current live session (a self / dashboard read where
+ * the current session IS the one being read). getTargetedCliAdapter already
+ * uses this same fallback to resolve the adapter; the native-history floor and
+ * claim-owner token must use it too. Without the fallback, a self-read arrives
+ * with no targetSessionId → the floor collapses to undefined (→0) and the
+ * antigravity claim-owner token collapses to '' → pickUnboundConversationDb
+ * drops out of its spawn-floor branch into newest-by-mtime and binds whichever
+ * conversation .db was written most recently. For an antigravity MAGI
+ * coordinator that is exactly a co-located replica's .db (the replica finished
+ * its turn last), so the coordinator's read cross-wires onto the replica's
+ * conversation instead of its own (ANTIGRAVITY coordinator↔replica crosswire).
+ */
+function effectiveReadSessionId(h: CommandHelpers, targetSessionId: string | undefined): string {
+    const explicit = typeof targetSessionId === 'string' ? targetSessionId.trim() : '';
+    if (explicit) return explicit;
+    const current = (h.currentSession as any)?.sessionId;
+    return typeof current === 'string' ? current.trim() : '';
+}
+
 /**
  * Pull the session's spawnedAtMs out of the registry. Native-history
  * file pickers use it as a "files older than this can't be from this
@@ -1091,10 +1121,12 @@ function hasSafeNativeHistoryMapping(args: {
  * previous session's transcript whenever its file happened to be the
  * newest match. Returns undefined when the session isn't registered
  * (e.g. read_chat before the live session was wired up) — the executor
- * treats undefined as "no floor".
+ * treats undefined as "no floor". Resolves the effective session id
+ * (targetSessionId or the current live session) so a self-read still gets its
+ * real spawn floor rather than 0.
  */
 function sessionStartedAtMsFromRegistry(h: CommandHelpers, targetSessionId: string | undefined): number | undefined {
-    const sid = typeof targetSessionId === 'string' ? targetSessionId.trim() : '';
+    const sid = effectiveReadSessionId(h, targetSessionId);
     if (!sid) return undefined;
     const target = h.ctx?.sessionRegistry?.get?.(sid);
     return typeof target?.spawnedAtMs === 'number' ? target.spawnedAtMs : undefined;
@@ -1597,7 +1629,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,
+                instanceId: effectiveReadSessionId(h, args?.targetSessionId) || undefined,
                 pinnedProviderSessionId: getBoundProviderSessionIdPin(args?.targetSessionId),
             })
             : readProviderChatHistory(agentStr, {
@@ -1619,7 +1651,7 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
                 ? (result as any).providerSessionId
                 : readHistorySessionIdFromMessages(messages) || historySessionId;
             if (typeof (result as any)?.providerSessionId === 'string' && (result as any).providerSessionId.trim()) {
-                recordBoundProviderSessionId(args?.targetSessionId, (result as any).providerSessionId.trim());
+                recordBoundProviderSessionId(h, effectiveReadSessionId(h, args?.targetSessionId), (result as any).providerSessionId.trim());
             }
             const safeMapping = hasSafeNativeHistoryMapping({
                 historySessionId: lookup === 'workspace' ? undefined : historySessionId,
@@ -1852,7 +1884,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         envOverrides: sessionSpawnEnvFromAdapter(h, args?.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,
+                        instanceId: effectiveReadSessionId(h, args?.targetSessionId) || undefined,
                         pinnedProviderSessionId: pinnedProviderSessionIdForRead,
                         // Last-resort only when no pin was ever recorded for this
                         // session; the downstream workspace-overlap safety gate
@@ -1868,7 +1900,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         ? nativeHistory.providerSessionId.trim()
                         : '';
                     if (resolvedProviderSessionId) {
-                        recordBoundProviderSessionId(targetSessionId, resolvedProviderSessionId);
+                        recordBoundProviderSessionId(h, effectiveReadSessionId(h, targetSessionId), resolvedProviderSessionId);
                     }
                 } catch (error: any) {
                     nativeHistoryError = error;
@@ -1928,7 +1960,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,
+                        instanceId: effectiveReadSessionId(h, args?.targetSessionId) || undefined,
                     });
                     nativeHistoryError = undefined;
                     nativeMessages = nativeHistory && Array.isArray(nativeHistory.messages)
@@ -2227,7 +2259,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,
+                    instanceId: effectiveReadSessionId(h, 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.
@@ -2252,7 +2284,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 : readHistorySessionIdFromMessages(historyMessages) || effectiveHistorySessionIdForRead;
             // Refresh the pin whenever this path resolves a real provider id.
             if (typeof (history as any)?.providerSessionId === 'string' && (history as any).providerSessionId.trim()) {
-                recordBoundProviderSessionId(targetSid, (history as any).providerSessionId.trim());
+                recordBoundProviderSessionId(h, effectiveReadSessionId(h, targetSid), (history as any).providerSessionId.trim());
             }
             // Use the id we actually read with (pin / real provider id), NOT the
             // raw runtime-fallback historySessionId — otherwise the mapping guard

package/src/mesh/mesh-event-forwarding.ts

@@ -688,6 +688,31 @@ function evaluateMeshEventSuppression(
     return null;
 }
 
+/**
+ * True when the worker session that emitted this event has auto-approve enabled
+ * (a MAGI/delegated worker is launched with autoApprove:true). Such a worker
+ * resolves its own approval modals locally, so an agent:waiting_approval event
+ * from it is transient noise for the coordinator: forwarding it injects a
+ * "[System] … is waiting for approval, use mesh_approve" turn that the
+ * coordinator cannot usefully act on (the modal is already auto-resolving) and,
+ * mid-MAGI-collect, HIJACKS the coordinator's synthesis turn — the observed
+ * failure where a replica's repeated auto-approvals drowned out the completion
+ * events and the coordinator answered about approvals instead of the RCA. Only
+ * suppress when we can positively confirm the source worker auto-approves; a
+ * worker that genuinely needs a human/coordinator approval (autoApprove off)
+ * still forwards so the coordinator is told.
+ */
+function sourceWorkerAutoApproves(components: DaemonComponents, sessionId: string): boolean {
+    if (!sessionId) return false;
+    try {
+        const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+        const settings = (state?.settings as Record<string, unknown>) || {};
+        return settings.autoApprove === true;
+    } catch {
+        return false;
+    }
+}
+
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
@@ -805,6 +830,19 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     }
 
     const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+
+    // Auto-approving worker: never forward its approval prompts to the coordinator.
+    // The daemon resolves the modal locally, so the "[System] … waiting for
+    // approval" injection is pure noise that hijacks the coordinator's turn — the
+    // observed MAGI failure where a replica's repeated auto-approvals flooded the
+    // coordinator and derailed its final synthesis. A worker without auto-approve
+    // (genuinely blocked on a human/coordinator decision) still forwards.
+    if (args.event === 'agent:waiting_approval' && sourceWorkerAutoApproves(components, eventSessionId)) {
+        LOG.info('MeshEvents', `Suppressed agent:waiting_approval for auto-approving worker session ${eventSessionId || '(unknown)'} (mesh ${args.meshId}) — modal is resolved locally, coordinator not notified`);
+        traceMeshEventDrop('waiting_approval_auto_approving_worker', traceCtx);
+        return { success: true, forwarded: 0, suppressed: true, autoApprovingWorkerApproval: true };
+    }
+
     // Coordinator-side dedup/suppression gate (extracted, behavior-preserving). A non-null
     // outcome either short-circuits with a forwarded result or signals a no-progress→completion
     // reconciliation that we re-inject; null lets the event fall through to the ledger machinery.

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}` : '';
 }
 
 /**