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

package/dist/providers/chat-message-normalization.d.ts

@@ -58,6 +58,28 @@ export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessa
  * grace gate) on top of this structural check.
  */
 export declare function selectFinalAssistantTurnEndMessage(messages: ChatMessage[] | null | undefined): ChatMessage | 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 declare function hasTrailingToolActivityAfterFinalAssistant(messages: ChatMessage[] | null | undefined): boolean;
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

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.14",
+  "version": "1.0.18-rc.16",
   "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.14",
-    "@adhdev/session-host-core": "1.0.18-rc.14",
+    "@adhdev/mesh-shared": "1.0.18-rc.16",
+    "@adhdev/session-host-core": "1.0.18-rc.16",
     "@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-completion-synthesis.ts

@@ -26,7 +26,7 @@ import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
 import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
-import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
+import { extractFinalAssistantSummaryEvidence, hasTrailingToolActivityAfterFinalAssistant } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 import {
     getMeshV2BackstopCounters,
@@ -483,6 +483,17 @@ export async function pollAssignedTaskTerminalEvidence(
     const evidence = extractFinalAssistantSummaryEvidence(messages);
     if (!evidence.finalSummary) return null; // idle but no assistant result yet → not a turn-end
 
+    // EARLY-IDLE-COMPLETION-FALSE-POSITIVE (poll defense-in-depth): a momentary idle read
+    // (startup-grace, or the sliver between an assistant preamble and the tool it fires) can
+    // show an assistant "Let me explore…" bubble FOLLOWED by trailing Read/Grep tool_use — a
+    // turn that is still executing, not a turn-end. selectFinalAssistantTurnEndMessage skips
+    // those trailing tool bubbles and would promote the preamble, so guard here: if a
+    // tool/terminal activity bubble trails the final assistant message, the worker is mid-turn
+    // — refuse the completion (fall through to the caller's reclaim/grace path). A genuinely
+    // finished pure-PTY worker ends on its final assistant with no trailing tool activity, so
+    // the kimi rescue is preserved.
+    if (hasTrailingToolActivityAfterFinalAssistant(messages)) return null;
+
     // Stale-summary guard (same bar as PHASE 4): a reused session's transcript tail may hold a
     // PRIOR task's summary. Require the final assistant message to be dated at/after THIS task's
     // dispatch. When either timestamp is unusable, do NOT short-circuit — fall through so we never

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

@@ -69,13 +69,15 @@ import {
     resolveCoordinatorDaemonIds,
     daemonHostsMesh,
     resolveCoordinatorSelfIds,
+    daemonIdListIncludes,
 } from './mesh-reconcile-identity.js';
 import {
     resolveAutoPruneMinAgeMs,
     resolvePendingHeldDrainEscalateMs,
     resolveReconcileIntervalMs,
 } from './mesh-reconcile-config.js';
-import { pullRemoteNodeQueues, pullPendingEventsFromNode } from './mesh-remote-event-pull.js';
+import { pullRemoteNodeQueues, pullPendingEventsFromNode, reprobeWorkerStatus } from './mesh-remote-event-pull.js';
+import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
 import { runDiskRetentionSweep, detectAndSignalOrphanWorktrees } from './mesh-disk-retention.js';
 import {
     reconcileUnterminatedDirectDispatches,
@@ -732,10 +734,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
@@ -765,6 +789,118 @@ function assignedRowLiveStatusIsAwaitingApproval(
     }
 }
 
+// EARLY-IDLE-COMPLETION-FALSE-POSITIVE — resolve whether the assigned session's provider is
+// the pure-PTY transcript class (kimi and kin — no native history, no provider authority), from
+// the LOCAL instance when it is present. Returns:
+//   true      → local instance is a pure-PTY provider (the class the early rescue exists for)
+//   false     → local instance is NOT pure-PTY (native / provider-authoritative)
+//   undefined → no local instance (remote worker / gone / id-form skew) — pure-PTY unknowable here
+// A remote pure-PTY worker is handled by the reprobe path (a fresh-idle read positively confirms
+// the session is settled before the streak accrues), not by this local-only capability check.
+function resolveLocalSessionPurePty(components: DaemonComponents, sessionId: string): boolean | undefined {
+    try {
+        const instances = components.instanceManager?.getByCategory?.('cli') || [];
+        const inst = instances.find((i: any) => {
+            const sid = readNonEmptyString(i?.getState?.().instanceId);
+            return sid && sessionIdsEquivalent(sid, sessionId);
+        }) as { provider?: unknown } | undefined;
+        if (!inst) return undefined; // remote / gone / id-form skew — not locally observable
+        const provider = inst.provider;
+        if (!provider || typeof provider !== 'object') return undefined;
+        return isPurePtyTranscriptProvider(provider as Parameters<typeof isPurePtyTranscriptProvider>[0]);
+    } catch {
+        return undefined;
+    }
+}
+
+// EARLY-IDLE-COMPLETION-FALSE-POSITIVE — decide whether the early transcript-evidence completion
+// streak may ACCRUE this tick for an assigned row. This hardens the original arm gate, which only
+// checked `resolveSessionBusyVerdict(...) !== 'GENERATING'` — a gate a REMOTE worker (local verdict
+// UNKNOWN, not GENERATING) passed unconditionally, so its "8s continuous idle" streak degenerated to
+// 8s of wall-clock even while the worker was genuinely mid-turn, and a startup-grace boot-window idle
+// (before the first turn ever started) also passed. The row was then early-completed off a preamble.
+//
+// Two added requirements, defense-in-depth on top of the existing confirmed-delivery / no-terminal-
+// ledger / bound-session gate the caller applies:
+//   (a) POSITIVE idle evidence, not merely "not GENERATING". A LOCAL IDLE_CONFIRMED verdict qualifies
+//       directly. A remote/UNKNOWN verdict is RE-PROBED with a fresh read_chat status this tick: only
+//       a definitively 'idle' read lets the streak accrue; any active status (generating/waiting/…),
+//       or an inconclusive read, resets it. This is what stops the remote worker's mid-turn busy from
+//       silently passing as "continuous idle".
+//   (b) TURN-START evidence, so a boot-window / never-consumed idle cannot early-complete a preamble.
+//       taskDeliveryConsumed===true (the worker emitted agent:generating_started) satisfies it. When
+//       the delivery was never consumed, only a LOCAL pure-PTY provider — the exact class that never
+//       emits generating_started and that this rescue exists for — is still allowed; a native/
+//       provider-authoritative worker that hasn't started its turn is NOT armed (it will complete via
+//       its own emit or the normal grace). A remote-not-consumed worker whose provider class is
+//       unknowable locally falls back to the reprobe: it may accrue only once (a) reads it positively
+//       idle, and the poll's post-dispatch + trailing-tool-activity guards remain the final net.
+async function evaluateEarlyIdleTranscriptArm(
+    components: DaemonComponents,
+    mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
+    store: MeshRuntimeStore,
+    row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string },
+    localDaemonId?: string,
+    selfIds: string[] = [],
+): Promise<boolean> {
+    const sessionId = readNonEmptyString(row.assignedSessionId);
+    if (!sessionId) return false;
+
+    // (a) POSITIVE idle evidence.
+    const verdict = resolveSessionBusyVerdict(components, sessionId);
+    if (verdict === 'GENERATING') return false; // locally observed mid-turn — never accrue
+    if (verdict === 'UNKNOWN') {
+        // Remote / gone / id-form skew. First consult the LIVE mesh node snapshot (the same
+        // cross-daemon status feed the approval-hold guard and mesh_status use): if it already
+        // reports a definitively NON-idle status (generating / waiting_approval / awaiting_choice /
+        // …), the worker is not settled — reset the streak WITHOUT a read_chat. This keeps the
+        // streak the cheap per-tick gate for the common case and avoids probing a worker the graph
+        // already knows is busy or parked at an approval.
+        const nodeId = readNonEmptyString(row.assignedNodeId);
+        const node = (mesh.nodes ?? []).find(n => n.id === nodeId);
+        const liveStatus = nodeId
+            ? readNonEmptyString(sessionStatusFromNodes(mesh.nodes, nodeId, sessionId).status).toLowerCase()
+            : '';
+        if (liveStatus && liveStatus !== 'idle') return false; // live graph says non-idle → not a turn-end
+        if (!liveStatus) {
+            // No live snapshot for this session — re-probe the worker's own status this tick so a
+            // genuinely busy remote worker breaks the streak instead of coasting through as "not
+            // GENERATING". getInstance may be absent on some component surfaces (tests / standalone),
+            // so guard it.
+            const nodeDaemonId = readNonEmptyString(node?.daemonId);
+            const isLocalNode = !nodeDaemonId
+                || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
+                || daemonIdListIncludes(selfIds, nodeDaemonId)
+                || !!components.instanceManager?.getInstance?.(sessionId);
+            const providerType = readNonEmptyString(row.assignedProviderType);
+            const readArgs: Record<string, unknown> = {
+                sessionId,
+                targetSessionId: sessionId,
+                tailLimit: 1,
+                ...(node?.workspace ? { workspace: node.workspace } : {}),
+                ...(providerType ? { agentType: providerType, providerType } : {}),
+            };
+            const probedStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+            // Only a positively-idle re-probe lets the streak accrue. A non-idle status (the worker
+            // IS busy) or an inconclusive read (null — transport error / no payload) resets it: we
+            // never treat "couldn't tell" as idle for this early-completion path.
+            if (probedStatus !== 'idle') return false;
+        }
+    }
+
+    // (b) TURN-START evidence (guards the boot-window / preamble false positive).
+    if (store.taskDeliveryConsumed(mesh.id, row.id)) return true; // worker emitted generating_started
+    // Delivery never consumed. Preserve the kimi rescue ONLY for the LOCAL pure-PTY class (which
+    // never emits generating_started); a native/provider-authoritative local worker that hasn't
+    // started its turn must NOT be armed off a boot-window idle. For a remote worker (pure-PTY
+    // unknowable here) the positive-idle reprobe in (a) is the gate — allow accrual and let the poll
+    // enforce post-dispatch + trailing-tool-activity finality.
+    const localPurePty = resolveLocalSessionPurePty(components, sessionId);
+    if (localPurePty === true) return true;   // local pure-PTY — the class this rescue targets
+    if (localPurePty === false) return false; // local native/provider-owned, turn not started — hold
+    return verdict === 'UNKNOWN';             // remote, unknowable class — trust the (a) reprobe
+}
+
 // PHASE 2.5 — assigned-stranded dispatch watchdog (Bug B). claimNextTask atomically
 // flips a row to 'assigned' BEFORE the fire-and-forget dispatch runs. If that dispatch
 // neither rejects (→ no .catch requeue) nor is confirmed delivered — a relay that hangs
@@ -799,10 +935,82 @@ 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.
+        // EARLY-IDLE-COMPLETION-FALSE-POSITIVE: the arm gate now requires POSITIVE idle evidence
+        // (a fresh-idle reprobe for a remote/UNKNOWN worker, not merely "not GENERATING") AND
+        // turn-start evidence (delivery consumed, or the local pure-PTY class this rescue targets),
+        // so a mid-turn remote worker or a boot-window preamble can no longer coast the continuous-
+        // idle streak to a false completion. See evaluateEarlyIdleTranscriptArm.
+        const earlyArm =
+            store.taskHasConfirmedDelivery(meshId, row.id)
+            && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })
+            && readNonEmptyString(row.assignedSessionId)
+                ? await evaluateEarlyIdleTranscriptArm(components, mesh, store, row, localDaemonId, selfIds)
+                : false;
+        if (earlyArm) {
+            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

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.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