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

package/src/mesh/mesh-event-forwarding.ts

@@ -16,7 +16,8 @@ import { resolveMeshHostStatus } from './mesh-host-ownership.js';
 import { enqueueUnresolvedDelegateForward, nudgeUnresolvedForwardRetry } from './mesh-unresolved-forward-outbox.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
-import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
+import { delegatedWorkerAutoApproveSettings } from '../repo-mesh-types.js';
+import { loadRepoMeshJsonConfig } from '../config/mesh-json-config.js';
 import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, withStatusProbeMarker, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
@@ -1614,7 +1615,22 @@ function injectMeshSystemMessage(components: DaemonComponents, 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),
+                                        // Recovery relaunch: same repo-declared requested mode as the
+                                        // primary path. node.workspace missing → null → provider default.
+                                        (() => {
+                                            const ws = typeof node?.workspace === 'string' && node.workspace.trim() ? node.workspace.trim() : '';
+                                            if (!ws) return null;
+                                            try {
+                                                const r = loadRepoMeshJsonConfig(ws);
+                                                return r.sourceType === 'repo_file' && r.config ? r.config : null;
+                                            } catch { return null; }
+                                        })(),
+                                        recoveryContext.failedProviderType,
+                                    ),
                                     launchedByCoordinator: true,
                                 }
                             }).catch((e: any) => LOG.error('MeshRecovery', `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));

package/src/mesh/mesh-queue-assignment.ts

@@ -13,7 +13,9 @@ import { createSessionDelivery, updateSessionDeliveryStatus } from './mesh-deliv
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
-import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks, resolveCoordinatorIdlePushPolicy } from '../repo-mesh-types.js';
+import { delegatedWorkerAutoApproveSettings, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks, resolveCoordinatorIdlePushPolicy } from '../repo-mesh-types.js';
+import { loadRepoMeshJsonConfig } from '../config/mesh-json-config.js';
+import type { RepoMeshDeclarativeConfig } from '../config/mesh-json-config.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, expandDaemonIdForms, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, normalizeNodeCapabilitySlots, isMeshTaskDifficulty, withStatusProbeMarker, type MeshNodeIdentified, type NodeCapabilitySlot, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
 import { resolveNodeCapabilitySlots } from './mesh-node-slots.js';
@@ -90,6 +92,25 @@ export function __resetIdleAutoFastForwardForTests(): void {
     autoFastForwardWorkspaceLease.clear();
 }
 
+/**
+ * Load the repo-shared `.adhdev/mesh.json` for a node's workspace, tolerating a
+ * missing/invalid file (returns null → resolver falls back to provider-spec
+ * defaults, i.e. exactly the pre-providerDefaults behavior). Only the
+ * `providerDefaults` zone influences the delegated-worker MODE selection; it never
+ * touches the ENABLE decision. When a node carries no workspace path (should not
+ * happen for a launchable node, but be defensive), we skip the read entirely.
+ */
+function loadRepoConfigForNode(node: any): RepoMeshDeclarativeConfig | null {
+    const workspace = typeof node?.workspace === 'string' && node.workspace.trim() ? node.workspace.trim() : '';
+    if (!workspace) return null;
+    try {
+        const result = loadRepoMeshJsonConfig(workspace);
+        return result.sourceType === 'repo_file' && result.config ? result.config : null;
+    } catch {
+        return null;
+    }
+}
+
 export function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined {
     const localMesh = getMesh(meshId);
     const cachedMesh = components.router?.getCachedInlineMesh(meshId);
@@ -690,7 +711,7 @@ export function tryAssignQueueTask(
         if (inst && typeof inst.updateSettings === 'function') {
             // Adopting a (possibly manually-opened) local session as a worker: apply the
             // delegated-worker auto-approve policy here too, so a session that was launched
-            // without autoApprove still auto-approves once the coordinator dispatches a task
+            // without an auto-approve boolean/mode still resolves the delegated policy once dispatched
             // to it (the "approval notification fires only for certain delegated sessions"
             // case). updateSettings preserves runtime mesh keys; passing autoApprove keeps it.
             //
@@ -704,7 +725,13 @@ export function tryAssignQueueTask(
                 meshNodeFor: meshId,
                 meshNodeId: nodeId,
                 launchedByCoordinator: true,
-                autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
+                ...delegatedWorkerAutoApproveSettings(
+                    mesh?.policy,
+                    node?.policy,
+                    components.providerLoader?.getMeta(providerType),
+                    loadRepoConfigForNode(node),
+                    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)
@@ -1694,8 +1721,20 @@ function liveSessionCountForNode(components: DaemonComponents, meshId: string, n
  * free claimer, and is excluded — so a read-only auto-launch onto a busy-but-no-idle node
  * is still allowed. A node with NO live mesh session at all (dead, or never launched) does
  * not match, preserving the legitimate first-session spawn.
+ *
+ * PROVIDER-MATCH gate (DISPATCH-DEADLOCK-PROVIDER-MISMATCH): a live session only suppresses
+ * this launch if it could ACTUALLY claim THIS task. A session whose providerType does not
+ * satisfy the task's requiredTags (e.g. a claude-cli coordinator/worker session on a node,
+ * while the pending task is required_tags: [provider=codex-cli]) is NOT a pending claimer for
+ * this task — claimNextQueueTask's nodeSatisfiesRequiredTags gate would reject its claim. Left
+ * unchecked, such a mismatched session made this gate return true for a task it can never claim,
+ * so the required-provider worker never auto-launched AND no session could claim → nobody made
+ * progress → permanent silent deadlock. Mirror the claim path: build the session's own
+ * capability tags (its providerType pinned onto the node) and only count it as a pending claimer
+ * when those tags satisfy task.requiredTags. `node` is passed in so the tag set reflects this
+ * node's os/arch/worktree/converge context, matching claimNextQueueTask exactly.
  */
-function nodeHasLiveSessionPendingClaim(components: DaemonComponents, meshId: string, nodeId: string): boolean {
+function nodeHasLiveSessionPendingClaim(components: DaemonComponents, meshId: string, nodeId: string, task: MeshWorkQueueEntry, node: any): boolean {
     // (A) AUTOLAUNCH-CLAIM-CHURN remote-awareness: a task whose auto-launch record targets this
     // node and is still inside its await-claim window (base or backoff) already has a session on
     // its way to claim — even when that session is REMOTE and thus invisible to the local
@@ -1734,7 +1773,20 @@ function nodeHasLiveSessionPendingClaim(components: DaemonComponents, meshId: st
         if (isTerminalSessionStatus(status)) return false; // dead → no claimer here, allow launch
         const sessionId = readNonEmptyString(state.instanceId);
         if (sessionId && busySessionIds.has(sessionId)) return false; // busy with its own assigned task
-        return true; // live + unassigned → will claim the pending task itself
+        // PROVIDER-MATCH gate (DISPATCH-DEADLOCK-PROVIDER-MISMATCH): only count this session as a
+        // pending claimer if its own provider could satisfy THIS task's requiredTags. A session
+        // whose providerType does not match (e.g. a claude-cli session while task requires
+        // provider=codex-cli) can never claim this task via claimNextQueueTask's
+        // nodeSatisfiesRequiredTags gate, so it must not suppress the required-provider launch —
+        // otherwise the task deadlocks (mismatched session blocks launch, yet cannot claim). Mirror
+        // the claim path: pin the session's providerType onto this node and check the tags.
+        if (task.requiredTags?.length) {
+            const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
+            if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
+                return false; // provider mismatch → this session can't claim this task; not a pending claimer
+            }
+        }
+        return true; // live + unassigned + provider-capable → will claim the pending task itself
     });
 }
 
@@ -2246,7 +2298,7 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
             // busy-but-no-idle node is still allowed. Skip with a transient (non-actionable)
             // reason so the coordinator is not paged; the 4s reconcile retries, and once the
             // existing session goes terminal this gate clears and a legitimate launch proceeds.
-            if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId)) {
+            if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
                 markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'node_has_live_session_pending_claim', nodeId });
                 continue;
             }
@@ -2318,8 +2370,14 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, 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),
+                        loadRepoConfigForNode(node),
+                        resolved.providerType,
+                    ),
                     launchedByCoordinator: true,
                     autoLaunchedForQueueTaskId: task.id,
                 };
@@ -2984,4 +3042,3 @@ export function runIdleMaintenanceThenAssignQueue(components: DaemonComponents,
             });
     });
 }
-

package/src/providers/auto-approve-modes.ts

@@ -0,0 +1,97 @@
+import type {
+  AutoApproveMode,
+  AutoApproveModeRisk,
+  AutoApproveModeStrategy,
+  ProviderModule,
+} from './contracts.js';
+
+const KNOWN_DANGEROUS_LAUNCH_ARGS = new Set([
+  '--dangerously-skip-permissions',
+  '--dangerously-bypass-approvals-and-sandbox',
+  'bypassPermissions',
+  'sandbox_mode=danger-full-access',
+  'approval_policy=never',
+]);
+
+export interface ResolvedAutoApproveMode {
+  active: boolean;
+  strategy: AutoApproveModeStrategy;
+  modeId: string;
+}
+
+function isKnownDangerousLaunchArg(arg: string): boolean {
+  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=');
+}
+
+/** Runtime defense-in-depth for provider definitions that bypass schema validation. */
+export function deriveAutoApproveModeRisk(mode: Pick<AutoApproveMode, 'risk' | 'launchArgs'>): AutoApproveModeRisk {
+  return Array.isArray(mode.launchArgs) && mode.launchArgs.some(isKnownDangerousLaunchArg)
+    ? 'dangerous'
+    : mode.risk;
+}
+
+function inactiveMode(modeId = ''): ResolvedAutoApproveMode {
+  return { active: false, strategy: 'pty-parse-default', modeId };
+}
+
+function resolveConfiguredMode(
+  provider: ProviderModule,
+  mode: AutoApproveMode,
+  settings: Record<string, unknown> | undefined,
+): ResolvedAutoApproveMode {
+  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 };
+}
+
+/**
+ * Resolve new mode settings before the legacy boolean. A stale/unknown explicit
+ * mode id fails closed instead of falling through to an enabled legacy setting.
+ */
+export function resolveProviderAutoApproveMode(
+  provider: ProviderModule,
+  settings: Record<string, unknown> | undefined,
+): ResolvedAutoApproveMode {
+  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);
+}
+
+export function findProviderAutoApproveMode(
+  provider: ProviderModule | undefined,
+  modeId: string,
+): AutoApproveMode | undefined {
+  return provider?.autoApproveModes?.modes.find((mode) => mode.id === modeId);
+}

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

@@ -75,6 +75,7 @@ import type {
 } from './cli-provider-instance-types.js';
 import { mergeConversationMessages, buildExternalTranscriptProbe } from './cli-provider-transcript-merge.js';
 import { getEffectDedupKey, formatApprovalRequestMessage, formatMarkerTimestamp } from './cli-provider-effect-format.js';
+import { resolveProviderAutoApproveMode, type ResolvedAutoApproveMode } from './auto-approve-modes.js';
 
 // Re-export moved public symbols so existing importers (index.ts, tests) keep
 // their `./cli-provider-instance.js` path. Pure move — no behavior change.
@@ -2780,7 +2781,7 @@ export class CliProviderInstance implements ProviderInstance {
      * resolveModal, so a plain turn that never saw an approval always returns false.
      */
     private inApprovalResumeGrace(now = Date.now()): boolean {
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return false;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return false;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
             ? (this.adapter as any).lastApprovalResolvedAt as number
             : 0;
@@ -2897,7 +2898,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         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 as any)?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
         if (latestVisibleStatus !== 'idle') {
@@ -3300,7 +3301,7 @@ export class CliProviderInstance implements ProviderInstance {
     private stabilizeFlappingApprovalStatus(adapterStatus: any, now = Date.now()): any {
         // Only autonomous auto-approving mesh sessions are subject to the delegated flap;
         // never overlay for attended/foreground/non-mesh sessions.
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return adapterStatus;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return adapterStatus;
 
         const rawStatus = adapterStatus?.status;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
@@ -3347,6 +3348,13 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        // launch-args modes grant approval in the CLI process itself and therefore
+        // must never enter the PTY modal parser/fire/settle/mask/nudge subsystem.
+        // post-boot-command is reserved and resolves inactive in v1.
+        if (!this.shouldUsePtyAutoApprove()) {
+            this.resetPtyAutoApproveState();
+            return false;
+        }
         // Manual-attendance suppression (provider-common): when a human is
         // Manual-attendance suppression (provider-common): when a human is
         // actively driving this session from the dashboard, hold auto-approve so
@@ -3358,7 +3366,7 @@ export class CliProviderInstance implements ProviderInstance {
         // 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.shouldUsePtyAutoApprove()
             && this.manualAttendance.isAttended(now)) {
             this.lastAutoApprovalSignature = '';
             this.pendingAutoApprovalSignature = '';
@@ -3376,7 +3384,7 @@ export class CliProviderInstance implements ProviderInstance {
             }, this.manualAttendance.remainingMs(now) + 20);
             return false;
         }
-        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldUsePtyAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
         // times while the PTY absorbs the approval key. Without this flag, repeated
         // snapshots would write stray keys into the input once the modal dismisses.
@@ -4652,15 +4660,37 @@ export class CliProviderInstance implements ProviderInstance {
     get cliType(): string { return this.type; }
     get cliName(): string { return this.provider.name; }
 
+    private resolveAutoApproveMode(): ResolvedAutoApproveMode {
+        return resolveProviderAutoApproveMode(this.provider, this.settings);
+    }
+
+    /** Legacy boolean view retained for internal/test compatibility. */
     private shouldAutoApprove(): boolean {
-        if (typeof this.settings.autoApprove === 'boolean') {
-            return this.settings.autoApprove;
+        return this.resolveAutoApproveMode().active;
+    }
+
+    private shouldUsePtyAutoApprove(): boolean {
+        const resolved = this.resolveAutoApproveMode();
+        return this.shouldAutoApprove() && resolved.strategy === 'pty-parse-default';
+    }
+
+    private resetPtyAutoApproveState(): void {
+        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 */
@@ -4687,7 +4717,7 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
         return status === 'waiting_approval'
-            && this.shouldAutoApprove()
+            && this.shouldUsePtyAutoApprove()
             && !this.manualAttendance.isAttended(now);
     }
 
@@ -4699,7 +4729,8 @@ export class CliProviderInstance implements ProviderInstance {
     // maybeAutoApproveStatus (driven by getState + the recheck timer during a waiting episode);
     // this read is side-effect-free so getStatusMetadata can consult it too.
     private autoApproveMaskStalled(now = Date.now()): boolean {
-        return this.autoApproveMaskSince > 0
+        return this.shouldUsePtyAutoApprove()
+            && this.autoApproveMaskSince > 0
             && now - this.autoApproveMaskSince > CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
     }
 
@@ -4725,6 +4756,7 @@ export class CliProviderInstance implements ProviderInstance {
      * mask-clock value) so a modal that flaps between parsed/unparsed states is announced once.
      */
     private maybeEmitStalledApprovalNudge(adapterStatus: any, now: number): void {
+        if (!this.shouldUsePtyAutoApprove()) return;
         if (!this.isMeshWorkerSession()) return;
         if (adapterStatus?.status !== 'waiting_approval') return;
         if (!this.autoApproveMaskStalled(now)) return;

package/src/providers/contracts.ts

@@ -488,6 +488,28 @@ export interface ProviderCompatibilityEntry {
   scriptDir: string;
 }
 
+export type AutoApproveModeStrategy =
+  | 'pty-parse-default'
+  | 'launch-args'
+  | 'post-boot-command';
+
+export type AutoApproveModeRisk = 'safe' | 'caution' | 'dangerous';
+
+export interface AutoApproveMode {
+  id: string;
+  label: string;
+  strategy: AutoApproveModeStrategy;
+  risk: AutoApproveModeRisk;
+  warning?: string;
+  launchArgs?: string[];
+  removeArgs?: string[];
+}
+
+export interface AutoApproveModesConfig {
+  default: string;
+  modes: AutoApproveMode[];
+}
+
 export interface ProviderModule {
  /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
   type: string;
@@ -519,7 +541,9 @@ export interface ProviderModule {
   status?: string;
  /** Inventory/support detail string maintained in adhdev-providers */
   details?: string;
- /** Install instructions (shown when command is missing) */
+  /** Provider-specific auto-approve choices and their launch/runtime strategy. */
+  autoApproveModes?: AutoApproveModesConfig;
+  /** Install instructions (shown when command is missing) */
   install?: string;
  /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
   versionCommand?: ProviderVersionCommand;

package/src/providers/provider-schema.ts

@@ -1,4 +1,5 @@
 import type { ProviderControlDef, ProviderControlType, ProviderModule } from './contracts.js'
+import { deriveAutoApproveModeRisk } from './auto-approve-modes.js'
 import { providerHasOpenPanelSupport } from './open-panel-support.js'
 
 const VALID_CAPABILITY_MEDIA_TYPES = new Set(['text', 'image', 'audio', 'video', 'resource'])
@@ -66,6 +67,7 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'providerVersion',
   'status',
   'details',
+  'autoApproveModes',
   'modelLaunchArgs',
   'modelOptions',
   'thinkingLaunchArgs',
@@ -144,6 +146,7 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
   validateCapabilities(provider as unknown as ProviderModule, controls, errors)
   validateNativeHistory(provider.nativeHistory, errors)
   validateMeshCoordinator(provider.meshCoordinator, errors)
+  validateAutoApproveModes(provider.autoApproveModes, errors)
 
   for (const control of controls) {
     validateControl(control as ProviderControlDef, errors)
@@ -160,6 +163,86 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
   return { errors, warnings }
 }
 
+export function validateAutoApproveModes(raw: unknown, errors: string[]): void {
+  if (raw === undefined) return
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    errors.push('autoApproveModes must be an object')
+    return
+  }
+
+  const config = raw as Record<string, unknown>
+  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 = new Set<string>()
+  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 as Record<string, unknown>
+    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'] as const) {
+      const value = mode[field]
+      if (value !== undefined && (!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`)
+    }
+
+    // Mutate the validated provider object so downstream runtime/UI consumers see
+    // the effective risk. The runtime resolver repeats this derivation as defense-in-depth.
+    if (['safe', 'caution', 'dangerous'].includes(String(risk))
+        && deriveAutoApproveModeRisk(mode as any) === '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 !== undefined && (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: ProviderModule, controls: ProviderControlDef[], errors: string[]): void {
   const capabilities = provider.capabilities
   if (provider.contractVersion === 2) {

package/src/providers/sdk/v1/schemas/cli/provider.schema.json

@@ -119,6 +119,20 @@
         }
       }
     },
+    "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,
@@ -476,6 +490,36 @@
     }
   },
   "$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": {