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

package/dist/mesh/mesh-events-utils.d.ts

@@ -52,6 +52,7 @@ export declare function resolveMeshSurfacedSessionPreview(metadataEvent: Record<
     role: 'assistant';
     receivedAt: number;
 } | undefined;
+export declare function isWeakCompletionMetadata(metadataEvent: Record<string, unknown>): boolean;
 export declare function buildMeshSystemMessage(args: {
     event: string;
     nodeLabel: string;

package/dist/providers/cli-provider-instance.d.ts

@@ -183,6 +183,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;
     private getCompletedFinalizationBlock;
+    private hasApprovalResolutionEvidence;
+    private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private isMeshWorkerSession;
     private meshTraceCtx;

package/dist/providers/spec/fsm-driver.d.ts

@@ -198,6 +198,11 @@ export declare class FsmDriver implements ISpecDriver {
     private lastWin32WriteAt;
     /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
     private win32WriteTimer;
+    /** 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'). */
+    private win32ModalConfirmTimer;
     private currentEval;
     private stateHistory;
     private prevStateAt;
@@ -358,6 +363,28 @@ export declare class FsmDriver implements ISpecDriver {
     private scheduleWin32Submit;
     private handleClickControl;
     private handleClickModalButton;
+    /**
+     * 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.
+     */
+    private submitModalConfirm;
+    /**
+     * 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.
+     */
+    private scheduleWin32ModalConfirm;
     private handleAttachImage;
     private tryAdvancePicker;
     private handleExit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.362",
+  "version": "0.9.82-rc.364",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.362",
+    "@adhdev/mesh-shared": "0.9.82-rc.364",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/cli-state-engine.ts

@@ -126,7 +126,13 @@ export class CliStateEngine {
      * seq) is always a real, distinct approval and must be written.
      */
     approvalEntrySeq = 0;
-    private lastResolvedEntrySeq = -1;
+    // 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
      * to extract one, we record the timestamp here and only drop the modal

package/src/cli-adapters/provider-cli-adapter.ts

@@ -967,6 +967,7 @@ export class ProviderCliAdapter implements CliAdapter {
             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,

package/src/cli-adapters/provider-cli-shared.ts

@@ -38,6 +38,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/src/mesh/mesh-events-coordinator.ts

@@ -457,6 +457,17 @@ function deliverTaskToSession(dispatchThunk: () => Promise<unknown>, ctx: Delive
     });
 }
 
+// WTCLAIM: normalize a workspace path for base-vs-worktree comparison. Mirrors
+// cli-manager.ts normalizeDirForCompare (fix-B) — folds separator style, trailing
+// slashes, and case (Windows paths are case-insensitive) so a base node and a worktree
+// clone, whose only structural difference is their distinct workspace roots, are still
+// told apart. Kept local (the cli-manager copy is module-private) so the comparison rule
+// stays identical to the one fix-B already uses on the worker side.
+function normalizeMeshWorkspaceForCompare(dir?: string): string {
+    if (typeof dir !== 'string') return '';
+    return dir.trim().replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+
 export function tryAssignQueueTask(
     components: DaemonComponents,
     meshId: string,
@@ -466,6 +477,32 @@ export function tryAssignQueueTask(
 ): boolean {
     const mesh = getMeshWithCache(components, meshId);
     const node = mesh?.nodes.find((n: any) => readMeshNodeId(n) === nodeId);
+
+    // WTCLAIM (fix-B extended to the enqueue→claim path): a base-targeted task must never be
+    // claimed by — and dispatched into — a co-located worktree-clone session, nor vice versa.
+    // The drain candidate's nodeId is derived from settings.meshNodeId || settings.nodeId
+    // (triggerMeshQueue), so a worktree session whose meshNodeId is empty/stale falls back to
+    // settings.nodeId = the BASE node id and impersonates the base node here. fix-B's worker-side
+    // workspace scope only ran for sessionless dispatch (meshScopeNodeId && !targetSessionId); the
+    // claim path ALWAYS carries a targetSessionId, so it never engaged. Apply the same scope here:
+    // for a LOCAL claiming session (adapter resolvable on this daemon), require its actual
+    // workingDir to match the target node's declared workspace. On a confirmed mismatch, refuse the
+    // claim so the task returns to pending for the correctly-scoped session/node to pull. Scoped to
+    // local sessions where the workspace is verifiable — a remote session lives on another daemon
+    // whose paths we cannot compare here (and remote candidates are already nodeId-matched from
+    // getRemoteIdleSessions). Conservative by design: when either workspace is unknown we do NOT
+    // skip, so a node with no declared workspace keeps its prior behavior and no legitimate claim
+    // is starved.
+    const localClaimAdapter = components.cliManager?.adapters?.get(sessionId) as { workingDir?: string } | undefined;
+    if (localClaimAdapter) {
+        const sessionWorkspace = normalizeMeshWorkspaceForCompare(localClaimAdapter.workingDir);
+        const nodeWorkspace = normalizeMeshWorkspaceForCompare(readNonEmptyString(node?.workspace));
+        if (sessionWorkspace && nodeWorkspace && sessionWorkspace !== nodeWorkspace) {
+            LOG.info('MeshQueue', `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) — session workspace "${sessionWorkspace}" ≠ node workspace "${nodeWorkspace}" (cross-workspace dispatch blocked)`);
+            return false;
+        }
+    }
+
     const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
     // Per-(node, provider) maxParallel cap (RepoMeshNodePolicy.providerRoles) layers
     // on top of the global/taskMode caps — stricter wins. Resolved here where the

package/src/mesh/mesh-events-utils.ts

@@ -195,6 +195,23 @@ function readEventTimestampValue(value: unknown): number {
     return 0;
 }
 
+// A completion whose evidence is WEAK: the worker FSM reached idle but the turn's
+// final assistant message was never confirmed (missing_final_assistant / a
+// finalAssistantPresent=false diagnostic), or the event self-declares insufficient/weak
+// evidence. cli-provider-instance emits this on the CANON-C decoupled-immediate path and
+// on a forced finalization timeout, and the new structural approval-resolution gate
+// (FALSEIDLE-a) can also let an unconfirmed approval→idle through. Such a completion is NOT
+// trustworthy terminal evidence — surface a verify hint so the coordinator confirms via
+// mesh_read_chat / git status before declaring the task done. Mirrors
+// isWeakCompletionMetadata in mesh-events-pending.ts.
+export function isWeakCompletionMetadata(metadataEvent: Record<string, unknown>): boolean {
+    const evidenceLevel = readNonEmptyString(metadataEvent.evidenceLevel);
+    if (evidenceLevel === 'insufficient' || evidenceLevel === 'weak') return true;
+    if (metadataEvent.reviewRecommended === true) return true;
+    const diag = readRecord(metadataEvent.completionDiagnostic);
+    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
+}
+
 function formatCompletionMetadata(event: Record<string, unknown>): string {
     const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
         ? event.completionDiagnostic as Record<string, unknown>
@@ -229,6 +246,13 @@ export 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;
+        // FALSEIDLE-b: a weak completion (missing final assistant / finalAssistantPresent=false /
+        // insufficient evidence) is not trustworthy terminal evidence even when reviewRecommended
+        // is not set. Append an explicit verify hint so the coordinator does not declare the task
+        // done off a false idle. Only the weak case is affected — a genuine completion (final
+        // assistant confirmed, no weak diagnostic) carries no extra note and is unchanged.
+        const weakCompletion = isWeakCompletionMetadata(args.metadataEvent);
+        const verifyTextNote = ' Completion evidence is weak — verify via mesh_read_chat or git status before declaring the task done; the worker may still be parked on an approval/modal.';
         // Auto-surface the worker's final summary directly into the coordinator chat so it
         // does not have to call mesh_read_chat just to see the result. The summary IS the
         // worker's final assistant message; embedding it here replaces the previous
@@ -244,12 +268,14 @@ export function buildMeshSystemMessage(args: {
                 : completionSummary;
             const verifyNote = reviewRecommended
                 ? ' Completion evidence is insufficient — 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 — read it directly and only call mesh_read_chat if you need the full transcript.${verifyNote}\n\n--- ${args.nodeLabel} final summary ---\n${surfaced}`;
         }
         const reviewNote = reviewRecommended
             ? ' Completion evidence is insufficient — 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.';
+            : (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') {

package/src/providers/cli-provider-instance.ts

@@ -1401,6 +1401,12 @@ export class CliProviderInstance implements ProviderInstance {
             }
         }
 
+        // (FALSEIDLE-a) Structural approval-resolution gate. Runs BEFORE the brittle
+        // screen-text heuristic below so it also catches modals whose text does not match
+        // looksLikeActiveApprovalPromptText (e.g. claude-cli's cd / "untrusted hooks" prompt).
+        const approvalResolutionBlock = this.approvalResolutionFinalizationBlock(pending);
+        if (approvalResolutionBlock) return approvalResolutionBlock;
+
         // Guard: if the screen still shows an approval/choice prompt as the last visible text,
         // the turn is not complete even if the parsed status says idle and there is an assistant
         // message. This catches the case where waiting_approval→idle transitions occur before
@@ -1420,6 +1426,46 @@ export class CliProviderInstance implements ProviderInstance {
         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.
+    private hasApprovalResolutionEvidence(): boolean {
+        try {
+            const status = this.adapter.getStatus({ allowParse: false }) as any;
+            const entrySeq = typeof status?.approvalEntrySeq === 'number' ? status.approvalEntrySeq : 0;
+            if (entrySeq <= 0) return true;
+            const resolvedSeq = typeof status?.lastResolvedEntrySeq === 'number' ? status.lastResolvedEntrySeq : undefined;
+            if (resolvedSeq === undefined) 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.
+    private approvalResolutionFinalizationBlock(pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+        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 };
+    }
+
     private scheduleCompletedDebounceFlush(delayMs: number): void {
         if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
         this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);

package/src/providers/spec/fsm-driver.ts

@@ -294,6 +294,11 @@ export class FsmDriver implements ISpecDriver {
     private lastWin32WriteAt = 0;
     /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
     private win32WriteTimer: ReturnType<typeof setTimeout> | null = 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'). */
+    private win32ModalConfirmTimer: ReturnType<typeof setTimeout> | null = null;
 
     private currentEval: CurrentEval | null = null;
     private stateHistory: HistoryEntry[] = [];
@@ -413,6 +418,7 @@ export class FsmDriver implements ISpecDriver {
         if (this.stallTimer) { clearTimeout(this.stallTimer); this.stallTimer = null; }
         if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
         if (this.win32WriteTimer) { clearTimeout(this.win32WriteTimer); this.win32WriteTimer = null; }
+        if (this.win32ModalConfirmTimer) { clearTimeout(this.win32ModalConfirmTimer); this.win32ModalConfirmTimer = null; }
         this.specWatcher?.close();
         this.adapter.kill();
     }
@@ -1140,10 +1146,58 @@ export class FsmDriver implements ISpecDriver {
             // `{index}\r` → `\r`.
             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.
+     */
+    private submitModalConfirm(keys: string): void {
+        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.
+     */
+    private scheduleWin32ModalConfirm(submitKey: string): void {
+        if (this.win32ModalConfirmTimer) { clearTimeout(this.win32ModalConfirmTimer); this.win32ModalConfirmTimer = null; }
+        const fire = (attempt: number): void => {
+            this.win32ModalConfirmTimer = null;
+            this.adapter.send_keys(submitKey);
+            if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+            this.win32ModalConfirmTimer = setTimeout(() => {
+                // Left the modal → it resolved; stop resending.
+                if (this.currentStatus() !== 'approval') { this.win32ModalConfirmTimer = null; return; }
+                fire(attempt + 1);
+            }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        fire(0);
     }
 
     private handleAttachImage(blob: string, mime: string): void {