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

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/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.477",
   "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.477",
+    "@adhdev/session-host-core": "0.9.82-rc.477",
     "@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,77 @@ 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 recordBoundProviderSessionId(meshSessionId: string | undefined, providerSessionId: string | undefined): void {
+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(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
+    // 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;
@@ -1036,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
@@ -1043,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;
@@ -1549,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, {
@@ -1571,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,
@@ -1768,10 +1848,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,
@@ -1783,12 +1884,12 @@ 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,
-                        pinnedProviderSessionId: getBoundProviderSessionIdPin(targetSessionId),
+                        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
                         // 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
@@ -1799,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;
@@ -1859,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)
@@ -2158,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.
@@ -2183,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/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/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.