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

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "4b7c1b0d781f263663369085c4dde301d3b5cd2e" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "4b7c1b0d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:51.128Z" : 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 version2 = 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:06:20.085Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38374,6 +38374,13 @@ ${rendered}`, "utf-8");
       }
       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" : "";
@@ -38396,17 +38403,19 @@ ${rendered}`, "utf-8");
           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") {
@@ -38540,7 +38549,7 @@ Next step: ${nextStep}`;
         (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;
@@ -38559,7 +38568,7 @@ Next step: ${nextStep}`;
             event.meshId,
             event.event,
             terminalTaskId,
-            isWeakCompletionMetadata(metadata) ? "weak" : "genuine"
+            isWeakCompletionMetadata2(metadata) ? "weak" : "genuine"
           ].join("::");
         }
       }
@@ -42652,9 +42661,22 @@ ${cleanBody}`;
         }
       });
     }
+    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) {
+          LOG2.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, {
@@ -47174,6 +47196,12 @@ ${cont}` : cont;
            * 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
@@ -48890,6 +48918,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,
@@ -64700,6 +64729,11 @@ ${body}
       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;
@@ -64824,6 +64858,10 @@ ${body}
           clearTimeout(this.win32WriteTimer);
           this.win32WriteTimer = null;
         }
+        if (this.win32ModalConfirmTimer) {
+          clearTimeout(this.win32ModalConfirmTimer);
+          this.win32ModalConfirmTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -65419,10 +65457,61 @@ ${body}
           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.adapter.send_keys(btn.key);
+        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;
+        }
+        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");
@@ -68272,6 +68361,8 @@ ${body}
             };
           }
         }
+        const approvalResolutionBlock = this.approvalResolutionFinalizationBlock(pending);
+        if (approvalResolutionBlock) return approvalResolutionBlock;
         try {
           const screenText = typeof this.adapter.getScreenText === "function" ? String(this.adapter.getScreenText() || "") : "";
           if (screenText) {
@@ -68284,6 +68375,44 @@ ${body}
         }
         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);