@adhdev/daemon-core 1.0.18-rc.12 → 1.0.18-rc.14

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

@@ -192,6 +192,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private meshStallEmittedForAnchor;
     private meshStallTurnActiveLast;
     private meshStallLastFiredAt;
+    private meshStallNativeTranscriptSample;
     private busyEpoch;
     private fastCollapseSynthesizedTaskId;
     private startupGraceCollapseAt;
@@ -424,6 +425,7 @@ export declare class CliProviderInstance implements ProviderInstance {
      * once at completion). Reset on the next turn's start.
      */
     private lastCompletionSummary;
+    private lastEmittedCompletion;
     private enforceFreshSessionLaunchIfNeeded;
     /**
      * BRAIN-ROUTING (runtime-control thinking axis): for a provider that selects
@@ -574,6 +576,49 @@ export declare class CliProviderInstance implements ProviderInstance {
      * starts with a clean slate (a restart is not throttled by a prior stall).
      */
     private resetMeshStallEpisode;
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 1). For a native-source provider
+     * (transcriptAuthority=provider — its authoritative history is an on-disk
+     * transcript file, e.g. kimi's wire.jsonl), sample the transcript's current
+     * progress fingerprint (record count + source-file mtime) WITHOUT parsing the
+     * PTY. Used by the stall watchdog to distinguish "PTY render is quiet but the
+     * worker is still doing long tool work (transcript growing)" from a genuine
+     * wedge. Returns null for a pure-PTY provider (no native source) or when the
+     * source cannot be resolved this tick — the caller then falls back to the
+     * unchanged lastOutputAt-only judgment.
+     *
+     * Generalized on the provider's native-source flag, NOT a hardcoded provider
+     * type, so every current and future pure-PTY long-tool native-source provider
+     * benefits. Cheap enough for the stall path: it runs only at the stall threshold
+     * (≥180s of PTY stasis), never on the routine 5s tick.
+     */
+    private sampleNativeTranscriptProgress;
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 2). Last-chance completion emit for a mesh
+     * DELEGATED worker whose PTY has already exited (e.g. killed by a false stall)
+     * and is about to be auto-cleaned (cli-manager.startCliExitMonitor →
+     * removeInstance closes the event-emit window forever). If the worker actually
+     * FINISHED its assigned turn — its authoritative native transcript holds a final
+     * assistant message for the injected task — but the completion event never fired
+     * (the stall-kill happened before the FSM's idle transition), emit it now so the
+     * coordinator learns the task completed instead of waiting ~180s for the reconcile
+     * transcript-poll to reclaim it.
+     *
+     * Scope & guards (must all hold to emit):
+     *   • mesh worker session only — a normal standalone session's ordinary exit is
+     *     never synthesized (isMeshWorkerSession()).
+     *   • DOUBLE-EMIT guard — refuse if this turn's completion already fired
+     *     (lastEmittedCompletion matches the current taskId). A worker that completed
+     *     cleanly and is merely being cleaned up never double-emits.
+     *   • evidence gate — reuse the same final-assistant/turn-scoped summary machinery
+     *     as the normal completion path (completionFinalSummary over the native
+     *     transcript). No in-turn assistant summary ⇒ no proof of completion ⇒ leave
+     *     the reclaim path to handle a genuinely-unfinished worker.
+     *
+     * Returns true when a synthetic completion was emitted, false otherwise. Safe to
+     * call unconditionally from the cleanup path.
+     */
+    flushMeshCompletionBeforeCleanup(): boolean;
     /**
      * 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.12",
+  "version": "1.0.18-rc.14",
   "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.12",
-    "@adhdev/session-host-core": "1.0.18-rc.12",
+    "@adhdev/mesh-shared": "1.0.18-rc.14",
+    "@adhdev/session-host-core": "1.0.18-rc.14",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/cli-manager.ts

@@ -707,6 +707,24 @@ export class DaemonCliManager {
                     clearInterval(checkStopped);
                     setTimeout(() => {
                         if (this.adapters.has(key)) {
+                            // KIMI-MESH-COMPLETION-EMIT (axis 2): before removeInstance closes the
+                            // event-emit window, give a mesh DELEGATED worker one last chance to emit
+                            // its completion. A native-source worker (e.g. kimi) can have its PTY
+                            // killed by a false stall AFTER it finished the task (transcript written)
+                            // but BEFORE the FSM's idle→completed event fired — the instance is the
+                            // only thing that can emit that event, and it is about to be removed. The
+                            // instance-side method is a no-op for a non-mesh session or when the
+                            // turn's completion already fired (double-emit guard) or when there is no
+                            // transcript evidence of a finished turn. Best-effort — never blocks cleanup.
+                            try {
+                                const inst = instanceManager?.getInstance(key) as (ProviderInstance & { flushMeshCompletionBeforeCleanup?: () => boolean }) | undefined;
+                                if (typeof inst?.flushMeshCompletionBeforeCleanup === 'function') {
+                                    const emitted = inst.flushMeshCompletionBeforeCleanup();
+                                    if (emitted) LOG.info('CLI', `Emitted pre-cleanup mesh completion for ${cliType} session ${key} before auto-clean`);
+                                }
+                            } catch (e) {
+                                LOG.warn('CLI', `pre-cleanup mesh completion flush failed for ${key}: ${(e as Error)?.message || e}`);
+                            }
                             this.adapters.delete(key);
                             this.deps.removeAgentTracking(key);
                             sessionRegistry?.unregisterByInstanceKey(key);

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,
@@ -781,6 +781,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'] });
@@ -832,6 +834,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 +1268,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

@@ -332,6 +332,18 @@ export class CliProviderInstance implements ProviderInstance {
     // MESH_WORKER_STALL_REFIRE_COOLDOWN_MS between successive emissions across
     // anchor re-arms (the per-anchor guard only covers a single continuous stall).
     private meshStallLastFiredAt = -1;
+    // KIMI-MESH-COMPLETION-EMIT (axis 1): the native-source transcript progress
+    // fingerprint (record count + source mtime) observed the LAST time the stall
+    // watchdog checked a native-source provider (transcriptAuthority=provider — e.g.
+    // kimi wire.jsonl). A pure-PTY native-source worker running a long, screen-quiet
+    // tool (no viewport bytes for minutes) looks stalled by the lastOutputAt clock
+    // even though its transcript file is still growing. Before firing the stall, we
+    // compare the current transcript fingerprint against this snapshot; if the
+    // transcript advanced, the "stall" is a false positive of PTY-render stasis, so
+    // we re-arm the anchor instead of paging the coordinator (whose no_progress
+    // handling can lead to the worker being stopped mid-work → completion never
+    // emitted). null = not yet sampled for this session/anchor.
+    private meshStallNativeTranscriptSample: { msgCount: number; sourceMtimeMs: number } | null = null;
     // FALSE-IDLE continuity epoch: monotonically bumped on EVERY entry into a busy
     // phase (→generating or →waiting_approval). The completedDebouncePending snapshots
     // this value at arm time (busyEpochAtArm); the flush guard requires it UNCHANGED
@@ -1418,6 +1430,15 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private lastCompletionSummary: { content: string; receivedAt: number; sourceTimestampMs?: number } | null = null;
 
+    // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): the (taskId, wall-clock)
+    // of the most recent agent:generating_completed this instance emitted, stamped by
+    // emitGeneratingCompleted. The pre-cleanup completion flush
+    // (flushMeshCompletionBeforeCleanup, driven by cli-manager's exit monitor) reads
+    // this to refuse a SECOND completion for a turn whose completion already fired —
+    // so a worker that finished cleanly and is simply being auto-cleaned never emits a
+    // duplicate. taskId '' covers an ad-hoc (no-task) turn. null = none emitted yet.
+    private lastEmittedCompletion: { taskId: string; at: number } | null = null;
+
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
         if (!scriptName) return;
@@ -2404,6 +2425,38 @@ export class CliProviderInstance implements ProviderInstance {
         const stalledMs = now - this.meshStallAnchorAt;
         if (stalledMs < threshold) return;
 
+        // KIMI-MESH-COMPLETION-EMIT (axis 1): transcript-aware stall for native-source
+        // providers. A pure-PTY native-source worker (transcriptAuthority=provider,
+        // e.g. kimi) running a long, screen-quiet tool emits no viewport bytes for
+        // minutes, so the lastOutputAt clock above reads it as stalled — but its
+        // authoritative transcript (wire.jsonl) is still being appended. Firing
+        // monitor:no_progress here surfaces a false stall to the coordinator whose
+        // downstream handling can stop the worker mid-work, killing the emit window
+        // before the real completion propagates. So before firing, sample the native
+        // transcript's progress fingerprint: if it advanced (more records OR a fresher
+        // source mtime) since the last sample, the worker is demonstrably alive — treat
+        // it as progress. Re-arm the anchor to `now` and reset the episode so the clock
+        // restarts from this proven-live moment; only a transcript that is ALSO static
+        // falls through to the genuine-stall fire below. No-op for pure-PTY providers
+        // (sample is null → unchanged behavior).
+        const nativeSample = this.sampleNativeTranscriptProgress();
+        if (nativeSample) {
+            const prev = this.meshStallNativeTranscriptSample;
+            const advanced = !prev
+                || nativeSample.msgCount > prev.msgCount
+                || nativeSample.sourceMtimeMs > prev.sourceMtimeMs;
+            this.meshStallNativeTranscriptSample = nativeSample;
+            if (advanced) {
+                if (this.isMeshWorkerSession()) {
+                    traceMeshEventDrop('mesh_worker_stall_transcript_advancing', this.meshTraceCtx('monitor:no_progress'),
+                        `msgCount=${nativeSample.msgCount} sourceMtime=${nativeSample.sourceMtimeMs} (PTY quiet ${Math.round(stalledMs / 1000)}s but transcript advancing)`);
+                }
+                this.meshStallAnchorAt = now;
+                this.meshStallEmittedForAnchor = false;
+                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
@@ -2454,6 +2507,116 @@ export class CliProviderInstance implements ProviderInstance {
         this.meshStallEmittedForAnchor = false;
         this.meshStallTurnActiveLast = undefined;
         this.meshStallLastFiredAt = -1;
+        this.meshStallNativeTranscriptSample = null;
+    }
+
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 1). For a native-source provider
+     * (transcriptAuthority=provider — its authoritative history is an on-disk
+     * transcript file, e.g. kimi's wire.jsonl), sample the transcript's current
+     * progress fingerprint (record count + source-file mtime) WITHOUT parsing the
+     * PTY. Used by the stall watchdog to distinguish "PTY render is quiet but the
+     * worker is still doing long tool work (transcript growing)" from a genuine
+     * wedge. Returns null for a pure-PTY provider (no native source) or when the
+     * source cannot be resolved this tick — the caller then falls back to the
+     * unchanged lastOutputAt-only judgment.
+     *
+     * Generalized on the provider's native-source flag, NOT a hardcoded provider
+     * type, so every current and future pure-PTY long-tool native-source provider
+     * benefits. Cheap enough for the stall path: it runs only at the stall threshold
+     * (≥180s of PTY stasis), never on the routine 5s tick.
+     */
+    private sampleNativeTranscriptProgress(): { msgCount: number; sourceMtimeMs: number } | null {
+        if (!isNativeSourceCanonicalHistory(this.provider?.nativeHistory)) return null;
+        // readExternalCompletionMessages resolves this session's OWN native-source
+        // conversation (providerSessionId / persisted pin / floor claim) and, as a
+        // side effect, refreshes this.lastExternalCompletionProbe with the source
+        // path, mtime, and message count. Reusing it keeps the resolution logic in
+        // one place and immune to the antigravity-style session-id quirks.
+        let messages: unknown[] | null = null;
+        try {
+            messages = this.readExternalCompletionMessages();
+        } catch {
+            return null; // best-effort: an unresolved transcript → fall back to PTY clock
+        }
+        const probe = this.lastExternalCompletionProbe;
+        if (!probe) return null;
+        return {
+            msgCount: typeof probe.msgCount === 'number' ? probe.msgCount : (Array.isArray(messages) ? messages.length : 0),
+            sourceMtimeMs: typeof probe.sourceMtimeMs === 'number' ? probe.sourceMtimeMs : 0,
+        };
+    }
+
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 2). Last-chance completion emit for a mesh
+     * DELEGATED worker whose PTY has already exited (e.g. killed by a false stall)
+     * and is about to be auto-cleaned (cli-manager.startCliExitMonitor →
+     * removeInstance closes the event-emit window forever). If the worker actually
+     * FINISHED its assigned turn — its authoritative native transcript holds a final
+     * assistant message for the injected task — but the completion event never fired
+     * (the stall-kill happened before the FSM's idle transition), emit it now so the
+     * coordinator learns the task completed instead of waiting ~180s for the reconcile
+     * transcript-poll to reclaim it.
+     *
+     * Scope & guards (must all hold to emit):
+     *   • mesh worker session only — a normal standalone session's ordinary exit is
+     *     never synthesized (isMeshWorkerSession()).
+     *   • DOUBLE-EMIT guard — refuse if this turn's completion already fired
+     *     (lastEmittedCompletion matches the current taskId). A worker that completed
+     *     cleanly and is merely being cleaned up never double-emits.
+     *   • evidence gate — reuse the same final-assistant/turn-scoped summary machinery
+     *     as the normal completion path (completionFinalSummary over the native
+     *     transcript). No in-turn assistant summary ⇒ no proof of completion ⇒ leave
+     *     the reclaim path to handle a genuinely-unfinished worker.
+     *
+     * Returns true when a synthetic completion was emitted, false otherwise. Safe to
+     * call unconditionally from the cleanup path.
+     */
+    flushMeshCompletionBeforeCleanup(): boolean {
+        if (!this.isMeshWorkerSession()) 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;
+        }
+
+        // Evidence gate: the injected task's own turn must have genuinely started
+        // (guards against synthesizing a completion off a reused session's stale tail
+        // before this task ran) and the native transcript must hold an in-turn final
+        // assistant summary. turnStartedAt anchors the turn-scoped read.
+        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. Defer to the
+        // coordinator's reclaim/reconcile path rather than fabricate a completion.
+        if (!finalSummary) return false;
+
+        LOG.warn('CLI', `[${this.type}] emitting pre-cleanup mesh completion for session ${this.instanceId} `
+            + `task=${taskId ?? '(none)'} — PTY exited before the completion event fired but the native transcript `
+            + `shows a finished turn; synthesizing completion so the coordinator is not left waiting for reclaim.`);
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), 'pre_cleanup_transcript_completion');
+        }
+        this.emitGeneratingCompleted({
+            chatTitle: '',
+            duration: undefined,
+            timestamp: Date.now(),
+            taskId,
+            finalSummary,
+            evidenceLevel: 'transcript',
+            completionDiagnostic: { source: 'pre_cleanup_transcript_completion' },
+        });
+        return true;
     }
 
     /**
@@ -2997,6 +3160,10 @@ export class CliProviderInstance implements ProviderInstance {
         if (summary) {
             this.lastCompletionSummary = { content: summary, receivedAt: opts.timestamp };
         }
+        // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): record that THIS turn's
+        // completion has now been emitted, keyed by its taskId, so the pre-cleanup
+        // completion flush never fires a duplicate for the same turn.
+        this.lastEmittedCompletion = { taskId: typeof opts.taskId === 'string' ? opts.taskId : '', at: Date.now() };
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle: opts.chatTitle,