@adhdev/daemon-core 0.9.82-rc.137 → 0.9.82-rc.138

package/dist/index.mjs

@@ -4343,7 +4343,14 @@ var init_ghostty_vt_backend = __esm({
         this.terminal.write(data);
       }
       getText() {
-        return this.terminal.formatPlainText({ trim: true }) || "";
+        const raw = this.terminal.formatPlainText({ trim: false }) || "";
+        if (!raw) return "";
+        const lines = raw.split("\n").map((row) => row.replace(/\s+$/, ""));
+        let first = 0;
+        let last = lines.length;
+        while (first < last && !lines[first]) first += 1;
+        while (last > first && !lines[last - 1]) last -= 1;
+        return lines.slice(first, last).join("\n");
       }
       getCursorPosition() {
         return this.terminal.getCursorPosition();
@@ -4397,7 +4404,8 @@ var init_xterm_backend = __esm({
         const lines = [];
         for (let i = start; i < end; i++) {
           const line = buffer.getLine(i);
-          lines.push(line ? line.translateToString(true) : "");
+          const raw = line ? line.translateToString(false) : "";
+          lines.push(raw.replace(/\s+$/, ""));
         }
         let first = 0;
         let last = lines.length;
@@ -4932,8 +4940,13 @@ var init_provider_cli_shared = __esm({
         this.ensureRow();
         if (final === "A") this.row = Math.max(0, this.row - count);
         else if (final === "B") this.row += count;
-        else if (final === "C") this.col += count;
-        else if (final === "D") this.col = Math.max(0, this.col - count);
+        else if (final === "C") {
+          const line = this.lines[this.row];
+          for (let c = this.col; c < this.col + count; c += 1) {
+            if (line[c] === void 0) line[c] = " ";
+          }
+          this.col += count;
+        } else if (final === "D") this.col = Math.max(0, this.col - count);
         else if (final === "G") this.col = Math.max(0, count - 1);
         else if (final === "H" || final === "f") {
           const parts = String(params || "").split(";");
@@ -5106,7 +5119,8 @@ function buildCliParseInput(options) {
     partialResponse,
     isWaitingForResponse,
     scope,
-    runtimeSettings
+    runtimeSettings,
+    spawnAt
   } = options;
   const buffer = scope ? sliceFromOffset(accumulatedBuffer, scope.bufferStart) : accumulatedBuffer;
   const rawBuffer = scope ? sliceFromOffset(accumulatedRawBuffer, scope.rawBufferStart) : accumulatedRawBuffer;
@@ -5128,7 +5142,8 @@ function buildCliParseInput(options) {
     partialResponse,
     isWaitingForResponse,
     promptText: scope?.prompt || "",
-    settings: { ...runtimeSettings }
+    settings: { ...runtimeSettings },
+    ...typeof spawnAt === "number" && spawnAt > 0 ? { spawnAt } : {}
   };
 }
 function summarizeCliTraceText(text, max = 800) {
@@ -5144,7 +5159,7 @@ var init_provider_cli_parse = __esm({
 });
 
 // src/cli-adapters/cli-state-engine.ts
-var SCRIPT_STATUS_DEBOUNCE_MS, MAX_FINISH_RETRIES, FINISH_RETRY_DELAY_MS, MAX_TRACE_ENTRIES, APPROVAL_EXIT_TIMEOUT_MS, CliStateEngine;
+var SCRIPT_STATUS_DEBOUNCE_MS, MAX_FINISH_RETRIES, FINISH_RETRY_DELAY_MS, MAX_TRACE_ENTRIES, APPROVAL_EXIT_TIMEOUT_MS, IDLE_CONFIRMATION_GRACE_MS, CliStateEngine;
 var init_cli_state_engine = __esm({
   "src/cli-adapters/cli-state-engine.ts"() {
     "use strict";
@@ -5156,6 +5171,7 @@ var init_cli_state_engine = __esm({
     FINISH_RETRY_DELAY_MS = 300;
     MAX_TRACE_ENTRIES = 250;
     APPROVAL_EXIT_TIMEOUT_MS = 6e4;
+    IDLE_CONFIRMATION_GRACE_MS = 2e3;
     CliStateEngine = class {
       constructor(provider, runner, transport, callbacks, timeouts) {
         this.provider = provider;
@@ -5194,6 +5210,20 @@ var init_cli_state_engine = __esm({
       pendingScriptStatusTimer = null;
       // ── Idle candidate ───────────────────────────────
       idleFinishCandidate = null;
+      // ── Idle confirmation grace ──────────────────────
+      /**
+       * `finishResponse` produces the `generating → idle` transition that
+       * coordinators interpret as "task complete". Some providers (antigravity-
+       * cli observed in the wild) briefly paint a screen that looks like an
+       * idle prompt between tool result frames while still actively running,
+       * which fired `response_finished` and broke completion semantics.
+       * We defer the actual idle transition by IDLE_CONFIRMATION_GRACE_MS and
+       * cancel it if the scripted detection re-detects generating during that
+       * window — a true completion stays idle for many seconds, so a 2-second
+       * grace is sufficient to filter the paint blip.
+       */
+      pendingIdleFinishTimer = null;
+      pendingIdleFinishAt = 0;
       // ── Status history (debug) ───────────────────────
       statusHistory = [];
       traceEntries = [];
@@ -5368,6 +5398,11 @@ var init_cli_state_engine = __esm({
           clearTimeout(this.providerErrorRetryTimer);
           this.providerErrorRetryTimer = null;
         }
+        if (this.pendingIdleFinishTimer) {
+          clearTimeout(this.pendingIdleFinishTimer);
+          this.pendingIdleFinishTimer = null;
+          this.pendingIdleFinishAt = 0;
+        }
         this.providerErrorRetryKey = "";
       }
       resetActiveTurnState() {
@@ -5511,7 +5546,7 @@ var init_cli_state_engine = __esm({
           "CLI",
           `[${this.provider.type}] settled diagnostics prompt=${JSON.stringify(this.currentTurnScope?.prompt || "").slice(0, 140)} status=${String(status || "")} parsedStatus=${String(parsedStatus || "")} parsedMsgCount=${parsedMessages.length} lastParsedAssistant=${JSON.stringify((lastParsedAssistant?.content || "").slice(0, 120)).slice(0, 160)} responseBuffer=${JSON.stringify((snap.responseBuffer || "").slice(0, 160)).slice(0, 220)}`
         );
-        const shouldHoldGenerating = status === "idle" && this.isWaitingForResponse && !modal && recentInteractiveActivity && !(parsedStatus === "idle" && !!lastParsedAssistant);
+        const shouldHoldGenerating = status === "idle" && this.isWaitingForResponse && !!this.currentTurnScope && !modal && recentInteractiveActivity && !(parsedStatus === "idle" && !!lastParsedAssistant);
         if (shouldHoldGenerating) {
           this.applyHoldGenerating(ctx);
           return;
@@ -5607,19 +5642,30 @@ var init_cli_state_engine = __esm({
         if (!inCooldown) {
           if (!modal) {
             LOG.warn("CLI", `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
+            if (this.currentStatus === "waiting_approval") {
+              this.activeModal = null;
+              this.setStatus("generating", "approval_lost_modal");
+              this.callbacks.onStatusChange();
+            }
             return;
           }
           this.isWaitingForResponse = true;
           this.setStatus("waiting_approval", "script_detect");
-          this.activeModal = modal;
+          const prev = this.activeModal;
+          const prevBtnCount = Array.isArray(prev?.buttons) ? prev.buttons.length : 0;
+          const nextBtnCount = Array.isArray(modal.buttons) ? modal.buttons.length : 0;
+          if (!prev || prevBtnCount !== nextBtnCount) {
+            this.activeModal = modal;
+            this.callbacks.onStatusChange();
+          }
           if (this.idleTimeout) clearTimeout(this.idleTimeout);
           this.armApprovalExitTimeout();
-          this.callbacks.onStatusChange();
         }
       }
       applyGenerating(ctx) {
         const { modal, parsedMessages, lastParsedAssistant, parsedStatus, prevStatus } = ctx;
         this.clearIdleFinishCandidate("generating");
+        this.cancelPendingIdleFinish("generating_signal_returned");
         const snap = this.transport.getSnapshot();
         const effectiveScreenText = snap.screenText || snap.accumulatedBuffer;
         const noActiveTurn = !this.currentTurnScope;
@@ -5780,10 +5826,27 @@ var init_cli_state_engine = __esm({
         }
         this.resetActiveTurnState();
         this.callbacks.onTurnCompleted();
-        this.setStatus("idle", "response_finished");
-        this.callbacks.onStatusChange();
+        this.scheduleIdleFinish("response_finished");
         this.transport.flushOutboundQueue();
       }
+      scheduleIdleFinish(reason) {
+        if (this.pendingIdleFinishTimer) clearTimeout(this.pendingIdleFinishTimer);
+        this.pendingIdleFinishAt = Date.now() + IDLE_CONFIRMATION_GRACE_MS;
+        this.pendingIdleFinishTimer = setTimeout(() => {
+          this.pendingIdleFinishTimer = null;
+          this.pendingIdleFinishAt = 0;
+          if (this.isWaitingForResponse) return;
+          this.setStatus("idle", reason);
+          this.callbacks.onStatusChange();
+        }, IDLE_CONFIRMATION_GRACE_MS);
+      }
+      cancelPendingIdleFinish(reason) {
+        if (!this.pendingIdleFinishTimer) return;
+        clearTimeout(this.pendingIdleFinishTimer);
+        this.pendingIdleFinishTimer = null;
+        this.pendingIdleFinishAt = 0;
+        this.recordTrace("idle_finish_cancelled", { trigger: reason });
+      }
       // ─── Helpers ────────────────────────────────────────────────────────────
       armApprovalExitTimeout() {
         if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
@@ -6219,9 +6282,10 @@ var init_provider_cli_adapter = __esm({
       submitRetryTimer = null;
       // Resize redraw suppression
       resizeSuppressUntil = 0;
-      // Native transcript anchor — when >0, native history was confirmed for this session.
-      // Prevents freshEnough flips caused by PTY buffer activity after the first successful native read.
-      nativeHistoryAnchoredAt = 0;
+      // (A2.2) Native transcript anchor moved to CHAT_SOURCE_REGISTRY.
+      // ChatSourceMachine holds the lock by state, not by a mutable field on
+      // the adapter. Removed entirely; no callers remain after the readChat
+      // ladder was replaced.
       // ─── Script runner (parsing isolated here, adapter stays as transport) ───
       runner;
       /** @deprecated use runner.cliScripts for direct script access */
@@ -6557,6 +6621,8 @@ ${lastSnapshot}`;
             this.engine.lastApprovalResolvedAt = Date.now();
           }
           this.engine.activeModal = null;
+          this.engine.isWaitingForResponse = false;
+          this.engine.currentTurnScope = null;
           this.engine.setStatus("idle", `startup_ready:${trigger}`);
         }
         LOG.info(
@@ -6649,7 +6715,8 @@ ${lastSnapshot}`;
           partialResponse: this.responseBuffer,
           isWaitingForResponse: this.engine.isWaitingForResponse,
           scope: this.engine.currentTurnScope,
-          runtimeSettings: this.runtimeSettings
+          runtimeSettings: this.runtimeSettings,
+          spawnAt: this.spawnAt
         });
         const session = this.runner.parseSession({
           ...input,
@@ -6686,7 +6753,7 @@ ${lastSnapshot}`;
       }
       applyParsedSessionMetadata(parsed) {
         const providerSessionId = typeof parsed?.providerSessionId === "string" && parsed.providerSessionId.trim() ? parsed.providerSessionId.trim() : "";
-        if (providerSessionId) {
+        if (providerSessionId && providerSessionId !== this.providerSessionId) {
           this.providerSessionId = providerSessionId;
           this.updateRuntimeMeta({ providerSessionId });
         }
@@ -6704,7 +6771,25 @@ ${lastSnapshot}`;
         const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText()) : null;
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.engine.activeModal;
-        if (startupDetectedStatus === "waiting_approval") {
+        if (allowParse && !effectiveModal && this.engine.isWaitingForResponse) {
+          const liveDetect = this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText());
+          if (liveDetect === "waiting_approval") {
+            const liveModal = this.runParseApproval(this.terminalScreen.getText()) || this.runParseApproval(this.recentOutputBuffer);
+            if (liveModal) {
+              effectiveModal = liveModal;
+              if (!this.engine.activeModal) this.engine.activeModal = liveModal;
+            } else {
+              LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: detect=waiting_approval but parseApproval still null (recentLen=${this.recentOutputBuffer.length} screenLen=${this.terminalScreen.getText().length})`);
+            }
+          } else if (liveDetect && liveDetect !== "generating" && liveDetect !== "idle") {
+            LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: detect=${liveDetect} (not waiting_approval)`);
+          } else if (this.engine.currentStatus === "waiting_approval" && liveDetect !== "waiting_approval") {
+            LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: engine.status=waiting_approval but live detect=${liveDetect}`);
+          }
+        } else if (!effectiveModal && this.engine.currentStatus === "waiting_approval") {
+          LOG.warn("CLI", `[${this.cliType}] getStatus skipped live re-extract: allowParse=${allowParse} isWaitingForResponse=${this.engine.isWaitingForResponse}`);
+        }
+        if (startupDetectedStatus === "waiting_approval" && effectiveModal) {
           effectiveStatus = "waiting_approval";
         } else if (startupDetectedStatus === "idle" && !startupModal && !effectiveModal) {
           effectiveStatus = "idle";
@@ -6806,7 +6891,8 @@ ${lastSnapshot}`;
           partialResponse: this.responseBuffer,
           isWaitingForResponse: this.engine.isWaitingForResponse,
           scope: this.engine.currentTurnScope,
-          runtimeSettings: this.runtimeSettings
+          runtimeSettings: this.runtimeSettings,
+          spawnAt: this.spawnAt
         });
         return await Promise.resolve(this.runner.invokeByName(scriptName, {
           ...input,
@@ -14577,19 +14663,37 @@ function getProviderNativeHistoryScript(scripts, canonicalHistory, key) {
 function normalizeProviderNativeHistoryRecords(agentType, historySessionId, records) {
   if (!Array.isArray(records)) return [];
   const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
-  return records.map((record) => sanitizeHistoryMessage(agentType, {
-    ts: typeof record?.ts === "string" ? record.ts : new Date(Number(record?.receivedAt) || Date.now()).toISOString(),
-    receivedAt: Number(record?.receivedAt) || Date.parse(record?.ts || "") || Date.now(),
-    role: record?.role,
-    content: String(record?.content || ""),
-    kind: record?.kind || (record?.role === "system" ? "session_start" : "standard"),
-    senderName: record?.senderName,
-    agent: agentType,
-    instanceId: record?.instanceId,
-    historySessionId: normalizeSavedHistorySessionId(record?.historySessionId || normalizedSessionId),
-    sessionTitle: record?.sessionTitle,
-    workspace: record?.workspace
-  })).filter(Boolean);
+  return records.map((record) => {
+    const base = {
+      ts: typeof record?.ts === "string" ? record.ts : new Date(Number(record?.receivedAt) || Date.now()).toISOString(),
+      receivedAt: Number(record?.receivedAt) || Date.parse(record?.ts || "") || Date.now(),
+      role: record?.role,
+      content: String(record?.content || ""),
+      kind: record?.kind || (record?.role === "system" ? "session_start" : "standard"),
+      senderName: record?.senderName,
+      agent: agentType,
+      instanceId: record?.instanceId,
+      historySessionId: normalizeSavedHistorySessionId(record?.historySessionId || normalizedSessionId),
+      sessionTitle: record?.sessionTitle,
+      workspace: record?.workspace
+    };
+    if (typeof record?.providerUnitKey === "string" && record.providerUnitKey) {
+      base.providerUnitKey = record.providerUnitKey;
+    }
+    if (typeof record?.bubbleId === "string" && record.bubbleId) {
+      base.bubbleId = record.bubbleId;
+    }
+    if (typeof record?.sequence === "number" && Number.isFinite(record.sequence)) {
+      base.sequence = record.sequence;
+    }
+    if (typeof record?._turnKey === "string" && record._turnKey) {
+      base._turnKey = record._turnKey;
+    }
+    if (typeof record?.bubbleState === "string" && record.bubbleState) {
+      base.bubbleState = record.bubbleState;
+    }
+    return sanitizeHistoryMessage(agentType, base);
+  }).filter(Boolean);
 }
 function callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, historySessionId, workspace, excludeInProgressTurn) {
   const fn = getProviderNativeHistoryScript(scripts, canonicalHistory, "readSession");
@@ -15254,6 +15358,9 @@ ${effect.notification.body || ""}`.trim();
 // src/providers/ide-provider-instance.ts
 init_logger();
 
+// src/providers/transcript-v2.ts
+var CHAT_CONTRACT_VERSION_V1 = "1.0";
+
 // src/providers/read-chat-contract.ts
 var VALID_STATUSES = ["idle", "generating", "waiting_approval", "error", "panel_hidden", "starting", "streaming", "long_generating"];
 var VALID_ROLES = ["user", "assistant", "system", "human"];
@@ -15310,6 +15417,7 @@ function validateMessage(message, source, index) {
   if (isFiniteNumber(message.index)) normalized.index = message.index;
   if (isFiniteNumber(message.timestamp)) normalized.timestamp = message.timestamp;
   if (isFiniteNumber(message.receivedAt)) normalized.receivedAt = message.receivedAt;
+  if (isFiniteNumber(message.sequence)) normalized.sequence = message.sequence;
   if (typeof message._turnKey === "string") normalized._turnKey = message._turnKey;
   if (Array.isArray(message.toolCalls)) normalized.toolCalls = message.toolCalls;
   if (isPlainObject3(message.meta)) normalized.meta = message.meta;
@@ -17241,12 +17349,365 @@ function buildSessionModalDeliverySignature(payload) {
   ]);
 }
 
+// src/chat/source-machine.ts
+var INITIAL_CHAT_SOURCE_STATE = Object.freeze({
+  name: "Booting",
+  nativeSequencePeak: void 0,
+  committedUnitKeys: Object.freeze(/* @__PURE__ */ new Set()),
+  recoveringMisses: 0
+});
+var RECOVERING_MISS_PROMOTION_THRESHOLD = 3;
+function transitionChatSourceState(prev, observation, at, lockedSince) {
+  const fromState = prev.name;
+  if (observation.kind === "native_unavailable") {
+    return handleNativeUnavailable(prev, observation.reason, at, lockedSince);
+  }
+  return handleNativePresent(prev, observation, at, lockedSince, fromState);
+}
+function handleNativeUnavailable(prev, reason, at, lockedSince) {
+  const cause = reasonToUnavailableCause(reason);
+  const fromState = prev.name;
+  if (prev.name === "Booting") {
+    const next2 = {
+      name: "PtyOnly",
+      nativeSequencePeak: void 0,
+      committedUnitKeys: prev.committedUnitKeys,
+      recoveringMisses: 0
+    };
+    return {
+      next: next2,
+      selected: "pty-parser",
+      transition: { fromState, toState: "PtyOnly", event: "NativeUnavailable", cause, at },
+      lockState: { locked: false }
+    };
+  }
+  if (prev.name === "PtyOnly") {
+    return {
+      next: prev,
+      selected: "pty-parser",
+      transition: { fromState, toState: "PtyOnly", event: "NoOp", cause, at },
+      lockState: { locked: false }
+    };
+  }
+  if (prev.name === "NativeLocked") {
+    const next2 = {
+      name: "Recovering",
+      nativeSequencePeak: prev.nativeSequencePeak,
+      committedUnitKeys: prev.committedUnitKeys,
+      recoveringMisses: 1
+    };
+    return {
+      next: next2,
+      selected: "pty-parser",
+      transition: { fromState, toState: "Recovering", event: "NativeUnavailable", cause, at },
+      lockState: { locked: false }
+    };
+  }
+  const misses = prev.recoveringMisses + 1;
+  if (misses >= RECOVERING_MISS_PROMOTION_THRESHOLD) {
+    const next2 = {
+      name: "PtyOnly",
+      nativeSequencePeak: prev.nativeSequencePeak,
+      committedUnitKeys: prev.committedUnitKeys,
+      recoveringMisses: 0
+    };
+    return {
+      next: next2,
+      selected: "pty-parser",
+      transition: { fromState, toState: "PtyOnly", event: "NativeUnavailable", cause, at },
+      lockState: { locked: false }
+    };
+  }
+  const next = {
+    name: "Recovering",
+    nativeSequencePeak: prev.nativeSequencePeak,
+    committedUnitKeys: prev.committedUnitKeys,
+    recoveringMisses: misses
+  };
+  return {
+    next,
+    selected: "pty-parser",
+    transition: { fromState, toState: "Recovering", event: "NoOp", cause, at },
+    lockState: { locked: false }
+  };
+}
+function handleNativePresent(prev, observation, at, lockedSince, fromState) {
+  if (!observation.safeMapping) {
+    return regressTo(prev, fromState, "native_regressed_unsafe_mapping", at);
+  }
+  if (observation.coverage === "partial" && observation.messages.length === 0) {
+    return regressTo(prev, fromState, "native_regressed_coverage_partial", at);
+  }
+  if (observation.messages.length === 0) {
+    return handleNativeUnavailable(prev, "empty", at, lockedSince);
+  }
+  const incomingUnitKeys = collectUnitKeys(observation.messages);
+  const incomingPeak = maxSequence(observation.messages);
+  if (prev.name === "Booting") {
+    if (observation.coverage === "partial") {
+      const next2 = {
+        name: "Recovering",
+        nativeSequencePeak: incomingPeak,
+        committedUnitKeys: incomingUnitKeys,
+        recoveringMisses: 0
+      };
+      return {
+        next: next2,
+        selected: "pty-parser",
+        transition: { fromState, toState: "Recovering", event: "NativeProgressed", cause: "native_progressed", at },
+        lockState: { locked: false }
+      };
+    }
+    const next = {
+      name: "NativeLocked",
+      nativeSequencePeak: incomingPeak,
+      committedUnitKeys: incomingUnitKeys,
+      recoveringMisses: 0
+    };
+    return {
+      next,
+      selected: "native-history",
+      transition: { fromState, toState: "NativeLocked", event: "NativeProgressed", cause: "native_progressed", at },
+      lockState: { locked: true, lockedSince: at }
+    };
+  }
+  if (prev.name === "NativeLocked") {
+    if (!isSupersetOf(incomingUnitKeys, prev.committedUnitKeys)) {
+      return regressTo(prev, fromState, "native_regressed_shrunk", at);
+    }
+    if (prev.nativeSequencePeak !== void 0 && incomingPeak < prev.nativeSequencePeak) {
+      return regressTo(prev, fromState, "native_regressed_shrunk", at);
+    }
+    const next = {
+      name: "NativeLocked",
+      nativeSequencePeak: Math.max(prev.nativeSequencePeak ?? incomingPeak, incomingPeak),
+      committedUnitKeys: incomingUnitKeys,
+      recoveringMisses: 0
+    };
+    return {
+      next,
+      selected: "native-history",
+      transition: { fromState, toState: "NativeLocked", event: "NoOp", cause: "native_progressed", at },
+      lockState: { locked: true, lockedSince: lockedSince ?? at }
+    };
+  }
+  if (prev.name === "Recovering") {
+    const meetsWatermark = prev.nativeSequencePeak === void 0 || incomingPeak >= prev.nativeSequencePeak;
+    if (meetsWatermark && isSupersetOf(incomingUnitKeys, prev.committedUnitKeys) && observation.coverage !== "partial") {
+      const next = {
+        name: "NativeLocked",
+        nativeSequencePeak: Math.max(prev.nativeSequencePeak ?? incomingPeak, incomingPeak),
+        committedUnitKeys: incomingUnitKeys,
+        recoveringMisses: 0
+      };
+      return {
+        next,
+        selected: "native-history",
+        transition: { fromState, toState: "NativeLocked", event: "NativeProgressed", cause: "native_progressed", at },
+        lockState: { locked: true, lockedSince: at }
+      };
+    }
+    return handleNativeUnavailable(prev, "empty", at, lockedSince);
+  }
+  if (prev.nativeSequencePeak === void 0 || incomingPeak > prev.nativeSequencePeak) {
+    if (observation.coverage !== "partial" && incomingUnitKeys.size > 0) {
+      const next = {
+        name: "NativeLocked",
+        nativeSequencePeak: Math.max(prev.nativeSequencePeak ?? incomingPeak, incomingPeak),
+        committedUnitKeys: incomingUnitKeys,
+        recoveringMisses: 0
+      };
+      return {
+        next,
+        selected: "native-history",
+        transition: { fromState, toState: "NativeLocked", event: "NativeProgressed", cause: "native_progressed", at },
+        lockState: { locked: true, lockedSince: at }
+      };
+    }
+  } else if (incomingPeak >= prev.nativeSequencePeak) {
+    if (isSupersetOf(incomingUnitKeys, prev.committedUnitKeys) && observation.coverage !== "partial") {
+      const next = {
+        name: "NativeLocked",
+        nativeSequencePeak: Math.max(prev.nativeSequencePeak ?? incomingPeak, incomingPeak),
+        committedUnitKeys: incomingUnitKeys,
+        recoveringMisses: 0
+      };
+      return {
+        next,
+        selected: "native-history",
+        transition: { fromState, toState: "NativeLocked", event: "NativeProgressed", cause: "native_progressed", at },
+        lockState: { locked: true, lockedSince: at }
+      };
+    }
+  }
+  return {
+    next: prev,
+    selected: "pty-parser",
+    transition: { fromState, toState: "PtyOnly", event: "NoOp", cause: "native_progressed", at },
+    lockState: { locked: false }
+  };
+}
+function regressTo(prev, fromState, cause, at) {
+  const next = {
+    name: "PtyOnly",
+    nativeSequencePeak: prev.nativeSequencePeak,
+    committedUnitKeys: prev.committedUnitKeys,
+    recoveringMisses: 0
+  };
+  return {
+    next,
+    selected: "pty-parser",
+    transition: { fromState, toState: "PtyOnly", event: "NativeRegressed", cause, at },
+    lockState: { locked: false }
+  };
+}
+function reasonToUnavailableCause(reason) {
+  switch (reason) {
+    case "provider_not_supported":
+      return "native_unavailable_provider_unsupported";
+    case "read_error":
+      return "native_unavailable_read_error";
+    case "empty":
+      return "native_unavailable_empty";
+    case "not_native_source":
+      return "native_unavailable_not_native_source";
+    case "coverage_unavailable":
+      return "native_regressed_coverage_unavailable";
+  }
+}
+function collectUnitKeys(messages) {
+  const set = /* @__PURE__ */ new Set();
+  for (const m of messages) set.add(m.providerUnitKey);
+  return set;
+}
+function maxSequence(messages) {
+  let max = -Infinity;
+  for (const m of messages) {
+    if (m.sequence > max) max = m.sequence;
+  }
+  return max === -Infinity ? 0 : max;
+}
+function isSupersetOf(candidate, required) {
+  if (required.size === 0) return true;
+  for (const key of required) {
+    if (!candidate.has(key)) return false;
+  }
+  return true;
+}
+
+// src/chat/source-resolver.ts
+var TRANSITION_HISTORY_LIMIT = 25;
+function chatSourceSessionKey(providerType, sessionId) {
+  return `${providerType}\0${sessionId}`;
+}
+var ChatSourceRegistry = class {
+  records = /* @__PURE__ */ new Map();
+  /** Snapshot of current state for diagnostics. Does not mutate. */
+  getState(key) {
+    return this.records.get(key)?.state ?? INITIAL_CHAT_SOURCE_STATE;
+  }
+  /** Recent transitions, newest last. Empty array when nothing has happened. */
+  getTransitions(key) {
+    return this.records.get(key)?.transitions ?? [];
+  }
+  /** Drop a session. Caller should invoke this when the session is destroyed
+   *  to avoid unbounded growth across long-lived daemons. */
+  clear(key) {
+    this.records.delete(key);
+  }
+  /** Drop all sessions. Test helper. */
+  clearAll() {
+    this.records.clear();
+  }
+  /**
+   * Apply one observation, returning the decision and side-effecting the
+   * stored state. The returned `nextState` is the same object now stored
+   * under `key`; callers may treat the decision as authoritative without
+   * re-reading.
+   */
+  observe(key, observation, at = Date.now()) {
+    const prev = this.records.get(key);
+    const prevState = prev?.state ?? INITIAL_CHAT_SOURCE_STATE;
+    const prevLockedSince = prev?.lockedSince;
+    const result = transitionChatSourceState(prevState, observation, at, prevLockedSince);
+    const transitions = prev?.transitions ?? [];
+    const nextTransitions = appendTransition(transitions, result.transition);
+    const lockedSince = result.lockState.lockedSince;
+    this.records.set(key, {
+      state: result.next,
+      lockedSince,
+      transitions: nextTransitions
+    });
+    return {
+      selected: result.selected,
+      nextState: result.next,
+      transition: result.transition,
+      lockState: result.lockState
+    };
+  }
+};
+function appendTransition(existing, next) {
+  const last = existing[existing.length - 1];
+  if (last && last.fromState === next.fromState && last.toState === next.toState && last.event === next.event && last.cause === next.cause) {
+    return existing;
+  }
+  const trimmed = existing.length >= TRANSITION_HISTORY_LIMIT ? existing.slice(existing.length - TRANSITION_HISTORY_LIMIT + 1) : [...existing];
+  trimmed.push(next);
+  return trimmed;
+}
+function buildV1NativePresentObservation(args) {
+  const identities = [];
+  let synthesisedSequence = 0;
+  for (const message of args.messages) {
+    const providerUnitKey = pickFirstString(
+      message.providerUnitKey,
+      message.bubbleId,
+      message.id
+    ) ?? synthesiseV1UnitKey(args.providerType, args.sessionId, synthesisedSequence, message);
+    const sequence = pickFiniteNumber(message.receivedAt, message.timestamp, message.index) ?? synthesisedSequence;
+    identities.push({ providerUnitKey, sequence });
+    synthesisedSequence += 1;
+  }
+  return {
+    kind: "native_present",
+    contractVersion: CHAT_CONTRACT_VERSION_V1,
+    messages: identities,
+    coverage: args.coverage,
+    safeMapping: args.safeMapping
+  };
+}
+function pickFirstString(...candidates) {
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0) return c;
+  }
+  return void 0;
+}
+function pickFiniteNumber(...candidates) {
+  for (const c of candidates) {
+    if (typeof c === "number" && Number.isFinite(c)) return c;
+  }
+  return void 0;
+}
+function synthesiseV1UnitKey(providerType, sessionId, positionalSeq, message) {
+  const role = typeof message.role === "string" ? message.role : "";
+  const ts2 = pickFiniteNumber(message.receivedAt, message.timestamp);
+  return `v1:${providerType}:${sessionId}:${ts2 ?? ""}:${positionalSeq}:${role}`;
+}
+var CHAT_SOURCE_REGISTRY = new ChatSourceRegistry();
+
 // src/commands/chat-commands.ts
 var RECENT_SEND_WINDOW_MS = 1200;
 var READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25e3;
 var HERMES_CLI_STARTING_SEND_SETTLE_MS = 2e3;
-var CLI_NATIVE_HISTORY_FRESH_MS = 5 * 6e4;
 var CLI_NATIVE_TRANSCRIPT_PROVIDERS = /* @__PURE__ */ new Set(["codex-cli", "claude-cli", "hermes-cli", "antigravity-cli"]);
+var warnedLegacyNativeAllowlistHits = /* @__PURE__ */ new Set();
+function warnLegacyNativeAllowlistHit(providerType) {
+  if (warnedLegacyNativeAllowlistHits.has(providerType)) return;
+  warnedLegacyNativeAllowlistHits.add(providerType);
+  console.warn(
+    `[chat-commands] supportsCliNativeTranscript fell back to the hardcoded CLI_NATIVE_TRANSCRIPT_PROVIDERS set for "${providerType}". The provider module was unavailable or did not declare canonicalHistory. Set canonicalHistory.contractVersion in the provider.json to remove this dependency.`
+  );
+}
 var recentSendByTarget = /* @__PURE__ */ new Map();
 function getCurrentProviderType(h, fallback = "") {
   return h.currentSession?.providerType || h.currentProviderType || fallback;
@@ -17421,7 +17882,11 @@ function readHistorySessionIdFromMessages(messages) {
 function shouldPreserveNativeIdentity(providerType, sessionId, message) {
   const providerUnitKey = typeof message.providerUnitKey === "string" ? message.providerUnitKey.trim() : "";
   const turnKey = typeof message._turnKey === "string" ? message._turnKey.trim() : "";
-  if (!providerUnitKey || !turnKey) return false;
+  if (!providerUnitKey) return false;
+  if (providerUnitKey.startsWith("v2:") || providerUnitKey.startsWith("v2-pty:")) {
+    return true;
+  }
+  if (!turnKey) return false;
   if (providerType === "hermes-cli" && sessionId) {
     return providerUnitKey.startsWith(`${providerType}:native:${sessionId}:`) && turnKey.startsWith(`${providerType}:native-turn:${sessionId}:`);
   }
@@ -17450,12 +17915,16 @@ function normalizeNativeHistoryMessages(providerType, messages, nativeSessionId)
     const meta = message.meta && typeof message.meta === "object" ? message.meta : void 0;
     const isSystemSessionStart = role === "system" || kind === "system" || kind === "session_start";
     const isActivity = role === "assistant" && (kind === "tool" || kind === "terminal" || kind === "thought");
+    const existingSequence = typeof message.sequence === "number" && Number.isFinite(message.sequence) ? message.sequence : null;
+    const tsCandidate = Number(message.receivedAt || message.timestamp || 0);
+    const sequence = existingSequence !== null ? existingSequence : tsCandidate > 0 ? tsCandidate : index;
     return {
       ...message,
       role: role === "human" ? "user" : role || "assistant",
       kind: isSystemSessionStart ? "system" : kind,
       providerUnitKey,
       bubbleId: typeof message.bubbleId === "string" && message.bubbleId.trim() && preserveNativeIdentity ? message.bubbleId.trim() : `bubble:${providerUnitKey}`,
+      sequence,
       _turnKey: preserveNativeIdentity ? existingTurnKey : `${providerType}:native-turn:${nativeIdentitySessionId || "workspace"}:${turnIndex}`,
       bubbleState: message.bubbleState || "final",
       ...isSystemSessionStart ? {
@@ -17514,17 +17983,185 @@ function buildCliMessageSourceProvenance(args) {
     }
   };
 }
-function buildNativeHistoryFallbackReason(args) {
-  if (!supportsCliNativeTranscript(args.providerType, args.provider)) return "provider_native_transcript_not_supported";
-  if (args.unavailableReason) return `native_history_unavailable:${args.unavailableReason}`;
-  if (args.nativeSource === "native-unavailable") return "native_history_unavailable";
-  if (args.nativeHistoryCoverage === "partial") return "native_history_partial";
-  if (args.nativeHistoryCoverage === "unavailable") return "native_history_unavailable";
-  if (args.nativeSource && args.nativeSource !== "provider-native") return `native_history_source_${args.nativeSource}`;
-  if (args.nativeMessageCount <= 0) return "native_history_empty";
-  if (!args.safeMapping) return "native_history_not_safely_mapped";
-  if (!args.freshEnough) return "native_history_stale";
-  return "native_history_not_selected";
+function causeToLegacyFallbackReason(cause, selected, extraDetail) {
+  if (selected === "native-history") return void 0;
+  switch (cause) {
+    case "initial":
+      return "native_history_not_checked";
+    case "native_progressed":
+      return "native_history_not_selected";
+    case "native_regressed_shrunk":
+      return "native_history_empty";
+    case "native_regressed_unsafe_mapping":
+      return "native_history_not_safely_mapped";
+    case "native_regressed_coverage_partial":
+      return "native_history_partial";
+    case "native_regressed_coverage_unavailable":
+      return "native_history_unavailable";
+    case "native_unavailable_read_error":
+      return extraDetail?.unavailableReason ? `native_history_unavailable:${extraDetail.unavailableReason}` : "native_history_unavailable";
+    case "native_unavailable_provider_unsupported":
+      return "provider_native_transcript_not_supported";
+    case "native_unavailable_empty":
+      return "native_history_empty";
+    case "native_unavailable_not_native_source":
+      return extraDetail?.nativeSource ? `native_history_source_${extraDetail.nativeSource}` : "native_history_unavailable";
+  }
+}
+function decideCliReadChatSource(args) {
+  const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
+  const observation = buildObservationForCli(args, supportsNative);
+  const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
+  const decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+  const nativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
+  const nativeSource = typeof args.nativeHistoryResult?.source === "string" ? args.nativeHistoryResult.source : void 0;
+  const sourcePath = typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0;
+  const sourceMtimeMs = typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0;
+  const coverageHint = typeof args.nativeHistoryResult?.nativeHistoryCoverage === "string" ? args.nativeHistoryResult.nativeHistoryCoverage : void 0;
+  const partialReason = typeof args.nativeHistoryResult?.partialReason === "string" ? args.nativeHistoryResult.partialReason : void 0;
+  const unavailableReason = typeof args.nativeHistoryResult?.unavailableReason === "string" ? args.nativeHistoryResult.unavailableReason : args.nativeHistoryError ? `error:${args.nativeHistoryError?.message || String(args.nativeHistoryError)}` : void 0;
+  const nativeHandle = typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0;
+  const transcriptWorkspace = typeof args.nativeHistoryResult?.workspace === "string" ? args.nativeHistoryResult.workspace : nativeMessages.map((m) => typeof m?.workspace === "string" ? m.workspace.trim() : "").find(Boolean);
+  const fallbackReason = causeToLegacyFallbackReason(decision.transition.cause, decision.selected, {
+    unavailableReason,
+    nativeSource: nativeSource && nativeSource !== "provider-native" ? nativeSource : void 0
+  });
+  const ptyStatusApprovalOnly = decision.selected === "native-history" ? true : args.ptyStatusApprovalOnly;
+  const messageSource = buildCliMessageSourceProvenance({
+    selected: decision.selected,
+    provider: args.providerType,
+    nativeHandle,
+    sessionWorkspace: args.sessionWorkspace,
+    intendedWorkspace: args.intendedWorkspace,
+    transcriptWorkspace,
+    fallbackReason,
+    nativeSource,
+    sourcePath,
+    sourceMtimeMs,
+    nativeHistoryCoverage: coverageHint,
+    partialReason,
+    unavailableReason,
+    nativeMessages,
+    ptyMessages: args.ptyMessages,
+    returnedMessages: decision.selected === "native-history" ? nativeMessages : args.ptyMessages,
+    safeMapping: args.safeMapping,
+    // freshEnough is a v1 concept the machine does not model directly.
+    // We surface lockState.locked here so v1 consumers reading
+    // staleness.freshEnough still get a meaningful boolean.
+    freshEnough: decision.lockState.locked,
+    ptyStatusApprovalOnly
+  });
+  return {
+    decision,
+    messageSource,
+    nativeMessages,
+    nativeSelected: decision.selected === "native-history"
+  };
+}
+function buildObservationForCli(args, supportsNative) {
+  if (!supportsNative) {
+    return { kind: "native_unavailable", reason: "provider_not_supported" };
+  }
+  if (args.nativeHistoryError) {
+    return { kind: "native_unavailable", reason: "read_error" };
+  }
+  const result = args.nativeHistoryResult;
+  if (!result || typeof result !== "object") {
+    return { kind: "native_unavailable", reason: "read_error" };
+  }
+  const source = typeof result.source === "string" ? result.source : "";
+  if (source && source !== "provider-native") {
+    return { kind: "native_unavailable", reason: source === "native-unavailable" ? "empty" : "not_native_source" };
+  }
+  const messages = Array.isArray(result.messages) ? result.messages : [];
+  if (messages.length === 0) {
+    return { kind: "native_unavailable", reason: "empty" };
+  }
+  const coverage = typeof result.nativeHistoryCoverage === "string" ? result.nativeHistoryCoverage : "tail";
+  if (coverage === "unavailable") {
+    return { kind: "native_unavailable", reason: "coverage_unavailable" };
+  }
+  return buildV1NativePresentObservation({
+    providerType: args.providerType,
+    sessionId: args.sessionId,
+    messages,
+    coverage: coverage === "full" || coverage === "tail" || coverage === "current-turn" || coverage === "partial" ? coverage : "tail",
+    safeMapping: args.safeMapping
+  });
+}
+function extractNativeMessagesFromResult(providerType, result) {
+  if (!result || !Array.isArray(result.messages)) return [];
+  return normalizeNativeHistoryMessages(
+    providerType,
+    result.messages,
+    typeof result.providerSessionId === "string" ? result.providerSessionId : void 0
+  );
+}
+function applyUnsafeNativeDaemonFallback(args) {
+  if (args.adapter.cliType !== "codex-cli") {
+    return;
+  }
+  const ms = args.messageSourceRef.get();
+  const fallbackReason = typeof ms.fallbackReason === "string" ? ms.fallbackReason : "";
+  if (!isUnsafeNativeTranscriptFallback(fallbackReason)) {
+    return;
+  }
+  const safeCurrentRuntimePtyMessages = isCurrentRuntimePtySafelyAttributed({
+    adapter: args.adapter,
+    helpers: args.helpers,
+    readChatArgs: args.readChatArgs,
+    sessionWorkspace: args.sessionWorkspace,
+    intendedWorkspace: args.intendedWorkspace,
+    ptyMessages: args.ptyMessages
+  });
+  if (safeCurrentRuntimePtyMessages) {
+    args.apply({
+      messages: args.ptyMessages,
+      transcriptAuthority: "daemon",
+      coverage: args.coverage || "current-turn",
+      status: args.returnedStatus
+    });
+    const next2 = { ...ms, selectedDaemonSource: "current-runtime-pty", transcriptAuthority: "daemon", runtimeMappingSafe: true };
+    args.messageSourceRef.set(next2);
+    return;
+  }
+  const safeRuntimeAckMessages = selectRuntimeInputAckMessages(args.ptyMessages);
+  if (safeRuntimeAckMessages.length > 0) {
+    args.apply({
+      messages: safeRuntimeAckMessages,
+      transcriptAuthority: "daemon",
+      coverage: "tail",
+      status: coerceUnsafeNativeFallbackStatus(args.returnedStatus, args.activeModal)
+    });
+    const next2 = { ...ms, ptyStatusApprovalOnly: true };
+    args.messageSourceRef.set(next2);
+    return;
+  }
+  const exactRuntimeMirrorMessages = readExactRuntimeMirrorMessages({
+    providerType: args.providerType,
+    targetSessionId: typeof args.readChatArgs?.targetSessionId === "string" ? args.readChatArgs.targetSessionId : void 0,
+    currentSessionId: typeof args.helpers.currentSession?.sessionId === "string" ? args.helpers.currentSession.sessionId : void 0,
+    tailLimit: args.nativeHistoryLimit,
+    historyBehavior: args.provider?.historyBehavior
+  });
+  if (exactRuntimeMirrorMessages.length > 0) {
+    args.apply({
+      messages: exactRuntimeMirrorMessages,
+      transcriptAuthority: "daemon",
+      coverage: "tail",
+      status: coerceUnsafeNativeFallbackStatus(args.returnedStatus, args.activeModal)
+    });
+    const next2 = { ...ms, selectedDaemonSource: "exact-runtime-mirror", transcriptAuthority: "daemon", ptyStatusApprovalOnly: true };
+    args.messageSourceRef.set(next2);
+    return;
+  }
+  args.apply({
+    messages: args.ptyMessages,
+    coverage: args.coverage,
+    status: coerceUnsafeNativeFallbackStatus(args.returnedStatus, args.activeModal)
+  });
+  const next = { ...ms, ptyStatusApprovalOnly: true };
+  args.messageSourceRef.set(next);
 }
 function isUnsafeNativeTranscriptFallback(reason) {
   const value = String(reason || "").trim();
@@ -17596,8 +18233,14 @@ function isCurrentRuntimePtySafelyAttributed(args) {
   return true;
 }
 function supportsCliNativeTranscript(providerType, provider) {
-  if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) return true;
-  return provider?.category === "cli" && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
+  if (provider?.category === "cli" && isNativeSourceCanonicalHistory(provider?.canonicalHistory)) {
+    return true;
+  }
+  if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) {
+    warnLegacyNativeAllowlistHit(providerType);
+    return true;
+  }
+  return false;
 }
 function getComparableVisibleText(message) {
   if (!message) return "";
@@ -17696,14 +18339,6 @@ function readLiveCodexWorkspaceNativeHistory(agentStr, args) {
   });
   return { ...history, lookup: "workspace" };
 }
-function isNativeHistoryFreshEnough(args) {
-  const nativeNewest = getMessageNewestReceivedAt(args.nativeMessages);
-  const ptyNewest = getMessageNewestReceivedAt(args.ptyMessages);
-  if (nativeNewest > 0 && nativeNewest >= ptyNewest) return true;
-  const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
-  if (sourceMtimeMs > 0 && Date.now() - sourceMtimeMs <= CLI_NATIVE_HISTORY_FRESH_MS) return true;
-  return ptyNewest === 0 && nativeNewest > 0;
-}
 function shouldPreserveReadChatPayloadField(key) {
   return key === "messageSource" || key === "transcriptProvenance";
 }
@@ -17768,6 +18403,8 @@ function normalizeReadChatCommandStatus(status, activeModal) {
     case "disconnected":
     case "not_monitored":
       return "error";
+    case "waiting_approval":
+      return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "generating";
     default:
       return raw;
   }
@@ -17816,6 +18453,36 @@ function finalizeStreamingMessagesWhenIdle(messages, status) {
     };
   });
 }
+function collapseAdjacentDuplicateChatMessages(messages) {
+  if (!Array.isArray(messages) || messages.length <= 1) return messages;
+  const result = [];
+  let prevRoleKind = "";
+  let prevStripped = "";
+  for (const message of messages) {
+    const role = typeof message.role === "string" ? message.role : "";
+    const kind = typeof message.kind === "string" ? message.kind : "standard";
+    const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.map((p) => typeof p?.text === "string" ? p.text : "").join("") : "";
+    const strippedContent = content.replace(/\s+/g, "");
+    if (!strippedContent || role === "system") {
+      result.push(message);
+      prevRoleKind = "";
+      prevStripped = "";
+      continue;
+    }
+    const roleKind = `${role}:${kind}`;
+    const sameStripped = strippedContent === prevStripped && roleKind === prevRoleKind;
+    if (result.length > 0 && sameStripped) {
+      result[result.length - 1] = message;
+      prevRoleKind = roleKind;
+      prevStripped = strippedContent;
+      continue;
+    }
+    result.push(message);
+    prevRoleKind = roleKind;
+    prevStripped = strippedContent;
+  }
+  return result;
+}
 function buildReadChatCommandResult(payload, args) {
   let validatedPayload;
   const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === "object" ? payload.debugReadChat : void 0;
@@ -18338,7 +19005,9 @@ async function handleReadChat(h, args) {
       const activeModal = parsedRecord.activeModal ?? parsedRecord.modal ?? null;
       const returnedStatus = normalizeCliReadChatStatus(parsedRecord.status, activeModal, adapter, adapterStatus, parsedRecord.messages);
       const runtimeMessageMerger = getTargetInstance(h, args);
-      const parsedMessages = finalizeStreamingMessagesWhenIdle(parsedRecord.messages, returnedStatus);
+      const parsedMessages = collapseAdjacentDuplicateChatMessages(
+        finalizeStreamingMessagesWhenIdle(parsedRecord.messages, returnedStatus)
+      );
       const returnedMessages = runtimeMessageMerger?.category === "cli" && runtimeMessageMerger.type === adapter.cliType && typeof runtimeMessageMerger.mergeRuntimeChatMessages === "function" ? runtimeMessageMerger.mergeRuntimeChatMessages(parsedMessages) : parsedMessages;
       const providerType = provider?.type || adapter.cliType;
       let selectedMessages = returnedMessages;
@@ -18349,30 +19018,22 @@ async function handleReadChat(h, args) {
       let selectedStatus = returnedStatus;
       const sessionWorkspace = typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : typeof adapter.workingDir === "string" ? adapter.workingDir : void 0;
       const intendedWorkspace = typeof args?.workspace === "string" ? args.workspace : void 0;
-      let messageSource = buildCliMessageSourceProvenance({
-        selected: "pty-parser",
-        provider: adapter.cliType,
-        fallbackReason: supportsCliNativeTranscript(providerType, provider) ? "native_history_not_checked" : "provider_native_transcript_not_supported",
-        sessionWorkspace,
-        intendedWorkspace,
-        ptyMessages: returnedMessages,
-        returnedMessages,
-        ptyStatusApprovalOnly: false
-      });
-      if (supportsCliNativeTranscript(providerType, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)) {
-        const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
-        const workspace = sessionWorkspace;
-        const nativeHistoryLimit = Math.max(
-          normalizeReadChatTailLimit(args) || 0,
-          returnedMessages.length,
-          200
-        );
-        const nativeHistorySessionId = resolveCliNativeHistorySessionId(args, historySessionId, providerSessionId);
-        const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
-        const exactNativeHistoryScope = Boolean(
-          typeof args?.historySessionId === "string" && args.historySessionId.trim() || typeof args?.providerSessionId === "string" && args.providerSessionId.trim() || providerSessionId || nativeHistorySessionId && nativeHistorySessionId !== targetSessionId || h.currentSession?.sessionId === args?.targetSessionId && typeof h.currentSession?.providerSessionId === "string" && h.currentSession.providerSessionId.trim()
-        );
-        let nativeHistory = null;
+      const supportsNative = supportsCliNativeTranscript(providerType, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
+      const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
+      const workspace = sessionWorkspace;
+      const nativeHistoryLimit = Math.max(
+        normalizeReadChatTailLimit(args) || 0,
+        returnedMessages.length,
+        200
+      );
+      const nativeHistorySessionId = supportsNative ? resolveCliNativeHistorySessionId(args, historySessionId, providerSessionId) : void 0;
+      const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+      const exactNativeHistoryScope = Boolean(
+        typeof args?.historySessionId === "string" && args.historySessionId.trim() || typeof args?.providerSessionId === "string" && args.providerSessionId.trim() || providerSessionId || nativeHistorySessionId && nativeHistorySessionId !== targetSessionId || h.currentSession?.sessionId === args?.targetSessionId && typeof h.currentSession?.providerSessionId === "string" && h.currentSession.providerSessionId.trim()
+      );
+      let nativeHistory = null;
+      let nativeHistoryError;
+      if (supportsNative) {
         try {
           nativeHistory = readCliProviderNativeHistory(agentStr, {
             canonicalHistory: provider?.canonicalHistory,
@@ -18386,210 +19047,148 @@ async function handleReadChat(h, args) {
             excludeInProgressTurn: returnedStatus === "waiting_approval"
           });
         } catch (error) {
-          const fallbackReason = `native_history_error:${error?.message || String(error)}`;
-          messageSource = buildCliMessageSourceProvenance({
-            selected: "pty-parser",
-            provider: adapter.cliType,
-            fallbackReason,
-            sessionWorkspace,
-            intendedWorkspace,
-            ptyMessages: returnedMessages,
-            returnedMessages,
-            ptyStatusApprovalOnly: false
-          });
+          nativeHistoryError = error;
           nativeHistory = null;
         }
-        if (nativeHistory) {
-          const nativeMessages = Array.isArray(nativeHistory.messages) ? normalizeNativeHistoryMessages(agentStr, nativeHistory.messages, nativeHistory?.providerSessionId) : [];
-          const historyProviderSessionId = typeof nativeHistory?.providerSessionId === "string" ? nativeHistory.providerSessionId : readHistorySessionIdFromMessages(nativeMessages) || nativeHistorySessionId || historySessionId;
-          const nativeHistoryCoverage = typeof nativeHistory?.nativeHistoryCoverage === "string" ? nativeHistory.nativeHistoryCoverage : void 0;
-          const partialReason = typeof nativeHistory?.partialReason === "string" ? nativeHistory.partialReason : void 0;
-          const unavailableReason = typeof nativeHistory?.unavailableReason === "string" ? nativeHistory.unavailableReason : void 0;
-          const lookup = nativeHistory.lookup === "workspace" ? "workspace" : "session";
-          const transcriptWorkspace = typeof nativeHistory?.workspace === "string" ? nativeHistory.workspace : nativeMessages.map((message) => typeof message?.workspace === "string" ? message.workspace.trim() : "").find(Boolean);
-          const nativeHistorySessionForMapping = adapter.cliType === "antigravity-cli" && historyProviderSessionId && nativeHistorySessionId && historyProviderSessionId !== nativeHistorySessionId ? void 0 : nativeHistorySessionId;
-          const safeMapping = hasSafeNativeHistoryMapping({
-            historySessionId: lookup === "workspace" ? void 0 : nativeHistorySessionForMapping,
-            providerSessionId: lookup === "workspace" ? void 0 : historyProviderSessionId || providerSessionId,
-            workspace,
-            nativeMessages,
+      }
+      const nativeMessages = nativeHistory && Array.isArray(nativeHistory.messages) ? normalizeNativeHistoryMessages(agentStr, nativeHistory.messages, nativeHistory.providerSessionId) : [];
+      const historyProviderSessionId = typeof nativeHistory?.providerSessionId === "string" ? nativeHistory.providerSessionId : readHistorySessionIdFromMessages(nativeMessages) || nativeHistorySessionId || historySessionId;
+      const lookup = nativeHistory?.lookup === "workspace" ? "workspace" : "session";
+      const nativeHistorySessionForMapping = adapter.cliType === "antigravity-cli" && historyProviderSessionId && nativeHistorySessionId && historyProviderSessionId !== nativeHistorySessionId ? void 0 : nativeHistorySessionId;
+      const safeMapping = supportsNative && nativeHistory ? hasSafeNativeHistoryMapping({
+        historySessionId: lookup === "workspace" ? void 0 : nativeHistorySessionForMapping,
+        providerSessionId: lookup === "workspace" ? void 0 : historyProviderSessionId || providerSessionId,
+        workspace,
+        nativeMessages,
+        ptyMessages: returnedMessages,
+        requireWorkspaceContentOverlap: lookup === "workspace" && !exactNativeHistoryScope
+      }) : false;
+      const machineSessionKey = String(
+        args?.targetSessionId || providerSessionId || historySessionId || h.currentSession?.sessionId || ""
+      );
+      const primary = decideCliReadChatSource({
+        providerType,
+        provider,
+        sessionId: machineSessionKey,
+        nativeHistoryResult: nativeHistory,
+        nativeHistoryError,
+        safeMapping,
+        sessionWorkspace,
+        intendedWorkspace,
+        ptyMessages: returnedMessages,
+        // Start with PTY visible; decideCliReadChatSource flips this
+        // to true when the machine actually selects native-history.
+        ptyStatusApprovalOnly: false
+      });
+      let messageSource = primary.messageSource;
+      if (primary.nativeSelected) {
+        selectedMessages = finalizeStreamingMessagesWhenIdle(primary.nativeMessages, returnedStatus);
+        selectedProviderSessionId = historyProviderSessionId || providerSessionId;
+        selectedTranscriptAuthority = "provider";
+        selectedCoverage = nativeHistory?.hasMore ? "tail" : "full";
+      } else if (supportsNative) {
+        const liveCurrentRuntimePtySafe = isCurrentRuntimePtySafelyAttributed({
+          adapter,
+          helpers: h,
+          readChatArgs: args,
+          sessionWorkspace,
+          intendedWorkspace,
+          ptyMessages: returnedMessages
+        });
+        const mayProbeLiveCodexWorkspaceNative = adapter.cliType === "codex-cli" && liveCurrentRuntimePtySafe && !(typeof args?.providerSessionId === "string" && args.providerSessionId.trim()) && !(providerSessionId && providerSessionId.trim()) && (!historyProviderSessionId || historyProviderSessionId === nativeHistorySessionId || historyProviderSessionId === historySessionId);
+        const liveWorkspaceNativeHistory = mayProbeLiveCodexWorkspaceNative ? readLiveCodexWorkspaceNativeHistory(agentStr, {
+          canonicalHistory: provider?.canonicalHistory,
+          workspace,
+          offset: 0,
+          limit: nativeHistoryLimit,
+          excludeRecentCount: 0,
+          historyBehavior: provider?.historyBehavior,
+          scripts: provider?.scripts
+        }) : null;
+        const liveWorkspaceNativeMessages = Array.isArray(liveWorkspaceNativeHistory?.messages) ? normalizeNativeHistoryMessages(agentStr, liveWorkspaceNativeHistory.messages, liveWorkspaceNativeHistory?.providerSessionId) : [];
+        const liveWorkspaceNativeProviderSessionId = typeof liveWorkspaceNativeHistory?.providerSessionId === "string" ? liveWorkspaceNativeHistory.providerSessionId : readHistorySessionIdFromMessages(liveWorkspaceNativeMessages);
+        const liveWorkspaceNativeSafeMapping = liveWorkspaceNativeMessages.length > 0 && hasSafeNativeHistoryMapping({
+          workspace,
+          nativeMessages: liveWorkspaceNativeMessages,
+          ptyMessages: returnedMessages,
+          requireWorkspaceContentOverlap: true
+        });
+        if (liveWorkspaceNativeHistory) {
+          const liveDecision = decideCliReadChatSource({
+            providerType,
+            provider,
+            // Distinct session key so a transient codex live-probe does not
+            // clobber the primary session's lock. The machine treats this
+            // as its own session; the primary session's state is untouched.
+            sessionId: `${machineSessionKey}::live-workspace`,
+            nativeHistoryResult: liveWorkspaceNativeHistory,
+            safeMapping: liveWorkspaceNativeSafeMapping,
+            sessionWorkspace,
+            intendedWorkspace,
             ptyMessages: returnedMessages,
-            requireWorkspaceContentOverlap: lookup === "workspace" && !exactNativeHistoryScope
-          });
-          const freshEnough = isNativeHistoryFreshEnough({
-            sourceMtimeMs: nativeHistory.sourceMtimeMs,
-            nativeMessages,
-            ptyMessages: returnedMessages
+            ptyStatusApprovalOnly: true
           });
-          const nativeUsableForChatMessages = nativeHistory.source === "provider-native" && nativeMessages.length > 0 && nativeHistoryCoverage !== "partial" && nativeHistoryCoverage !== "unavailable" && safeMapping;
-          const NATIVE_ANCHOR_TTL_MS = 30 * 6e4;
-          const nativeAnchoredAt = adapter.nativeHistoryAnchoredAt ?? 0;
-          const nativeIsAnchored = nativeAnchoredAt > 0 && Date.now() - nativeAnchoredAt < NATIVE_ANCHOR_TTL_MS;
-          const allowStaleNativeChatMessages = (adapter.cliType === "antigravity-cli" || nativeIsAnchored) && nativeUsableForChatMessages;
-          if (nativeUsableForChatMessages && (freshEnough || allowStaleNativeChatMessages)) {
-            adapter.nativeHistoryAnchoredAt = Date.now();
-            selectedMessages = finalizeStreamingMessagesWhenIdle(nativeMessages, returnedStatus);
-            selectedProviderSessionId = historyProviderSessionId || providerSessionId;
+          if (liveDecision.nativeSelected) {
+            selectedMessages = finalizeStreamingMessagesWhenIdle(liveDecision.nativeMessages, returnedStatus);
+            selectedProviderSessionId = liveWorkspaceNativeProviderSessionId || providerSessionId;
             selectedTranscriptAuthority = "provider";
-            selectedCoverage = nativeHistory.hasMore ? "tail" : "full";
-            messageSource = buildCliMessageSourceProvenance({
-              selected: "native-history",
-              provider: adapter.cliType,
-              nativeHandle: selectedProviderSessionId || nativeHistorySessionId || historySessionId,
-              sessionWorkspace,
-              intendedWorkspace,
-              transcriptWorkspace,
-              nativeSource: nativeHistory.source,
-              sourcePath: nativeHistory.sourcePath,
-              sourceMtimeMs: nativeHistory.sourceMtimeMs,
-              nativeHistoryCoverage,
-              partialReason,
-              unavailableReason,
-              nativeMessages,
-              ptyMessages: returnedMessages,
-              returnedMessages: selectedMessages,
-              safeMapping,
-              freshEnough,
-              ptyStatusApprovalOnly: true
-            });
+            selectedCoverage = liveWorkspaceNativeHistory.hasMore ? "tail" : "full";
+            messageSource = liveDecision.messageSource;
+            messageSource.selectedDaemonSource = "live-workspace-native-history";
+            messageSource.runtimeMappingSafe = true;
           } else {
-            if (!nativeUsableForChatMessages && adapter.nativeHistoryAnchoredAt) {
-              adapter.nativeHistoryAnchoredAt = 0;
-            }
-            const liveCurrentRuntimePtySafe = isCurrentRuntimePtySafelyAttributed({
+            applyUnsafeNativeDaemonFallback({
+              providerType,
               adapter,
               helpers: h,
               readChatArgs: args,
               sessionWorkspace,
               intendedWorkspace,
-              ptyMessages: returnedMessages
-            });
-            const mayProbeLiveCodexWorkspaceNative = adapter.cliType === "codex-cli" && liveCurrentRuntimePtySafe && !(typeof args?.providerSessionId === "string" && args.providerSessionId.trim()) && !(providerSessionId && providerSessionId.trim()) && (!historyProviderSessionId || historyProviderSessionId === nativeHistorySessionId || historyProviderSessionId === historySessionId);
-            const liveWorkspaceNativeHistory = mayProbeLiveCodexWorkspaceNative ? readLiveCodexWorkspaceNativeHistory(agentStr, {
-              canonicalHistory: provider?.canonicalHistory,
-              workspace,
-              offset: 0,
-              limit: nativeHistoryLimit,
-              excludeRecentCount: 0,
-              historyBehavior: provider?.historyBehavior,
-              scripts: provider?.scripts
-            }) : null;
-            const liveWorkspaceNativeMessages = Array.isArray(liveWorkspaceNativeHistory?.messages) ? normalizeNativeHistoryMessages(agentStr, liveWorkspaceNativeHistory.messages, liveWorkspaceNativeHistory?.providerSessionId) : [];
-            const liveWorkspaceNativeProviderSessionId = typeof liveWorkspaceNativeHistory?.providerSessionId === "string" ? liveWorkspaceNativeHistory.providerSessionId : readHistorySessionIdFromMessages(liveWorkspaceNativeMessages);
-            const liveWorkspaceTranscriptWorkspace = typeof liveWorkspaceNativeHistory?.workspace === "string" ? liveWorkspaceNativeHistory.workspace : liveWorkspaceNativeMessages.map((message) => typeof message?.workspace === "string" ? message.workspace.trim() : "").find(Boolean);
-            const liveWorkspaceNativeSafeMapping = liveWorkspaceNativeMessages.length > 0 && hasSafeNativeHistoryMapping({
-              workspace,
-              nativeMessages: liveWorkspaceNativeMessages,
               ptyMessages: returnedMessages,
-              requireWorkspaceContentOverlap: true
-            });
-            const liveWorkspaceNativeFreshEnough = liveWorkspaceNativeMessages.length > 0 && isNativeHistoryFreshEnough({
-              sourceMtimeMs: liveWorkspaceNativeHistory?.sourceMtimeMs,
-              nativeMessages: liveWorkspaceNativeMessages,
-              ptyMessages: returnedMessages
+              nativeHistoryLimit,
+              provider,
+              messageSourceRef: { set(value) {
+                messageSource = value;
+              }, get() {
+                return messageSource;
+              } },
+              apply(selection) {
+                selectedMessages = selection.messages;
+                selectedTranscriptAuthority = selection.transcriptAuthority;
+                selectedCoverage = selection.coverage ?? coverage;
+                selectedStatus = selection.status ?? returnedStatus;
+              },
+              activeModal,
+              returnedStatus,
+              coverage
             });
-            const liveWorkspaceNativeUsable = liveWorkspaceNativeHistory?.source === "provider-native" && liveWorkspaceNativeMessages.length > 0 && liveWorkspaceNativeHistory?.nativeHistoryCoverage !== "partial" && liveWorkspaceNativeHistory?.nativeHistoryCoverage !== "unavailable" && liveWorkspaceNativeSafeMapping && liveWorkspaceNativeFreshEnough;
-            if (liveWorkspaceNativeUsable) {
-              selectedMessages = finalizeStreamingMessagesWhenIdle(liveWorkspaceNativeMessages, returnedStatus);
-              selectedProviderSessionId = liveWorkspaceNativeProviderSessionId || providerSessionId;
-              selectedTranscriptAuthority = "provider";
-              selectedCoverage = liveWorkspaceNativeHistory.hasMore ? "tail" : "full";
-              messageSource = buildCliMessageSourceProvenance({
-                selected: "native-history",
-                provider: adapter.cliType,
-                nativeHandle: selectedProviderSessionId || nativeHistorySessionId || historySessionId,
-                sessionWorkspace,
-                intendedWorkspace,
-                transcriptWorkspace: liveWorkspaceTranscriptWorkspace,
-                nativeSource: liveWorkspaceNativeHistory.source,
-                sourcePath: liveWorkspaceNativeHistory.sourcePath,
-                sourceMtimeMs: liveWorkspaceNativeHistory.sourceMtimeMs,
-                nativeHistoryCoverage: liveWorkspaceNativeHistory.nativeHistoryCoverage,
-                partialReason: liveWorkspaceNativeHistory.partialReason,
-                unavailableReason: liveWorkspaceNativeHistory.unavailableReason,
-                nativeMessages: liveWorkspaceNativeMessages,
-                ptyMessages: returnedMessages,
-                returnedMessages: selectedMessages,
-                safeMapping: true,
-                freshEnough: true,
-                ptyStatusApprovalOnly: true
-              });
-              messageSource.selectedDaemonSource = "live-workspace-native-history";
-              messageSource.runtimeMappingSafe = true;
-            } else {
-              const fallbackReason = buildNativeHistoryFallbackReason({
-                providerType,
-                provider,
-                nativeSource: nativeHistory.source,
-                nativeHistoryCoverage,
-                unavailableReason,
-                nativeMessageCount: nativeMessages.length,
-                safeMapping,
-                freshEnough
-              });
-              const unsafeNativeFallback = adapter.cliType === "codex-cli" && isUnsafeNativeTranscriptFallback(fallbackReason);
-              const safeCurrentRuntimePtyMessages = unsafeNativeFallback && isCurrentRuntimePtySafelyAttributed({
-                adapter,
-                helpers: h,
-                readChatArgs: args,
-                sessionWorkspace,
-                intendedWorkspace,
-                ptyMessages: returnedMessages
-              });
-              const safeRuntimeAckMessages = unsafeNativeFallback && !safeCurrentRuntimePtyMessages ? selectRuntimeInputAckMessages(returnedMessages) : [];
-              const exactRuntimeMirrorMessages = unsafeNativeFallback && !safeCurrentRuntimePtyMessages && safeRuntimeAckMessages.length === 0 ? readExactRuntimeMirrorMessages({
-                providerType,
-                targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId : void 0,
-                currentSessionId: typeof h.currentSession?.sessionId === "string" ? h.currentSession.sessionId : void 0,
-                tailLimit: nativeHistoryLimit,
-                historyBehavior: provider?.historyBehavior
-              }) : [];
-              const safeDaemonMessages = safeRuntimeAckMessages.length > 0 ? safeRuntimeAckMessages : exactRuntimeMirrorMessages;
-              if (unsafeNativeFallback) {
-                if (safeCurrentRuntimePtyMessages) {
-                  selectedMessages = returnedMessages;
-                  selectedTranscriptAuthority = "daemon";
-                  selectedCoverage = coverage || "current-turn";
-                  selectedStatus = returnedStatus;
-                } else {
-                  selectedMessages = safeDaemonMessages;
-                  selectedTranscriptAuthority = safeDaemonMessages.length > 0 ? "daemon" : void 0;
-                  selectedCoverage = safeDaemonMessages.length > 0 ? "tail" : void 0;
-                  selectedStatus = coerceUnsafeNativeFallbackStatus(returnedStatus, activeModal);
-                }
-              }
-              messageSource = buildCliMessageSourceProvenance({
-                selected: "pty-parser",
-                provider: adapter.cliType,
-                nativeHandle: historyProviderSessionId || nativeHistorySessionId || historySessionId,
-                sessionWorkspace,
-                intendedWorkspace,
-                transcriptWorkspace,
-                fallbackReason,
-                nativeSource: nativeHistory.source,
-                sourcePath: nativeHistory.sourcePath,
-                sourceMtimeMs: nativeHistory.sourceMtimeMs,
-                nativeHistoryCoverage,
-                partialReason,
-                unavailableReason,
-                nativeMessages,
-                ptyMessages: returnedMessages,
-                returnedMessages: unsafeNativeFallback && !safeCurrentRuntimePtyMessages ? safeDaemonMessages : returnedMessages,
-                safeMapping,
-                freshEnough,
-                ptyStatusApprovalOnly: unsafeNativeFallback && !safeCurrentRuntimePtyMessages
-              });
-              if (safeCurrentRuntimePtyMessages) {
-                messageSource.selectedDaemonSource = "current-runtime-pty";
-                messageSource.transcriptAuthority = "daemon";
-                messageSource.runtimeMappingSafe = true;
-              }
-              if (unsafeNativeFallback && exactRuntimeMirrorMessages.length > 0) {
-                messageSource.selectedDaemonSource = "exact-runtime-mirror";
-                messageSource.transcriptAuthority = "daemon";
-              }
-            }
           }
+        } else {
+          applyUnsafeNativeDaemonFallback({
+            providerType,
+            adapter,
+            helpers: h,
+            readChatArgs: args,
+            sessionWorkspace,
+            intendedWorkspace,
+            ptyMessages: returnedMessages,
+            nativeHistoryLimit,
+            provider,
+            messageSourceRef: { set(value) {
+              messageSource = value;
+            }, get() {
+              return messageSource;
+            } },
+            apply(selection) {
+              selectedMessages = selection.messages;
+              selectedTranscriptAuthority = selection.transcriptAuthority;
+              selectedCoverage = selection.coverage ?? coverage;
+              selectedStatus = selection.status ?? returnedStatus;
+            },
+            activeModal,
+            returnedStatus,
+            coverage
+          });
         }
       }
       LOG.debug("Command", `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || "")} adapterStatus=${String(adapterStatus.status || "")} parsedStatus=${String(parsedRecord.status || "")} parsedMsgCount=${parsedRecord.messages.length} returnedMsgCount=${returnedMessages.length}`);
@@ -18622,10 +19221,8 @@ async function handleReadChat(h, args) {
       const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h);
       const workspace = typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : void 0;
       const intendedWorkspace = typeof args?.workspace === "string" ? args.workspace : void 0;
-      const exactNativeHistoryScope = Boolean(
-        typeof args?.targetSessionId === "string" && args.targetSessionId.trim() || typeof args?.historySessionId === "string" && args.historySessionId.trim() || typeof args?.providerSessionId === "string" && args.providerSessionId.trim() || h.currentSession?.sessionId === args?.targetSessionId && typeof h.currentSession?.providerSessionId === "string" && h.currentSession.providerSessionId.trim()
-      );
-      const history = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory) ? readCliProviderNativeHistory(agentStr, {
+      const supportsNative = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
+      const history = supportsNative ? readCliProviderNativeHistory(agentStr, {
         canonicalHistory: provider?.canonicalHistory,
         historySessionId,
         workspace,
@@ -18644,65 +19241,44 @@ async function handleReadChat(h, args) {
         historyBehavior: provider?.historyBehavior,
         scripts: provider?.scripts
       });
-      const lookup = history.lookup === "workspace" ? "workspace" : "session";
+      const lookup = history?.lookup === "workspace" ? "workspace" : "session";
       const historyMessages = Array.isArray(history?.messages) ? normalizeNativeHistoryMessages(agentStr, history.messages, history?.providerSessionId) : [];
       const historyProviderSessionId = typeof history?.providerSessionId === "string" ? history.providerSessionId : readHistorySessionIdFromMessages(historyMessages) || historySessionId;
-      const nativeHistoryCoverage = typeof history?.nativeHistoryCoverage === "string" ? history.nativeHistoryCoverage : void 0;
-      const partialReason = typeof history?.partialReason === "string" ? history.partialReason : void 0;
-      const unavailableReason = typeof history?.unavailableReason === "string" ? history.unavailableReason : void 0;
-      const transcriptWorkspace = typeof history?.workspace === "string" ? history.workspace : historyMessages.map((message) => typeof message?.workspace === "string" ? message.workspace.trim() : "").find(Boolean);
-      const safeMapping = supportsCliNativeTranscript(agentStr, provider) ? hasSafeNativeHistoryMapping({
+      const safeMapping = supportsNative ? hasSafeNativeHistoryMapping({
         historySessionId: lookup === "workspace" ? void 0 : historySessionId,
         providerSessionId: lookup === "workspace" ? void 0 : historyProviderSessionId,
         workspace,
         nativeMessages: historyMessages
       }) : false;
-      const nativeSelected = supportsCliNativeTranscript(agentStr, provider) && history.source === "provider-native" && historyMessages.length > 0 && nativeHistoryCoverage !== "partial" && nativeHistoryCoverage !== "unavailable" && safeMapping;
-      const messageSource = buildCliMessageSourceProvenance({
-        selected: nativeSelected ? "native-history" : "pty-parser",
-        provider: agentStr,
-        nativeHandle: historyProviderSessionId || historySessionId,
+      const machineSessionKey = String(
+        args?.targetSessionId || historyProviderSessionId || historySessionId || h.currentSession?.sessionId || ""
+      );
+      const decision = decideCliReadChatSource({
+        providerType: agentStr,
+        provider,
+        sessionId: machineSessionKey,
+        nativeHistoryResult: history,
+        safeMapping,
         sessionWorkspace: workspace,
         intendedWorkspace,
-        transcriptWorkspace,
-        fallbackReason: nativeSelected ? void 0 : buildNativeHistoryFallbackReason({
-          providerType: agentStr,
-          provider,
-          nativeSource: history.source,
-          nativeHistoryCoverage,
-          unavailableReason,
-          nativeMessageCount: historyMessages.length,
-          safeMapping,
-          freshEnough: true
-        }),
-        nativeSource: history.source,
-        sourcePath: history.sourcePath,
-        sourceMtimeMs: history.sourceMtimeMs,
-        nativeHistoryCoverage,
-        partialReason,
-        unavailableReason,
-        nativeMessages: historyMessages,
-        returnedMessages: historyMessages,
-        safeMapping,
-        freshEnough: true,
+        ptyMessages: [],
         ptyStatusApprovalOnly: false
       });
-      const requiresNativeSource = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
-      if (requiresNativeSource && !nativeSelected) {
+      if (supportsNative && !decision.nativeSelected) {
         return {
           success: false,
           code: "native_history_not_safely_available",
           error: "Provider-native history was not safely available for the requested CLI session.",
           providerSessionId: historyProviderSessionId,
-          messageSource,
-          transcriptProvenance: messageSource
+          messageSource: decision.messageSource,
+          transcriptProvenance: decision.messageSource
         };
       }
       return buildReadChatCommandResult({
         messages: historyMessages,
         status: "idle",
-        messageSource,
-        transcriptProvenance: messageSource,
+        messageSource: decision.messageSource,
+        transcriptProvenance: decision.messageSource,
         ...typeof history?.title === "string" ? { title: history.title } : {},
         ...historyProviderSessionId ? { providerSessionId: historyProviderSessionId } : {},
         ...provider?.historyBehavior?.transcriptAuthority === "provider" || provider?.historyBehavior?.transcriptAuthority === "daemon" ? { transcriptAuthority: (provider?.historyBehavior).transcriptAuthority } : {},
@@ -24930,6 +25506,10 @@ function validateCanonicalHistory(raw, errors) {
   if (mode !== void 0 && !["native-source", "materialized-mirror", "disabled"].includes(String(mode))) {
     errors.push("canonicalHistory.mode must be one of: native-source, materialized-mirror, disabled");
   }
+  const chatContractVersion = canonicalHistory.contractVersion;
+  if (chatContractVersion !== void 0 && chatContractVersion !== "1.0" && chatContractVersion !== "2.0") {
+    errors.push(`canonicalHistory.contractVersion must be '1.0' or '2.0' when provided (got ${JSON.stringify(chatContractVersion)})`);
+  }
   const scripts = canonicalHistory.scripts;
   if (scripts === void 0) return;
   if (!scripts || typeof scripts !== "object" || Array.isArray(scripts)) {
@@ -26168,7 +26748,7 @@ var ProviderLoader = class _ProviderLoader {
       return args ? args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ") : "";
     }
     const schemaDef = this.getSettingsSchema(providerType)[key];
-    const defaultVal = schemaDef ? key === "autoApprove" && schemaDef.type === "boolean" ? true : schemaDef.default : void 0;
+    const defaultVal = schemaDef ? schemaDef.default : void 0;
     const config = this.readConfig();
     const userVal = config?.providerSettings?.[providerType]?.[key];
     return userVal !== void 0 ? userVal : defaultVal;
@@ -26270,7 +26850,6 @@ var ProviderLoader = class _ProviderLoader {
     if (result.autoApprove?.type === "boolean") {
       result.autoApprove = {
         ...result.autoApprove,
-        default: true,
         public: true,
         label: result.autoApprove.label || "Auto Approve",
         description: result.autoApprove.description || "Automatically approve actionable prompts without sending approval alerts."
@@ -26292,7 +26871,10 @@ var ProviderLoader = class _ProviderLoader {
     if (!provider.settings?.autoApprove) {
       result.autoApprove = {
         type: "boolean",
-        default: true,
+        // (fix) Safe default is *off*. Auto-approving every modal without the
+        // user opting in produced silent-bash-execution surprises and the
+        // "Auto-approved: ..." system-message flood seen on AGY/Codex.
+        default: false,
         public: true,
         label: "Auto Approve",
         description: "Automatically approve actionable prompts without sending approval alerts."
@@ -27589,15 +28171,22 @@ function getSessionMessageUpdatedAt(session) {
   return getMessageEventTime(lastMessage);
 }
 function getSessionCompletionMarker(session) {
-  const lastMessage = session.activeChat?.messages?.at?.(-1);
-  if (!lastMessage) return "";
-  const role = typeof lastMessage.role === "string" ? lastMessage.role : "";
-  if (role === "user" || role === "human" || role === "system") return "";
-  if (typeof lastMessage._turnKey === "string" && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
-  if (typeof lastMessage.id === "string" && lastMessage.id) return `id:${lastMessage.id}`;
-  if (typeof lastMessage.index === "number" && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
-  const timestamp = getMessageEventTime(lastMessage);
-  return timestamp > 0 ? `ts:${timestamp}` : "";
+  const messages = session.activeChat?.messages;
+  if (!Array.isArray(messages) || messages.length === 0) return "";
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const m = messages[i];
+    const role = typeof m?.role === "string" ? m.role : "";
+    const kind = typeof m?.kind === "string" ? m.kind : "";
+    if (role === "user" || role === "human") return "";
+    if (role === "system") continue;
+    if (kind === "tool") continue;
+    if (typeof m._turnKey === "string" && m._turnKey) return `turn:${m._turnKey}`;
+    if (typeof m.id === "string" && m.id) return `id:${m.id}`;
+    if (typeof m.index === "number" && Number.isFinite(m.index)) return `idx:${m.index}`;
+    const timestamp = getMessageEventTime(m);
+    return timestamp > 0 ? `ts:${timestamp}` : "";
+  }
+  return "";
 }
 function getSessionLastUsedAt(session) {
   return getSessionMessageUpdatedAt(session) || session.lastUpdated || Date.now();
@@ -27612,7 +28201,8 @@ function getUnreadState(hasContentChange, status, lastUsedAt, lastSeenAt, lastRo
   if (status === "generating" || status === "starting") {
     return { unread: false, inboxBucket: "working" };
   }
-  const unread = completionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human" && lastRole !== "system";
+  const ignorableTrailingRoles = lastRole === "user" || lastRole === "human" || lastRole === "system" || lastRole === "tool";
+  const unread = completionMarker ? seenCompletionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && !ignorableTrailingRoles : hasContentChange && lastUsedAt > lastSeenAt && !ignorableTrailingRoles;
   return { unread, inboxBucket: unread ? "task_complete" : "idle" };
 }
 function projectLiveSessionFromFull(session) {
@@ -30976,7 +31566,8 @@ var DaemonCommandRouter = class {
       }
       case "get_pending_mesh_events": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        const events = drainPendingMeshCoordinatorEvents(meshId || void 0);
+        const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+        const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
         return { success: true, events };
       }
       case "launch_cli":
@@ -32952,7 +33543,8 @@ ${block2}`);
             finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
-          const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId);
+          const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+          const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
           const previewFreshness = (() => {
             const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs11.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
@@ -33430,6 +34022,7 @@ function prepareSessionChatTailUpdate(input) {
   const title = typeof result.title === "string" ? result.title : void 0;
   const activeModal = normalizeChatTailActiveModal(result.activeModal);
   const status = typeof result.status === "string" ? result.status : "idle";
+  const messageSource = result.messageSource && typeof result.messageSource === "object" ? result.messageSource : void 0;
   const deliverySignature = buildChatTailDeliverySignature({
     sessionId: input.sessionId,
     ...input.historySessionId ? { historySessionId: input.historySessionId } : {},
@@ -33462,7 +34055,8 @@ function prepareSessionChatTailUpdate(input) {
       messages,
       status,
       ...title ? { title } : {},
-      ...activeModal ? { activeModal } : {}
+      ...activeModal ? { activeModal } : {},
+      ...messageSource ? { messageSource } : {}
     }
   };
 }