@adhdev/daemon-standalone 0.9.82-rc.536 → 0.9.82-rc.538

package/dist/index.js

@@ -30208,10 +30208,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "e7001a2fe5b5af35d3710c964727f7e4d735e852" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "e7001a2f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.536" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-15T11:40:00.569Z" : void 0);
+      const commit = readInjected(true ? "35ac849eca76162066561b27633e11827fa19a73" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "35ac849e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.538" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-15T15:52:37.408Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35565,6 +35565,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       MESH_TASK_MODES: () => MESH_TASK_MODES,
       MESH_TASK_PRIORITIES: () => MESH_TASK_PRIORITIES,
       NOT_BEFORE_RELATIVE_THRESHOLD_MS: () => NOT_BEFORE_RELATIVE_THRESHOLD_MS,
+      REDRIVE_RECLAIM_REASONS: () => REDRIVE_RECLAIM_REASONS,
+      REDRIVE_SUPERSEDE_WINDOW_MS: () => REDRIVE_SUPERSEDE_WINDOW_MS,
       __clearDirectDispatchesForTests: () => __clearDirectDispatchesForTests,
       __clearMeshQueueForTests: () => __clearMeshQueueForTests,
       __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
@@ -35860,10 +35862,21 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         return true;
       });
     }
-    function firstProviderPriority(policy) {
-      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
-      if (!Array.isArray(raw)) return void 0;
-      return raw.find((type) => typeof type === "string" && type.trim())?.trim();
+    function readNodeProviderTypes(policy) {
+      const record2 = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      const push = (type) => {
+        const trimmed = typeof type === "string" ? type.trim() : "";
+        if (!trimmed || seen.has(trimmed)) return;
+        seen.add(trimmed);
+        out.push(trimmed);
+      };
+      for (const slot of normalizeNodeCapabilitySlots(record2.slots)) push(slot.provider);
+      if (Array.isArray(record2.providerPriority)) {
+        for (const type of record2.providerPriority) push(type);
+      }
+      return out;
     }
     function readNodeOverride(node, key2) {
       const overrides = node?.userOverrides;
@@ -35876,7 +35889,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return typeof value === "string" && value.trim() ? value.trim() : null;
     }
     function buildMeshNodeCapabilityTags(node, providerType) {
-      const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
+      const pinnedProvider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : void 0;
+      const providerTags = pinnedProvider ? [pinnedProvider] : readNodeProviderTypes(node?.policy);
       const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
       const os322 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
       const arch2 = readNodeOverride(node, "arch") ?? readNodeReporter(node, "arch") ?? process.arch;
@@ -35884,7 +35898,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ...Array.isArray(node?.capabilities) ? node.capabilities : [],
         `os=${os322}`,
         `arch=${arch2}`,
-        ...provider ? [`provider=${provider}`] : [],
+        ...providerTags.map((p) => `provider=${p}`),
         // Worktree nodes automatically expose a "worktree=<branch>" tag so that
         // mesh_enqueue_task with required_tags: ["worktree=<branch>"] routes
         // only to the matching worktree node.
@@ -36400,6 +36414,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     var GIT_STASH_READONLY_SUBCOMMANDS;
     var DEPENDENCY_FAILURE_TERMINALS;
     var MAX_STRANDED_RECLAIMS;
+    var REDRIVE_RECLAIM_REASONS;
+    var REDRIVE_SUPERSEDE_WINDOW_MS;
     var init_mesh_work_queue = __esm2({
       "src/mesh/mesh-work-queue.ts"() {
         "use strict";
@@ -36468,6 +36484,12 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         GIT_STASH_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show"]);
         DEPENDENCY_FAILURE_TERMINALS = /* @__PURE__ */ new Set(["failed", "cancelled"]);
         MAX_STRANDED_RECLAIMS = 3;
+        REDRIVE_RECLAIM_REASONS = /* @__PURE__ */ new Set([
+          "delivered_no_turn_deadline",
+          "reclaim_after_unknown_grace",
+          "delivered_not_consumed_redrive"
+        ]);
+        REDRIVE_SUPERSEDE_WINDOW_MS = 5 * 6e4;
       }
     });
     function loadDatabaseCtor() {
@@ -46753,7 +46775,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
           if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
           if (task.requiredTags?.length) {
-            const priorities = normalizeProviderPriority2(node?.policy);
+            const slotProviders = resolveNodeCapabilitySlots(node).map((s2) => s2.provider).filter(Boolean);
+            const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority2(node?.policy);
             const providerCandidates = priorities.length ? priorities : [void 0];
             return providerCandidates.some(
               (p) => nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
@@ -50373,6 +50396,52 @@ ${cleanBody}`;
         LOG2.warn("MeshQueue", `stopStaleMeshWorker error for ${sessionId}: ${e?.message || e}`);
       }
     }
+    function supersedeRedriveReclaimForLateCompletion(components, meshId, row, completingSessionId, outcome, args) {
+      if (!row.requeueReason || !REDRIVE_RECLAIM_REASONS.has(row.requeueReason)) return false;
+      if (row.status === "completed" || row.status === "failed" || row.status === "cancelled") return false;
+      const requeuedAtMs = Date.parse(row.requeuedAt ?? "");
+      if (!Number.isFinite(requeuedAtMs)) return false;
+      if (Date.now() - requeuedAtMs > REDRIVE_SUPERSEDE_WINDOW_MS) return false;
+      const reDispatchedSessionId = row.assignedSessionId;
+      if (row.status === "assigned" && reDispatchedSessionId && !sessionIdsEquivalent(reDispatchedSessionId, completingSessionId)) {
+        stopStaleMeshWorker(components, {
+          meshId,
+          sessionId: reDispatchedSessionId,
+          nodeId: row.assignedNodeId,
+          providerType: row.assignedProviderType
+        });
+      }
+      endTaskDispatchInFlight(meshId, row.id);
+      updateTaskStatus(meshId, row.id, outcome === "completed" ? "completed" : "failed");
+      if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+        try {
+          appendLedgerEntry(meshId, {
+            kind: outcome === "completed" ? "task_completed" : "task_failed",
+            sessionId: completingSessionId,
+            nodeId: readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId) || void 0,
+            providerType: readNonEmptyString2(args.metadataEvent.providerType) || void 0,
+            payload: {
+              taskId: row.id,
+              event: args.event,
+              source: "redrive_late_completion_supersede",
+              reclaimReason: row.requeueReason,
+              reclaimAgeMs: Date.now() - requeuedAtMs,
+              finalSummary: readNonEmptyString2(args.metadataEvent.finalSummary) || void 0
+            }
+          });
+        } catch {
+        }
+      }
+      LOG2.warn("MeshQueue", `Late completion superseded re-drive for task ${row.id} on mesh ${meshId} (reclaimed '${row.requeueReason}' ${Math.round((Date.now() - requeuedAtMs) / 1e3)}s ago; completing session ${completingSessionId}) \u2192 flipped ${outcome}${row.status === "assigned" && reDispatchedSessionId && !sessionIdsEquivalent(reDispatchedSessionId, completingSessionId) ? `, stopped duplicate re-dispatch on ${reDispatchedSessionId}` : ""}`);
+      traceMeshEventDrop("redrive_late_completion_supersede", {
+        taskId: row.id,
+        sessionId: completingSessionId,
+        nodeId: row.assignedNodeId ?? args.nodeId,
+        meshId,
+        event: args.event
+      }, `${row.requeueReason} ${Math.round((Date.now() - requeuedAtMs) / 1e3)}s \u2192 ${outcome}`);
+      return true;
+    }
     function injectMeshSystemMessage(components, args) {
       const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
       const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
@@ -50484,6 +50553,7 @@ ${cleanBody}`;
                   }
                 });
               }
+            } else if (strandedRow && supersedeRedriveReclaimForLateCompletion(components, args.meshId, strandedRow, sessionId, outcome, args)) {
             }
           } catch {
           }
@@ -51807,6 +51877,50 @@ ${cleanBody}`;
         LOG2.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
       }
     }
+    async function pollAssignedTaskTerminalEvidence(components, mesh, row) {
+      const sessionId = readNonEmptyString2(row.assignedSessionId);
+      const nodeId = readNonEmptyString2(row.assignedNodeId);
+      if (!sessionId || !nodeId) return null;
+      const node = (mesh.nodes ?? []).find((n) => n.id === nodeId);
+      const nodeDaemonId = readNonEmptyString2(node?.daemonId);
+      const localDaemonId = readNonEmptyString2(components.statusInstanceId);
+      const isLocalNode = !nodeDaemonId || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+      const providerType = readNonEmptyString2(row.assignedProviderType);
+      const readArgs = {
+        sessionId,
+        targetSessionId: sessionId,
+        tailLimit: 10,
+        ...node?.workspace ? { workspace: node.workspace } : {},
+        ...providerType ? { agentType: providerType, providerType } : {}
+      };
+      let payload = null;
+      try {
+        if (isLocalNode) {
+          const result = await components.commandHandler?.handle("read_chat", readArgs);
+          if (result && result.success === false) return null;
+          payload = unwrapReadChatPayload(result);
+        } else if (components.dispatchMeshCommand) {
+          const result = await components.dispatchMeshCommand(nodeDaemonId, "read_chat", readArgs);
+          payload = unwrapReadChatPayload(result);
+          if (payload && payload.success === false) return null;
+        } else {
+          return null;
+        }
+      } catch {
+        return null;
+      }
+      if (!payload) return null;
+      if (readChatPayloadStatus(payload) !== "idle") return null;
+      const messages = Array.isArray(payload.messages) ? payload.messages : [];
+      const evidence = extractFinalAssistantSummaryEvidence(messages);
+      if (!evidence.finalSummary) return null;
+      const dispatchedAtMs = Date.parse(readNonEmptyString2(row.dispatchTimestamp));
+      const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
+      if (!(Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs >= dispatchedAtMs)) {
+        return null;
+      }
+      return "completed";
+    }
     var init_mesh_completion_synthesis = __esm2({
       "src/mesh/mesh-completion-synthesis.ts"() {
         "use strict";
@@ -52081,7 +52195,8 @@ ${cleanBody}`;
       }
       return delivered;
     }
-    function recoverStrandedAssignedDispatches(components, meshId, store) {
+    async function recoverStrandedAssignedDispatches(components, mesh, store) {
+      const meshId = mesh.id;
       const assigned = getQueue(meshId, { status: ["assigned"] });
       if (!assigned.length) return;
       const nowMs = Date.now();
@@ -52188,6 +52303,36 @@ ${cleanBody}`;
             }
             reclaimReason = "reclaim_after_unknown_grace";
           }
+          const terminalEvidence = await pollAssignedTaskTerminalEvidence(components, mesh, row);
+          if (terminalEvidence) {
+            deliveredNoTurnUnknownStreak.delete(streakKey);
+            updateTaskStatus(meshId, row.id, terminalEvidence);
+            if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+              try {
+                appendLedgerEntry(meshId, {
+                  kind: terminalEvidence === "completed" ? "task_completed" : "task_failed",
+                  nodeId: row.assignedNodeId,
+                  sessionId: row.assignedSessionId,
+                  providerType: row.assignedProviderType,
+                  payload: {
+                    taskId: row.id,
+                    event: "agent:generating_completed",
+                    source: "redrive_deadline_transcript_evidence"
+                  }
+                });
+              } catch {
+              }
+            }
+            LOG2.warn("MeshReconcile", `Skipped delivered-no-turn re-drive for task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}): worker transcript is idle with a final assistant message after dispatch \u2014 the completion event was lost/late, task is ${terminalEvidence}, NOT re-driving`);
+            traceMeshEventDrop("redrive_deadline_transcript_completed", {
+              taskId: row.id,
+              sessionId: row.assignedSessionId,
+              nodeId: row.assignedNodeId,
+              meshId,
+              event: "agent:generating_completed"
+            }, `${reclaimReason} \u2192 transcript ${terminalEvidence}`);
+            continue;
+          }
           const reclaimedLost = reclaimStrandedAssignedTask(meshId, row.id, {
             reason: reclaimReason,
             ageMs: nowMs - dispatchedAtMs
@@ -52314,7 +52459,7 @@ ${cleanBody}`;
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
           if (!daemonHostsMesh(mesh, selfIds)) continue;
           try {
-            recoverStrandedAssignedDispatches(components, mesh.id, store);
+            await recoverStrandedAssignedDispatches(components, mesh, store);
           } catch (e) {
             LOG2.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
           }
@@ -54488,6 +54633,70 @@ ${cleanBody}`;
       if (buttonBlockApprovalCue(spec, text)) return true;
       return false;
     }
+    function lastModalCueLine(spec, screenText) {
+      if (!screenText) return -1;
+      const lines = screenText.split("\n");
+      const question = compile2(spec.questionPattern, spec.questionFlags ?? "i");
+      const variants = (spec.questionVariants ?? []).map((v) => compile2(v.regex, v.flags ?? "i"));
+      const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes("m") ? spec.buttonFlags : `${spec.buttonFlags ?? ""}m`;
+      const buttonRe = compile2(spec.buttonPattern, buttonFlags);
+      let last = -1;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        question.lastIndex = 0;
+        if (question.test(line)) {
+          last = i;
+          continue;
+        }
+        if (variants.some((re) => {
+          re.lastIndex = 0;
+          return re.test(line);
+        })) {
+          last = i;
+          continue;
+        }
+        buttonRe.lastIndex = 0;
+        if (buttonRe.test(line)) {
+          last = i;
+          continue;
+        }
+      }
+      return last;
+    }
+    function modalSupersededBySettledPrompt(modalSpec, settledSpec, settled, input) {
+      if (!settled || !settledSpec) return false;
+      if (settledSpec.scope === "whole-screen") return false;
+      const screenText = input.screenText ?? "";
+      if (!screenText) return false;
+      const modalLine = lastModalCueLine(modalSpec, screenText);
+      if (modalLine < 0) return false;
+      const lines = screenText.split("\n");
+      const below = lines.slice(modalLine + 1);
+      if (below.length === 0) return false;
+      const belowText = below.join("\n");
+      if (!settled.prompt.test(belowText)) return false;
+      if (settled.footers.length > 0 && !settled.footers.every((f) => f.test(belowText))) return false;
+      const question = compile2(modalSpec.questionPattern, modalSpec.questionFlags ?? "i");
+      const variants = (modalSpec.questionVariants ?? []).map((v) => compile2(v.regex, v.flags ?? "i"));
+      const buttonFlags = modalSpec.buttonFlags && modalSpec.buttonFlags.includes("m") ? modalSpec.buttonFlags : `${modalSpec.buttonFlags ?? ""}m`;
+      const buttonRe = compile2(modalSpec.buttonPattern, buttonFlags);
+      const isModalCueLine = (line) => {
+        question.lastIndex = 0;
+        if (question.test(line)) return true;
+        if (variants.some((re) => {
+          re.lastIndex = 0;
+          return re.test(line);
+        })) return true;
+        buttonRe.lastIndex = 0;
+        return buttonRe.test(line);
+      };
+      const settledPromptLineRe = compile2(settledSpec.regex, (settledSpec.flags ?? "m").includes("m") ? settledSpec.flags ?? "m" : `${settledSpec.flags ?? ""}m`);
+      const isSettledLine = (line) => {
+        settledPromptLineRe.lastIndex = 0;
+        return settledPromptLineRe.test(line);
+      };
+      return below.some((line) => line.trim() !== "" && !isModalCueLine(line) && !isSettledLine(line));
+    }
     function evaluateGroup(group, spec, input, compiled) {
       switch (group) {
         case "spinner": {
@@ -54497,7 +54706,9 @@ ${cleanBody}`;
         }
         case "modal": {
           if (!spec.modal) return null;
-          return modalMatches(spec.modal, input) ? "waiting_approval" : null;
+          if (!modalMatches(spec.modal, input)) return null;
+          if (modalSupersededBySettledPrompt(spec.modal, spec.settledPrompt, compiled.settled, input)) return null;
+          return "waiting_approval";
         }
         case "settled-prompt": {
           if (!spec.settledPrompt || !compiled.settled) return null;
@@ -54553,6 +54764,21 @@ ${cleanBody}`;
     }
     function findQuestionLineIndex(spec, lines) {
       const primary = compile3(spec.questionPattern, spec.questionFlags ?? "i");
+      const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes("m") ? spec.buttonFlags : `${spec.buttonFlags ?? ""}m`;
+      const buttonRe = compile3(spec.buttonPattern, buttonFlags);
+      const isButtonLine = (line) => {
+        buttonRe.lastIndex = 0;
+        return buttonRe.test(line);
+      };
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (primary.test(lines[i]) && !isButtonLine(lines[i])) return { index: i, matchedSource: "primary" };
+      }
+      for (const variant of spec.questionVariants ?? []) {
+        const re = compile3(variant.regex, variant.flags ?? "i");
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+          if (re.test(lines[i]) && !isButtonLine(lines[i])) return { index: i, matchedSource: variant.label ?? "variant" };
+        }
+      }
       for (let i = lines.length - 1; i >= 0; i -= 1) {
         if (primary.test(lines[i])) return { index: i, matchedSource: "primary" };
       }
@@ -55286,6 +55512,7 @@ ${cont}` : cont;
            * paint and made the engine type "1" repeatedly into the prompt.
            */
           modalLostAt = 0;
+          modalLostRecheckTimer = null;
           approvalExitTimeout = null;
           // ── Response tracking ────────────────────────────
           responseEpoch = 0;
@@ -55337,6 +55564,10 @@ ${cont}` : cont;
           setStatus(status, trigger) {
             const prev = this.currentStatus;
             if (prev === status) return;
+            if (prev === "waiting_approval" && this.modalLostRecheckTimer) {
+              clearTimeout(this.modalLostRecheckTimer);
+              this.modalLostRecheckTimer = null;
+            }
             this.currentStatus = status;
             this.statusHistory.push({ status, at: Date.now(), trigger });
             if (this.statusHistory.length > 50) this.statusHistory.shift();
@@ -55497,6 +55728,10 @@ ${cont}` : cont;
               clearTimeout(this.approvalExitTimeout);
               this.approvalExitTimeout = null;
             }
+            if (this.modalLostRecheckTimer) {
+              clearTimeout(this.modalLostRecheckTimer);
+              this.modalLostRecheckTimer = null;
+            }
             if (this.finishRetryTimer) {
               clearTimeout(this.finishRetryTimer);
               this.finishRetryTimer = null;
@@ -55808,7 +56043,7 @@ ${cont}` : cont;
             if (!inCooldown || modal) {
               if (!modal) {
                 LOG2.warn("CLI", `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
-                if (this.currentStatus === "waiting_approval" && this.activeModal) {
+                if (this.currentStatus === "waiting_approval") {
                   const lostAt = this.modalLostAt || Date.now();
                   if (!this.modalLostAt) this.modalLostAt = lostAt;
                   if (Date.now() - lostAt >= this.timeouts.approvalCooldown) {
@@ -55816,6 +56051,8 @@ ${cont}` : cont;
                     this.modalLostAt = 0;
                     this.setStatus("generating", "approval_lost_modal");
                     this.callbacks.onStatusChange();
+                  } else {
+                    this.armModalLostRecheck();
                   }
                 }
                 return;
@@ -56077,6 +56314,25 @@ ${cont}` : cont;
             this.recordTrace("idle_finish_cancelled", { trigger: reason });
           }
           // ─── Helpers ────────────────────────────────────────────────────────────
+          /**
+           * Schedule one more settled evaluation while pinned to `waiting_approval`
+           * with no actionable modal. The settled FSM normally only re-runs on new
+           * PTY output; a provider whose modal cue lingers in a form detectStatus
+           * still matches (e.g. kimi's questionPattern hitting the user echo) but
+           * whose PTY has gone quiet would never get another evaluation, latching
+           * `waiting_approval` forever. This timer guarantees the modal-lost recovery
+           * in `applyWaitingApproval` is reached even against a silent PTY. It is a
+           * no-op once the FSM leaves `waiting_approval` (the re-evaluation itself
+           * takes the recovery branch and clears the state).
+           */
+          armModalLostRecheck() {
+            if (this.modalLostRecheckTimer) return;
+            this.modalLostRecheckTimer = setTimeout(() => {
+              this.modalLostRecheckTimer = null;
+              if (this.currentStatus !== "waiting_approval") return;
+              this.evaluateSettled(this.transport.getSnapshot());
+            }, this.timeouts.approvalCooldown);
+          }
           armApprovalExitTimeout() {
             if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
             this.approvalExitTimeout = setTimeout(() => {
@@ -56669,6 +56925,7 @@ ${cont}` : cont;
             const staleSnapshotLooksActive = activeScreenPattern.test(lastSnapshot);
             const currentScreenLooksIdle = /(?:^|\n|\r)\s*[❯›>]\s*(?:Try\s+["“][^\n\r"”]+["”])?\s*(?:\n|\r|$)/.test(screenText) && !activeScreenPattern.test(screenText);
             if (staleSnapshotLooksActive && currentScreenLooksIdle) return screenText;
+            if (this.runDetectStatus(screenText) === "idle") return screenText;
             if (currentSnapshot.length >= lastSnapshot.length) return screenText;
             return `${screenText}
 ${lastSnapshot}`;
@@ -65824,6 +66081,33 @@ ${effect.notification.body || ""}`.trim();
       getState(key2) {
         return this.records.get(key2)?.state ?? INITIAL_CHAT_SOURCE_STATE;
       }
+      /**
+       * Opaque snapshot of a session's FULL record (state + lock + transitions),
+       * for callers that need to speculatively `observe()` and then roll back if
+       * the resulting decision is undesirable (STICKY-NATIVE hold: a trusted
+       * exact-identity session must not flip to PTY on a transient native gap).
+       * Returns undefined when the session has no record yet. The snapshot is a
+       * shallow copy — transitions array is copied so a later append does not
+       * mutate it.
+       */
+      snapshotRecord(key2) {
+        const rec = this.records.get(key2);
+        if (!rec) return void 0;
+        return { state: rec.state, lockedSince: rec.lockedSince, transitions: [...rec.transitions] };
+      }
+      /** Restore a previously snapshotted record, undoing a speculative observe.
+       *  Passing undefined clears the key (it had no record when snapshotted). */
+      restoreRecord(key2, snapshot) {
+        if (!snapshot) {
+          this.records.delete(key2);
+          return;
+        }
+        this.records.set(key2, {
+          state: snapshot.state,
+          lockedSince: snapshot.lockedSince,
+          transitions: [...snapshot.transitions]
+        });
+      }
       /** Recent transitions, newest last. Empty array when nothing has happened. */
       getTransitions(key2) {
         return this.records.get(key2)?.transitions ?? [];
@@ -66245,7 +66529,52 @@ ${effect.notification.body || ""}`.trim();
       const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
       const observation = buildObservationForCli(args, supportsNative);
       const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
+      const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey);
+      const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey);
+      const eligibleForStickyHold = args.trustedExactNativeIdentity === true && (priorState.name === "NativeLocked" || priorState.name === "Recovering");
       let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+      if (eligibleForStickyHold && decision.selected === "pty-parser") {
+        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey, priorSnapshot);
+        const heldNativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
+        const messageSource2 = buildCliMessageSourceProvenance({
+          selected: "native-history",
+          provider: args.providerType,
+          nativeHandle: typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0,
+          sessionWorkspace: args.sessionWorkspace,
+          intendedWorkspace: args.intendedWorkspace,
+          transcriptWorkspace: void 0,
+          fallbackReason: "native_history_transient_gap_held",
+          nativeSource: "provider-native",
+          sourcePath: typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0,
+          sourceMtimeMs: typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0,
+          nativeHistoryCoverage: void 0,
+          partialReason: void 0,
+          unavailableReason: observation.kind === "native_unavailable" ? observation.reason : void 0,
+          nativeMessages: heldNativeMessages,
+          ptyMessages: args.ptyMessages,
+          returnedMessages: heldNativeMessages,
+          safeMapping: args.safeMapping,
+          freshEnough: true,
+          ptyStatusApprovalOnly: true
+        });
+        return {
+          decision: {
+            selected: "native-history",
+            nextState: priorState,
+            transition: {
+              fromState: priorState.name,
+              toState: priorState.name,
+              event: "NoOp",
+              cause: decision.transition.cause,
+              at: Date.now()
+            },
+            lockState: { locked: priorState.name === "NativeLocked" }
+          },
+          messageSource: messageSource2,
+          nativeMessages: heldNativeMessages,
+          nativeSelected: true
+        };
+      }
       if (decision.selected === "pty-parser" && args.trustedExactNativeIdentity === true && args.safeMapping && args.ptyMessages.length === 0 && observation.kind === "native_present" && observation.coverage !== "partial" && observation.messages.length > 0) {
         CHAT_SOURCE_REGISTRY.clear(sessionKey);
         decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
@@ -66565,7 +66894,7 @@ ${effect.notification.body || ""}`.trim();
     function readCliProviderNativeHistory(agentStr, args) {
       const canBindFromLiveSession = !args.historySessionId && typeof args.sessionStartedAtMs === "number" && args.sessionStartedAtMs > 0 && typeof args.workspace === "string" && args.workspace.trim().length > 0;
       const pinnedProviderSessionId = typeof args.pinnedProviderSessionId === "string" ? args.pinnedProviderSessionId.trim() : "";
-      const effectiveHistorySessionId = args.historySessionId || (!canBindFromLiveSession ? pinnedProviderSessionId : "");
+      const effectiveHistorySessionId = args.historySessionId || pinnedProviderSessionId || "";
       const workspaceLatestFallback = !effectiveHistorySessionId && !canBindFromLiveSession && !pinnedProviderSessionId && args.allowWorkspaceLatestFallback === true && typeof args.workspace === "string" && args.workspace.trim().length > 0;
       if (!effectiveHistorySessionId && !canBindFromLiveSession && !workspaceLatestFallback) {
         return {