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

package/dist/chat/source-resolver.d.ts

@@ -41,6 +41,27 @@ export declare class ChatSourceRegistry {
     private readonly records;
     /** Snapshot of current state for diagnostics. Does not mutate. */
     getState(key: ChatSourceSessionKey): ChatSourceState;
+    /**
+     * 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(key: ChatSourceSessionKey): {
+        state: ChatSourceState;
+        lockedSince: number | undefined;
+        transitions: ChatSourceTransition[];
+    } | undefined;
+    /** Restore a previously snapshotted record, undoing a speculative observe.
+     *  Passing undefined clears the key (it had no record when snapshotted). */
+    restoreRecord(key: ChatSourceSessionKey, snapshot: {
+        state: ChatSourceState;
+        lockedSince: number | undefined;
+        transitions: ChatSourceTransition[];
+    } | undefined): void;
     /** Recent transitions, newest last. Empty array when nothing has happened. */
     getTransitions(key: ChatSourceSessionKey): ReadonlyArray<ChatSourceTransition>;
     /** Drop a session. Caller should invoke this when the session is destroyed

package/dist/cli-adapters/cli-state-engine.d.ts

@@ -105,6 +105,7 @@ export declare class CliStateEngine {
      * paint and made the engine type "1" repeatedly into the prompt.
      */
     modalLostAt: number;
+    private modalLostRecheckTimer;
     private approvalExitTimeout;
     responseEpoch: number;
     submitPendingUntil: number;
@@ -230,6 +231,18 @@ export declare class CliStateEngine {
     finishResponse(): void;
     private scheduleIdleFinish;
     private cancelPendingIdleFinish;
+    /**
+     * 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).
+     */
+    private armModalLostRecheck;
     private armApprovalExitTimeout;
     private armIdleFinishCandidate;
     private shouldDeferIdleTimeoutFinish;

package/dist/index.js

@@ -419,10 +419,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "e7001a2fe5b5af35d3710c964727f7e4d735e852" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "e7001a2f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:34:59.318Z" : 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 version = 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:51:55.785Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -5712,6 +5712,8 @@ __export(mesh_work_queue_exports, {
   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,
@@ -6007,10 +6009,21 @@ function normalizeMeshCapabilityTags(value) {
     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 record = 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(record.slots)) push(slot.provider);
+  if (Array.isArray(record.providerPriority)) {
+    for (const type of record.providerPriority) push(type);
+  }
+  return out;
 }
 function readNodeOverride(node, key2) {
   const overrides = node?.userOverrides;
@@ -6023,7 +6036,8 @@ function readNodeReporter(node, key2) {
   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 os32 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
   const arch2 = readNodeOverride(node, "arch") ?? readNodeReporter(node, "arch") ?? process.arch;
@@ -6031,7 +6045,7 @@ function buildMeshNodeCapabilityTags(node, providerType) {
     ...Array.isArray(node?.capabilities) ? node.capabilities : [],
     `os=${os32}`,
     `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.
@@ -6534,7 +6548,7 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var import_crypto6, ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS;
+var import_crypto6, ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS, REDRIVE_RECLAIM_REASONS, REDRIVE_SUPERSEDE_WINDOW_MS;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -6603,6 +6617,12 @@ var init_mesh_work_queue = __esm({
     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;
   }
 });
 
@@ -16841,7 +16861,8 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       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))
@@ -20430,6 +20451,52 @@ function stopStaleMeshWorker(components, args) {
     LOG.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 {
+    }
+  }
+  LOG.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);
@@ -20541,6 +20608,7 @@ function injectMeshSystemMessage(components, args) {
               }
             });
           }
+        } else if (strandedRow && supersedeRedriveReclaimForLateCompletion(components, args.meshId, strandedRow, sessionId, outcome, args)) {
         }
       } catch {
       }
@@ -21867,6 +21935,50 @@ async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDa
     LOG.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 = __esm({
   "src/mesh/mesh-completion-synthesis.ts"() {
     "use strict";
@@ -22143,7 +22255,8 @@ function drainAndDeliverApprovalNudges(meshId, drainDaemonIds, localDaemonId, me
   }
   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();
@@ -22250,6 +22363,36 @@ function recoverStrandedAssignedDispatches(components, meshId, store) {
         }
         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 {
+          }
+        }
+        LOG.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
@@ -22376,7 +22519,7 @@ async function runMeshReconcileTick(components) {
       const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
       if (!daemonHostsMesh(mesh, selfIds)) continue;
       try {
-        recoverStrandedAssignedDispatches(components, mesh.id, store);
+        await recoverStrandedAssignedDispatches(components, mesh, store);
       } catch (e) {
         LOG.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
       }
@@ -24551,6 +24694,70 @@ function modalMatches(spec, input) {
   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": {
@@ -24560,7 +24767,9 @@ function evaluateGroup(group, spec, input, compiled) {
     }
     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;
@@ -24618,6 +24827,21 @@ function compile3(re, flags) {
 }
 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" };
   }
@@ -25347,6 +25571,7 @@ var init_cli_state_engine = __esm({
        * paint and made the engine type "1" repeatedly into the prompt.
        */
       modalLostAt = 0;
+      modalLostRecheckTimer = null;
       approvalExitTimeout = null;
       // ── Response tracking ────────────────────────────
       responseEpoch = 0;
@@ -25398,6 +25623,10 @@ var init_cli_state_engine = __esm({
       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();
@@ -25558,6 +25787,10 @@ var init_cli_state_engine = __esm({
           clearTimeout(this.approvalExitTimeout);
           this.approvalExitTimeout = null;
         }
+        if (this.modalLostRecheckTimer) {
+          clearTimeout(this.modalLostRecheckTimer);
+          this.modalLostRecheckTimer = null;
+        }
         if (this.finishRetryTimer) {
           clearTimeout(this.finishRetryTimer);
           this.finishRetryTimer = null;
@@ -25869,7 +26102,7 @@ var init_cli_state_engine = __esm({
         if (!inCooldown || modal) {
           if (!modal) {
             LOG.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) {
@@ -25877,6 +26110,8 @@ var init_cli_state_engine = __esm({
                 this.modalLostAt = 0;
                 this.setStatus("generating", "approval_lost_modal");
                 this.callbacks.onStatusChange();
+              } else {
+                this.armModalLostRecheck();
               }
             }
             return;
@@ -26138,6 +26373,25 @@ var init_cli_state_engine = __esm({
         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(() => {
@@ -26731,6 +26985,7 @@ var init_provider_cli_adapter = __esm({
         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}`;
@@ -35979,6 +36234,33 @@ var ChatSourceRegistry = class {
   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 ?? [];
@@ -36402,7 +36684,52 @@ function decideCliReadChatSource(args) {
   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);
@@ -36722,7 +37049,7 @@ function sessionSpawnEnvFromAdapter(h, targetSessionId) {
 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 {