@adhdev/daemon-core 1.0.27 → 1.0.28-rc.2

package/dist/mesh/mesh-completion-synthesis.d.ts

@@ -11,6 +11,20 @@ export interface AssignedTaskTerminalEvidence {
     nodeId?: string;
     sessionId: string;
 }
+export declare function pollAssignedTaskInTurnProgress(components: DaemonComponents, mesh: {
+    id: string;
+    nodes?: Array<{
+        id: string;
+        daemonId?: string;
+        workspace?: string;
+    }>;
+}, row: {
+    id: string;
+    assignedSessionId?: string;
+    assignedNodeId?: string;
+    assignedProviderType?: string;
+    dispatchTimestamp?: string;
+}): Promise<boolean>;
 export declare function pollAssignedTaskTerminalEvidence(components: DaemonComponents, mesh: {
     id: string;
     nodes?: Array<{

package/package.json

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

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, hasTrailingToolActivityAfterFinalAssistant } from '../providers/chat-message-normalization.js';
+import { extractFinalAssistantSummaryEvidence, hasTrailingToolActivityAfterFinalAssistant, readChatMessageTimestampMs } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 import {
     getMeshV2BackstopCounters,
@@ -449,6 +449,90 @@ export interface AssignedTaskTerminalEvidence {
     sessionId: string;
 }
 
+// STARTED-REDRIVE-NATIVE-SOURCE-BLINDSPOT. Single-shot transcript poll that asks the NARROWER
+// question the delivered-not-consumed short re-drive needs: did the worker START this turn
+// (in-turn progress), regardless of whether it ever FINISHED it?
+//
+// The short re-drive treats "no agent:generating_started arrived" as positive evidence the worker
+// never consumed the task. That inference holds for a PTY-event provider, whose turn start IS an
+// emitted event. It is FALSE for a NATIVE-SOURCE provider (transcriptAuthority=provider +
+// on-disk nativeHistory — kimi and kin): its start/finish signals live in the native transcript,
+// not in the PTY event stream, so a worker that is demonstrably mid-task still reads
+// delivered-but-never-acked. The observed symptom (2026-07-25): a kimi worker answering the same
+// question four times as the watchdog re-injected the prompt at 35s/28s/27s/43s, then marked the
+// task failed — verdict IDLE_CONFIRMED, because between tool calls the session reads idle.
+//
+// pollAssignedTaskTerminalEvidence answers "did it FINISH" (idle + final-assistant + no trailing
+// tool activity). That is the wrong bar here: a worker mid-task has NOT finished, yet must not be
+// re-driven. This poll therefore accepts ANY post-dispatch transcript bubble — assistant text,
+// thought, or tool/terminal activity — as proof the prompt was consumed and work is under way.
+//
+// Conservative in the same direction as its sibling: an unreadable transcript, a missing/unusable
+// dispatch timestamp, or a tail containing nothing dated at/after dispatch all yield false, so the
+// caller falls through to its normal re-drive decision. The poll can only PREVENT a re-drive of a
+// working session, never create or suppress a completion.
+export async function pollAssignedTaskInTurnProgress(
+    components: DaemonComponents,
+    mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
+    row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
+): Promise<boolean> {
+    const sessionId = readNonEmptyString(row.assignedSessionId);
+    const nodeId = readNonEmptyString(row.assignedNodeId);
+    if (!sessionId || !nodeId) return false; // no worker to read
+
+    // A dispatch boundary is REQUIRED: without it a reused session's prior-task tail would read as
+    // progress on THIS task and suppress the re-drive forever.
+    const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
+    if (!Number.isFinite(dispatchedAtMs)) return false;
+
+    const node = (mesh.nodes ?? []).find(n => n.id === nodeId);
+    const nodeDaemonId = readNonEmptyString(node?.daemonId);
+    const localDaemonId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
+    const isLocalNode = !nodeDaemonId
+        || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
+        || !!components.instanceManager.getInstance(sessionId);
+
+    const providerType = readNonEmptyString(row.assignedProviderType);
+    const readArgs: Record<string, unknown> = {
+        sessionId,
+        targetSessionId: sessionId,
+        tailLimit: 10,
+        ...(node?.workspace ? { workspace: node.workspace } : {}),
+        ...(providerType ? { agentType: providerType, providerType } : {}),
+    };
+
+    let payload: Record<string, unknown> | null = null;
+    try {
+        if (isLocalNode) {
+            const result = await components.commandHandler?.handle('read_chat', readArgs);
+            if (result && (result as { success?: boolean }).success === false) return false;
+            payload = unwrapReadChatPayload(result);
+        } else if (components.dispatchMeshCommand) {
+            const result = await components.dispatchMeshCommand(nodeDaemonId, 'read_chat', readArgs);
+            payload = unwrapReadChatPayload(result);
+            if (payload && (payload as { success?: boolean }).success === false) return false;
+        } else {
+            return false; // remote node, no P2P transport — can't read this tick
+        }
+    } catch {
+        return false; // transport error / session gone → inconclusive, let the caller decide
+    }
+    if (!payload) return false;
+
+    const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
+    // Any AGENT-side bubble dated at/after dispatch proves the prompt landed and the turn is under
+    // way. User bubbles are excluded: the injected task prompt itself is a post-dispatch user
+    // message, and counting it would suppress the re-drive for the very row this watchdog exists
+    // to rescue (delivered, echoed into the transcript, but never actually worked).
+    return messages.some(msg => {
+        if (!msg) return false;
+        if (msg.role === 'user' || msg.role === 'system') return false;
+        const ts = readChatMessageTimestampMs(msg);
+        if (typeof ts !== 'number' || !Number.isFinite(ts)) return false;
+        return ts >= dispatchedAtMs;
+    });
+}
+
 export async function pollAssignedTaskTerminalEvidence(
     components: DaemonComponents,
     mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },

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

@@ -84,6 +84,7 @@ import {
     reconcileUnterminatedDirectDispatches,
     autoPruneStaleDirectDispatches,
     pollAssignedTaskTerminalEvidence,
+    pollAssignedTaskInTurnProgress,
     type AssignedTaskTerminalEvidence,
 } from './mesh-completion-synthesis.js';
 import { sessionStatusFromNodes } from './mesh-active-work.js';
@@ -1199,6 +1200,37 @@ async function recoverStrandedAssignedDispatches(
             if (verdict === 'GENERATING') {
                 deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
             } else {
+                // STARTED-REDRIVE-NATIVE-SOURCE-BLINDSPOT. Everything below infers "the worker never
+                // consumed the task" from the ABSENCE of agent:generating_started. That inference is
+                // only valid for a provider whose turn start IS a PTY event. A NATIVE-SOURCE provider
+                // (transcriptAuthority=provider + on-disk nativeHistory — kimi and kin) signals start
+                // and finish through its native transcript, never emitting generating_started, so the
+                // delivery legitimately stays 'delivered' while the worker is hard at work; and
+                // between tool calls it reads IDLE_CONFIRMED, which re-drives IMMEDIATELY with no
+                // grace at all. Live 2026-07-25: a kimi worker was re-injected the same prompt at
+                // 35s/28s/27s/43s (answering it each time) and the task then marked failed.
+                //
+                // So for that class ONLY, replace the missing event with the evidence the provider
+                // actually produces: any post-dispatch agent bubble in its transcript. Found → the
+                // prompt WAS consumed and the turn is under way; hold the row (and clear the streak,
+                // since progress is positive evidence, not a deferral). Not found / unreadable → fall
+                // through unchanged. PTY-event providers never enter this branch
+                // (resolveLocalSessionNativeSource false/undefined), so their behaviour is untouched.
+                const nativeSourceRedriveCandidate = row.assignedSessionId
+                    ? resolveLocalSessionNativeSource(components, row.assignedSessionId) === true
+                    : false;
+                if (nativeSourceRedriveCandidate
+                    && await pollAssignedTaskInTurnProgress(components, { id: meshId, nodes: mesh.nodes }, row)) {
+                    deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+                    traceMeshEventDrop('short_redrive_deferred_native_source_progress', {
+                        taskId: row.id,
+                        sessionId: row.assignedSessionId,
+                        nodeId: row.assignedNodeId,
+                        meshId,
+                        event: 'agent:generating_started',
+                    }, `native_source_in_turn_progress (verdict ${verdict})`);
+                    continue;
+                }
                 if (verdict === 'IDLE_CONFIRMED') {
                     deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
                 } else if (assignedRowLiveStatusIsAwaitingApproval(mesh, row.assignedNodeId, row.assignedSessionId)) {