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

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.475",
+  "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.475",
-    "@adhdev/session-host-core": "0.9.82-rc.475",
+    "@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;
@@ -1768,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,
@@ -1784,11 +1853,11 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         // 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: getBoundProviderSessionIdPin(targetSessionId),
+                        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

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/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/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 {