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

package/dist/index.mjs

@@ -25,6 +25,62 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/providers/auto-approve-modes.ts
+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 config = provider.autoApproveModes;
+  const explicitModeId = settings?.autoApproveMode;
+  if (typeof explicitModeId === "string") {
+    const mode = config?.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 (!config) {
+    return { active: true, strategy: "pty-parse-default", modeId: "legacy" };
+  }
+  const defaultMode = config.modes.find((mode) => mode.id === config.default);
+  if (!defaultMode) return inactiveMode(config.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 = __esm({
+  "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"
+    ]);
+  }
+});
+
 // src/repo-mesh-types.ts
 function normalizeMeshSchedulingStrategy(value) {
   if (typeof value !== "string") return DEFAULT_MESH_SCHEDULING_STRATEGY;
@@ -111,6 +167,11 @@ function mergeAndNormalizePolicy(base, patch) {
   } 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 {
@@ -118,14 +179,35 @@ function mergeAndNormalizePolicy(base, patch) {
   }
   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") {
@@ -155,6 +237,7 @@ var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
+    init_auto_approve_modes();
     MESH_SCHEDULING_STRATEGIES = [
       "first_eligible",
       "least_loaded",
@@ -182,6 +265,7 @@ var init_repo_mesh_types = __esm({
       // 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)
@@ -437,10 +521,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "74f34080bcd7c145e55fd7e5fd492a40a4942bc4" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "74f34080" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:29:46.281Z" : 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 version = 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:30:50.962Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -16835,7 +16919,11 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         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)
@@ -17608,8 +17696,12 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           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
         };
@@ -20449,6 +20541,7 @@ function buildAvailableProviders(providerLoader) {
       ...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),
@@ -21627,7 +21720,11 @@ function injectMeshSystemMessage(components, args) {
                   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) => LOG.error("MeshRecovery", `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));
@@ -24287,6 +24384,20 @@ var init_provider_schema = __esm({
             }
           }
         },
+        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,
@@ -24660,6 +24771,36 @@ var init_provider_schema = __esm({
         }
       },
       $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: {
@@ -49005,6 +49146,7 @@ function formatMarkerTimestamp(timestamp) {
 }
 
 // src/providers/cli-provider-instance.ts
+init_auto_approve_modes();
 function approvalModalSignature(message, affirmativeAnchor) {
   return [typeof message === "string" ? message.trim() : "", affirmativeAnchor].join("::");
 }
@@ -50985,7 +51127,7 @@ var CliProviderInstance = class _CliProviderInstance {
    * 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;
@@ -51090,7 +51232,7 @@ var CliProviderInstance = class _CliProviderInstance {
       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;
     LOG.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") {
@@ -51360,7 +51502,7 @@ var CliProviderInstance = class _CliProviderInstance {
    * 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") {
@@ -51390,7 +51532,11 @@ var CliProviderInstance = class _CliProviderInstance {
     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;
@@ -51405,7 +51551,7 @@ var CliProviderInstance = class _CliProviderInstance {
       }, 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) {
@@ -52100,15 +52246,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) {
@@ -52124,7 +52289,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
@@ -52134,7 +52299,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
@@ -52158,6 +52323,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;
@@ -53703,6 +53869,7 @@ function shouldRestoreHostedRuntime(record, managerTag) {
 }
 
 // src/commands/cli-manager.ts
+init_auto_approve_modes();
 function isExplicitCommand(command) {
   const trimmed = command.trim();
   return path30.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
@@ -53929,6 +54096,24 @@ function expandThinkingLaunchArgs(template, level, levelMap) {
   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;
@@ -54359,22 +54544,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) {
       LOG.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) {
       LOG.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,
@@ -54382,7 +54575,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         resolvedDir,
         resolvedCliArgs,
         resolvedProvider,
-        { ...this.providerLoader.getSettings(normalizedType), ...options?.settingsOverride || {} },
+        launchSettings,
         false,
         {
           providerSessionId: sessionBinding.providerSessionId,
@@ -55221,6 +55414,7 @@ init_hash();
 init_logger();
 
 // src/providers/provider-schema.ts
+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"]);
@@ -55286,6 +55480,7 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "providerVersion",
   "status",
   "details",
+  "autoApproveModes",
   "modelLaunchArgs",
   "modelOptions",
   "thinkingLaunchArgs",
@@ -55347,6 +55542,7 @@ function validateProviderDefinition(raw) {
   validateCapabilities(provider, controls, errors);
   validateNativeHistory(provider.nativeHistory, errors);
   validateMeshCoordinator(provider.meshCoordinator, errors);
+  validateAutoApproveModes(provider.autoApproveModes, errors);
   for (const control of controls) {
     validateControl(control, errors);
   }
@@ -55355,6 +55551,75 @@ function validateProviderDefinition(raw) {
   }
   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 config = raw;
+  const defaultModeId = typeof config.default === "string" ? config.default.trim() : "";
+  if (!defaultModeId) {
+    errors.push("autoApproveModes.default must be a non-empty string");
+  } else {
+    config.default = defaultModeId;
+  }
+  if (!Array.isArray(config.modes) || config.modes.length === 0) {
+    errors.push("autoApproveModes.modes must be a non-empty array");
+    return;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, rawMode] of config.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) {
@@ -76205,6 +76470,7 @@ export {
   createSessionDelivery,
   createWorktree,
   daemonIdsEquivalent,
+  delegatedWorkerAutoApproveSettings,
   deleteDirectDispatchesByTaskId,
   deleteMesh,
   deriveMeshNodeHealthFromGit,
@@ -76404,6 +76670,7 @@ export {
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
   resolveDelegatedWorkerAutoApprove,
+  resolveDelegatedWorkerDangerousModeAllow,
   resolveDeliveryDecision,
   resolveEffectiveMeshNodeHealth,
   resolveGitRepository,