@adhdev/daemon-core 0.9.82-rc.350 → 0.9.82-rc.352

package/dist/index.mjs

@@ -311,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "f066449c7e758daf63ad40d431a5e97fc8d79a0e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f066449c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.350" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-21T19:33:17.868Z" : void 0);
+  const commit = readInjected(true ? "ca5f944b7763a621357fc28a9f62ac398b0ced6c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "ca5f944b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.352" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-22T07:17:05.715Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3193,7 +3193,7 @@ function installGlobalInterceptor() {
 function getLogPath() {
   return currentLogFile;
 }
-var LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
+var LEVEL_NUM, LEVEL_LABEL, currentLevel, ADHDEV_HOME, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
@@ -3201,7 +3201,8 @@ var init_logger = __esm({
     LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
     LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
     currentLevel = "info";
-    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
+    ADHDEV_HOME = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path9.join(os3.homedir(), ".adhdev");
+    LOG_DIR = path9.join(ADHDEV_HOME, "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -4001,6 +4002,7 @@ __export(mesh_work_queue_exports, {
   nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
   normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
+  reclaimStrandedAssignedTask: () => reclaimStrandedAssignedTask,
   recordDirectDispatchTask: () => recordDirectDispatchTask,
   recordMeshToolCall: () => recordMeshToolCall,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
@@ -4437,6 +4439,52 @@ function requeueTask(meshId, taskId, opts) {
     return entry;
   });
 }
+function reclaimStrandedAssignedTask(meshId, taskId, opts) {
+  requireMeshHostQueueOwner(opts);
+  return withQueueLock(meshId, () => {
+    const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
+    if (!entry) return null;
+    if (entry.status !== "assigned") return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const reason = opts?.reason || "assigned_stranded_dispatch_unconfirmed";
+    const reclaims = (entry.strandedReclaimCount || 0) + 1;
+    const prevNode = entry.assignedNodeId;
+    const prevSession = entry.assignedSessionId;
+    delete entry.assignedNodeId;
+    delete entry.assignedSessionId;
+    delete entry.assignedProviderType;
+    delete entry.dispatchTimestamp;
+    entry.strandedReclaimCount = reclaims;
+    entry.updatedAt = now;
+    if (reclaims > MAX_STRANDED_RECLAIMS) {
+      entry.status = "failed";
+      entry.cancelReason = `stranded_dispatch_unrecovered: reclaimed ${reclaims - 1} time(s) without a confirmed dispatch`;
+      MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+      propagateDependencyFailure(meshId, taskId);
+    } else {
+      entry.status = "pending";
+      entry.requeuedAt = now;
+      entry.requeueReason = reason;
+      MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+    }
+    try {
+      appendLedgerEntry(meshId, {
+        kind: "task_reclaimed",
+        nodeId: prevNode,
+        sessionId: prevSession,
+        payload: {
+          taskId,
+          reason,
+          ...typeof opts?.ageMs === "number" ? { ageMs: opts.ageMs } : {},
+          reclaimCount: reclaims,
+          outcome: entry.status
+        }
+      });
+    } catch {
+    }
+    return entry;
+  });
+}
 function updateSessionTaskStatus(meshId, sessionId, status, opts) {
   return withQueueLock(meshId, () => {
     const store = MeshRuntimeStore.getInstance();
@@ -4550,7 +4598,7 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS;
+var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -4559,6 +4607,7 @@ var init_mesh_work_queue = __esm({
     init_mesh_runtime_store();
     init_mesh_config();
     init_logger();
+    init_mesh_ledger();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
     HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
     MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -4611,6 +4660,7 @@ 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;
   }
 });
 
@@ -4670,6 +4720,10 @@ var init_mesh_runtime_store = __esm({
       migratedMeshIds = /* @__PURE__ */ new Set();
       fingerprintSweepCounter = 0;
       walWriteCounter = 0;
+      // Independent cadence for the tool-call-log sweep. Must NOT share walWriteCounter:
+      // sharing makes each store's threshold drift by the other's write volume (WAL
+      // checkpoint at 500 vs tool-log sweep at 200 would interfere arbitrarily).
+      toolCallLogCounter = 0;
       static WAL_CHECK_INTERVAL = 500;
       static WAL_MAX_BYTES = 50 * 1024 * 1024;
       // 50 MB
@@ -5492,6 +5546,22 @@ var init_mesh_runtime_store = __esm({
           updatedAt: r.updated_at
         }));
       }
+      /**
+       * Bug B watchdog support: true when at least one delivery record for the task has
+       * reached a confirmed-handed-off status (delivered / acked / completed). The
+       * assigned-stranded watchdog uses this to distinguish a dispatch that was never
+       * confirmed (reclaimable) from one that WAS handed to the worker (a genuinely
+       * in-flight or completion-lost task, which is PHASE 4's responsibility, not this
+       * watchdog's). Indexed by (mesh_id, task_id).
+       */
+      taskHasConfirmedDelivery(meshId, taskId) {
+        const row = this.db.prepare(`
+            SELECT 1 FROM mesh_session_delivery
+            WHERE mesh_id = ? AND task_id = ? AND status IN ('delivered','acked','completed')
+            LIMIT 1
+        `).get(meshId, taskId);
+        return !!row;
+      }
       expireStaleSessionDeliveries(meshId) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         this.db.prepare(`
@@ -5563,7 +5633,7 @@ var init_mesh_runtime_store = __esm({
           "SELECT COUNT(*) as cnt FROM mesh_tool_call_log WHERE mesh_id = ? AND tool = ? AND called_at >= ?"
         ).get(meshId, tool, windowStart);
         const callsInWindow = row?.cnt ?? 0;
-        if (++this.walWriteCounter % 200 === 0) {
+        if (++this.toolCallLogCounter % 200 === 0) {
           this.db.prepare(
             "DELETE FROM mesh_tool_call_log WHERE called_at < ?"
           ).run(now - Math.max(windowMs * 10, 6e4));
@@ -6018,9 +6088,9 @@ function computeMeshTaskStats(meshId, opts) {
   }
   return targetIds.map((taskId) => {
     const queueEntry = queueById.get(taskId);
-    const status = queueEntry?.status ?? "unknown";
     const dispatch = dispatches.get(taskId);
     const terminal = terminals.get(taskId);
+    const status = queueEntry?.status ?? (terminal ? terminal.kind === "task_completed" ? "completed" : "failed" : "unknown");
     const isTerminalStatus = status === "completed" || status === "failed" || status === "cancelled";
     const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
     const terminalTime = parseTime(terminal?.at);
@@ -7915,6 +7985,35 @@ function meshNodeIdMatches(node, candidateId) {
   if (!trimmed) return false;
   return normalizeMeshNodeId(node) === trimmed;
 }
+function machineCoreFromDaemonId(id) {
+  const trimmed = readString5(id);
+  if (!trimmed) return void 0;
+  for (const prefix of DAEMON_ID_PREFIXES) {
+    if (trimmed.startsWith(prefix)) {
+      const core = trimmed.slice(prefix.length).trim();
+      return core || void 0;
+    }
+  }
+  return trimmed;
+}
+function expandDaemonIdForms(ids) {
+  const list = Array.isArray(ids) ? ids : ids != null ? [ids] : [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    if (!value || seen.has(value)) return;
+    seen.add(value);
+    out.push(value);
+  };
+  for (const raw of list) add(readString5(raw));
+  for (const raw of list) {
+    const core = machineCoreFromDaemonId(readString5(raw));
+    if (!core || !core.startsWith("mach_")) continue;
+    add(core);
+    for (const prefix of DAEMON_ID_PREFIXES) add(`${prefix}${core}`);
+  }
+  return out;
+}
 function summarizeGitShape(status) {
   const record = readRecord3(status);
   if (!Object.keys(record).length) return null;
@@ -7949,9 +8048,11 @@ function summarizeGitShape(status) {
     submodules
   };
 }
+var DAEMON_ID_PREFIXES;
 var init_dist = __esm({
   "../mesh-shared/dist/index.mjs"() {
     "use strict";
+    DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
   }
 });
 
@@ -8029,6 +8130,14 @@ function statusFromTerminal(entry) {
   if (entry.kind === "task_completed") return "idle";
   return "failed";
 }
+function classifyDirectDispatch(params) {
+  const { status, isTerminalRow, hasTerminalStatus, liveStatus, liveStaleReason, dispatchedToIdleSession } = params;
+  const isNoTransition = !hasTerminalStatus && !liveStatus;
+  const isIdleUnacknowledged = status === "idle";
+  const ledgerOnlyStaleReason = !isTerminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? LEDGER_ONLY_STALE_REASON : void 0;
+  const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !liveStaleReason);
+  return { ledgerOnlyStaleReason, isFreshUnacknowledged };
+}
 function buildMeshActiveWorkSummary(activeWork) {
   const statusCounts = {
     pending: 0,
@@ -8091,10 +8200,14 @@ function buildMeshActiveWork(opts) {
       const dbStatus = dispatch.status;
       const isTerminal = dbStatus === "completed" || dbStatus === "failed" || dbStatus === "stale";
       const status = isTerminal ? dbStatus === "completed" ? "idle" : "failed" : live.status || (dbStatus === "acked" ? "generating" : "assigned");
-      const isNoTransition = !isTerminal && !live.status;
-      const isIdleUnacknowledged = status === "idle" && !isTerminal;
-      const ledgerOnlyStaleReason = !isTerminal && (isIdleUnacknowledged || isNoTransition || dispatch.dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
+      const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: isTerminal,
+        hasTerminalStatus: isTerminal,
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.dispatchedToIdleSession === true
+      });
       const { title, summary: summary2 } = summarizeMessage(dispatch.message || "");
       const record = {
         taskId: dispatch.taskId,
@@ -8137,13 +8250,16 @@ function buildMeshActiveWork(opts) {
       const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
       const status = terminalStatus || live.status || "assigned";
       const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-      const isNoTransition = !terminalStatus && !live.status;
-      const isIdleUnacknowledged = status === "idle";
-      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
+      const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: terminalRow,
+        hasTerminalStatus: Boolean(terminalStatus),
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
+      });
       const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
       const { title, summary: summary2 } = summarizeMessage(message);
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
       const record = {
         taskId,
         source: "direct",
@@ -8185,13 +8301,16 @@ function buildMeshActiveWork(opts) {
       const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
       const status = terminalStatus || live.status || "assigned";
       const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-      const isNoTransition = !terminalStatus && !live.status;
-      const isIdleUnacknowledged = status === "idle";
-      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
+      const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: terminalRow,
+        hasTerminalStatus: Boolean(terminalStatus),
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
+      });
       const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
       const { title, summary: summary2 } = summarizeMessage(message);
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
       const record = {
         taskId,
         source: "direct",
@@ -8342,7 +8461,7 @@ function buildCompactStaleDirectWorkSummary(staleDirectWork, opts = {}) {
     ...opts.note ? { note: opts.note } : {}
   };
 }
-var DIRECT_DISPATCH_VIA, TERMINAL_LEDGER_KINDS, PRUNABLE_ORPHAN_STALE_REASONS;
+var DIRECT_DISPATCH_VIA, TERMINAL_LEDGER_KINDS, LEDGER_ONLY_STALE_REASON, PRUNABLE_ORPHAN_STALE_REASONS;
 var init_mesh_active_work = __esm({
   "src/mesh/mesh-active-work.ts"() {
     "use strict";
@@ -8351,6 +8470,7 @@ var init_mesh_active_work = __esm({
     init_dist();
     DIRECT_DISPATCH_VIA = /* @__PURE__ */ new Set(["p2p_direct", "local_direct", "mesh_send_task"]);
     TERMINAL_LEDGER_KINDS = /* @__PURE__ */ new Set(["task_completed", "task_failed", "task_stalled"]);
+    LEDGER_ONLY_STALE_REASON = "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition";
     PRUNABLE_ORPHAN_STALE_REASONS = /* @__PURE__ */ new Set([
       "direct task node is no longer in the live mesh",
       "direct task session is not present in live session records",
@@ -8592,17 +8712,7 @@ import { appendFileSync as appendFileSync2, existsSync as existsSync14, readFile
 import { join as join15 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
-  const raw = Array.isArray(coordinatorDaemonId) ? coordinatorDaemonId : coordinatorDaemonId != null ? [coordinatorDaemonId] : [];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const id of raw) {
-    if (typeof id !== "string") continue;
-    const trimmed = id.trim();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    out.push(trimmed);
-  }
-  return out;
+  return expandDaemonIdForms(coordinatorDaemonId);
 }
 function readRefineJobId2(event) {
   const metadata = readRecord4(event.metadataEvent) || event;
@@ -8790,6 +8900,7 @@ function queuePendingMeshCoordinatorEvent(event) {
       return true;
     }
     const fingerprint = buildPendingEventFingerprint(event);
+    let sqliteOk = false;
     try {
       MeshRuntimeStore.getInstance().insertPendingEvent({
         id: randomUUID7(),
@@ -8800,11 +8911,17 @@ function queuePendingMeshCoordinatorEvent(event) {
         fingerprint: fingerprint || null,
         queuedAt: event.queuedAt
       });
+      sqliteOk = true;
     } catch {
     }
-    const path42 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-    trimPendingEventsIfNeeded(path42);
-    appendFileSync2(path42, JSON.stringify(event) + "\n", "utf-8");
+    try {
+      const path42 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+      trimPendingEventsIfNeeded(path42);
+      appendFileSync2(path42, JSON.stringify(event) + "\n", "utf-8");
+    } catch (e) {
+      if (!sqliteOk) throw e;
+      LOG.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+    }
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -8982,6 +9099,7 @@ var init_mesh_events_pending = __esm({
     init_mesh_ledger();
     init_mesh_runtime_store();
     init_mesh_events_utils();
+    init_dist();
     REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
@@ -9200,6 +9318,12 @@ function hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId) {
   }
   return false;
 }
+function isWeakCompletionLedgerPayload(payload) {
+  if (!payload) return false;
+  if (payload.evidenceLevel === "insufficient" || payload.reviewRecommended === true) return true;
+  const diag = readRecord4(payload.completionDiagnostic);
+  return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
+}
 function findDirectDispatchLedgerEntry(args) {
   const entries = readLedgerEntries(args.meshId, { tail: 500 });
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -9236,6 +9360,7 @@ function hasTerminalLedgerAfterDispatch(args) {
       if (!afterDispatch) continue;
     }
     if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+    if (entry.kind === "task_completed" && isWeakCompletionLedgerPayload(entry.payload)) continue;
     const terminalTaskId = readNonEmptyString2(entry.payload?.taskId);
     if (terminalTaskId && terminalTaskId === args.taskId) return true;
     if (terminalTaskId && terminalTaskId !== args.taskId) continue;
@@ -12429,12 +12554,9 @@ var init_snapshot = __esm({
 // src/mesh/mesh-events-coordinator.ts
 import { existsSync as existsSync17 } from "fs";
 function resolveCoordinatorDrainDaemonIds(components) {
-  const ids = /* @__PURE__ */ new Set();
   const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
-  if (statusInstanceId) ids.add(statusInstanceId);
   const machineId = readNonEmptyString2(loadConfig().machineId);
-  if (machineId) ids.add(machineId);
-  return [...ids];
+  return expandDaemonIdForms([statusInstanceId, machineId]);
 }
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
@@ -12561,6 +12683,79 @@ function isDuplicateRefineTerminalEvent(meshId, eventName, metadataEvent) {
   recordFingerprintSeen(fingerprint);
   return false;
 }
+function isFalseIdleCompletion(metadataEvent) {
+  const diag = readRecord4(metadataEvent.completionDiagnostic);
+  if (!diag) return false;
+  return diag.finalAssistantPresent === false || diag.blockReason === "missing_final_assistant";
+}
+function isGenuineCompletionEvidence(metadataEvent) {
+  if (isFalseIdleCompletion(metadataEvent)) return false;
+  return !!readWorkerResultMetadata(metadataEvent) || !!readNonEmptyString2(metadataEvent.finalSummary);
+}
+function isWeakTerminalLedgerPayload(payload) {
+  if (!payload) return false;
+  if (payload.evidenceLevel === "insufficient" || payload.reviewRecommended === true) return true;
+  const diag = readRecord4(payload.completionDiagnostic);
+  return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
+}
+function resolveActiveDirectDispatchTaskId(meshId, sessionId) {
+  try {
+    const matches = getActiveDirectDispatches(meshId).filter((d) => d.sessionId === sessionId);
+    if (!matches.length) return void 0;
+    return readNonEmptyString2(matches[matches.length - 1].taskId) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deliverTaskToSession(dispatchThunk, ctx) {
+  const delivery = createSessionDelivery({
+    meshId: ctx.meshId,
+    nodeId: ctx.nodeId,
+    sessionId: ctx.sessionId,
+    providerType: ctx.providerType,
+    taskId: ctx.task.id,
+    kind: "task",
+    message: ctx.task.message,
+    status: "delivering",
+    ...ctx.sourceCoordinatorSessionId ? { sourceCoordinatorSessionId: ctx.sourceCoordinatorSessionId } : {},
+    ...ctx.sourceCoordinatorDaemonId ? { sourceCoordinatorDaemonId: ctx.sourceCoordinatorDaemonId } : {}
+  });
+  let dispatchPromise;
+  try {
+    dispatchPromise = Promise.resolve(dispatchThunk());
+  } catch (e) {
+    dispatchPromise = Promise.reject(e);
+  }
+  let timer;
+  const guarded = Promise.race([
+    dispatchPromise,
+    new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`dispatch_confirm_timeout after ${DISPATCH_CONFIRM_TIMEOUT_MS}ms`)),
+        DISPATCH_CONFIRM_TIMEOUT_MS
+      );
+      if (typeof timer?.unref === "function") timer.unref();
+    })
+  ]);
+  guarded.then(() => {
+    if (timer) clearTimeout(timer);
+    updateSessionDeliveryStatus(delivery.id, "delivered");
+  }).catch((e) => {
+    if (timer) clearTimeout(timer);
+    LOG.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
+    updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
+    updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
+    try {
+      appendLedgerEntry(ctx.meshId, {
+        kind: "dispatch_failed",
+        nodeId: ctx.nodeId,
+        sessionId: ctx.sessionId,
+        payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable: true, transport: ctx.transport }
+      });
+    } catch {
+    }
+  });
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const mesh = getMeshWithCache(components, meshId);
   const node = mesh?.nodes.find((n) => readMeshNodeId(n) === nodeId);
@@ -12579,46 +12774,33 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     if (!isLocalNode) {
       const localDaemonIdForDispatch = readNonEmptyString2(loadConfig().machineId) || void 0;
       const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
-      const delivery2 = createSessionDelivery({
-        meshId,
-        nodeId,
-        sessionId,
-        providerType,
-        taskId: task.id,
-        kind: "task",
-        message: task.message,
-        status: "delivering",
-        ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
-        ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
-      });
-      components.dispatchMeshCommand(node.daemonId, "agent_command", {
-        targetSessionId: sessionId,
-        cliType: providerType,
-        action: "send_chat",
-        message: task.message,
-        meshContext: {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      const remoteDaemonId = node.daemonId;
+      deliverTaskToSession(
+        () => dispatchMeshCommand(remoteDaemonId, "agent_command", {
+          targetSessionId: sessionId,
+          cliType: providerType,
+          action: "send_chat",
+          message: task.message,
+          meshContext: {
+            meshId,
+            nodeId,
+            taskId: task.id,
+            ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {},
+            ...sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}
+          }
+        }),
+        {
           meshId,
           nodeId,
-          taskId: task.id,
-          ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {},
-          ...sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}
-        }
-      }).then(() => {
-        updateSessionDeliveryStatus(delivery2.id, "delivered");
-      }).catch((e) => {
-        LOG.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-        updateSessionDeliveryStatus(delivery2.id, "failed", { lastError: e?.message, incrementAttempt: true });
-        updateTaskStatus(meshId, task.id, "pending");
-        try {
-          appendLedgerEntry(meshId, {
-            kind: "dispatch_failed",
-            nodeId,
-            sessionId,
-            payload: { taskId: task.id, deliveryId: delivery2.id, error: e?.message, retryable: true }
-          });
-        } catch {
+          sessionId,
+          providerType,
+          task,
+          transport: "remote",
+          ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
+          ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
         }
-      });
+      );
       return true;
     }
   }
@@ -12640,39 +12822,24 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     }
   } catch {
   }
-  const delivery = createSessionDelivery({
-    meshId,
-    nodeId,
-    sessionId,
-    providerType,
-    taskId: task.id,
-    kind: "task",
-    message: task.message,
-    status: "delivering",
-    ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
-    ...readNonEmptyString2(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {}
-  });
-  components.cliManager.handleCliCommand("agent_command", {
-    targetSessionId: sessionId,
-    cliType: providerType,
-    action: "send_chat",
-    message: task.message
-  }).then(() => {
-    updateSessionDeliveryStatus(delivery.id, "delivered");
-  }).catch((e) => {
-    LOG.error("MeshQueue", `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
-    updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
-    updateTaskStatus(meshId, task.id, "pending");
-    try {
-      appendLedgerEntry(meshId, {
-        kind: "dispatch_failed",
-        nodeId,
-        sessionId,
-        payload: { taskId: task.id, deliveryId: delivery.id, error: e?.message, retryable: true }
-      });
-    } catch {
+  deliverTaskToSession(
+    () => components.cliManager.handleCliCommand("agent_command", {
+      targetSessionId: sessionId,
+      cliType: providerType,
+      action: "send_chat",
+      message: task.message
+    }),
+    {
+      meshId,
+      nodeId,
+      sessionId,
+      providerType,
+      task,
+      transport: "local",
+      ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
+      ...readNonEmptyString2(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {}
     }
-  });
+  );
   return true;
 }
 function sweepExpiredCooldowns() {
@@ -12937,7 +13104,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       }
     }
     const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
-      if (task.targetNodeId && readMeshNodeId(node) !== task.targetNodeId) return false;
+      if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
       if (task.requiredTags?.length) {
         const priorities = normalizeProviderPriority(node?.policy);
         const providerCandidates = priorities.length ? priorities : [void 0];
@@ -12948,7 +13115,12 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       return true;
     }) : [];
     if (!candidateNodes.length) {
-      markAutoLaunch(meshId, task.id, { status: "skipped", reason: "no_node_satisfies_required_tags", nodeId: task.targetNodeId });
+      const targetPinUnmatched = !!task.targetNodeId && !(Array.isArray(mesh?.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, task.targetNodeId)));
+      markAutoLaunch(meshId, task.id, {
+        status: "skipped",
+        reason: targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
+        nodeId: task.targetNodeId
+      });
       continue;
     }
     const strategy = resolveSchedulingStrategy(mesh);
@@ -13405,7 +13577,8 @@ function injectMeshSystemMessage(components, args) {
     });
     if (terminal?.kind === "task_completed" && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
       const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
-      if (!newDispatchAfterTerminal) {
+      const supersedesWeakTerminal = isWeakTerminalLedgerPayload(terminal.payload) && isGenuineCompletionEvidence(args.metadataEvent);
+      if (!newDispatchAfterTerminal && !supersedesWeakTerminal) {
         const terminalProviderSessionId = readNonEmptyString2(terminal.payload.providerSessionId);
         const terminalFinalSummary = readNonEmptyString2(terminal.payload.finalSummary);
         const eventProviderSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
@@ -13451,24 +13624,30 @@ function injectMeshSystemMessage(components, args) {
       return { success: true, forwarded: 0, suppressed: true, duplicateStopped: true };
     }
   }
-  function markSessionTerminal(sessionId, outcome, occurredAtMs) {
+  function markSessionTerminal(sessionId, outcome, occurredAtMs, opts) {
     const eventTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
     const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
       occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : void 0,
       taskId: eventTaskId
     });
-    updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+    const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true;
+    if (!leaveDirectDispatchActive) {
+      updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+    }
     markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
     setImmediate(() => cleanupTerminalDirectDispatches());
     return task ? { id: task.id } : null;
   }
   let completedTaskForLedger = null;
+  let directDispatchTaskIdForLedger;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString2(args.metadataEvent.providerType);
     if (sessionId) {
-      completedTaskForLedger = markSessionTerminal(sessionId, "completed", eventTimestamp);
+      directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
+      const isFalseIdle = isFalseIdleCompletion(args.metadataEvent);
+      completedTaskForLedger = markSessionTerminal(sessionId, "completed", eventTimestamp, { tentativeIfDirect: isFalseIdle });
       if (nodeId && providerType) {
         runIdleMaintenanceThenAssignQueue(components, { meshId: args.meshId, nodeId, sessionId, providerType });
       }
@@ -13571,6 +13750,7 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId) {
+      directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
       completedTaskForLedger = markSessionTerminal(sessionId, "failed");
     }
   }
@@ -13600,7 +13780,10 @@ function injectMeshSystemMessage(components, args) {
         payload: {
           event: args.event,
           nodeLabel: args.nodeLabel,
-          taskId: completedTaskForLedger?.id || void 0,
+          // Fix B: fall back to the direct-dispatch taskId when no work-queue row
+          // matched, so the terminal entry is attributable in mesh task-stats
+          // (otherwise the direct task shows status='unknown' / terminalKind=null).
+          taskId: completedTaskForLedger?.id || directDispatchTaskIdForLedger || void 0,
           providerSessionId,
           finalSummary,
           workerResult,
@@ -13888,7 +14071,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, DISPATCH_CONFIRM_TIMEOUT_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
@@ -13916,6 +14099,7 @@ var init_mesh_events_coordinator = __esm({
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
     RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+    DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
     autoLaunchInProgress = /* @__PURE__ */ new Set();
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -13971,12 +14155,9 @@ function resolveReconcileIntervalMs() {
   return DEFAULT_RECONCILE_INTERVAL_MS;
 }
 function resolveCoordinatorDaemonIds(components) {
-  const ids = /* @__PURE__ */ new Set();
   const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
-  if (statusInstanceId) ids.add(statusInstanceId);
   const machineId = readNonEmptyString2(loadConfig().machineId);
-  if (machineId) ids.add(machineId);
-  return [...ids];
+  return expandDaemonIdForms([statusInstanceId, machineId]);
 }
 function daemonHostsMesh(mesh, daemonIds) {
   const host = mesh.meshHost;
@@ -14060,6 +14241,24 @@ function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldFo
     }
   }
 }
+function recoverStrandedAssignedDispatches(meshId, store) {
+  const assigned = getQueue(meshId, { status: ["assigned"] });
+  if (!assigned.length) return;
+  const nowMs = Date.now();
+  for (const row of assigned) {
+    const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
+    if (!Number.isFinite(dispatchedAtMs)) continue;
+    if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
+    if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;
+    const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
+      reason: "assigned_stranded_dispatch_unconfirmed",
+      ageMs: nowMs - dispatchedAtMs
+    });
+    if (reclaimed) {
+      LOG.warn("MeshReconcile", `Reclaimed stranded assigned task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, dispatched ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s ago, never confirmed delivered \u2192 ${reclaimed.status})`);
+    }
+  }
+}
 async function runMeshReconcileTick(components) {
   const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
   const drainDaemonIds = resolveCoordinatorDaemonIds(components);
@@ -14089,6 +14288,17 @@ async function runMeshReconcileTick(components) {
       }
     }
   }
+  if (store) {
+    for (const mesh of listMeshes()) {
+      const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+      if (!daemonHostsMesh(mesh, selfIds)) continue;
+      try {
+        recoverStrandedAssignedDispatches(mesh.id, store);
+      } catch (e) {
+        LOG.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
+      }
+    }
+  }
   for (const mesh of listMeshes()) {
     const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
     if (!daemonHostsMesh(mesh, selfIds)) continue;
@@ -14476,7 +14686,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, STRICT_SESSION_MATCH_TTL_MS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -14489,6 +14699,7 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_events_coordinator();
     init_mesh_unresolved_forward_outbox();
     init_mesh_events_utils();
+    init_dist();
     init_mesh_work_queue();
     init_mesh_ledger();
     init_mesh_active_work();
@@ -14497,6 +14708,7 @@ var init_mesh_reconcile_loop = __esm({
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
     DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
+    ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
     STRICT_SESSION_MATCH_TTL_MS = 6e4;
   }
 });
@@ -14529,6 +14741,84 @@ var init_mesh_events = __esm({
   }
 });
 
+// src/providers/approval-utils.ts
+function normalizeApprovalLabel(value) {
+  return String(value || "").toLowerCase().replace(/^[\s\[(<{]*\d+(?:\s*[.)\]}>:-]|\s)+/, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function isNegativeApprovalLabel(value) {
+  const label = normalizeApprovalLabel(value);
+  return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label) || /\bwithout\b/.test(label) || /\bdo not\b/.test(label);
+}
+function hasNegativeApprovalOption(buttons) {
+  return (buttons || []).some((button) => isNegativeApprovalLabel(String(button || "")));
+}
+function getApprovalPositiveHints(provider) {
+  const customHints = Array.isArray(provider?.approvalPositiveHints) ? provider.approvalPositiveHints.map((hint) => normalizeApprovalLabel(String(hint || ""))).filter(Boolean) : [];
+  return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
+}
+function pickApprovalButton(buttons, provider) {
+  const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
+  if (labels.length === 0) {
+    return { index: -1, label: "" };
+  }
+  const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
+  const hints = getApprovalPositiveHints(provider);
+  for (const hint of hints) {
+    const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
+    if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
+    const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
+    if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
+    const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
+    if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
+  }
+  return { index: -1, label: "" };
+}
+function pickAutoApprovalButton(buttons) {
+  const labels = (buttons || []).map((button) => String(button || "").trim());
+  const index = labels.findIndex(Boolean);
+  return index >= 0 ? { index, label: labels[index] } : { index: -1, label: "" };
+}
+function formatAutoApprovalMessage(modalMessage, buttonLabel) {
+  const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
+  const cleanMessage = String(modalMessage || "").trim();
+  if (cleanMessage) lines.push(cleanMessage);
+  return lines.join("\n");
+}
+function looksLikeActiveApprovalPromptText(content) {
+  const text = content.trim();
+  if (!text || text.length > 2e3) return false;
+  const hasApprovalQuestion = /do you want to (?:proceed|allow|run|make this edit|create)/i.test(text) || /this command requires approval/i.test(text) || /quick safety check/i.test(text) || /is this a project you trust/i.test(text);
+  const hasNumberedChoices = /^\s*[❯›>]?\s*1[.)]\s+(?:yes|allow|proceed|run)/im.test(text) || /^\s*1[.)]\s+yes\b/im.test(text);
+  if (hasApprovalQuestion && hasNumberedChoices) return true;
+  const lastLines = text.split(/\r?\n/).slice(-12).join("\n");
+  const hasDontAskAgain = /yes.*don'?t ask again/i.test(lastLines) || /yes.*always allow/i.test(lastLines);
+  const hasNoOption = /^\s*[❯›>]?\s*\d+[.)]\s+no\b/im.test(lastLines);
+  if (hasDontAskAgain && hasNoOption) return true;
+  if (/what do you want to do\?/i.test(text) && /^\s*\d+[.)]\s+\S/m.test(text)) return true;
+  return false;
+}
+var DEFAULT_APPROVAL_POSITIVE_HINTS;
+var init_approval_utils = __esm({
+  "src/providers/approval-utils.ts"() {
+    "use strict";
+    DEFAULT_APPROVAL_POSITIVE_HINTS = [
+      "yes",
+      "allow once",
+      "approve",
+      "accept",
+      "continue",
+      "run",
+      "proceed",
+      "confirm",
+      "save",
+      "ok",
+      "trust",
+      "allow",
+      "always allow"
+    ];
+  }
+});
+
 // src/logging/debug-config.ts
 function normalizeCategories(categories) {
   if (!Array.isArray(categories)) return [];
@@ -15515,6 +15805,27 @@ function compileSettledPromptMatchers(spec) {
   });
   return { prompt, footers };
 }
+function extractButtonLabels(spec, text) {
+  if (!text) return [];
+  const flags = spec.buttonFlags && spec.buttonFlags.includes("m") ? spec.buttonFlags : `${spec.buttonFlags ?? ""}m`;
+  const buttonRe = compile2(spec.buttonPattern, flags);
+  const labelGroup = Number.isInteger(spec.buttonLabelGroup) && (spec.buttonLabelGroup ?? 0) > 0 ? spec.buttonLabelGroup : 1;
+  const out = [];
+  for (const line of text.split("\n")) {
+    buttonRe.lastIndex = 0;
+    const m = buttonRe.exec(line);
+    if (!m) continue;
+    const captured = m[labelGroup] ?? (labelGroup === 1 && m.length > 2 ? m[m.length - 1] : void 0);
+    if (captured && captured.trim()) out.push(captured.trim());
+  }
+  return out;
+}
+function buttonBlockApprovalCue(spec, text) {
+  const labels = extractButtonLabels(spec, text);
+  if (labels.length < 2) return false;
+  if (pickApprovalButton(labels).index < 0) return false;
+  return hasNegativeApprovalOption(labels);
+}
 function modalMatches(spec, input) {
   const text = input.screenText ?? "";
   const question = compile2(spec.questionPattern, spec.questionFlags ?? "i");
@@ -15523,6 +15834,7 @@ function modalMatches(spec, input) {
     const re = compile2(variant.regex, variant.flags ?? "i");
     if (re.test(text)) return true;
   }
+  if (buttonBlockApprovalCue(spec, text)) return true;
   return false;
 }
 function evaluateGroup(group, spec, input, compiled) {
@@ -15577,6 +15889,7 @@ var init_detect_status = __esm({
   "src/providers/sdk/v1/builders/cli/detect-status.ts"() {
     "use strict";
     init_visible_region();
+    init_approval_utils();
     DEFAULT_ORDER = ["spinner", "modal", "settled-prompt"];
   }
 });
@@ -21754,6 +22067,7 @@ init_mesh_active_work();
 init_mesh_refine_status();
 init_mesh_host_ownership();
 init_mesh_events();
+init_mesh_events_utils();
 init_mesh_delivery_policy();
 
 // src/mesh/p2p-relay-failure.ts
@@ -25673,76 +25987,8 @@ function validateReadChatResultPayload(raw, source = "read_chat") {
   return normalized;
 }
 
-// src/providers/approval-utils.ts
-var DEFAULT_APPROVAL_POSITIVE_HINTS = [
-  "yes",
-  "allow once",
-  "approve",
-  "accept",
-  "continue",
-  "run",
-  "proceed",
-  "confirm",
-  "save",
-  "ok",
-  "trust",
-  "allow",
-  "always allow"
-];
-function normalizeApprovalLabel(value) {
-  return String(value || "").toLowerCase().replace(/^[\s\[(<{]*\d+(?:\s*[.)\]}>:-]|\s)+/, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
-}
-function isNegativeApprovalLabel(value) {
-  const label = normalizeApprovalLabel(value);
-  return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label) || /\bwithout\b/.test(label) || /\bdo not\b/.test(label);
-}
-function getApprovalPositiveHints(provider) {
-  const customHints = Array.isArray(provider?.approvalPositiveHints) ? provider.approvalPositiveHints.map((hint) => normalizeApprovalLabel(String(hint || ""))).filter(Boolean) : [];
-  return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
-}
-function pickApprovalButton(buttons, provider) {
-  const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
-  if (labels.length === 0) {
-    return { index: -1, label: "" };
-  }
-  const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
-  const hints = getApprovalPositiveHints(provider);
-  for (const hint of hints) {
-    const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
-    if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
-    const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
-    if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
-    const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
-    if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
-  }
-  return { index: -1, label: "" };
-}
-function pickAutoApprovalButton(buttons) {
-  const labels = (buttons || []).map((button) => String(button || "").trim());
-  const index = labels.findIndex(Boolean);
-  return index >= 0 ? { index, label: labels[index] } : { index: -1, label: "" };
-}
-function formatAutoApprovalMessage(modalMessage, buttonLabel) {
-  const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
-  const cleanMessage = String(modalMessage || "").trim();
-  if (cleanMessage) lines.push(cleanMessage);
-  return lines.join("\n");
-}
-function looksLikeActiveApprovalPromptText(content) {
-  const text = content.trim();
-  if (!text || text.length > 2e3) return false;
-  const hasApprovalQuestion = /do you want to (?:proceed|allow|run|make this edit|create)/i.test(text) || /this command requires approval/i.test(text) || /quick safety check/i.test(text) || /is this a project you trust/i.test(text);
-  const hasNumberedChoices = /^\s*[❯›>]?\s*1[.)]\s+(?:yes|allow|proceed|run)/im.test(text) || /^\s*1[.)]\s+yes\b/im.test(text);
-  if (hasApprovalQuestion && hasNumberedChoices) return true;
-  const lastLines = text.split(/\r?\n/).slice(-12).join("\n");
-  const hasDontAskAgain = /yes.*don'?t ask again/i.test(lastLines) || /yes.*always allow/i.test(lastLines);
-  const hasNoOption = /^\s*[❯›>]?\s*\d+[.)]\s+no\b/im.test(lastLines);
-  if (hasDontAskAgain && hasNoOption) return true;
-  if (/what do you want to do\?/i.test(text) && /^\s*\d+[.)]\s+\S/m.test(text)) return true;
-  return false;
-}
-
 // src/providers/ide-provider-instance.ts
+init_approval_utils();
 init_provider_patch_state();
 init_chat_message_normalization();
 init_open_panel_support();
@@ -26826,6 +27072,7 @@ import * as fs7 from "fs";
 import * as os10 from "os";
 import * as path16 from "path";
 import { randomUUID as randomUUID11 } from "crypto";
+init_approval_utils();
 init_coordinator_registry();
 init_logger();
 
@@ -34814,6 +35061,7 @@ function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFact
 // src/providers/cli-provider-instance.ts
 init_logger();
 init_control_effects();
+init_approval_utils();
 init_provider_patch_state();
 
 // src/providers/provider-session-id.ts
@@ -35075,6 +35323,20 @@ var CliProviderInstance = class _CliProviderInstance {
    * keystroke until the modal *content* has settled.
    */
   static AUTO_APPROVE_SETTLE_MS = 600;
+  /**
+   * Busy-side hysteresis for the settle gate. A momentary `generating` flip
+   * while the SAME approval modal's button block is still on screen (its
+   * question line scrolled out of the captured frame, only the buttons + a
+   * residual `esc to interrupt` spinner remain) briefly reports
+   * status!=waiting_approval. Without hysteresis that flip wipes the settle
+   * clock, and the modal→generating→modal flap restarts the 600ms window
+   * every time so auto-approve never fires. We keep the in-progress settle
+   * gate warm across an inactive blip up to this bound; only once the modal
+   * has genuinely stayed gone this long (a real resolution → idle) is the
+   * gate cleared. Bounded so a genuinely new, later approval still re-settles
+   * from scratch rather than firing on a stale timestamp.
+   */
+  static AUTO_APPROVE_GATE_HYSTERESIS_MS = 1500;
   adapter;
   context = null;
   events = [];
@@ -35096,6 +35358,10 @@ var CliProviderInstance = class _CliProviderInstance {
   pendingAutoApprovalSignature = "";
   pendingAutoApprovalSince = 0;
   autoApproveSettleTimer = null;
+  // Wall-clock when auto-approve first observed status!=waiting_approval while
+  // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
+  // brief generating flip does not immediately wipe the settle clock.
+  autoApproveInactiveSince = 0;
   controlValues = {};
   summaryMetadata = void 0;
   appliedEffectKeys = /* @__PURE__ */ new Set();
@@ -35916,14 +36182,28 @@ var CliProviderInstance = class _CliProviderInstance {
     const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove();
     if (!autoApproveActive) {
       this.lastAutoApprovalSignature = "";
+      if (this.pendingAutoApprovalSince) {
+        if (!this.autoApproveInactiveSince) this.autoApproveInactiveSince = now;
+        const goneForMs = now - this.autoApproveInactiveSince;
+        if (goneForMs < _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS) {
+          if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+          this.autoApproveSettleTimer = setTimeout(() => {
+            this.autoApproveSettleTimer = null;
+            this.recheckAutoApproveSettled();
+          }, _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS - goneForMs + 20);
+          return autoApproveActive;
+        }
+      }
       this.pendingAutoApprovalSignature = "";
       this.pendingAutoApprovalSince = 0;
+      this.autoApproveInactiveSince = 0;
       if (this.autoApproveSettleTimer) {
         clearTimeout(this.autoApproveSettleTimer);
         this.autoApproveSettleTimer = null;
       }
       return autoApproveActive;
     }
+    this.autoApproveInactiveSince = 0;
     const modal = adapterStatus.activeModal;
     const buttons = Array.isArray(modal?.buttons) ? modal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
     if (!modal || buttons.length === 0) {
@@ -35933,18 +36213,18 @@ var CliProviderInstance = class _CliProviderInstance {
     if (buttonIndex < 0) {
       return autoApproveActive;
     }
-    const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
-    const signature = [
-      approvalEntrySeq,
+    const modalSignature = [
       typeof modal?.message === "string" ? modal.message.trim() : "",
       buttons.join("|"),
       buttonIndex
     ].join("::");
-    if (this.autoApproveBusy && signature === this.lastAutoApprovalSignature) {
+    const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
+    const busySignature = `${approvalEntrySeq}::${modalSignature}`;
+    if (this.autoApproveBusy && busySignature === this.lastAutoApprovalSignature) {
       return autoApproveActive;
     }
-    if (signature !== this.pendingAutoApprovalSignature) {
-      this.pendingAutoApprovalSignature = signature;
+    if (modalSignature !== this.pendingAutoApprovalSignature) {
+      this.pendingAutoApprovalSignature = modalSignature;
       this.pendingAutoApprovalSince = now;
     }
     const settledForMs = now - this.pendingAutoApprovalSince;
@@ -35961,9 +36241,10 @@ var CliProviderInstance = class _CliProviderInstance {
       this.autoApproveSettleTimer = null;
     }
     this.autoApproveBusy = true;
-    this.lastAutoApprovalSignature = signature;
+    this.lastAutoApprovalSignature = busySignature;
     this.pendingAutoApprovalSignature = "";
     this.pendingAutoApprovalSince = 0;
+    this.autoApproveInactiveSince = 0;
     if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
     this.autoApproveBusyTimer = setTimeout(() => {
       this.autoApproveBusy = false;
@@ -42855,7 +43136,8 @@ init_logger();
 import * as fs23 from "fs";
 import * as path35 from "path";
 import * as os26 from "os";
-var LOG_DIR2 = process.platform === "win32" ? path35.join(process.env.LOCALAPPDATA || process.env.APPDATA || path35.join(os26.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path35.join(os26.homedir(), "Library", "Logs", "adhdev") : path35.join(os26.homedir(), ".local", "share", "adhdev", "logs");
+var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path35.join(os26.homedir(), ".adhdev");
+var LOG_DIR2 = path35.join(ADHDEV_HOME2, "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
@@ -43315,7 +43597,7 @@ function runGit2(repoRoot, args) {
     return "";
   }
 }
-function readRecord6(repoRoot) {
+function readRecord5(repoRoot) {
   const path42 = resolve19(repoRoot, PREVIEW_DEPLOY_RECORD);
   if (!existsSync36(path42)) return null;
   try {
@@ -43355,7 +43637,7 @@ function readCurrentMainCommit(repoRoot) {
 }
 function buildPreviewFreshness(repoRoot) {
   const current = readCurrentMainCommit(repoRoot);
-  const record = readRecord6(repoRoot);
+  const record = readRecord5(repoRoot);
   const lastPreviewCommit = normalizeCommit(record?.lastPreviewCommit);
   const targets = readTargetFreshness(record, current.currentMainCommit);
   let status = "unknown";
@@ -43710,13 +43992,14 @@ async function waitForPidExit(pid, timeoutMs) {
     }
   }
 }
-function stopSessionHostProcesses(appName) {
+async function stopSessionHostProcesses(appName) {
   const pidFile = path36.join(os27.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  let killedPid = null;
   try {
     if (fs25.existsSync(pidFile)) {
       const pid = Number.parseInt(fs25.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
-        killPid(pid);
+        if (killPid(pid)) killedPid = pid;
       }
     }
   } catch {
@@ -43726,6 +44009,15 @@ function stopSessionHostProcesses(appName) {
     } catch {
     }
   }
+  if (killedPid !== null) {
+    await waitForPidExit(killedPid, 15e3);
+  }
+}
+function isRetriableInstallLockError(error) {
+  const code = error?.code;
+  if (code === "EBUSY" || code === "EPERM") return true;
+  const text = `${error?.message || ""} ${error?.stderr || ""}`;
+  return /\bEBUSY\b|\bEPERM\b|resource busy or locked/i.test(text);
 }
 function removeDaemonPidFile() {
   const pidFile = path36.join(os27.homedir(), ".adhdev", "daemon.pid");
@@ -43805,22 +44097,37 @@ async function runDaemonUpgradeHelper(payload) {
     appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
     await waitForPidExit(payload.parentPid, 15e3);
   }
-  stopSessionHostProcesses(sessionHostAppName);
+  await stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync5(
-    installCommand.command,
-    installCommand.args,
-    {
-      encoding: "utf8",
-      stdio: "pipe",
-      maxBuffer: 20 * 1024 * 1024,
-      env: buildInstallEnvWithNodeOnPath(),
-      ...installCommand.execOptions
+  const maxInstallAttempts = process.platform === "win32" ? 3 : 1;
+  let installOutput = "";
+  for (let attempt = 1; attempt <= maxInstallAttempts; attempt++) {
+    try {
+      installOutput = String(execFileSync5(
+        installCommand.command,
+        installCommand.args,
+        {
+          encoding: "utf8",
+          stdio: "pipe",
+          maxBuffer: 20 * 1024 * 1024,
+          env: buildInstallEnvWithNodeOnPath(),
+          ...installCommand.execOptions
+        }
+      ));
+      break;
+    } catch (error) {
+      if (attempt < maxInstallAttempts && isRetriableInstallLockError(error)) {
+        appendUpgradeLog(`Install attempt ${attempt} hit a file lock (${error?.code || "lock"}); cleaning staging and retrying after backoff`);
+        cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
+        await new Promise((resolve24) => setTimeout(resolve24, attempt * 1500));
+        continue;
+      }
+      throw error;
     }
-  );
+  }
   if (installOutput.trim()) {
     appendUpgradeLog(installOutput.trim());
   }
@@ -52582,6 +52889,7 @@ var DaemonAgentStreamManager = class {
 
 // src/agent-stream/poller.ts
 init_logger();
+init_approval_utils();
 init_chat_message_normalization();
 var AgentStreamPoller = class {
   deps;
@@ -60283,6 +60591,7 @@ export {
   readLedgerEntries,
   readLedgerSlice,
   readLedgerSliceFromStore,
+  readMeshCompletionSummary,
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
@@ -60308,6 +60617,7 @@ export {
   resolveMeshHostStatus,
   resolveMeshNodeAttribution,
   resolveMeshRefineValidationPlan,
+  resolveMeshSurfacedSessionPreview,
   resolveNodeSchedulingPriority,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,