@adhdev/daemon-core 0.9.82-rc.362 → 0.9.82-rc.364

package/dist/cli-adapters/cli-state-engine.d.ts

@@ -83,7 +83,7 @@ export declare class CliStateEngine {
      * seq) is always a real, distinct approval and must be written.
      */
     approvalEntrySeq: number;
-    private lastResolvedEntrySeq;
+    lastResolvedEntrySeq: number;
     /**
      * When the engine previously held a modal but the latest parse failed
      * to extract one, we record the timestamp here and only drop the modal

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

@@ -36,6 +36,16 @@ export interface CliSessionStatus {
      * seq is the only reliable discriminator.
      */
     approvalEntrySeq?: number;
+    /**
+     * The approval entry seq that the engine's last resolveModal() handled. When
+     * `lastResolvedEntrySeq >= approvalEntrySeq` (and approvalEntrySeq > 0) it is positive
+     * evidence that the current/latest approval entry was resolved through ADHDev (auto-approve
+     * fire, dashboard / mesh_approve, or dev-cli-debug — all route through resolveModal). The
+     * completion finalization gate uses this to avoid confirming a waiting_approval→idle
+     * transition for which no resolution actually occurred (a false idle: the spec's text-based
+     * approval→idle rule tripped while the modal is still on screen).
+     */
+    lastResolvedEntrySeq?: number;
     activeInteractivePrompt?: InteractivePrompt | null;
     pendingOutboundCount?: number;
     pendingOutboundMessages?: Array<{

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "4b7c1b0d781f263663369085c4dde301d3b5cd2e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "4b7c1b0d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.362" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-23T12:54:22.426Z" : void 0);
+  const commit = readInjected(true ? "1428e9d027beefe860a77f34dea34d202db80f00" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "1428e9d0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.364" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-24T00:05:49.524Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -8594,6 +8594,13 @@ function readEventTimestampValue(value) {
   }
   return 0;
 }
+function isWeakCompletionMetadata(metadataEvent) {
+  const evidenceLevel = readNonEmptyString2(metadataEvent.evidenceLevel);
+  if (evidenceLevel === "insufficient" || evidenceLevel === "weak") return true;
+  if (metadataEvent.reviewRecommended === true) return true;
+  const diag = readRecord4(metadataEvent.completionDiagnostic);
+  return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
+}
 function formatCompletionMetadata(event) {
   const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === "object" ? event.completionDiagnostic : null;
   const diagnosticReason = completionDiagnostic ? readNonEmptyString2(completionDiagnostic.blockReason) || "present" : "";
@@ -8616,17 +8623,19 @@ function buildMeshSystemMessage(args) {
       return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
     }
     const reviewRecommended = args.metadataEvent.reviewRecommended === true;
+    const weakCompletion = isWeakCompletionMetadata(args.metadataEvent);
+    const verifyTextNote = " Completion evidence is weak \u2014 verify via mesh_read_chat or git status before declaring the task done; the worker may still be parked on an approval/modal.";
     const completionSummary = readMeshCompletionSummary(args.metadataEvent);
     if (completionSummary) {
       const truncationSuffix = "\n\u2026[truncated \u2014 call mesh_read_chat once for the full transcript]";
       const surfaced = completionSummary.length > MESH_COMPLETION_SURFACE_MAX_CHARS ? `${completionSummary.slice(0, MESH_COMPLETION_SURFACE_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}` : completionSummary;
-      const verifyNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done." : "";
+      const verifyNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done." : weakCompletion ? verifyTextNote : "";
       return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. Its final summary is included below \u2014 read it directly and only call mesh_read_chat if you need the full transcript.${verifyNote}
 
 --- ${args.nodeLabel} final summary ---
 ${surfaced}`;
     }
-    const reviewNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
+    const reviewNote = reviewRecommended ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : weakCompletion ? `${verifyTextNote} Use mesh_read_chat once if needed, but do not poll repeatedly.` : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
     return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;
   }
   if (args.event === "agent:waiting_approval") {
@@ -8761,7 +8770,7 @@ function hasPendingRefineTerminalEventDuplicate(event) {
     (pending) => pending.event === event.event && readRefineJobId2(pending) === jobId
   );
 }
-function isWeakCompletionMetadata(metadata) {
+function isWeakCompletionMetadata2(metadata) {
   const evidenceLevel = readNonEmptyString2(metadata.evidenceLevel);
   if (evidenceLevel === "insufficient" || evidenceLevel === "weak") return true;
   if (metadata.reviewRecommended === true) return true;
@@ -8780,7 +8789,7 @@ function buildPendingEventFingerprint(event) {
         event.meshId,
         event.event,
         terminalTaskId,
-        isWeakCompletionMetadata(metadata) ? "weak" : "genuine"
+        isWeakCompletionMetadata2(metadata) ? "weak" : "genuine"
       ].join("::");
     }
   }
@@ -12863,9 +12872,22 @@ function deliverTaskToSession(dispatchThunk, ctx) {
     }
   });
 }
+function normalizeMeshWorkspaceForCompare(dir) {
+  if (typeof dir !== "string") return "";
+  return dir.trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const mesh = getMeshWithCache(components, meshId);
   const node = mesh?.nodes.find((n) => readMeshNodeId(n) === nodeId);
+  const localClaimAdapter = components.cliManager?.adapters?.get(sessionId);
+  if (localClaimAdapter) {
+    const sessionWorkspace = normalizeMeshWorkspaceForCompare(localClaimAdapter.workingDir);
+    const nodeWorkspace = normalizeMeshWorkspaceForCompare(readNonEmptyString2(node?.workspace));
+    if (sessionWorkspace && nodeWorkspace && sessionWorkspace !== nodeWorkspace) {
+      LOG.info("MeshQueue", `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) \u2014 session workspace "${sessionWorkspace}" \u2260 node workspace "${nodeWorkspace}" (cross-workspace dispatch blocked)`);
+      return false;
+    }
+  }
   const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
   const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
   const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
@@ -17378,6 +17400,12 @@ var init_cli_state_engine = __esm({
        * seq) is always a real, distinct approval and must be written.
        */
       approvalEntrySeq = 0;
+      // Records which approval entry the last resolveModal() handled. Set unconditionally on
+      // every resolveModal (auto-approve fire, dashboard/mesh_approve, dev-cli-debug), so
+      // `lastResolvedEntrySeq >= approvalEntrySeq` is positive, ADHDev-side proof that the
+      // current/latest approval entry was actually resolved. Exposed via getStatus so the
+      // completion finalization gate (FALSEIDLE-a) can require resolution evidence before
+      // confirming a waiting_approval→idle transition. Public (read-only by convention).
       lastResolvedEntrySeq = -1;
       /**
        * When the engine previously held a modal but the latest parse failed
@@ -19095,6 +19123,7 @@ ${lastSnapshot}`;
           workingDir: this.workingDir,
           activeModal: effectiveModal,
           approvalEntrySeq: this.engine.approvalEntrySeq,
+          lastResolvedEntrySeq: this.engine.lastResolvedEntrySeq,
           pendingOutboundCount: this.pendingOutboundQueue.length,
           pendingOutboundMessages: this.pendingOutboundQueue.map((message) => ({
             id: message.id,
@@ -35062,6 +35091,11 @@ var FsmDriver = class {
   lastWin32WriteAt = 0;
   /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
   win32WriteTimer = null;
+  /** Timer driving the win32 verification-based modal-confirm CR resend loop (see
+   *  scheduleWin32ModalConfirm). A lone CR that confirms an approval/picker choice
+   *  is absorbed by ConPTY the same way a send_message submit CR is, so the confirm
+   *  must be resent until the modal actually resolves (status leaves 'approval'). */
+  win32ModalConfirmTimer = null;
   currentEval = null;
   stateHistory = [];
   prevStateAt = 0;
@@ -35186,6 +35220,10 @@ var FsmDriver = class {
       clearTimeout(this.win32WriteTimer);
       this.win32WriteTimer = null;
     }
+    if (this.win32ModalConfirmTimer) {
+      clearTimeout(this.win32ModalConfirmTimer);
+      this.win32ModalConfirmTimer = null;
+    }
     this.specWatcher?.close();
     this.adapter.kill();
   }
@@ -35781,10 +35819,61 @@ var FsmDriver = class {
       const nav = step.repeat(Math.abs(delta));
       const confirm = (rule.key_for_index || "\r").replace(/\{index\}/g, "") || "\r";
       if (nav) this.adapter.send_keys(nav);
-      this.adapter.send_keys(confirm);
+      this.submitModalConfirm(confirm);
+      return;
+    }
+    this.submitModalConfirm(btn.key);
+  }
+  /**
+   * Submit a modal-confirm key sequence (the choice key + its trailing CR).
+   *
+   * On win32 the trailing CR is the SAME lone-CR-swallow case as a send_message
+   * submit: ConPTY can absorb a single CR as a literal newline instead of a
+   * confirm, so the approval/picker modal never resolves and the FSM flaps
+   * approval↔busy while auto-approve keeps firing into the void (APPROVESTUCK).
+   * So we split any non-CR prefix (e.g. the "1" of "1\r") off, write it once, and
+   * resend the CR on a fixed cadence until the modal actually resolves (status
+   * leaves 'approval'). Non-win32 keeps the single direct write — its CR submits
+   * on the first try.
+   */
+  submitModalConfirm(keys) {
+    if (process.platform !== "win32") {
+      this.adapter.send_keys(keys);
       return;
     }
-    this.adapter.send_keys(btn.key);
+    const m = /^([\s\S]*?)([\r\n]+)$/.exec(keys);
+    const prefix = m ? m[1] : keys;
+    const cr = m ? m[2] : "";
+    if (prefix) this.adapter.send_keys(prefix);
+    if (!cr) return;
+    this.scheduleWin32ModalConfirm(cr);
+  }
+  /**
+   * win32 modal-confirm CR resend loop. Mirrors scheduleWin32Submit's phase-2
+   * verified resend, but gated on still being IN a modal (status 'approval')
+   * rather than still idle: the first CR fires immediately, then resends every
+   * WIN32_SUBMIT_RESEND_GAP_MS while the FSM is still showing the modal, up to
+   * WIN32_SUBMIT_MAX_RESENDS. The instant the modal resolves (status flips to
+   * generating/idle) we stop, so no stray CR leaks into the next turn's composer.
+   */
+  scheduleWin32ModalConfirm(submitKey) {
+    if (this.win32ModalConfirmTimer) {
+      clearTimeout(this.win32ModalConfirmTimer);
+      this.win32ModalConfirmTimer = null;
+    }
+    const fire = (attempt) => {
+      this.win32ModalConfirmTimer = null;
+      this.adapter.send_keys(submitKey);
+      if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+      this.win32ModalConfirmTimer = setTimeout(() => {
+        if (this.currentStatus() !== "approval") {
+          this.win32ModalConfirmTimer = null;
+          return;
+        }
+        fire(attempt + 1);
+      }, WIN32_SUBMIT_RESEND_GAP_MS);
+    };
+    fire(0);
   }
   handleAttachImage(blob, mime) {
     const ctl = (this.spec.control_bar ?? []).find((c) => c.action.type === "attach_image");
@@ -38652,6 +38741,8 @@ var CliProviderInstance = class _CliProviderInstance {
         };
       }
     }
+    const approvalResolutionBlock = this.approvalResolutionFinalizationBlock(pending);
+    if (approvalResolutionBlock) return approvalResolutionBlock;
     try {
       const screenText = typeof this.adapter.getScreenText === "function" ? String(this.adapter.getScreenText() || "") : "";
       if (screenText) {
@@ -38664,6 +38755,44 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     return null;
   }
+  // (FALSEIDLE-a) Positive, structural proof that the latest approval entry was resolved
+  // through ADHDev. resolveModal() — driven by auto-approve, dashboard/mesh_approve, and
+  // dev-cli-debug alike — advances the engine's lastResolvedEntrySeq to the current
+  // approvalEntrySeq. So `lastResolvedEntrySeq >= approvalEntrySeq` (with a real entry,
+  // approvalEntrySeq > 0) means the modal we last saw was actually answered. Absence of this
+  // evidence after a waiting_approval→idle transition means the idle is suspect: the spec's
+  // text-based approval→idle rule false-tripped while the modal is still unresolved.
+  // Fails OPEN (returns true) when the seq fields are unavailable, so the gate can never wedge
+  // a session on a provider/adapter that does not surface the counters.
+  hasApprovalResolutionEvidence() {
+    try {
+      const status = this.adapter.getStatus({ allowParse: false });
+      const entrySeq = typeof status?.approvalEntrySeq === "number" ? status.approvalEntrySeq : 0;
+      if (entrySeq <= 0) return true;
+      const resolvedSeq = typeof status?.lastResolvedEntrySeq === "number" ? status.lastResolvedEntrySeq : void 0;
+      if (resolvedSeq === void 0) return true;
+      return resolvedSeq >= entrySeq;
+    } catch {
+      return true;
+    }
+  }
+  // (FALSEIDLE-a) Hold a completion that is the anomalous DIRECT waiting_approval→idle
+  // transition with no positive resolution evidence. A genuinely resolved approval routes
+  // through resolveModal → setStatus('generating'), so its completion's previousStatus is
+  // 'generating' (not 'waiting_approval') and this gate never fires for it. Scoped to
+  // delegated mesh/coordinator sessions — whose only modal-resolution path is auto-approve /
+  // mesh_approve (both advance lastResolvedEntrySeq) — so an interactive local session, where
+  // a human may answer the PTY prompt directly and leave no resolveModal record, is untouched.
+  // Non-terminal: the hold is bounded by COMPLETED_FINALIZATION_MAX_WAIT_MS (30s), giving a
+  // settling auto-approve time to fire and advance the seq, and guaranteeing no permanent wedge
+  // if resolution ever happens via a path that does not record evidence.
+  approvalResolutionFinalizationBlock(pending) {
+    if (pending.previousStatus !== "waiting_approval") return null;
+    const meshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+    if (!meshContext) return null;
+    if (this.hasApprovalResolutionEvidence()) return null;
+    return { reason: "approval_resolution_unconfirmed", terminal: false };
+  }
   scheduleCompletedDebounceFlush(delayMs) {
     if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
     this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);