@adhdev/daemon-core 0.9.82-rc.292 → 0.9.82-rc.294

package/dist/mesh/mesh-missions.d.ts

@@ -37,6 +37,23 @@ export interface MeshMissionTaskAggregate {
 export interface MeshMissionSummary extends MeshMissionRecord {
     tasks: MeshMissionTaskAggregate;
 }
+/**
+ * Slim mission summary for the mesh_status compact (default) surface. Drops the
+ * full `goal` text — which can be hundreds of chars per mission and is repeated
+ * for every mission on every status call — keeping only a short preview plus a
+ * `goalTruncated` flag when the original was longer. The stored goal is never
+ * mutated; this is an output-only projection. Coordinators that need the full
+ * goal call mesh_status with verbose=true, or read the mission directly via
+ * mesh_mission_upsert / getMeshMission.
+ */
+export interface MeshMissionSlimSummary extends Omit<MeshMissionSummary, 'goal'> {
+    /** Short preview of the goal (≤ GOAL_PREVIEW_MAX chars), '' when goal empty. */
+    goalPreview: string;
+    /** True when the stored goal was longer than the preview (full text elided). */
+    goalTruncated: boolean;
+}
+/** Max chars of goal text retained in the slim (compact) mission summary. */
+export declare const GOAL_PREVIEW_MAX = 120;
 export declare function upsertMeshMission(meshId: string, input: {
     id?: string;
     title: string;
@@ -56,10 +73,17 @@ export declare function getActiveMeshMissionSummaries(meshId: string): MeshMissi
  * the dashboard can render a collapsible "history" section without unbounded
  * payload growth. Returned newest-first within each group (active/paused first,
  * then history), so the frontend can split on `status` directly.
+ *
+ * Compact mode (the default) elides each mission's full `goal` text — which is
+ * repeated verbatim on every status poll and dominates the payload when a mesh
+ * has many missions — returning only a short `goalPreview` + `goalTruncated`
+ * flag. Pass `verbose: true` to get the full `goal` text per mission. The stored
+ * goal is untouched in both modes; this is an output-only projection.
  */
 export declare function getMeshStatusMissionSummaries(meshId: string, options?: {
     historyLimit?: number;
-}): MeshMissionSummary[];
+    verbose?: boolean;
+}): MeshMissionSummary[] | MeshMissionSlimSummary[];
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/dist/mesh/mesh-runtime-store.d.ts

@@ -342,4 +342,19 @@ export declare class MeshRuntimeStore {
     /** Remove all pending-event rows (drained included) for a mesh — mesh deletion / test cleanup. */
     clearPendingEventsForMesh(meshId: string): number;
     pendingEventCount(meshId: string): number;
+    /**
+     * Mark specific pending-event rows drained by id (ack). Used by the
+     * unresolved-delegate durable-forward outbox: an event is peeked (not drained)
+     * while its push to the coordinator is unconfirmed, then marked drained ONLY
+     * after the push is acked. A failed push leaves the row undrained so the next
+     * reconcile tick retries it. Returns the number of rows newly marked drained.
+     */
+    markPendingEventsDrainedById(ids: ReadonlyArray<string>): number;
+    /**
+     * Hard-delete pending-event rows by id (including the dedup fingerprint history).
+     * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
+     * budget — fully removing it frees the fingerprint so a genuinely new completion
+     * for the same task could be re-queued later. Returns the number of rows deleted.
+     */
+    deletePendingEventsById(ids: ReadonlyArray<string>): number;
 }

package/dist/mesh/mesh-unresolved-forward-outbox.d.ts

@@ -0,0 +1,30 @@
+export declare const UNRESOLVED_FORWARD_OUTBOX_MESH_ID = "__unresolved_forward_outbox__";
+export interface UnresolvedForwardEntry {
+    /** Row id in mesh_pending_events; pass back to ack/expire after a push attempt. */
+    id: string;
+    /** The coordinator daemon to push this event to (mesh_forward_event target). */
+    coordinatorDaemonId: string;
+    /** The flat payload to forward (already shaped for handleMeshForwardEvent). */
+    payload: Record<string, unknown>;
+    /** When the entry was first enqueued (epoch ms) — used for age-based expiry. */
+    queuedAt: number;
+}
+/**
+ * Durably enqueue an unresolved-delegate forward for a coordinator daemon. The
+ * `forwardPayload` is the flat shape handleMeshForwardEvent reads on the coordinator.
+ * Idempotent on the event fingerprint. Returns true when a new row was written (or a
+ * duplicate was harmlessly ignored), false on a hard persistence failure.
+ */
+export declare function enqueueUnresolvedDelegateForward(coordinatorDaemonId: string, eventName: string, forwardPayload: Record<string, unknown>): boolean;
+/** Peek (non-destructive) every undrained outbox entry across all coordinators. */
+export declare function peekUnresolvedDelegateForwards(): UnresolvedForwardEntry[];
+/** Mark an outbox entry delivered (acked) after a successful push. */
+export declare function ackUnresolvedDelegateForward(id: string): void;
+/**
+ * Drop outbox entries that have exceeded the max retry age. Returns the count
+ * expired so the caller can log a fail-loud trace (a dropped completion is a real
+ * loss; it must be visible, not silent).
+ */
+export declare function expireStaleUnresolvedDelegateForwards(nowMs?: number): number;
+/** Test helper: purge the entire outbox. */
+export declare function __clearUnresolvedDelegateForwardOutboxForTests(): void;

package/dist/providers/spec/cli-adapter.d.ts

@@ -132,6 +132,20 @@ export declare class SpecCliAdapter implements CliAdapter {
      */
     private maybeClearResolvedClaudeTuiPrompt;
     private maybeCaptureClaudeTuiPrompt;
+    /**
+     * 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.
+     */
+    private maybeUpgradeClaudeTuiMultiSelect;
     private readClaudeTuiHeaders;
     private captureClaudeTuiPrompt;
     getDebugState(): Record<string, any>;

package/dist/providers/types/interactive-prompt.d.ts

@@ -33,6 +33,25 @@ export interface ClaudeInteractiveTuiPage {
     screenText: string;
     header?: string;
 }
+/**
+ * Decide whether a captured claude-cli AskUserQuestion TUI page is multi-select.
+ *
+ * The original heuristic only matched the footer hint `/Space to select|toggle
+ * selections/i`. That string drifts between claude-cli versions, so when it
+ * changed the dashboard silently fell back to multiSelect:false and rendered
+ * single-select (radio) controls even though the on-screen picker showed
+ * checkboxes — the user could not check more than one box. (The CLI's own
+ * terminal still rendered `[ ]` correctly because it never depends on this
+ * parse.)
+ *
+ * Make detection robust by ALSO recognising the actual checkbox markers the
+ * multi-select picker draws on its option rows (`[ ]` / `[x]` / `☐` / `☒` /
+ * `◻` / `◼`). Single-select rows are drawn with a `❯`/number cursor only and
+ * carry none of these box glyphs, so their presence is a reliable signal. The
+ * broadened footer patterns ("Space to", "toggle", "select multiple") are kept
+ * as a secondary signal for layouts that render markers differently.
+ */
+export declare function detectClaudeTuiMultiSelect(screenText: string): boolean;
 export declare function detectClaudeAskUserQuestionPromptFromTuiPages(pages: ClaudeInteractiveTuiPage[], options: {
     promptId: string;
     providerType?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.292",
+  "version": "0.9.82-rc.294",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.292",
+    "@adhdev/mesh-shared": "0.9.82-rc.294",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -8267,6 +8267,13 @@ export class DaemonCommandRouter {
                     const meshHost = resolveMeshHostStatus(mesh);
 
                     const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+                    // Compact (default) elides each mission's full goal text from the
+                    // payload — coordinators polling node health don't need every
+                    // mission's multi-hundred-char goal repeated. verbose=true (or the
+                    // explicit compact=false) restores full goals. Verbose bypasses the
+                    // shared (compact) aggregate cache so a verbose call never poisons
+                    // the compact cache and vice versa.
+                    const verboseMissions = args?.verbose === true || args?.compact === false;
                     // See (B3) below: scope the peek to this daemon when the
                     // caller doesn't tell us, otherwise scoped events look
                     // missing and we falsely return a stale cache.
@@ -8275,7 +8282,7 @@ export class DaemonCommandRouter {
                         : (this.deps.statusInstanceId || undefined);
                     const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId, peekScope).length;
                     const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
-                    if (!refreshRequested && pendingCoordinatorEventCount === 0) {
+                    if (!refreshRequested && !verboseMissions && pendingCoordinatorEventCount === 0) {
                         const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
                         if (cachedStatus) {
                             logRepoMeshStatusDebug('return_cached', {
@@ -8649,7 +8656,7 @@ export class DaemonCommandRouter {
                         liveSessionRecords: liveMeshSessions,
                     });
                     const { getMeshStatusMissionSummaries } = await import('../mesh/mesh-missions.js');
-                    const missions = getMeshStatusMissionSummaries(meshId);
+                    const missions = getMeshStatusMissionSummaries(meshId, { verbose: verboseMissions });
                     const statusResult = {
                         success: true,
                         meshId: mesh.id,
@@ -8709,7 +8716,12 @@ export class DaemonCommandRouter {
                             })),
                     };
                     const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult as any;
-                    const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+                    // Verbose carries full mission goals; never store it in the shared
+                    // (compact) aggregate cache or a later compact poll would return the
+                    // heavy goals from cache. Return it without caching.
+                    const rememberedStatus = verboseMissions
+                        ? cacheableStatusResult
+                        : this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
                     const returnedStatus = {
                         ...rememberedStatus,
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),

package/src/config/chat-history.ts

@@ -1234,6 +1234,241 @@ function isBoundedTailRequest(limit: number, offset: number, excludeRecentCount:
     return true;
 }
 
+// Byte threshold below which a file is small enough that reading the whole
+// thing is cheaper than seeking. Reverse-seek pays off only on large files.
+const REVERSE_TAIL_SMALL_FILE_BYTES = 64 * 1024;
+// Chunk size for backward reads. We read the file tail one chunk at a time
+// (newest bytes first) until we have collected enough complete lines.
+const REVERSE_TAIL_CHUNK_BYTES = 64 * 1024;
+
+// Per-(file path) incremental tail cache. A hot session's daily JSONL file grows
+// append-only while it generates; the size+mtime signature on the bounded-tail
+// read cache therefore invalidates on every append and forces a full re-read.
+// Here we keep the most recently decoded tail LINES for a file plus the byte
+// length we read them from. When the file has only grown (append-only: size
+// increased, the previously-read prefix is unchanged) we read just the new bytes
+// from `size` onward and splice them onto the retained tail — no full re-parse.
+// Truncation/rotation (size shrank, or a fresh inode) drops the entry and falls
+// back to a full reverse-seek.
+interface IncrementalTailCacheEntry {
+    // File length (bytes) we have already consumed into `lines`.
+    size: number;
+    mtimeMs: number;
+    // Decoded complete lines (oldest-first) covering at least the tail window.
+    // Bounded to TAIL_LINES_RETAINED so memory stays flat for huge files.
+    lines: string[];
+    // True when `lines` is the entire file (head reached), so older pages can
+    // trust that nothing precedes the retained window.
+    coversWholeFile: boolean;
+}
+
+// How many trailing lines we retain per file. The bounded-tail caller never
+// asks for more than BOUNDED_TAIL_MAX_LIMIT + slack; keep a generous multiple so
+// repeated reads at the same window are served incrementally.
+const TAIL_LINES_RETAINED = BOUNDED_TAIL_MAX_LIMIT + 2 * BOUNDED_TAIL_SLACK;
+const INCREMENTAL_TAIL_CACHE_MAX_ENTRIES = 64;
+const incrementalTailCache = new Map<string, IncrementalTailCacheEntry>();
+
+function evictIncrementalTailCache(): void {
+    while (incrementalTailCache.size > INCREMENTAL_TAIL_CACHE_MAX_ENTRIES) {
+        const oldest = incrementalTailCache.keys().next().value;
+        if (oldest === undefined) break;
+        incrementalTailCache.delete(oldest);
+    }
+}
+
+// Split a Buffer into complete lines plus a leftover head fragment, partitioning
+// only on the newline byte (0x0A). 0x0A never appears inside a multibyte UTF-8
+// sequence, so decoding each complete byte segment is boundary-safe. The leftover
+// (bytes before the first newline) is returned undecoded so a caller stitching
+// chunks together never splits a multibyte char.
+function splitBufferLines(buf: Buffer): { head: Buffer; lines: string[] } {
+    const lines: string[] = [];
+    let lineEnd = buf.length;
+    let firstNewline = -1;
+    for (let i = buf.length - 1; i >= 0; i--) {
+        if (buf[i] !== 0x0a) continue;
+        if (i + 1 < lineEnd) {
+            lines.push(buf.toString('utf-8', i + 1, lineEnd));
+        }
+        lineEnd = i;
+        firstNewline = i;
+    }
+    // Lines were collected newest-first; restore oldest-first for the segment
+    // that follows the first (lowest-index) newline.
+    lines.reverse();
+    const head = firstNewline >= 0 ? buf.subarray(0, firstNewline) : buf;
+    return { head, lines };
+}
+
+// Read the last bytes of a file, newest-first, until we have at least `needed`
+// complete lines (or reach the start of the file). Returns lines oldest-first and
+// whether the whole file was consumed. Boundary-safe: lines are cut on the
+// newline byte only, so multibyte UTF-8 chars are never split, and a trailing
+// partial line (no terminating newline) is preserved as a complete final line.
+function readReverseTailLines(filePath: string, needed: number): { lines: string[]; coversWholeFile: boolean; size: number; mtimeMs: number } {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        const size = stat.size;
+        let position = size;
+        // `carry` holds bytes belonging to a line that straddles the current
+        // chunk boundary (its start is in an older, not-yet-read chunk).
+        let carry: Buffer = Buffer.alloc(0);
+        const collected: string[] = [];
+
+        while (position > 0 && collected.length < needed) {
+            const chunkSize = Math.min(REVERSE_TAIL_CHUNK_BYTES, position);
+            position -= chunkSize;
+            const chunk = Buffer.alloc(chunkSize);
+            fs.readSync(fd, chunk, 0, chunkSize, position);
+            const combined = carry.length ? Buffer.concat([chunk, carry]) : chunk;
+            const { head, lines } = splitBufferLines(combined);
+            // `head` is the (possibly partial) line whose start lies further back;
+            // hold it for the next (older) chunk to complete.
+            carry = head;
+            // `lines` are oldest-first within this combined buffer; prepend them
+            // ahead of what we already collected (which is strictly newer).
+            for (let i = lines.length - 1; i >= 0; i--) {
+                collected.push(lines[i]);
+            }
+        }
+
+        const reachedStart = position <= 0;
+        if (reachedStart && carry.length) {
+            // Leftover head at the start of the file is itself a complete line.
+            collected.push(carry.toString('utf-8'));
+        }
+        // `collected` is newest-first; restore oldest-first.
+        collected.reverse();
+        return { lines: collected, coversWholeFile: reachedStart, size, mtimeMs: stat.mtimeMs };
+    } finally {
+        fs.closeSync(fd);
+    }
+}
+
+// Return the tail lines (oldest-first) for a single history file, reading as
+// little of the file as possible. Strategy:
+//   - Small files: one readFileSync (seeking is not worth the syscalls).
+//   - Large files: reverse byte-seek for the newest `needed` lines.
+//   - Append-only growth since the last read: read only the appended bytes and
+//     splice them onto the retained tail (no full re-parse) — this is what keeps
+//     a hot, still-generating session cheap to poll.
+// `needed` is a soft floor; we may return more (whole small files / retained
+// window). Lines include any trailing partial (unterminated) final line.
+function readFileTailLines(filePath: string, needed: number): { lines: string[]; coversWholeFile: boolean } {
+    let stat: fs.Stats;
+    try {
+        stat = fs.statSync(filePath);
+    } catch {
+        return { lines: [], coversWholeFile: true };
+    }
+    const size = stat.size;
+    const mtimeMs = stat.mtimeMs;
+    if (size === 0) {
+        incrementalTailCache.delete(filePath);
+        return { lines: [], coversWholeFile: true };
+    }
+
+    const cached = incrementalTailCache.get(filePath);
+    if (cached) {
+        if (cached.size === size && cached.mtimeMs === mtimeMs) {
+            // Unchanged since last read — reuse retained tail. Refresh LRU.
+            incrementalTailCache.delete(filePath);
+            incrementalTailCache.set(filePath, cached);
+            if (cached.coversWholeFile || cached.lines.length >= needed) {
+                return { lines: cached.lines, coversWholeFile: cached.coversWholeFile };
+            }
+            // Retained window is smaller than this request needs; fall through
+            // to a fresh reverse-seek for the larger window.
+        } else if (size > cached.size) {
+            // Append-only growth: the prefix [0, cached.size) is assumed
+            // unchanged (JSONL is append-only). Read just the new bytes and
+            // stitch them — but verify the byte at cached.size-1 is still the
+            // newline that terminated our last retained line, so a rewrite that
+            // happens to grow the file (compaction) is detected and rejected.
+            const incremental = tryIncrementalTailGrowth(filePath, cached, size, mtimeMs, needed);
+            if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
+        }
+        // size shrank (truncation/rotation) or incremental failed → drop & reload.
+        incrementalTailCache.delete(filePath);
+    }
+
+    if (size <= REVERSE_TAIL_SMALL_FILE_BYTES) {
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            return { lines: [], coversWholeFile: true };
+        }
+        const lines = content.split('\n');
+        // A trailing newline yields a final empty element; drop only that one so
+        // an unterminated partial last line is still preserved.
+        if (lines.length && lines[lines.length - 1] === '') lines.pop();
+        storeIncrementalTailCache(filePath, size, mtimeMs, lines, true);
+        return { lines, coversWholeFile: true };
+    }
+
+    let result: { lines: string[]; coversWholeFile: boolean; size: number; mtimeMs: number };
+    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 };
+}
+
+// Read appended bytes [cached.size, size) and splice them onto the retained tail.
+// Returns null if the prior byte is not a newline (the retained tail did not end
+// on a record boundary, e.g. the file was rewritten) so the caller can full-reload.
+function tryIncrementalTailGrowth(
+    filePath: string,
+    cached: IncrementalTailCacheEntry,
+    size: number,
+    mtimeMs: number,
+    needed: number,
+): { lines: string[]; coversWholeFile: boolean } | null {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        // Confirm the byte ending the previously-read prefix is still a newline.
+        if (cached.size > 0) {
+            const boundary = Buffer.alloc(1);
+            fs.readSync(fd, boundary, 0, 1, cached.size - 1);
+            if (boundary[0] !== 0x0a) return null;
+        }
+        const appendedLength = size - cached.size;
+        const appended = Buffer.alloc(appendedLength);
+        fs.readSync(fd, appended, 0, appendedLength, cached.size);
+        const newLines = appended.toString('utf-8').split('\n');
+        if (newLines.length && newLines[newLines.length - 1] === '') newLines.pop();
+        const merged = cached.lines.concat(newLines);
+        // Keep memory flat: retain only the trailing window.
+        const trimmed = merged.length > TAIL_LINES_RETAINED
+            ? merged.slice(merged.length - TAIL_LINES_RETAINED)
+            : merged;
+        const coversWholeFile = cached.coversWholeFile && trimmed.length === merged.length;
+        storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
+        if (coversWholeFile || trimmed.length >= needed) {
+            return { lines: trimmed, coversWholeFile };
+        }
+        // Should not happen (we only grew), but be safe.
+        return { lines: trimmed, coversWholeFile };
+    } catch {
+        return null;
+    } finally {
+        fs.closeSync(fd);
+    }
+}
+
+function storeIncrementalTailCache(filePath: string, size: number, mtimeMs: number, lines: string[], coversWholeFile: boolean): void {
+    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();
+}
+
 // Read newest-first only as many files as needed to cover the requested window
 // plus slack. listHistoryFiles already returns files reversed (newest-first), so
 // we accumulate (de-duped) candidates from the end and stop once we have enough,
@@ -1250,19 +1485,22 @@ function readBoundedTailRecords(
 
     for (let f = 0; f < files.length; f++) {
         const filePath = path.join(dir, files[f]);
-        let content: string;
-        try {
-            content = fs.readFileSync(filePath, 'utf-8');
-        } catch {
-            continue;
-        }
-        const lines = content.trim().split('\n').filter(Boolean);
-        // Walk this file's lines newest-first so we fill the tail window from the
-        // bottom. seen-dedup keeps the same first-wins-by-newest semantics the
+        // Read only the file tail needed to top up the window — for a large
+        // single-day file this seeks the last `needed` lines instead of parsing
+        // the whole file. We re-derive the per-file floor each iteration from how
+        // many records are still missing (plus slack so dedup at the boundary is
+        // stable), capped at `needed`.
+        const remaining = Math.max(0, needed - collected.length);
+        const perFileNeeded = Math.min(needed, remaining + BOUNDED_TAIL_SLACK);
+        const { lines, coversWholeFile } = readFileTailLines(filePath, perFileNeeded);
+        // Walk this file's tail lines newest-first so we fill the tail window from
+        // the bottom. seen-dedup keeps the same first-wins-by-newest semantics the
         // full read produced (files are processed newest-first there too).
         for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (!line) continue;
             try {
-                const parsed = JSON.parse(lines[i]) as HistoryMessage;
+                const parsed = JSON.parse(line) as HistoryMessage;
                 const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
                 if (!sanitizedMessage) continue;
                 const hash = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -1271,6 +1509,13 @@ function readBoundedTailRecords(
                 collected.push(sanitizedMessage);
             } catch { /* skip invalid lines */ }
         }
+        // If we only read this file's tail (its head was not reached), older
+        // messages remain within this very file — the conversation is NOT fully
+        // represented even if this is the last file, so hasMore must stay true.
+        if (!coversWholeFile) {
+            readAllFiles = false;
+            break;
+        }
         // Stop once we have the window AND there is at least one more file (so a
         // potential older boundary message exists). If this is the last file we
         // fall through and mark the whole history as read.

package/src/git/git-status.ts

@@ -143,11 +143,39 @@ const WEB_ONLY_PACKAGES = new Set([
   'terminal-render-web',
 ]);
 
+/**
+ * Root-level (non-package) files that demonstrably cannot change what the daemon
+ * runtime executes: convergence/verify markers, documentation, and license/notice
+ * text. A root commit that moves the oss gitlink while the oss commit only touched
+ * one of these is NOT a reason to rebuild/restart the daemon — flagging it produces
+ * the staleDaemonBuild false-positive this guard exists to suppress.
+ *
+ * Deliberately conservative: anything NOT matched here (root config like
+ * package.json / tsconfig / build scripts, `.txt` fixtures, lockfiles, unknown
+ * dotfiles) stays daemon-affecting, because a false-negative — staying silent when
+ * the daemon really IS stale — is worse than an over-warn. Markers are the common
+ * real-world case (e.g. `.verify-patch-equiv-rc292`), so they are matched broadly;
+ * docs are matched by the `docs/` prefix or a markdown/text-doc extension at a
+ * filename we recognize as documentation (README/CHANGELOG/LICENSE/NOTICE).
+ */
+function isNonRuntimeRootFile(file: string): boolean {
+  const base = file.slice(file.lastIndexOf('/') + 1);
+  // Verify/convergence markers: dotfiles whose name signals a transient marker.
+  if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+  // Documentation living under a docs/ tree (any depth, root or nested).
+  if (/(?:^|\/)docs\//i.test(file)) return true;
+  // Recognized top-level documentation / license files.
+  if (/^(?:README|CHANGELOG|LICENSE|NOTICE|AUTHORS|CONTRIBUTING|CODEOWNERS)(?:\.[A-Za-z0-9]+)?$/i.test(base)) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
  * package. Returns isDaemonAffecting:true conservatively when the changed-file set
  * can't be obtained or any changed path is outside the known web-only package set
- * (including root-level / non-package files).
+ * AND is not a recognized non-runtime root file (marker/doc/license).
  */
 async function classifyDaemonBuildChange(
   repoPath: string,
@@ -166,24 +194,28 @@ async function classifyDaemonBuildChange(
       return { isDaemonAffecting: true, affectedPackages: [] };
     }
     const pkgs = new Set<string>();
-    let sawNonPackageOrUnknown = false;
+    // A non-package path that is NOT a recognized benign root file (marker/doc).
+    // Only these force daemon-affecting; benign markers/docs are ignored so a
+    // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
+    let sawRuntimeAmbiguousNonPackage = false;
     for (const file of files) {
       const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
       if (!match) {
-        sawNonPackageOrUnknown = true;
+        if (!isNonRuntimeRootFile(file)) sawRuntimeAmbiguousNonPackage = true;
         continue;
       }
       pkgs.add(match[1]);
     }
     const affectedPackages = [...pkgs].sort();
-    // Daemon-affecting if: any non-package/root file changed, any unknown package
-    // changed, or any explicit daemon-runtime package changed. Only when EVERY
-    // changed file maps to a known web-only package is the daemon unaffected.
-    const allWebOnly =
-      !sawNonPackageOrUnknown &&
-      affectedPackages.length > 0 &&
+    // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
+    // unknown package changed, or any explicit daemon-runtime package changed.
+    // The daemon is unaffected only when every changed file is either a known
+    // web-only package or a recognized benign root file (and at least one such
+    // file changed) — i.e. nothing runtime-ambiguous remains.
+    const allBenign =
+      !sawRuntimeAmbiguousNonPackage &&
       affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
-    return { isDaemonAffecting: !allWebOnly, affectedPackages };
+    return { isDaemonAffecting: !allBenign, affectedPackages };
   } catch {
     // diff probe failed → can't prove web-only; stay conservative.
     return { isDaemonAffecting: true, affectedPackages: [] };
@@ -229,11 +261,14 @@ async function detectDaemonBuildBehind(
         options,
       );
       const scopeLabel = scope === 'root' ? 'workspace' : scope;
+      const benignDetail = affectedPackages.length > 0
+        ? `only web packages changed (${affectedPackages.join(', ')})`
+        : 'only non-runtime files changed (markers/docs)';
       const warning = isDaemonAffecting
         ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. ` +
           `Merged code is NOT live until the daemon is rebuilt/redeployed and restarted — a local dist rebuild alone does not update a cloud daemon.`
         : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, ` +
-          `but only web packages changed (${(affectedPackages || []).join(', ') || 'web'}). ` +
+          `but ${benignDetail}. ` +
           `Daemon restart NOT required — redeploy the web app to reflect the change.`;
       return {
         buildCommit: build.commit,

package/src/mesh/coordinator-prompt.ts

@@ -350,7 +350,7 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
+4. **Monitor** — Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` — do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
 5. **Verify** — When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** — Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** — Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -382,8 +382,9 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
 - **Respect explicit provider requests.** Map: Hermes → \`hermes-cli\`, Claude/Claude Code → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`, Antigravity → \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **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–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing.
+- **Limit parallelism.** Start with 1–2 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 — 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 — especially the oss submodule pointer — 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\` → classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.