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

package/src/mesh/coordinator-prompt.ts

@@ -34,7 +34,6 @@ 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';
 
@@ -85,41 +84,6 @@ 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 ─────────────────────────────
@@ -618,243 +582,33 @@ function buildRecentActivitySection(activity?: CoordinatorRecentActivity): strin
 const OPERATING_NOTES_PROMPT_CAP = 20;
 const OPERATING_NOTE_MAX_CHARS = 300;
 
-/**
- * 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 } {
+function buildOperatingNotesSection(notes?: CoordinatorOperatingNote[]): string {
     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 '';
 
-    // 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 '';
+    // 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;
 
     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 entry of shown) {
-        lines.push(renderOperatingNoteLine(entry));
+    for (const n of shown) {
+        const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : '';
+        lines.push(`- ${cat}${truncateNote(n.text.trim())}`);
     }
     if (omittedCount > 0) {
         lines.push('');
-        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\`)._`);
+        lines.push(`_${omittedCount} older note${omittedCount === 1 ? '' : 's'} omitted (kept in ledger; prune with \`mesh_forget_note\`)._`);
     }
     return lines.join('\n');
 }
@@ -1007,8 +761,7 @@ 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 (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_approve\` | Approve/reject a pending agent action |
 | \`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' | 'awaiting_choice';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
 
 export interface MeshActiveWorkRecord {
     taskId: string;
@@ -135,10 +135,6 @@ 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' };
@@ -170,10 +166,6 @@ 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';
 }
@@ -339,7 +331,6 @@ 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) {
@@ -389,7 +380,6 @@ 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, hasTrailingToolActivityAfterFinalAssistant } from '../providers/chat-message-normalization.js';
+import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 import {
     getMeshV2BackstopCounters,
@@ -483,17 +483,6 @@ 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

package/src/mesh/mesh-event-classify.ts

@@ -8,11 +8,6 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'agent:generating_started',
     'agent:generating_completed',
     'agent:waiting_approval',
-    // A worker parked on an AskUserQuestion multi-choice prompt. DISTINCT from
-    // agent:waiting_approval (a yes/no tool-consent modal): a question is answered
-    // with mesh_answer_question, never mesh_approve (mission f1d25e11). Carries the
-    // full InteractivePrompt payload so the coordinator can render + answer.
-    'agent:waiting_choice',
     'agent:stopped',
     'agent:ready',
     'monitor:no_progress',
@@ -31,7 +26,6 @@ const MESH_COORDINATOR_EVENTS = new Set([
 export const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind> = {
     'agent:generating_completed': 'task_completed',
     'agent:waiting_approval': 'task_approval_needed',
-    'agent:waiting_choice': 'task_question_pending',
     'agent:stopped': 'task_failed',
     'monitor:no_progress': 'task_stalled',
 };
@@ -51,11 +45,6 @@ export const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string> = new Set([
     'agent:generating_completed',
     'agent:stopped',
     'agent:waiting_approval',
-    // A worker's question (waiting_choice) is real-time and the coordinator may be
-    // generating when it arrives; force-inject it like approval so the busy coordinator
-    // learns it must answer (mesh_answer_question) rather than the nudge sitting in the
-    // adapter's outbound queue until the coordinator idles on its own (mission f1d25e11).
-    'agent:waiting_choice',
     'refine:completed',
     'refine:failed',
     'worktree_bootstrap_complete',
@@ -82,14 +71,6 @@ export function shouldForceInjectMeshEvent(eventName: unknown): boolean {
 //     require, and why a stale/resolved approval nudge can simply be dropped.
 export const MESH_APPROVAL_EVENTS: ReadonlySet<string> = new Set([
     'agent:waiting_approval',
-    // agent:waiting_choice (a worker's AskUserQuestion) shares the approval class's
-    // real-time-nudge / level-backed contract: its authoritative state is recorded at
-    // LEVEL the moment it is processed (task_question_pending → mesh_status
-    // awaiting_choice), so the pending event is only a NUDGE and can be delivered to a
-    // busy coordinator's inbox (and dropped) without data loss — the level state
-    // re-derives it. It is therefore exempt from the idle-edge hold completions require,
-    // exactly like an approval nudge (mission f1d25e11).
-    'agent:waiting_choice',
 ]);
 
 export function isMeshApprovalEvent(eventName: unknown): boolean {

package/src/mesh/mesh-event-forwarding.ts

@@ -16,8 +16,7 @@ import { resolveMeshHostStatus } from './mesh-host-ownership.js';
 import { enqueueUnresolvedDelegateForward, nudgeUnresolvedForwardRetry } from './mesh-unresolved-forward-outbox.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
-import { delegatedWorkerAutoApproveSettings } from '../repo-mesh-types.js';
-import { loadRepoMeshJsonConfig } from '../config/mesh-json-config.js';
+import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
 import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, withStatusProbeMarker, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
@@ -1072,44 +1071,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         // C2: prefer an exact taskId match when the completion event carries one —
         // it's immune to coordinator↔worker clock skew that can hide the assigned row.
         const eventTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
-        // WEAK-QUEUE-TENTATIVE (early-completed safety net, symmetric with the direct-dispatch
-        // `tentativeIfDirect` guard below): a `completed` outcome whose evidence is WEAK — a
-        // false-idle / missing_final_assistant emit (the CANON-C decoupled-immediate path that
-        // stamps evidenceLevel=insufficient) — must NOT hard-flip a matched QUEUE row to
-        // terminal. Until this net, only DIRECT dispatches were kept tentative on weak evidence;
-        // a queue-claimed task's session flipped its row to 'completed' unconditionally, so a
-        // worker that dropped to idle ~13s in with no final assistant closed the task early even
-        // though it never produced an answer. Leaving the row 'assigned' hands it to the reconcile
-        // loop's proven net (PHASE 4 records the GENUINE completion once the transcript lands via
-        // findTerminalLedgerEvidenceForTask; PHASE 2.5 reclaims a truly-stranded row back to
-        // 'pending' for re-dispatch, bounded by MAX_STRANDED_RECLAIMS) — never a permanent wedge.
-        //
-        // CRUCIAL SCOPE: this covers only the PREMATURE decoupled-immediate emit
-        // (emittedAfterFinalizationTimeout !== true). A weak completion that already waited out the
-        // full 30s COMPLETED_FINALIZATION_MAX_WAIT_MS window (emittedAfterFinalizationTimeout=true)
-        // is a GENUINE — if answerless — terminal: the worker exhausted its finalization wait and
-        // is done, so it flips 'completed' as before (a tool-only turn that never produced an
-        // assistant bubble must still close its task). A `failed` outcome or a completion with
-        // genuine evidence flips terminal as before too.
-        const completionDiagnostic = args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === 'object'
-            ? args.metadataEvent.completionDiagnostic as Record<string, unknown>
-            : undefined;
-        const emittedAfterFinalizationTimeout = completionDiagnostic?.emittedAfterFinalizationTimeout === true;
-        const weakCompleted = outcome === 'completed'
-            && isWeakCompletionEvidence(args.metadataEvent)
-            && !emittedAfterFinalizationTimeout;
-        const task = weakCompleted
-            ? updateSessionTaskStatus(args.meshId, sessionId, 'assigned', {
-                occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
-                taskId: eventTaskId,
-            })
-            : updateSessionTaskStatus(args.meshId, sessionId, outcome, {
-                occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
-                taskId: eventTaskId,
-            });
-        if (weakCompleted && task) {
-            LOG.info('MeshQueue', `Weak completion (${readNonEmptyString(args.metadataEvent.evidenceLevel) || 'missing_final_assistant'}) kept queue task ${task.id} tentative (session ${sessionId}); reconcile owns the genuine terminal`);
-        }
+        const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
+            occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
+            taskId: eventTaskId,
+        });
         // Fix A (early-terminal prevention): a false-idle completion (no confirmed final
         // assistant) for a DIRECT dispatch — i.e. no work-queue row matched — must not flip the
         // dispatch row terminal. Leaving it active lets the reconcile loop (PHASE 4) re-read the
@@ -1615,22 +1580,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                                     spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || 'hidden',
                                     // Coordinator-dispatched recovery relaunch: same auto-approve
                                     // policy as the primary worker launch path.
-                                    ...delegatedWorkerAutoApproveSettings(
-                                        mesh?.policy,
-                                        node?.policy,
-                                        components.providerLoader?.getMeta(recoveryContext.failedProviderType),
-                                        // Recovery relaunch: same repo-declared requested mode as the
-                                        // primary path. node.workspace missing → null → provider default.
-                                        (() => {
-                                            const ws = typeof node?.workspace === 'string' && node.workspace.trim() ? node.workspace.trim() : '';
-                                            if (!ws) return null;
-                                            try {
-                                                const r = loadRepoMeshJsonConfig(ws);
-                                                return r.sourceType === 'repo_file' && r.config ? r.config : null;
-                                            } catch { return null; }
-                                        })(),
-                                        recoveryContext.failedProviderType,
-                                    ),
+                                    autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
                                     launchedByCoordinator: true,
                                 }
                             }).catch((e: any) => LOG.error('MeshRecovery', `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));
@@ -1804,14 +1754,6 @@ export function buildRelayMetadataEvent(payload: Record<string, unknown>): Recor
         retryOfJobId: readNonEmptyString(payload.retryOfJobId),
         ...(relayModalMessage ? { modalMessage: relayModalMessage } : {}),
         ...(relayModalButtons && relayModalButtons.length > 0 ? { modalButtons: relayModalButtons } : {}),
-        // agent:waiting_choice (mission f1d25e11): carry the FULL structured question
-        // payload across the machine boundary so a REMOTE worker's AskUserQuestion reaches
-        // the coordinator with every question + option intact — the coordinator renders
-        // these and answers with mesh_answer_question. The local in-process forward path
-        // preserves the whole event for free; this mirrors the fields for the remote relay.
-        ...(payload.interactivePrompt && typeof payload.interactivePrompt === 'object' && !Array.isArray(payload.interactivePrompt) ? { interactivePrompt: payload.interactivePrompt } : {}),
-        ...(readNonEmptyString(payload.promptId) ? { promptId: readNonEmptyString(payload.promptId) } : {}),
-        ...(payload.multiSelect === true ? { multiSelect: true } : {}),
         ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
         ...(payload.completionDiagnostic && typeof payload.completionDiagnostic === 'object' && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {}),
         ...(payload.workerResult && typeof payload.workerResult === 'object' && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {}),

package/src/mesh/mesh-events-utils.ts

@@ -330,48 +330,6 @@ export function buildMeshSystemMessage(args: {
     if (args.event === 'agent:waiting_approval') {
         return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
     }
-    if (args.event === 'agent:waiting_choice') {
-        // A multi-choice QUESTION (AskUserQuestion) — NOT an approval. It is answered with
-        // mesh_answer_question (never mesh_approve). Surface the question text + choices
-        // inline so the coordinator can decide without a mesh_read_chat round-trip, and
-        // name the correct tool + promptId (mission f1d25e11).
-        const prompt = args.metadataEvent.interactivePrompt as
-            | { promptId?: unknown; questions?: Array<Record<string, unknown>> }
-            | undefined;
-        const promptId = readNonEmptyString(args.metadataEvent.promptId)
-            || (prompt && readNonEmptyString(prompt.promptId));
-        const lines: string[] = [
-            `[System] ${args.nodeLabel} is asking a question and is waiting for your answer${metadata}.`,
-        ];
-        const questions = Array.isArray(prompt?.questions) ? prompt!.questions! : [];
-        if (questions.length > 0) {
-            for (const q of questions) {
-                const header = readNonEmptyString(q.header);
-                const question = readNonEmptyString(q.question);
-                const multiSelect = q.multiSelect === true;
-                if (question) {
-                    lines.push(`\n**${header ? `${header}: ` : ''}${question}**${multiSelect ? ' (select one or more)' : ''}`);
-                }
-                const options = Array.isArray(q.options) ? q.options : [];
-                options.forEach((opt, i) => {
-                    const record = (opt && typeof opt === 'object') ? opt as Record<string, unknown> : {};
-                    const label = readNonEmptyString(record.label);
-                    if (!label) return;
-                    const description = readNonEmptyString(record.description);
-                    lines.push(`  ${i + 1}. ${label}${description ? ` — ${description}` : ''}`);
-                });
-            }
-        } else {
-            const modalMessage = readNonEmptyString(args.metadataEvent.modalMessage);
-            if (modalMessage) lines.push(`\n${modalMessage}`);
-        }
-        lines.push(
-            `\nAnswer with mesh_answer_question(node_id, session_id${promptId ? `, promptId: "${promptId}"` : ''}, answers). ` +
-            `Do NOT use mesh_approve — that only resolves yes/no consent modals, not a question. ` +
-            `Use mesh_read_chat once if you need the full context first.`,
-        );
-        return lines.join('\n');
-    }
     if (args.event === 'agent:stopped') {
         const rc = args.recoveryContext;
         if (rc && rc.consecutiveNodeFailures > 0) {