@adhdev/daemon-core 1.0.18-rc.9 → 1.0.19

package/src/mesh/mesh-remote-event-pull.ts

@@ -60,57 +60,78 @@ export async function pullRemoteNodeQueues(
     // 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
-        // against the full self-identity set (candidateDaemonIds), not just the bare
-        // 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) return;
-        if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
-        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
+    await Promise.allSettled(mesh.nodes.map(node =>
+        pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls)));
+}
 
-        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a) + OFFLINE-NODE-FANOUT):
-        // 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.
-        //   • getter WIRED (cloud) → a null/undefined snapshot means "no peer object
-        //     right now" = NOT connected (a powered-off node whose failPeer just deleted
-        //     the peer each cycle). Treat it EXACTLY like state !== 'connected' and skip;
-        //     dialing here would re-queue for another 90s (the null-race the guard is
-        //     meant to prevent). Only a snapshot with state === 'connected' proceeds.
-        //   • getter UNWIRED (standalone) → DO NOT skip; fall through to the legacy path
-        //     so this stays regression-free (the standalone case the guard's history
-        //     references).
-        const getPeerStatus = components.getMeshPeerConnectionStatus;
-        if (getPeerStatus) {
-            const peerSnapshot = getPeerStatus(nodeDaemonId);
-            if (!peerSnapshot || String(peerSnapshot.state) !== 'connected') return;
-        }
+// Pull one node's pending coordinator events and re-inject them locally via
+// handleMeshForwardEvent (which runs the delivery-consume + re-queue paths). Factored
+// out of pullRemoteNodeQueues so the reconcile loop can also issue a TARGETED single-node
+// pull on demand — specifically, the DELIVERED-NOT-CONSUMED redrive gate calls this for
+// one node right before it would re-drive, so a worker's already-emitted (but not-yet-
+// pulled) agent:generating_started is consumed IN-PROCESS this tick instead of waiting for
+// the next PHASE 1 pull. That closes the redrive-vs-consume race: the redrive gate reads
+// taskDeliveryConsumed() AFTER this pull has had its chance to flip the delivery row.
+// Returns silently on any skip/error — every caller treats it as best-effort.
+export async function pullPendingEventsFromNode(
+    components: DaemonComponents,
+    meshId: string,
+    node: { daemonId?: string },
+    localDaemonId: string | undefined,
+    candidateDaemonIds: string[],
+    pulls: Array<Record<string, unknown>>,
+): Promise<void> {
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    if (!dispatchMeshCommand) return;
+    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
+    // against the full self-identity set (candidateDaemonIds), not just the bare
+    // 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) return;
+    if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
+    if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
 
-        for (const pendingEventArgs of pulls) {
-            let events: unknown;
+    // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a) + OFFLINE-NODE-FANOUT):
+    // 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.
+    //   • getter WIRED (cloud) → a null/undefined snapshot means "no peer object
+    //     right now" = NOT connected (a powered-off node whose failPeer just deleted
+    //     the peer each cycle). Treat it EXACTLY like state !== 'connected' and skip;
+    //     dialing here would re-queue for another 90s (the null-race the guard is
+    //     meant to prevent). Only a snapshot with state === 'connected' proceeds.
+    //   • getter UNWIRED (standalone) → DO NOT skip; fall through to the legacy path
+    //     so this stays regression-free (the standalone case the guard's history
+    //     references).
+    const getPeerStatus = components.getMeshPeerConnectionStatus;
+    if (getPeerStatus) {
+        const peerSnapshot = getPeerStatus(nodeDaemonId);
+        if (!peerSnapshot || String(peerSnapshot.state) !== 'connected') return;
+    }
+
+    for (const pendingEventArgs of pulls) {
+        let events: unknown;
+        try {
+            events = await dispatchMeshCommand(nodeDaemonId, 'get_pending_mesh_events', pendingEventArgs);
+        } catch {
+            // Remote pull is best-effort; the node may be offline. Retry next tick.
+            break; // node unreachable — don't bother with the other id form this tick.
+        }
+        const list = extractPendingEvents(events).filter(e => readNonEmptyString(e?.meshId) === meshId);
+        for (const event of list) {
+            const payload = buildForwardPayloadFromPending(event);
+            if (!payload.event || !payload.meshId) continue;
             try {
-                events = await dispatchMeshCommand(nodeDaemonId, 'get_pending_mesh_events', pendingEventArgs);
-            } catch {
-                // Remote pull is best-effort; the node may be offline. Retry next tick.
-                break; // node unreachable — don't bother with the other id form this tick.
-            }
-            const list = extractPendingEvents(events).filter(e => readNonEmptyString(e?.meshId) === meshId);
-            for (const event of list) {
-                const payload = buildForwardPayloadFromPending(event);
-                if (!payload.event || !payload.meshId) continue;
-                try {
-                    handleMeshForwardEvent(components, payload);
-                } catch { /* best-effort re-inject */ }
-            }
+                handleMeshForwardEvent(components, payload);
+            } catch { /* best-effort re-inject */ }
         }
-    }));
+    }
 }
 
 // Pull the read_chat payload out of whatever envelope the transport returned.

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

@@ -1231,6 +1231,19 @@ function propagateDependencyFailure(meshId: string, failedTaskId: string): MeshW
 
 const DEPENDENCY_FAILURE_TERMINALS = new Set<MeshTaskStatus>(['failed', 'cancelled']);
 
+/**
+ * CANCEL-STICKY-TERMINAL: the terminal task statuses. A row in one of these states is a
+ * historical record — no live dispatch owns it — and must NEVER be flipped back to an
+ * active (`pending`/`assigned`) state by a late writer. The canonical live example is a
+ * cancel that races the dispatch-failure `.catch` (mesh-queue-assignment.ts): that catch
+ * fires-and-forgets an unconditional `updateTaskStatus(...,'pending')`, resolving AFTER
+ * the cancel commits, which resurrected the cancelled row → it got re-claimed and the
+ * reclaim watchdog re-drove the same prompt. Guarding the write side (see
+ * {@link updateTaskStatus}) applies the same terminal-row protection
+ * {@link reclaimStrandedAssignedTask} already enforces to EVERY status writer at once.
+ */
+const TERMINAL_TASK_STATUSES = new Set<MeshTaskStatus>(['completed', 'failed', 'cancelled']);
+
 /**
  * G3 (step ①) — fire-and-forget mission_close_candidate detection for the missions of
  * the given task ids. Called after any task-status mutation (completion / failure /
@@ -1267,12 +1280,33 @@ export function updateTaskStatus(
     meshId: string,
     taskId: string,
     status: MeshTaskStatus,
-    opts?: MeshQueueMutationOptions,
+    opts?: {
+        /**
+         * CANCEL-STICKY-TERMINAL: operator/system override to permit a terminal→non-terminal
+         * transition (e.g. an explicit operator reopen). Without this, a write that would flip
+         * a `completed`/`failed`/`cancelled` row back to `pending`/`assigned` is refused as a
+         * no-op. Terminal→terminal and any transition FROM a non-terminal state are unaffected.
+         */
+        force?: boolean;
+    } & MeshQueueMutationOptions,
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     const result = withQueueLock(meshId, () => {
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
+        // CANCEL-STICKY-TERMINAL: never resurrect a terminal row into an active state. A late
+        // fire-and-forget writer (canonically the dispatch-failure `.catch` requeue to
+        // 'pending' in mesh-queue-assignment.ts, which resolves AFTER a cancel commits) must
+        // not undo a cancel/completion/failure — that revival let the row be re-claimed and the
+        // reclaim watchdog re-drive the same prompt. Refuse the transition as a no-op unless an
+        // explicit operator override is passed. This is the write-side sibling of the
+        // status!=='assigned' guard reclaimStrandedAssignedTask already applies.
+        if (!opts?.force
+            && TERMINAL_TASK_STATUSES.has(entry.status)
+            && !TERMINAL_TASK_STATUSES.has(status)) {
+            LOG.debug('MeshQueue', `Refusing updateTaskStatus(${taskId} → ${status}) on mesh ${meshId}: row is terminal (${entry.status}). A late writer (e.g. dispatch-failure requeue) must not resurrect a cancelled/completed/failed task. Pass force to override.`);
+            return { entry, cascaded: [] as MeshWorkQueueEntry[] };
+        }
         entry.status = status;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         // Any transition OFF `assigned` ends the single-flight dispatch window (terminal
@@ -1313,18 +1347,67 @@ export function cancelTask(
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         const now = new Date().toISOString();
+        // CANCEL-STICKY-TERMINAL (authoritative cancel): capture the prior assignment BEFORE
+        // clearing it, so the caller can stop the bound live worker. Leaving assignedNodeId/
+        // SessionId/ProviderType on the cancelled row let the still-running worker keep emitting
+        // delivery/turn signals that re-ignited the reclaim watchdog (observed: nonce 6→9,
+        // needing two cancels + a manual session stop). Clearing them also drops this row from
+        // the status==='assigned' counters so it can never be treated as live again.
+        const priorAssignment: CancelledTaskAssignment | undefined = entry.assignedSessionId
+            ? {
+                sessionId: entry.assignedSessionId,
+                nodeId: entry.assignedNodeId,
+                providerType: entry.assignedProviderType,
+            }
+            : undefined;
         entry.status = 'cancelled';
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
+        delete entry.assignedNodeId;
+        delete entry.assignedSessionId;
+        delete entry.assignedProviderType;
+        delete entry.dispatchTimestamp;
+        // Belt-and-suspenders: bump the dispatch nonce so any in-flight inject the
+        // now-orphaned worker later echoes carries a stale nonce and is rejected by the
+        // coordinator's stale-nonce guard — same mechanism reclaimStrandedAssignedTask uses.
+        entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         endTaskDispatchInFlight(meshId, taskId);
         const cascaded = propagateDependencyFailure(meshId, taskId);
-        return { entry, cascaded };
+        return { entry, cascaded, priorAssignment };
     });
     if (result) scheduleMissionCloseCandidateCheck(meshId, [result.entry, ...result.cascaded]);
+    // Surface the prior binding to the caller (out-of-band from the persisted row, so it is
+    // never serialized) so the cancel command handler — which holds DaemonComponents — can
+    // stop the now-orphaned worker via the transport-aware stopStaleMeshWorker helper.
+    if (result?.priorAssignment) lastCancelledTaskAssignment.set(`${meshId}::${taskId}`, result.priorAssignment);
     return result ? result.entry : null;
 }
 
+/**
+ * CANCEL-STICKY-TERMINAL: the assignment a task carried at cancel time, handed to the cancel
+ * command handler so it can stop the bound worker. cancelTask runs in the pure queue-store
+ * module (no DaemonComponents), so it records the binding here and the handler drains it.
+ */
+export interface CancelledTaskAssignment {
+    sessionId: string;
+    nodeId?: string;
+    providerType?: string;
+}
+
+const lastCancelledTaskAssignment = new Map<string, CancelledTaskAssignment>();
+
+/**
+ * Read-and-clear the assignment a just-cancelled task was bound to. Returns undefined when the
+ * cancelled task had no live assignment (nothing to stop). One-shot: the entry is deleted on read.
+ */
+export function takeCancelledTaskAssignment(meshId: string, taskId: string): CancelledTaskAssignment | undefined {
+    const key = `${meshId}::${taskId}`;
+    const value = lastCancelledTaskAssignment.get(key);
+    if (value) lastCancelledTaskAssignment.delete(key);
+    return value;
+}
+
 /**
  * Return a queue task to pending for retry. By default, dead session targeting
  * and assigned ownership are cleared so stale assignments do not strand again.

package/src/providers/auto-approve-modes.ts

@@ -0,0 +1,97 @@
+import type {
+  AutoApproveMode,
+  AutoApproveModeRisk,
+  AutoApproveModeStrategy,
+  ProviderModule,
+} from './contracts.js';
+
+const KNOWN_DANGEROUS_LAUNCH_ARGS = new Set([
+  '--dangerously-skip-permissions',
+  '--dangerously-bypass-approvals-and-sandbox',
+  'bypassPermissions',
+  'sandbox_mode=danger-full-access',
+  'approval_policy=never',
+]);
+
+export interface ResolvedAutoApproveMode {
+  active: boolean;
+  strategy: AutoApproveModeStrategy;
+  modeId: string;
+}
+
+function isKnownDangerousLaunchArg(arg: string): boolean {
+  const normalized = arg.trim();
+  if (KNOWN_DANGEROUS_LAUNCH_ARGS.has(normalized)) return true;
+  return normalized.startsWith('--dangerously-skip-permissions=')
+    || normalized.startsWith('--dangerously-bypass-approvals-and-sandbox=');
+}
+
+/** Runtime defense-in-depth for provider definitions that bypass schema validation. */
+export function deriveAutoApproveModeRisk(mode: Pick<AutoApproveMode, 'risk' | 'launchArgs'>): AutoApproveModeRisk {
+  return Array.isArray(mode.launchArgs) && mode.launchArgs.some(isKnownDangerousLaunchArg)
+    ? 'dangerous'
+    : mode.risk;
+}
+
+function inactiveMode(modeId = ''): ResolvedAutoApproveMode {
+  return { active: false, strategy: 'pty-parse-default', modeId };
+}
+
+function resolveConfiguredMode(
+  provider: ProviderModule,
+  mode: AutoApproveMode,
+  settings: Record<string, unknown> | undefined,
+): ResolvedAutoApproveMode {
+  if (mode.strategy === 'post-boot-command') return inactiveMode(mode.id);
+  if (settings?.launchedByCoordinator === true
+      && settings.delegatedWorkerDangerousModeAllow !== true
+      && deriveAutoApproveModeRisk(mode) === 'dangerous') {
+    const fallback = provider.autoApproveModes?.modes.find((candidate) =>
+      candidate.strategy === 'pty-parse-default'
+      && deriveAutoApproveModeRisk(candidate) !== 'dangerous');
+    return fallback
+      ? { active: true, strategy: fallback.strategy, modeId: fallback.id }
+      : inactiveMode(mode.id);
+  }
+  return { active: true, strategy: mode.strategy, modeId: mode.id };
+}
+
+/**
+ * Resolve new mode settings before the legacy boolean. A stale/unknown explicit
+ * mode id fails closed instead of falling through to an enabled legacy setting.
+ */
+export function resolveProviderAutoApproveMode(
+  provider: ProviderModule,
+  settings: Record<string, unknown> | undefined,
+): ResolvedAutoApproveMode {
+  const config = provider.autoApproveModes;
+  const explicitModeId = settings?.autoApproveMode;
+  if (typeof explicitModeId === 'string') {
+    const mode = config?.modes.find((candidate) => candidate.id === explicitModeId);
+    if (!mode) return inactiveMode(explicitModeId);
+    return resolveConfiguredMode(provider, mode, settings);
+  }
+
+  const explicitLegacy = settings?.autoApprove;
+  const providerLegacyDefault = provider.settings?.autoApprove?.default;
+  const legacyActive = typeof explicitLegacy === 'boolean'
+    ? explicitLegacy
+    : typeof providerLegacyDefault === 'boolean'
+      ? providerLegacyDefault
+      : false;
+  if (!legacyActive) return inactiveMode();
+
+  if (!config) {
+    return { active: true, strategy: 'pty-parse-default', modeId: 'legacy' };
+  }
+  const defaultMode = config.modes.find((mode) => mode.id === config.default);
+  if (!defaultMode) return inactiveMode(config.default);
+  return resolveConfiguredMode(provider, defaultMode, settings);
+}
+
+export function findProviderAutoApproveMode(
+  provider: ProviderModule | undefined,
+  modeId: string,
+): AutoApproveMode | undefined {
+  return provider?.autoApproveModes?.modes.find((mode) => mode.id === modeId);
+}

package/src/providers/chat-message-normalization.ts

@@ -156,6 +156,59 @@ export function selectFinalAssistantTurnEndMessage(
   return null;
 }
 
+/**
+ * EARLY-IDLE-COMPLETION-FALSE-POSITIVE — trailing tool/terminal activity detector.
+ *
+ * True when the transcript's LAST non-empty user-facing assistant bubble is followed
+ * by one or more TOOL / TERMINAL activity bubbles (a tool_use/command the assistant
+ * fired AFTER its text) — i.e. the assistant emitted a preamble ("Let me explore…"),
+ * then started running Read/Grep, so the turn is still executing and its answer has
+ * not landed. Callers that would otherwise promote that preamble to a turn-end summary
+ * off a momentary (startup-grace / inter-tool) idle read use this as a veto.
+ *
+ * Deliberately NARROW so the pure-PTY completion rescue is preserved:
+ *   - Only TOOL/TERMINAL activity trailing the assistant vetoes. A trailing THOUGHT or
+ *     status bubble does NOT (a finished turn can end on an internal thought), matching
+ *     selectFinalAssistantTurnEndMessage's skip set minus the "still-working" signals.
+ *   - A genuinely FINISHED worker (final assistant last, no trailing tool activity —
+ *     the kimi pure-PTY continuous-idle shape) returns false, so its early completion
+ *     is untouched.
+ *
+ * Returns false when there is no final assistant bubble at all (the caller's
+ * selectFinalAssistantTurnEndMessage already handles that as "not a turn end").
+ */
+export function hasTrailingToolActivityAfterFinalAssistant(
+  messages: ChatMessage[] | null | undefined,
+): boolean {
+  if (!Array.isArray(messages) || messages.length === 0) return false;
+  let sawTrailingToolActivity = false;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    // A trailing user-facing assistant/model bubble with real text ends the scan:
+    // whether we saw a tool AFTER it is the verdict.
+    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
+      if (flattenContent(msg.content).trim()) return sawTrailingToolActivity;
+      // Empty streaming assistant bubble — keep scanning back past it, same as
+      // selectFinalAssistantTurnEndMessage (which returns null here); an empty tail
+      // isn't a turn end, so there is nothing to veto.
+      return false;
+    }
+    if (classification.isUserFacing) {
+      // A trailing user bubble (freshly dispatched task, no reply) → no assistant
+      // turn end below it to veto.
+      return false;
+    }
+    // Non-user-facing activity/internal bubble sitting AFTER the (not-yet-seen)
+    // assistant bubble. Only tool/terminal activity signals an in-flight turn.
+    if (classification.kind === 'tool' || classification.kind === 'terminal') {
+      sawTrailingToolActivity = true;
+    }
+  }
+  return false;
+}
+
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;
 
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];

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

@@ -66,6 +66,15 @@ export type CompletedFinalizationBlock = {
     // preamble summary (evidenceLevel=insufficient) into the append-only ledger before the
     // worker's next approval turn resumes. Independent of valley length.
     holdForTranscript?: boolean;
+    // (CANON-C EARLY-EMIT FLOOR) Set on a missing_final_assistant block whose provider has NO
+    // external transcript source to trail — a PTY-parsed provider (codex-cli) or one that merely
+    // requires a final assistant before idle. For those the CANON-C decoupled-immediate emit is a
+    // pure timing guess (no separate transcript will land to upgrade it), so it must observe the
+    // CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS floor rather than fire at the ~13s first-poll
+    // waitedMs. A native-source block (claude-cli external-native, where the transcript legitimately
+    // trails the idle transition by a write) deliberately does NOT set this — its immediate emit is
+    // correct and is upgraded by the transcript reconcile.
+    noExternalTranscriptSource?: boolean;
 };
 
 export type CompletionFinalAssistantEvidence = {
@@ -87,6 +96,25 @@ export type ExternalTranscriptProbe = {
 
 export const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 export const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
+// (CANON-C EARLY-EMIT FLOOR) Minimum elapsed time before the CANON-C transcript-evidence
+// gate (allowTimeout blocks) may fire its decoupled-immediate completion for a block that
+// has NO final-assistant evidence (missing_final_assistant, finalAssistantPresent=false).
+//
+// CANON-C deliberately decouples the idle NOTIFICATION from the transcript's final-assistant
+// turn: for a native-source worker whose transcript write merely trails the idle transition,
+// emitting immediately (weak, later upgraded) is correct. But the SAME allowTimeout path also
+// carries codex/antigravity PLAIN terminal blocks whose on-screen "final" assistant never
+// landed — there the immediate emit fires at whatever tiny waitedMs the first completion-gate
+// poll observed (~13s live), stamping evidenceLevel=insufficient and racing the transcript
+// before it can catch up or the 180s mesh-worker stall watchdog can arm. Requiring a minimum
+// dwell gives the transcript a window to land (clearing the block for a GENUINE emit) and lets
+// the stall watchdog own long turns, while still emitting a weak completion promptly once the
+// floor is met so a genuinely-answerless turn is never wedged. A block WITH final-assistant
+// evidence present is unaffected (it takes the normal emit path, not this floor). Scoped (at
+// the call site) to the missing_final_assistant transcript-evidence gate on mesh workers.
+// Sized so a short transcript-write lag resolves under it while staying well below the 30s
+// COMPLETED_FINALIZATION_MAX_WAIT_MS cap that force-releases the weak completion regardless.
+export const CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 20_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