@adhdev/daemon-core 1.0.18-rc.20 → 1.0.18-rc.4

package/src/providers/contracts.ts

@@ -488,28 +488,6 @@ 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;
@@ -541,9 +519,7 @@ export interface ProviderModule {
   status?: string;
  /** Inventory/support detail string maintained in adhdev-providers */
   details?: string;
-  /** Provider-specific auto-approve choices and their launch/runtime strategy. */
-  autoApproveModes?: AutoApproveModesConfig;
-  /** Install instructions (shown when command is missing) */
+ /** 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,5 +1,4 @@
 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'])
@@ -67,7 +66,6 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'providerVersion',
   'status',
   'details',
-  'autoApproveModes',
   'modelLaunchArgs',
   'modelOptions',
   'thinkingLaunchArgs',
@@ -146,7 +144,6 @@ 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)
@@ -163,86 +160,6 @@ 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/builders/cli/detect-status.ts

@@ -210,33 +210,10 @@ function buttonBlockApprovalCue(spec: ModalSpec, text: string): boolean {
   return hasNegativeApprovalOption(labels);
 }
 
-/**
- * APPROVAL-PICKER-MISROUTE (mission f1d25e11) defense-in-depth: an
- * AskUserQuestion multi-choice picker is NOT an approval modal. Its option rows
- * ("❯ 1. label") can otherwise satisfy the approval button cue and get
- * mis-classified as `waiting_approval`, so the worker's question is surfaced to
- * the coordinator as a task_approval_needed (→ mesh_approve, which cannot answer
- * it). The picker carries a distinctive signature the approval FSM never does:
- * the claude TUI select footer ("Enter to select … Esc to cancel") together with
- * the freeform escape hatch ("Type something" / "Chat about this"). When both are
- * present the screen is a question picker — surfaced separately as
- * waiting_choice — so the approval matchers must yield. Mirrors the legacy
- * looksLikeSelectionPicker guard (cli-provider-instance.ts) ported to SDK-v1.
- */
-export function isAskUserQuestionPickerSignature(text: string): boolean {
-  if (!text) return false;
-  const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
-  if (!hasSelectFooter) return false;
-  return /Type something\.?|Chat about this/i.test(text);
-}
-
 function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean {
   // Status-level modal detection is cue-only — does the question appear at all?
   // Button extraction lives in buildParseApprovalFromTui.
   const text = input.screenText ?? '';
-  // A question picker (AskUserQuestion) is never an approval — bail before any
-  // approval cue can match its numbered option rows (mission f1d25e11).
-  if (isAskUserQuestionPickerSignature(text)) return false;
   const question = compile(spec.questionPattern, spec.questionFlags ?? 'i');
   if (question.test(text)) return true;
   for (const variant of spec.questionVariants ?? []) {

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -78,22 +78,6 @@ function compile(re: string, flags?: string): RegExp {
   }
 }
 
-/**
- * APPROVAL-PICKER-MISROUTE (mission f1d25e11) defense-in-depth: mirror
- * detect-status.isAskUserQuestionPickerSignature at the button-parse layer. A
- * multi-choice AskUserQuestion picker is not an approval modal; its numbered
- * option rows can otherwise be extracted as approval buttons and produce a
- * spurious approval modal. When the picker signature (claude TUI select footer +
- * "Type something"/"Chat about this" freeform escape hatch) is present, return
- * null early so the screen is surfaced as waiting_choice, never approval.
- */
-function isAskUserQuestionPickerSignature(text: string): boolean {
-  if (!text) return false;
-  const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
-  if (!hasSelectFooter) return false;
-  return /Type something\.?|Chat about this/i.test(text);
-}
-
 function findQuestionLineIndex(
   spec: ModalTuiSpec,
   lines: string[],
@@ -284,10 +268,6 @@ export function buildParseApprovalFromTui(
   return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
     const rawText = input.screenText ?? input.buffer ?? '';
     if (!rawText) return null;
-    // An AskUserQuestion picker is not an approval — never extract its option
-    // rows as approval buttons (mission f1d25e11). Check the raw text before any
-    // visible-region scoping trims the footer that identifies the picker.
-    if (isAskUserQuestionPickerSignature(rawText)) return null;
     const text = visibleRegion ? applyVisibleRegion(visibleRegion, rawText) : rawText;
     const lines = text.split('\n');
     const question = findQuestionLineIndex(spec, lines);

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

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

package/src/providers/types/interactive-prompt.ts

@@ -117,83 +117,6 @@ export function normalizeInteractivePromptResponse(raw: unknown): InteractivePro
   return { promptId, answers };
 }
 
-/**
- * Resolve a coordinator-friendly answer form into the strict, questionId-keyed
- * InteractivePromptResponse the TUI/answer machinery consumes (mission f1d25e11).
- *
- * mesh_answer_question lets the coordinator answer against the option LABELS or
- * 1-based INDEXES it saw in the agent:waiting_choice event, without having to
- * reconstruct the exact questionId → selectedLabels map. This resolves that
- * ergonomic form against the AUTHORITATIVE active prompt (the daemon holds it),
- * so index/label resolution and question ordering are correct by construction.
- *
- * Accepted `raw` shapes:
- *   - The strict form ({ promptId, answers: { [questionId]: { selectedLabels } } })
- *     — passed straight to normalizeInteractivePromptResponse (back-compat).
- *   - The friendly form ({ promptId, answers: [ { questionId?, select?, freeform? } ] })
- *     — entries map to questions by questionId, else by array position. `select`
- *     is a label (string) / 1-based index (number) / array of either.
- */
-export function resolveInteractivePromptResponse(
-  prompt: InteractivePrompt,
-  raw: unknown,
-): InteractivePromptResponse {
-  if (!raw || typeof raw !== 'object') throw new Error('Interactive prompt response must be an object');
-  const record = raw as Record<string, unknown>;
-  const promptId = readString(record.promptId);
-  if (!promptId) throw new Error('promptId must be a non-empty string');
-  if (promptId !== prompt.promptId) throw new Error('Interactive prompt response does not match active prompt');
-  // Strict (keyed-object) form → existing normalizer.
-  if (record.answers && typeof record.answers === 'object' && !Array.isArray(record.answers)) {
-    return normalizeInteractivePromptResponse(record);
-  }
-  if (!Array.isArray(record.answers)) throw new Error('answers must be an array or a questionId-keyed object');
-
-  const resolveOneLabel = (question: InteractiveQuestion, sel: unknown): string => {
-    if (typeof sel === 'number' && Number.isFinite(sel)) {
-      const idx = Math.trunc(sel) - 1; // 1-based
-      const option = question.options[idx];
-      if (!option) throw new Error(`Option index ${sel} out of range for ${question.questionId}`);
-      return option.label;
-    }
-    const label = readString(sel);
-    if (!label) throw new Error(`Empty selection for ${question.questionId}`);
-    // Exact label match first; fall back to a numeric string index.
-    const exact = question.options.find((o) => o.label === label);
-    if (exact) return exact.label;
-    const asIndex = Number(label);
-    if (Number.isInteger(asIndex)) {
-      const option = question.options[asIndex - 1];
-      if (option) return option.label;
-    }
-    throw new Error(`Unknown option for ${question.questionId}: ${label}`);
-  };
-
-  const answers: Record<string, InteractiveAnswer> = {};
-  const entries = record.answers as unknown[];
-  entries.forEach((entryRaw, index) => {
-    if (!entryRaw || typeof entryRaw !== 'object' || Array.isArray(entryRaw)) return;
-    const entry = entryRaw as Record<string, unknown>;
-    const questionId = readString(entry.questionId);
-    const question = (questionId ? prompt.questions.find((q) => q.questionId === questionId) : undefined)
-      ?? prompt.questions[index];
-    if (!question) throw new Error(`No matching question for answer entry ${index}`);
-    const freeformText = readString(entry.freeform) ?? readString(entry.freeformText);
-    const selectedLabels: string[] = [];
-    const select = entry.select;
-    if (Array.isArray(select)) {
-      for (const sel of select) selectedLabels.push(resolveOneLabel(question, sel));
-    } else if (select !== undefined && select !== null) {
-      selectedLabels.push(resolveOneLabel(question, select));
-    }
-    answers[question.questionId] = {
-      selectedLabels,
-      ...(freeformText ? { freeformText } : {}),
-    };
-  });
-  return { promptId, answers };
-}
-
 export function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string {
     return JSON.stringify({
     type: 'user',

package/src/repo-mesh-types.ts

@@ -15,11 +15,6 @@ import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
 import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 import type { MeshMagiActivitySummary } from './mesh/mesh-magi-status.js';
 import type { MagiKindPanelMap, DifficultyBrainMap, NodeCapabilitySlot } from '@adhdev/mesh-shared';
-import type { ProviderModule } from './providers/contracts.js';
-import { deriveAutoApproveModeRisk } from './providers/auto-approve-modes.js';
-// Type-only import (no runtime cycle) — mesh-json-config imports types from this
-// module, and this direction is `import type` so tsc erases it at emit.
-import type { RepoMeshDeclarativeConfig } from './config/mesh-json-config.js';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -355,8 +350,6 @@ export interface RepoMeshPolicy {
      * A node policy may override this per-node (RepoMeshNodePolicy.delegatedWorkerAutoApprove).
      */
     delegatedWorkerAutoApprove?: boolean;
-    /** Explicit opt-in required before delegated workers may use a dangerous provider mode. */
-    delegatedWorkerDangerousModeAllow?: boolean;
     /**
      * MESH-SEND-KEYS (feature 3): opt-in to allow the coordinator to inject
      * DESTRUCTIVE keys (CTRL_C / ESC) into a worker PTY via mesh_send_keys. These
@@ -512,8 +505,6 @@ export interface RepoMeshNodePolicy {
      * precedence over the mesh-level policy for worker sessions launched onto this node.
      */
     delegatedWorkerAutoApprove?: boolean;
-    /** Per-node override for dangerous delegated worker mode authorization. */
-    delegatedWorkerDangerousModeAllow?: boolean;
     /**
      * MESH-SEND-KEYS (feature 3): per-node override for
      * RepoMeshPolicy.allowSendKeysDestructive.
@@ -559,7 +550,6 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     // 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)
@@ -786,13 +776,6 @@ export function mergeAndNormalizePolicy(
     } else {
         delete policy.autoConvergeCodeChange;
     }
-    // Dangerous delegated-worker provider modes are fail-closed and only persist
-    // when the mesh owner has explicitly opted in.
-    if (policy.delegatedWorkerDangerousModeAllow === true) {
-        policy.delegatedWorkerDangerousModeAllow = true;
-    } else {
-        delete policy.delegatedWorkerDangerousModeAllow;
-    }
     // Coordinator idle-push policy: strict opt-in. Only persist the explicit
     // 'auto_silent_on_dispatch' value; any other/invalid value normalizes to the
     // 'always' default and is dropped so existing meshes.json stays byte-for-byte
@@ -806,106 +789,23 @@ export function mergeAndNormalizePolicy(
 }
 
 /**
- * Resolve delegated worker auto-approve. Legacy providers return a boolean. Providers
- * with modes return a mode id, except a dangerous mode is downgraded to a
- * non-dangerous PTY mode unless mesh/node policy explicitly opts in.
- *
- * THREE EXPLICIT STAGES — do not collapse them; the ordering is a hard MAGI
- * invariant:
- *
- *   ① ENABLE gate (machine-local policy only): node boolean > mesh boolean.
- *      `enabled=false` returns `false` IMMEDIATELY, BEFORE any mode selection.
- *      The repo `mesh.json` providerDefaults has ZERO influence here — a
- *      node/mesh opt-out is never overridden by a repo-declared requested mode.
- *
- *   ② MODE selection (only when enabled === true):
- *        task override [FUTURE — param reserved below, not yet wired] >
- *        repo mesh.json providerDefaults.autoApproveModes[providerType] >
- *        provider spec autoApproveModes.default.
- *      A repo-requested mode ID is adopted ONLY when it exists in the provider's
- *      own `autoApproveModes.modes`; an unknown/stale/typo'd ID is IGNORED and we
- *      fall back to the provider default (fail-closed: never coerce into a
- *      dangerous mode via a bad ID).
- *
- *   ③ DANGEROUS gate: whichever mode stage ② picked, if it is dangerous and the
- *      machine-local delegatedWorkerDangerousModeAllow is not set, downgrade to a
- *      non-dangerous PTY-parse mode (or `false` if none exists).
+ * Resolve whether a delegated worker session launched onto `nodePolicy` (within a mesh
+ * governed by `meshPolicy`) should auto-approve. Precedence: node override → mesh policy
+ * → default true. The result is stamped into the worker launch settings envelope as
+ * `autoApprove`; it wins over the global per-provider-type autoApprove config because the
+ * launch path merges the envelope as a settingsOverride on top of the provider defaults.
  */
 export function resolveDelegatedWorkerAutoApprove(
-    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null,
-    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null,
-    provider?: Pick<ProviderModule, 'autoApproveModes'> | null,
-    repoConfig?: RepoMeshDeclarativeConfig | null,
-    // providerType is needed to look up the repo-declared requested mode; it is
-    // separate from `provider` because the caller resolves the spec independently.
-    providerType?: string | null,
-): boolean | string {
-    // ── ① ENABLE gate — machine-local only. false short-circuits before mode. ──
-    let enabled = true;
+    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null,
+    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null,
+): boolean {
     if (typeof nodePolicy?.delegatedWorkerAutoApprove === 'boolean') {
-        enabled = nodePolicy.delegatedWorkerAutoApprove;
-    } else if (typeof meshPolicy?.delegatedWorkerAutoApprove === 'boolean') {
-        enabled = meshPolicy.delegatedWorkerAutoApprove;
+        return nodePolicy.delegatedWorkerAutoApprove;
     }
-    if (!enabled) return false;
-
-    const modes = provider?.autoApproveModes;
-    if (!modes) return true;
-
-    // ── ② MODE selection (enabled only). Repo providerDefaults MAY override the
-    //     provider spec default here — but only with a mode ID the spec knows. ──
-    // Future: a per-task override would slot in ahead of the repo default; the
-    // signature reserves that precedence but no task override is wired yet.
-    const requestedModeRaw = typeof providerType === 'string'
-        ? repoConfig?.providerDefaults?.autoApproveModes?.[providerType.trim()]
-        : undefined;
-    const requestedModeId = typeof requestedModeRaw === 'string' && requestedModeRaw.trim()
-        ? requestedModeRaw.trim()
-        : '';
-    const requestedMode = requestedModeId
-        ? modes.modes.find((mode) => mode.id === requestedModeId)
-        : undefined;
-    const selectedMode = requestedMode
-        ?? modes.modes.find((mode) => mode.id === modes.default);
-    if (!selectedMode || selectedMode.strategy === 'post-boot-command') return false;
-
-    // ── ③ DANGEROUS gate — downgrade a dangerous selection without machine opt-in. ──
-    const dangerousAllowed = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
-    if (deriveAutoApproveModeRisk(selectedMode) === 'dangerous' && !dangerousAllowed) {
-        const ptyFallback = modes.modes.find((mode) =>
-            mode.strategy === 'pty-parse-default' && deriveAutoApproveModeRisk(mode) !== 'dangerous');
-        return ptyFallback?.id || false;
+    if (typeof meshPolicy?.delegatedWorkerAutoApprove === 'boolean') {
+        return meshPolicy.delegatedWorkerAutoApprove;
     }
-    return selectedMode.id;
-}
-
-export function resolveDelegatedWorkerDangerousModeAllow(
-    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerDangerousModeAllow'> | null,
-    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerDangerousModeAllow'> | null,
-): boolean {
-    if (typeof nodePolicy?.delegatedWorkerDangerousModeAllow === 'boolean') {
-        return nodePolicy.delegatedWorkerDangerousModeAllow;
-    }
-    return meshPolicy?.delegatedWorkerDangerousModeAllow === true;
-}
-
-/** Shape a boolean-or-mode resolution for the settings precedence contract. */
-export function delegatedWorkerAutoApproveSettings(
-    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null,
-    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove' | 'delegatedWorkerDangerousModeAllow'> | null,
-    provider?: Pick<ProviderModule, 'autoApproveModes'> | null,
-    repoConfig?: RepoMeshDeclarativeConfig | null,
-    providerType?: string | null,
-): {
-    autoApprove: boolean | undefined;
-    autoApproveMode: string | undefined;
-    delegatedWorkerDangerousModeAllow: boolean;
-} {
-    const resolved = resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider, repoConfig, providerType);
-    const delegatedWorkerDangerousModeAllow = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
-    return typeof resolved === 'string'
-        ? { autoApprove: undefined, autoApproveMode: resolved, delegatedWorkerDangerousModeAllow }
-        : { autoApprove: resolved, autoApproveMode: undefined, delegatedWorkerDangerousModeAllow };
+    return true;
 }
 
 /**

package/src/shared-types.ts

@@ -52,7 +52,7 @@ export type { ProviderErrorReason } from './providers/provider-instance.js';
 // Local import for use in Managed*Entry types below
 import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
-import type { AutoApproveModesConfig, ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
+import type { ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
 import type {
     GitCompactSummary,
     GitDiffSummary,
@@ -563,8 +563,6 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-    /** Provider-declared auto-approve choices shown by session launch UIs. */
-    autoApproveModes?: AutoApproveModesConfig;
     /** BRAIN-ROUTING: suggested model values for the new-session model dropdown. */
     modelOptions?: string[];
     /** BRAIN-ROUTING: reasoning-effort values for the new-session thinking dropdown. */
@@ -777,12 +775,6 @@ export interface DashboardBootstrapDaemonEntry extends Partial<CloudDaemonSummar
 export type DaemonStatusEventName =
     | 'agent:generating_started'
     | 'agent:waiting_approval'
-    // A question picker (AskUserQuestion / InteractivePrompt) parks the agent
-    // awaiting a human decision — distinct from an approval modal, but equally a
-    // state the user must answer before work continues. Relayed to the server so
-    // push notifications fire (owner requirement: coordinator sessions must be
-    // pinged for pending questions).
-    | 'agent:waiting_choice'
     | 'agent:generating_completed'
     | 'agent:stopped'
     | 'monitor:no_progress'

package/src/status/reporter.ts

@@ -118,7 +118,6 @@ export class DaemonStatusReporter {
         switch (value) {
             case 'agent:generating_started':
             case 'agent:waiting_approval':
-            case 'agent:waiting_choice':
             case 'agent:generating_completed':
             case 'agent:stopped':
             case 'monitor:no_progress':

package/src/status/snapshot.ts

@@ -145,7 +145,6 @@ export function buildAvailableProviders(
         lastDetection?: AvailableProviderInfo['lastDetection'];
         lastVerification?: AvailableProviderInfo['lastVerification'];
         meshCoordinator?: AvailableProviderInfo['meshCoordinator'];
-        autoApproveModes?: AvailableProviderInfo['autoApproveModes'];
         _sourceTrust?: AvailableProviderInfo['trust'];
         _sourceLayer?: AvailableProviderInfo['sourceLayer'];
         _sourceName?: string | null;
@@ -184,7 +183,6 @@ export function buildAvailableProviders(
             ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
             ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
             ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
-            ...(provider.autoApproveModes !== undefined ? { autoApproveModes: provider.autoApproveModes } : {}),
             ...(trust ? {
                 trust,
                 trustDescription: describeTrust(trust),