@adhdev/daemon-core 0.9.82-rc.253 → 0.9.82-rc.255

package/dist/index.mjs

@@ -2666,6 +2666,30 @@ __export(mesh_work_queue_exports, {
   validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
 });
 import { randomUUID as randomUUID5 } from "crypto";
+function detectGitMutation(message) {
+  const re = /\bgit\s+([a-z][a-z0-9-]*)/gi;
+  let match;
+  while ((match = re.exec(message)) !== null) {
+    const sub = match[1].toLowerCase();
+    if (GIT_MUTATION_SUBCOMMANDS.has(sub)) return true;
+    if (sub === "stash") {
+      const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+      const next = after ? after[1].toLowerCase() : "";
+      if (!GIT_STASH_READONLY_SUBCOMMANDS.has(next)) return true;
+    } else if (sub === "checkout") {
+      return true;
+    } else if (sub === "submodule") {
+      const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+      const next = after ? after[1].toLowerCase() : "";
+      if (next === "update" || next === "add" || next === "sync" || next === "deinit") return true;
+    } else if (sub === "worktree") {
+      const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+      const next = after ? after[1].toLowerCase() : "";
+      if (next === "add" || next === "remove" || next === "move" || next === "prune") return true;
+    }
+  }
+  return false;
+}
 function normalizeMeshTaskMode(value) {
   if (typeof value !== "string") return void 0;
   const normalized = value.trim();
@@ -2679,7 +2703,11 @@ function validateMeshTaskModeRequest(mode, message) {
   if (taskMode !== "live_debug_readonly") {
     return { valid: true, taskMode, violations: [] };
   }
-  const violations = LIVE_DEBUG_READONLY_FORBIDDEN.filter((rule) => rule.pattern.test(message || "")).map((rule) => rule.label);
+  const text = message || "";
+  const violations = LIVE_DEBUG_READONLY_FORBIDDEN.filter((rule) => rule.pattern.test(text)).map((rule) => rule.label);
+  if (detectGitMutation(text)) {
+    violations.push("git_mutation");
+  }
   return {
     valid: violations.length === 0,
     taskMode,
@@ -3001,7 +3029,7 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN, DEPENDENCY_FAILURE_TERMINALS;
+var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -3013,13 +3041,35 @@ var init_mesh_work_queue = __esm({
     MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
     LIVE_DEBUG_READONLY_FORBIDDEN = [
       { label: "source_edit", pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
-      { label: "git_mutation", pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv|stash|worktree\s+(?:add|remove|move))|push\b)/i },
       { label: "checkpoint", pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
       { label: "deploy_or_version_bump", pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release|npm\s+publish|yarn\s+publish|pnpm\s+publish)\b/i },
       { label: "destructive_shell", pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i|shred\b)\b/i },
       { label: "package_install", pattern: /\b(npm\s+(?:install|i|add|link|uninstall|remove)|yarn\s+(?:add|remove|link)|pnpm\s+(?:add|remove|link)|pip\s+install|brew\s+install|apt\s+install|cargo\s+install)\b/i },
       { label: "container_mutation", pattern: /\b(docker\s+(?:build|run|exec|push|tag|rmi|rm|create|start|stop|kill)|kubectl\s+(?:apply|delete|patch|replace|create|scale))\b/i }
     ];
+    GIT_MUTATION_SUBCOMMANDS = /* @__PURE__ */ new Set([
+      "add",
+      "commit",
+      "push",
+      "reset",
+      "rebase",
+      "clean",
+      "switch",
+      "merge",
+      "tag",
+      "restore",
+      "rm",
+      "mv",
+      "cherry-pick",
+      "revert",
+      "pull",
+      "fetch",
+      "am",
+      "apply",
+      "gc",
+      "prune"
+    ]);
+    GIT_STASH_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show"]);
     DEPENDENCY_FAILURE_TERMINALS = /* @__PURE__ */ new Set(["failed", "cancelled"]);
   }
 });
@@ -5836,12 +5886,11 @@ function refineTerminalEventFromLedger(meshId, pending) {
 }
 function reconcilePendingMeshCoordinatorEvents(meshId, events) {
   const backfilled = refineTerminalEventFromLedger(meshId, events);
-  if (backfilled.length === 0) return events;
-  const terminalJobIds = new Set(backfilled.map((event) => readRefineJobId2(event)).filter(Boolean));
-  return [
-    ...events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event)))),
-    ...backfilled
-  ];
+  const terminalJobIds = new Set(
+    [...events.filter((event) => REFINE_TERMINAL_EVENTS.has(event.event)), ...backfilled].map((event) => readRefineJobId2(event)).filter(Boolean)
+  );
+  const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
+  return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
 function trimPendingEventsIfNeeded(path39) {
   try {
@@ -6824,7 +6873,15 @@ function nodeHasActiveAssignment(meshId, nodeId) {
   return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
 }
 function sessionHasActiveAssignment(meshId, sessionId) {
-  return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId);
+  if (getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId)) {
+    return true;
+  }
+  try {
+    if (getActiveDirectDispatches(meshId).some((d) => d.sessionId === sessionId)) return true;
+    if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
+  } catch {
+  }
+  return false;
 }
 function liveSessionCountForNode(components, meshId, nodeId) {
   return components.instanceManager.getByCategory("cli").filter((inst) => {
@@ -7191,6 +7248,9 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
 function isMeshCoordinatorEvent(eventName) {
   return typeof eventName === "string" && MESH_COORDINATOR_EVENTS.has(eventName);
 }
+function shouldForceInjectMeshEvent(eventName) {
+  return typeof eventName === "string" && MESH_FORCE_INJECT_EVENTS.has(eventName);
+}
 function injectMeshSystemMessage(components, args) {
   const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
@@ -7581,10 +7641,14 @@ function injectMeshSystemMessage(components, args) {
   })) {
     LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
   }
+  const forceInject = shouldForceInjectMeshEvent(args.event);
   for (const coord of coordinatorInstances) {
     const coordState = coord.getState();
-    LOG.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
-    coord.onEvent("send_message", { input: { text: messageText, textFallback: messageText } });
+    LOG.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? " (force)" : ""}`);
+    coord.onEvent("send_message", {
+      input: { text: messageText, textFallback: messageText },
+      ...forceInject ? { force: true } : {}
+    });
   }
   return { success: true, forwarded: coordinatorInstances.length };
 }
@@ -7637,6 +7701,45 @@ function handleMeshForwardEvent(components, payload) {
 }
 function setupMeshEventForwarding(components) {
   components.instanceManager.onEvent((event) => {
+    if (event.event === "agent:ready" || event.event === "agent:generating_completed") {
+      const flushInstanceId = readNonEmptyString2(event.instanceId);
+      if (flushInstanceId) {
+        const flushSource = components.instanceManager.getInstance(flushInstanceId);
+        if (flushSource && flushSource.category === "cli") {
+          const flushState = flushSource.getState();
+          const flushSettings = flushState.settings && typeof flushState.settings === "object" ? flushState.settings : {};
+          const coordinatorMeshId2 = readNonEmptyString2(flushSettings.meshCoordinatorFor);
+          if (coordinatorMeshId2) {
+            const status = readNonEmptyString2(flushState.status).toLowerCase();
+            if (status === "idle") {
+              try {
+                const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
+                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId2, localDaemonId);
+                if (pendingEvents.length > 0) {
+                  LOG.info("MeshEvents", `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId2} on coordinator idle`);
+                  for (const pending of pendingEvents) {
+                    if (!pending.coordinatorMessage) continue;
+                    const forcePending = shouldForceInjectMeshEvent(pending.event);
+                    flushSource.onEvent("send_message", {
+                      input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+                      ...forcePending ? { force: true } : {}
+                    });
+                  }
+                }
+              } catch (e) {
+                LOG.warn("MeshEvents", `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
+              }
+            }
+            let hasDirectDispatch = false;
+            try {
+              hasDirectDispatch = getActiveDirectDispatches(coordinatorMeshId2).some((d) => d.sessionId === flushInstanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId2, flushInstanceId);
+            } catch {
+            }
+            if (!hasDirectDispatch) return;
+          }
+        }
+      }
+    }
     if (!isMeshCoordinatorEvent(event.event)) return;
     const instanceId = readNonEmptyString2(event.instanceId);
     if (!instanceId) return;
@@ -7675,33 +7778,8 @@ function setupMeshEventForwarding(components) {
       metadataEvent: event
     });
   });
-  components.instanceManager.onEvent((event) => {
-    if (event.event !== "agent:ready" && event.event !== "agent:generating_completed") return;
-    const instanceId = readNonEmptyString2(event.instanceId);
-    if (!instanceId) return;
-    const sourceInstance = components.instanceManager.getInstance(instanceId);
-    if (!sourceInstance || sourceInstance.category !== "cli") return;
-    const state = sourceInstance.getState();
-    const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
-    const coordinatorMeshId = readNonEmptyString2(settings.meshCoordinatorFor);
-    if (!coordinatorMeshId) return;
-    const status = readNonEmptyString2(state.status).toLowerCase();
-    if (status !== "idle") return;
-    try {
-      const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
-      const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
-      if (pendingEvents.length === 0) return;
-      LOG.info("MeshEvents", `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
-      for (const pending of pendingEvents) {
-        if (!pending.coordinatorMessage) continue;
-        sourceInstance.onEvent("send_message", { input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage } });
-      }
-    } catch (e) {
-      LOG.warn("MeshEvents", `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
-    }
-  });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
@@ -7746,6 +7824,15 @@ var init_mesh_events_coordinator = __esm({
       "agent:stopped": "task_failed",
       "monitor:long_generating": "task_stalled"
     };
+    MESH_FORCE_INJECT_EVENTS = /* @__PURE__ */ new Set([
+      "agent:generating_completed",
+      "agent:stopped",
+      "agent:waiting_approval",
+      "refine:completed",
+      "refine:failed",
+      "worktree_bootstrap_complete",
+      "worktree_bootstrap_failed"
+    ]);
   }
 });
 
@@ -28365,7 +28452,12 @@ var FsmDriver = class {
     const controls = this.deriveControls(state.id);
     const title = modal?.title ?? this.deriveTitle(state, sections, lines.join("\n"));
     const next = {
-      state: { id: state.id, label: state.label, title },
+      // status is derived from the FSM state itself (statusForState), NOT from
+      // whether a modal was parsed this frame. A modal state whose buttons briefly
+      // fail to parse (PTY repaint → deriveModal returns null) must still report
+      // its authoritative status (e.g. 'approval'), so the adapter never collapses
+      // an approval/busy state to idle on a transient modal-parse miss.
+      state: { id: state.id, label: state.label, title, status: statusForState(state) },
       modal,
       controls
     };
@@ -29466,20 +29558,18 @@ var SpecCliAdapter = class {
     const state = this.latestState;
     if (!state) return { status: "starting", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
     const modal = this.latestModal;
-    const lc = state.id.toLowerCase();
-    if (modal) {
+    if (state.status === "approval") {
       return {
         status: "waiting_approval",
         messages: [],
-        activeModal: {
-          message: modal.title ?? state.label,
-          buttons: modal.buttons.map((b) => b.label)
-        },
+        // Surface buttons when we have them; an approval state with no parsed
+        // modal this frame still stays waiting_approval (no activeModal yet).
+        activeModal: modal ? { message: modal.title ?? state.label, buttons: modal.buttons.map((b) => b.label) } : null,
         activeInteractivePrompt: this.activeInteractivePrompt,
         ...sessionFields
       };
     }
-    if (lc === "busy" || lc === "generating") {
+    if (state.status === "generating") {
       return { status: "generating", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
     }
     return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
@@ -30200,7 +30290,6 @@ var CliProviderInstance = class {
   runtimeMessages = [];
   lastPersistedHistoryMessages = [];
   lastAcknowledgedUserInputAt = 0;
-  externalBusyIdleFingerprint = "";
   lastNativeSourceCanonicalCheckAt = 0;
   lastNativeSourceCanonicalCacheKey = void 0;
   cachedSqliteDb = null;
@@ -30331,10 +30420,6 @@ var CliProviderInstance = class {
     const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
     const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === "idle";
     let visibleStatus = parseErrorMessage || parsedStatus?.status === "error" ? "error" : autoApproveActive || autoApproveHoldIdle ? "generating" : adapterStatus.status;
-    const externalNativeFinal = this.getExternalNativeFinalReconciliation(parsedStatus?.messages, adapterStatus);
-    if (externalNativeFinal && isCliGeneratingLikeStatus(visibleStatus)) {
-      visibleStatus = "idle";
-    }
     if (isCliGeneratingLikeStatus(visibleStatus) && this.lastStatus === "idle") {
       visibleStatus = "idle";
     }
@@ -30567,7 +30652,8 @@ var CliProviderInstance = class {
       assertProviderSupportsDeclaredInput(this.provider, input);
       const promptText = buildCliStructuredInputPrompt(input);
       if (promptText) {
-        void this.adapter.sendMessage(promptText).catch((e) => {
+        const force = data?.force === true;
+        void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e) => {
           LOG.warn("CLI", `[${this.type}] send_message failed: ${e?.message || e}`);
         });
       }
@@ -30612,7 +30698,6 @@ var CliProviderInstance = class {
     if (!content) return;
     const receivedAt = Date.now();
     this.lastAcknowledgedUserInputAt = receivedAt;
-    this.externalBusyIdleFingerprint = "";
     const dedupKey = `user_input_ack:${crypto4.createHash("sha256").update(`${this.instanceId}:${content}:${receivedAt}`).digest("hex").slice(0, 24)}`;
     this.appendRuntimeMessage(buildChatMessage({
       role: "user",
@@ -30761,50 +30846,6 @@ var CliProviderInstance = class {
     const evidence = this.completionFinalAssistantEvidence(parsedMessages);
     return extractFinalSummaryFromMessages(evidence.messages);
   }
-  externalNativeFinalFingerprint(evidence) {
-    const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
-    const visibleMessages = messages.filter((message) => isUserFacingChatMessage(message));
-    const lastVisible = visibleMessages[visibleMessages.length - 1];
-    const content = lastVisible ? flattenContent(lastVisible.content).trim() : "";
-    const receivedAt = lastVisible ? getMessageTime(lastVisible) : 0;
-    const probe = this.lastExternalCompletionProbe;
-    return crypto4.createHash("sha256").update([
-      this.type,
-      this.providerSessionId || "",
-      probe?.sourcePath || "",
-      String(probe?.sourceMtimeMs || 0),
-      String(receivedAt || 0),
-      content.slice(-500)
-    ].join("\0")).digest("hex").slice(0, 24);
-  }
-  getExternalNativeFinalReconciliation(parsedMessages, adapterStatus) {
-    const rawStatus = typeof adapterStatus?.status === "string" ? adapterStatus.status.trim() : "";
-    if (!isCliGeneratingLikeStatus(rawStatus)) return null;
-    if (hasNonEmptyCliModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal)) return null;
-    const evidence = this.completionFinalAssistantEvidence(parsedMessages);
-    if (evidence.source !== "external-native" || !evidence.present) return null;
-    const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
-    const visibleMessages = messages.filter((message) => isUserFacingChatMessage(message));
-    const lastVisible = visibleMessages[visibleMessages.length - 1];
-    const lastMessageAt = lastVisible ? getMessageTime(lastVisible) : 0;
-    const sourceMtimeMs = Number(this.lastExternalCompletionProbe?.sourceMtimeMs || 0);
-    const minEvidenceAt = Math.max(
-      this.startedAt > 0 ? this.startedAt - 5e3 : 0,
-      this.generatingStartedAt > 0 ? this.generatingStartedAt - 5e3 : 0,
-      this.lastAcknowledgedUserInputAt > 0 ? this.lastAcknowledgedUserInputAt - 1e3 : 0
-    );
-    if (minEvidenceAt > 0 && lastMessageAt > 0 && lastMessageAt < minEvidenceAt && sourceMtimeMs < minEvidenceAt) {
-      return null;
-    }
-    const finalSummary = extractFinalSummaryFromMessages(evidence.messages);
-    if (!finalSummary) return null;
-    const fingerprint = this.externalNativeFinalFingerprint(evidence);
-    if (fingerprint === this.externalBusyIdleFingerprint) {
-      return { fingerprint, finalSummary, evidence };
-    }
-    this.externalBusyIdleFingerprint = fingerprint;
-    return { fingerprint, finalSummary, evidence };
-  }
   buildCompletedFinalizationDiagnostic(args) {
     let parsed = null;
     let parseError;
@@ -30875,18 +30916,17 @@ var CliProviderInstance = class {
     if (typeof adapterAny?.responseBuffer === "string" && adapterAny.responseBuffer.trim()) return false;
     return true;
   }
-  getCompletedFinalizationBlock(latestVisibleStatus, pending, opts) {
+  getCompletedFinalizationBlock(latestVisibleStatus, pending) {
     if (latestVisibleStatus !== "idle") return { reason: `status:${latestVisibleStatus}`, terminal: true };
     const adapterAny = this.adapter;
     const approvalResolvedIdle = pending.previousStatus === "waiting_approval";
-    const externalNativeFinal = opts?.externalNativeFinal || null;
-    if (!approvalResolvedIdle && !externalNativeFinal) {
+    if (!approvalResolvedIdle) {
       if (adapterAny?.isWaitingForResponse === true) return { reason: "adapter_waiting_for_response", terminal: true };
       if (adapterAny?.currentTurnScope) return { reason: "adapter_turn_scope_active", terminal: true };
       if (this.hasAdapterPendingResponse()) return { reason: "adapter_pending_response", terminal: true };
     }
     const partial = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
-    if (!externalNativeFinal && typeof partial === "string" && partial.trim()) return { reason: "partial_response_pending", terminal: true };
+    if (typeof partial === "string" && partial.trim()) return { reason: "partial_response_pending", terminal: true };
     let parsed;
     try {
       parsed = this.adapter.getScriptParsedStatus();
@@ -30896,7 +30936,6 @@ var CliProviderInstance = class {
     const parsedStatus = typeof parsed?.status === "string" ? parsed.status : "unknown";
     if (parsedStatus !== "idle") {
       const adapterStatus = this.adapter.getStatus({ allowParse: false });
-      if (externalNativeFinal && isCliGeneratingLikeStatus(parsedStatus)) return null;
       if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
       return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
     }
@@ -30904,6 +30943,20 @@ var CliProviderInstance = class {
     const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
     const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
     const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+    if (adapterOwnsMessagesElsewhere && finalAssistantEvidence.source === "external-native") {
+      const prevProbe = (pending.transcriptProbeHistory || [])[(pending.transcriptProbeHistory?.length ?? 0) - 1];
+      this.readExternalCompletionMessages();
+      const settleProbe = this.lastExternalCompletionProbe;
+      if (settleProbe && prevProbe) {
+        const stillGrowing = settleProbe.msgCount > prevProbe.msgCount || settleProbe.lastRole === "assistant" && settleProbe.contentLen > prevProbe.contentLen;
+        if (stillGrowing) {
+          this.recordPendingTranscriptProbe(pending);
+          return { reason: `transcript_settling:${prevProbe.contentLen}->${settleProbe.contentLen}`, terminal: false };
+        }
+      } else if (settleProbe) {
+        this.recordPendingTranscriptProbe(pending);
+      }
+    }
     LOG.debug("CLI", `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
     if (!finalAssistantEvidence.present) {
       if (adapterOwnsMessagesElsewhere) {
@@ -30958,16 +31011,15 @@ var CliProviderInstance = class {
     }
     const latestStatus = this.adapter.getStatus({ allowParse: false });
     const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
-    const externalNativeFinal = this.getExternalNativeFinalReconciliation(void 0, latestStatus);
-    const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status) ? "idle" : latestAutoApproveActive || this.autoApproveBusy ? "generating" : latestStatus.status;
-    LOG.debug("CLI", `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} externalNativeFinal=${!!externalNativeFinal} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!this.adapter?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
+    const latestVisibleStatus = latestAutoApproveActive || this.autoApproveBusy ? "generating" : latestStatus.status;
+    LOG.debug("CLI", `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!this.adapter?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
     if (latestVisibleStatus !== "idle") {
       LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
       this.completedDebouncePending = null;
       this.completedDebounceTimer = null;
       return;
     }
-    const block2 = this.getCompletedFinalizationBlock(latestVisibleStatus, pending, { externalNativeFinal });
+    const block2 = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
     if (block2) {
       const blockReason = block2.reason;
       const waitedMs = Date.now() - pending.firstObservedAt;
@@ -31009,18 +31061,7 @@ var CliProviderInstance = class {
       chatTitle: pending.chatTitle,
       duration: pending.duration,
       timestamp: pending.timestamp,
-      finalSummary: externalNativeFinal?.finalSummary || this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
-      ...externalNativeFinal ? {
-        completionDiagnostic: {
-          providerType: this.type,
-          sessionId: this.instanceId,
-          providerSessionId: this.providerSessionId || null,
-          reconciliationReason: "external_native_final_assistant_while_adapter_busy",
-          finalAssistantPresent: true,
-          finalAssistantEvidenceSource: externalNativeFinal.evidence.source,
-          externalFinalFingerprint: externalNativeFinal.fingerprint
-        }
-      } : {}
+      finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages)
     });
     this.completedDebouncePending = null;
     this.completedDebounceTimer = null;
@@ -31076,9 +31117,8 @@ var CliProviderInstance = class {
     const parsedStatus = null;
     const rawStatus = adapterStatus.status;
     const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
-    const externalNativeFinal = this.getExternalNativeFinalReconciliation(void 0, adapterStatus);
     const autoApproveHoldIdle = this.autoApproveBusy && rawStatus === "idle";
-    const newStatus = externalNativeFinal && isCliGeneratingLikeStatus(rawStatus) ? "idle" : autoApproveActive || autoApproveHoldIdle ? "generating" : rawStatus;
+    const newStatus = autoApproveActive || autoApproveHoldIdle ? "generating" : rawStatus;
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
     const partial = this.adapter.getPartialResponse();
@@ -39230,16 +39270,26 @@ function reconcileInlineMeshCache(cached, incoming) {
     const nodeId = readInlineMeshNodeId(node);
     if (nodeId) cachedById.set(nodeId, node);
   }
+  const mergedIncomingIds = /* @__PURE__ */ new Set();
   const nodes = incomingNodes.map((incomingNode) => {
     const nodeId = readInlineMeshNodeId(incomingNode);
     const cachedNode = nodeId ? cachedById.get(nodeId) : void 0;
     if (!cachedNode && preserveCachedMembership) return null;
+    if (nodeId) mergedIncomingIds.add(nodeId);
     if (!cachedNode) return incomingNode;
     if (hasInlineMeshTransientNodeState(incomingNode)) {
       return { ...cachedNode, ...incomingNode };
     }
     return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
   }).filter(Boolean);
+  if (preserveCachedMembership) {
+    for (const cachedNode of cachedNodes) {
+      const nodeId = readInlineMeshNodeId(cachedNode);
+      if (nodeId && !mergedIncomingIds.has(nodeId)) {
+        nodes.push(cachedNode);
+      }
+    }
+  }
   return {
     ...cached,
     ...incoming,
@@ -42154,6 +42204,18 @@ ${tail}` : ""
         return { success: true };
       }
       case "launch_cli": {
+        {
+          const launchSettings = args?.settings && typeof args.settings === "object" ? args.settings : void 0;
+          const isMeshWorkerLaunch = !!launchSettings && (readStringValue(launchSettings.meshNodeFor) || launchSettings.launchedByCoordinator === true);
+          const hasCoordinatorDaemonId = !!launchSettings && !!readStringValue(launchSettings.meshCoordinatorDaemonId);
+          if (launchSettings && isMeshWorkerLaunch && !hasCoordinatorDaemonId) {
+            try {
+              const localDaemonId = readStringValue(loadConfig().machineId);
+              if (localDaemonId) launchSettings.meshCoordinatorDaemonId = localDaemonId;
+            } catch {
+            }
+          }
+        }
         const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
         const meshNodeId = readStringValue(args?.settings?.meshNodeId);
         const meshId = readStringValue(args?.settings?.meshNodeFor);
@@ -43651,7 +43713,7 @@ ${tail}` : ""
         const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "worktree clone");
         if (ownerFailure) return ownerFailure;
         try {
-          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
           const sourceNode = mesh.nodes?.find((n) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
@@ -43702,6 +43764,8 @@ ${tail}` : ""
               policy: { ...sourceNode.policy || {} }
             });
             if (!node) return { success: false, error: "Failed to register worktree node" };
+            const inlineForReconcile = this.getCachedInlineMesh(meshId);
+            if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
             this.invalidateAggregateMeshStatus(meshId);
           }
           const persistWorktreeSetupState = async (bootstrapState2) => {