@adhdev/daemon-core 0.9.82-rc.352 → 0.9.82-rc.354

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

@@ -51,6 +51,7 @@ import { normalizeContent, flattenContent, normalizeInputEnvelope } from './cont
 import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport } from './provider-input-support.js';
 import type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorReason, ProviderEvent, InstanceContext, SessionModalState } from './provider-instance.js';
 import { StatusMonitor } from './status-monitor.js';
+import { ManualAttendanceTracker } from './manual-attendance.js';
 import { buildLegacyModelModeSummaryMetadata } from './summary-metadata.js';
 import { workingDirBasename } from './working-dir.js';
 import {
@@ -845,7 +846,12 @@ export class AcpProviderInstance implements ProviderInstance {
                 }
 
                 // ─── Auto-approve: skip user confirmation ───
-                if (this.settings.autoApprove !== false) {
+                // Held while a human is actively attending this session (manual
+                // attendance) so they can decide the permission themselves; falls
+                // through to the waiting_approval manual path below. A background
+                // worker is never attended, so its delegated auto-approve fires
+                // as before.
+                if (this.settings.autoApprove !== false && !this.manualAttendance.isAttended()) {
                     const toolTitle = tc.title || tc.toolCallId || 'tool call';
                     this.log.info(`[${this.type}] Auto-approving: ${toolTitle}`);
                     this.appendSystemMessage(`Auto-approved: ${toolTitle}`);
@@ -1128,6 +1134,17 @@ export class AcpProviderInstance implements ProviderInstance {
 
     private permissionResolvers: ((approved: boolean) => void)[] = [];
 
+    // Provider-common manual-attendance signal: while a human is actively driving
+    // this session from the dashboard, auto-approve holds so they can decide on
+    // the permission request themselves. Background workers are never attended →
+    // delegated auto-approve is unaffected.
+    private readonly manualAttendance = new ManualAttendanceTracker();
+
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now = Date.now()): void {
+        this.manualAttendance.note(now);
+    }
+
     async resolvePermission(approved: boolean): Promise<void> {
         const resolver = this.permissionResolvers.shift();
         if (resolver) {

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

@@ -29,6 +29,7 @@ import { mergeProviderPatchState, resolveProviderStateSurface } from './provider
 import { normalizeProviderSessionId } from './provider-session-id.js';
 import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
 import { workingDirBasename } from './working-dir.js';
+import { ManualAttendanceTracker } from './manual-attendance.js';
 
 type PersistableCliHistoryMessage = {
     role: string;
@@ -416,6 +417,11 @@ export class CliProviderInstance implements ProviderInstance {
     // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
     // brief generating flip does not immediately wipe the settle clock.
     private autoApproveInactiveSince = 0;
+    // Provider-common manual-attendance signal: while a human is actively driving
+    // this session from the dashboard, auto-approve holds so they can take manual
+    // control. Background mesh workers are never attended → delegated auto-approve
+    // is unaffected.
+    private readonly manualAttendance = new ManualAttendanceTracker();
     private controlValues: Record<string, string | number | boolean> = {};
     private summaryMetadata: unknown = undefined;
     private appliedEffectKeys = new Set<string>();
@@ -828,7 +834,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getHotChatSessionState(): HotChatSessionState {
         const adapterStatus = this.adapter.getStatus({ allowParse: false });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
         const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
         const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const runtime = this.adapter.getRuntimeMetadata();
@@ -844,7 +850,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getSessionModalState(sessionId?: string): SessionModalState {
         const adapterStatus = this.adapter.getStatus({ allowParse: true });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status);
         const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
         const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const dirName = workingDirBasename(this.workingDir);
@@ -947,7 +953,10 @@ export class CliProviderInstance implements ProviderInstance {
         } catch {
             return null;
         }
-        if (adapterStatus.status === 'waiting_approval' && !this.shouldAutoApprove()) {
+        // A session whose auto-approve is held by manual attendance IS parked on a
+        // modal awaiting the human — autoApproveEffectivelyActive folds that in, so
+        // the mesh force-inject guard correctly treats it as modal-parked.
+        if (adapterStatus.status === 'waiting_approval' && !this.autoApproveEffectivelyActive(adapterStatus.status)) {
             return 'waiting_approval';
         }
         return null;
@@ -1481,6 +1490,29 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        // Manual-attendance suppression (provider-common): when a human is
+        // actively driving this session from the dashboard, hold auto-approve so
+        // the modal stays visible and they can pick a button / use the controlbar
+        // themselves. Return false (NOT auto-approving) so getState keeps the
+        // modal surfaced. Clear any in-progress settle gate — a genuine fire
+        // after the window lapses must re-settle from scratch — and arm a
+        // re-check for the lapse moment, because the PTY may have gone silent and
+        // would otherwise never re-drive this decision. Background mesh workers
+        // are never attended, so their delegated auto-approve is untouched.
+        if (adapterStatus?.status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && this.manualAttendance.isAttended(now)) {
+            this.lastAutoApprovalSignature = '';
+            this.pendingAutoApprovalSignature = '';
+            this.pendingAutoApprovalSince = 0;
+            this.autoApproveInactiveSince = 0;
+            if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = setTimeout(() => {
+                this.autoApproveSettleTimer = null;
+                this.recheckAutoApproveSettled();
+            }, this.manualAttendance.remainingMs(now) + 20);
+            return false;
+        }
         const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
         // times while the PTY absorbs the approval key. Without this flag, repeated
@@ -2096,6 +2128,25 @@ export class CliProviderInstance implements ProviderInstance {
         return false;
     }
 
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now = Date.now()): void {
+        this.manualAttendance.note(now);
+    }
+
+    /**
+     * Whether auto-approve should be treated as active *right now* for display
+     * and firing decisions: the configured intent AND the user is not currently
+     * attending this session by hand. When a human is attending, auto-approve is
+     * held so the modal stays visible and they can drive it via the controlbar.
+     * Provider-agnostic — the attendance signal is the command set, never any
+     * CLI-specific modal text.
+     */
+    private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
+        return status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && !this.manualAttendance.isAttended(now);
+    }
+
     private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
         this.appendRuntimeSystemMessage(
             formatAutoApprovalMessage(modalMessage, buttonLabel),

package/src/providers/manual-attendance.ts

@@ -0,0 +1,85 @@
+/**
+ * ManualAttendanceTracker — provider-agnostic "is a human driving this session
+ * right now" signal, used to suppress auto-approve while the user is taking
+ * manual control of a session from the dashboard.
+ *
+ * Why this exists
+ * ---------------
+ * When `autoApprove` is on, an approval modal is auto-dismissed within a few
+ * hundred ms of appearing. For a background mesh worker that is exactly the
+ * desired delegated behavior. But for a session the user is actively watching
+ * and operating (a base-node / foreground session), the auto-fire closes the
+ * modal before the human can pick a button — and likewise fights their use of
+ * the controlbar. The fix is to give the human a short quiet window: while they
+ * are attending the session by hand, auto-approve holds; once they go idle it
+ * resumes.
+ *
+ * The tracker holds only a timestamp. The *signal* — which commands count as
+ * "a human attending" — is decided by the caller (the command handler), and is
+ * the same set for every provider: foreground tab selection (select_session /
+ * open_panel), controlbar use (invoke_provider_script / set_mode / change_model
+ * / set_thought_level), manual approval (resolve_action) and manual terminal
+ * input (pty_input). Notably NOT send_chat, which is also how a coordinator
+ * delegates a task to a worker — counting it would wrongly suppress the
+ * worker's delegated auto-approve.
+ *
+ * Because a background worker never receives any of those attending commands,
+ * it is never "attended", so its delegated auto-approve is unaffected. The
+ * mechanism is therefore provider-common AND preserves worker auto-approve
+ * without any per-provider branching.
+ */
+
+/**
+ * How long after the last manual interaction auto-approve stays suppressed.
+ *
+ * Trade-off: long enough that after foregrounding a session's tab the user has
+ * a realistic chance to act on an incoming approval (the auto-approve settle
+ * window is only ~600ms, so a human cannot out-race it), yet short enough that
+ * a session left unattended — e.g. a worker tab the user briefly peeked at —
+ * resumes auto-approving within about a minute. Re-armed on every attending
+ * command, so a user who keeps interacting keeps the window fresh.
+ */
+export const AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 60_000;
+
+export class ManualAttendanceTracker {
+    private lastInteractionAt = 0;
+
+    constructor(private readonly suppressMs: number = AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS) {}
+
+    /** Record that a human just drove this session by hand. */
+    note(now = Date.now()): void {
+        this.lastInteractionAt = now;
+    }
+
+    /** True while a manual interaction is recent enough to suppress auto-approve. */
+    isAttended(now = Date.now()): boolean {
+        return this.lastInteractionAt > 0 && (now - this.lastInteractionAt) < this.suppressMs;
+    }
+
+    /**
+     * Milliseconds remaining in the current suppression window, or 0 when not
+     * attended. Used to re-arm a re-check timer so auto-approve fires the moment
+     * the window lapses even if the PTY/agent has since gone silent.
+     */
+    remainingMs(now = Date.now()): number {
+        if (this.lastInteractionAt <= 0) return 0;
+        return Math.max(0, this.suppressMs - (now - this.lastInteractionAt));
+    }
+}
+
+/**
+ * The session-scoped commands that count as "a human is attending this session
+ * by hand". Shared so the command handler and any forward path agree on one
+ * definition. Deliberately excludes send_chat (coordinator task delegation) and
+ * pure read commands (read_chat / list_chats — passive polling, not driving).
+ */
+export const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string> = new Set([
+    'select_session',
+    'open_panel',
+    'invoke_provider_script',
+    'set_mode',
+    'change_model',
+    'set_thought_level',
+    'resolve_action',
+    'pty_input',
+]);

package/src/providers/provider-instance.ts

@@ -226,6 +226,15 @@ export interface ProviderInstance {
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
 
+    /**
+     * Record that a human is actively attending this session by hand right now
+     * (foreground tab selection, controlbar use, manual approval, terminal
+     * 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.
+     */
+    noteManualInteraction?(now?: number): void;
+
  /** cleanup */
     dispose(): void;
 }