@adhdev/daemon-standalone 1.0.18-rc.16 → 1.0.18-rc.17

package/dist/index.js

@@ -29838,6 +29838,60 @@ var require_dist3 = __commonJS({
       mod
     ));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    function isKnownDangerousLaunchArg(arg) {
+      const normalized = arg.trim();
+      if (KNOWN_DANGEROUS_LAUNCH_ARGS.has(normalized)) return true;
+      return normalized.startsWith("--dangerously-skip-permissions=") || normalized.startsWith("--dangerously-bypass-approvals-and-sandbox=");
+    }
+    function deriveAutoApproveModeRisk(mode) {
+      return Array.isArray(mode.launchArgs) && mode.launchArgs.some(isKnownDangerousLaunchArg) ? "dangerous" : mode.risk;
+    }
+    function inactiveMode(modeId = "") {
+      return { active: false, strategy: "pty-parse-default", modeId };
+    }
+    function resolveConfiguredMode(provider, mode, settings) {
+      if (mode.strategy === "post-boot-command") return inactiveMode(mode.id);
+      if (settings?.launchedByCoordinator === true && settings.delegatedWorkerDangerousModeAllow !== true && deriveAutoApproveModeRisk(mode) === "dangerous") {
+        const fallback = provider.autoApproveModes?.modes.find((candidate) => candidate.strategy === "pty-parse-default" && deriveAutoApproveModeRisk(candidate) !== "dangerous");
+        return fallback ? { active: true, strategy: fallback.strategy, modeId: fallback.id } : inactiveMode(mode.id);
+      }
+      return { active: true, strategy: mode.strategy, modeId: mode.id };
+    }
+    function resolveProviderAutoApproveMode(provider, settings) {
+      const config2 = provider.autoApproveModes;
+      const explicitModeId = settings?.autoApproveMode;
+      if (typeof explicitModeId === "string") {
+        const mode = config2?.modes.find((candidate) => candidate.id === explicitModeId);
+        if (!mode) return inactiveMode(explicitModeId);
+        return resolveConfiguredMode(provider, mode, settings);
+      }
+      const explicitLegacy = settings?.autoApprove;
+      const providerLegacyDefault = provider.settings?.autoApprove?.default;
+      const legacyActive = typeof explicitLegacy === "boolean" ? explicitLegacy : typeof providerLegacyDefault === "boolean" ? providerLegacyDefault : false;
+      if (!legacyActive) return inactiveMode();
+      if (!config2) {
+        return { active: true, strategy: "pty-parse-default", modeId: "legacy" };
+      }
+      const defaultMode = config2.modes.find((mode) => mode.id === config2.default);
+      if (!defaultMode) return inactiveMode(config2.default);
+      return resolveConfiguredMode(provider, defaultMode, settings);
+    }
+    function findProviderAutoApproveMode(provider, modeId) {
+      return provider?.autoApproveModes?.modes.find((mode) => mode.id === modeId);
+    }
+    var KNOWN_DANGEROUS_LAUNCH_ARGS;
+    var init_auto_approve_modes = __esm2({
+      "src/providers/auto-approve-modes.ts"() {
+        "use strict";
+        KNOWN_DANGEROUS_LAUNCH_ARGS = /* @__PURE__ */ new Set([
+          "--dangerously-skip-permissions",
+          "--dangerously-bypass-approvals-and-sandbox",
+          "bypassPermissions",
+          "sandbox_mode=danger-full-access",
+          "approval_policy=never"
+        ]);
+      }
+    });
     function normalizeMeshSchedulingStrategy(value) {
       if (typeof value !== "string") return DEFAULT_MESH_SCHEDULING_STRATEGY;
       const trimmed = value.trim();
@@ -29923,6 +29977,11 @@ var require_dist3 = __commonJS({
       } else {
         delete policy.autoConvergeCodeChange;
       }
+      if (policy.delegatedWorkerDangerousModeAllow === true) {
+        policy.delegatedWorkerDangerousModeAllow = true;
+      } else {
+        delete policy.delegatedWorkerDangerousModeAllow;
+      }
       if (policy.coordinatorIdlePushPolicy === "auto_silent_on_dispatch") {
         policy.coordinatorIdlePushPolicy = "auto_silent_on_dispatch";
       } else {
@@ -29930,14 +29989,35 @@ var require_dist3 = __commonJS({
       }
       return policy;
     }
-    function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy) {
+    function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider) {
+      let enabled = true;
       if (typeof nodePolicy?.delegatedWorkerAutoApprove === "boolean") {
-        return nodePolicy.delegatedWorkerAutoApprove;
+        enabled = nodePolicy.delegatedWorkerAutoApprove;
+      } else if (typeof meshPolicy?.delegatedWorkerAutoApprove === "boolean") {
+        enabled = meshPolicy.delegatedWorkerAutoApprove;
       }
-      if (typeof meshPolicy?.delegatedWorkerAutoApprove === "boolean") {
-        return meshPolicy.delegatedWorkerAutoApprove;
+      if (!enabled) return false;
+      const modes = provider?.autoApproveModes;
+      if (!modes) return true;
+      const defaultMode = modes.modes.find((mode) => mode.id === modes.default);
+      if (!defaultMode || defaultMode.strategy === "post-boot-command") return false;
+      const dangerousAllowed = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
+      if (deriveAutoApproveModeRisk(defaultMode) === "dangerous" && !dangerousAllowed) {
+        const ptyFallback = modes.modes.find((mode) => mode.strategy === "pty-parse-default" && deriveAutoApproveModeRisk(mode) !== "dangerous");
+        return ptyFallback?.id || false;
       }
-      return true;
+      return defaultMode.id;
+    }
+    function resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy) {
+      if (typeof nodePolicy?.delegatedWorkerDangerousModeAllow === "boolean") {
+        return nodePolicy.delegatedWorkerDangerousModeAllow;
+      }
+      return meshPolicy?.delegatedWorkerDangerousModeAllow === true;
+    }
+    function delegatedWorkerAutoApproveSettings(meshPolicy, nodePolicy, provider) {
+      const resolved = resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider);
+      const delegatedWorkerDangerousModeAllow = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
+      return typeof resolved === "string" ? { autoApprove: void 0, autoApproveMode: resolved, delegatedWorkerDangerousModeAllow } : { autoApprove: resolved, autoApproveMode: void 0, delegatedWorkerDangerousModeAllow };
     }
     function resolveAllowSendKeysDestructive(meshPolicy, nodePolicy) {
       if (typeof nodePolicy?.allowSendKeysDestructive === "boolean") {
@@ -29978,6 +30058,7 @@ var require_dist3 = __commonJS({
     var init_repo_mesh_types = __esm2({
       "src/repo-mesh-types.ts"() {
         "use strict";
+        init_auto_approve_modes();
         MESH_SCHEDULING_STRATEGIES = [
           "first_eligible",
           "least_loaded",
@@ -30005,6 +30086,7 @@ var require_dist3 = __commonJS({
           // any specific session manually; that override is preserved per-device.
           spawnedSessionVisibility: "hidden",
           delegatedWorkerAutoApprove: true,
+          delegatedWorkerDangerousModeAllow: false,
           sessionCleanupOnNodeRemove: "preserve",
           // MAGI auto-launches a worker session per pinned replica target with no idle
           // session; those stay idle-LIVE after their turn. Default ON (stop_and_delete)
@@ -30265,10 +30347,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "74f34080bcd7c145e55fd7e5fd492a40a4942bc4" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "74f34080" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.18-rc.16" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-23T02:30:18.950Z" : void 0);
+      const commit = readInjected(true ? "eeb3e1474488eb5543c443270208f3ca8958a86a" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "eeb3e147" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.18-rc.17" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-23T03:31:27.486Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -46790,7 +46872,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             meshNodeFor: meshId,
             meshNodeId: nodeId,
             launchedByCoordinator: true,
-            autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
+            ...delegatedWorkerAutoApproveSettings(
+              mesh?.policy,
+              node?.policy,
+              components.providerLoader?.getMeta(providerType)
+            ),
             ...localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {},
             // COMPLETION-PROPAGATION F5: (re)stamp the coordinator SESSION anchor from THIS
             // task's sourceCoordinatorSessionId with PRIORITY — a manually-launched (or reused)
@@ -47563,8 +47649,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
               // Coordinator-dispatched worker: auto-approve unless mesh/node policy
               // opts out (default true). Lands in settingsOverride and beats the
-              // global per-provider-type autoApprove config (see shouldAutoApprove).
-              autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
+              // global per-provider-type boolean/mode through explicit opposite-key clearing.
+              ...delegatedWorkerAutoApproveSettings(
+                mesh?.policy,
+                node?.policy,
+                components.providerLoader?.getMeta(resolved.providerType)
+              ),
               launchedByCoordinator: true,
               autoLaunchedForQueueTaskId: task.id
             };
@@ -50436,6 +50526,7 @@ ${cleanBody}`;
           ...provider.lastDetection !== void 0 ? { lastDetection: provider.lastDetection } : {},
           ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {},
           ...provider.meshCoordinator !== void 0 ? { meshCoordinator: provider.meshCoordinator } : {},
+          ...provider.autoApproveModes !== void 0 ? { autoApproveModes: provider.autoApproveModes } : {},
           ...trust ? {
             trust,
             trustDescription: describeTrust2(trust),
@@ -51615,7 +51706,11 @@ ${cleanBody}`;
                       spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
                       // Coordinator-dispatched recovery relaunch: same auto-approve
                       // policy as the primary worker launch path.
-                      autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
+                      ...delegatedWorkerAutoApproveSettings(
+                        mesh?.policy,
+                        node?.policy,
+                        components.providerLoader?.getMeta(recoveryContext.failedProviderType)
+                      ),
                       launchedByCoordinator: true
                     }
                   }).catch((e) => LOG2.error("MeshRecovery", `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));
@@ -54280,6 +54375,20 @@ ${cleanBody}`;
                 }
               }
             },
+            autoApproveModes: {
+              type: "object",
+              description: "Provider-specific auto-approve choices and their launch/runtime strategy.",
+              required: ["default", "modes"],
+              additionalProperties: false,
+              properties: {
+                default: { type: "string", minLength: 1 },
+                modes: {
+                  type: "array",
+                  minItems: 1,
+                  items: { $ref: "#/$defs/autoApproveMode" }
+                }
+              }
+            },
             sendDelayMs: {
               type: "number",
               minimum: 0,
@@ -54653,6 +54762,36 @@ ${cleanBody}`;
             }
           },
           $defs: {
+            autoApproveMode: {
+              type: "object",
+              required: ["id", "label", "strategy", "risk"],
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", minLength: 1 },
+                label: { type: "string", minLength: 1 },
+                strategy: { enum: ["pty-parse-default", "launch-args", "post-boot-command"] },
+                risk: { enum: ["safe", "caution", "dangerous"] },
+                warning: { type: "string", minLength: 1 },
+                launchArgs: {
+                  type: "array",
+                  items: { type: "string", minLength: 1 }
+                },
+                removeArgs: {
+                  type: "array",
+                  items: { type: "string", minLength: 1 }
+                }
+              },
+              allOf: [
+                {
+                  if: { properties: { strategy: { const: "launch-args" } }, required: ["strategy"] },
+                  then: { required: ["launchArgs"], properties: { launchArgs: { minItems: 1 } } }
+                },
+                {
+                  if: { properties: { risk: { const: "dangerous" } }, required: ["risk"] },
+                  then: { required: ["warning"] }
+                }
+              ]
+            },
             patternList: {
               type: "array",
               items: {
@@ -60532,6 +60671,7 @@ ${lastSnapshot}`;
       createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
       daemonIdsEquivalent: () => daemonIdsEquivalent,
+      delegatedWorkerAutoApproveSettings: () => delegatedWorkerAutoApproveSettings,
       deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
       deriveMeshNodeHealthFromGit: () => deriveMeshNodeHealthFromGit,
@@ -60731,6 +60871,7 @@ ${lastSnapshot}`;
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
       resolveDelegatedWorkerAutoApprove: () => resolveDelegatedWorkerAutoApprove,
+      resolveDelegatedWorkerDangerousModeAllow: () => resolveDelegatedWorkerDangerousModeAllow,
       resolveDeliveryDecision: () => resolveDeliveryDecision,
       resolveEffectiveMeshNodeHealth: () => resolveEffectiveMeshNodeHealth,
       resolveGitRepository: () => resolveGitRepository,
@@ -79220,6 +79361,7 @@ ${body}
       const pad = (value) => String(value).padStart(2, "0");
       return `${date5.getFullYear()}-${pad(date5.getMonth() + 1)}-${pad(date5.getDate())} ${pad(date5.getHours())}:${pad(date5.getMinutes())}:${pad(date5.getSeconds())}`;
     }
+    init_auto_approve_modes();
     function approvalModalSignature(message, affirmativeAnchor) {
       return [typeof message === "string" ? message.trim() : "", affirmativeAnchor].join("::");
     }
@@ -81200,7 +81342,7 @@ ${body}
        * resolveModal, so a plain turn that never saw an approval always returns false.
        */
       inApprovalResumeGrace(now = Date.now()) {
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return false;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return false;
         const resolvedAt = typeof this.adapter?.lastApprovalResolvedAt === "number" ? this.adapter.lastApprovalResolvedAt : 0;
         if (resolvedAt <= 0) return false;
         return now - resolvedAt < _CliProviderInstance.APPROVAL_RESUME_GRACE_MS;
@@ -81305,7 +81447,7 @@ ${body}
           return;
         }
         const latestStatus = this.adapter.getStatus({ allowParse: false });
-        const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
+        const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldUsePtyAutoApprove();
         const latestVisibleStatus = latestAutoApproveActive || this.autoApproveBusy ? "generating" : latestStatus.status;
         LOG2.debug("CLI", `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!this.adapter?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
         if (latestVisibleStatus !== "idle") {
@@ -81575,7 +81717,7 @@ ${body}
        * session, where a human answers the prompt, is returned untouched).
        */
       stabilizeFlappingApprovalStatus(adapterStatus, now = Date.now()) {
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return adapterStatus;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return adapterStatus;
         const rawStatus = adapterStatus?.status;
         const resolvedAt = typeof this.adapter?.lastApprovalResolvedAt === "number" ? this.adapter.lastApprovalResolvedAt : 0;
         if (rawStatus === "waiting_approval") {
@@ -81605,7 +81747,11 @@ ${body}
         return adapterStatus;
       }
       maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
-        if (adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove() && this.manualAttendance.isAttended(now)) {
+        if (!this.shouldUsePtyAutoApprove()) {
+          this.resetPtyAutoApproveState();
+          return false;
+        }
+        if (adapterStatus?.status === "waiting_approval" && this.shouldUsePtyAutoApprove() && this.manualAttendance.isAttended(now)) {
           this.lastAutoApprovalSignature = "";
           this.pendingAutoApprovalSignature = "";
           this.pendingAutoApprovalSince = 0;
@@ -81620,7 +81766,7 @@ ${body}
           }, this.manualAttendance.remainingMs(now) + 20);
           return false;
         }
-        const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove();
+        const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldUsePtyAutoApprove();
         if (!autoApproveActive) {
           this.lastAutoApprovalSignature = "";
           if (this.pendingAutoApprovalSince) {
@@ -82315,15 +82461,34 @@ ${buttons.join("\n")}`;
       get cliName() {
         return this.provider.name;
       }
+      resolveAutoApproveMode() {
+        return resolveProviderAutoApproveMode(this.provider, this.settings);
+      }
+      /** Legacy boolean view retained for internal/test compatibility. */
       shouldAutoApprove() {
-        if (typeof this.settings.autoApprove === "boolean") {
-          return this.settings.autoApprove;
+        return this.resolveAutoApproveMode().active;
+      }
+      shouldUsePtyAutoApprove() {
+        const resolved = this.resolveAutoApproveMode();
+        return this.shouldAutoApprove() && resolved.strategy === "pty-parse-default";
+      }
+      resetPtyAutoApproveState() {
+        this.lastAutoApprovalSignature = "";
+        this.pendingAutoApprovalSignature = "";
+        this.pendingAutoApprovalSince = 0;
+        this.autoApproveInactiveSince = 0;
+        this.autoApproveMaskSince = 0;
+        this.stalledApprovalNudgeEpisode = 0;
+        this.autoApproveLastModalSeenAt = 0;
+        this.autoApproveBusy = false;
+        if (this.autoApproveSettleTimer) {
+          clearTimeout(this.autoApproveSettleTimer);
+          this.autoApproveSettleTimer = null;
         }
-        const providerDefault = this.provider.settings?.autoApprove?.default;
-        if (typeof providerDefault === "boolean") {
-          return providerDefault;
+        if (this.autoApproveBusyTimer) {
+          clearTimeout(this.autoApproveBusyTimer);
+          this.autoApproveBusyTimer = null;
         }
-        return false;
       }
       /** @see ProviderInstance.noteManualInteraction */
       noteManualInteraction(now = Date.now(), opts) {
@@ -82339,7 +82504,7 @@ ${buttons.join("\n")}`;
        * CLI-specific modal text.
        */
       autoApproveEffectivelyActive(status, now = Date.now()) {
-        return status === "waiting_approval" && this.shouldAutoApprove() && !this.manualAttendance.isAttended(now);
+        return status === "waiting_approval" && this.shouldUsePtyAutoApprove() && !this.manualAttendance.isAttended(now);
       }
       // STATUS-MISMATCH: true once the current auto-approve episode has been masking
       // waiting_approval behind `generating` for longer than AUTO_APPROVE_MASK_STALL_MS without
@@ -82349,7 +82514,7 @@ ${buttons.join("\n")}`;
       // maybeAutoApproveStatus (driven by getState + the recheck timer during a waiting episode);
       // this read is side-effect-free so getStatusMetadata can consult it too.
       autoApproveMaskStalled(now = Date.now()) {
-        return this.autoApproveMaskSince > 0 && now - this.autoApproveMaskSince > _CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
+        return this.shouldUsePtyAutoApprove() && this.autoApproveMaskSince > 0 && now - this.autoApproveMaskSince > _CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
       }
       /**
        * NOTIF-APPROVAL-MASKED (Q1b): surface a delegated worker's STALLED auto-approve modal
@@ -82373,6 +82538,7 @@ ${buttons.join("\n")}`;
        * mask-clock value) so a modal that flaps between parsed/unparsed states is announced once.
        */
       maybeEmitStalledApprovalNudge(adapterStatus, now) {
+        if (!this.shouldUsePtyAutoApprove()) return;
         if (!this.isMeshWorkerSession()) return;
         if (adapterStatus?.status !== "waiting_approval") return;
         if (!this.autoApproveMaskStalled(now)) return;
@@ -83905,6 +84071,7 @@ ${rawInput}` : rawInput;
       if (!managedBy) return true;
       return managedBy === managerTag;
     }
+    init_auto_approve_modes();
     function isExplicitCommand(command) {
       const trimmed = command.trim();
       return path30.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
@@ -84131,6 +84298,24 @@ ${rawInput}` : rawInput;
       const mapped = levelMap && typeof levelMap[raw] === "string" && levelMap[raw].trim() ? levelMap[raw].trim() : raw;
       return template.map((part) => part.includes("{{level}}") ? part.replace("{{level}}", mapped) : part);
     }
+    function matchesRemovedLaunchArg(arg, removeArg) {
+      return arg === removeArg || removeArg.startsWith("--") && arg.startsWith(`${removeArg}=`);
+    }
+    function applyAutoApproveModeLaunchArgs(provider, cliArgs, settings) {
+      if (!provider) return { provider, cliArgs };
+      const resolved = resolveProviderAutoApproveMode(provider, settings);
+      if (!resolved.active || resolved.strategy !== "launch-args") return { provider, cliArgs };
+      const mode = findProviderAutoApproveMode(provider, resolved.modeId);
+      if (!mode || !Array.isArray(mode.launchArgs) || mode.launchArgs.length === 0) return { provider, cliArgs };
+      const removeArgs = Array.isArray(mode.removeArgs) ? mode.removeArgs : [];
+      const baseArgs = provider.spawn?.args;
+      const filteredBaseArgs = Array.isArray(baseArgs) && removeArgs.length > 0 ? baseArgs.filter((arg) => !removeArgs.some((removeArg) => matchesRemovedLaunchArg(arg, removeArg))) : baseArgs;
+      const launchProvider = filteredBaseArgs === baseArgs ? provider : { ...provider, spawn: { ...provider.spawn, args: filteredBaseArgs } };
+      return {
+        provider: launchProvider,
+        cliArgs: [...mode.launchArgs, ...cliArgs || []]
+      };
+    }
     function readSubcommandSessionId(args, subcommands) {
       const resumeIndex = args.findIndex((arg) => subcommands.includes(arg));
       if (resumeIndex < 0) return void 0;
@@ -84561,22 +84746,30 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (provider) {
           console.log(colorize("cyan", `  \u{1F4E6} Using provider: ${provider.name} (${provider.type})`));
         }
-        const modelLaunchArgs = expandModelLaunchArgs(provider?.modelLaunchArgs, initialModel);
-        const cliArgsWithModel = modelLaunchArgs ? [...modelLaunchArgs, ...cliArgs || []] : cliArgs;
+        const launchSettings = {
+          ...this.providerLoader.getSettings(normalizedType),
+          ...options?.settingsOverride || {}
+        };
+        const versionResolvedProvider = provider ? this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider : void 0;
+        const autoApproveLaunch = applyAutoApproveModeLaunchArgs(versionResolvedProvider, cliArgs, launchSettings);
+        const launchProvider = autoApproveLaunch.provider || provider;
+        const cliArgsWithAutoApprove = autoApproveLaunch.cliArgs;
+        const modelLaunchArgs = expandModelLaunchArgs(launchProvider?.modelLaunchArgs, initialModel);
+        const cliArgsWithModel = modelLaunchArgs ? [...modelLaunchArgs, ...cliArgsWithAutoApprove || []] : cliArgsWithAutoApprove;
         if (initialModel && !modelLaunchArgs) {
           LOG2.warn("CLI", `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template \u2014 launching without model selection.`);
         }
         const initialThinkingLevel = options?.initialThinkingLevel;
-        const thinkingLaunchArgs = expandThinkingLaunchArgs(provider?.thinkingLaunchArgs, initialThinkingLevel, provider?.thinkingLevelMap);
+        const thinkingLaunchArgs = expandThinkingLaunchArgs(launchProvider?.thinkingLaunchArgs, initialThinkingLevel, launchProvider?.thinkingLevelMap);
         const cliArgsWithBrain = thinkingLaunchArgs ? [...thinkingLaunchArgs, ...cliArgsWithModel || []] : cliArgsWithModel;
         if (initialThinkingLevel && !thinkingLaunchArgs) {
           LOG2.warn("CLI", `[${normalizedType}] initialThinkingLevel='${initialThinkingLevel}' requested but provider declares no thinkingLaunchArgs template \u2014 launching without thinking-level selection.`);
         }
-        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
+        const sessionBinding = resolveCliSessionBinding(launchProvider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
         const resolvedCliArgs = sessionBinding.cliArgs;
         const instanceManager = this.deps.getInstanceManager();
-        if (provider && instanceManager) {
-          const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
+        if (launchProvider && instanceManager) {
+          const resolvedProvider = launchProvider;
           await this.registerCliInstance(
             key2,
             normalizedType,
@@ -84584,7 +84777,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolvedDir,
             resolvedCliArgs,
             resolvedProvider,
-            { ...this.providerLoader.getSettings(normalizedType), ...options?.settingsOverride || {} },
+            launchSettings,
             false,
             {
               providerSessionId: sessionBinding.providerSessionId,
@@ -85415,6 +85608,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var chokidar = __toESM2(require_chokidar());
     init_hash();
     init_logger();
+    init_auto_approve_modes();
     init_open_panel_support();
     var VALID_CAPABILITY_MEDIA_TYPES = /* @__PURE__ */ new Set(["text", "image", "audio", "video", "resource"]);
     var VALID_INPUT_STRATEGIES2 = /* @__PURE__ */ new Set(["native", "native_acp", "resource_link", "text_fallback", "paste", "upload"]);
@@ -85480,6 +85674,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "providerVersion",
       "status",
       "details",
+      "autoApproveModes",
       "modelLaunchArgs",
       "modelOptions",
       "thinkingLaunchArgs",
@@ -85541,6 +85736,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       validateCapabilities(provider, controls, errors);
       validateNativeHistory(provider.nativeHistory, errors);
       validateMeshCoordinator(provider.meshCoordinator, errors);
+      validateAutoApproveModes(provider.autoApproveModes, errors);
       for (const control of controls) {
         validateControl(control, errors);
       }
@@ -85549,6 +85745,75 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       return { errors, warnings };
     }
+    function validateAutoApproveModes(raw, errors) {
+      if (raw === void 0) return;
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("autoApproveModes must be an object");
+        return;
+      }
+      const config2 = raw;
+      const defaultModeId = typeof config2.default === "string" ? config2.default.trim() : "";
+      if (!defaultModeId) {
+        errors.push("autoApproveModes.default must be a non-empty string");
+      } else {
+        config2.default = defaultModeId;
+      }
+      if (!Array.isArray(config2.modes) || config2.modes.length === 0) {
+        errors.push("autoApproveModes.modes must be a non-empty array");
+        return;
+      }
+      const ids = /* @__PURE__ */ new Set();
+      for (const [index, rawMode] of config2.modes.entries()) {
+        const prefix = `autoApproveModes.modes[${index}]`;
+        if (!rawMode || typeof rawMode !== "object" || Array.isArray(rawMode)) {
+          errors.push(`${prefix} must be an object`);
+          continue;
+        }
+        const mode = rawMode;
+        const id = typeof mode.id === "string" ? mode.id.trim() : "";
+        if (!id) {
+          errors.push(`${prefix}.id must be a non-empty string`);
+        } else if (ids.has(id)) {
+          errors.push(`${prefix}.id must be unique (duplicate: ${id})`);
+        } else {
+          ids.add(id);
+          mode.id = id;
+        }
+        if (typeof mode.label !== "string" || !mode.label.trim()) {
+          errors.push(`${prefix}.label must be a non-empty string`);
+        }
+        const strategy = mode.strategy;
+        if (!["pty-parse-default", "launch-args", "post-boot-command"].includes(String(strategy))) {
+          errors.push(`${prefix}.strategy must be one of: pty-parse-default, launch-args, post-boot-command`);
+        } else if (strategy === "post-boot-command") {
+          errors.push(`${prefix}.strategy post-boot-command is reserved and unsupported in v1`);
+        }
+        const risk = mode.risk;
+        if (!["safe", "caution", "dangerous"].includes(String(risk))) {
+          errors.push(`${prefix}.risk must be one of: safe, caution, dangerous`);
+        }
+        for (const field of ["launchArgs", "removeArgs"]) {
+          const value = mode[field];
+          if (value !== void 0 && (!Array.isArray(value) || value.some((arg) => typeof arg !== "string" || !arg.trim()))) {
+            errors.push(`${prefix}.${field} must be an array of non-empty strings when provided`);
+          }
+        }
+        if (strategy === "launch-args" && (!Array.isArray(mode.launchArgs) || mode.launchArgs.length === 0)) {
+          errors.push(`${prefix}.launchArgs must be a non-empty array for launch-args strategy`);
+        }
+        if (["safe", "caution", "dangerous"].includes(String(risk)) && deriveAutoApproveModeRisk(mode) === "dangerous") {
+          mode.risk = "dangerous";
+        }
+        if (mode.risk === "dangerous" && (typeof mode.warning !== "string" || !mode.warning.trim())) {
+          errors.push(`${prefix}.warning is required for dangerous modes`);
+        } else if (mode.warning !== void 0 && (typeof mode.warning !== "string" || !mode.warning.trim())) {
+          errors.push(`${prefix}.warning must be a non-empty string when provided`);
+        }
+      }
+      if (defaultModeId && !ids.has(defaultModeId)) {
+        errors.push(`autoApproveModes.default must reference an existing mode id: ${defaultModeId}`);
+      }
+    }
     function validateCapabilities(provider, controls, errors) {
       const capabilities = provider.capabilities;
       if (provider.contractVersion === 2) {