@adhdev/daemon-core 1.0.28-rc.15 → 1.0.28-rc.17

package/dist/index.mjs

@@ -786,10 +786,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "3c6684c9e2549bf7ab1508195857595a89ae9ec1" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "3c6684c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "1.0.28-rc.15" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-26T13:11:34.159Z" : void 0);
+  const commit = readInjected(true ? "9452bd039720355425e62fc7469808a0dda3ab80" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "9452bd03" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "1.0.28-rc.17" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-27T01:42:15.160Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -16439,6 +16439,31 @@ var init_debug_trace = __esm({
 function recordSynthCompletionGateTrace(stage, payload) {
   recordDebugTrace({ category: "completion-gate", stage, level: "debug", payload });
 }
+function evaluateTranscriptSynthAdmission(admission) {
+  if (!admission) return { admitted: true };
+  if (admission.trailingToolActivityAfterFinalAssistant === true) {
+    return { admitted: false, reason: "trailing_tool_activity_after_final_assistant" };
+  }
+  if (!admission.boundedBackstop && typeof admission.liveTurnPendingEvidence === "function") {
+    let pending = false;
+    try {
+      pending = admission.liveTurnPendingEvidence() === true;
+    } catch {
+    }
+    if (pending) return { admitted: false, reason: "live_turn_pending_evidence" };
+  }
+  return { admitted: true };
+}
+function resolveLiveTurnPendingEvidence(components, sessionId) {
+  try {
+    const instance = components?.instanceManager?.getInstance?.(sessionId);
+    if (typeof instance?.hasLiveTurnPendingEvidence !== "function") return void 0;
+    const probe = instance.hasLiveTurnPendingEvidence.bind(instance);
+    return () => probe();
+  } catch {
+    return void 0;
+  }
+}
 function findRecentTerminalLedgerEvidence(args) {
   if (!args.sessionId && !args.nodeId) return null;
   const entries = readLedgerEntries(args.meshId, { tail: 200 });
@@ -16559,6 +16584,17 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
   })) {
     return { reconciled: false, alreadyTerminal: true, reason: "terminal_ledger_entry_exists" };
   }
+  const admission = evaluateTranscriptSynthAdmission(args.causalAdmission);
+  if (!admission.admitted) {
+    LOG.info("MeshEvents", `Transcript synth vetoed for task ${args.taskId} session ${args.sessionId} (source ${args.source || "direct_task_transcript_reconciliation"}): ${admission.reason} \u2014 holding the completion; it re-evaluates on the next reconcile pass`);
+    recordSynthCompletionGateTrace("synth-veto", {
+      producer: "transcript_reconcile",
+      source: args.source || "direct_task_transcript_reconciliation",
+      taskId: args.taskId,
+      reason: admission.reason
+    });
+    return { reconciled: false, reason: admission.reason };
+  }
   const nodeId = readNonEmptyString(args.nodeId) || dispatch?.nodeId;
   const providerType = readNonEmptyString(args.providerType) || dispatch?.providerType || readNonEmptyString(dispatch?.payload.providerType);
   const completedAt = args.completedAt || (/* @__PURE__ */ new Date()).toISOString();
@@ -16720,6 +16756,7 @@ var init_mesh_events_stale = __esm({
     init_mesh_events_pending();
     init_mesh_events_utils();
     init_debug_trace();
+    init_logger();
     init_dist();
     DIRECT_DISPATCH_RECONCILE_GRACE_MS = 6e4;
     DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS = 12e4;
@@ -19751,6 +19788,9 @@ function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
 }
 function isLaunchableNode(node) {
   if (!node || node.status === "disabled" || node.status === "removed") return false;
+  if (shouldDeferDispatchForBootstrap(node)) {
+    return false;
+  }
   return isMeshNodeHealthLaunchable(node);
 }
 function isLocalAutoLaunchNode(node) {
@@ -22987,8 +23027,27 @@ function resolveActiveDirectDispatchTaskId(meshId, sessionId) {
     return void 0;
   }
 }
+function findInWindowUnclaimedAutoLaunchTask(meshId, sessionId, nowMs) {
+  return getQueue(meshId, { status: ["pending"] }).find((task) => {
+    const al = task.autoLaunch;
+    if (!al || al.status !== "completed" || !al.sessionId) return false;
+    if (!sessionIdsEquivalent(al.sessionId, sessionId)) return false;
+    const launchedAtMs = Date.parse(al.updatedAt);
+    return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+  });
+}
+function hasMatchingTaskDispatchedLedgerEntry(meshId, taskId, sessionId) {
+  const entries = readLedgerEntries(meshId, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.kind !== "task_dispatched") continue;
+    if (!sessionIdsEquivalent(entry.sessionId, sessionId)) continue;
+    if (readNonEmptyString(entry.payload?.taskId) === taskId) return true;
+  }
+  return false;
+}
 function evaluateMeshEventSuppression(args, ctx) {
-  const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId } = ctx;
+  const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components } = ctx;
   const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
     event: args.event,
     meshId: args.meshId,
@@ -23055,6 +23114,42 @@ function evaluateMeshEventSuppression(args, ctx) {
     }
   }
   if (args.event === "agent:generating_completed" && eventSessionId) {
+    const liveInstance = components.instanceManager?.getInstance?.(eventSessionId);
+    if (typeof liveInstance?.hasLiveTurnPendingEvidence === "function") {
+      let midTurnPending = false;
+      try {
+        midTurnPending = liveInstance.hasLiveTurnPendingEvidence() === true;
+      } catch {
+      }
+      if (midTurnPending) {
+        LOG.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): live adapter re-check shows the turn is still pending (mid-tool / streaming / modal) \u2014 treating as a premature/redraw-race emit; the adapter's own finalization retry or the reconcile loop's transcript evidence will surface the real completion`);
+        traceMeshEventDrop("mid_turn_live_state_pending", traceCtx);
+        return {
+          kind: "suppress",
+          result: { success: true, forwarded: 0, suppressed: true, midTurnLiveStatePending: true }
+        };
+      }
+    }
+    if (!readNonEmptyString(args.metadataEvent.taskId) && !sessionHasActiveAssignment(args.meshId, eventSessionId) && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || void 0 }) && isWeakCompletionEvidence(args.metadataEvent)) {
+      LOG.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): no taskId, no active assignment, and no prior terminal ledger evidence \u2014 a pre-dispatch startup/greeting artifact, not a real task completion`);
+      traceMeshEventDrop("no_dispatch_native_completion", traceCtx);
+      return {
+        kind: "suppress",
+        result: { success: true, forwarded: 0, suppressed: true, noDispatchNativeCompletion: true }
+      };
+    }
+    const inWindowTask = findInWindowUnclaimedAutoLaunchTask(args.meshId, eventSessionId, Date.now());
+    if (inWindowTask) {
+      const causalEvidence = MeshRuntimeStore.getInstance().taskDeliveryConsumed(args.meshId, inWindowTask.id) || hasMatchingTaskDispatchedLedgerEntry(args.meshId, inWindowTask.id, eventSessionId);
+      if (!causalEvidence) {
+        LOG.warn("MeshEvents", `Suppressed premature agent:generating_completed for auto-launch session ${eventSessionId} (mesh ${args.meshId}): task ${inWindowTask.id} delivery not yet consumed and no turn-start evidence \u2014 likely a boot artifact before the task was ever dispatched`);
+        traceMeshEventDrop("autolaunch_completion_before_causal_evidence", traceCtx, `taskId=${inWindowTask.id}`);
+        return {
+          kind: "suppress",
+          result: { success: true, forwarded: 0, suppressed: true, autoLaunchCausalGateFailed: true, taskId: inWindowTask.id }
+        };
+      }
+    }
     const terminal = findRecentTerminalLedgerEvidence({
       meshId: args.meshId,
       sessionId: eventSessionId,
@@ -23287,7 +23382,8 @@ function injectMeshSystemMessage(components, args) {
     eventSessionId,
     eventNodeId,
     eventTimestamp,
-    workerCoordinatorDaemonId
+    workerCoordinatorDaemonId,
+    components
   });
   if (suppression) {
     if (suppression.kind === "reconcile") {
@@ -24798,6 +24894,18 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     }
     const messages = Array.isArray(payload.messages) ? payload.messages : [];
     const evidence = extractFinalAssistantSummaryEvidence(messages);
+    if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
+      setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+      LOG.info("MeshReconcile", `Mid-turn causal admission: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 the latest final-looking assistant bubble is followed by trailing tool/terminal activity (interim narration; the turn is still executing); holding the transcript synth`);
+      traceMeshEventDrop("reconcile_synth_veto_trailing_tool_activity", {
+        taskId,
+        sessionId,
+        nodeId,
+        meshId: mesh.id,
+        event: "agent:generating_completed"
+      });
+      continue;
+    }
     if (isAcked) {
       const ackedAtMs = Date.parse(readNonEmptyString(dispatch.updatedAt));
       const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
@@ -24872,6 +24980,17 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         // The ledger-recovered dispatching-coordinator daemon (inside the reconcile fn)
         // takes PRIORITY over this arg; this remains the best-available fallback.
         ...coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {},
+        // MID-TURN-CAUSAL-ADMISSION (rc.16): pass the LOCAL live adapter's synchronous
+        // turn-state probe into the unified choke point — a pending verdict vetoes this
+        // eager synth (never-acked first-idle / acked fast-track). The death-deadline
+        // backstop is the bounded max-wait net and overrides the veto (genuine-final
+        // fail-open preserved); a remote/missing live source resolves to undefined and
+        // fails open onto the bounded transcript evidence above. The trailing-tool veto
+        // already ran at the top of this tick.
+        causalAdmission: {
+          liveTurnPendingEvidence: resolveLiveTurnPendingEvidence(components, sessionId),
+          boundedBackstop: backstopKind === "ackedHoldDeathDeadlineFired"
+        },
         source: "daemon_reconcile_transcript_completion"
       });
       if (result.reconciled) {
@@ -25317,10 +25436,10 @@ async function evaluateEarlyIdleTranscriptArm(components, mesh, store, row, loca
   if (profile) return profile.emitsPtyTurnEvents === false;
   return verdict === "UNKNOWN";
 }
-function propagateWatchdogTranscriptCompletion(meshId, row, evidence, source) {
+function propagateWatchdogTranscriptCompletion(components, meshId, row, evidence, source, opts) {
   const sessionId = readNonEmptyString(row.assignedSessionId) || evidence.sessionId;
   if (!sessionId || !readNonEmptyString(evidence.finalSummary)) {
-    return false;
+    return "unavailable";
   }
   try {
     const result = reconcileDirectDispatchCompletionFromTranscript({
@@ -25336,11 +25455,26 @@ function propagateWatchdogTranscriptCompletion(meshId, row, evidence, source) {
       // The watchdog poll already enforced idle + post-dispatch + no-trailing-tool + streak;
       // skip the reconcile's own grace/transcript_not_proven gates (dedup backstops remain).
       preValidatedTranscriptEvidence: true,
+      // MID-TURN-CAUSAL-ADMISSION (rc.16): the transcript poll's structural evidence can
+      // still straddle a genuinely mid-turn LOCAL worker (the incident shape: transcript
+      // reads idle-with-final-assistant while the raw PTY is mid-tool). Route the live
+      // adapter's synchronous probe through the unified choke point. The EARLY-IDLE
+      // caller is an eager path (no opts) → a pending verdict defers; the redrive-deadline
+      // caller passes boundedBackstop (the max-wait net) → the veto yields, preserving the
+      // genuine-final fail-open semantics.
+      causalAdmission: {
+        liveTurnPendingEvidence: resolveLiveTurnPendingEvidence(components, sessionId),
+        boundedBackstop: opts?.boundedBackstop === true
+      },
       source
     });
-    return result.reconciled || result.alreadyTerminal === true;
+    if (result.reconciled || result.alreadyTerminal === true) return "propagated";
+    if (result.reason === "live_turn_pending_evidence" || result.reason === "trailing_tool_activity_after_final_assistant") {
+      return "deferred";
+    }
+    return "unavailable";
   } catch {
-    return false;
+    return "unavailable";
   }
 }
 async function recoverStrandedAssignedDispatches(components, mesh, store, localDaemonId, selfIds = []) {
@@ -25374,14 +25508,28 @@ async function recoverStrandedAssignedDispatches(components, mesh, store, localD
           minFinalAssistantAgeMs: ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS
         });
         if (terminalEvidence) {
-          assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
-          updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
-          const propagated = propagateWatchdogTranscriptCompletion(
+          const propagation = propagateWatchdogTranscriptCompletion(
+            components,
             meshId,
             row,
             terminalEvidence,
             "early_idle_transcript_evidence"
           );
+          if (propagation === "deferred") {
+            assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+            LOG.info("MeshReconcile", `Deferred early transcript completion for task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}): the live adapter still reports the turn pending (mid-tool / streaming / modal) \u2014 holding; the completion re-evaluates next tick`);
+            traceMeshEventDrop("early_idle_completion_deferred_live_pending", {
+              taskId: row.id,
+              sessionId: row.assignedSessionId,
+              nodeId: row.assignedNodeId,
+              meshId,
+              event: "agent:generating_completed"
+            });
+            continue;
+          }
+          assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+          updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
+          const propagated = propagation === "propagated";
           if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
             try {
               appendLedgerEntry(meshId, {
@@ -25556,12 +25704,15 @@ async function recoverStrandedAssignedDispatches(components, mesh, store, localD
       if (terminalEvidence) {
         deliveredNoTurnUnknownStreak.delete(streakKey);
         updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
-        const propagated = propagateWatchdogTranscriptCompletion(
+        const propagation = propagateWatchdogTranscriptCompletion(
+          components,
           meshId,
           row,
           terminalEvidence,
-          "redrive_deadline_transcript_evidence"
+          "redrive_deadline_transcript_evidence",
+          { boundedBackstop: true }
         );
+        const propagated = propagation === "propagated";
         if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
           try {
             appendLedgerEntry(meshId, {
@@ -31100,7 +31251,9 @@ ${lastSnapshot}`;
             const requiredStreak = this.isAutonomousMeshSession() ? _ProviderCliAdapter.STATIC_IDLE_POLL_CONFIRM_COUNT : 1;
             this.staticIdlePollStreak += 1;
             if (this.staticIdlePollStreak >= requiredStreak) {
-              this.engine.confirmPollStaticIdle("poll_static_idle");
+              if (this.engine.confirmPollStaticIdle("poll_static_idle")) {
+                this.onStatusChange?.();
+              }
               this.staticIdlePollStreak = 0;
             }
           } else {
@@ -51121,6 +51274,50 @@ var CliProviderInstance = class _CliProviderInstance {
   isModalParked() {
     return this.resolveModalParkStatus() !== null;
   }
+  /**
+   * MID-TURN-LIVE-STATE-GATE (broader false-idle RCA, mid-turn follow-up): a live,
+   * synchronous re-check of whether this session's CURRENT turn genuinely still has
+   * unresolved work. Public wrapper so the coordinator (mesh-event-forwarding) can
+   * independently re-verify an incoming agent:generating_completed for a LOCAL session
+   * before trusting it — defense-in-depth against a race where the completion emit and the
+   * coordinator's receipt straddle a state change (screen-redraw parse artifact, decoupled-
+   * immediate emit). Reuses the EXACT same discriminators this instance's own finalization
+   * gate (getCompletedFinalizationBlock) uses — hasAdapterPendingResponse() (adapter
+   * isWaitingForResponse / currentTurnScope / isProcessing() / a non-empty partial response)
+   * OR isModalParked() (a live approval/choice modal) — so a session this method reports
+   * pending is, by construction, one the local finalization gate would also refuse to
+   * finalize right now.
+   *
+   * NATIVE-TRAILING-TOOL-GATE (rc.16 follow-up): the three adapter-state discriminators
+   * above are blind to a background shell tool that keeps a turn alive without the adapter
+   * reporting a pending response — e.g. a backgrounded `sleep 40 &` between narration
+   * bubbles on a write-lag native-source provider (claude-cli), which is deliberately
+   * un-floored (noExternalTranscriptSource omitted, mission f2f6da1b owner decision) so its
+   * transcript write-lag emits promptly. That un-flooring is correct for the ordinary
+   * fraction-of-a-second trail, but it also means the growth-hold / busy-lease protections
+   * in getCompletedFinalizationBlock never engage for claude-cli, so an interim final-
+   * LOOKING bubble followed by continuing tool calls can still finalize as a completion
+   * while the transcript demonstrably shows the turn still executing. Close that gap here,
+   * narrowly: for a native-source provider only, reuse the SAME bounded transcript read the
+   * class's own completion judgment already performs (probeNativeTranscriptSignals) and
+   * apply the SAME trailing-tool-activity veto the transcript-synth admission choke point
+   * uses (hasTrailingToolActivityAfterFinalAssistant) — the latest final-looking assistant
+   * bubble followed by tool/terminal activity is interim narration, not a turn end. Fail-open
+   * by construction: a non-native-source class (probe returns null), an unresolved
+   * transcript, or a read error never reaches the veto, so a missing/unavailable transcript
+   * can never wedge a session as "pending" forever.
+   */
+  hasLiveTurnPendingEvidence() {
+    if (this.hasAdapterPendingResponse() || this.isModalParked()) return true;
+    try {
+      const probe = this.probeNativeTranscriptSignals();
+      if (probe?.snapshot?.available === true && Array.isArray(probe.messages)) {
+        if (hasTrailingToolActivityAfterFinalAssistant(probe.messages)) return true;
+      }
+    } catch {
+    }
+    return false;
+  }
   /**
    * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh
    * reconcile loop must consult — the RAW adapter turn-state, with the
@@ -51611,7 +51808,8 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   completionFinalAssistantEvidence(parsedMessages, turnStartedAt) {
     const turnClosed = !this.hasAdapterPendingResponse();
-    if (this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
+    const preferNativeOverParsed = this.adapter?.chatMessagesOwnedExternally === true && this.busyLeaseGateEnabled();
+    if (!preferNativeOverParsed && this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
       return {
         present: turnClosed,
         messages: Array.isArray(parsedMessages) ? parsedMessages : [],
@@ -51621,7 +51819,8 @@ var CliProviderInstance = class _CliProviderInstance {
     const externalMessages = this.readExternalCompletionMessages();
     if (externalMessages) {
       const injectedTaskGenerating = this.injectedTaskHasStartedGenerating();
-      const present = injectedTaskGenerating && turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
+      const trailingToolActivity = hasTrailingToolActivityAfterFinalAssistant(externalMessages);
+      const present = injectedTaskGenerating && turnClosed && !trailingToolActivity && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
       const lastVisibleAssistant = this.lastVisibleAssistantSummaryDetail(externalMessages);
       if (lastVisibleAssistant.content) {
         this.lastCompletionSummary = { content: lastVisibleAssistant.content, receivedAt: Date.now(), sourceTimestampMs: lastVisibleAssistant.timestampMs };
@@ -51632,6 +51831,13 @@ var CliProviderInstance = class _CliProviderInstance {
         source: "external-native"
       };
     }
+    if (preferNativeOverParsed && this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
+      return {
+        present: turnClosed,
+        messages: Array.isArray(parsedMessages) ? parsedMessages : [],
+        source: "parsed"
+      };
+    }
     return {
       present: false,
       messages: Array.isArray(parsedMessages) ? parsedMessages : [],
@@ -51859,6 +52065,18 @@ var CliProviderInstance = class _CliProviderInstance {
       } catch {
       }
     }
+    if (adapterOwnsMessagesElsewhere && finalAssistantEvidence.source === "external-native" && this.busyLeaseGateEnabled()) {
+      try {
+        const snapshot = this.lastTranscriptSignalSnapshot;
+        const transcriptAgeMs = snapshot?.available === true && typeof snapshot.detail?.ageMs === "number" && Number.isFinite(snapshot.detail.ageMs) ? snapshot.detail.ageMs : void 0;
+        if (typeof transcriptAgeMs === "number") {
+          if (transcriptAgeMs < PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS) {
+            return { reason: "native_source_final_assistant_quiet_dwell", terminal: false };
+          }
+        }
+      } catch {
+      }
+    }
     return null;
   }
   // (FALSEIDLE-a) Positive, structural proof that the latest approval entry was resolved
@@ -52486,7 +52704,7 @@ var CliProviderInstance = class _CliProviderInstance {
       return;
     }
     const latestOutputAt = typeof latestStatus?.lastOutputAt === "number" ? latestStatus.lastOutputAt : void 0;
-    if (typeof pending.lastOutputAtArm === "number" && typeof latestOutputAt === "number" && latestOutputAt > pending.lastOutputAtArm) {
+    if (!pending.loggedBlockReason && typeof pending.lastOutputAtArm === "number" && typeof latestOutputAt === "number" && latestOutputAt > pending.lastOutputAtArm) {
       LOG.info("CLI", `[${this.type}] cancelled pending completed (new PTY output during settle: ${pending.lastOutputAtArm}\u2192${latestOutputAt})`);
       if (this.completionTraceOn()) this.recordCompletionGateTrace("cancel", {
         blockReason: "new_pty_output",
@@ -56480,6 +56698,7 @@ init_state_store();
 init_recent_activity();
 init_chat_history();
 init_mesh_events_utils();
+init_mesh_queue_assignment();
 init_logger();
 async function forwardConversationPrefsToCoordinator(ctx, sessionId, patch) {
   const dispatch = ctx.deps.dispatchMeshCommand;
@@ -56594,8 +56813,8 @@ var cliAgentHandlers = {
     };
   },
   agent_command: async (ctx, args) => {
+    const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
     {
-      const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
       const dispatchMeshContext = args?.meshContext;
       if (dispatchSessionId && dispatchMeshContext) {
         try {
@@ -56629,18 +56848,23 @@ var cliAgentHandlers = {
         const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
         const { shouldDeferDispatchForBootstrap: shouldDeferDispatchForBootstrap2 } = await Promise.resolve().then(() => (init_worktree_bootstrap_config(), worktree_bootstrap_config_exports));
         if (shouldDeferDispatchForBootstrap2(nodeObj)) {
-          return {
-            success: false,
-            recoverable: true,
-            dispatched: false,
-            code: "mesh_node_bootstrap_pending",
-            reason: "bootstrap_still_running",
-            nodeId: dispatchNodeId,
-            meshId: dispatchMeshId,
-            ...readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {},
-            error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
-            nextAction: "Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available."
-          };
+          const dispatchSessionState = dispatchSessionId ? ctx.deps.instanceManager?.getInstance?.(dispatchSessionId)?.getState?.() : void 0;
+          const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState(dispatchSessionState);
+          if (!sessionConfirmedReady) {
+            return {
+              success: false,
+              recoverable: true,
+              dispatched: false,
+              code: "mesh_node_bootstrap_pending",
+              reason: "bootstrap_still_running",
+              nodeId: dispatchNodeId,
+              meshId: dispatchMeshId,
+              ...readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {},
+              error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+              nextAction: "Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available."
+            };
+          }
+          LOG.info("MeshQueue", `Overriding stale worktreeBootstrap 'running' flag for node ${dispatchNodeId}: explicit target session ${dispatchSessionId} is independently confirmed idle/ready \u2014 dispatching mesh_send_task directly.`);
         }
       } catch {
       }
@@ -78316,6 +78540,7 @@ export {
   handleGitCommand,
   hasCdpManager,
   hasPendingDependents,
+  hasTrailingToolActivityAfterFinalAssistant,
   hashSignatureParts,
   initDaemonComponents,
   insertDirectDispatch,