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

package/dist/index.js

@@ -30265,10 +30265,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "8cce29137e6b62781be7645411736bd8d1a9e7a8" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "8cce2913" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:26:05.397Z" : 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 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);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -79326,6 +79326,18 @@ ${body}
       // 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
@@ -80135,6 +80147,14 @@ ${body}
        * 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;
@@ -80760,6 +80780,24 @@ ${body}
         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;
@@ -80796,6 +80834,99 @@ ${body}
         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;
+        LOG2.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
@@ -81197,6 +81328,7 @@ ${body}
         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,
@@ -83980,6 +84112,15 @@ ${rawInput}` : rawInput;
               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) LOG2.info("CLI", `Emitted pre-cleanup mesh completion for ${cliType} session ${key2} before auto-clean`);
+                    }
+                  } catch (e) {
+                    LOG2.warn("CLI", `pre-cleanup mesh completion flush failed for ${key2}: ${e?.message || e}`);
+                  }
                   this.adapters.delete(key2);
                   this.deps.removeAgentTracking(key2);
                   sessionRegistry?.unregisterByInstanceKey(key2);