@adhdev/daemon-standalone 0.9.82-rc.385 → 0.9.82-rc.387

package/dist/index.js

@@ -30108,10 +30108,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "3aa3e12839017da30b44a64ca6c20f0c9730fae2" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "3aa3e128" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.385" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-25T16:17:00.115Z" : void 0);
+      const commit = readInjected(true ? "057d5def5d55af124dfe910ee9accdf244576c14" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "057d5def" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.387" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-26T02:21:54.536Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31142,6 +31142,7 @@ var require_dist3 = __commonJS({
     var git_worktree_exports = {};
     __export2(git_worktree_exports, {
       createWorktree: () => createWorktree,
+      deleteBranchRef: () => deleteBranchRef,
       listWorktrees: () => listWorktrees,
       parseWorktreeListOutput: () => parseWorktreeListOutput,
       removeWorktree: () => removeWorktree,
@@ -31284,6 +31285,53 @@ ${error48.message || ""}`;
       }
       return entries;
     }
+    async function deleteBranchRef(repoRoot, branch, opts = {}) {
+      const name = (branch || "").trim();
+      if (!name) return { deleted: false, reason: "empty_branch_name" };
+      try {
+        await execFileAsync2("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${name}`], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS,
+          maxBuffer: GIT_MAX_BUFFER,
+          windowsHide: true
+        });
+      } catch {
+        return { deleted: true, reason: "branch_ref_absent" };
+      }
+      try {
+        await execFileAsync2("git", ["branch", "-d", name], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS,
+          maxBuffer: GIT_MAX_BUFFER,
+          windowsHide: true
+        });
+        return { deleted: true, reason: "safe_deleted_merged_branch" };
+      } catch (error48) {
+        const stderr = typeof error48?.stderr === "string" ? error48.stderr : "";
+        const notMerged = /not fully merged/i.test(stderr) || /not fully merged/i.test(String(error48?.message || ""));
+        if (!notMerged) {
+          return { deleted: false, reason: `branch_delete_failed: ${stderr.trim() || error48?.message || "unknown error"}` };
+        }
+        if (opts.safeDeleteOnly) {
+          return { deleted: false, reason: "branch_not_merged_per_git_safe_delete_only" };
+        }
+        try {
+          await execFileAsync2("git", ["branch", "-D", name], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            windowsHide: true
+          });
+          return { deleted: true, reason: "force_deleted_patch_equivalent_branch", forced: true };
+        } catch (forceError) {
+          const fErr = typeof forceError?.stderr === "string" ? forceError.stderr : forceError?.message;
+          return { deleted: false, reason: `branch_force_delete_failed: ${String(fErr || "unknown error").trim()}` };
+        }
+      }
+    }
     async function pruneWorktrees(repoRoot) {
       try {
         await execFileAsync2("git", ["worktree", "prune"], {
@@ -34189,6 +34237,12 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const linePrefix = text.slice(lineStart, matchStart);
       if (/^\s*[$>]\s/.test(text.slice(lineStart))) return true;
       if (/^\s*$/.test(linePrefix)) return true;
+      let tokStart = matchStart;
+      while (tokStart > lineStart && !/\s/.test(text[tokStart - 1])) tokStart--;
+      const beforeToken = text.slice(lineStart, tokStart);
+      const tokenLead = text.slice(tokStart, matchStart);
+      const atCmdPos = /^\s*$/.test(beforeToken) || /(?:&&|\|\||\||;)\s*$/.test(beforeToken);
+      if (atCmdPos && /^(?:\.\/|\.\.\/|~\/|\/)/.test(tokenLead)) return true;
       if (/(?:&&|\|\||\||;)\s*$/.test(linePrefix)) return true;
       if (/(?:^|[\s,])(?:then|run|first)\s+$/i.test(linePrefix)) return true;
       if (/,\s*$/.test(linePrefix)) return true;
@@ -34215,9 +34269,65 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       return inlineCount % 2 === 1;
     }
+    function isInsidePathSegment(text, matchStart, matchEnd) {
+      const prev = matchStart > 0 ? text[matchStart - 1] : "";
+      const next = matchEnd < text.length ? text[matchEnd] : "";
+      const isSep = (c) => c === "/" || c === "\\";
+      const segChar = (c) => /[A-Za-z0-9._~-]/.test(c);
+      const inPath = isSep(prev) && (next === "" || isSep(next) || segChar(next) || /\s/.test(next)) || isSep(next) && (prev === "" || isSep(prev) || segChar(prev) || /\s/.test(prev));
+      if (!inPath) return false;
+      const lineStart = text.lastIndexOf("\n", matchStart - 1) + 1;
+      let tokStart = matchStart;
+      while (tokStart > lineStart && !/\s/.test(text[tokStart - 1])) tokStart--;
+      const linePrefixBeforeToken = text.slice(lineStart, tokStart);
+      const tokenPrefix = text.slice(tokStart, matchStart);
+      const atLineStart = /^\s*$/.test(linePrefixBeforeToken);
+      const afterConnective = /(?:&&|\|\||\||;)\s*$/.test(linePrefixBeforeToken);
+      const isRunPrefixPath = /^(?:\.\/|\.\.\/|~\/|\/)/.test(tokenPrefix);
+      if ((atLineStart || afterConnective) && isRunPrefixPath) return false;
+      return true;
+    }
+    function isInsideQuotedSpan(text, matchStart, matchEnd) {
+      const pairs = [
+        ["\u201C", "\u201D"],
+        ["\u2018", "\u2019"],
+        ["\u300C", "\u300D"],
+        ["\u300E", "\u300F"],
+        ["\u300A", "\u300B"]
+      ];
+      for (const [open, close] of pairs) {
+        const openIdx = text.lastIndexOf(open, matchStart - 1);
+        if (openIdx < 0) continue;
+        if (text.indexOf(close, openIdx + open.length) >= matchEnd) return true;
+      }
+      const lineStart = text.lastIndexOf("\n", matchStart - 1) + 1;
+      const lineEnd = (() => {
+        const i = text.indexOf("\n", matchEnd);
+        return i < 0 ? text.length : i;
+      })();
+      for (const q of ['"', "'"]) {
+        let count = 0;
+        for (let i = lineStart; i < matchStart; i++) if (text[i] === q) count++;
+        if (count % 2 === 1 && text.indexOf(q, matchEnd) >= 0 && text.indexOf(q, matchEnd) < lineEnd) {
+          if (q === '"') return true;
+          let openPos = -1, c = 0;
+          for (let i = lineStart; i < matchStart; i++) {
+            if (text[i] === q) {
+              c++;
+              if (c % 2 === 1) openPos = i;
+            }
+          }
+          const beforeOpen = openPos > lineStart ? text[openPos - 1] : " ";
+          if (/[\s(\[{>]/.test(beforeOpen) || openPos === lineStart) return true;
+        }
+      }
+      return false;
+    }
     function isRealMutationMatch(text, matchStart, matchEnd) {
       if (hasNegationBefore(text, matchStart)) return false;
       if (hasTrailingNegation(text, matchEnd)) return false;
+      if (isInsidePathSegment(text, matchStart, matchEnd)) return false;
+      if (isInsideQuotedSpan(text, matchStart, matchEnd)) return false;
       return isMutationKeywordInCommandContext(text, matchStart, matchEnd);
     }
     function patternHasRealMutation(pattern, text) {
@@ -65849,6 +65959,17 @@ ${body}
       hasIdleHoldPending() {
         return (this.lastFsmEval?.transitions ?? []).some((t) => !t.holdSatisfied && t.condResult);
       }
+      /**
+       * True once the machine has reached its first non-initial idle state (the
+       * prompt is genuinely drawn — see maybeMarkReady). The cli-adapter surfaces
+       * this on its idle status so CliProviderInstance can re-arm the queue-claim
+       * agent:ready on the first genuine ready, independent of the boot-time
+       * starting→idle one-shot (which is consumed too early for specs whose
+       * initial state already reports idle).
+       */
+      hasSeenReady() {
+        return this.readySeenOnce;
+      }
       getCompletionIdleDebounceState() {
         const out = outgoingTransitions(this.spec, this.currentStateId);
         const toReady = this.lastFsmEval?.transitions.find((t, i) => {
@@ -67505,7 +67626,7 @@ ${body}
         if (state.status === "generating") {
           return { status: "generating", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
         }
-        return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
+        return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, fsmReadySeen: this.driver.hasSeenReady?.() ?? false, ...sessionFields };
       }
       maybeRefreshNativeHistory() {
       }
@@ -68538,6 +68659,14 @@ ${body}
       context = null;
       events = [];
       lastStatus = "starting";
+      // Idempotency guard for the queue-claim agent:ready event. agent:ready is the
+      // sole signal the mesh coordinator's tryAssignQueueTask waits on to hand a
+      // queued task to this worker. It is emitted in two places: the boot-time
+      // starting→idle one-shot, and the readySeen re-arm below. This flag makes the
+      // event fire AT MOST ONCE per session so a worker is never claimed twice and a
+      // queued task is never double-dispatched/double-injected. Whichever path fires
+      // first sets it; the other becomes a no-op.
+      agentReadyEmitted = false;
       generatingStartedAt = 0;
       settings = {};
       monitor;
@@ -69618,6 +69747,17 @@ ${body}
         } catch {
         }
       }
+      /**
+       * Emit the queue-claim agent:ready event at most once per session. Both the
+       * boot-time starting→idle one-shot and the fsmReadySeen re-arm call this; the
+       * agentReadyEmitted guard ensures the second caller is a no-op so a worker is
+       * never claimed twice and a queued task is never double-dispatched.
+       */
+      emitAgentReadyOnce(chatTitle, now) {
+        if (this.agentReadyEmitted) return;
+        this.agentReadyEmitted = true;
+        this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
+      }
       detectStatusTransition() {
         const now = Date.now();
         const adapterStatus = this.adapter.getStatus({ allowParse: false });
@@ -69770,7 +69910,7 @@ ${body}
               this.scheduleCompletedDebounceFlush(flushDelay);
             }
           } else if (newStatus === "idle" && this.lastStatus === "starting") {
-            this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
+            this.emitAgentReadyOnce(chatTitle, now);
           } else if (newStatus === "error") {
             if (this.generatingDebounceTimer) {
               clearTimeout(this.generatingDebounceTimer);
@@ -69809,6 +69949,9 @@ ${body}
           }
           this.lastStatus = newStatus;
         }
+        if (newStatus === "idle" && adapterStatus.fsmReadySeen === true && !this.agentReadyEmitted) {
+          this.emitAgentReadyOnce(chatTitle, now);
+        }
         this.applyProviderResponse(parsedStatus, {
           phase: newStatus === "idle" && (previousStatus === "generating" || previousStatus === "waiting_approval") ? "turn_completed" : "immediate"
         });
@@ -77137,13 +77280,16 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                   worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0,
                   worktreeCleanupFallback: typeof worktreeCleanup?.fallback === "string" ? worktreeCleanup.fallback : void 0,
                   forced: worktreeCleanup?.forced === true ? true : void 0,
-                  forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0
+                  forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0,
+                  branchRefDeleted: typeof worktreeCleanup?.branchRefDeleted === "boolean" ? worktreeCleanup.branchRefDeleted : void 0,
+                  branchRefReason: typeof worktreeCleanup?.branchRefReason === "string" ? worktreeCleanup.branchRefReason : void 0
                 }
               });
             } catch {
             }
           }
           const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
+          const branchRefWarning = typeof worktreeCleanup?.branchRefWarning === "string" ? worktreeCleanup.branchRefWarning : void 0;
           const skippedLiveSessionIds = Array.isArray(sessionCleanup?.skippedLiveSessionIds) ? sessionCleanup.skippedLiveSessionIds.filter((v) => typeof v === "string") : [];
           const orphanedSessionsRemaining = skippedLiveSessionIds.length > 0;
           const orphanNextAction = orphanedSessionsRemaining ? `Live session(s) [${skippedLiveSessionIds.join(", ")}] were skipped and still survive this node removal. Run mesh_cleanup_sessions with mode:'stop_and_delete' and sessionIds:[${skippedLiveSessionIds.map((id) => `'${id}'`).join(", ")}] to release them.` : void 0;
@@ -77151,6 +77297,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             success: true,
             removed,
             ...residueWarning ? { residueWarning } : {},
+            ...branchRefWarning ? { branchRefWarning } : {},
             ...sessionCleanup ? { sessionCleanup } : {},
             ...worktreeCleanup ? { worktreeCleanup } : {},
             ...orphanedSessionsRemaining ? { orphanedSessionsRemaining: true, nextAction: orphanNextAction } : {}
@@ -82376,16 +82523,50 @@ ${mergeTreeErr?.stderr || ""}`;
             recoveryHint: "Inspect the worktree branch and mesh metadata before retrying cleanup."
           };
         }
-        const forceFallbackConvergence = args.force ? { allow: true, status: "force_override", source: "caller_force_flag" } : await this.getWorktreeForceCleanupConvergence({ repoRoot, workspace, node: args.node });
+        const mergeConvergence = await this.getWorktreeForceCleanupConvergence({ repoRoot, workspace, node: args.node });
+        const forceFallbackConvergence = args.force ? { allow: true, status: "force_override", source: "caller_force_flag" } : mergeConvergence;
+        const deleteBranchIfMerged = async () => {
+          const branch = String(args.node.worktreeBranch).trim();
+          const status = mergeConvergence.allow ? mergeConvergence.status || "" : "";
+          const MERGED_STATUSES = /* @__PURE__ */ new Set([
+            "merged_to_main",
+            "merged_pushed",
+            "merged_to_default_ref",
+            "cleanup_candidate"
+          ]);
+          const PATCH_EQUIV_STATUS = "patch_equivalent_to_default_ref";
+          if (!branch) {
+            return { branchRefDeleted: false, branchRefReason: "empty_branch_name" };
+          }
+          if (!mergeConvergence.allow || !MERGED_STATUSES.has(status) && status !== PATCH_EQUIV_STATUS) {
+            return {
+              branchRefDeleted: false,
+              branchRefReason: `branch_not_merged_preserved: ${mergeConvergence.error || mergeConvergence.status || "convergence_unverified"}`,
+              branchRefWarning: `Branch ref '${branch}' was preserved (not deleted) because it is not confirmed merged into the default ref \u2014 no work was lost. Merge it (or pass a verified branchConvergence final state) and re-run cleanup, or delete it manually after confirming.`
+            };
+          }
+          const { deleteBranchRef: deleteBranchRef2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+          const res = await deleteBranchRef2(repoRoot, branch, { safeDeleteOnly: status !== PATCH_EQUIV_STATUS });
+          return {
+            branchRefDeleted: res.deleted,
+            branchRefReason: res.reason,
+            ...res.forced ? { branchRefForced: true } : {},
+            ...res.deleted ? {} : {
+              branchRefWarning: `Branch ref '${branch}' could not be deleted (${res.reason}); it was preserved so no work is lost.`
+            }
+          };
+        };
         try {
           const result = await removeWorktree2(repoRoot, workspace, {
             requireClean: !args.force,
             allowSubmoduleForceFallback: forceFallbackConvergence.allow
           });
+          const branchOutcome = await deleteBranchIfMerged();
           return {
             success: true,
             removedPath: result.removedPath,
             repoRoot,
+            ...branchOutcome,
             ...result.fallback ? {
               fallback: result.fallback,
               forced: result.forced,
@@ -82418,10 +82599,12 @@ ${mergeTreeErr?.stderr || ""}`;
                 maxBuffer: GIT_MAX_BUFFER_CLEANUP,
                 windowsHide: true
               });
+              const branchOutcome = await deleteBranchIfMerged();
               return {
                 success: true,
                 removedPath: workspace,
                 repoRoot,
+                ...branchOutcome,
                 fallback: "git_worktree_remove_submodule_deinit",
                 forced: true,
                 reason: "working_trees_containing_submodules",
@@ -82439,10 +82622,12 @@ ${mergeTreeErr?.stderr || ""}`;
                 });
               } catch {
               }
+              const branchOutcome = await deleteBranchIfMerged();
               return {
                 success: true,
                 removedPath: workspace,
                 repoRoot,
+                ...branchOutcome,
                 fallback: "fs_rm_worktree_prune",
                 forced: true,
                 reason: "working_trees_containing_submodules",