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

package/dist/index.js

@@ -275,10 +275,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "88f97abcc85d83fe5d5313b229d32a7d76b1208a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "88f97abc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:13:51.625Z" : 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 version = 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:28.663Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2009,6 +2009,7 @@ function buildRulesSection(coordinatorCliType) {
 - **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\`.
@@ -15643,10 +15644,12 @@ function detectClaudeTuiMultiSelect(screenText) {
   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;
 }
@@ -15786,6 +15789,16 @@ function parseClaudeInteractiveTuiQuestion(page, index) {
     ...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);
@@ -21912,22 +21925,160 @@ function isBoundedTailRequest(limit, offset, excludeRecentCount) {
   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 = fs5.openSync(filePath, "r");
+  try {
+    const stat2 = fs5.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);
+      fs5.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 {
+    fs5.closeSync(fd);
+  }
+}
+function readFileTailLines(filePath, needed) {
+  let stat2;
+  try {
+    stat2 = fs5.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 cached2 = incrementalTailCache.get(filePath);
+  if (cached2) {
+    if (cached2.size === size && cached2.mtimeMs === mtimeMs) {
+      incrementalTailCache.delete(filePath);
+      incrementalTailCache.set(filePath, cached2);
+      if (cached2.coversWholeFile || cached2.lines.length >= needed) {
+        return { lines: cached2.lines, coversWholeFile: cached2.coversWholeFile };
+      }
+    } else if (size > cached2.size) {
+      const incremental = tryIncrementalTailGrowth(filePath, cached2, 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 = fs5.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, cached2, size, mtimeMs, needed) {
+  const fd = fs5.openSync(filePath, "r");
+  try {
+    if (cached2.size > 0) {
+      const boundary = Buffer.alloc(1);
+      fs5.readSync(fd, boundary, 0, 1, cached2.size - 1);
+      if (boundary[0] !== 10) return null;
+    }
+    const appendedLength = size - cached2.size;
+    const appended = Buffer.alloc(appendedLength);
+    fs5.readSync(fd, appended, 0, appendedLength, cached2.size);
+    const newLines = appended.toString("utf-8").split("\n");
+    if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
+    const merged = cached2.lines.concat(newLines);
+    const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
+    const coversWholeFile = cached2.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 {
+    fs5.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 = fs5.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 hash = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -21937,6 +22088,10 @@ function readBoundedTailRecords(agentType, dir, files, needed) {
       } catch {
       }
     }
+    if (!coversWholeFile) {
+      readAllFiles = false;
+      break;
+    }
     if (collected.length >= needed && f < files.length - 1) {
       readAllFiles = false;
       break;
@@ -31893,12 +32048,14 @@ var SpecCliAdapter = class _SpecCliAdapter {
         }
         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 {
@@ -32047,6 +32204,53 @@ var SpecCliAdapter = class _SpecCliAdapter {
       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 [];
@@ -32196,6 +32400,7 @@ function normalizeProviderSessionId(provider, providerSessionId) {
 }
 
 // src/providers/cli-provider-instance.ts
+var STATUS_HYDRATION_TAIL_LIMIT = 200;
 function isIdleStatus(value) {
   const status = typeof value === "string" ? value.trim().toLowerCase() : "";
   return !status || status === "idle" || status === "ready";
@@ -33858,12 +34063,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;
@@ -33875,7 +34082,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
       });
@@ -33891,7 +34098,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;
@@ -33901,7 +34108,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,
@@ -33916,7 +34123,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,