@adhdev/daemon-core 0.9.82-rc.353 → 0.9.82-rc.355

package/dist/index.mjs

@@ -311,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "a680b74d9b940b82f691ebb85a725a1a72445bfc" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "a680b74d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.353" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-22T09:11:13.499Z" : void 0);
+  const commit = readInjected(true ? "a45106605e2ae1c10c0bc6cbe48c2cac4e862ded" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a4510660" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.355" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-22T15:21:19.981Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -1067,6 +1067,9 @@ __export(git_diff_exports, {
 });
 import { readFile, realpath as realpath2 } from "fs/promises";
 import * as path2 from "path";
+function withCollectionTimeout(options) {
+  return options.timeoutMs === void 0 ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
+}
 function validateBaseRef(ref) {
   const trimmed = ref.trim();
   if (!trimmed || trimmed.startsWith("-") || trimmed.includes("..") || !/^[A-Za-z0-9][A-Za-z0-9._/@-]*$/.test(trimmed)) {
@@ -1076,14 +1079,15 @@ function validateBaseRef(ref) {
 }
 async function getGitDiffSummary(workspace, options = {}) {
   const lastCheckedAt = Date.now();
+  const effectiveOptions = withCollectionTimeout(options);
   try {
-    const repo = await resolveGitRepository(workspace, options);
+    const repo = await resolveGitRepository(workspace, effectiveOptions);
     const repoRoot = repo.repoRoot;
     if (options.baseRef) {
       const range = `${validateBaseRef(options.baseRef)}...HEAD`;
       const [nameStatus, numstat] = await Promise.all([
-        runGit(repo, ["diff", "--no-ext-diff", "--name-status", range, "--"], { ...options, cwd: repoRoot }),
-        runGit(repo, ["diff", "--no-ext-diff", "--numstat", range, "--"], { ...options, cwd: repoRoot })
+        runGit(repo, ["diff", "--no-ext-diff", "--name-status", range, "--"], { ...effectiveOptions, cwd: repoRoot }),
+        runGit(repo, ["diff", "--no-ext-diff", "--numstat", range, "--"], { ...effectiveOptions, cwd: repoRoot })
       ]);
       const outputBytes2 = byteLength(nameStatus.stdout + numstat.stdout);
       const changes2 = combineDiffEntries(nameStatus.stdout, numstat.stdout, false);
@@ -1102,11 +1106,11 @@ async function getGitDiffSummary(workspace, options = {}) {
       };
     }
     const [unstagedNameStatus, unstagedNumstat, stagedNameStatus, stagedNumstat, untracked] = await Promise.all([
-      runGit(repo, ["diff", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["ls-files", "--others", "--exclude-standard"], { ...options, cwd: repoRoot })
+      runGit(repo, ["diff", "--no-ext-diff", "--name-status"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--no-ext-diff", "--numstat"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--name-status"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--numstat"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["ls-files", "--others", "--exclude-standard"], { ...effectiveOptions, cwd: repoRoot })
     ]);
     const outputBytes = byteLength(
       unstagedNameStatus.stdout + unstagedNumstat.stdout + stagedNameStatus.stdout + stagedNumstat.stdout + untracked.stdout
@@ -1148,13 +1152,14 @@ async function getGitDiffSummary(workspace, options = {}) {
 }
 async function getGitFileDiff(workspace, filePath, options = {}) {
   const lastCheckedAt = Date.now();
-  const repo = await resolveGitRepository(workspace, options);
+  const effectiveOptions = withCollectionTimeout(options);
+  const repo = await resolveGitRepository(workspace, effectiveOptions);
   const repoRoot = repo.repoRoot;
   const selected = await resolveRepoFilePath(repoRoot, filePath);
   const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
   if (options.baseRef) {
     const range = `${validateBaseRef(options.baseRef)}...HEAD`;
-    const result = await runGit(repo, ["diff", "--no-ext-diff", range, "--", selected.relativePath], { ...options, cwd: repoRoot });
+    const result = await runGit(repo, ["diff", "--no-ext-diff", range, "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot });
     const bounded2 = truncateText(result.stdout, maxBytes);
     return {
       workspace: repo.workspace,
@@ -1167,13 +1172,13 @@ async function getGitFileDiff(workspace, filePath, options = {}) {
     };
   }
   const [unstaged, staged] = await Promise.all([
-    runGit(repo, ["diff", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot }),
-    runGit(repo, ["diff", "--cached", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot })
+    runGit(repo, ["diff", "--no-ext-diff", "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
+    runGit(repo, ["diff", "--cached", "--no-ext-diff", "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot })
   ]);
   let diff = [unstaged.stdout, staged.stdout].filter((part) => part.length > 0).join("\n");
   if (!diff) {
     const untracked = await runGit(repo, ["ls-files", "--others", "--exclude-standard", "--", selected.relativePath], {
-      ...options,
+      ...effectiveOptions,
       cwd: repoRoot
     });
     const untrackedFiles = untracked.stdout.split("\n").filter(Boolean);
@@ -4817,9 +4822,12 @@ function getActiveDirectDispatches(meshId) {
     return [];
   }
 }
-function updateDirectDispatchStatus(meshId, sessionId, status) {
+function updateDirectDispatchStatus(meshId, sessionId, status, taskId) {
   try {
-    MeshRuntimeStore.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
+    if (!taskId) {
+      LOG.warn("MeshQueue", `updateDirectDispatchStatus(${status}) for mesh ${meshId} session ${sessionId} has no taskId \u2014 falling back to session_id match (may flip a sibling dispatch row)`);
+    }
+    MeshRuntimeStore.getInstance().updateDirectDispatchStatus(meshId, sessionId, status, taskId);
   } catch {
   }
 }
@@ -5651,9 +5659,25 @@ var init_mesh_runtime_store = __esm({
           updatedAt: r.updated_at
         }));
       }
-      updateDirectDispatchStatus(meshId, sessionId, status) {
-        if (!sessionId) return;
+      // CANON-B (dispatch identity): mesh_direct_dispatches is keyed by task_id (PK), but a
+      // single session can host several sequential direct dispatches (re-dispatch / nudge), so
+      // matching a status flip by session_id alone hits EVERY non-terminal row for that session
+      // — flipping a sibling task's row and stranding the one whose event actually fired (the
+      // assigned-stranded watchdog then requeues a task that is really still generating). When
+      // the firing event carries a taskId, target the single PK row; the session_id match is the
+      // legacy fallback only for events that arrive without a taskId.
+      updateDirectDispatchStatus(meshId, sessionId, status, taskId) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
+        if (taskId) {
+          this.db.prepare(`
+                UPDATE mesh_direct_dispatches
+                SET status = @status, updated_at = @updatedAt
+                WHERE mesh_id = @meshId AND task_id = @taskId
+                  AND status NOT IN ('completed', 'failed')
+            `).run({ status, meshId, taskId, updatedAt: now });
+          return;
+        }
+        if (!sessionId) return;
         this.db.prepare(`
             UPDATE mesh_direct_dispatches
             SET status = @status, updated_at = @updatedAt
@@ -7382,7 +7406,7 @@ function resolveWin32Executable(command) {
       windowsHide: true
     }).trim();
     if (out) {
-      const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+      const matches = out.split(/\r?\n/).map((s2) => s2.trim()).filter(Boolean);
       const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path10.extname(m).toLowerCase()));
       return direct || matches[0] || command;
     }
@@ -8734,11 +8758,29 @@ function hasPendingRefineTerminalEventDuplicate(event) {
     (pending) => pending.event === event.event && readRefineJobId2(pending) === jobId
   );
 }
+function isWeakCompletionMetadata(metadata) {
+  const evidenceLevel = readNonEmptyString2(metadata.evidenceLevel);
+  if (evidenceLevel === "insufficient" || evidenceLevel === "weak") return true;
+  if (metadata.reviewRecommended === true) return true;
+  const diag = readRecord4(metadata.completionDiagnostic);
+  return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
+}
 function buildPendingEventFingerprint(event) {
   const metadata = readRecord4(event.metadataEvent) || {};
   if (event.event === "worktree_bootstrap_complete" || event.event === "worktree_bootstrap_failed") {
     return [event.meshId, event.event, event.nodeId || ""].join("::");
   }
+  if (TERMINAL_COMPLETION_EVENTS.has(event.event)) {
+    const terminalTaskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord4(metadata.payload)?.taskId);
+    if (terminalTaskId) {
+      return [
+        event.meshId,
+        event.event,
+        terminalTaskId,
+        isWeakCompletionMetadata(metadata) ? "weak" : "genuine"
+      ].join("::");
+    }
+  }
   const sessionId = resolveEventSessionId(metadata);
   const providerSessionId = readNonEmptyString2(metadata.providerSessionId);
   const taskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord4(metadata.payload)?.taskId);
@@ -9097,7 +9139,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
@@ -9107,6 +9149,7 @@ var init_mesh_events_pending = __esm({
     init_mesh_events_utils();
     init_dist();
     REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
+    TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
   }
@@ -9436,7 +9479,7 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
       evidence
     }
   });
-  updateDirectDispatchStatus(args.meshId, args.sessionId, kind === "task_completed" ? "completed" : "failed");
+  updateDirectDispatchStatus(args.meshId, args.sessionId, kind === "task_completed" ? "completed" : "failed", args.taskId);
   markSessionDeliveriesTerminal(args.meshId, args.sessionId, kind === "task_completed" ? "completed" : "failed");
   setImmediate(() => cleanupTerminalDirectDispatches());
   queuePendingMeshCoordinatorEvent({
@@ -9731,8 +9774,8 @@ function parsePatternEntry(x) {
   if (x instanceof RegExp) return x;
   if (x && typeof x === "object" && typeof x.source === "string") {
     try {
-      const s = x;
-      return new RegExp(s.source, s.flags || "");
+      const s2 = x;
+      return new RegExp(s2.source, s2.flags || "");
     } catch {
       return null;
     }
@@ -10300,6 +10343,38 @@ var init_mesh_unresolved_forward_outbox = __esm({
   }
 });
 
+// src/mesh/mesh-event-trace.ts
+function s(v) {
+  return typeof v === "string" && v.trim() ? v.trim() : "";
+}
+function meshEventTraceKey(ctx) {
+  const segs = [`task=${s(ctx.taskId) || "-"}`];
+  const eventId = s(ctx.eventId);
+  if (eventId) segs.push(`evt=${eventId}`);
+  segs.push(`sess=${s(ctx.sessionId) || "-"}`);
+  const nodeId = s(ctx.nodeId);
+  if (nodeId) segs.push(`node=${nodeId}`);
+  const meshId = s(ctx.meshId);
+  if (meshId) segs.push(`mesh=${meshId}`);
+  const event = s(ctx.event);
+  if (event) segs.push(`event=${event}`);
+  return segs.join(" ");
+}
+function traceMeshEventStage(stage, ctx, detail) {
+  LOG.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+}
+function traceMeshEventDrop(reason, ctx, detail) {
+  LOG.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+}
+var CAT;
+var init_mesh_event_trace = __esm({
+  "src/mesh/mesh-event-trace.ts"() {
+    "use strict";
+    init_logger();
+    CAT = "EvtTrace";
+  }
+});
+
 // src/config/state-store.ts
 import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
 import { join as join18 } from "path";
@@ -12085,9 +12160,9 @@ function buildAcpSession(state, options) {
 }
 function buildSessionEntries(allStates, cdpManagers, options = {}) {
   const sessions = [];
-  const ideStates = allStates.filter((s) => s.category === "ide");
-  const cliStates = allStates.filter((s) => s.category === "cli");
-  const acpStates = allStates.filter((s) => s.category === "acp");
+  const ideStates = allStates.filter((s2) => s2.category === "ide");
+  const cliStates = allStates.filter((s2) => s2.category === "cli");
+  const acpStates = allStates.filter((s2) => s2.category === "acp");
   for (const state of ideStates) {
     sessions.push(buildWorkspaceSession(state, cdpManagers, options));
     for (const ext of state.extensions) {
@@ -12572,6 +12647,15 @@ function getCachedMeshByWorkspace(workspace) {
   meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
   return mesh;
 }
+function recoverMeshIdByNodeId(nodeId) {
+  if (!nodeId) return "";
+  for (const mesh of listMeshes()) {
+    if (Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId))) {
+      return readNonEmptyString2(mesh.id);
+    }
+  }
+  return "";
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
@@ -13474,6 +13558,13 @@ function shouldForceInjectMeshEvent(eventName) {
 function injectMeshSystemMessage(components, args) {
   const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
+  const traceCtx = {
+    taskId: args.metadataEvent.taskId,
+    sessionId: eventSessionId,
+    nodeId: eventNodeId,
+    meshId: args.meshId,
+    event: args.event
+  };
   const sourceSession = args.sourceInstanceId ? components.instanceManager.getInstance(args.sourceInstanceId) : void 0;
   const workerCoordinatorDaemonId = readNonEmptyString2(
     sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
@@ -13527,6 +13618,7 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     LOG.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
+    traceMeshEventDrop("intentional_cleanup_stop", traceCtx);
     return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
   }
   if (args.event === "monitor:no_progress") {
@@ -13547,6 +13639,7 @@ function injectMeshSystemMessage(components, args) {
     }
     if (reconciledCompletion?.source === "no_progress_terminal_ledger_suppression") {
       LOG.info("MeshEvents", `Suppressed no-progress monitor because terminal ledger evidence already exists for session ${eventSessionId || "(unknown session)"}`);
+      traceMeshEventDrop("no_progress_terminal_ledger_suppression", traceCtx, `terminalKind=${reconciledCompletion.terminalLedgerKind}`);
       return {
         success: true,
         forwarded: 0,
@@ -13558,6 +13651,7 @@ function injectMeshSystemMessage(components, args) {
   }
   if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
     LOG.info("MeshEvents", `Suppressed duplicate ${args.event} for refine job ${readRefineJobId({ metadataEvent: args.metadataEvent })}`);
+    traceMeshEventDrop("duplicate_refine_terminal", traceCtx);
     return { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true };
   }
   const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
@@ -13572,6 +13666,7 @@ function injectMeshSystemMessage(components, args) {
     });
     if (duplicateApproval) {
       LOG.info("MeshEvents", `Suppressed duplicate approval event for mesh ${args.meshId} session ${eventSessionId}`);
+      traceMeshEventDrop("duplicate_approval", traceCtx);
       return { success: true, forwarded: 0, suppressed: true, duplicateApproval: true };
     }
   }
@@ -13591,6 +13686,7 @@ function injectMeshSystemMessage(components, args) {
         const eventFinalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
         if (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId || terminalFinalSummary && terminalFinalSummary === eventFinalSummary || args.metadataEvent.source === "no_progress_reconciliation") {
           LOG.info("MeshEvents", `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
+          traceMeshEventDrop("duplicate_completion_terminal_ledger", traceCtx);
           return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
         }
       }
@@ -13609,6 +13705,7 @@ function injectMeshSystemMessage(components, args) {
     });
     if (duplicateCompletion) {
       LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+      traceMeshEventDrop("duplicate_completion", traceCtx);
       return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
     }
   }
@@ -13627,6 +13724,7 @@ function injectMeshSystemMessage(components, args) {
     });
     if (duplicateStopped) {
       LOG.info("MeshEvents", `Suppressed duplicate stopped event for mesh ${args.meshId} session ${eventSessionId}`);
+      traceMeshEventDrop("duplicate_stopped", traceCtx);
       return { success: true, forwarded: 0, suppressed: true, duplicateStopped: true };
     }
   }
@@ -13638,7 +13736,7 @@ function injectMeshSystemMessage(components, args) {
     });
     const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true;
     if (!leaveDirectDispatchActive) {
-      updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+      updateDirectDispatchStatus(args.meshId, sessionId, outcome, eventTaskId);
     }
     markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
     setImmediate(() => cleanupTerminalDirectDispatches());
@@ -13651,7 +13749,7 @@ function injectMeshSystemMessage(components, args) {
     const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString2(args.metadataEvent.providerType);
     if (sessionId) {
-      directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
+      directDispatchTaskIdForLedger = readNonEmptyString2(args.metadataEvent.taskId) || resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
       const isFalseIdle = isFalseIdleCompletion(args.metadataEvent);
       completedTaskForLedger = markSessionTerminal(sessionId, "completed", eventTimestamp, { tentativeIfDirect: isFalseIdle });
       if (nodeId && providerType) {
@@ -13734,7 +13832,8 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId) {
-      updateDirectDispatchStatus(args.meshId, sessionId, "acked");
+      const startedTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
+      updateDirectDispatchStatus(args.meshId, sessionId, "acked", startedTaskId);
       const activeDeliveries = (() => {
         try {
           return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(args.meshId, sessionId);
@@ -13742,7 +13841,8 @@ function injectMeshSystemMessage(components, args) {
           return [];
         }
       })();
-      for (const d of activeDeliveries) {
+      const deliveriesToAck = startedTaskId ? activeDeliveries.filter((d) => d.taskId === startedTaskId) : activeDeliveries;
+      for (const d of deliveriesToAck) {
         updateSessionDeliveryStatus(d.id, "acked");
       }
     }
@@ -13756,7 +13856,7 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId) {
-      directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
+      directDispatchTaskIdForLedger = readNonEmptyString2(args.metadataEvent.taskId) || resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
       completedTaskForLedger = markSessionTerminal(sessionId, "failed");
     }
   }
@@ -13902,6 +14002,9 @@ function injectMeshSystemMessage(components, args) {
   };
   if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
     LOG.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""}${workerCoordinatorSessionId ? `, coordinator session ${workerCoordinatorSessionId}` : ""})`);
+    traceMeshEventStage("queued", traceCtx, workerCoordinatorDaemonId ? `coordinatorDaemon=${workerCoordinatorDaemonId}` : "broadcast");
+  } else {
+    traceMeshEventDrop("queue_dedup", traceCtx);
   }
   return { success: true, forwarded: 0 };
 }
@@ -13912,8 +14015,23 @@ function handleMeshForwardEvent(components, payload) {
   }
   const nodeId = readNonEmptyString2(payload.nodeId);
   const workspace = readNonEmptyString2(payload.workspace);
-  const meshId = readNonEmptyString2(payload.meshId) || (workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "");
-  if (!meshId) return { success: false, error: "meshId required" };
+  const meshId = readNonEmptyString2(payload.meshId) || (workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "") || recoverMeshIdByNodeId(nodeId);
+  if (!meshId) {
+    traceMeshEventDrop("meshId_required", {
+      taskId: payload.taskId,
+      sessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId),
+      nodeId,
+      event: eventName
+    }, workspace ? `workspace=${workspace} unresolved` : "no workspace/nodeId");
+    return { success: false, error: "meshId required" };
+  }
+  traceMeshEventStage("received", {
+    taskId: payload.taskId,
+    sessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId),
+    nodeId,
+    meshId,
+    event: eventName
+  });
   const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
   const relayModalMessage = readNonEmptyString2(payload.modalMessage);
   const relayModalButtons = Array.isArray(payload.modalButtons) ? payload.modalButtons.filter((b) => typeof b === "string" && b.trim().length > 0) : null;
@@ -13994,9 +14112,18 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
   };
   const persisted = enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, payload);
+  const fwdTraceCtx = {
+    taskId: payload.taskId,
+    sessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId),
+    nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId),
+    event: eventName
+  };
+  traceMeshEventStage("outbox_enqueue", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId} meshId=absent`);
+  traceMeshEventStage("forward_send", fwdTraceCtx, "immediate push");
   Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
     if (result && result.success === false) {
       LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued for retry`);
+      traceMeshEventDrop("immediate_forward_rejected", fwdTraceCtx, readNonEmptyString2(result.error) || "no reason");
       return;
     }
     if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
@@ -14064,6 +14191,14 @@ function setupMeshEventForwarding(components) {
       if (isUnroutableDelegateRejection(routing) && forwardUnresolvedDelegateEvent(components, routing, event)) {
         return;
       }
+      if (isUnroutableDelegateRejection(routing)) {
+        traceMeshEventDrop("unroutable", {
+          taskId: event.meshActiveTaskId ?? event.taskId,
+          sessionId: routing.sessionId,
+          nodeId: routing.nodeId,
+          event: event.event
+        }, "no coordinator anchor / mesh_unresolved");
+      }
       recordUnroutableDelegateEvent(routing, event.event);
       return;
     }
@@ -14093,6 +14228,7 @@ var init_mesh_events_coordinator = __esm({
     init_mesh_events_pending();
     init_mesh_routing();
     init_mesh_unresolved_forward_outbox();
+    init_mesh_event_trace();
     init_snapshot();
     init_repo_mesh_types();
     init_dist();
@@ -14204,6 +14340,13 @@ function findLiveCoordinators(components) {
 function injectPendingIntoCoordinator(coordinator, pending) {
   if (!coordinator || !pending.coordinatorMessage) return;
   const force = shouldForceInjectMeshEvent(pending.event);
+  traceMeshEventStage("surfaced", {
+    taskId: pending.metadataEvent?.taskId,
+    sessionId: pending.metadataEvent?.targetSessionId ?? pending.targetCoordinatorSessionId,
+    nodeId: pending.nodeId,
+    meshId: pending.meshId,
+    event: pending.event
+  }, force ? "force-inject" : "inject");
   coordinator.onEvent("send_message", {
     input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
     ...force ? { force: true } : {}
@@ -14262,6 +14405,13 @@ function recoverStrandedAssignedDispatches(meshId, store) {
     });
     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})`);
+      traceMeshEventDrop("assigned_stranded_reclaim", {
+        taskId: row.id,
+        sessionId: row.assignedSessionId,
+        nodeId: row.assignedNodeId,
+        meshId,
+        event: "agent:generating_completed"
+      }, `unconfirmed ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s \u2192 ${reclaimed.status}`);
     }
   }
 }
@@ -14421,6 +14571,13 @@ function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
     try {
       queuePendingMeshCoordinatorEvent(pending);
       LOG.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})`);
+      traceMeshEventDrop("strict_route_hold", {
+        taskId: pending.metadataEvent?.taskId,
+        sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
+        nodeId: pending.nodeId,
+        meshId,
+        event: pending.event
+      }, `coordinatorSession=${wantSession} not live`);
     } catch (e) {
       LOG.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
     }
@@ -14444,6 +14601,13 @@ function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
       }
     });
     LOG.warn("MeshReconcile", `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} \u2014 recorded to ledger (recoverable), dropped (${pending.event})`);
+    traceMeshEventDrop("strict_route_expired", {
+      taskId: pending.metadataEvent?.taskId,
+      sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
+      nodeId: pending.nodeId,
+      meshId,
+      event: pending.event
+    }, `coordinatorSession=${wantSession} never returned`);
   } catch (e) {
     LOG.warn("MeshReconcile", `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
   }
@@ -14455,15 +14619,24 @@ async function retryUnresolvedDelegateForwards(components) {
   const entries = peekUnresolvedDelegateForwards();
   if (entries.length === 0) return;
   for (const entry of entries) {
+    const entryTraceCtx = {
+      taskId: entry.payload.taskId,
+      sessionId: readNonEmptyString2(entry.payload.targetSessionId) || readNonEmptyString2(entry.payload.sessionId),
+      nodeId: readNonEmptyString2(entry.payload.nodeId),
+      event: readNonEmptyString2(entry.payload.event)
+    };
     let result;
     try {
+      traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
       result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", entry.payload);
     } catch (e) {
       LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+      traceMeshEventDrop("retry_forward_failed", entryTraceCtx, e?.message || String(e));
       continue;
     }
     if (result && result.success === false) {
       LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
+      traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, readNonEmptyString2(result.error) || "no reason");
       continue;
     }
     ackUnresolvedDelegateForward(entry.id);
@@ -14705,6 +14878,7 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_events_coordinator();
     init_mesh_unresolved_forward_outbox();
     init_mesh_events_utils();
+    init_mesh_event_trace();
     init_dist();
     init_mesh_work_queue();
     init_mesh_ledger();
@@ -15543,8 +15717,8 @@ function saveProvidersActive(file) {
 }
 function isValidSource(x) {
   if (!x || typeof x !== "object") return false;
-  const s = x;
-  return typeof s.name === "string" && s.name.length > 0 && typeof s.url === "string" && s.url.length > 0 && typeof s.ref === "string" && s.ref.length > 0 && typeof s.addedAt === "string";
+  const s2 = x;
+  return typeof s2.name === "string" && s2.name.length > 0 && typeof s2.url === "string" && s2.url.length > 0 && typeof s2.ref === "string" && s2.ref.length > 0 && typeof s2.addedAt === "string";
 }
 function deriveSourceName(url) {
   const m = url.match(/[/:]([^/:]+)\/([^/]+?)(?:\.git)?$/);
@@ -15600,7 +15774,7 @@ function inventoryExternalSources() {
 }
 function sourcesProviding(category, type) {
   const inventory = inventoryExternalSources();
-  return inventory.filter((s) => (s.providers[category] || []).includes(type)).map((s) => s.sourceName);
+  return inventory.filter((s2) => (s2.providers[category] || []).includes(type)).map((s2) => s2.sourceName);
 }
 function resolveActiveSource(category, type, activeFile) {
   const candidates = sourcesProviding(category, type);
@@ -15804,10 +15978,10 @@ function compileSettledPromptMatchers(spec) {
   const footers = (spec.withFooter ?? []).map((f) => {
     if (f.kind === "regex") {
       const re = compile2(f.pattern, f.flags ?? "i");
-      return { test: (s) => re.test(s) };
+      return { test: (s2) => re.test(s2) };
     }
     const needle = f.pattern.toLowerCase();
-    return { test: (s) => s.toLowerCase().includes(needle) };
+    return { test: (s2) => s2.toLowerCase().includes(needle) };
   });
   return { prompt, footers };
 }
@@ -16681,7 +16855,7 @@ var init_cli_state_engine = __esm({
       }
       resolveModal(buttonIndex) {
         const snap = this.transport.getSnapshot();
-        const parseApproval = typeof this.transport.runParseApproval === "function" ? (s) => this.transport.runParseApproval(s.recentOutputBuffer.slice(-500)) : (s) => this.runParseApproval(s);
+        const parseApproval = typeof this.transport.runParseApproval === "function" ? (s2) => this.transport.runParseApproval(s2.recentOutputBuffer.slice(-500)) : (s2) => this.runParseApproval(s2);
         let modal = this.activeModal ?? parseApproval(snap);
         if (!modal && this.runner.hasParseSession()) {
           try {
@@ -19369,22 +19543,23 @@ function resolveSections(sectionsObj, lines) {
         const matchesCandidate = (c, i) => c.re.test(lines[i]) && (c.prevRe === null || i > 0 && c.prevRe.test(lines[i - 1])) && (c.nextRe === null || i < total - 1 && c.nextRe.test(lines[i + 1]));
         let idx = -1;
         for (const c of candidates) {
+          let candIdx = -1;
           if (sec.anchor_last) {
             for (let i = total - 1; i >= 0; i--) {
               if (matchesCandidate(c, i)) {
-                idx = i;
+                candIdx = i;
                 break;
               }
             }
           } else {
             for (let i = 0; i < total; i++) {
               if (matchesCandidate(c, i)) {
-                idx = i;
+                candIdx = i;
                 break;
               }
             }
           }
-          if (idx !== -1) break;
+          if (candIdx !== -1 && (idx === -1 || candIdx < idx)) idx = candIdx;
         }
         if (idx !== -1) {
           from = idx;
@@ -19436,7 +19611,7 @@ function resolveSections(sectionsObj, lines) {
 }
 function sectionText(sections, sectionId, fullScreen) {
   if (!sectionId) return fullScreen;
-  const found = sections.find((s) => s.id === sectionId);
+  const found = sections.find((s2) => s2.id === sectionId);
   return found ? found.text : "";
 }
 function isRegexCondition(c) {
@@ -19604,10 +19779,10 @@ function isV4Spec(raw) {
   return !!raw && typeof raw === "object" && raw.$schema === "adhdev:cli/spec@4";
 }
 function initialState(spec) {
-  return spec.states.find((s) => s.initial) ?? spec.states[0];
+  return spec.states.find((s2) => s2.initial) ?? spec.states[0];
 }
 function stateById(spec, id) {
-  return spec.states.find((s) => s.id === id);
+  return spec.states.find((s2) => s2.id === id);
 }
 function outgoingTransitions(spec, stateId) {
   const matches = spec.transitions.filter((t) => {
@@ -19696,7 +19871,17 @@ function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTr
     const result = evaluateCondition(cond, sections, fullScreen, cursor, prevLines, legacyTrace, stateId);
     const kind = isRegex(cond) ? "regex" : "changed";
     const detail = isRegex(cond) ? `${cond.section ?? "*"}~/${cond.matches}/` : `cursor_above=${cond.cursor_above} changed=${cond.changed}`;
-    return { kind, result, detail };
+    let matchedText;
+    if (result && isRegex(cond)) {
+      try {
+        const hay = sectionText(sections, cond.section, fullScreen);
+        const re = new RegExp(cond.matches, cond.flags ?? "i");
+        const m = re.exec(hay);
+        if (m && m[0]) matchedText = m[0].replace(/\s+/g, " ").trim().slice(0, 160);
+      } catch {
+      }
+    }
+    return matchedText ? { kind, result, detail, matchedText } : { kind, result, detail };
   }
   return { kind: "all", result: false, detail: "unknown condition" };
 }
@@ -19812,17 +19997,17 @@ function validateFsmSpec(raw) {
   }
   const ids = /* @__PURE__ */ new Set();
   let initialCount = 0;
-  for (const [i, s] of spec.states.entries()) {
-    if (!s.id) {
+  for (const [i, s2] of spec.states.entries()) {
+    if (!s2.id) {
       errs.push(`states[${i}].id is required`);
       continue;
     }
-    if (ids.has(s.id)) errs.push(`states[${i}].id "${s.id}" is duplicated`);
-    ids.add(s.id);
-    if (!s.label) errs.push(`states[${i}].label is required`);
-    if (s.initial) initialCount += 1;
-    if (s.status && !["idle", "generating", "approval"].includes(s.status)) {
-      errs.push(`states[${i}].status "${s.status}" must be idle|generating|approval`);
+    if (ids.has(s2.id)) errs.push(`states[${i}].id "${s2.id}" is duplicated`);
+    ids.add(s2.id);
+    if (!s2.label) errs.push(`states[${i}].label is required`);
+    if (s2.initial) initialCount += 1;
+    if (s2.status && !["idle", "generating", "approval"].includes(s2.status)) {
+      errs.push(`states[${i}].status "${s2.status}" must be idle|generating|approval`);
     }
   }
   if (initialCount === 0) errs.push("exactly one state must have initial:true (none found)");
@@ -19838,10 +20023,10 @@ function validateFsmSpec(raw) {
     else if (!ids.has(t.to)) errs.push(`transitions[${i}].to references unknown state "${t.to}"`);
     if (t.when) errs.push(...validateCondition(t.when, sectionIds, `transitions[${i}].when`));
   }
-  for (const [i, s] of spec.states.entries()) {
-    const sec = s.extract?.title?.section;
+  for (const [i, s2] of spec.states.entries()) {
+    const sec = s2.extract?.title?.section;
     if (sec && !sectionIds.has(sec)) errs.push(`states[${i}].extract.title.section "${sec}" unknown`);
-    const bsec = s.extract?.buttons?.section;
+    const bsec = s2.extract?.buttons?.section;
     if (bsec && !sectionIds.has(bsec)) errs.push(`states[${i}].extract.buttons.section "${bsec}" unknown`);
   }
   return errs;
@@ -27072,6 +27257,42 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
   return fn() || null;
 }
 
+// src/providers/manual-attendance.ts
+var AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 6e4;
+var ManualAttendanceTracker = class {
+  constructor(suppressMs = AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS) {
+    this.suppressMs = suppressMs;
+  }
+  lastInteractionAt = 0;
+  /** Record that a human just drove this session by hand. */
+  note(now = Date.now()) {
+    this.lastInteractionAt = now;
+  }
+  /** True while a manual interaction is recent enough to suppress auto-approve. */
+  isAttended(now = Date.now()) {
+    return this.lastInteractionAt > 0 && now - this.lastInteractionAt < this.suppressMs;
+  }
+  /**
+   * Milliseconds remaining in the current suppression window, or 0 when not
+   * attended. Used to re-arm a re-check timer so auto-approve fires the moment
+   * the window lapses even if the PTY/agent has since gone silent.
+   */
+  remainingMs(now = Date.now()) {
+    if (this.lastInteractionAt <= 0) return 0;
+    return Math.max(0, this.suppressMs - (now - this.lastInteractionAt));
+  }
+};
+var MANUAL_ATTENDANCE_COMMANDS = /* @__PURE__ */ new Set([
+  "select_session",
+  "open_panel",
+  "invoke_provider_script",
+  "set_mode",
+  "change_model",
+  "set_thought_level",
+  "resolve_action",
+  "pty_input"
+]);
+
 // src/commands/chat-commands.ts
 init_contracts();
 init_provider_input_support();
@@ -31411,11 +31632,38 @@ var DaemonCommandHandler = class {
   setAgentStreamManager(manager) {
     this._agentStream = manager;
   }
+  /**
+   * When a command in the manual-attendance set arrives for a session this
+   * daemon hosts, stamp the live instance so auto-approve holds while the user
+   * drives the session by hand. Provider-common: the signal is the command
+   * (foreground select_session / open_panel, controlbar invoke_provider_script
+   * / set_mode / change_model / set_thought_level, manual resolve_action,
+   * pty_input), never any CLI-specific modal text — so it works identically for
+   * every CLI/ACP provider. send_chat is deliberately excluded because a
+   * coordinator delegating a task to a worker also uses send_chat; counting it
+   * would wrongly suppress the worker's delegated auto-approve. For a remote
+   * mesh worker session the controlbar commands are forwarded to the owning
+   * worker daemon, which runs this same hook there, so attendance is recorded
+   * on the daemon that actually hosts the instance.
+   */
+  noteManualAttendanceIfApplicable(cmd, args) {
+    if (!MANUAL_ATTENDANCE_COMMANDS.has(cmd)) return;
+    const sessionId = this._currentRoute.session?.sessionId || (typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "");
+    if (!sessionId) return;
+    const session = this._ctx.sessionRegistry?.get(sessionId);
+    const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
+    const instance = this._ctx.instanceManager?.getInstance(instanceKey);
+    try {
+      instance?.noteManualInteraction?.();
+    } catch {
+    }
+  }
   // ─── Command Dispatcher ──────────────────────────
   async handle(cmd, args) {
     this._currentRoute = this.resolveRoute(args);
     const startedAt = Date.now();
     this.logCommandStart(cmd, args);
+    this.noteManualAttendanceIfApplicable(cmd, args);
     let result;
     if (isGitCommandName(cmd)) {
       result = await handleGitCommand(cmd, args, this._ctx.gitCommandServices);
@@ -32150,10 +32398,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const path42 = __require("path");
     const { spawnSync: spawnSync2 } = __require("child_process");
     const file = ext.loadExternalSources();
-    if (file.sources.some((s) => s.name === requestedName)) {
+    if (file.sources.some((s2) => s2.name === requestedName)) {
       return { success: false, error: `source name "${requestedName}" is already registered` };
     }
-    if (file.sources.some((s) => s.url === url && s.ref === ref)) {
+    if (file.sources.some((s2) => s2.url === url && s2.ref === ref)) {
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
     const sourceDir = path42.join(ext.externalRoot(), requestedName);
@@ -32215,7 +32463,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const fs32 = __require("fs");
     const path42 = __require("path");
     const file = ext.loadExternalSources();
-    const match = file.sources.find((s) => s.name === name);
+    const match = file.sources.find((s2) => s2.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
     const sourceDir = path42.join(ext.externalRoot(), name);
     if (fs32.existsSync(sourceDir)) {
@@ -32227,7 +32475,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     }
     ext.saveExternalSources({
       schema: 1,
-      sources: file.sources.filter((s) => s.name !== name)
+      sources: file.sources.filter((s2) => s2.name !== name)
     });
     const active = ext.loadProvidersActive();
     const filteredActive = {};
@@ -32251,10 +32499,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const file = ext.loadExternalSources();
     const inventory = ext.inventoryExternalSources();
     const active = ext.loadProvidersActive();
-    const sources = file.sources.map((s) => {
-      const inv = inventory.find((e) => e.sourceName === s.name);
+    const sources = file.sources.map((s2) => {
+      const inv = inventory.find((e) => e.sourceName === s2.name);
       return {
-        ...s,
+        ...s2,
         providers: inv?.providers ?? {}
       };
     });
@@ -32431,6 +32679,21 @@ import * as path21 from "path";
 // src/providers/spec/adapter.ts
 init_terminal_screen();
 import { DEFAULT_SESSION_HOST_COLS as DEFAULT_SESSION_HOST_COLS5, DEFAULT_SESSION_HOST_ROWS as DEFAULT_SESSION_HOST_ROWS5 } from "@adhdev/session-host-core";
+var MAX_PTY_EVENTS = 300;
+var EVENT_CONTENT_CAP = 240;
+function escapeControl(text) {
+  return String(text).replace(/[\x00-\x1f\x7f]/g, (ch) => {
+    const code = ch.charCodeAt(0);
+    if (ch === "\r") return "\\r";
+    if (ch === "\n") return "\\n";
+    if (ch === "	") return "\\t";
+    if (code === 27) return "\\x1b";
+    return "\\x" + code.toString(16).padStart(2, "0");
+  });
+}
+function capPreview(text) {
+  return text.length > EVENT_CONTENT_CAP ? text.slice(0, EVENT_CONTENT_CAP) + `\u2026(+${text.length - EVENT_CONTENT_CAP})` : text;
+}
 var TerminalAdapter = class {
   constructor(opts, handlers) {
     this.opts = opts;
@@ -32457,6 +32720,9 @@ var TerminalAdapter = class {
   screenTimer = null;
   tickTimer = null;
   lastScreen = "";
+  /** Debug-only ring buffer of PTY input/output/resize/cursor events. */
+  events = [];
+  lastCursorKey = "";
   start() {
     const env = this.opts.envIsComplete ? this.opts.env ?? {} : { ...process.env, ...this.opts.env ?? {} };
     this.pty = this.factory.spawn(this.opts.binary, this.opts.args ?? [], {
@@ -32465,10 +32731,12 @@ var TerminalAdapter = class {
       cols: this.cols,
       rows: this.rows
     });
+    this.recordEvent("spawn", `${this.opts.binary} (${this.cols}x${this.rows})`);
     this.handlers.init?.({ pid: this.pty.pid });
     this.pty.onData((chunk) => this.onChunk(chunk));
     this.pty.onExit((info) => {
       this.stopTimers();
+      this.recordEvent("exit", `exitCode=${typeof info.exitCode === "number" ? info.exitCode : 0}`);
       this.handlers.on_exit?.({ exitCode: typeof info.exitCode === "number" ? info.exitCode : 0 });
       this.pty = null;
     });
@@ -32479,6 +32747,7 @@ var TerminalAdapter = class {
   resize(cols, rows) {
     this.cols = cols;
     this.rows = rows;
+    this.recordEvent("resize", `${cols}x${rows}`);
     this.pty?.resize(cols, rows);
     this.screen.resize(rows, cols);
   }
@@ -32499,8 +32768,21 @@ var TerminalAdapter = class {
     return { row: pos.row, col: pos.col };
   }
   send_keys(text) {
+    this.recordEvent("input", capPreview(escapeControl(text)), text.length);
     this.pty?.write(text);
   }
+  /** Debug-only: most-recent PTY input/output/resize/cursor events, oldest
+   *  first. Pure observation — never consulted by the FSM. */
+  getEventTimeline(limit = MAX_PTY_EVENTS) {
+    const n = Math.max(0, Math.min(limit, this.events.length));
+    return this.events.slice(this.events.length - n);
+  }
+  recordEvent(kind, content, bytes) {
+    const ev = { ts: Date.now(), kind, content };
+    if (typeof bytes === "number") ev.bytes = bytes;
+    this.events.push(ev);
+    if (this.events.length > MAX_PTY_EVENTS) this.events.splice(0, this.events.length - MAX_PTY_EVENTS);
+  }
   kill() {
     this.stopTimers();
     try {
@@ -32511,6 +32793,7 @@ var TerminalAdapter = class {
     this.screen.dispose();
   }
   onChunk(chunk) {
+    this.recordEvent("output", capPreview(escapeControl(chunk)), chunk.length);
     try {
       this.handlers.on_pty_data?.(chunk);
     } catch {
@@ -32520,6 +32803,12 @@ var TerminalAdapter = class {
     this.screenTimer = setTimeout(() => {
       this.screenTimer = null;
       const snap = this.computeScreen();
+      const cur = this.screen.getCursorPosition();
+      const curKey = `${cur.row},${cur.col}`;
+      if (curKey !== this.lastCursorKey) {
+        this.lastCursorKey = curKey;
+        this.recordEvent("cursor", `(${cur.row},${cur.col})`);
+      }
       if (snap === this.lastScreen) return;
       this.lastScreen = snap;
       try {
@@ -32604,20 +32893,40 @@ function applyPreLaunchTrust(trust, workingDir) {
 
 // src/providers/spec/fsm-driver.ts
 init_logger();
-function countNewlines(s) {
+function countNewlines(s2) {
   let n = 0;
-  for (let i = 0; i < s.length; i += 1) if (s.charCodeAt(i) === 10) n += 1;
+  for (let i = 0; i < s2.length; i += 1) if (s2.charCodeAt(i) === 10) n += 1;
   return n;
 }
 var SUBMIT_DELAY_FLOOR_MS = 200;
 var WIN32_SUBMIT_RESEND_GAP_MS = 350;
 var WIN32_SUBMIT_MAX_RESENDS = 14;
+var WIN32_SUBMIT_SETTLE_MS = 500;
+var WIN32_SUBMIT_MAX_SETTLE_WAIT_MS = 1e4;
+var WIN32_SUBMIT_SETTLE_POLL_MS = 120;
+var WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+var WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
 function resolveSubmitDelayMs(specBeforeSubmit, text) {
   const lines = countNewlines(text);
   const linesBonus = Math.min(800, lines * 80);
   const spec = typeof specBeforeSubmit === "number" && specBeforeSubmit > 0 ? specBeforeSubmit : 0;
   return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
 }
+function chunkPreservingSurrogates(text, size) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let end = Math.min(text.length, offset + size);
+    if (end < text.length) {
+      const code = text.charCodeAt(end - 1);
+      if (code >= 55296 && code <= 56319) end -= 1;
+    }
+    if (end <= offset) end = Math.min(text.length, offset + size);
+    chunks.push(text.slice(offset, end));
+    offset = end;
+  }
+  return chunks;
+}
 function guessExt(mime) {
   if (/png/i.test(mime)) return ".png";
   if (/jpe?g/i.test(mime)) return ".jpg";
@@ -32633,7 +32942,10 @@ var FsmDriver = class {
       this.buildAdapterOpts(),
       {
         init: () => this.emitInitialState(),
-        on_pty_data: (chunk) => this.emit({ kind: "pty_data", chunk }),
+        on_pty_data: (chunk) => {
+          this.lastPtyDataAt = Date.now();
+          this.emit({ kind: "pty_data", chunk });
+        },
         on_screen_changed: () => this.reevaluate(),
         on_exit: ({ exitCode }) => this.handleExit(exitCode)
       }
@@ -32667,6 +32979,16 @@ var FsmDriver = class {
    *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
    *  leaves idle (submitted) or the resend budget is spent. */
   win32SubmitTimer = null;
+  /** Wall-clock (ms) of the most recent raw PTY output chunk. Advances on every
+   *  on_pty_data — including the echo of text written into the composer — so the
+   *  win32 submit settle-gate can tell when input has finished landing. */
+  lastPtyDataAt = 0;
+  /** Wall-clock (ms) of the most recent win32 message-body input write. Bridges
+   *  the gap between writing a chunk and its echo so the settle-gate does not
+   *  declare "quiet" mid-write. */
+  lastWin32WriteAt = 0;
+  /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
+  win32WriteTimer = null;
   currentEval = null;
   stateHistory = [];
   prevStateAt = 0;
@@ -32787,6 +33109,10 @@ var FsmDriver = class {
       clearTimeout(this.win32SubmitTimer);
       this.win32SubmitTimer = null;
     }
+    if (this.win32WriteTimer) {
+      clearTimeout(this.win32WriteTimer);
+      this.win32WriteTimer = null;
+    }
     this.specWatcher?.close();
     this.adapter.kill();
   }
@@ -32817,11 +33143,15 @@ var FsmDriver = class {
   getFsmSnapshotHistory() {
     return this.fsmSnapshotHistory;
   }
+  /** Debug-only PTY input/output/resize/cursor timeline from the adapter. */
+  getEventTimeline(limit) {
+    return this.adapter.getEventTimeline(limit);
+  }
   getSections() {
     try {
       const screen = this.adapter.snapshot();
       const lines = screen.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
-      return resolveSections(this.spec.sections ?? {}, lines).map((s) => ({ id: s.id, text: s.text }));
+      return resolveSections(this.spec.sections ?? {}, lines).map((s2) => ({ id: s2.id, text: s2.text }));
     } catch {
       return null;
     }
@@ -33199,7 +33529,7 @@ var FsmDriver = class {
     const perChar = sm.delay_ms_per_char ?? 0;
     const beforeSubmit = resolveSubmitDelayMs(sm.delay_ms_before_submit, text);
     if (process.platform === "win32") {
-      this.adapter.send_keys(text);
+      this.writeWin32Body(text);
       this.scheduleWin32Submit(sm.submit_key, beforeSubmit);
       return;
     }
@@ -33225,20 +33555,72 @@ var FsmDriver = class {
     const st = stateById(this.spec, this.currentStateId);
     return st ? statusForState(st) : "idle";
   }
+  /** Record a win32 body write so the settle-gate counts it as input activity
+   *  even before the echo arrives. */
+  markWin32Write() {
+    this.lastWin32WriteAt = Date.now();
+  }
+  /** Most recent win32 input activity — a write we issued OR a PTY output chunk
+   *  (echo). The submit settle-gate waits for this to go quiet. */
+  lastWin32InputActivityAt() {
+    return Math.max(this.lastPtyDataAt, this.lastWin32WriteAt);
+  }
   /**
-   * win32 verification-based submit. Sends the submit key, waits a gap, and if
-   * the FSM is still 'idle' (the prompt did not submit — the CR was absorbed as
-   * a multiline-paste newline) resends, up to WIN32_SUBMIT_MAX_RESENDS. The
-   * first CR always fires (so a stale/edge status never suppresses the submit);
-   * subsequent resends are gated on still being idle, and stop the instant the
-   * agent leaves idle (submitted → generating / approval). This converges the
-   * nondeterministic multiline window without spamming Enter into the next turn.
+   * Write the message body to the PTY for win32, paced into bounded chunks. A
+   * single unbounded ConPTY write can overflow the input pipe and drop leading
+   * bytes; splitting it with a short inter-chunk gap keeps the console input
+   * buffer from overflowing. Small bodies still go out in a single write. Each
+   * chunk advances lastWin32WriteAt so the submit settle-gate keeps waiting until
+   * the final chunk is out and echoed.
+   */
+  writeWin32Body(text) {
+    if (this.win32WriteTimer) {
+      clearTimeout(this.win32WriteTimer);
+      this.win32WriteTimer = null;
+    }
+    if (text.length <= WIN32_PTY_WRITE_CHUNK_CHARS) {
+      this.markWin32Write();
+      this.adapter.send_keys(text);
+      return;
+    }
+    const chunks = chunkPreservingSurrogates(text, WIN32_PTY_WRITE_CHUNK_CHARS);
+    let idx = 0;
+    const writeNext = () => {
+      this.win32WriteTimer = null;
+      if (idx >= chunks.length) return;
+      this.markWin32Write();
+      this.adapter.send_keys(chunks[idx]);
+      idx += 1;
+      if (idx < chunks.length) {
+        this.win32WriteTimer = setTimeout(writeNext, WIN32_PTY_WRITE_CHUNK_GAP_MS);
+      }
+    };
+    writeNext();
+  }
+  /**
+   * win32 submit. Two phases:
+   *
+   *  Phase 1 (settle-gate): hold the first CR until the PTY output has been quiet
+   *  for WIN32_SUBMIT_SETTLE_MS after the last input write — i.e. the full
+   *  (possibly multi-KB / multiline) body has finished arriving in the composer
+   *  and echoing. Honors an initial minimum delay and is bounded by
+   *  WIN32_SUBMIT_MAX_SETTLE_WAIT_MS so a noisy screen can never hang the submit.
+   *  This is what stops a long message from being submitted half-arrived (its
+   *  leading lines lost). A short message settles almost immediately.
+   *
+   *  Phase 2 (verified resend — unchanged): send the submit key, wait a gap, and
+   *  if the FSM is still 'idle' (the CR was absorbed as a multiline-paste
+   *  newline) resend, up to WIN32_SUBMIT_MAX_RESENDS. The first CR always fires
+   *  (a stale/edge status never suppresses it); resends are gated on still being
+   *  idle and stop the instant the agent leaves idle (submitted → generating /
+   *  approval). This preserves the win32 lone-CR-swallow handling.
    */
   scheduleWin32Submit(submitKey, initialDelayMs) {
     if (this.win32SubmitTimer) {
       clearTimeout(this.win32SubmitTimer);
       this.win32SubmitTimer = null;
     }
+    const startedAt = Date.now();
     const fire = (attempt) => {
       this.win32SubmitTimer = null;
       this.adapter.send_keys(submitKey);
@@ -33251,8 +33633,20 @@ var FsmDriver = class {
         fire(attempt + 1);
       }, WIN32_SUBMIT_RESEND_GAP_MS);
     };
-    if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(() => fire(0), initialDelayMs);
-    else fire(0);
+    const waitForSettle = () => {
+      this.win32SubmitTimer = null;
+      const now = Date.now();
+      const quietFor = now - this.lastWin32InputActivityAt();
+      const waited = now - startedAt;
+      if (quietFor >= WIN32_SUBMIT_SETTLE_MS || waited >= WIN32_SUBMIT_MAX_SETTLE_WAIT_MS) {
+        fire(0);
+        return;
+      }
+      const recheckIn = Math.min(WIN32_SUBMIT_SETTLE_MS - quietFor, WIN32_SUBMIT_SETTLE_POLL_MS);
+      this.win32SubmitTimer = setTimeout(waitForSettle, Math.max(recheckIn, 30));
+    };
+    if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(waitForSettle, initialDelayMs);
+    else waitForSettle();
   }
   handleClickControl(controlId, payload) {
     const ctl = (this.spec.control_bar ?? []).find((c) => c.id === controlId);
@@ -33365,7 +33759,8 @@ function summarizeTransition(t) {
   return out;
 }
 function flattenCond(c, out, depth) {
-  out.push(`${"  ".repeat(depth)}${c.kind} ${c.detail} = ${c.result}${c.remainingMs ? ` (${c.remainingMs}ms left)` : ""}`);
+  const matched = c.matchedText ? ` matched=${JSON.stringify(c.matchedText)}` : "";
+  out.push(`${"  ".repeat(depth)}${c.kind} ${c.detail} = ${c.result}${c.remainingMs ? ` (${c.remainingMs}ms left)` : ""}${matched}`);
   for (const child of c.children ?? []) flattenCond(child, out, depth + 1);
 }
 function findStable(c) {
@@ -34083,8 +34478,8 @@ function projectToolBlock(block2, role, tmap) {
   }
   return null;
 }
-function oneLine(s, max) {
-  const flat = s.replace(/\s+/g, " ").trim();
+function oneLine(s2, max) {
+  const flat = s2.replace(/\s+/g, " ").trim();
   return flat.length > max ? flat.slice(0, max - 1) + "\u2026" : flat;
 }
 function parseTimestamp(v) {
@@ -34104,10 +34499,10 @@ function parseTimestamp(v) {
   return null;
 }
 function normalizeRole(r) {
-  const s = String(r ?? "").toLowerCase();
-  if (s === "user" || s === "human" || s === "user_explicit") return "user";
-  if (s === "assistant" || s === "ai" || s === "model") return "assistant";
-  if (s === "tool" || s === "tool_result" || s === "function") return "assistant";
+  const s2 = String(r ?? "").toLowerCase();
+  if (s2 === "user" || s2 === "human" || s2 === "user_explicit") return "user";
+  if (s2 === "assistant" || s2 === "ai" || s2 === "model") return "assistant";
+  if (s2 === "tool" || s2 === "tool_result" || s2 === "function") return "assistant";
   return "system";
 }
 function stringifyContent(v) {
@@ -34155,18 +34550,18 @@ function compileWhere(src) {
   return (record) => ors.some((ands) => ands.every((t) => evalTerm(t, record)));
 }
 function parseTerm(src) {
-  let s = src.trim();
+  let s2 = src.trim();
   let negate = false;
-  if (s.startsWith("!")) {
+  if (s2.startsWith("!")) {
     negate = true;
-    s = s.slice(1).trim();
+    s2 = s2.slice(1).trim();
   }
-  const fnMatch = s.match(/^(startsWith|endsWith|contains)\s*\(\s*(.+?)\s*,\s*(.+?)\s*\)$/);
+  const fnMatch = s2.match(/^(startsWith|endsWith|contains)\s*\(\s*(.+?)\s*,\s*(.+?)\s*\)$/);
   if (fnMatch) {
     const [, op2, pathExpr, litExpr] = fnMatch;
     return { path: pathExpr, op: op2, lit: parseLiteral(litExpr), negate };
   }
-  const opMatch = s.match(/^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
+  const opMatch = s2.match(/^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
   if (!opMatch) return null;
   const [, lhs, op, rhsRaw] = opMatch;
   return { path: lhs.trim(), op, lit: parseLiteral(rhsRaw.trim()), negate };
@@ -34598,7 +34993,7 @@ var SpecCliAdapter = class _SpecCliAdapter {
     try {
       const sections = this.driver.getSections();
       if (sectionId && sections) {
-        const hit = sections.find((s) => s.id === sectionId);
+        const hit = sections.find((s2) => s2.id === sectionId);
         if (hit) return hit.text;
       }
       return this.driver.getScreen();
@@ -34613,7 +35008,7 @@ var SpecCliAdapter = class _SpecCliAdapter {
       screen = this.driver.snapshot();
       const driverSections = this.driver.getSections?.();
       if (driverSections) {
-        sections = Object.fromEntries(driverSections.map((s) => [s.id, s.text]));
+        sections = Object.fromEntries(driverSections.map((s2) => [s2.id, s2.text]));
       } else {
         sections = this.readCurrentScreenSections(screen);
       }
@@ -34659,6 +35054,10 @@ var SpecCliAdapter = class _SpecCliAdapter {
       // answers "why did this rule fire" after the fact, unlike the live
       // `fsm` field which only reflects the current instant.
       fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+      // PTY input/output/resize/cursor event timeline (debug-only) so the
+      // snapshot shows what we typed / what the PTY printed around each
+      // status transition. Null for drivers without the timeline.
+      eventTimeline: this.driver.getEventTimeline?.() ?? null,
       // Extended fields
       name: this.cliName,
       status: this.getStatus().status,
@@ -35023,6 +35422,8 @@ var SpecCliAdapter = class _SpecCliAdapter {
       // v4 FSM transition snapshot history — the captured pre-transition
       // evaluation table at each transition (null for v3 specs).
       fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+      // PTY input/output/resize/cursor event timeline (debug-only).
+      eventTimeline: this.driver.getEventTimeline?.() ?? null,
       messages,
       committedMessages: messages
     };
@@ -35067,6 +35468,7 @@ function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFact
 
 // src/providers/cli-provider-instance.ts
 init_logger();
+init_mesh_event_trace();
 init_control_effects();
 init_approval_utils();
 init_provider_patch_state();
@@ -35369,6 +35771,11 @@ var CliProviderInstance = class _CliProviderInstance {
   // 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;
+  // Provider-common manual-attendance signal: while a human is actively driving
+  // this session from the dashboard, auto-approve holds so they can take manual
+  // control. Background mesh workers are never attended → delegated auto-approve
+  // is unaffected.
+  manualAttendance = new ManualAttendanceTracker();
   controlValues = {};
   summaryMetadata = void 0;
   appliedEffectKeys = /* @__PURE__ */ new Set();
@@ -35644,7 +36051,7 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   getHotChatSessionState() {
     const adapterStatus = this.adapter.getStatus({ allowParse: false });
-    const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+    const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
     const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === "idle";
     const visibleStatus = autoApproveActive || autoApproveHoldIdle ? "generating" : adapterStatus.status;
     const runtime = this.adapter.getRuntimeMetadata();
@@ -35659,7 +36066,7 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   getSessionModalState(sessionId) {
     const adapterStatus = this.adapter.getStatus({ allowParse: true });
-    const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+    const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
     const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === "idle";
     const visibleStatus = autoApproveActive || autoApproveHoldIdle ? "generating" : adapterStatus.status;
     const dirName = workingDirBasename(this.workingDir);
@@ -35740,7 +36147,7 @@ var CliProviderInstance = class _CliProviderInstance {
     } catch {
       return null;
     }
-    if (adapterStatus.status === "waiting_approval" && !this.shouldAutoApprove()) {
+    if (adapterStatus.status === "waiting_approval" && !this.autoApproveEffectivelyActive(adapterStatus.status)) {
       return "waiting_approval";
     }
     return null;
@@ -36113,6 +36520,23 @@ var CliProviderInstance = class _CliProviderInstance {
     if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
     this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
   }
+  // EVTTRACE (observation-only): is this a mesh worker session whose completion
+  // events must route to a coordinator? Used purely to gate trace logging so a
+  // non-mesh CLI session's completions don't add EvtTrace noise. No decision logic.
+  isMeshWorkerSession() {
+    return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.meshNodeId || this.settings.launchedByCoordinator);
+  }
+  // EVTTRACE correlation context for this session's completion lifecycle. taskId is
+  // the primary grep anchor; instanceId is the session fallback.
+  meshTraceCtx(event = "agent:generating_completed") {
+    return {
+      taskId: this.settings.meshActiveTaskId,
+      sessionId: this.instanceId,
+      nodeId: this.settings.meshNodeId,
+      meshId: this.settings.meshNodeFor,
+      event
+    };
+  }
   flushCompletedDebounceIfFinalized() {
     const pending = this.completedDebouncePending;
     if (!pending) {
@@ -36133,24 +36557,33 @@ var CliProviderInstance = class _CliProviderInstance {
     if (block2) {
       const blockReason = block2.reason;
       const waitedMs = Date.now() - pending.firstObservedAt;
-      LOG.debug("CLI", `[${this.type}] finalization block: reason=${blockReason} terminal=${block2.terminal} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
-      if (block2.terminal && !block2.allowTimeout || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+      const isTranscriptEvidenceGate = block2.allowTimeout === true;
+      LOG.debug("CLI", `[${this.type}] finalization block: reason=${blockReason} terminal=${block2.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
+      if (!isTranscriptEvidenceGate && (block2.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS)) {
         if (pending.loggedBlockReason !== blockReason) {
           LOG.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+          if (this.isMeshWorkerSession()) {
+            traceMeshEventDrop("completion_gate_hold", this.meshTraceCtx(), `${blockReason} waited=${waitedMs}ms`);
+          }
           pending.loggedBlockReason = blockReason;
         }
         this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
         return;
       }
+      const emittedAfterFinalizationTimeout = waitedMs >= COMPLETED_FINALIZATION_MAX_WAIT_MS;
       const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
         blockReason,
         latestStatus,
         latestVisibleStatus,
         waitedMs,
         pending,
-        emittedAfterFinalizationTimeout: true
+        emittedAfterFinalizationTimeout
       });
-      LOG.warn("CLI", `[${this.type}] emitting completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+      completionDiagnostic.decoupledImmediateEmit = isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout;
+      LOG.warn("CLI", `[${this.type}] emitting completed event (${isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout ? "CANON-C decoupled-immediate, transcript pending" : `after ${waitedMs}ms`}) without finalized assistant turn (${blockReason})`);
+      if (this.isMeshWorkerSession()) {
+        traceMeshEventStage("fired", this.meshTraceCtx(), `forced after ${waitedMs}ms (${blockReason})`);
+      }
       this.pushEvent({
         event: "agent:generating_completed",
         chatTitle: pending.chatTitle,
@@ -36173,6 +36606,9 @@ var CliProviderInstance = class _CliProviderInstance {
       return;
     }
     LOG.info("CLI", `[${this.type}] completed in ${pending.duration}s`);
+    if (this.isMeshWorkerSession()) {
+      traceMeshEventStage("fired", this.meshTraceCtx(), `duration=${pending.duration}s`);
+    }
     this.pushEvent({
       event: "agent:generating_completed",
       chatTitle: pending.chatTitle,
@@ -36186,6 +36622,18 @@ var CliProviderInstance = class _CliProviderInstance {
     this.lastApprovalEventFingerprint = "";
   }
   maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
+    if (adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove() && this.manualAttendance.isAttended(now)) {
+      this.lastAutoApprovalSignature = "";
+      this.pendingAutoApprovalSignature = "";
+      this.pendingAutoApprovalSince = 0;
+      this.autoApproveInactiveSince = 0;
+      if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+      this.autoApproveSettleTimer = setTimeout(() => {
+        this.autoApproveSettleTimer = null;
+        this.recheckAutoApproveSettled();
+      }, this.manualAttendance.remainingMs(now) + 20);
+      return false;
+    }
     const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove();
     if (!autoApproveActive) {
       this.lastAutoApprovalSignature = "";
@@ -36399,6 +36847,9 @@ var CliProviderInstance = class _CliProviderInstance {
           if (missingEvidence && !hasMeshContext) {
             LOG.info("CLI", `[${this.type}] short completion suppressed: missing final assistant evidence, no mesh context (source=${shortEvidenceSource})`);
           } else {
+            if (this.isMeshWorkerSession()) {
+              traceMeshEventStage("fired", this.meshTraceCtx(), `short-generating idle (source=${shortEvidenceSource})`);
+            }
             this.pushEvent({
               event: "agent:generating_completed",
               chatTitle,
@@ -36475,6 +36926,9 @@ var CliProviderInstance = class _CliProviderInstance {
     const monitorParsedStatus = parsedStatus;
     for (const me of monitorEvents) {
       if (me.type === "monitor:no_progress" && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages) && !this.hasAdapterPendingResponse() && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)) {
+        if (this.isMeshWorkerSession()) {
+          traceMeshEventStage("fired", this.meshTraceCtx(), "no_progress_monitor_final_summary");
+        }
         this.pushEvent({
           event: "agent:generating_completed",
           chatTitle,
@@ -36651,6 +37105,21 @@ ${effect.notification.body || ""}`.trim();
     }
     return false;
   }
+  /** @see ProviderInstance.noteManualInteraction */
+  noteManualInteraction(now = Date.now()) {
+    this.manualAttendance.note(now);
+  }
+  /**
+   * Whether auto-approve should be treated as active *right now* for display
+   * and firing decisions: the configured intent AND the user is not currently
+   * attending this session by hand. When a human is attending, auto-approve is
+   * held so the modal stays visible and they can drive it via the controlbar.
+   * Provider-agnostic — the attendance signal is the command set, never any
+   * CLI-specific modal text.
+   */
+  autoApproveEffectivelyActive(status, now = Date.now()) {
+    return status === "waiting_approval" && this.shouldAutoApprove() && !this.manualAttendance.isAttended(now);
+  }
   recordAutoApproval(modalMessage, buttonLabel, now = Date.now()) {
     this.appendRuntimeSystemMessage(
       formatAutoApprovalMessage(modalMessage, buttonLabel),
@@ -37601,7 +38070,7 @@ var AcpProviderInstance = class {
             input: tc.rawInput ? typeof tc.rawInput === "string" ? tc.rawInput : JSON.stringify(tc.rawInput) : void 0
           });
         }
-        if (this.settings.autoApprove !== false) {
+        if (this.settings.autoApprove !== false && !this.manualAttendance.isAttended()) {
           const toolTitle = tc.title || tc.toolCallId || "tool call";
           this.log.info(`[${this.type}] Auto-approving: ${toolTitle}`);
           this.appendSystemMessage(`Auto-approved: ${toolTitle}`);
@@ -37832,6 +38301,15 @@ var AcpProviderInstance = class {
     this.detectStatusTransition();
   }
   permissionResolvers = [];
+  // Provider-common manual-attendance signal: while a human is actively driving
+  // this session from the dashboard, auto-approve holds so they can decide on
+  // the permission request themselves. Background workers are never attended →
+  // delegated auto-approve is unaffected.
+  manualAttendance = new ManualAttendanceTracker();
+  /** @see ProviderInstance.noteManualInteraction */
+  noteManualInteraction(now = Date.now()) {
+    this.manualAttendance.note(now);
+  }
   async resolvePermission(approved) {
     const resolver = this.permissionResolvers.shift();
     if (resolver) {
@@ -38989,6 +39467,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         );
         continue;
       }
+      const restoredSettings = { ...this.providerLoader.getSettings(normalizedType) };
+      const coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+      if (coordinatorEntry?.meshId) {
+        restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
+      }
       try {
         await this.registerCliInstance(
           record.runtimeId,
@@ -38997,7 +39480,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           record.workspace,
           record.cliArgs,
           resolvedProvider,
-          {},
+          restoredSettings,
           true,
           {
             providerSessionId: sessionBinding.providerSessionId,
@@ -40314,7 +40797,7 @@ function parsePbFile(filePath, sessionId) {
   }
   if (buf.length === 0) return null;
   const strings = extractStringsFromBuffer(buf);
-  const meaningful = strings.filter((s) => s.length >= MIN_PRINTABLE_RUN && /\w/.test(s));
+  const meaningful = strings.filter((s2) => s2.length >= MIN_PRINTABLE_RUN && /\w/.test(s2));
   if (meaningful.length === 0) return null;
   const content = meaningful.join("\n");
   const sourceMtimeMs = statMtimeMs3(filePath);
@@ -40522,10 +41005,10 @@ function readSession4(sessionPath) {
   };
 }
 function normalizeHermesRole(r) {
-  const s = String(r ?? "").toLowerCase();
-  if (s === "user" || s === "human") return "user";
-  if (s === "assistant" || s === "ai" || s === "model") return "assistant";
-  if (s === "tool" || s === "tool_result" || s === "function") return "assistant";
+  const s2 = String(r ?? "").toLowerCase();
+  if (s2 === "user" || s2 === "human") return "user";
+  if (s2 === "assistant" || s2 === "ai" || s2 === "model") return "assistant";
+  if (s2 === "tool" || s2 === "tool_result" || s2 === "function") return "assistant";
   return "system";
 }
 
@@ -40751,10 +41234,10 @@ function safeMtime(p) {
   }
 }
 function normalizeRole2(r) {
-  const s = String(r ?? "").toLowerCase();
-  if (s === "user" || s === "human") return "user";
-  if (s === "assistant" || s === "ai" || s === "model") return "assistant";
-  if (s === "tool" || s === "tool_result" || s === "function") return "assistant";
+  const s2 = String(r ?? "").toLowerCase();
+  if (s2 === "user" || s2 === "human") return "user";
+  if (s2 === "assistant" || s2 === "ai" || s2 === "model") return "assistant";
+  if (s2 === "tool" || s2 === "tool_result" || s2 === "function") return "assistant";
   return "system";
 }
 
@@ -40774,7 +41257,7 @@ function synthesizeControlsFromControlBar(specControls) {
     const actionType = ctl?.action?.type;
     if (!id || !actionType) return;
     const label = typeof ctl?.label === "string" && ctl.label.trim() ? ctl.label : id;
-    const visibleWhenState = Array.isArray(ctl?.visible_when_state) ? ctl.visible_when_state.filter((s) => typeof s === "string") : void 0;
+    const visibleWhenState = Array.isArray(ctl?.visible_when_state) ? ctl.visible_when_state.filter((s2) => typeof s2 === "string") : void 0;
     if (actionType === "open_picker") {
       out.push({
         id,
@@ -47690,7 +48173,7 @@ var DaemonCommandRouter = class {
           const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
           if (!firstFailedCmd) return base;
           const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
-          const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s) => typeof s === "string" && s.length > 0).join("\n");
+          const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s2) => typeof s2 === "string" && s2.length > 0).join("\n");
           const tail = rawOutput.length > 800 ? rawOutput.slice(-800) : rawOutput;
           return [
             base,
@@ -48441,7 +48924,7 @@ ${hintLines.join("\n")}` : "",
         convergence = "blocked_review";
       }
       const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
-      const stage = Array.isArray(result.refineStages) ? result.refineStages.filter((s) => s.status === "failed").map((s) => s.stage).filter(Boolean).pop() : void 0;
+      const stage = Array.isArray(result.refineStages) ? result.refineStages.filter((s2) => s2.status === "failed").map((s2) => s2.stage).filter(Boolean).pop() : void 0;
       results.push({
         nodeId: node.id,
         workspace: node.workspace,
@@ -49438,7 +49921,7 @@ ${hintLines.join("\n")}` : "",
           return {
             success: true,
             screenLineCount: lines.length,
-            sections: resolved.map((s) => ({ id: s.id, fromLine: s.fromLine, toLine: s.toLine, text: s.text }))
+            sections: resolved.map((s2) => ({ id: s2.id, fromLine: s2.fromLine, toLine: s2.toLine, text: s2.text }))
           };
         } catch (e) {
           return { success: false, error: `resolve failed: ${e.message}` };
@@ -50007,7 +50490,7 @@ ${hintLines.join("\n")}` : "",
         if (!meshId) return { success: false, error: "meshId required" };
         try {
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2, describeTaskDependencyState: describeTaskDependencyState2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-          const status = Array.isArray(args?.status) ? args.status.map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean) : void 0;
+          const status = Array.isArray(args?.status) ? args.status.map((s2) => typeof s2 === "string" ? s2.trim() : "").filter(Boolean) : void 0;
           const rawQueue = getQueue2(meshId, { status });
           const statusById = new Map(getQueue2(meshId).map((task) => [task.id, task.status]));
           const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById) } : task);
@@ -50288,7 +50771,7 @@ ${hintLines.join("\n")}` : "",
           nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
         }
         const selfDaemonId = this.deps.statusInstanceId;
-        const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
         if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
           const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
             ...typeof args === "object" && args !== null ? args : {},
@@ -50322,7 +50805,7 @@ ${hintLines.join("\n")}` : "",
           nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
         }
         const selfDaemonId = this.deps.statusInstanceId;
-        const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
         if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
           const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "get_mesh_node_logs", {
             ...typeof args === "object" && args !== null ? args : {},
@@ -50370,7 +50853,7 @@ ${hintLines.join("\n")}` : "",
           const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
           const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
           const selfDaemonId = this.deps.statusInstanceId;
-          const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+          const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
           if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
             const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
             const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
@@ -50457,7 +50940,7 @@ ${hintLines.join("\n")}` : "",
           let worktreeCleanup;
           if (node?.isLocalWorktree) {
             const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-            const isRemoteWorktree = nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
+            const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
             if (isRemoteWorktree) {
               const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "remove_mesh_node", {
                 ...typeof args === "object" && args !== null ? args : {},
@@ -50539,7 +51022,7 @@ ${hintLines.join("\n")}` : "",
           const sourceNode = mesh.nodes?.find((n) => meshNodeIdMatches(n, sourceNodeId));
           if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
           const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
-          if (sourceDaemonId && sourceDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
             const forwarded = await this.deps.dispatchMeshCommand(sourceDaemonId, "clone_mesh_node", {
               ...typeof args === "object" && args !== null ? args : {},
               _meshDirectDispatch: true
@@ -50781,7 +51264,7 @@ ${hintLines.join("\n")}` : "",
           if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
           if (!node.isLocalWorktree) return { success: false, error: "Node is not a local worktree node" };
           const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-          if (nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
             const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "retry_mesh_node_bootstrap", {
               ...typeof args === "object" && args !== null ? args : {},
               _meshDirectDispatch: true
@@ -51991,16 +52474,16 @@ var DaemonStatusReporter = class {
     const now = this.lastStatusSentAt;
     const target = opts?.p2pOnly ? "P2P" : serverConnected ? "P2P+Server" : "P2P";
     const allStates = this.deps.instanceManager.collectAllStates();
-    const ideStates = allStates.filter((s) => s.category === "ide");
-    const cliStates = allStates.filter((s) => s.category === "cli");
-    const acpStates = allStates.filter((s) => s.category === "acp");
-    const ideSummary = ideStates.map((s) => {
-      const msgs = s.activeChat?.messages?.length || 0;
-      const exts = s.extensions.length;
-      return `${s.type}(${s.status},${msgs}msg,${exts}ext)`;
+    const ideStates = allStates.filter((s2) => s2.category === "ide");
+    const cliStates = allStates.filter((s2) => s2.category === "cli");
+    const acpStates = allStates.filter((s2) => s2.category === "acp");
+    const ideSummary = ideStates.map((s2) => {
+      const msgs = s2.activeChat?.messages?.length || 0;
+      const exts = s2.extensions.length;
+      return `${s2.type}(${s2.status},${msgs}msg,${exts}ext)`;
     }).join(", ");
-    const cliSummary = cliStates.map((s) => `${s.type}(${s.status})`).join(", ");
-    const acpSummary = acpStates.map((s) => `${s.type}(${s.status})`).join(", ");
+    const cliSummary = cliStates.map((s2) => `${s2.type}(${s2.status})`).join(", ");
+    const acpSummary = acpStates.map((s2) => `${s2.type}(${s2.status})`).join(", ");
     const logLevel = opts?.p2pOnly ? "debug" : "info";
     const baseSummary = `IDE: ${ideStates.length} [${ideSummary}] CLI: ${cliStates.length} [${cliSummary}] ACP: ${acpStates.length} [${acpSummary}]`;
     const summaryChanged = baseSummary !== this.lastStatusSummary;
@@ -52111,10 +52594,10 @@ var DaemonStatusReporter = class {
     }
     return false;
   }
-  simpleHash(s) {
+  simpleHash(s2) {
     let h = 2166136261;
-    for (let i = 0; i < s.length; i++) {
-      h ^= s.charCodeAt(i);
+    for (let i = 0; i < s2.length; i++) {
+      h ^= s2.charCodeAt(i);
       h = h * 16777619 >>> 0;
     }
     return h.toString(36);
@@ -53340,7 +53823,7 @@ var ProviderInstanceManager = class {
   * Per-category status collect
   */
   collectStatesByCategory(category) {
-    return this.collectAllStates().filter((s) => s.category === category);
+    return this.collectAllStates().filter((s2) => s2.category === category);
   }
   // ─── Tick engine ─────────────────────────────────
   /**
@@ -55240,9 +55723,9 @@ function getCliProviderResolutionMeta(ctx, type, adapter) {
 function findCliTarget(ctx, type, instanceId) {
   if (!ctx.instanceManager) return null;
   const cliStates = ctx.instanceManager.collectAllStates().filter(isCliTargetState);
-  if (instanceId) return cliStates.find((s) => s.instanceId === instanceId) || null;
+  if (instanceId) return cliStates.find((s2) => s2.instanceId === instanceId) || null;
   if (!type) return cliStates[cliStates.length - 1] || null;
-  const matches = cliStates.filter((s) => s.type === type);
+  const matches = cliStates.filter((s2) => s2.type === type);
   return matches[matches.length - 1] || null;
 }
 function getCliTargetBundle(ctx, type, instanceId) {
@@ -55605,20 +56088,20 @@ async function handleCliStatus(ctx, _req, res) {
     return;
   }
   const allStates = ctx.instanceManager.collectAllStates();
-  const cliStates = allStates.filter((s) => s.category === "cli" || s.category === "acp");
-  const result = cliStates.map((s) => ({
-    instanceId: s.instanceId,
-    type: s.type,
-    name: s.name,
-    category: s.category,
-    status: s.status,
-    mode: s.mode,
-    workspace: s.workspace,
-    messageCount: s.activeChat?.messages?.length || 0,
-    lastMessage: s.activeChat?.messages?.slice(-1)[0] || null,
-    activeModal: s.activeChat?.activeModal || null,
-    pendingEvents: s.pendingEvents || [],
-    settings: s.settings
+  const cliStates = allStates.filter((s2) => s2.category === "cli" || s2.category === "acp");
+  const result = cliStates.map((s2) => ({
+    instanceId: s2.instanceId,
+    type: s2.type,
+    name: s2.name,
+    category: s2.category,
+    status: s2.status,
+    mode: s2.mode,
+    workspace: s2.workspace,
+    messageCount: s2.activeChat?.messages?.length || 0,
+    lastMessage: s2.activeChat?.messages?.slice(-1)[0] || null,
+    activeModal: s2.activeChat?.activeModal || null,
+    pendingEvents: s2.pendingEvents || [],
+    settings: s2.settings
   }));
   ctx.json(res, 200, { instances: result, count: result.length });
 }
@@ -55707,9 +56190,9 @@ function handleCliSSE(ctx, cliSSEClients, _req, res) {
   }
   if (ctx.instanceManager) {
     const allStates = ctx.instanceManager.collectAllStates();
-    const cliStates = allStates.filter((s) => s.category === "cli" || s.category === "acp");
-    for (const s of cliStates) {
-      ctx.sendCliSSE({ event: "snapshot", providerType: s.type, status: s.status, instanceId: s.instanceId });
+    const cliStates = allStates.filter((s2) => s2.category === "cli" || s2.category === "acp");
+    for (const s2 of cliStates) {
+      ctx.sendCliSSE({ event: "snapshot", providerType: s2.type, status: s2.status, instanceId: s2.instanceId });
     }
   }
   _req.on("close", () => {
@@ -55725,7 +56208,7 @@ async function handleCliDebug(ctx, type, _req, res) {
   const target = findCliTarget(ctx, type);
   if (!target) {
     const allStates = ctx.instanceManager.collectAllStates();
-    ctx.json(res, 404, { error: `No running instance for: ${type}`, available: allStates.filter((s) => s.category === "cli" || s.category === "acp").map((s) => s.type) });
+    ctx.json(res, 404, { error: `No running instance for: ${type}`, available: allStates.filter((s2) => s2.category === "cli" || s2.category === "acp").map((s2) => s2.type) });
     return;
   }
   const instance = ctx.instanceManager.getInstance(target.instanceId);
@@ -55771,7 +56254,7 @@ async function handleCliTrace(ctx, type, req, res) {
     const allStates = ctx.instanceManager.collectAllStates();
     ctx.json(res, 404, {
       error: `No running instance for: ${type}`,
-      available: allStates.filter((s) => s.category === "cli" || s.category === "acp").map((s) => s.type)
+      available: allStates.filter((s2) => s2.category === "cli" || s2.category === "acp").map((s2) => s2.type)
     });
     return;
   }
@@ -56576,7 +57059,7 @@ async function handleAutoImplement(ctx, type, req, res) {
           child.write("\x1B[12;1R");
           ctx.log("Terminal CPR request (\\x1b[6n) intercepted in PTY, responding with dummy coordinates [12;1R]");
         }
-        checkAutoApproval(data, (s) => child.write(s));
+        checkAutoApproval(data, (s2) => child.write(s2));
         sendAutoImplSSE(ctx, { event: "output", data: { chunk: data, stream: "stdout" } });
         scheduleAutoStopForVerification();
       });
@@ -56589,7 +57072,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdout += chunk;
         clearAutoStopTimer();
         if (chunk.includes("\x1B[6n")) child.stdin?.write("\x1B[1;1R");
-        checkAutoApproval(chunk, (s) => child.stdin?.write(s));
+        checkAutoApproval(chunk, (s2) => child.stdin?.write(s2));
         sendAutoImplSSE(ctx, { event: "output", data: { chunk, stream: "stdout" } });
         scheduleAutoStopForVerification();
       });
@@ -56597,7 +57080,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         const chunk = d.toString();
         stderr += chunk;
         clearAutoStopTimer();
-        checkAutoApproval(chunk, (s) => child.stdin?.write(s));
+        checkAutoApproval(chunk, (s2) => child.stdin?.write(s2));
         sendAutoImplSSE(ctx, { event: "output", data: { chunk, stream: "stderr" } });
         scheduleAutoStopForVerification();
       });
@@ -57412,59 +57895,59 @@ var DevServer = class _DevServer {
   // ─── Route Table ─────────────────────────────────────
   routes = [
     // Static routes
-    { method: "GET", pattern: "/api/providers", handler: (q, s) => this.handleListProviders(q, s) },
-    { method: "GET", pattern: "/api/providers/source-config", handler: (q, s) => this.handleGetProviderSourceConfig(q, s) },
-    { method: "POST", pattern: "/api/providers/source-config", handler: (q, s) => this.handleSetProviderSourceConfig(q, s) },
-    { method: "GET", pattern: "/api/providers/versions", handler: (q, s) => this.handleDetectVersions(q, s) },
-    { method: "POST", pattern: "/api/providers/reload", handler: (q, s) => this.handleReload(q, s) },
-    { method: "POST", pattern: "/api/cdp/evaluate", handler: (q, s) => this.handleCdpEvaluate(q, s) },
-    { method: "POST", pattern: "/api/cdp/click", handler: (q, s) => this.handleCdpClick(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/query", handler: (q, s) => this.handleCdpDomQuery(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/inspect", handler: (q, s) => this.handleDomInspect(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/children", handler: (q, s) => this.handleDomChildren(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/analyze", handler: (q, s) => this.handleDomAnalyze(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/find-text", handler: (q, s) => this.handleFindByText(q, s) },
-    { method: "POST", pattern: "/api/cdp/dom/find-common", handler: (q, s) => this.handleFindCommon(q, s) },
-    { method: "GET", pattern: "/api/cdp/screenshot", handler: (q, s) => this.handleScreenshot(q, s) },
-    { method: "GET", pattern: "/api/cdp/targets", handler: (q, s) => this.handleCdpTargets(q, s) },
-    { method: "POST", pattern: "/api/scripts/run", handler: (q, s) => this.handleScriptsRun(q, s) },
-    { method: "GET", pattern: "/api/status", handler: (q, s) => this.handleStatus(q, s) },
-    { method: "POST", pattern: "/api/watch/start", handler: (q, s) => this.handleWatchStart(q, s) },
-    { method: "POST", pattern: "/api/watch/stop", handler: (q, s) => this.handleWatchStop(q, s) },
-    { method: "GET", pattern: "/api/watch/events", handler: (q, s) => this.handleSSE(q, s) },
-    { method: "POST", pattern: "/api/scaffold", handler: (q, s) => this.handleScaffold(q, s) },
+    { method: "GET", pattern: "/api/providers", handler: (q, s2) => this.handleListProviders(q, s2) },
+    { method: "GET", pattern: "/api/providers/source-config", handler: (q, s2) => this.handleGetProviderSourceConfig(q, s2) },
+    { method: "POST", pattern: "/api/providers/source-config", handler: (q, s2) => this.handleSetProviderSourceConfig(q, s2) },
+    { method: "GET", pattern: "/api/providers/versions", handler: (q, s2) => this.handleDetectVersions(q, s2) },
+    { method: "POST", pattern: "/api/providers/reload", handler: (q, s2) => this.handleReload(q, s2) },
+    { method: "POST", pattern: "/api/cdp/evaluate", handler: (q, s2) => this.handleCdpEvaluate(q, s2) },
+    { method: "POST", pattern: "/api/cdp/click", handler: (q, s2) => this.handleCdpClick(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/query", handler: (q, s2) => this.handleCdpDomQuery(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/inspect", handler: (q, s2) => this.handleDomInspect(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/children", handler: (q, s2) => this.handleDomChildren(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/analyze", handler: (q, s2) => this.handleDomAnalyze(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/find-text", handler: (q, s2) => this.handleFindByText(q, s2) },
+    { method: "POST", pattern: "/api/cdp/dom/find-common", handler: (q, s2) => this.handleFindCommon(q, s2) },
+    { method: "GET", pattern: "/api/cdp/screenshot", handler: (q, s2) => this.handleScreenshot(q, s2) },
+    { method: "GET", pattern: "/api/cdp/targets", handler: (q, s2) => this.handleCdpTargets(q, s2) },
+    { method: "POST", pattern: "/api/scripts/run", handler: (q, s2) => this.handleScriptsRun(q, s2) },
+    { method: "GET", pattern: "/api/status", handler: (q, s2) => this.handleStatus(q, s2) },
+    { method: "POST", pattern: "/api/watch/start", handler: (q, s2) => this.handleWatchStart(q, s2) },
+    { method: "POST", pattern: "/api/watch/stop", handler: (q, s2) => this.handleWatchStop(q, s2) },
+    { method: "GET", pattern: "/api/watch/events", handler: (q, s2) => this.handleSSE(q, s2) },
+    { method: "POST", pattern: "/api/scaffold", handler: (q, s2) => this.handleScaffold(q, s2) },
     // CLI Debug routes
-    { method: "GET", pattern: "/api/cli/status", handler: (q, s) => this.handleCliStatus(q, s) },
-    { method: "POST", pattern: "/api/cli/launch", handler: (q, s) => this.handleCliLaunch(q, s) },
-    { method: "POST", pattern: "/api/cli/send", handler: (q, s) => this.handleCliSend(q, s) },
-    { method: "POST", pattern: "/api/cli/exercise", handler: (q, s) => this.handleCliExercise(q, s) },
-    { method: "POST", pattern: "/api/cli/fixture/capture", handler: (q, s) => this.handleCliFixtureCapture(q, s) },
-    { method: "POST", pattern: "/api/cli/fixture/replay", handler: (q, s) => this.handleCliFixtureReplay(q, s) },
-    { method: "POST", pattern: "/api/cli/resolve", handler: (q, s) => this.handleCliResolve(q, s) },
-    { method: "POST", pattern: "/api/cli/raw", handler: (q, s) => this.handleCliRaw(q, s) },
-    { method: "POST", pattern: "/api/cli/stop", handler: (q, s) => this.handleCliStop(q, s) },
-    { method: "GET", pattern: "/api/cli/events", handler: (q, s) => this.handleCliSSE(q, s) },
-    { method: "GET", pattern: /^\/api\/cli\/debug\/([^/]+)$/, handler: (q, s, p) => this.handleCliDebug(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/cli\/trace\/([^/]+)$/, handler: (q, s, p) => this.handleCliTrace(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/cli\/fixtures\/([^/]+)$/, handler: (q, s, p) => this.handleCliFixtureList(p[0], q, s) },
+    { method: "GET", pattern: "/api/cli/status", handler: (q, s2) => this.handleCliStatus(q, s2) },
+    { method: "POST", pattern: "/api/cli/launch", handler: (q, s2) => this.handleCliLaunch(q, s2) },
+    { method: "POST", pattern: "/api/cli/send", handler: (q, s2) => this.handleCliSend(q, s2) },
+    { method: "POST", pattern: "/api/cli/exercise", handler: (q, s2) => this.handleCliExercise(q, s2) },
+    { method: "POST", pattern: "/api/cli/fixture/capture", handler: (q, s2) => this.handleCliFixtureCapture(q, s2) },
+    { method: "POST", pattern: "/api/cli/fixture/replay", handler: (q, s2) => this.handleCliFixtureReplay(q, s2) },
+    { method: "POST", pattern: "/api/cli/resolve", handler: (q, s2) => this.handleCliResolve(q, s2) },
+    { method: "POST", pattern: "/api/cli/raw", handler: (q, s2) => this.handleCliRaw(q, s2) },
+    { method: "POST", pattern: "/api/cli/stop", handler: (q, s2) => this.handleCliStop(q, s2) },
+    { method: "GET", pattern: "/api/cli/events", handler: (q, s2) => this.handleCliSSE(q, s2) },
+    { method: "GET", pattern: /^\/api\/cli\/debug\/([^/]+)$/, handler: (q, s2, p) => this.handleCliDebug(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/cli\/trace\/([^/]+)$/, handler: (q, s2, p) => this.handleCliTrace(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/cli\/fixtures\/([^/]+)$/, handler: (q, s2, p) => this.handleCliFixtureList(p[0], q, s2) },
     // Dynamic routes (provider :type param)
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/script$/, handler: (q, s, p) => this.handleRunScript(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/files$/, handler: (q, s, p) => this.handleListFiles(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/file$/, handler: (q, s, p) => this.handleReadFile(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/file$/, handler: (q, s, p) => this.handleWriteFile(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/source$/, handler: (q, s, p) => this.handleSource(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/save$/, handler: (q, s, p) => this.handleSave(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/typeAndSend$/, handler: (q, s, p) => this.handleTypeAndSend(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/typeAndSendAt$/, handler: (q, s, p) => this.handleTypeAndSendAt(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/config$/, handler: (q, s, p) => this.handleProviderConfig(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/dom-context$/, handler: (q, s, p) => this.handleDomContext(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/auto-implement$/, handler: (q, s, p) => this.handleAutoImplement(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/auto-implement\/cancel$/, handler: (q, s, p) => this.handleAutoImplCancel(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/auto-implement\/status$/, handler: (q, s, p) => this.handleAutoImplSSE(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/spawn-test$/, handler: (q, s, p) => this.handleSpawnTest(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/validate$/, handler: (q, s, p) => this.handleValidate(p[0], q, s) },
-    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/acp-chat$/, handler: (q, s, p) => this.handleAcpChat(p[0], q, s) },
-    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/script-hints$/, handler: (q, s, p) => this.handleScriptHints(p[0], q, s) }
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/script$/, handler: (q, s2, p) => this.handleRunScript(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/files$/, handler: (q, s2, p) => this.handleListFiles(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/file$/, handler: (q, s2, p) => this.handleReadFile(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/file$/, handler: (q, s2, p) => this.handleWriteFile(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/source$/, handler: (q, s2, p) => this.handleSource(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/save$/, handler: (q, s2, p) => this.handleSave(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/typeAndSend$/, handler: (q, s2, p) => this.handleTypeAndSend(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/typeAndSendAt$/, handler: (q, s2, p) => this.handleTypeAndSendAt(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/config$/, handler: (q, s2, p) => this.handleProviderConfig(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/dom-context$/, handler: (q, s2, p) => this.handleDomContext(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/auto-implement$/, handler: (q, s2, p) => this.handleAutoImplement(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/auto-implement\/cancel$/, handler: (q, s2, p) => this.handleAutoImplCancel(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/auto-implement\/status$/, handler: (q, s2, p) => this.handleAutoImplSSE(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/spawn-test$/, handler: (q, s2, p) => this.handleSpawnTest(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/validate$/, handler: (q, s2, p) => this.handleValidate(p[0], q, s2) },
+    { method: "POST", pattern: /^\/api\/providers\/([^/]+)\/acp-chat$/, handler: (q, s2, p) => this.handleAcpChat(p[0], q, s2) },
+    { method: "GET", pattern: /^\/api\/providers\/([^/]+)\/script-hints$/, handler: (q, s2, p) => this.handleScriptHints(p[0], q, s2) }
   ];
   matchRoute(method, pathname) {
     for (const route of this.routes) {
@@ -58059,14 +58542,14 @@ var DevServer = class _DevServer {
       warnings.push(...validation.warnings);
       if (config.settings) {
         for (const [key, val] of Object.entries(config.settings)) {
-          const s = val;
-          if (!s.type) errors.push(`settings.${key}: missing type`);
-          else if (!["boolean", "number", "string", "select"].includes(s.type))
-            errors.push(`settings.${key}: invalid type '${s.type}'`);
-          if (s.default === void 0) warnings.push(`settings.${key}: no default value`);
-          if (s.type === "number" && s.min !== void 0 && s.max !== void 0 && s.min > s.max)
-            errors.push(`settings.${key}: min (${s.min}) > max (${s.max})`);
-          if (s.type === "select" && (!s.options || !Array.isArray(s.options) || s.options.length === 0))
+          const s2 = val;
+          if (!s2.type) errors.push(`settings.${key}: missing type`);
+          else if (!["boolean", "number", "string", "select"].includes(s2.type))
+            errors.push(`settings.${key}: invalid type '${s2.type}'`);
+          if (s2.default === void 0) warnings.push(`settings.${key}: no default value`);
+          if (s2.type === "number" && s2.min !== void 0 && s2.max !== void 0 && s2.min > s2.max)
+            errors.push(`settings.${key}: min (${s2.min}) > max (${s2.max})`);
+          if (s2.type === "select" && (!s2.options || !Array.isArray(s2.options) || s2.options.length === 0))
             errors.push(`settings.${key}: select type requires options[]`);
         }
       }