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

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

@@ -314,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;
             }

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);