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

package/dist/index.mjs

@@ -437,10 +437,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "8cce29137e6b62781be7645411736bd8d1a9e7a8" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "8cce2913" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "1.0.18-rc.12" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-22T12:25:26.100Z" : void 0);
+  const commit = readInjected(true ? "a44f4a2814c4db171a9ebb0f6fcfb0798203aebb" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a44f4a28" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "1.0.18-rc.14" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-22T17:37:52.683Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -22229,34 +22229,37 @@ async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDa
   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;
@@ -23164,7 +23167,7 @@ function assignedRowLiveStatusIsAwaitingApproval(mesh, nodeId, sessionId) {
     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;
@@ -23188,6 +23191,24 @@ async function recoverStrandedAssignedDispatches(components, mesh, store) {
         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") {
@@ -23446,7 +23467,7 @@ async function runMeshReconcileTick(components) {
       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) {
         LOG.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
       }
@@ -49113,6 +49134,18 @@ var CliProviderInstance = class _CliProviderInstance {
   // MESH_WORKER_STALL_REFIRE_COOLDOWN_MS between successive emissions across
   // anchor re-arms (the per-anchor guard only covers a single continuous stall).
   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.
+  meshStallNativeTranscriptSample = 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
@@ -49922,6 +49955,14 @@ var CliProviderInstance = class _CliProviderInstance {
    * once at completion). Reset on the next turn's start.
    */
   lastCompletionSummary = 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.
+  lastEmittedCompletion = null;
   async enforceFreshSessionLaunchIfNeeded() {
     const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
     if (!scriptName) return;
@@ -50547,6 +50588,24 @@ var CliProviderInstance = class _CliProviderInstance {
     const threshold = turnActive ? _CliProviderInstance.MESH_WORKER_STALL_TURN_THRESHOLD_MS : _CliProviderInstance.MESH_WORKER_STALL_IDLE_THRESHOLD_MS;
     const stalledMs = now - this.meshStallAnchorAt;
     if (stalledMs < threshold) return;
+    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 / 1e3)}s but transcript advancing)`
+          );
+        }
+        this.meshStallAnchorAt = now;
+        this.meshStallEmittedForAnchor = false;
+        return;
+      }
+    }
     this.meshStallEmittedForAnchor = true;
     if (this.meshStallLastFiredAt >= 0 && now - this.meshStallLastFiredAt < _CliProviderInstance.MESH_WORKER_STALL_REFIRE_COOLDOWN_MS) {
       return;
@@ -50583,6 +50642,99 @@ var CliProviderInstance = class _CliProviderInstance {
     this.meshStallEmittedForAnchor = false;
     this.meshStallTurnActiveLast = void 0;
     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.
+   */
+  sampleNativeTranscriptProgress() {
+    if (!isNativeSourceCanonicalHistory(this.provider?.nativeHistory)) return null;
+    let messages = null;
+    try {
+      messages = this.readExternalCompletionMessages();
+    } catch {
+      return null;
+    }
+    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() {
+    if (!this.isMeshWorkerSession()) 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;
+    LOG.warn("CLI", `[${this.type}] emitting pre-cleanup mesh completion for session ${this.instanceId} task=${taskId ?? "(none)"} \u2014 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: void 0,
+      timestamp: Date.now(),
+      taskId,
+      finalSummary,
+      evidenceLevel: "transcript",
+      completionDiagnostic: { source: "pre_cleanup_transcript_completion" }
+    });
+    return true;
   }
   /**
    * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
@@ -50984,6 +51136,7 @@ var CliProviderInstance = class _CliProviderInstance {
     if (summary) {
       this.lastCompletionSummary = { content: summary, receivedAt: opts.timestamp };
     }
+    this.lastEmittedCompletion = { taskId: typeof opts.taskId === "string" ? opts.taskId : "", at: Date.now() };
     this.pushEvent({
       event: "agent:generating_completed",
       chatTitle: opts.chatTitle,
@@ -53780,6 +53933,15 @@ var DaemonCliManager = class {
           clearInterval(checkStopped);
           setTimeout(() => {
             if (this.adapters.has(key2)) {
+              try {
+                const inst = instanceManager?.getInstance(key2);
+                if (typeof inst?.flushMeshCompletionBeforeCleanup === "function") {
+                  const emitted = inst.flushMeshCompletionBeforeCleanup();
+                  if (emitted) LOG.info("CLI", `Emitted pre-cleanup mesh completion for ${cliType} session ${key2} before auto-clean`);
+                }
+              } catch (e) {
+                LOG.warn("CLI", `pre-cleanup mesh completion flush failed for ${key2}: ${e?.message || e}`);
+              }
               this.adapters.delete(key2);
               this.deps.removeAgentTracking(key2);
               sessionRegistry?.unregisterByInstanceKey(key2);