@adhdev/daemon-core 1.0.18-rc.13 → 1.0.18-rc.15

package/dist/mesh/mesh-remote-event-pull.d.ts

@@ -1,6 +1,9 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 export declare function pullRemoteNodeQueues(components: DaemonComponents, mesh: LocalMeshEntry, localDaemonId: string | undefined, candidateDaemonIds: string[]): Promise<void>;
+export declare function pullPendingEventsFromNode(components: DaemonComponents, meshId: string, node: {
+    daemonId?: string;
+}, localDaemonId: string | undefined, candidateDaemonIds: string[], pulls: Array<Record<string, unknown>>): Promise<void>;
 export declare function unwrapReadChatPayload(raw: unknown): Record<string, unknown> | null;
 export declare function readChatPayloadStatus(payload: Record<string, unknown> | null): string;
 export declare function realTerminalEmitPendingForTask(meshId: string, taskId: string): boolean;

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

@@ -619,6 +619,33 @@ export declare class CliProviderInstance implements ProviderInstance {
      * call unconditionally from the cleanup path.
      */
     flushMeshCompletionBeforeCleanup(): boolean;
+    /**
+     * KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for the
+     * PURE-PTY transcript class (kimi and kin — no native transcript, no provider
+     * authority; see isPurePtyTranscriptProvider). Such a worker whose
+     * generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1
+     * fixes at the source) sits at a STATIC idle prompt: its PTY output stops the
+     * instant the answer is rendered, so the status-agnostic no-progress watchdog
+     * (checkMeshWorkerStall) reads the finished-but-quiet session as a stall and would
+     * false-fire monitor:no_progress. The native-transcript reconcile
+     * (sampleNativeTranscriptProgress) does NOT cover this class (no native source →
+     * null sample), so the stall path needs its own guard.
+     *
+     * Called from checkMeshWorkerStall just before the fire. Returns true when the
+     * session is a finished pure-PTY turn — idle, no pending response, and a PTY-parsed
+     * in-turn final assistant summary — in which case it emits the missing
+     * generating_completed (idempotent: a real/late emit writes the terminal ledger and
+     * the coordinator's reconcile makes any duplicate a no-op) and the caller SUPPRESSES
+     * the stall. Returns false for every other class/state (native-source provider, a
+     * genuinely mid-turn or wedged worker with no final assistant), so a real stall still
+     * fires unchanged.
+     *
+     * Evidence bar is identical to flushMeshCompletionBeforeCleanup: injected task's turn
+     * genuinely started + an in-turn final assistant summary. Conservative by
+     * construction — no summary ⇒ no proof of completion ⇒ return false and let the real
+     * stall fire.
+     */
+    private tryReconcilePurePtyCompletionForStall;
     /**
      * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
      * persist before the in-progress settle gate is torn down. For a delegated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.18-rc.13",
+  "version": "1.0.18-rc.15",
   "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": "1.0.18-rc.13",
-    "@adhdev/session-host-core": "1.0.18-rc.13",
+    "@adhdev/mesh-shared": "1.0.18-rc.15",
+    "@adhdev/session-host-core": "1.0.18-rc.15",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -15,6 +15,7 @@ import {
 import {
     buildCliScreenSnapshot,
     compactPromptText,
+    isPurePtyTranscriptProvider,
     normalizePromptText,
     promptLikelyVisible,
     type CliChatMessage,
@@ -361,7 +362,22 @@ export class CliStateEngine {
         // idle transition, unchanged. Scoped to transcriptAuthority:'provider'
         // only, so PTY-authoritative providers (whose spinner/settled parsing
         // already drives generating promptly) are unaffected.
-        if (this.provider.transcriptAuthority === 'provider' && this.currentStatus !== 'waiting_approval') {
+        //
+        // (fix: kimi pure-PTY completion-emit) The pure-PTY full-buffer class
+        // (kimi and kin — see isPurePtyTranscriptProvider) is NOT
+        // transcriptAuthority:'provider', so without this it stays idle when a
+        // prompt is submitted from idle: the FSM never crosses generating→idle,
+        // detectStatusTransition's generating|waiting_approval→idle arm never
+        // runs, and agent:generating_completed is never emitted — the mesh
+        // coordinator leaves the task 'assigned' and the status-agnostic stall
+        // watchdog then false-fires task_stalled on the finished-but-idle
+        // session. Promoting this class to generating on turn-start makes the
+        // existing PTY-parsed final-assistant idle gate produce a real
+        // generating→idle completion edge. Same idle safety as above: applyIdle
+        // / finishResponse still own the actual idle transition.
+        const promoteOnTurnStart = this.provider.transcriptAuthority === 'provider'
+            || isPurePtyTranscriptProvider(this.provider);
+        if (promoteOnTurnStart && this.currentStatus !== 'waiting_approval') {
             this.setStatus('generating', 'turn_started');
             this.callbacks.onStatusChange();
         }

package/src/cli-adapters/provider-cli-adapter.ts

@@ -39,6 +39,7 @@ import {
     compactPromptText,
     estimatePromptDisplayLines,
     extractPromptRetrySnippet,
+    isPurePtyTranscriptProvider,
     listCliScriptNames,
     normalizePromptText,
     normalizeScreenSnapshot,
@@ -456,12 +457,7 @@ export class ProviderCliAdapter implements CliAdapter {
      * provider-owned) so no other provider's turn-scoped parse changes.
      */
     private parsesFullPtyTranscriptFromBuffer(): boolean {
-        if (this.providerOwnsTranscript()) return false;
-        // nativeHistory is a top-level provider field not surfaced on
-        // CliProviderModule; read it via the same structural cast used for `tui`.
-        if ((this.provider as { nativeHistory?: unknown }).nativeHistory) return false;
-        const transcriptPty = (this.provider.tui as { transcriptPty?: { scope?: unknown } } | undefined)?.transcriptPty;
-        return transcriptPty?.scope === 'buffer';
+        return isPurePtyTranscriptProvider(this.provider);
     }
 
     /**

package/src/cli-adapters/provider-cli-shared.ts

@@ -254,6 +254,47 @@ export interface CliProviderModule {
     _versionWarning?: string | null;
 }
 
+/**
+ * PURE-PTY TRANSCRIPT CLASS predicate (kimi and kin).
+ *
+ * A provider is "pure-PTY full-buffer" when it reconstructs its ENTIRE transcript
+ * from the rendered PTY buffer on every read and has NO alternate transcript
+ * source:
+ *   - transcriptAuthority !== 'provider'  (the daemon PTY parser owns the transcript,
+ *     not a provider-side canonical source)
+ *   - NO nativeHistory              (no on-disk / native-source history to fall back to)
+ *   - tui.transcriptPty.scope === 'buffer' (the parser walks the full rendered buffer)
+ *
+ * This class is invisible to two provider-authority-keyed code paths that other
+ * providers rely on for mesh completion semantics:
+ *   1. CliStateEngine.onTurnStarted only promotes to 'generating' for
+ *      transcriptAuthority==='provider' providers — so a pure-PTY session that
+ *      submits a prompt while already idle collapses idle→idle, the
+ *      generating→idle edge never occurs, and agent:generating_completed is never
+ *      emitted (the coordinator ledger leaves the task 'assigned' forever).
+ *   2. checkMeshWorkerStall's native-transcript completion reconcile is gated on
+ *      the native-source shape, so a finished pure-PTY worker's static idle is
+ *      misread as monitor:no_progress (a false task_stalled).
+ *
+ * The runtime capability, NOT any single spec field value, is authoritative: a
+ * given kimi manifest checkout may declare nativeHistory/transcriptAuthority, but
+ * the live-loaded pure-PTY session has none. Callers that only hold a
+ * CliProviderModule (the engine) share this exact predicate with the adapter
+ * (parsesFullPtyTranscriptFromBuffer) so the two never drift.
+ */
+export function isPurePtyTranscriptProvider(provider: {
+    transcriptAuthority?: 'provider' | 'daemon';
+    nativeHistory?: unknown;
+    tui?: Record<string, unknown>;
+}): boolean {
+    if (provider.transcriptAuthority === 'provider') return false;
+    // nativeHistory is a top-level provider field not surfaced on
+    // CliProviderModule; read it via the same structural shape the adapter uses.
+    if (provider.nativeHistory) return false;
+    const transcriptPty = (provider.tui as { transcriptPty?: { scope?: unknown } } | undefined)?.transcriptPty;
+    return transcriptPty?.scope === 'buffer';
+}
+
 function stripAnsi(str: string): string {
     // eslint-disable-next-line no-control-regex
     return str

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

@@ -75,7 +75,7 @@ import {
     resolvePendingHeldDrainEscalateMs,
     resolveReconcileIntervalMs,
 } from './mesh-reconcile-config.js';
-import { pullRemoteNodeQueues } from './mesh-remote-event-pull.js';
+import { pullRemoteNodeQueues, pullPendingEventsFromNode } from './mesh-remote-event-pull.js';
 import { runDiskRetentionSweep, detectAndSignalOrphanWorktrees } from './mesh-disk-retention.js';
 import {
     reconcileUnterminatedDirectDispatches,
@@ -732,10 +732,32 @@ const deliveredNoTurnUnknownStreak = new Map<string, number>();
 // immediately; UNKNOWN accrues a streak and re-drives only after RECLAIM_UNKNOWN_GRACE_TICKS.
 const deliveredUnconsumedUnknownStreak = new Map<string, number>();
 
+// KIMI-PURE-PTY-COMPLETION-EMIT (Fix 2): how long a delivered assigned row whose worker is
+// CONTINUOUSLY idle-WITH-a-final-assistant-message must stay so before we short-circuit it to
+// 'completed' from transcript evidence — WITHOUT waiting the full DELIVERED_NO_TURN_DEADLINE_MS
+// (15min). A pure-PTY worker (kimi and kin — no native transcript, no provider authority) whose
+// generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1 addresses at the
+// source) leaves the row 'assigned' with an idle worker that already rendered its answer. The
+// F3 long-deadline reclaim's pollAssignedTaskTerminalEvidence would eventually recover it — but only
+// after 15min, during which the coordinator ledger wrongly shows the task in flight. This EARLY
+// reconcile applies the SAME idle-with-final-assistant-after-dispatch evidence bar (via
+// pollAssignedTaskTerminalEvidence) after a few continuous-idle ticks, so a finished worker's task
+// is marked complete promptly. Conservative by construction: the streak resets the instant a read is
+// non-idle / lacks a final summary / is unreadable, and the poll itself enforces the after-dispatch
+// stale-summary guard, so a mid-turn or warming-up worker is never falsely completed.
+const ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS = 8_000;
+
+// Per-row continuous idle-with-final-assistant streak for the early transcript-evidence completion,
+// keyed `${meshId}::${taskId}`, storing the wall-clock ms when the continuous run began. Pruned each
+// pass to the currently-assigned rows (same as the UNKNOWN streaks). A non-idle / no-summary /
+// unreadable tick clears the entry so the grace must re-accumulate from scratch.
+const assignedIdleFinalAssistantSince = new Map<string, number>();
+
 // Test hook: clear the delivered-no-turn UNKNOWN streaks between cases.
 export function __resetReclaimUnknownStreakForTests(): void {
     deliveredNoTurnUnknownStreak.clear();
     deliveredUnconsumedUnknownStreak.clear();
+    assignedIdleFinalAssistantSince.clear();
 }
 
 // APPROVAL-INBOX-BLINDSPOT (Fix A.3): true when the assigned row's bound session is, per the
@@ -781,6 +803,8 @@ async function recoverStrandedAssignedDispatches(
     components: DaemonComponents,
     mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
     store: MeshRuntimeStore,
+    localDaemonId?: string,
+    selfIds: string[] = [],
 ): Promise<void> {
     const meshId = mesh.id;
     const assigned = getQueue(meshId, { status: ['assigned'] });
@@ -797,10 +821,76 @@ async function recoverStrandedAssignedDispatches(
     for (const key of [...deliveredUnconsumedUnknownStreak.keys()]) {
         if (key.startsWith(meshKeyPrefix) && !assignedKeys.has(key)) deliveredUnconsumedUnknownStreak.delete(key);
     }
+    for (const key of [...assignedIdleFinalAssistantSince.keys()]) {
+        if (key.startsWith(meshKeyPrefix) && !assignedKeys.has(key)) assignedIdleFinalAssistantSince.delete(key);
+    }
     for (const row of assigned) {
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? '');
         if (!Number.isFinite(dispatchedAtMs)) continue;              // no dispatch ts → can't age it
         const ageMs = nowMs - dispatchedAtMs;
+        const idleTranscriptStreakKey = `${meshId}::${row.id}`;
+        // KIMI-PURE-PTY-COMPLETION-EMIT (Fix 2): EARLY transcript-evidence completion for a
+        // delivered assigned row whose worker is already idle with a final assistant answer, so a
+        // pure-PTY worker whose generating_completed never emitted is marked done PROMPTLY instead of
+        // sitting 'assigned' until the 15-min DELIVERED_NO_TURN_DEADLINE_MS reclaim. Gate on a
+        // CONFIRMED delivery (a never-delivered row is handled by dispatch/redrive, not completion)
+        // and a bound session, then require the worker to read idle-WITH-final-assistant continuously
+        // for ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS before polling the decisive transcript evidence.
+        // The streak is the cheap gate (avoids a read every tick); the read only runs once the grace
+        // elapses. pollAssignedTaskTerminalEvidence enforces idle + final-assistant-after-dispatch, so
+        // a mid-turn / stale-tail / unreadable worker is never falsely completed — a non-qualifying
+        // tick clears the streak below.
+        if (
+            store.taskHasConfirmedDelivery(meshId, row.id)
+            && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })
+            && readNonEmptyString(row.assignedSessionId)
+            && resolveSessionBusyVerdict(components, row.assignedSessionId!) !== 'GENERATING'
+        ) {
+            const since = assignedIdleFinalAssistantSince.get(idleTranscriptStreakKey);
+            if (since === undefined) {
+                assignedIdleFinalAssistantSince.set(idleTranscriptStreakKey, nowMs);
+            } else if (nowMs - since >= ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS) {
+                const terminalEvidence = await pollAssignedTaskTerminalEvidence(components, mesh, row);
+                if (terminalEvidence) {
+                    assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+                    updateTaskStatus(meshId, row.id, terminalEvidence);
+                    if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+                        try {
+                            appendLedgerEntry(meshId, {
+                                kind: terminalEvidence === 'completed' ? 'task_completed' : 'task_failed',
+                                nodeId: row.assignedNodeId,
+                                sessionId: row.assignedSessionId,
+                                providerType: row.assignedProviderType,
+                                payload: {
+                                    taskId: row.id,
+                                    event: 'agent:generating_completed',
+                                    source: 'early_idle_transcript_evidence',
+                                },
+                            });
+                        } catch { /* best-effort ledger write */ }
+                    }
+                    LOG.warn('MeshReconcile', `Early-completed assigned task ${row.id} on mesh ${meshId} `
+                        + `(node=${row.assignedNodeId ?? '?'} session=${row.assignedSessionId ?? '?'}): worker idle with a `
+                        + `final assistant message after dispatch for ≥${Math.round(ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS / 1000)}s — `
+                        + `the completion event was lost/late (pure-PTY provider), task is ${terminalEvidence} without waiting the 15-min deadline`);
+                    traceMeshEventDrop('assigned_early_transcript_completed', {
+                        taskId: row.id,
+                        sessionId: row.assignedSessionId,
+                        nodeId: row.assignedNodeId,
+                        meshId,
+                        event: 'agent:generating_completed',
+                    }, terminalEvidence);
+                    continue;
+                }
+                // Poll was inconclusive (mid-turn re-check / stale tail / unreadable) — reset the
+                // streak so it must re-accumulate a fresh continuous-idle run before the next poll.
+                assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+            }
+        } else {
+            // Not a qualifying tick (no confirmed delivery, generating, terminal ledger present, or
+            // no bound session) — break the continuous-idle run.
+            assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+        }
         // DELIVERED-NOT-CONSUMED short-grace re-drive (remote autoLaunch delivered≠consumed gap).
         // Runs BEFORE the ASSIGNED_STRANDED_DEADLINE_MS confirm-window gate below because its whole
         // point is to recover a delivered-but-unconsumed row well inside that window. A remote
@@ -832,6 +922,45 @@ async function recoverStrandedAssignedDispatches(
                 updateTaskStatus(meshId, row.id, status);
                 continue;
             }
+            // GENERATING-STARTED-CONSUME-RACE (fix B): the delivery-consume that clears this
+            // gate (delivered → acked) runs ONLY when the coordinator pulls the worker's queued
+            // agent:generating_started in PHASE 1 (handleMeshForwardEvent → consumeSessionDelivery).
+            // A worker may have emitted generating_started ALREADY, but if PHASE 1 has not yet
+            // pulled that specific event (a skipped/slow peer tick, or the event was queued after
+            // this tick's pull ran), the delivery row still reads 'delivered' here and the redrive
+            // below tears a genuinely-generating remote worker off its task and re-injects the
+            // prompt (the delivered_not_consumed_redrive symptom). Close the race by issuing a
+            // TARGETED, in-process last-chance pull of THIS node's queue right now, then
+            // re-reading taskDeliveryConsumed(): if the worker's generating_started was waiting to
+            // be pulled, the pull consumes the delivery this tick and we skip the redrive entirely.
+            // Best-effort and self-scoped (the same skip/peer guards as PHASE 1) — a miss just
+            // falls through to the existing UNKNOWN-streak grace, so this only ever removes false
+            // redrives, never adds one. A local (co-hosted) worker has nothing to pull (the node's
+            // daemon is a self id) and this is a fast no-op.
+            const assignedNode = row.assignedNodeId
+                ? mesh.nodes?.find(n => meshNodeIdMatches(n, row.assignedNodeId))
+                : undefined;
+            if (assignedNode?.daemonId) {
+                try {
+                    await pullPendingEventsFromNode(
+                        components,
+                        meshId,
+                        assignedNode,
+                        localDaemonId,
+                        selfIds,
+                        selfIds.length > 0
+                            ? selfIds.map(id => ({ meshId, coordinatorDaemonId: id }))
+                            : [{ meshId }],
+                    );
+                } catch { /* best-effort last-chance pull */ }
+                if (store.taskDeliveryConsumed(meshId, row.id)) {
+                    // The pull delivered the worker's generating_started (or a terminal event) and
+                    // consumed the delivery — the task is genuinely live/handled. Reset any accrued
+                    // streak and leave the row to PHASE 4's completion reconcile.
+                    deliveredUnconsumedUnknownStreak.delete(`${meshId}::${row.id}`);
+                    continue;
+                }
+            }
             const shortStreakKey = `${meshId}::${row.id}`;
             const verdict = row.assignedSessionId
                 ? resolveSessionBusyVerdict(components, row.assignedSessionId)
@@ -1227,7 +1356,7 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
             if (!daemonHostsMesh(mesh, selfIds)) continue;
             try {
-                await recoverStrandedAssignedDispatches(components, mesh, store);
+                await recoverStrandedAssignedDispatches(components, mesh, store, localDaemonId, selfIds);
             } catch (e: any) {
                 LOG.warn('MeshReconcile', `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
             }

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/providers/cli-provider-instance.ts

@@ -17,6 +17,7 @@ import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import { shortHash } from '../system/hash.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import type { MeshSendKeyItem, MeshSendKeyName } from '../cli-adapters/provider-cli-shared.js';
+import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
 import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
@@ -2457,6 +2458,20 @@ export class CliProviderInstance implements ProviderInstance {
             }
         }
 
+        // KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): before firing a false stall, check the
+        // pure-PTY class (no native transcript → nativeSample was null above). A finished
+        // pure-PTY worker sits at a static idle prompt with an in-turn final assistant
+        // message but never emitted generating_completed — the status-agnostic watchdog
+        // would misread that quiet as a wedge. If the PTY transcript proves a finished
+        // turn, emit the missing completion and SUPPRESS the stall (mark the anchor
+        // emitted so this static idle is not re-checked every tick). No-op for
+        // native-source providers and for a genuinely mid-turn / wedged worker with no
+        // final assistant → the real stall fires below unchanged.
+        if (this.tryReconcilePurePtyCompletionForStall(observedStatus)) {
+            this.meshStallEmittedForAnchor = true;
+            return;
+        }
+
         // FALSE-STALL-WATCHDOG-OVERFIRE (fix E): per-session refire cooldown. Mark
         // this anchor emitted regardless so a still-static anchor does not re-check
         // every tick, but suppress the actual coordinator notification (and the
@@ -2619,6 +2634,83 @@ export class CliProviderInstance implements ProviderInstance {
         return true;
     }
 
+    /**
+     * KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for the
+     * PURE-PTY transcript class (kimi and kin — no native transcript, no provider
+     * authority; see isPurePtyTranscriptProvider). Such a worker whose
+     * generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1
+     * fixes at the source) sits at a STATIC idle prompt: its PTY output stops the
+     * instant the answer is rendered, so the status-agnostic no-progress watchdog
+     * (checkMeshWorkerStall) reads the finished-but-quiet session as a stall and would
+     * false-fire monitor:no_progress. The native-transcript reconcile
+     * (sampleNativeTranscriptProgress) does NOT cover this class (no native source →
+     * null sample), so the stall path needs its own guard.
+     *
+     * Called from checkMeshWorkerStall just before the fire. Returns true when the
+     * session is a finished pure-PTY turn — idle, no pending response, and a PTY-parsed
+     * in-turn final assistant summary — in which case it emits the missing
+     * generating_completed (idempotent: a real/late emit writes the terminal ledger and
+     * the coordinator's reconcile makes any duplicate a no-op) and the caller SUPPRESSES
+     * the stall. Returns false for every other class/state (native-source provider, a
+     * genuinely mid-turn or wedged worker with no final assistant), so a real stall still
+     * fires unchanged.
+     *
+     * Evidence bar is identical to flushMeshCompletionBeforeCleanup: injected task's turn
+     * genuinely started + an in-turn final assistant summary. Conservative by
+     * construction — no summary ⇒ no proof of completion ⇒ return false and let the real
+     * stall fire.
+     */
+    private tryReconcilePurePtyCompletionForStall(observedStatus: string): boolean {
+        // Only the pure-PTY class — native-source providers are handled by
+        // sampleNativeTranscriptProgress above.
+        if (!isPurePtyTranscriptProvider(this.provider)) return false;
+        // A finished turn is idle with nothing pending. A generating/waiting session is
+        // mid-turn (the real stall path should evaluate it), so never complete it here.
+        if (observedStatus !== 'idle') return false;
+        if (this.hasAdapterPendingResponse()) return false;
+
+        const taskId = this.completingTurnTaskId();
+        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
+        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+            return false;
+        }
+        // The injected task's own turn must have genuinely started (guards against a
+        // reused session's stale tail before this task ran).
+        if (!this.injectedTaskHasStartedGenerating()) return false;
+
+        const turnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : this.meshTaskInjectedAt || undefined;
+        let parsedMessages: unknown;
+        try {
+            parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
+        } catch { parsedMessages = undefined; }
+        let finalSummary: string | undefined;
+        try {
+            finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
+        } catch { finalSummary = undefined; }
+        // No in-turn final assistant evidence → not a proven turn-end. Let the real
+        // stall fire so a genuinely-wedged worker is still surfaced.
+        if (!finalSummary) return false;
+
+        LOG.warn('CLI', `[${this.type}] reconciling pure-PTY mesh completion from the stall path for session ${this.instanceId} `
+            + `task=${taskId ?? '(none)'} — PTY is idle-quiet with an in-turn final assistant message but the completion `
+            + `event never fired (pure-PTY provider); emitting it instead of a false monitor:no_progress.`);
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), 'stall_pure_pty_transcript_completion');
+        }
+        this.emitGeneratingCompleted({
+            chatTitle: '',
+            duration: undefined,
+            timestamp: Date.now(),
+            taskId,
+            finalSummary,
+            evidenceLevel: 'transcript',
+            completionDiagnostic: { source: 'stall_pure_pty_transcript_completion' },
+        });
+        return true;
+    }
+
     /**
      * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
      * persist before the in-progress settle gate is torn down. For a delegated