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

package/dist/commands/handler.d.ts

@@ -102,6 +102,21 @@ export declare class DaemonCommandHandler implements CommandHelpers {
     private logCommandStart;
     private logCommandEnd;
     setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    /**
+     * When a command in the manual-attendance set arrives for a session this
+     * daemon hosts, stamp the live instance so auto-approve holds while the user
+     * drives the session by hand. Provider-common: the signal is the command
+     * (foreground select_session / open_panel, controlbar invoke_provider_script
+     * / set_mode / change_model / set_thought_level, manual resolve_action,
+     * pty_input), never any CLI-specific modal text — so it works identically for
+     * every CLI/ACP provider. send_chat is deliberately excluded because a
+     * coordinator delegating a task to a worker also uses send_chat; counting it
+     * would wrongly suppress the worker's delegated auto-approve. For a remote
+     * mesh worker session the controlbar commands are forwarded to the owning
+     * worker daemon, which runs this same hook there, so attendance is recorded
+     * on the daemon that actually hosts the instance.
+     */
+    private noteManualAttendanceIfApplicable;
     handle(cmd: string, args: any): Promise<CommandResult>;
     private dispatch;
     /**

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "a680b74d9b940b82f691ebb85a725a1a72445bfc" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "a680b74d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.353" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-22T09:11:13.499Z" : void 0);
+  const commit = readInjected(true ? "5d100a177f412ae29a58048f0a211c3928b06910" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "5d100a17" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.354" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-22T11:32:05.389Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -1070,6 +1070,9 @@ __export(git_diff_exports, {
   getGitDiffSummary: () => getGitDiffSummary,
   getGitFileDiff: () => getGitFileDiff
 });
+function withCollectionTimeout(options) {
+  return options.timeoutMs === void 0 ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
+}
 function validateBaseRef(ref) {
   const trimmed = ref.trim();
   if (!trimmed || trimmed.startsWith("-") || trimmed.includes("..") || !/^[A-Za-z0-9][A-Za-z0-9._/@-]*$/.test(trimmed)) {
@@ -1079,14 +1082,15 @@ function validateBaseRef(ref) {
 }
 async function getGitDiffSummary(workspace, options = {}) {
   const lastCheckedAt = Date.now();
+  const effectiveOptions = withCollectionTimeout(options);
   try {
-    const repo = await resolveGitRepository(workspace, options);
+    const repo = await resolveGitRepository(workspace, effectiveOptions);
     const repoRoot = repo.repoRoot;
     if (options.baseRef) {
       const range = `${validateBaseRef(options.baseRef)}...HEAD`;
       const [nameStatus, numstat] = await Promise.all([
-        runGit(repo, ["diff", "--no-ext-diff", "--name-status", range, "--"], { ...options, cwd: repoRoot }),
-        runGit(repo, ["diff", "--no-ext-diff", "--numstat", range, "--"], { ...options, cwd: repoRoot })
+        runGit(repo, ["diff", "--no-ext-diff", "--name-status", range, "--"], { ...effectiveOptions, cwd: repoRoot }),
+        runGit(repo, ["diff", "--no-ext-diff", "--numstat", range, "--"], { ...effectiveOptions, cwd: repoRoot })
       ]);
       const outputBytes2 = byteLength(nameStatus.stdout + numstat.stdout);
       const changes2 = combineDiffEntries(nameStatus.stdout, numstat.stdout, false);
@@ -1105,11 +1109,11 @@ async function getGitDiffSummary(workspace, options = {}) {
       };
     }
     const [unstagedNameStatus, unstagedNumstat, stagedNameStatus, stagedNumstat, untracked] = await Promise.all([
-      runGit(repo, ["diff", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
-      runGit(repo, ["ls-files", "--others", "--exclude-standard"], { ...options, cwd: repoRoot })
+      runGit(repo, ["diff", "--no-ext-diff", "--name-status"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--no-ext-diff", "--numstat"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--name-status"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["diff", "--cached", "--no-ext-diff", "--numstat"], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ["ls-files", "--others", "--exclude-standard"], { ...effectiveOptions, cwd: repoRoot })
     ]);
     const outputBytes = byteLength(
       unstagedNameStatus.stdout + unstagedNumstat.stdout + stagedNameStatus.stdout + stagedNumstat.stdout + untracked.stdout
@@ -1151,13 +1155,14 @@ async function getGitDiffSummary(workspace, options = {}) {
 }
 async function getGitFileDiff(workspace, filePath, options = {}) {
   const lastCheckedAt = Date.now();
-  const repo = await resolveGitRepository(workspace, options);
+  const effectiveOptions = withCollectionTimeout(options);
+  const repo = await resolveGitRepository(workspace, effectiveOptions);
   const repoRoot = repo.repoRoot;
   const selected = await resolveRepoFilePath(repoRoot, filePath);
   const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
   if (options.baseRef) {
     const range = `${validateBaseRef(options.baseRef)}...HEAD`;
-    const result = await runGit(repo, ["diff", "--no-ext-diff", range, "--", selected.relativePath], { ...options, cwd: repoRoot });
+    const result = await runGit(repo, ["diff", "--no-ext-diff", range, "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot });
     const bounded2 = truncateText(result.stdout, maxBytes);
     return {
       workspace: repo.workspace,
@@ -1170,13 +1175,13 @@ async function getGitFileDiff(workspace, filePath, options = {}) {
     };
   }
   const [unstaged, staged] = await Promise.all([
-    runGit(repo, ["diff", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot }),
-    runGit(repo, ["diff", "--cached", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot })
+    runGit(repo, ["diff", "--no-ext-diff", "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
+    runGit(repo, ["diff", "--cached", "--no-ext-diff", "--", selected.relativePath], { ...effectiveOptions, cwd: repoRoot })
   ]);
   let diff = [unstaged.stdout, staged.stdout].filter((part) => part.length > 0).join("\n");
   if (!diff) {
     const untracked = await runGit(repo, ["ls-files", "--others", "--exclude-standard", "--", selected.relativePath], {
-      ...options,
+      ...effectiveOptions,
       cwd: repoRoot
     });
     const untrackedFiles = untracked.stdout.split("\n").filter(Boolean);
@@ -27440,6 +27445,42 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
   return fn() || null;
 }
 
+// src/providers/manual-attendance.ts
+var AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 6e4;
+var ManualAttendanceTracker = class {
+  constructor(suppressMs = AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS) {
+    this.suppressMs = suppressMs;
+  }
+  lastInteractionAt = 0;
+  /** Record that a human just drove this session by hand. */
+  note(now = Date.now()) {
+    this.lastInteractionAt = now;
+  }
+  /** True while a manual interaction is recent enough to suppress auto-approve. */
+  isAttended(now = Date.now()) {
+    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()) {
+    if (this.lastInteractionAt <= 0) return 0;
+    return Math.max(0, this.suppressMs - (now - this.lastInteractionAt));
+  }
+};
+var MANUAL_ATTENDANCE_COMMANDS = /* @__PURE__ */ new Set([
+  "select_session",
+  "open_panel",
+  "invoke_provider_script",
+  "set_mode",
+  "change_model",
+  "set_thought_level",
+  "resolve_action",
+  "pty_input"
+]);
+
 // src/commands/chat-commands.ts
 var fs7 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
@@ -31779,11 +31820,38 @@ var DaemonCommandHandler = class {
   setAgentStreamManager(manager) {
     this._agentStream = manager;
   }
+  /**
+   * When a command in the manual-attendance set arrives for a session this
+   * daemon hosts, stamp the live instance so auto-approve holds while the user
+   * drives the session by hand. Provider-common: the signal is the command
+   * (foreground select_session / open_panel, controlbar invoke_provider_script
+   * / set_mode / change_model / set_thought_level, manual resolve_action,
+   * pty_input), never any CLI-specific modal text — so it works identically for
+   * every CLI/ACP provider. send_chat is deliberately excluded because a
+   * coordinator delegating a task to a worker also uses send_chat; counting it
+   * would wrongly suppress the worker's delegated auto-approve. For a remote
+   * mesh worker session the controlbar commands are forwarded to the owning
+   * worker daemon, which runs this same hook there, so attendance is recorded
+   * on the daemon that actually hosts the instance.
+   */
+  noteManualAttendanceIfApplicable(cmd, args) {
+    if (!MANUAL_ATTENDANCE_COMMANDS.has(cmd)) return;
+    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);
+    try {
+      instance?.noteManualInteraction?.();
+    } catch {
+    }
+  }
   // ─── Command Dispatcher ──────────────────────────
   async handle(cmd, args) {
     this._currentRoute = this.resolveRoute(args);
     const startedAt = Date.now();
     this.logCommandStart(cmd, args);
+    this.noteManualAttendanceIfApplicable(cmd, args);
     let result;
     if (isGitCommandName(cmd)) {
       result = await handleGitCommand(cmd, args, this._ctx.gitCommandServices);
@@ -35737,6 +35805,11 @@ var CliProviderInstance = class _CliProviderInstance {
   // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
   // brief generating flip does not immediately wipe the settle clock.
   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.
+  manualAttendance = new ManualAttendanceTracker();
   controlValues = {};
   summaryMetadata = void 0;
   appliedEffectKeys = /* @__PURE__ */ new Set();
@@ -36012,7 +36085,7 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   getHotChatSessionState() {
     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();
@@ -36027,7 +36100,7 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   getSessionModalState(sessionId) {
     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);
@@ -36108,7 +36181,7 @@ var CliProviderInstance = class _CliProviderInstance {
     } catch {
       return null;
     }
-    if (adapterStatus.status === "waiting_approval" && !this.shouldAutoApprove()) {
+    if (adapterStatus.status === "waiting_approval" && !this.autoApproveEffectivelyActive(adapterStatus.status)) {
       return "waiting_approval";
     }
     return null;
@@ -36554,6 +36627,18 @@ var CliProviderInstance = class _CliProviderInstance {
     this.lastApprovalEventFingerprint = "";
   }
   maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
+    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();
     if (!autoApproveActive) {
       this.lastAutoApprovalSignature = "";
@@ -37019,6 +37104,21 @@ ${effect.notification.body || ""}`.trim();
     }
     return false;
   }
+  /** @see ProviderInstance.noteManualInteraction */
+  noteManualInteraction(now = Date.now()) {
+    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.
+   */
+  autoApproveEffectivelyActive(status, now = Date.now()) {
+    return status === "waiting_approval" && this.shouldAutoApprove() && !this.manualAttendance.isAttended(now);
+  }
   recordAutoApproval(modalMessage, buttonLabel, now = Date.now()) {
     this.appendRuntimeSystemMessage(
       formatAutoApprovalMessage(modalMessage, buttonLabel),
@@ -37964,7 +38064,7 @@ var AcpProviderInstance = class {
             input: tc.rawInput ? typeof tc.rawInput === "string" ? tc.rawInput : JSON.stringify(tc.rawInput) : void 0
           });
         }
-        if (this.settings.autoApprove !== false) {
+        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}`);
@@ -38195,6 +38295,15 @@ var AcpProviderInstance = class {
     this.detectStatusTransition();
   }
   permissionResolvers = [];
+  // 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.
+  manualAttendance = new ManualAttendanceTracker();
+  /** @see ProviderInstance.noteManualInteraction */
+  noteManualInteraction(now = Date.now()) {
+    this.manualAttendance.note(now);
+  }
   async resolvePermission(approved) {
     const resolver = this.permissionResolvers.shift();
     if (resolver) {
@@ -39352,6 +39461,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         );
         continue;
       }
+      const restoredSettings = { ...this.providerLoader.getSettings(normalizedType) };
+      const coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+      if (coordinatorEntry?.meshId) {
+        restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
+      }
       try {
         await this.registerCliInstance(
           record.runtimeId,
@@ -39360,7 +39474,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           record.workspace,
           record.cliArgs,
           resolvedProvider,
-          {},
+          restoredSettings,
           true,
           {
             providerSessionId: sessionBinding.providerSessionId,