@adhdev/daemon-core 0.9.82-rc.454 → 0.9.82-rc.456

package/dist/mesh/mesh-event-classify.d.ts

@@ -3,3 +3,5 @@ export declare const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind>;
 export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
 export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
 export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
+export declare const MESH_APPROVAL_EVENTS: ReadonlySet<string>;
+export declare function isMeshApprovalEvent(eventName: unknown): boolean;

package/dist/mesh/worktree-bootstrap-config.d.ts

@@ -38,6 +38,26 @@ export declare function isWorktreeBootstrapStaleRunning(node: {
     };
     workspace?: string;
 } | undefined, nowMs?: number): boolean;
+/**
+ * COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready / bootstrap-pending defer
+ * predicate. A task must NOT be injected into a worktree node whose bootstrap is still 'running'
+ * — the provider is not yet ready to consume input, so the inject lands in the input buffer and
+ * is silently swallowed (empty session). Both the remote dispatch guard (the router agent_command
+ * handler) and the local queue-claim gate (tryAssignQueueTask) route through THIS predicate so
+ * they agree on exactly when to defer. Returns true = defer. The stale-'running' backstop
+ * (isWorktreeBootstrapStaleRunning) is honored here too: a 'running' state far older than any real
+ * bootstrap whose worktree is git-clean is treated as silently complete (do NOT defer), so a node
+ * whose terminal stamp never reached this daemon is not stranded forever.
+ */
+export declare function shouldDeferDispatchForBootstrap(node: {
+    worktreeBootstrap?: {
+        status?: string;
+        startedAt?: string;
+        updatedAt?: string;
+        completedAt?: string;
+    };
+    workspace?: string;
+} | undefined, nowMs?: number): boolean;
 export interface WorktreeBootstrapConfigLoadResult {
     config?: RepoMeshWorktreeBootstrapConfig;
     source: string;

package/dist/providers/approval-utils.d.ts

@@ -6,6 +6,31 @@ import type { ProviderModule } from './contracts.js';
  * decline, which distinguishes it from a generic numbered menu or prose list.
  */
 export declare function hasNegativeApprovalOption(buttons: string[] | null | undefined): boolean;
+/**
+ * True when a button reliably identifies a tool-CONSENT modal on its own — a
+ * scoped permission-grant affirmative such as:
+ *   - "Yes, allow all edits in tmp/ during this session"
+ *   - "Yes, and don't ask again for example.com"
+ *   - "Yes, allow reading from etc/ from this project"
+ *   - "Always allow"
+ *
+ * These options only ever appear in a genuine approval/permission prompt; a
+ * /model or /mode picker ("1. Default  2. Opus  3. Sonnet") never offers a
+ * "grant this scope" choice. They therefore serve as a SECOND reliable
+ * structural anchor alongside {@link hasNegativeApprovalOption}.
+ *
+ * Why this exists (tall-diff fallback, #137): when a Write/Edit diff is tall,
+ * the trailing decline option ("3. No") can scroll off the bottom of the
+ * captured PTY frame, leaving only "1. Yes" + "2. Yes, allow … this session".
+ * hasNegativeApprovalOption then reads false and the auto-approve gate bails —
+ * a delegated worker sits forever on a modal it could safely have approved. The
+ * grant-scope affirmative lets the gate recognize the consent modal WITHOUT
+ * seeing the off-frame decline. The gate still selects the plain "Yes"
+ * (allow-once) via pickApprovalButton, never the broader grant, and the settle
+ * gate still requires a stable modal — so a half-rendered frame never fires.
+ * Kept deliberately narrow so no picker/confirm modal can trip it.
+ */
+export declare function hasReliableApprovalAffirmative(buttons: string[] | null | undefined): boolean;
 export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
 export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
     index: number;

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

@@ -115,6 +115,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private autoApproveSettleTimer;
     private autoApproveInactiveSince;
     private autoApproveMaskSince;
+    private stalledApprovalNudgeEpisode;
     private readonly manualAttendance;
     private controlValues;
     private summaryMetadata;
@@ -355,7 +356,9 @@ export declare class CliProviderInstance implements ProviderInstance {
     get cliName(): string;
     private shouldAutoApprove;
     /** @see ProviderInstance.noteManualInteraction */
-    noteManualInteraction(now?: number): void;
+    noteManualInteraction(now?: number, opts?: {
+        passive?: boolean;
+    }): void;
     /**
      * Whether auto-approve should be treated as active *right now* for display
      * and firing decisions: the configured intent AND the user is not currently
@@ -366,6 +369,28 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     private autoApproveEffectivelyActive;
     private autoApproveMaskStalled;
+    /**
+     * NOTIF-APPROVAL-MASKED (Q1b): surface a delegated worker's STALLED auto-approve modal
+     * to the mesh COORDINATOR, decoupled from the dashboard visible-status mask.
+     *
+     * When auto-approve is configured but the episode never settles (modal parse miss / the
+     * settle gate never satisfied), getState()/detectStatusTransition() fold the raw
+     * `waiting_approval` into `generating` to suppress dashboard flicker — so
+     * detectStatusTransition()'s `waiting_approval` arm never runs and NO agent:waiting_approval
+     * event is emitted. The coordinator's real-time approval-nudge delivery then has no input and
+     * the worker's stuck modal is never surfaced (the live ~25s stall). The dashboard mask is
+     * intentional and stays; this emits the coordinator nudge exactly ONCE, gated on the SAME
+     * raw-waiting_approval + mask-stalled signal resolveModalParkStatus() distinguishes, the
+     * instant the mask-stall threshold trips (the same moment getState un-folds the mask).
+     *
+     * Only delegated worker sessions qualify: a foreground session has no coordinator to notify,
+     * and its own dashboard mask already reveals the modal on stall. A normally-resolving
+     * auto-approve never reaches AUTO_APPROVE_MASK_STALL_MS, so it emits nothing here; and if a
+     * masked approval clears just as this fires, rc.455's isApprovalNudgeResolved stale-drop
+     * discards the nudge coordinator-side without noise. Dedup is per-episode (keyed on the
+     * mask-clock value) so a modal that flaps between parsed/unparsed states is announced once.
+     */
+    private maybeEmitStalledApprovalNudge;
     private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
     private formatMarkerTimestamp;

package/dist/providers/manual-attendance.d.ts

@@ -61,3 +61,19 @@ export declare class ManualAttendanceTracker {
  * pure read commands (read_chat / list_chats — passive polling, not driving).
  */
 export declare const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string>;
+/**
+ * The subset of {@link MANUAL_ATTENDANCE_COMMANDS} that are PASSIVE view-only
+ * actions — foregrounding a session's tab / opening its panel. They convey "I am
+ * looking at this session", not "I am driving it", and carry no user input.
+ *
+ * For a foreground (base-node) session these still attend: a user who
+ * foregrounds their own session should get the quiet window so an incoming
+ * approval stays visible for them to act on. But for a DELEGATED worker session
+ * a passive peek must NOT attend — a coordinator merely opening a worker's panel
+ * to watch progress would otherwise suppress that worker's delegated
+ * auto-approve for the whole window (secondary cause, #137). The per-instance
+ * hook decides: it drops a passive stamp only when the session is a delegated
+ * worker, so explicit input (controlbar / resolve_action / pty_input) still
+ * attends a worker and a foreground session is unaffected.
+ */
+export declare const MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS: ReadonlySet<string>;

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

@@ -200,8 +200,15 @@ export interface ProviderInstance {
      * input). Provider-common signal that suppresses auto-approve for a short
      * window so the user can drive the session manually; background mesh worker
      * sessions never receive it, so their delegated auto-approve is unaffected.
+     *
+     * `opts.passive` marks a view-only action (select_session / open_panel). A
+     * delegated worker session ignores passive stamps so a coordinator merely
+     * watching its panel does not suppress its delegated auto-approve; explicit
+     * input still attends. Foreground sessions attend on passive views too.
      */
-    noteManualInteraction?(now?: number): void;
+    noteManualInteraction?(now?: number, opts?: {
+        passive?: boolean;
+    }): void;
     /** cleanup */
     dispose(): void;
 }

package/package.json

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

package/src/commands/handler.ts

@@ -26,7 +26,7 @@ import { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 import { resolveLegacyProviderScript, type LegacyStringScript } from './provider-script-resolver.js';
 import { sha256Hex } from '../system/hash.js';
-import { MANUAL_ATTENDANCE_COMMANDS } from '../providers/manual-attendance.js';
+import { MANUAL_ATTENDANCE_COMMANDS, MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS } from '../providers/manual-attendance.js';
 
 // Sub-module imports
 import * as Chat from './chat-commands.js';
@@ -393,15 +393,18 @@ export class DaemonCommandHandler implements CommandHelpers {
      */
     private noteManualAttendanceIfApplicable(cmd: string, args: any): void {
         if (!MANUAL_ATTENDANCE_COMMANDS.has(cmd)) return;
+        // Passive view-only actions (select_session / open_panel) attend a
+        // foreground session but NOT a delegated worker — the instance decides.
+        const passive = MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS.has(cmd);
         const sessionId = this._currentRoute.session?.sessionId
             || (typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '');
         if (!sessionId) return;
         const session = this._ctx.sessionRegistry?.get(sessionId);
         const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
         const instance = this._ctx.instanceManager?.getInstance(instanceKey) as
-            { noteManualInteraction?: (now?: number) => void } | undefined;
+            { noteManualInteraction?: (now?: number, opts?: { passive?: boolean }) => void } | undefined;
         try {
-            instance?.noteManualInteraction?.();
+            instance?.noteManualInteraction?.(undefined, { passive });
         } catch {
             // attendance is best-effort — never block command dispatch
         }

package/src/commands/med-family/cli-agent.ts

@@ -114,32 +114,35 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
         if (isSendChat && dispatchNodeId && dispatchMeshId) {
             try {
                 const { getMesh } = await import('../../config/mesh-config.js');
-                const meshObj = getMesh(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
+                // COMPLETION-PROPAGATION F6 (C1 SSOT): read the router's synchronous inline mesh
+                // cache FIRST, falling back to getMesh only when the inline view has nothing. The
+                // inline cache is the authoritative bootstrap-status source — markWorktreeBootstrapTerminalState
+                // stamps 'complete'/'failed' into it SYNCHRONOUSLY, then persists to local config
+                // (what getMesh reads) via a DETACHED async import chain that lags. Reading getMesh
+                // first therefore observed a stale 'running' and deferred a dispatch whose worktree
+                // was already bootstrapped — the stale-'running' defer this eliminates. Inline-first
+                // makes the freshest single source of truth win for both the running and terminal states.
+                const meshObj = ctx.getCachedInlineMesh(dispatchMeshId) ?? getMesh(dispatchMeshId);
                 const nodeObj = Array.isArray(meshObj?.nodes)
                     ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, dispatchNodeId))
                     : undefined;
-                const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                if (bootstrapStatus === 'running') {
-                    // Fix (3) safety net: a 'running' bootstrap far older than any real bootstrap whose
-                    // worktree is git-clean is almost certainly one whose terminal-state stamp never
-                    // reached this daemon — fall through and dispatch instead of deferring forever. The
-                    // conservative threshold + git-clean co-requirement keep a genuinely in-progress
-                    // bootstrap (which must still defer) gated.
-                    const { isWorktreeBootstrapStaleRunning } = await import('../../mesh/worktree-bootstrap-config.js');
-                    if (!isWorktreeBootstrapStaleRunning(nodeObj as any)) {
-                        return {
-                            success: false,
-                            recoverable: true,
-                            dispatched: false,
-                            code: 'mesh_node_bootstrap_pending',
-                            reason: 'bootstrap_still_running',
-                            nodeId: dispatchNodeId,
-                            meshId: dispatchMeshId,
-                            ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
-                            error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
-                            nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
-                        };
-                    }
+                // COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready/bootstrap-pending
+                // defer predicate (honors the stale-'running' git-clean backstop internally), reused
+                // by the local queue-claim gate too so remote and local dispatch agree on when to defer.
+                const { shouldDeferDispatchForBootstrap } = await import('../../mesh/worktree-bootstrap-config.js');
+                if (shouldDeferDispatchForBootstrap(nodeObj as any)) {
+                    return {
+                        success: false,
+                        recoverable: true,
+                        dispatched: false,
+                        code: 'mesh_node_bootstrap_pending',
+                        reason: 'bootstrap_still_running',
+                        nodeId: dispatchNodeId,
+                        meshId: dispatchMeshId,
+                        ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
+                        error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+                        nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
+                    };
                 }
             } catch { /* best-effort — if the bootstrap probe fails, fall through and dispatch */ }
         }