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

package/dist/cli-adapter-types.d.ts

@@ -34,7 +34,10 @@ export interface CliAdapter {
     workingDir: string;
     _acpInstance?: AcpAdapterHandle;
     spawn(): Promise<void>;
-    sendMessage(text: string): Promise<void>;
+    sendMessage(text: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    forceSendMessage?(text: string): Promise<void>;
     getStatus(): CliAdapterStatus;
     getScriptParsedStatus?(): unknown;
     getDebugSnapshot?(): unknown;

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -214,7 +214,10 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private submitSendKey;
     private submitImmediatePrompt;
     private waitForEchoAndSubmit;
-    sendMessage(text: string): Promise<void>;
+    sendMessage(text: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    forceSendMessage(text: string): Promise<void>;
     private enqueuePendingOutboundMessage;
     private shouldQueuePendingOutboundMessage;
     private schedulePendingOutboundFlush;

package/dist/index.js

@@ -2563,7 +2563,7 @@ function hasPendingRefineTerminalEventDuplicate(event) {
   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
   );
 }
@@ -2588,12 +2588,91 @@ function buildPendingEventFingerprint(event) {
 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)) {
@@ -2616,38 +2695,19 @@ function drainPendingMeshCoordinatorEvents(meshId) {
   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;
@@ -2752,6 +2812,62 @@ function isDuplicateRefineTerminalEvent(meshId, eventName, metadataEvent) {
   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) {
@@ -2845,6 +2961,9 @@ function activeAssignedCount(meshId) {
 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();
@@ -3055,6 +3174,9 @@ async function triggerMeshQueue(components, meshId) {
 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") {
@@ -3092,7 +3214,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 });
@@ -3170,12 +3292,54 @@ function injectMeshSystemMessage(components, args) {
     LOG.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") {
+      LOG.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") {
+      LOG.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)) {
     LOG.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") {
+        LOG.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,
@@ -3452,6 +3616,10 @@ function handleMeshForwardEvent(components, payload) {
       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,
@@ -6351,9 +6519,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
+        });
+        LOG.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);
@@ -18118,8 +18304,18 @@ async function handleSendChat(h, args) {
         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}` };
       }
@@ -20470,6 +20666,7 @@ var CliProviderInstance = class {
   lastApprovalEventAt = 0;
   autoApproveBusy = false;
   autoApproveBusyTimer = null;
+  lastAutoApprovalSignature = "";
   controlValues = {};
   summaryMetadata = void 0;
   appliedEffectKeys = /* @__PURE__ */ new Set();
@@ -20979,15 +21176,26 @@ var CliProviderInstance = class {
   }
   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);
@@ -21129,7 +21337,26 @@ var CliProviderInstance = class {
     });
     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 });
     }
   }
@@ -23731,11 +23958,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();