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

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 ? "2a9ab536171fcf675788ac5b41596e740046bbfa" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "2a9ab536" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = 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:01:45.066Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -49113,6 +49113,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 +49934,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 +50567,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 +50621,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 +51115,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 +53912,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);