@adhdev/daemon-standalone 0.9.82-rc.293 → 0.9.82-rc.295

package/dist/index.js

@@ -29983,10 +29983,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "88f97abcc85d83fe5d5313b229d32a7d76b1208a" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "88f97abc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.293" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-16T11:14:20.929Z" : void 0);
+      const commit = readInjected(true ? "dc26917ced80beb84689897738b6edb82208c146" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "dc26917c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.295" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-16T13:44:55.274Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31725,6 +31725,7 @@ ${rules.join("\n")}`;
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
+- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially the oss submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
@@ -45410,10 +45411,12 @@ ${lastSnapshot}`;
       if (/Space to (?:select|toggle)|toggle selection|select multiple|select all that apply/i.test(screenText)) {
         return true;
       }
-      const optionCheckbox = /^\s*(?:[❯›>]\s*)?(?:\[[ xX]\]|[☐☒◻◼])\s*\d+\.\s+\S/;
+      const optionCheckbox = `(?:\\[[ xX]\\]|[\u2610\u2612\u25FB\u25FC])`;
+      const beforeNumber = new RegExp(`^\\s*(?:[\u276F\u203A>]\\s*)?${optionCheckbox}\\s*\\d+\\.\\s+\\S`);
+      const afterNumber = new RegExp(`^\\s*(?:[\u276F\u203A>]\\s*)?\\d+\\.\\s*${optionCheckbox}\\s+\\S`);
       for (const line of screenText.split(/\r?\n/)) {
         if (line.includes("\u2714 Submit")) continue;
-        if (optionCheckbox.test(line)) return true;
+        if (beforeNumber.test(line) || afterNumber.test(line)) return true;
       }
       return false;
     }
@@ -45553,6 +45556,16 @@ ${lastSnapshot}`;
         ...allowFreeform ? { allowFreeform: true } : {}
       };
     }
+    function readFocusedClaudeTuiQuestion(screenText) {
+      if (!screenText.includes("Enter to select")) return null;
+      const parsed = parseClaudeInteractiveTuiQuestion({ screenText }, 0);
+      if (!parsed) return null;
+      return {
+        question: parsed.question,
+        ...parsed.header ? { header: parsed.header } : {},
+        multiSelect: parsed.multiSelect
+      };
+    }
     function detectClaudeAskUserQuestionPromptFromTuiPages(pages, options) {
       if (pages.length === 0) return null;
       const headers = claudeTuiQuestionHeaders(pages[0].screenText);
@@ -51597,22 +51610,160 @@ ${cleanBody}`;
       if (!Number.isFinite(numericOffset) || !Number.isFinite(numericExclude)) return false;
       return true;
     }
+    var REVERSE_TAIL_SMALL_FILE_BYTES = 64 * 1024;
+    var REVERSE_TAIL_CHUNK_BYTES = 64 * 1024;
+    var TAIL_LINES_RETAINED = BOUNDED_TAIL_MAX_LIMIT + 2 * BOUNDED_TAIL_SLACK;
+    var INCREMENTAL_TAIL_CACHE_MAX_ENTRIES = 64;
+    var incrementalTailCache = /* @__PURE__ */ new Map();
+    function evictIncrementalTailCache() {
+      while (incrementalTailCache.size > INCREMENTAL_TAIL_CACHE_MAX_ENTRIES) {
+        const oldest = incrementalTailCache.keys().next().value;
+        if (oldest === void 0) break;
+        incrementalTailCache.delete(oldest);
+      }
+    }
+    function splitBufferLines(buf) {
+      const lines = [];
+      let lineEnd = buf.length;
+      let firstNewline = -1;
+      for (let i = buf.length - 1; i >= 0; i--) {
+        if (buf[i] !== 10) continue;
+        if (i + 1 < lineEnd) {
+          lines.push(buf.toString("utf-8", i + 1, lineEnd));
+        }
+        lineEnd = i;
+        firstNewline = i;
+      }
+      lines.reverse();
+      const head = firstNewline >= 0 ? buf.subarray(0, firstNewline) : buf;
+      return { head, lines };
+    }
+    function readReverseTailLines(filePath, needed) {
+      const fd = fs52.openSync(filePath, "r");
+      try {
+        const stat2 = fs52.fstatSync(fd);
+        const size = stat2.size;
+        let position = size;
+        let carry = Buffer.alloc(0);
+        const collected = [];
+        while (position > 0 && collected.length < needed) {
+          const chunkSize = Math.min(REVERSE_TAIL_CHUNK_BYTES, position);
+          position -= chunkSize;
+          const chunk = Buffer.alloc(chunkSize);
+          fs52.readSync(fd, chunk, 0, chunkSize, position);
+          const combined = carry.length ? Buffer.concat([chunk, carry]) : chunk;
+          const { head, lines } = splitBufferLines(combined);
+          carry = head;
+          for (let i = lines.length - 1; i >= 0; i--) {
+            collected.push(lines[i]);
+          }
+        }
+        const reachedStart = position <= 0;
+        if (reachedStart && carry.length) {
+          collected.push(carry.toString("utf-8"));
+        }
+        collected.reverse();
+        return { lines: collected, coversWholeFile: reachedStart, size, mtimeMs: stat2.mtimeMs };
+      } finally {
+        fs52.closeSync(fd);
+      }
+    }
+    function readFileTailLines(filePath, needed) {
+      let stat2;
+      try {
+        stat2 = fs52.statSync(filePath);
+      } catch {
+        return { lines: [], coversWholeFile: true };
+      }
+      const size = stat2.size;
+      const mtimeMs = stat2.mtimeMs;
+      if (size === 0) {
+        incrementalTailCache.delete(filePath);
+        return { lines: [], coversWholeFile: true };
+      }
+      const cached22 = incrementalTailCache.get(filePath);
+      if (cached22) {
+        if (cached22.size === size && cached22.mtimeMs === mtimeMs) {
+          incrementalTailCache.delete(filePath);
+          incrementalTailCache.set(filePath, cached22);
+          if (cached22.coversWholeFile || cached22.lines.length >= needed) {
+            return { lines: cached22.lines, coversWholeFile: cached22.coversWholeFile };
+          }
+        } else if (size > cached22.size) {
+          const incremental = tryIncrementalTailGrowth(filePath, cached22, size, mtimeMs, needed);
+          if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
+        }
+        incrementalTailCache.delete(filePath);
+      }
+      if (size <= REVERSE_TAIL_SMALL_FILE_BYTES) {
+        let content;
+        try {
+          content = fs52.readFileSync(filePath, "utf-8");
+        } catch {
+          return { lines: [], coversWholeFile: true };
+        }
+        const lines = content.split("\n");
+        if (lines.length && lines[lines.length - 1] === "") lines.pop();
+        storeIncrementalTailCache(filePath, size, mtimeMs, lines, true);
+        return { lines, coversWholeFile: true };
+      }
+      let result;
+      try {
+        result = readReverseTailLines(filePath, needed);
+      } catch {
+        return { lines: [], coversWholeFile: true };
+      }
+      storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
+      return { lines: result.lines, coversWholeFile: result.coversWholeFile };
+    }
+    function tryIncrementalTailGrowth(filePath, cached22, size, mtimeMs, needed) {
+      const fd = fs52.openSync(filePath, "r");
+      try {
+        if (cached22.size > 0) {
+          const boundary = Buffer.alloc(1);
+          fs52.readSync(fd, boundary, 0, 1, cached22.size - 1);
+          if (boundary[0] !== 10) return null;
+        }
+        const appendedLength = size - cached22.size;
+        const appended = Buffer.alloc(appendedLength);
+        fs52.readSync(fd, appended, 0, appendedLength, cached22.size);
+        const newLines = appended.toString("utf-8").split("\n");
+        if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
+        const merged = cached22.lines.concat(newLines);
+        const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
+        const coversWholeFile = cached22.coversWholeFile && trimmed.length === merged.length;
+        storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
+        if (coversWholeFile || trimmed.length >= needed) {
+          return { lines: trimmed, coversWholeFile };
+        }
+        return { lines: trimmed, coversWholeFile };
+      } catch {
+        return null;
+      } finally {
+        fs52.closeSync(fd);
+      }
+    }
+    function storeIncrementalTailCache(filePath, size, mtimeMs, lines, coversWholeFile) {
+      const retained = lines.length > TAIL_LINES_RETAINED ? lines.slice(lines.length - TAIL_LINES_RETAINED) : lines;
+      const covers = coversWholeFile && retained.length === lines.length;
+      incrementalTailCache.delete(filePath);
+      incrementalTailCache.set(filePath, { size, mtimeMs, lines: retained, coversWholeFile: covers });
+      evictIncrementalTailCache();
+    }
     function readBoundedTailRecords(agentType, dir, files, needed) {
       const collected = [];
       const seen = /* @__PURE__ */ new Set();
       let readAllFiles = true;
       for (let f = 0; f < files.length; f++) {
         const filePath = path12.join(dir, files[f]);
-        let content;
-        try {
-          content = fs52.readFileSync(filePath, "utf-8");
-        } catch {
-          continue;
-        }
-        const lines = content.trim().split("\n").filter(Boolean);
+        const remaining = Math.max(0, needed - collected.length);
+        const perFileNeeded = Math.min(needed, remaining + BOUNDED_TAIL_SLACK);
+        const { lines, coversWholeFile } = readFileTailLines(filePath, perFileNeeded);
         for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i];
+          if (!line) continue;
           try {
-            const parsed = JSON.parse(lines[i]);
+            const parsed = JSON.parse(line);
             const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
             if (!sanitizedMessage) continue;
             const hash2 = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -51622,6 +51773,10 @@ ${cleanBody}`;
           } catch {
           }
         }
+        if (!coversWholeFile) {
+          readAllFiles = false;
+          break;
+        }
         if (collected.length >= needed && f < files.length - 1) {
           readAllFiles = false;
           break;
@@ -61492,12 +61647,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             }
             this.maybeClearResolvedClaudeTuiPrompt();
             this.maybeCaptureClaudeTuiPrompt();
+            this.maybeUpgradeClaudeTuiMultiSelect();
             this.statusCallback?.();
             return;
           case "pty_data":
             this.detectInteractivePromptFromPtyChunk(ev.chunk);
             this.maybeClearResolvedClaudeTuiPrompt();
             this.maybeCaptureClaudeTuiPrompt();
+            this.maybeUpgradeClaudeTuiMultiSelect();
             try {
               this.ptyDataCallback?.(ev.chunk);
             } catch {
@@ -61646,6 +61803,53 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           this.claudeTuiPromptCaptureInFlight = false;
         });
       }
+      /**
+       * The TUI prompt is captured on the FIRST frame that renders the
+       * "Enter to select" footer. At that instant the option rows' checkbox
+       * column may not have drawn yet, so `detectClaudeTuiMultiSelect` returns
+       * false and the prompt is frozen as single-select — the dashboard then
+       * renders radio buttons even though the picker is multi-select.
+       *
+       * While the same TUI prompt is still on screen, re-check the live snapshot:
+       * if checkbox glyphs have since appeared, promote any single-select
+       * question to multi-select and re-emit status. Promotion is one-way
+       * (false→true only) — once a question is known multi-select we never demote
+       * it, since the glyph column can scroll out of view on later frames.
+       *
+       * For MULTI-question prompts the per-page Tab capture is the actual source
+       * of the bug: pages 2..N are snapshotted ~120ms after the Tab keypress,
+       * before their option-row glyph column has redrawn, so those questions
+       * freeze as single-select while page 1 (already settled) is correct. We
+       * cannot upgrade blindly — the live snapshot shows only ONE focused page —
+       * but we CAN read that page's question text/header and upgrade the matching
+       * question. As the user navigates the picker (or it settles), each page is
+       * eventually re-read and repaired.
+       */
+      maybeUpgradeClaudeTuiMultiSelect() {
+        if (this.cliType !== "claude-cli" || this.interactivePromptTransport !== "tui" || !this.activeInteractivePrompt) return;
+        const questions = this.activeInteractivePrompt.questions;
+        if (questions.every((q) => q.multiSelect)) return;
+        let screenText = "";
+        try {
+          screenText = this.driver.snapshot();
+        } catch {
+          return;
+        }
+        if (!screenText.includes("Enter to select")) return;
+        if (questions.length === 1) {
+          if (questions[0].multiSelect) return;
+          if (!detectClaudeTuiMultiSelect(screenText)) return;
+          questions[0].multiSelect = true;
+          this.statusCallback?.();
+          return;
+        }
+        const focused = readFocusedClaudeTuiQuestion(screenText);
+        if (!focused || !focused.multiSelect) return;
+        const match = questions.find((q) => focused.header && q.header && q.header === focused.header || q.question === focused.question);
+        if (!match || match.multiSelect) return;
+        match.multiSelect = true;
+        this.statusCallback?.();
+      }
       readClaudeTuiHeaders(screenText) {
         const navLine = screenText.split(/\r?\n/).find((line) => line.includes("\u2714 Submit") && /[☐☒]/.test(line));
         if (!navLine) return [];
@@ -61787,6 +61991,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       return normalizedId;
     }
+    var STATUS_HYDRATION_TAIL_LIMIT = 200;
     function isIdleStatus(value) {
       const status = typeof value === "string" ? value.trim().toLowerCase() : "";
       return !status || status === "idle" || status === "ready";
@@ -63449,12 +63654,14 @@ ${effect.notification.body || ""}`.trim();
         const newestMessageAt = parsedMessages.reduce((newest, message) => Math.max(newest, getMessageTime(message)), 0);
         return newestMessageAt === 0;
       }
-      syncCanonicalSavedHistoryIfNeeded() {
+      syncCanonicalSavedHistoryIfNeeded(options = {}) {
         if (!this.providerSessionId) return false;
         const canonicalHistory = this.provider.nativeHistory;
         if (!canonicalHistory) return false;
+        const limit = options.full ? Number.MAX_SAFE_INTEGER : STATUS_HYDRATION_TAIL_LIMIT;
+        const windowTag = options.full ? "full" : `tail:${STATUS_HYDRATION_TAIL_LIMIT}`;
         if (isNativeSourceCanonicalHistory(canonicalHistory)) {
-          const cacheKey = [this.type, this.providerSessionId, this.workingDir].join("\0");
+          const cacheKey = [this.type, this.providerSessionId, this.workingDir, windowTag].join("\0");
           const now = Date.now();
           if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2e3) {
             return true;
@@ -63466,7 +63673,7 @@ ${effect.notification.body || ""}`.trim();
             historySessionId: this.providerSessionId,
             workspace: this.workingDir,
             offset: 0,
-            limit: Number.MAX_SAFE_INTEGER,
+            limit,
             historyBehavior: this.provider.historyBehavior,
             scripts: this.provider.scripts
           });
@@ -63482,7 +63689,7 @@ ${effect.notification.body || ""}`.trim();
           return true;
         }
         try {
-          const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || "materialized-mirror"].join("\0");
+          const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || "materialized-mirror", windowTag].join("\0");
           const now = Date.now();
           if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2e3) {
             return true;
@@ -63492,7 +63699,7 @@ ${effect.notification.body || ""}`.trim();
           if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts)) {
             return false;
           }
-          const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+          const restoredHistory = readChatHistory(this.type, 0, limit, this.providerSessionId, 0, this.provider.historyBehavior);
           this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
             role: message.role,
             content: message.content,
@@ -63507,7 +63714,7 @@ ${effect.notification.body || ""}`.trim();
       }
       restorePersistedHistoryFromCurrentSession() {
         if (!this.providerSessionId) return;
-        this.syncCanonicalSavedHistoryIfNeeded();
+        this.syncCanonicalSavedHistoryIfNeeded({ full: true });
         const restoredHistory = isNativeSourceCanonicalHistory(this.provider.nativeHistory) ? readProviderChatHistory(this.type, {
           canonicalHistory: this.provider.nativeHistory,
           historySessionId: this.providerSessionId,