@adhdev/daemon-standalone 0.9.82-rc.253 → 0.9.82-rc.254

package/dist/index.js

@@ -32404,6 +32404,30 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       updateTaskStatus: () => updateTaskStatus,
       validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
     });
+    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();
@@ -32417,7 +32441,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       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,
@@ -32744,6 +32772,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     var HISTORICAL_MESH_QUEUE_STATUSES;
     var MESH_TASK_MODES;
     var LIVE_DEBUG_READONLY_FORBIDDEN;
+    var GIT_MUTATION_SUBCOMMANDS;
+    var GIT_STASH_READONLY_SUBCOMMANDS;
     var DEPENDENCY_FAILURE_TERMINALS;
     var init_mesh_work_queue = __esm2({
       "src/mesh/mesh-work-queue.ts"() {
@@ -32757,13 +32787,35 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         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"]);
       }
     });
@@ -35593,12 +35645,11 @@ Next step: ${nextStep}`;
     }
     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 {
@@ -36587,7 +36638,15 @@ Next step: ${nextStep}`;
       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) => {
@@ -36954,6 +37013,9 @@ Next step: ${nextStep}`;
     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);
@@ -37344,10 +37406,14 @@ Next step: ${nextStep}`;
       })) {
         LOG2.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();
-        LOG2.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
-        coord.onEvent("send_message", { input: { text: messageText, textFallback: messageText } });
+        LOG2.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 };
     }
@@ -37400,6 +37466,45 @@ Next step: ${nextStep}`;
     }
     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(loadConfig2().machineId) || void 0;
+                    const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId2, localDaemonId);
+                    if (pendingEvents.length > 0) {
+                      LOG2.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) {
+                    LOG2.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;
@@ -37438,31 +37543,6 @@ Next step: ${nextStep}`;
           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(loadConfig2().machineId) || void 0;
-          const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
-          if (pendingEvents.length === 0) return;
-          LOG2.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) {
-          LOG2.warn("MeshEvents", `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
-        }
-      });
     }
     var import_fs10;
     var REMOTE_IDLE_SESSION_TTL_MS;
@@ -37477,6 +37557,7 @@ Next step: ${nextStep}`;
     var AUTO_LAUNCH_COOLDOWN_MS;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
+    var MESH_FORCE_INJECT_EVENTS;
     var init_mesh_events_coordinator = __esm2({
       "src/mesh/mesh-events-coordinator.ts"() {
         "use strict";
@@ -37522,6 +37603,15 @@ Next step: ${nextStep}`;
           "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"
+        ]);
       }
     });
     var mesh_events_exports = {};
@@ -58303,7 +58393,12 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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
         };
@@ -59400,20 +59495,18 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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 };
@@ -60126,7 +60219,6 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       runtimeMessages = [];
       lastPersistedHistoryMessages = [];
       lastAcknowledgedUserInputAt = 0;
-      externalBusyIdleFingerprint = "";
       lastNativeSourceCanonicalCheckAt = 0;
       lastNativeSourceCanonicalCacheKey = void 0;
       cachedSqliteDb = null;
@@ -60257,10 +60349,6 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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";
         }
@@ -60493,7 +60581,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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) => {
               LOG2.warn("CLI", `[${this.type}] send_message failed: ${e?.message || e}`);
             });
           }
@@ -60538,7 +60627,6 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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",
@@ -60687,50 +60775,6 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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;
@@ -60801,18 +60845,17 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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 partial2 = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
-        if (!externalNativeFinal && typeof partial2 === "string" && partial2.trim()) return { reason: "partial_response_pending", terminal: true };
+        if (typeof partial2 === "string" && partial2.trim()) return { reason: "partial_response_pending", terminal: true };
         let parsed;
         try {
           parsed = this.adapter.getScriptParsedStatus();
@@ -60822,7 +60865,6 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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) };
         }
@@ -60884,16 +60926,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         }
         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;
-        LOG2.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;
+        LOG2.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") {
           LOG2.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;
@@ -60935,18 +60976,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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;
@@ -61002,9 +61032,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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 partial2 = this.adapter.getPartialResponse();
@@ -69101,16 +69130,26 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         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 {
         ...cached2,
         ...incoming,
@@ -73522,7 +73561,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);
@@ -73573,6 +73612,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) => {