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

package/dist/index.js

@@ -30265,10 +30265,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "2a9ab536171fcf675788ac5b41596e740046bbfa" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "2a9ab536" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.18-rc.13" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-22T14:02:17.678Z" : void 0);
+      const commit = readInjected(true ? "64f056340da99d3b28464efcf5c05fe643e5db63" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "64f05634" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.18-rc.15" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-23T00:53:09.129Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42873,6 +42873,12 @@ ${rendered}`, "utf-8");
         import_session_host_core22 = require_dist();
       }
     });
+    function isPurePtyTranscriptProvider(provider) {
+      if (provider.transcriptAuthority === "provider") return false;
+      if (provider.nativeHistory) return false;
+      const transcriptPty = provider.tui?.transcriptPty;
+      return transcriptPty?.scope === "buffer";
+    }
     function stripAnsi(str) {
       return str.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
     }
@@ -52218,34 +52224,37 @@ ${cleanBody}`;
       if (!dispatchMeshCommand) return;
       const meshId = mesh.id;
       const pulls = candidateDaemonIds.length > 0 ? candidateDaemonIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }];
-      await Promise.allSettled(mesh.nodes.map(async (node) => {
-        const nodeDaemonId = readNonEmptyString(node.daemonId);
-        if (!nodeDaemonId) return;
-        if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
-        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
-        const getPeerStatus = components.getMeshPeerConnectionStatus;
-        if (getPeerStatus) {
-          const peerSnapshot = getPeerStatus(nodeDaemonId);
-          if (!peerSnapshot || String(peerSnapshot.state) !== "connected") return;
-        }
-        for (const pendingEventArgs of pulls) {
-          let events;
+      await Promise.allSettled(mesh.nodes.map((node) => pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls)));
+    }
+    async function pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls) {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      if (!dispatchMeshCommand) return;
+      const nodeDaemonId = readNonEmptyString(node.daemonId);
+      if (!nodeDaemonId) return;
+      if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
+      if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
+      const getPeerStatus = components.getMeshPeerConnectionStatus;
+      if (getPeerStatus) {
+        const peerSnapshot = getPeerStatus(nodeDaemonId);
+        if (!peerSnapshot || String(peerSnapshot.state) !== "connected") return;
+      }
+      for (const pendingEventArgs of pulls) {
+        let events;
+        try {
+          events = await dispatchMeshCommand(nodeDaemonId, "get_pending_mesh_events", pendingEventArgs);
+        } catch {
+          break;
+        }
+        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);
+            handleMeshForwardEvent(components, payload);
           } catch {
-            break;
-          }
-          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 {
-            }
           }
         }
-      }));
+      }
     }
     function unwrapReadChatPayload(raw) {
       let cursor = raw;
@@ -53145,7 +53154,7 @@ ${cleanBody}`;
         return false;
       }
     }
-    async function recoverStrandedAssignedDispatches(components, mesh, store) {
+    async function recoverStrandedAssignedDispatches(components, mesh, store, localDaemonId, selfIds = []) {
       const meshId = mesh.id;
       const assigned = getQueue(meshId, { status: ["assigned"] });
       if (!assigned.length) return;
@@ -53158,10 +53167,54 @@ ${cleanBody}`;
       for (const key2 of [...deliveredUnconsumedUnknownStreak.keys()]) {
         if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) deliveredUnconsumedUnknownStreak.delete(key2);
       }
+      for (const key2 of [...assignedIdleFinalAssistantSince.keys()]) {
+        if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) assignedIdleFinalAssistantSince.delete(key2);
+      }
       for (const row of assigned) {
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
         if (!Number.isFinite(dispatchedAtMs)) continue;
         const ageMs = nowMs - dispatchedAtMs;
+        const idleTranscriptStreakKey = `${meshId}::${row.id}`;
+        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 === void 0) {
+            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 {
+                }
+              }
+              LOG2.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 \u2265${Math.round(ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS / 1e3)}s \u2014 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;
+            }
+            assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+          }
+        } else {
+          assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+        }
         if (ageMs >= ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS && ageMs < ASSIGNED_STRANDED_DEADLINE_MS && store.taskHasConfirmedDelivery(meshId, row.id) && !store.taskDeliveryConsumed(meshId, row.id)) {
           const terminal2 = findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id });
           if (terminal2) {
@@ -53169,6 +53222,24 @@ ${cleanBody}`;
             updateTaskStatus(meshId, row.id, status);
             continue;
           }
+          const assignedNode = row.assignedNodeId ? mesh.nodes?.find((n) => meshNodeIdMatches(n, row.assignedNodeId)) : void 0;
+          if (assignedNode?.daemonId) {
+            try {
+              await pullPendingEventsFromNode(
+                components,
+                meshId,
+                assignedNode,
+                localDaemonId,
+                selfIds,
+                selfIds.length > 0 ? selfIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }]
+              );
+            } catch {
+            }
+            if (store.taskDeliveryConsumed(meshId, row.id)) {
+              deliveredUnconsumedUnknownStreak.delete(`${meshId}::${row.id}`);
+              continue;
+            }
+          }
           const shortStreakKey = `${meshId}::${row.id}`;
           const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
           if (verdict === "GENERATING") {
@@ -53427,7 +53498,7 @@ ${cleanBody}`;
           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) {
             LOG2.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
           }
@@ -53829,6 +53900,8 @@ ${cleanBody}`;
     var RECLAIM_UNKNOWN_GRACE_TICKS;
     var deliveredNoTurnUnknownStreak;
     var deliveredUnconsumedUnknownStreak;
+    var ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS;
+    var assignedIdleFinalAssistantSince;
     var ZOMBIE_ASSIGNED_MIN_AGE_MS;
     var STRICT_SESSION_MATCH_TTL_MS;
     var unresolvedForwardRejectionCounts;
@@ -53873,6 +53946,8 @@ ${cleanBody}`;
         RECLAIM_UNKNOWN_GRACE_TICKS = 3;
         deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
         deliveredUnconsumedUnknownStreak = /* @__PURE__ */ new Map();
+        ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS = 8e3;
+        assignedIdleFinalAssistantSince = /* @__PURE__ */ new Map();
         ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
         STRICT_SESSION_MATCH_TTL_MS = 6e4;
         unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
@@ -56630,7 +56705,8 @@ ${cont}` : cont;
             this.currentTurnStartedAt = Date.now();
             this.responseEpoch += 1;
             this.clearApprovalResolutionMemory();
-            if (this.provider.transcriptAuthority === "provider" && this.currentStatus !== "waiting_approval") {
+            const promoteOnTurnStart = this.provider.transcriptAuthority === "provider" || isPurePtyTranscriptProvider(this.provider);
+            if (promoteOnTurnStart && this.currentStatus !== "waiting_approval") {
               this.setStatus("generating", "turn_started");
               this.callbacks.onStatusChange();
             }
@@ -58161,10 +58237,7 @@ ${lastSnapshot}`;
            * provider-owned) so no other provider's turn-scoped parse changes.
            */
           parsesFullPtyTranscriptFromBuffer() {
-            if (this.providerOwnsTranscript()) return false;
-            if (this.provider.nativeHistory) return false;
-            const transcriptPty = this.provider.tui?.transcriptPty;
-            return transcriptPty?.scope === "buffer";
+            return isPurePtyTranscriptProvider(this.provider);
           }
           /**
            * The turn scope to feed the transcript parser. Normally the live turn scope
@@ -75170,6 +75243,7 @@ ${body}
     init_contracts2();
     init_provider_input_support();
     init_hash();
+    init_provider_cli_shared();
     var fs222 = __toESM2(require("fs"));
     var path26 = __toESM2(require("path"));
     init_provider_cli_adapter();
@@ -80798,6 +80872,10 @@ ${body}
             return;
           }
         }
+        if (this.tryReconcilePurePtyCompletionForStall(observedStatus)) {
+          this.meshStallEmittedForAnchor = true;
+          return;
+        }
         this.meshStallEmittedForAnchor = true;
         if (this.meshStallLastFiredAt >= 0 && now - this.meshStallLastFiredAt < _CliProviderInstance.MESH_WORKER_STALL_REFIRE_COOLDOWN_MS) {
           return;
@@ -80928,6 +81006,70 @@ ${body}
         });
         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.
+       */
+      tryReconcilePurePtyCompletionForStall(observedStatus) {
+        if (!isPurePtyTranscriptProvider(this.provider)) return false;
+        if (observedStatus !== "idle") return false;
+        if (this.hasAdapterPendingResponse()) return false;
+        const taskId = this.completingTurnTaskId();
+        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? "")) {
+          return false;
+        }
+        if (!this.injectedTaskHasStartedGenerating()) return false;
+        const turnStartedAt = typeof this.adapter?.currentTurnStartedAt === "number" ? this.adapter.currentTurnStartedAt : this.meshTaskInjectedAt || void 0;
+        let parsedMessages;
+        try {
+          parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
+        } catch {
+          parsedMessages = void 0;
+        }
+        let finalSummary;
+        try {
+          finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
+        } catch {
+          finalSummary = void 0;
+        }
+        if (!finalSummary) return false;
+        LOG2.warn("CLI", `[${this.type}] reconciling pure-PTY mesh completion from the stall path for session ${this.instanceId} task=${taskId ?? "(none)"} \u2014 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: void 0,
+          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