@adhdev/daemon-core 1.0.18-rc.2 → 1.0.18-rc.20

package/src/mesh/coordinator-prompt.ts

@@ -34,6 +34,7 @@ import type {
 import { mergeAndNormalizePolicy, resolveProviderMaxParallel } from '../repo-mesh-types.js';
 import { getDifficultyBrains } from '../config/mesh-config.js';
 import { resolveNodeCapabilitySlots } from './mesh-node-slots.js';
+import { isNoteExpired, OPERATING_NOTE_CATEGORY_TTL_DAYS } from './mesh-ledger.js';
 import { MESH_TASK_DIFFICULTIES } from '@adhdev/mesh-shared';
 import type { MagiKindPanelMap, MagiSlot, MagiTaskKind } from '@adhdev/mesh-shared';
 
@@ -84,6 +85,41 @@ export interface CoordinatorOperatingNote {
     category?: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson';
     createdAt?: string;
     sourceCoordinator?: string;
+    /**
+     * Operating-notes lifecycle (minimal first cut). When true the note ALWAYS
+     * rides into the coordinator prompt — it is never dropped by TTL expiry and
+     * survives the injection cap ahead of unpinned notes. Legacy notes without
+     * this field default to false.
+     */
+    pinned?: boolean;
+    /**
+     * Optional explicit expiry ISO timestamp. When set and in the past, an
+     * UNPINNED note is dropped from the injected prompt (read-side only — the
+     * ledger entry is never pruned by age). When absent, the category→TTL map
+     * (see isNoteExpired) governs expiry; pinned notes never expire regardless.
+     */
+    expiresAt?: string;
+    /**
+     * Phase 2 — the ledger id of this note, when known. Threaded from the ledger
+     * entry id at launch so version-supersede can target a specific note and
+     * same-class folding can list the subsumed ids. Repo-declared notes may lack
+     * one; absent is fine (folding/supersede fall back to the subject key).
+     */
+    noteId?: string;
+    /**
+     * Phase 2 (b) version-supersede — an optional note-id or stable subject-key
+     * this note replaces. At injection, any earlier LIVE note whose `noteId` or
+     * `subjectKey` matches this value is hidden from the prompt (the ledger entry
+     * is retained for audit). Optional and lossless: absent = supersedes nothing.
+     */
+    supersedes?: string;
+    /**
+     * Phase 2 (b)/(c) — an optional stable subject-key grouping notes about the
+     * same subject. Drives version-supersede targeting and same-class folding.
+     * When absent, folding derives a key from a leading `[tag]` bracket instead,
+     * so legacy notes still collapse by their conventional tag prefix.
+     */
+    subjectKey?: string;
 }
 
 // ─── Prompt Builder ─────────────────────────────
@@ -582,33 +618,243 @@ function buildRecentActivitySection(activity?: CoordinatorRecentActivity): strin
 const OPERATING_NOTES_PROMPT_CAP = 20;
 const OPERATING_NOTE_MAX_CHARS = 300;
 
-function buildOperatingNotesSection(notes?: CoordinatorOperatingNote[]): string {
+/**
+ * Phase 2 (d) — byte budget for the injected Operating Notes list. The count cap
+ * above (20) is still a ceiling, but selection now fills up to this UTF-8 byte
+ * budget on the RENDERED note lines, ranked pinned > durable > recency, so a few
+ * long notes don't crowd out many short ones and vice-versa. Pinned notes are
+ * ALWAYS kept even if they alone exceed the budget (pinned is author-opt-in and
+ * bounded by the author); the budget only bounds the unpinned tail.
+ *
+ * ~6KB ≈ the 20-note cap at typical note length, so on ordinary meshes this
+ * changes nothing — it only kicks in when notes run long. It sits well under the
+ * whole-prompt PROMPT_SOFT_CAP_BYTES (60KB) so the two caps don't fight.
+ */
+const OPERATING_NOTE_INJECTION_BYTE_BUDGET = 6 * 1024;
+
+/**
+ * A category is "durable" (survives the cap ahead of recency) when it has no
+ * TTL entry — provider_quirk, uncategorized, or any unknown category. This
+ * mirrors isNoteExpired's durability rule so ranking and expiry agree.
+ */
+function isDurableCategory(category?: string): boolean {
+    if (!category) return true;
+    return !(category in OPERATING_NOTE_CATEGORY_TTL_DAYS);
+}
+
+/**
+ * Phase 2 (b)/(c) — derive a note's subject key for supersede targeting and
+ * same-class folding. Precedence:
+ *   1. an explicit `subjectKey` (trimmed, lowercased) when present, else
+ *   2. a leading `[tag]` bracket, so legacy notes that follow the conventional
+ *      `[some-tag] …` prefix still group/supersede by that tag, else
+ *   3. undefined — the note has no derivable subject and never folds/supersedes
+ *      by key (it can still be targeted by exact noteId).
+ * Pure. Lowercased so `[Foo]` and `[foo]` collapse together.
+ */
+function deriveSubjectKey(note: CoordinatorOperatingNote): string | undefined {
+    const explicit = typeof note.subjectKey === 'string' ? note.subjectKey.trim().toLowerCase() : '';
+    if (explicit) return explicit;
+    const text = typeof note.text === 'string' ? note.text.trimStart() : '';
+    const m = /^\[([^\]]{1,80})\]/.exec(text);
+    const tag = m ? m[1].trim().toLowerCase() : '';
+    return tag || undefined;
+}
+
+/**
+ * Phase 2 (c) — deterministic same-class fold. Given ranked notes (already
+ * highest-priority first), collapse runs of UNPINNED notes that share the same
+ * category AND subject key into a single injected entry: keep the highest-ranked
+ * (first-seen) note and record the note-ids/count it subsumes so the rendered
+ * line can say "(+N earlier)". Pinned notes never fold — each pinned note is
+ * author-opted-in and shown verbatim. The store is untouched; this is a pure,
+ * model-free text fold at injection time.
+ *
+ * Returns the folded note list (order preserved) with per-entry subsumed info.
+ */
+interface FoldedNote {
+    note: CoordinatorOperatingNote;
+    /** note-ids of same-class notes this entry subsumes (may be empty). */
+    subsumedIds: string[];
+    /** count of subsumed notes (== subsumedIds.length, but counts id-less ones too). */
+    subsumedCount: number;
+}
+
+function foldSameClassNotes(ranked: CoordinatorOperatingNote[]): FoldedNote[] {
+    const out: FoldedNote[] = [];
+    // group key → index into `out` of the surviving (highest-ranked) entry.
+    const survivorByKey = new Map<string, number>();
+    for (const note of ranked) {
+        const subject = deriveSubjectKey(note);
+        // Only unpinned notes with a category AND a subject key are foldable —
+        // without both there is no reliable "same class/subject" signal, so we
+        // keep the note standalone (lossless for legacy/uncategorized notes).
+        const foldable = !note.pinned && !!note.category && !!subject;
+        if (foldable) {
+            const key = `${note.category}${subject}`;
+            const existing = survivorByKey.get(key);
+            if (existing !== undefined) {
+                const survivor = out[existing];
+                survivor.subsumedCount += 1;
+                if (typeof note.noteId === 'string' && note.noteId) survivor.subsumedIds.push(note.noteId);
+                continue;
+            }
+            survivorByKey.set(key, out.length);
+        }
+        out.push({ note, subsumedIds: [], subsumedCount: 0 });
+    }
+    return out;
+}
+
+/** Estimate the UTF-8 byte cost of one rendered operating-note line (Phase 2 d). */
+function renderedNoteBytes(folded: FoldedNote): number {
+    return byteLength(renderOperatingNoteLine(folded));
+}
+
+/**
+ * Operating-notes lifecycle selection (read-side). Given the effective notes
+ * (oldest-first, ledger order) and the current time, produce the ordered list
+ * that rides into the prompt:
+ *   (i)    ALWAYS include pinned notes.
+ *   (ii)   drop expired UNPINNED notes (per category TTL / explicit expiresAt).
+ *   (iii)  Phase 2 (b) drop any note SUPERSEDED by a later live note (by noteId
+ *          or subjectKey); pinned notes are never dropped by supersede.
+ *   (iv)   rank pinned-first, then durable-category, then recency (newest first).
+ *   (v)    Phase 2 (c) fold same-category/same-subject unpinned runs into one.
+ *   (vi)   Phase 2 (d) fill up to a byte budget AND a count cap; pinned always
+ *          kept even if they alone exceed the byte budget.
+ * Pure + deterministic given `now`. Returns { shown, omittedCount } where `shown`
+ * carries per-entry fold info for the renderer.
+ *
+ * Ranking is stable on the original ledger index so, within a tier, newest notes
+ * lead. The caps keep the leading (highest-priority) entries.
+ */
+export function selectOperatingNotesForPrompt(
+    notes: CoordinatorOperatingNote[],
+    now: number,
+    cap: number = OPERATING_NOTES_PROMPT_CAP,
+    byteBudget: number = OPERATING_NOTE_INJECTION_BYTE_BUDGET,
+): { shown: FoldedNote[]; omittedCount: number } {
     const valid = Array.isArray(notes)
         ? notes.filter(n => n && typeof n.text === 'string' && n.text.trim())
         : [];
-    if (valid.length === 0) return '';
 
+    // (i)+(ii): keep pinned always; drop expired unpinned. Retain original index
+    // for a stable recency tiebreak (later index == newer, ledger is oldest-first).
+    let kept = valid
+        .map((note, index) => ({ note, index }))
+        .filter(({ note }) => note.pinned || !isNoteExpired(note as any, now));
+
+    // (iii) Phase 2 (b) version-supersede: a LATER live note may name (via
+    // `supersedes`) an earlier note's noteId or subjectKey; the earlier one is
+    // then hidden. "Later" == higher ledger index. Collect every supersede target
+    // paired with the max index that supersedes it, then drop any UNPINNED note
+    // whose id/subjectKey is superseded by a strictly-later note. Pinned notes are
+    // never dropped by supersede (pinned always wins, mirroring TTL).
+    const supersededAtIndex = new Map<string, number>();
+    for (const { note, index } of kept) {
+        const target = typeof note.supersedes === 'string' ? note.supersedes.trim().toLowerCase() : '';
+        if (!target) continue;
+        const prev = supersededAtIndex.get(target);
+        if (prev === undefined || index > prev) supersededAtIndex.set(target, index);
+    }
+    if (supersededAtIndex.size > 0) {
+        kept = kept.filter(({ note, index }) => {
+            if (note.pinned) return true;
+            const byId = typeof note.noteId === 'string' ? note.noteId.trim().toLowerCase() : '';
+            const bySubject = deriveSubjectKey(note);
+            const supIdx = Math.max(
+                byId ? (supersededAtIndex.get(byId) ?? -1) : -1,
+                bySubject ? (supersededAtIndex.get(bySubject) ?? -1) : -1,
+            );
+            return !(supIdx > index); // superseded by a strictly-later note → drop
+        });
+    }
+
+    // (iv): rank pinned > durable > recency (newest first within a tier).
+    const rank = (n: CoordinatorOperatingNote): number =>
+        n.pinned ? 0 : isDurableCategory(n.category) ? 1 : 2;
+    kept.sort((a, b) => {
+        const r = rank(a.note) - rank(b.note);
+        if (r !== 0) return r;
+        return b.index - a.index; // newer (higher index) first
+    });
+
+    // (v) Phase 2 (c): fold same-class/same-subject unpinned runs into one entry.
+    const folded = foldSameClassNotes(kept.map(k => k.note));
+
+    // (vi) Phase 2 (d): fill up to the byte budget AND the count cap. Pinned
+    // entries are always kept (never dropped to fit the budget); the budget/cap
+    // bound the unpinned tail. Entries are already highest-priority first, so we
+    // walk in order and stop once an UNPINNED entry would break a bound.
+    const shown: FoldedNote[] = [];
+    let usedBytes = 0;
+    let usedCount = 0;
+    for (const entry of folded) {
+        if (entry.note.pinned) {
+            shown.push(entry);
+            usedBytes += renderedNoteBytes(entry);
+            usedCount += 1;
+            continue;
+        }
+        if (usedCount >= cap) break;
+        const bytes = renderedNoteBytes(entry);
+        if (usedCount > 0 && usedBytes + bytes > byteBudget) break;
+        shown.push(entry);
+        usedBytes += bytes;
+        usedCount += 1;
+    }
+
+    // omittedCount counts eligible (non-expired, non-superseded, post-fold) entries
+    // that did not make the cut. Folded-away duplicates are not "omitted" — they are
+    // represented by their survivor's "(+N earlier)" marker, so exclude them here.
+    const omittedCount = Math.max(0, folded.length - shown.length);
+    return { shown, omittedCount };
+}
+
+/**
+ * Render one operating-note bullet line (Phase 2 c fold-aware). Shared by the
+ * byte-budget estimator and the section renderer so the budget is measured on
+ * the exact bytes that ship.
+ */
+function renderOperatingNoteLine(folded: FoldedNote): string {
+    const n = folded.note;
     const categoryLabel: Record<string, string> = {
         provider_quirk: 'provider quirk',
         pattern_to_avoid: 'pattern to avoid',
         recovery_lesson: 'recovery lesson',
     };
+    const pin = n.pinned ? '📌 ' : '';
+    const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : '';
+    const fold = folded.subsumedCount > 0
+        ? ` _(+${folded.subsumedCount} earlier same-subject note${folded.subsumedCount === 1 ? '' : 's'} folded${folded.subsumedIds.length ? `: ${folded.subsumedIds.join(', ')}` : ''})_`
+        : '';
+    return `- ${pin}${cat}${truncateNote(n.text.trim())}${fold}`;
+}
+
+function buildOperatingNotesSection(notes?: CoordinatorOperatingNote[], now: number = Date.now()): string {
+    const hasAny = Array.isArray(notes)
+        ? notes.some(n => n && typeof n.text === 'string' && n.text.trim())
+        : false;
+    if (!hasAny) return '';
 
-    // Keep only the most recent OPERATING_NOTES_PROMPT_CAP notes in the prompt.
-    // `valid` is oldest-first (ledger order), so the newest are at the tail.
-    const omittedCount = Math.max(0, valid.length - OPERATING_NOTES_PROMPT_CAP);
-    const shown = omittedCount > 0 ? valid.slice(-OPERATING_NOTES_PROMPT_CAP) : valid;
+    // Lifecycle selection: pinned-always + expired-unpinned-dropped +
+    // superseded-dropped + rank (pinned > durable > recency) + same-class fold +
+    // byte-budget/count cap. `shown` is already highest-priority-first and carries
+    // per-entry fold info; renderOperatingNoteLine emits the exact bytes the
+    // budget was measured against.
+    const { shown, omittedCount } = selectOperatingNotesForPrompt(notes ?? [], now);
+    if (shown.length === 0) return '';
 
     const lines: string[] = ['## Operating Notes', ''];
     lines.push('Lessons earlier coordinators on this mesh recorded via `mesh_record_note`. Treat them as accumulated operating knowledge — apply them. When you learn a durable lesson (a provider quirk, a pattern to avoid, a recovery lesson), record it with `mesh_record_note` so future coordinators inherit it.');
     lines.push('');
-    for (const n of shown) {
-        const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : '';
-        lines.push(`- ${cat}${truncateNote(n.text.trim())}`);
+    for (const entry of shown) {
+        lines.push(renderOperatingNoteLine(entry));
     }
     if (omittedCount > 0) {
         lines.push('');
-        lines.push(`_${omittedCount} older note${omittedCount === 1 ? '' : 's'} omitted (kept in ledger; prune with \`mesh_forget_note\`)._`);
+        lines.push(`_${omittedCount} lower-priority note${omittedCount === 1 ? '' : 's'} omitted to fit the injection cap/byte-budget (kept in ledger; expired, superseded, and same-subject-folded notes are also hidden from this list but retained for audit; prune with \`mesh_forget_note\`)._`);
     }
     return lines.join('\n');
 }
@@ -761,7 +1007,8 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_restart_daemon\` | Update a node's daemon to the latest published version on its channel and restart it (the dashboard "preview update" path, as a mesh command) |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
-| \`mesh_approve\` | Approve/reject a pending agent action |
+| \`mesh_approve\` | Approve/reject a pending agent action (a yes/no tool-consent modal) |
+| \`mesh_answer_question\` | Answer a delegated session's multi-choice QUESTION (AskUserQuestion / status awaiting_choice). NOT an approval — it offers labelled options (possibly multi-select or freeform). Pass the promptId from the agent:waiting_choice event + one answer per question (select by option label or 1-based index). Use this, never mesh_approve, for a question |
 | \`mesh_list_pending_approvals\` | List every session across the mesh awaiting an approval decision (the approval inbox) — read-only; enumerate all blocked sessions at once, then drive a mesh_approve for each |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
 | \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |

package/src/mesh/mesh-active-work.ts

@@ -5,7 +5,7 @@ import { deleteDirectDispatchesByTaskId } from './mesh-work-queue.js';
 import { meshNodeIdMatches, daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 
 export type MeshActiveWorkSource = 'queue' | 'direct';
-export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval' | 'awaiting_choice';
 
 export interface MeshActiveWorkRecord {
     taskId: string;
@@ -135,6 +135,10 @@ export function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string
     if (!session) return { staleReason: 'direct task session is not present in live session records' };
     if (typeof session === 'string') return {};
     const raw = `${readString(session.status) || ''} ${readString(session.lifecycle) || ''} ${readString(session.state) || ''} ${readString(session.activeChat?.status) || ''}`.toLowerCase();
+    // A question picker surfaces as waiting_choice — distinct from an approval modal.
+    // Check it first so a question worker is not mislabeled awaiting_approval and
+    // pulled into the approval inbox (mission f1d25e11).
+    if (raw.includes('waiting_choice') || raw.includes('choice')) return { status: 'awaiting_choice' };
     if (raw.includes('approval')) return { status: 'awaiting_approval' };
     if (raw.includes('generating') || raw.includes('running') || raw.includes('busy')) return { status: 'generating' };
     if (raw.includes('failed') || raw.includes('stopped') || raw.includes('terminated') || raw.includes('exited')) return { status: 'failed' };
@@ -166,6 +170,10 @@ function terminalMatchesDispatch(terminal: MeshLedgerEntry, dispatch: MeshLedger
 
 function statusFromTerminal(entry: MeshLedgerEntry): MeshActiveWorkStatus {
     if (entry.kind === 'task_approval_needed') return 'awaiting_approval';
+    // A question (waiting_choice) is a distinct blocked state — kept OUT of
+    // awaiting_approval so it is not surfaced in the approval inbox / mesh_approve
+    // flow (mission f1d25e11). Answered via mesh_answer_question.
+    if (entry.kind === 'task_question_pending') return 'awaiting_choice';
     if (entry.kind === 'task_completed') return 'idle';
     return 'failed';
 }
@@ -331,6 +339,7 @@ export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]):
         idle: 0,
         failed: 0,
         awaiting_approval: 0,
+        awaiting_choice: 0,
     };
     const sourceCounts: Record<MeshActiveWorkSource, number> = { queue: 0, direct: 0 };
     for (const item of activeWork) {
@@ -380,6 +389,7 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             ? sessionStatusFromNodes(opts.nodes, queueNodeId ?? undefined, queueSessionId ?? undefined)
             : {};
         const queueStatus: MeshActiveWorkStatus = queueLive.status === 'awaiting_approval'
+            || queueLive.status === 'awaiting_choice'
             || queueLive.status === 'generating'
             ? queueLive.status
             : task.status;

package/src/mesh/mesh-completion-synthesis.ts

@@ -26,7 +26,7 @@ import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
 import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
-import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
+import { extractFinalAssistantSummaryEvidence, hasTrailingToolActivityAfterFinalAssistant } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 import {
     getMeshV2BackstopCounters,
@@ -483,6 +483,17 @@ export async function pollAssignedTaskTerminalEvidence(
     const evidence = extractFinalAssistantSummaryEvidence(messages);
     if (!evidence.finalSummary) return null; // idle but no assistant result yet → not a turn-end
 
+    // EARLY-IDLE-COMPLETION-FALSE-POSITIVE (poll defense-in-depth): a momentary idle read
+    // (startup-grace, or the sliver between an assistant preamble and the tool it fires) can
+    // show an assistant "Let me explore…" bubble FOLLOWED by trailing Read/Grep tool_use — a
+    // turn that is still executing, not a turn-end. selectFinalAssistantTurnEndMessage skips
+    // those trailing tool bubbles and would promote the preamble, so guard here: if a
+    // tool/terminal activity bubble trails the final assistant message, the worker is mid-turn
+    // — refuse the completion (fall through to the caller's reclaim/grace path). A genuinely
+    // finished pure-PTY worker ends on its final assistant with no trailing tool activity, so
+    // the kimi rescue is preserved.
+    if (hasTrailingToolActivityAfterFinalAssistant(messages)) return null;
+
     // Stale-summary guard (same bar as PHASE 4): a reused session's transcript tail may hold a
     // PRIOR task's summary. Require the final assistant message to be dated at/after THIS task's
     // dispatch. When either timestamp is unusable, do NOT short-circuit — fall through so we never