@adhdev/daemon-core 0.9.82-rc.466 → 0.9.82-rc.468

package/dist/providers/cli-provider-effect-format.d.ts

@@ -0,0 +1,30 @@
+export declare function getEffectDedupKey(effect: {
+    id?: string;
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+    };
+}): string;
+export declare function getPersistedEffectContent(effect: {
+    type: string;
+    message?: {
+        content?: unknown;
+    };
+    toast?: {
+        message?: string;
+    };
+    notification?: {
+        title?: string;
+        body?: string;
+        bubbleContent?: unknown;
+    };
+}): string | null;
+export declare function formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string;
+export declare function formatMarkerTimestamp(timestamp: number): string;

package/dist/providers/cli-provider-instance-types.d.ts

@@ -0,0 +1,45 @@
+export declare const STATUS_HYDRATION_TAIL_LIMIT = 200;
+export type CompletedDebouncePending = {
+    chatTitle: string;
+    duration: number;
+    timestamp: number;
+    firstObservedAt: number;
+    previousStatus: string;
+    loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+    taskId?: string;
+    turnStartedAt?: number;
+    busyEpochAtArm?: number;
+    lastOutputAtArm?: number;
+};
+export type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+    allowTimeout?: boolean;
+    holdForTranscript?: boolean;
+};
+export type CompletionFinalAssistantEvidence = {
+    present: boolean;
+    messages: unknown[];
+    source: 'parsed' | 'external-native' | 'unavailable';
+};
+export type ExternalTranscriptProbe = {
+    readAt: number;
+    msgCount: number;
+    lastRole: string | null;
+    lastKind: string | null;
+    contentLen: number;
+    sourcePath: string | null;
+    sourceMtimeMs: number | null;
+    mtimeAgeMs: number | null;
+};
+export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
+export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
+export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+export declare const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60000;
+export declare const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12000;
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+export declare const TERMINAL_MESH_EVENTS: Set<string>;

package/dist/providers/cli-provider-instance.d.ts

@@ -278,7 +278,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private lastExternalCompletionProbe;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
-    private buildExternalTranscriptProbe;
     private recordPendingTranscriptProbe;
     /**
      * The spawned CLI's env overrides (e.g. the mesh coordinator points hermes
@@ -312,6 +311,18 @@ export declare class CliProviderInstance implements ProviderInstance {
      * genuine resolution frees the gate promptly.
      */
     private autoApproveContinuityWindowMs;
+    /**
+     * The settle-gate identity signature for a raw activeModal, or null when the
+     * modal is NOT a concrete auto-approvable consent prompt (no captured buttons,
+     * a picker/confirm kind, or no reliable affirmative+decline anchor). Mirrors the
+     * gates the auto-approve fire path applies before computing modalSignature, so
+     * the mask-stall nudge can ask the SAME question the settle gate is tracking —
+     * "is THIS frame's modal the identity the settle clock is accruing against?" —
+     * without duplicating the button-pick logic. The signature is message +
+     * normalized affirmative label only (no volatile counters/button set), matching
+     * the fire path exactly (AUTOAPPROVE-SETTLE-FLAP).
+     */
+    private approvableModalSignature;
     private isAutonomousMeshSession;
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
@@ -378,8 +389,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pushEvent;
     private flushEvents;
     private applyProviderResponse;
-    private getEffectDedupKey;
-    private getPersistedEffectContent;
     getAdapter(): ProviderCliAdapter;
     get cliType(): string;
     get cliName(): string;
@@ -422,13 +431,10 @@ export declare class CliProviderInstance implements ProviderInstance {
     private maybeEmitStalledApprovalNudge;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
-    private formatMarkerTimestamp;
     private maybeAppendRuntimeRecoveryMessage;
     private appendRuntimeSystemMessage;
     private appendRuntimeMessage;
     mergeRuntimeChatMessages(parsedMessages: ChatMessage[]): ChatMessage[];
-    private mergeConversationMessages;
-    private formatApprovalRequestMessage;
     private promoteProviderSessionId;
     private shouldHydrateExistingProviderHistory;
     private shouldSuppressFreshLaunchStartupReplay;

package/dist/providers/cli-provider-transcript-merge.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from '../types.js';
+import type { ExternalTranscriptProbe } from './cli-provider-instance-types.js';
+export declare function mergeConversationMessages(runtimeMessages: Array<{
+    key: string;
+    message: ChatMessage;
+}>, parsedMessages: any[]): ChatMessage[];
+export declare function buildExternalTranscriptProbe(messages: unknown[], sourcePath?: string, sourceMtimeMs?: number): ExternalTranscriptProbe;

package/package.json

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

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

@@ -551,6 +551,8 @@ export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent)
 // wasDirectDeliveredToCoordinator) was removed when spontaneous PTY direct-inject was retired.
 // Delivery is now queue-drain-only: an event is consumed by exactly one drainer via the atomic
 // SQLite drained=1 marking, so there is no PTY-vs-poll double-delivery left to dedup against.
+// The dormant mesh_direct_delivered_events table that backed it was dropped in
+// MeshRuntimeStore.migrateMeshIsolationColumns (DROP TABLE IF EXISTS, migration step 5).
 
 export function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
     const fingerprint = buildPendingEventFingerprint(event);

package/src/mesh/mesh-reconcile-loop.ts

@@ -1531,7 +1531,11 @@ async function pullRemoteNodeQueues(
         ? candidateDaemonIds.map(id => ({ meshId, coordinatorDaemonId: id }))
         : [{ meshId }];
 
-    for (const node of mesh.nodes) {
+    // Parallelize across nodes: a single connected-but-slow node must not serially
+    // block the other nodes for the rest of the tick. Each node callback is fully
+    // self-contained (local/candidate skip, peer-connected pre-check, per-candidate
+    // pulls, extract→re-inject) and best-effort — allSettled swallows per-node errors.
+    await Promise.allSettled(mesh.nodes.map(async (node) => {
         const nodeDaemonId = readNonEmptyString(node.daemonId);
         // Skip nodes without a daemon, and nodes on THIS daemon (their events are
         // already in the local queue drained in PHASE 2). "This daemon" is matched
@@ -1539,9 +1543,22 @@ async function pullRemoteNodeQueues(
         // localDaemonId — a self node can be registered under the config-form daemonId
         // (`daemon_<machineId>`) which would NOT equal bare localDaemonId, and pulling
         // from ourselves over P2P is both wasteful and a self-dispatch hazard.
-        if (!nodeDaemonId) continue;
-        if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
+        if (!nodeDaemonId) return;
+        if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
+        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
+
+        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a)): a degraded peer whose
+        // DataChannel is not open would sink this pull into peer.connectQueue and stall
+        // until CONNECT_TIMEOUT_MS (90s), formerly freezing the whole serial loop and
+        // delaying completion-event recovery from healthy nodes. Skip such a node THIS
+        // tick and retry next tick — LOSSLESS: an unconnected peer has not drained
+        // anything (drained=0 preserved), so its events are recovered whole on the next
+        // successful tick. Skip = delay, never loss.
+        //   • snapshot present and state !== 'connected' → skip (continue next tick).
+        //   • snapshot null/undefined (getter unwired, e.g. standalone) → DO NOT skip;
+        //     fall through to the legacy path so this stays regression-free.
+        const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
+        if (peerSnapshot && String(peerSnapshot.state) !== 'connected') return;
 
         for (const pendingEventArgs of pulls) {
             let events: unknown;
@@ -1560,7 +1577,7 @@ async function pullRemoteNodeQueues(
                 } catch { /* best-effort re-inject */ }
             }
         }
-    }
+    }));
 }
 
 // Pull the read_chat payload out of whatever envelope the transport returned.
@@ -1989,6 +2006,16 @@ async function collectLiveNodesWithSessions(
         const isLocalNode = !nodeDaemonId
             || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
+        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a)): mirror pullRemoteNodeQueues.
+        // Without this the 90s connect-deadline block re-enters via this Promise.all —
+        // a degraded remote's get_status_metadata sinks into peer.connectQueue and stalls
+        // the whole prune probe. Only call the remote when the peer is 'connected'; an
+        // unconnected peer is left undecorated (empty session list), same as unreachable.
+        // Getter unwired (null/undefined) → do NOT skip, fall through (regression-free).
+        if (!isLocalNode) {
+            const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
+            if (peerSnapshot && String(peerSnapshot.state) !== 'connected') return node;
+        }
         let statusResult: unknown;
         try {
             if (isLocalNode) {

package/src/mesh/mesh-runtime-store.ts

@@ -1,7 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync } from 'fs';
 import { dirname, join } from 'path';
 import { LOG } from '../logging/logger.js';
 import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
+import { getConfigDir } from '../config/config.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags, isTaskReadonly, taskDependenciesSatisfied } from './mesh-work-queue.js';
 import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent } from '@adhdev/mesh-shared';
@@ -39,10 +40,43 @@ function legacyQueuePath(meshId: string): string {
 }
 
 let loggedMigrationFailure = false;
+let loggedStrayCleanup = false;
+
+/**
+ * MESH-COMPLEXITY-AUDIT Part 8-1: one-shot hygiene for a stray root mesh-runtime.db.
+ *
+ * The store lives at `~/.adhdev/mesh-ledger/mesh-runtime.db` (getLedgerDir()). An older
+ * build path could create a 0-byte `mesh-runtime.db` directly under `~/.adhdev/` — a
+ * dead file that is never opened or read (the canonical path is the only one used) but
+ * lingers. Remove it if and only if it is provably that stray: (a) exists, (b) is NOT the
+ * canonical store path, and (c) is empty (0 bytes). The size gate is the safety belt — we
+ * never unlink a non-empty file, so a real DB that somehow landed here is left untouched
+ * and surfaces as data rather than being silently deleted. Best-effort: any error is
+ * swallowed (with one diagnostic warn), never blocking store init.
+ */
+function cleanupStrayRootRuntimeDb(canonicalPath: string): void {
+    try {
+        const strayPath = join(getConfigDir(), 'mesh-runtime.db');
+        if (strayPath === canonicalPath) return; // canonical dir IS the config dir — never touch
+        if (!existsSync(strayPath)) return;
+        if (statSync(strayPath).size !== 0) return; // non-empty → not the known 0-byte stray; leave it
+        unlinkSync(strayPath);
+        if (!loggedStrayCleanup) {
+            loggedStrayCleanup = true;
+            LOG.info('MeshRuntimeStore', `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
+        }
+    } catch (err: any) {
+        if (!loggedStrayCleanup) {
+            loggedStrayCleanup = true;
+            LOG.warn('MeshRuntimeStore', `Stray root mesh-runtime.db cleanup failed (ignored): ${err?.message || err}`);
+        }
+    }
+}
 
 function meshRuntimeStorePath(): string {
     const dir = getLedgerDir();
     const nextPath = join(dir, 'mesh-runtime.db');
+    cleanupStrayRootRuntimeDb(nextPath);
     if (existsSync(nextPath)) return nextPath;
 
     const legacyPath = join(dir, 'beads.db');
@@ -459,6 +493,17 @@ export class MeshRuntimeStore {
                     ON mesh_pending_events(mesh_id, event_id)
                     WHERE event_id IS NOT NULL
             `);
+
+            // 5. MESH-COMPLEXITY-AUDIT Part 8-1: drop the legacy mesh_direct_delivered_events
+            //    table. It backed the retired R3 "direct-delivered" dedup marker
+            //    (markMeshCoordinatorEventDirectDelivered / wasDirectDeliveredToCoordinator,
+            //    removed when spontaneous PTY direct-inject was retired — see the NOTE in
+            //    mesh-events-pending.ts). No live code CREATEs, reads, or writes it anymore,
+            //    so this is a pure runtime-residue cleanup with no behavior change: a store
+            //    that never had the table just no-ops (IF EXISTS), an old install carrying
+            //    the dormant table has it removed once. Idempotent — DROP TABLE IF EXISTS is
+            //    a no-op on every subsequent boot.
+            this.db.exec(`DROP TABLE IF EXISTS mesh_direct_delivered_events`);
         } catch (err: any) {
             // Best-effort: a failed isolation migration must not brick the store. The
             // CREATE-TABLE definitions above already carry the new schema for fresh DBs;

package/src/providers/cli-provider-effect-format.ts

@@ -0,0 +1,53 @@
+// Provider-effect dedup and message-formatting helpers extracted from
+// cli-provider-instance.ts. Pure move — no behavior change. None of these used
+// any instance state; they were private methods invoked only within the class.
+
+export function getEffectDedupKey(effect: { id?: string; type: string; message?: { content?: unknown }; toast?: { message?: string }; notification?: { title?: string; body?: string } }): string {
+    if (effect.id) return `provider_effect:${effect.id}`;
+    if (effect.type === 'message') {
+        const content = typeof effect.message?.content === 'string'
+            ? effect.message.content
+            : JSON.stringify(effect.message?.content || '');
+        return `provider_effect:message:${content}`;
+    }
+    if (effect.type === 'notification') {
+        return `provider_effect:notification:${effect.notification?.title || ''}:${effect.notification?.body || ''}`;
+    }
+    return `provider_effect:toast:${effect.toast?.message || ''}`;
+}
+
+export function getPersistedEffectContent(effect: { type: string; message?: { content?: unknown }; toast?: { message?: string }; notification?: { title?: string; body?: string; bubbleContent?: unknown } }): string | null {
+    if (effect.type === 'message') {
+        return typeof effect.message?.content === 'string'
+            ? effect.message.content
+            : JSON.stringify(effect.message?.content || '');
+    }
+    if (effect.type === 'toast') {
+        return effect.toast?.message || null;
+    }
+    if (effect.type === 'notification') {
+        if (typeof effect.notification?.bubbleContent === 'string') return effect.notification.bubbleContent;
+        if (typeof effect.notification?.title === 'string' && effect.notification.title.trim()) {
+            return `${effect.notification.title}\n${effect.notification.body || ''}`.trim();
+        }
+        return effect.notification?.body || null;
+    }
+    return null;
+}
+
+export function formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string {
+    const lines = ['Approval requested'];
+    const cleanMessage = String(modalMessage || '').trim();
+    if (cleanMessage) lines.push(cleanMessage);
+    const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
+    if (labels.length > 0) {
+        lines.push(labels.map((label) => `[${label}]`).join(' '));
+    }
+    return lines.join('\n');
+}
+
+export function formatMarkerTimestamp(timestamp: number): string {
+    const date = new Date(timestamp);
+    const pad = (value: number) => String(value).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}

package/src/providers/cli-provider-instance-types.ts

@@ -0,0 +1,131 @@
+// Module-level types and constants extracted from cli-provider-instance.ts.
+// Pure move — no behavior change. These were module-private in the original
+// file; they are re-imported by cli-provider-instance.ts and used identically.
+
+// Status snapshots only ever surface the newest messages: the cloud 'live'
+// profile drops chat messages entirely (loaded lazily via read_chat on
+// subscribe) and the 'full' profile caps activeChat.messages to the last 60
+// (see status/normalize.ts). Unread/completion markers walk only the tail.
+// So getState()'s saved-history hydration — which runs once per resume/manual
+// CLI session on every status report — must read only a bounded tail, not the
+// entire transcript. A full MAX_SAFE_INTEGER read here makes the initial
+// status report O(transcript) × N(sessions), which is the real cold first-
+// connection bottleneck on chat-heavy machines. The window comfortably exceeds
+// the 60-message snapshot cap so dedup/collapse at the boundary stays stable.
+export const STATUS_HYDRATION_TAIL_LIMIT = 200;
+
+export type CompletedDebouncePending = {
+    chatTitle: string;
+    duration: number;
+    timestamp: number;
+    firstObservedAt: number;
+    previousStatus: string;
+    loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+    // ARCH-REFACTOR R1: the taskId of the turn that produced this (debounced) completion,
+    // captured SYNCHRONOUSLY at the generating→idle transition. The actual completion
+    // event is emitted later by the debounce flush, by which point a follow-up task may
+    // already have started its own turn and overwritten engine.currentTurnTaskId — so the
+    // id must be snapshotted here, not re-read at flush time.
+    taskId?: string;
+    // NOTIF Defect-B: the wall-clock start of the turn that produced this (debounced)
+    // completion, snapshotted SYNCHRONOUSLY at the generating→idle transition (same
+    // reason as taskId — a follow-up turn moves engine.currentTurnStartedAt). The
+    // completion's finalSummary is turn-scoped to bubbles at/after this instant so a
+    // debounce that flushes before the producing turn's final assistant bubble lands
+    // in the native transcript never echoes the PRIOR task's last bubble.
+    turnStartedAt?: number;
+    // FALSE-IDLE continuity: the busyEpoch value at the instant this pending was armed.
+    // The flush guard requires this.busyEpoch to still equal this — proving no busy
+    // phase (generating/waiting_approval) opened since arming. A momentary busy→idle
+    // blip in an inter-approval valley bumps busyEpoch, so a completion armed before
+    // the blip is cancelled at flush instead of emitting a stale mid-turn summary.
+    busyEpochAtArm?: number;
+    // FALSE-IDLE continuity: the adapter's raw PTY lastOutputAt at arm time. New PTY
+    // output after arming means the session was not continuously idle through the
+    // settle window (the agent kept printing), so the completion is cancelled.
+    lastOutputAtArm?: number;
+};
+
+export type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+    allowTimeout?: boolean;
+    // (SETTLE-VALLEY) When set, suppress the CANON-C decoupled-immediate emit for this
+    // missing_final_assistant block and HOLD (retry up to COMPLETED_FINALIZATION_MAX_WAIT_MS)
+    // until the native transcript's final assistant turn arrives (block clears → genuine emit)
+    // or the worker resumes (resume guard cancels). Set only for the inter-approval idle valley
+    // of a native-history mesh worker, where an immediate weak emit would freeze a truncated
+    // preamble summary (evidenceLevel=insufficient) into the append-only ledger before the
+    // worker's next approval turn resumes. Independent of valley length.
+    holdForTranscript?: boolean;
+};
+
+export type CompletionFinalAssistantEvidence = {
+    present: boolean;
+    messages: unknown[];
+    source: 'parsed' | 'external-native' | 'unavailable';
+};
+
+export type ExternalTranscriptProbe = {
+    readAt: number;
+    msgCount: number;
+    lastRole: string | null;
+    lastKind: string | null;
+    contentLen: number;
+    sourcePath: string | null;
+    sourceMtimeMs: number | null;
+    mtimeAgeMs: number | null;
+};
+
+export const COMPLETED_FINALIZATION_RETRY_MS = 1000;
+export const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
+// (FALSEIDLE-BGCHILD-a) Minimum generating→idle settle window for native-history mesh worker
+// sessions. Native-history providers (e.g. claude-cli) normally flush the completion with
+// flushDelay=0 — the transcript is authoritative, so there is no reason to wait. But a worker
+// turn that spawns a BACKGROUND child (e.g. `npm test &`, a backgrounded Bash tool) can paint
+// a burst of child output, fall quiet, and have the screen parser read a PRIOR/intermediate
+// standard assistant as if the turn were done — firing a false idle while the agent is in fact
+// still generating (e.g. mid-commit). With flushDelay=0 there is no window for the resume guard
+// in flushCompletedDebounceIfFinalized (latestVisibleStatus !== 'idle' → cancel) to observe the
+// agent picking the turn back up. A short non-zero settle window restores that resume guard for
+// mesh workers without delaying genuinely-finished turns beyond this bound. Scoped to mesh
+// worker sessions so interactive native-history sessions keep the immediate flush.
+// 4000ms (was 1500): live measurement showed the completion event can fire 1.6–3s
+// BEFORE the worker's final-assistant turn lands in the transcript on a natural
+// generating→idle completion (no approval modal), freezing a prior intermediate
+// bubble as finalSummary (evidenceLevel=insufficient). The 68a3c324 waiting_approval
+// hold only covers the approval-resolved valley; widening this settle window to 4000ms
+// covers that race AND the ~3s waiting_approval valley within the settle bound.
+export const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+// TASKBUBBLE-DUP: window during which an identical user-input ack (same trimmed
+// content on the same instance) is treated as a redelivery of one dispatch and
+// suppressed from the chat transcript. Matches the coordinator-side
+// DUPLICATE_DISPATCH_WINDOW_MS (mesh-tools) so the daemon's bubble-level guard
+// covers the same retry horizon as the MCP-level dispatch dedup.
+export const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60_000;
+// GENERATING-BOUNDARY (R4c): window — measured from the startup-grace COLLAPSE moment
+// (startupGraceCollapseAt), not boot — inside which a "first turn that ran+completed
+// without the FSM ever observing a 'generating' frame" is attributed to the startup-grace
+// collapse and synthesized (reason 'startup_grace_idle_turn_collapse').
+// The spec's startup-grace exit is elapsed_ms=8000, so the FSM spends ~8s in 'starting'
+// before collapsing to idle; a turn can be dispatched a few seconds AFTER that collapse
+// (the live R4b miss: collapse at boot+8s, dispatch at boot+12.4s — already past a 12s
+// boot-anchored window before the turn even started). Anchoring on the collapse moment
+// covers dispatch-delay; R4d additionally anchors on the turn-START moment
+// (engine.currentTurnStartedAt) so a non-trivial turn-DURATION cannot push the completion
+// past a now-anchored window (the live rc.405 Probe2 miss). The strong discriminator is
+// generatingStartedAt===0 (generating was never observed) AND a started-but-finished turn
+// — the window only keeps the synthesized reason honest and scopes the synthesis to the
+// boot collapse, so a much-later unobservably-fast turn is not mislabelled a startup collapse.
+export const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12_000;
+
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+export const TERMINAL_MESH_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:stopped',
+    'agent:ready',
+]);