@adhdev/daemon-standalone 0.9.82-rc.121 → 0.9.82-rc.122

package/dist/index.js

@@ -24713,7 +24713,7 @@ Follow these recovery rules:
       if (!REFINE_TERMINAL_EVENTS.has(event.event)) return false;
       const jobId = readRefineJobId(event);
       if (!jobId) return false;
-      return getPendingMeshCoordinatorEvents(event.meshId).some(
+      return readPendingMeshCoordinatorEventsFromDisk(event.meshId).some(
         (pending) => pending.event === event.event && readRefineJobId(pending) === jobId
       );
     }
@@ -24738,12 +24738,91 @@ Follow these recovery rules:
     function hasPendingCoordinatorEventDuplicate(event) {
       const fingerprint = buildPendingEventFingerprint(event);
       if (!fingerprint.trim()) return false;
-      return getPendingMeshCoordinatorEvents(event.meshId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
+      return readPendingMeshCoordinatorEventsFromDisk(event.meshId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
     }
     function getPendingEventsPath(meshId) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path7.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
     }
+    function readPendingMeshCoordinatorEventsFromDisk(meshId) {
+      if (!meshId) return [];
+      const path28 = getPendingEventsPath(meshId);
+      if (!(0, import_fs8.existsSync)(path28)) return [];
+      try {
+        const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
+        return raw.split("\n").filter(Boolean).flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      } catch {
+        return [];
+      }
+    }
+    function refineTerminalEventFromLedger(meshId, pending) {
+      const acceptedJobIds = new Set(
+        pending.filter((event) => event.event === "refine:accepted").map((event) => readRefineJobId(event)).filter(Boolean)
+      );
+      if (acceptedJobIds.size === 0) return [];
+      const existingTerminalJobIds = new Set(
+        pending.filter((event) => REFINE_TERMINAL_EVENTS.has(event.event)).map((event) => `${event.event}:${readRefineJobId(event)}`).filter((value) => !value.endsWith(":"))
+      );
+      const backfilled = [];
+      const entries = readLedgerEntries(meshId);
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== "task_completed" && entry.kind !== "task_failed") continue;
+        const payload = readRecord2(entry.payload);
+        if (payload?.source !== "refine_mesh_node_async_job") continue;
+        const refineJob = readRecord2(payload.refineJob);
+        const jobId = readNonEmptyString2(refineJob?.jobId);
+        if (!jobId || !acceptedJobIds.has(jobId)) continue;
+        const eventName = entry.kind === "task_completed" ? "refine:completed" : "refine:failed";
+        if (existingTerminalJobIds.has(`${eventName}:${jobId}`)) continue;
+        existingTerminalJobIds.add(`${eventName}:${jobId}`);
+        const result = readRecord2(payload.result);
+        const metadataEvent = {
+          source: "refine_mesh_node_async_job",
+          jobId,
+          interactionId: readNonEmptyString2(refineJob?.interactionId),
+          meshId,
+          nodeId: readNonEmptyString2(refineJob?.nodeId) || entry.nodeId,
+          targetDaemonId: readNonEmptyString2(refineJob?.targetDaemonId),
+          workspace: readNonEmptyString2(refineJob?.workspace),
+          status: eventName === "refine:completed" ? "completed" : "failed",
+          startedAt: readNonEmptyString2(refineJob?.startedAt),
+          completedAt: readNonEmptyString2(refineJob?.completedAt) || entry.timestamp,
+          retryOfJobId: readNonEmptyString2(refineJob?.retryOfJobId) || readNonEmptyString2(payload.retryOfJobId),
+          ...result ? { result } : {}
+        };
+        backfilled.push({
+          event: eventName,
+          meshId,
+          nodeLabel: readNonEmptyString2(refineJob?.nodeId) || entry.nodeId || "refine job",
+          nodeId: readNonEmptyString2(refineJob?.nodeId) || entry.nodeId,
+          workspace: readNonEmptyString2(refineJob?.workspace),
+          metadataEvent,
+          coordinatorMessage: buildMeshSystemMessage({
+            event: eventName,
+            nodeLabel: readNonEmptyString2(refineJob?.nodeId) || entry.nodeId || "refine job",
+            metadataEvent
+          }),
+          queuedAt: Date.now()
+        });
+      }
+      return backfilled.reverse();
+    }
+    function reconcilePendingMeshCoordinatorEvents(meshId, events) {
+      const backfilled = refineTerminalEventFromLedger(meshId, events);
+      if (backfilled.length === 0) return events;
+      const terminalJobIds = new Set(backfilled.map((event) => readRefineJobId(event)).filter(Boolean));
+      return [
+        ...events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId(event)))),
+        ...backfilled
+      ];
+    }
     function queuePendingMeshCoordinatorEvent(event) {
       try {
         if (hasPendingRefineTerminalEventDuplicate(event)) {
@@ -24766,38 +24845,19 @@ Follow these recovery rules:
       const path28 = getPendingEventsPath(meshId);
       if (!(0, import_fs8.existsSync)(path28)) return [];
       try {
-        const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
+        const parsed = readPendingMeshCoordinatorEventsFromDisk(meshId);
         try {
           (0, import_fs8.unlinkSync)(path28);
         } catch {
         }
-        return raw.split("\n").filter(Boolean).flatMap((line) => {
-          try {
-            return [JSON.parse(line)];
-          } catch {
-            return [];
-          }
-        });
+        return reconcilePendingMeshCoordinatorEvents(meshId, parsed);
       } catch {
         return [];
       }
     }
     function getPendingMeshCoordinatorEvents(meshId) {
       if (!meshId) return [];
-      const path28 = getPendingEventsPath(meshId);
-      if (!(0, import_fs8.existsSync)(path28)) return [];
-      try {
-        const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
-        return raw.split("\n").filter(Boolean).flatMap((line) => {
-          try {
-            return [JSON.parse(line)];
-          } catch {
-            return [];
-          }
-        });
-      } catch {
-        return [];
-      }
+      return reconcilePendingMeshCoordinatorEvents(meshId, readPendingMeshCoordinatorEventsFromDisk(meshId));
     }
     function clearPendingMeshCoordinatorEvents(meshId) {
       if (!meshId) return;
@@ -24902,6 +24962,62 @@ Follow these recovery rules:
       recentCompletionFingerprints.set(fingerprint, now);
       return false;
     }
+    function findRecentTerminalLedgerEvidence(args) {
+      if (!args.sessionId && !args.nodeId) return null;
+      const entries = readLedgerEntries(args.meshId);
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+        if (args.sessionId && entry.sessionId === args.sessionId) {
+          return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+        }
+        if (!args.sessionId && args.nodeId && entry.nodeId === args.nodeId) {
+          return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+        }
+      }
+      return null;
+    }
+    function buildLongGeneratingCompletionReconciliation(args) {
+      const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+      const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
+      const providerType = readNonEmptyString2(args.metadataEvent.providerType);
+      const providerSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
+      const workerResult = readWorkerResultMetadata(args.metadataEvent);
+      const completionDiagnostic = readRecord2(args.metadataEvent.completionDiagnostic);
+      const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
+      const status = readNonEmptyString2(args.metadataEvent.status).toLowerCase();
+      const explicitCompletionEvidence = Boolean(
+        finalSummary || workerResult || completionDiagnostic?.finalAssistantPresent === true || status === "idle" || status === "ready" || status === "completed"
+      );
+      if (explicitCompletionEvidence) {
+        return {
+          ...args.metadataEvent,
+          targetSessionId: sessionId,
+          providerType,
+          providerSessionId,
+          finalSummary,
+          source: "long_generating_reconciliation",
+          reconciledFromEvent: "monitor:long_generating",
+          timestamp: args.metadataEvent.timestamp ?? Date.now(),
+          completionDiagnostic: {
+            ...completionDiagnostic || {},
+            reconciliationReason: "provider_completion_evidence"
+          }
+        };
+      }
+      const terminal = findRecentTerminalLedgerEvidence({
+        meshId: args.meshId,
+        sessionId: sessionId || void 0,
+        nodeId: nodeId || void 0
+      });
+      if (!terminal) return null;
+      return {
+        ...args.metadataEvent,
+        source: "long_generating_terminal_ledger_suppression",
+        terminalLedgerKind: terminal.kind,
+        terminalLedgerAt: terminal.timestamp
+      };
+    }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
       const task = claimNextTask(meshId, nodeId, sessionId);
       if (!task) {
@@ -24995,6 +25111,9 @@ Follow these recovery rules:
     function nodeHasActiveAssignment(meshId, nodeId) {
       return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
     }
+    function sessionHasActiveAssignment(meshId, sessionId) {
+      return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId);
+    }
     function liveSessionCountForNode(components, meshId, nodeId) {
       return components.instanceManager.getByCategory("cli").filter((inst) => {
         const state = inst.getState();
@@ -25205,6 +25324,9 @@ Follow these recovery rules:
     function buildMeshSystemMessage(args) {
       const metadata = formatCompletionMetadata(args.metadataEvent);
       if (args.event === "agent:generating_completed") {
+        if (args.metadataEvent.source === "long_generating_reconciliation") {
+          return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The long-generating monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
+        }
         return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path; use mesh_read_chat once to review its final progress, but do not poll repeatedly.`;
       }
       if (args.event === "agent:waiting_approval") {
@@ -25242,7 +25364,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
       }
       if (args.event === "monitor:long_generating") {
-        return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
+        return `[System] ${args.nodeLabel} is still reported as generating after a long interval${metadata}. Wait for pendingCoordinatorEvents or a completion/status event; if the user explicitly asks for status, make one bounded status check and then wait again.`;
       }
       if (args.event === "refine:accepted") {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
@@ -25320,12 +25442,54 @@ Next step: ${nextStep}`;
         LOG2.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
       }
+      if (args.event === "monitor:long_generating") {
+        const reconciledCompletion = buildLongGeneratingCompletionReconciliation({
+          meshId: args.meshId,
+          nodeId: args.nodeId,
+          nodeLabel: args.nodeLabel,
+          metadataEvent: args.metadataEvent,
+          sourceInstanceId: args.sourceInstanceId
+        });
+        if (reconciledCompletion?.source === "long_generating_reconciliation") {
+          LOG2.info("MeshEvents", `Reconciled long-generating monitor to completion for session ${eventSessionId || "(unknown session)"}`);
+          return injectMeshSystemMessage(components, {
+            ...args,
+            event: "agent:generating_completed",
+            metadataEvent: reconciledCompletion
+          });
+        }
+        if (reconciledCompletion?.source === "long_generating_terminal_ledger_suppression") {
+          LOG2.info("MeshEvents", `Suppressed long-generating monitor because terminal ledger evidence already exists for session ${eventSessionId || "(unknown session)"}`);
+          return {
+            success: true,
+            forwarded: 0,
+            suppressed: true,
+            terminalLedgerEvidence: true,
+            terminalLedgerKind: reconciledCompletion.terminalLedgerKind
+          };
+        }
+      }
       if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
         LOG2.info("MeshEvents", `Suppressed duplicate ${args.event} for refine job ${readRefineJobId({ metadataEvent: args.metadataEvent })}`);
         return { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true };
       }
       const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
       if (args.event === "agent:generating_completed" && eventSessionId) {
+        const terminal = findRecentTerminalLedgerEvidence({
+          meshId: args.meshId,
+          sessionId: eventSessionId,
+          nodeId: eventNodeId || void 0
+        });
+        if (terminal?.kind === "task_completed" && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
+          const terminalProviderSessionId = readNonEmptyString2(terminal.payload.providerSessionId);
+          const terminalFinalSummary = readNonEmptyString2(terminal.payload.finalSummary);
+          const eventProviderSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
+          const eventFinalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
+          if (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId || terminalFinalSummary && terminalFinalSummary === eventFinalSummary || args.metadataEvent.source === "long_generating_reconciliation") {
+            LOG2.info("MeshEvents", `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
+            return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+          }
+        }
         const duplicateCompletion = isDuplicateMeshCompletionEvent({
           meshId: args.meshId,
           event: args.event,
@@ -25602,6 +25766,10 @@ Next step: ${nextStep}`;
           completedAt: readNonEmptyString2(payload.completedAt),
           retryOfJobId: readNonEmptyString2(payload.retryOfJobId),
           ...payload.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? { result: payload.result } : {},
+          ...payload.completionDiagnostic && typeof payload.completionDiagnostic === "object" && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {},
+          ...payload.workerResult && typeof payload.workerResult === "object" && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {},
+          ...payload.meshWorkerResult && typeof payload.meshWorkerResult === "object" && !Array.isArray(payload.meshWorkerResult) ? { meshWorkerResult: payload.meshWorkerResult } : {},
+          ...payload.structuredResult && typeof payload.structuredResult === "object" && !Array.isArray(payload.structuredResult) ? { structuredResult: payload.structuredResult } : {},
           ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
           intentional: payload.intentional === true,
           intentionalStop: payload.intentionalStop === true,
@@ -28509,9 +28677,27 @@ ${lastSnapshot}`;
               nextScreenChangeAt
             ), 50);
           }
-          async sendMessage(text) {
+          async sendMessage(text, options = {}) {
+            if (options.force === true) {
+              await this.forceSendMessage(text);
+              return;
+            }
             await this.sendMessageNow(text, true);
           }
+          async forceSendMessage(text) {
+            if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+            const content = String(text || "");
+            if (!content.trim()) return;
+            this.recordTrace("force_send_message", {
+              text: summarizeCliTraceText(content, 500),
+              status: this.currentStatus,
+              isWaitingForResponse: this.isWaitingForResponse,
+              queueLength: this.pendingOutboundQueue.length
+            });
+            LOG2.info("CLI", `[${this.cliType}] force-sending prompt while status=${this.currentStatus}`);
+            await this.writeToPty(content + this.sendKey);
+            this.onStatusChange?.();
+          }
           enqueuePendingOutboundMessage(text, reason) {
             const content = String(text || "");
             const duplicate = this.pendingOutboundQueue.some((message2) => message2.content === content);
@@ -40144,8 +40330,18 @@ ${effect.notification.body || ""}`.trim();
             assertTextOnlyInput(provider, input);
             if (!text) return { success: false, error: "text required for PTY send" };
             await waitOnceForFreshHermesCliStart(adapter, _log);
-            await adapter.sendMessage(text);
-            return _logSendSuccess(`${transport}-adapter`, adapter.cliType);
+            const forceSend = args?.force === true || args?.forceSend === true;
+            if (forceSend && typeof adapter.forceSendMessage === "function") {
+              await adapter.forceSendMessage(text);
+            } else if (forceSend) {
+              await adapter.sendMessage(text, { force: true });
+            } else {
+              await adapter.sendMessage(text);
+            }
+            return {
+              ..._logSendSuccess(`${transport}-adapter`, adapter.cliType),
+              ...forceSend ? { forceSent: true } : {}
+            };
           } catch (e) {
             return { success: false, error: `${transport} send failed: ${e.message}` };
           }
@@ -42474,6 +42670,7 @@ ${effect.notification.body || ""}`.trim();
       lastApprovalEventAt = 0;
       autoApproveBusy = false;
       autoApproveBusyTimer = null;
+      lastAutoApprovalSignature = "";
       controlValues = {};
       summaryMetadata = void 0;
       appliedEffectKeys = /* @__PURE__ */ new Set();
@@ -42983,15 +43180,26 @@ ${effect.notification.body || ""}`.trim();
       }
       maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
         const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove();
-        if (autoApproveActive && !this.autoApproveBusy) {
+        if (!autoApproveActive) {
+          this.lastAutoApprovalSignature = "";
+          return autoApproveActive;
+        }
+        const modal = adapterStatus.activeModal;
+        const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(modal?.buttons, this.provider);
+        const signature = [
+          typeof modal?.message === "string" ? modal.message.trim() : "",
+          Array.isArray(modal?.buttons) ? modal.buttons.join("|") : "",
+          buttonIndex
+        ].join("::");
+        if (!this.autoApproveBusy || signature !== this.lastAutoApprovalSignature) {
           this.autoApproveBusy = true;
+          this.lastAutoApprovalSignature = signature;
           if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
           this.autoApproveBusyTimer = setTimeout(() => {
             this.autoApproveBusy = false;
             this.autoApproveBusyTimer = null;
+            this.lastAutoApprovalSignature = "";
           }, 2e3);
-          const modal = adapterStatus.activeModal;
-          const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(modal?.buttons, this.provider);
           this.recordAutoApproval(modal?.message, buttonLabel, now);
           setTimeout(() => {
             this.adapter.resolveModal(buttonIndex);
@@ -43133,7 +43341,26 @@ ${effect.notification.body || ""}`.trim();
         });
         const agentKey = `${this.type}:cli`;
         const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+        const monitorParsedStatus = parsedStatus;
         for (const me of monitorEvents) {
+          if (me.type === "monitor:long_generating" && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages) && !this.hasAdapterPendingResponse() && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)) {
+            this.pushEvent({
+              event: "agent:generating_completed",
+              chatTitle,
+              duration: this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : void 0,
+              timestamp: me.timestamp,
+              finalSummary: extractFinalSummaryFromMessages(monitorParsedStatus?.messages),
+              completionDiagnostic: {
+                providerType: this.type,
+                sessionId: this.instanceId,
+                providerSessionId: this.providerSessionId || null,
+                reconciliationReason: "long_generating_monitor_final_summary",
+                finalAssistantPresent: true
+              }
+            });
+            this.generatingStartedAt = 0;
+            continue;
+          }
           this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
         }
       }
@@ -45727,11 +45954,19 @@ Run 'adhdev doctor' for detailed diagnostics.`
               }
               const message = input.textFallback;
               if (!message) throw new Error("message required for send_chat");
-              await adapter.sendMessage(message);
+              const forceSend = args?.force === true || args?.forceSend === true;
+              if (forceSend && typeof adapter.forceSendMessage === "function") {
+                await adapter.forceSendMessage(message);
+              } else if (forceSend) {
+                await adapter.sendMessage(message, { force: true });
+              } else {
+                await adapter.sendMessage(message);
+              }
               return {
                 success: true,
                 status: BUSY_AGENT_STATUSES.has(currentStatus) ? currentStatus : "generating",
-                ...BUSY_AGENT_STATUSES.has(currentStatus) ? { queued: true, queuedReason: "agent_runtime_busy" } : {}
+                ...BUSY_AGENT_STATUSES.has(currentStatus) ? { queued: true, queuedReason: "agent_runtime_busy" } : {},
+                ...forceSend ? { forceSent: true, queued: false } : {}
               };
             } else if (action === "clear_history") {
               if (typeof adapter.clearHistory === "function") adapter.clearHistory();