deepseek-harness/docs/rfc/implemented/feature/2026-07-07-plan-mode.md

RFC: Plan mode — a logged per-agent session mode

Status: implemented

Problem

The harness has no way to put an agent into a reduced-authority working state. The canonical feature that needs one is plan mode — the agent explores and designs under a read-only tool policy, produces a reviewable plan, and crosses back into full authority only through an explicit approval. The extension cookbook already reserves the row ("Plan mode — tools/pre-execute (deny writes) + a mode prompt section"), and the ACP feature matrix records session modes as a known gap both reference adapters ship. Neither says where the mode STATE lives, how it survives resume and fork, or how its model-visible consequences stay honest with the session log.

Every shipped plan mode decomposes into the same five parts — a low-authority tool policy, a plan artifact, an approval moment, an execution-state switch, and durable state (Prior art carries the survey). Four of the five already exist here as gated infrastructure: what the model is TOLD it can do is shaped per step at system-prompt/assemble and whatever ships is logged as request/header* events (reconstructability); what can RUN is gated at tools/pre-execute with typed decisions (interception seams); the approval moment is a human answer over the user-interaction seam (ctx.userInteraction, the ask-user precedent); durable per-agent facts are SessionEventMap members (the todo/write precedent). The missing fifth is the mode itself: a named, durable, per-agent policy state the policy listeners can read.

Decision

The deliverable is plan mode. It ships as the first session mode — a named, logged, per-agent policy state: mode definitions — which tools stay visible, what guidance section renders — are deployment config, and the mode IN FORCE for an agent is session state, folded from its log. One new product package, @deepseek-ai/dsh-mode at packages/mode/mode/ (a new top-level group, the packages/approval/ shape), owns the event vocabulary, a thin ctx.modes service, and every policy listener; the loop does not change. plan is the only shipped definition — the mode-shaped vocabulary exists so a second mode never renames durable event types, not because more modes ship now.

The state is one SessionEventMap member: mode/set, a log-only, non-surface event carrying { mode: string } with whole-value-replace semantics, plus a pure foldMode(events) that returns the mode in force — the last mode/set, or the default mode when none exists. Because the log is the fact channel, resume, fork, and compaction restore the mode with no extra machinery, and UIs read flips off session/event. The default mode is the absence of policy — no section, no filtering, no gate — so an agent that never sees a mode/set behaves byte-identically to a deployment that never loads dsh-mode, which keeps every existing snapshot golden stable and makes the plugin safe to compose unconditionally.

Enforcement is two layers that cover each other. The soft layer is a system-prompt/assemble listener that filters the tool schemas down to the mode's allowlist and appends the mode's guidance section — every transition therefore surfaces as an attributable request/header event on the next step (a delta when expressible, the full fallback snapshot otherwise), keeping the reconstructability invariant green by construction. The hard layer is a tools/pre-execute listener that denies, deny-by-default against the same allowlist, any call the mode does not permit — so a hallucinated call to a still-registered tool, or a schema re-widened by a foreign assemble listener, still cannot run.

The model leaves plan mode through the exit_plan_mode tool: its single argument is the plan text, which makes the plan a durable log artifact, and the tool conducts the review itself through the user-interaction seam — a question with options and a free-text channel, not a bare permission — so an approval flips the logged mode back to the default, and a rejection becomes the corrective error carrying the user's feedback verbatim, which keeps the model planning with direction. A user flips the mode from any surface through ctx.modes.set(); the flip is applied at the next turn boundary (session events are turn-enclosed) and narrated to the model once, only when the model-visible state actually changed.

High-level API

A plan-mode session end to end

The user switches the session to plan mode — the ACP mode picker or the stdio /mode plan — and from the next turn every request ships the filtered read-only toolset plus the plan-mode guidance section.

The model explores and designs with what remains; if it attempts a write anyway, the gate denies with a reason naming the mode and pointing at exit_plan_mode, and the transcript keeps planning.

When ready, the model calls exit_plan_mode with the plan markdown as its argument; the UI renders the plan as the call card and the review question arrives through the user-interaction channel — approve, or keep planning, with free-text feedback welcome — so what the human reviews is exactly the logged artifact.

On approve, the tool flips the logged mode back to the default: the next step runs with the full toolset and the widening header event in the log, and execution tracking from there is already todo_write's job. On keep-planning, the model receives a corrective error carrying the user's feedback text, revises, and re-presents.

Deployment configuration

Mode definitions are validated plugin Config — per repo convention, changeable from cordis.yml with no code edit. The shipped plan definition works with zero config; overriding it, or adding a mode, is a config entry:

- id: mode
  name: '@deepseek-ai/dsh-mode'
  config:
    modes:
      plan:
        section: |
          You are in plan mode: explore and design, then present the
          plan for approval through exit_plan_mode.
        tools: [read, todo_write, web_search, web_fetch, ask_user_question, structured_output, exit_plan_mode]

plan's shipped default allowlist is the read-only surface (read, todo_write, web_search/web_fetch, ask_user_question, structured_output, exit_plan_mode — the last three are the pure ask/report class) with bash and subagent excluded until the sandbox family can actually confine them — a deployment that accepts the risk widens its own config today. default is reserved (the absence of policy) and rejected as a key; an unknown mode name fails validation loudly at set() time.

In the terminal

The stdio app gains /mode (print the current and available modes) and /mode <name> (switch + banner — a command line, never sent to the model, and reserved even while a question prompt is active: a command is never recorded as an answer). The exit review prompts right in the terminal with no new machinery: it is an ordinary user-interaction question, so it rides the stdio provider's one-prompt-owns-stdin queue that ask_user_question already uses.

Over ACP

The mode PICKER is this package's surface: session/new/session/load advertise availableModes/currentModeId from ctx.modes (consumed opportunistically via ctx.get, the tool-bash pattern), session/set_mode calls set() and notifies current_mode_update optimistically (the pending mode IS the user's selection; the logged mode/set follows at the boundary), and a session/event listener re-notifies on each logged flip that differs from the last sent. The exit tool's review needs no new ACP work at all — it rides the elicitation flow the user-interaction ACP provider already drives, beside the already-streamed plan card. Individual environment knobs — sandbox mode, approval policy, the model — are NOT modes and belong to session/set_config_option (FAQ).

For agent creators

ctx.modes is the whole programmatic surface: list() returns the configured definitions plus the synthetic default entry (for pickers), get(agent) returns the folded mode plus any pending intent, and set(agent, mode) validates the name against list()'s vocabulary and records the boundary-applied intent — default is always a valid target, so exiting a mode is the same call as entering one. A creator seeds a child's initial mode through AgentOptions.mode (AgentOptions is merge-extensible; dsh-mode declares the optional field). There is no live agent/* mirror to subscribe: UIs read mode/set off session/event, per event-domain semantics.

Detailed design

Vocabulary

'mode/set': { mode: string }        // SessionEventMap merge in dsh-mode: log-only, non-surface,
                                    // whole-value replace — the last one in the log wins
DEFAULT_MODE = 'default'            // the fold of a log with no mode/set; reserved, not definable

The payload carries no reason/provenance field: a tool-driven flip sits next to its tool/call in the log and a user flip sits at its turn boundary, so the cause is log-adjacent — the same "narrative fields are derivable" call the reconstructability RFC made for header deltas (the in-flight env/state event carries a source precisely because its drift variant has NO log-adjacent cause — a contrast, not a conflict). Mode names are config-declared vocabulary, not opaque cross-boundary ids, so they stay bare strings (no Branded<B>).

Config and the resolve step

interface ModeDefinition { section: string; tools: string[] }   // prompt text; allowlist of tool NAMES
interface ModeConfig { modes?: Record<string, ModeDefinition> } // plan's built-in definition merged unless overridden
resolveConfig(config): ResolvedModes                            // explicit resolve (the dsh-bash template), fail-loud:
                                                                // 'default' as a key rejected; allowlists may name
                                                                // not-yet-registered tools (registration is dynamic)

The allowlist is deliberately the degenerate form of a future per-tool decision map (allow | deny | ask): execution-phase ask policies (an every-write-asks "guarded" mode) stay deferred until the approval seam grows durable grants (allow_always — its own open question), and the config shape must not need a migration when they arrive.

The fold, the service, and the flush

foldMode(events) is pure (exported for reconstructors and tests); the service tracks it per session with a lazy cursor in a WeakMap<Session, { cursor, mode }> — O(new events) per read, never invalidated, because the log is append-only and mode/set is not a surface node (compaction cannot rewrite it). set(agent, mode) validates the name against list()'s vocabulary — the configured definitions plus the reserved default, which is rejected as a config KEY but always accepted as a set() TARGET (a picker's exit-to-default must be a valid write) — drops a no-op (target equals pending ?? current), and otherwise records the intent in a WeakMap<Session, string> — it cannot append immediately, because every session event is turn-enclosed and an idle agent has no open turn.

A contained session/event listener (defensive patterns: a policy plugin must not kill the feed) flushes the pending intent as a mode/set append on the next turn/start or step/end — both sit outside the step's tool-execution window, so the executions of a step always run under the mode its assembly folded — and, when the flushed mode differs from the fold at the last request/header, appends one coalesced context/message notice in the same frame ("The user switched this session to plan mode."); the user-visible narration cases are enumerated in the FAQ. Seeding rides agent/created: AgentOptions.mode becomes a pending intent, so explicit options beat the logged baseline on create AND resume — the same precedence the call-config seed follows.

The soft layer: a computed section and a post-next() filter

A system-prompt/assemble waterfall listener reads the calling agent's mode (the AssembleContext carries agent) and, in a non-default mode, filters assembly.tools down to the mode's allowlist and appends the mode's guidance section. The loop already renders per step and logs the result: entering or leaving a mode surfaces on the next step as a request/header-delta — or as the full request/header fallback snapshot when the change is inexpressible in the delta encoding (adding exit_plan_mode resorts the canonical tool list, and a pure reordering has no delta form) — so every mode transition is an attributable log fact. The section is static per mode and the plan itself stays in the conversation (messages and tool args, already in context), so a mode does not add per-step prompt churn — re-injecting plan state into every request (Prior art's compaction-survival hack) is unnecessary and would only burn prefix cache.

The guidance section is an ordinary registered section, { name: 'mode:policy', order: 50, text: context => … } — order 50 sits after the persona (0) and before tool guidance (100–199); it resolves to the folded mode's configured text and to '' (dropped at render) for the default mode or an agent-less assembly. The tool filter wraps with prepend: true: it awaits next() and filters the RETURNED assembly's tools, so additions made anywhere inside its wrap — including every append-registered listener's post-next() mutation, regardless of load order — are covered. run_code survives the filter in every mode: under the registry's Code Mode it is the only wire tool (filtering it would strip the model of everything, the exit included), and it is a transport, not a capability — each bridged sub-call re-enters the hard gate individually. Code Mode's soft surface is the tools:sdk section rather than the wire schemas, and section text resolves in assemble's base, so the same wrapper re-renders that section under the mode's visibility rule — the prompt documents exactly the callable bindings, never one the gate would deny. The default mode re-renders it too, hiding only the exit binding: that keeps a default-mode Code Mode assembly byte-identical to a deployment that never loaded dsh-mode (whose registry never saw the tool), instead of advertising a binding that can only error. The filter enforces one rule in every mode: exit_plan_mode is visible IFF the agent's folded mode is plan — which is also what keeps a default-mode assembly byte-identical to a no-dsh-mode deployment even though the tool is always registered. In a non-default mode it additionally intersects with the mode's allowlist.

The hard layer: the gate

The gate denies, with a mode-naming reason that steers the model back to planning, any call outside the mode's allowlist. This layer is not redundant with the filter: ToolRegistry.execute() dispatches any registered tool by name, so a model hallucinating a filtered-out (or MCP-registered) tool would still run it without the gate. Deny-by-default against the allowlist also means the two layers cover each other — a peer assemble listener that re-widens the schema set cannot make the widened tools executable.

tools/pre-execute: no exec.agent → next()          // agent-less calls have no session to fold
                   folded mode = default → next()
                   exec.name = run_code → next()    // transport: every bridged sub-call re-enters
                                                    // this gate with the same agent
                   allowlisted → next()             // plan's list includes exit_plan_mode
                   otherwise → deny                 // reason names the mode and points at exit_plan_mode

The gate folds the LOGGED mode only, never the pending intent — enforcement judges by the same state the request's header shipped under. The gate never returns { kind: 'ask' }: the exit review is a question with options and feedback, not a permission, so it lives inside the tool's own execution over the user-interaction seam and the registry's ask vocabulary stays free for genuine permission gating. A call to exit_plan_mode outside plan mode reaches the tool only from the default mode (any other mode's allowlist excludes it), and the tool's own folded-mode recheck rejects it there.

exit_plan_mode

defineTool with one required plan: string argument — the plan is thereby a durable, replayable log artifact riding the ordinary tool/call event. execute rejects an agent-less call (the todo_write precedent), re-checks the folded mode as defense in depth, then conducts the review: one single-select ctx.userInteraction.ask() question — approve, or keep planning — with the free-text channel open for feedback. Approve records the switch back to default as a SILENT boundary-applied pending intent (flushed at this step's end, still in-turn) and returns a short confirmation; the gate therefore stays plan-mode for every remaining call of the SAME assistant response — a same-batch exit_plan_mode + write pair cannot smuggle the write past a request assembled under the plan header — and the next step's assembly restores the full toolset and logs the widening header event. Every other outcome — keep-planning (the user's feedback text carried verbatim), an aborted question, a missing provider — returns the corrective isError that tells the model to revise and re-present, and the mode stays plan.

Its render intent, decided up front: presentCall is a generic card titled by the plan's first heading with the plan markdown as content, plus a generic result card — the review question arrives beside this already-streamed card, so what the human reviews is exactly the logged artifact. The seam is consumed opportunistically (ctx.get('userInteraction')), so dsh-mode composes without it and degrades to the manual exit pinned in the FAQ.

Dependencies and surfaces

dsh-mode is one product package, not a capability-seam trio (Alternatives considered): it peers on cordis, dsh-session, dsh-agent, dsh-tools, dsh-system-prompt (manifest shape mirrors dsh-tool-todo), injects ['tools', 'systemPrompt'], reads ctx.userInteraction opportunistically at execute time (a type-only peer edge on dsh-user-interaction), and depends on no UI package. Beyond the ctx.modes call surface everything participates through listeners, so dropping the package gracefully removes modes rather than breaking a consumer. The stdio app adds a /mode [name] line-handler branch — the exit review needs nothing there, because the stdio user-interaction provider already owns the prompt queue. The ACP wire mapping is pinned in High-level API; package-wise the bridge takes a type-only peer edge on dsh-mode and reads the service opportunistically, so a bridge without the plugin behaves exactly as today.

The recorded scenario and the harness op

input.json gains one step op, { "op": "setMode", "modeId": "plan" }, driven through the real session/set_mode RPC, and a scripted elicitationAnswers queue (FIFO, consumed by the harness client's elicitation callback — the review question's answer). The plan-mode scenario: initialize → newSession → setMode(plan) → a prompt that explores and attempts a write (denied by the gate, pinned verbatim) → the model presents the plan via exit_plan_mode → a scripted approve → a follow-up prompt that writes for real. Because the mode is set before turn 1, the FIRST request/header snapshot is already in plan shape (filtered tools + section, reason initial) — the widening header event appears at the exit; the scenario pins both, plus the mode/set pair. A sibling plan-mode-reject scenario scripts the keep-planning answer with feedback text and pins the corrective result. Both need a with-key recording session; the deny/reject texts are meanwhile pinned at the unit tier.

The mechanical tail

No new cordis event is declared (mode/set rides session/event; the listeners attach to existing waterfalls), so the events catalog is untouched; regenerated in the same change: the persistence log catalog (mode/set), the services catalog (ctx.modes, JSDoc-complete), the config catalog (ModeConfig), the tool catalog (exit_plan_mode), the producer/consumer map and doc graphs, and the module graph. Repo plumbing: a root tsconfig paths entry, the new group's README plus a packages map row (a new top-level group is the deliberate act that table names), an architecture.md capability-services row for ctx.modes (budget-checked), and the cookbook row upgrade.

Deferred

Each behind its own decision: subagent mode inheritance via a forwarded AgentOptions.mode (the option field itself ships), per-tool ask policies inside mode definitions (an OpenCode-style "bash asks in plan mode"), preset modes beyond plan (read-only, accept-edits), sandbox-backed bash confinement in plan mode, and the idle-record primitive if pending-intent loss proves real.

The recorded snapshot scenarios are landed: plan-mode (the pinned-header arc — plan-shaped initial header, scripted elicitation approve, the boundary-flushed flip and widened fallback header, a real edit) and plan-mode-reject (keep-planning feedback carried verbatim in the corrective isError), beside the keyless modes-advertise wire golden. The gate's deny path stays pinned at the unit tier — the recorded model never calls a filtered tool, which is the behavior the soft layer exists to produce.

FAQ

Behavioral clarifications of the chosen design; rejected designs live in Alternatives considered, accepted costs in Consequences.

When does a user's mode flip take effect? At the next turn boundary: set() records a pending intent, the service flushes it as the first append after the next turn/start, and the loop assembles the prompt after the turn opens and before each step — so step 1 already folds it. A mid-turn flip lands at the next boundary and takes effect on the following step. This is the "applies to subsequent requests" semantics every product in Prior art ships.

When is a mode change narrated to the model? Only when the model-visible state actually changed: the flush compares the flushed mode against the fold at the last request/header and narrates once, coalesced. A net-zero flip sequence (plan then back, all before the boundary) narrates nothing; a tool-driven exit narrates through its own tool result instead; a mode set before the first turn narrates nothing — the section is the state statement. The principle is the in-flight env-state proposal's boundary narration: a silently flipped prompt surface leaves the transcript arguing from a state the header no longer has.

What happens on resume when the config no longer defines the folded mode? One read-path rule closes the gap: a folded mode name the current config no longer defines behaves as the default mode plus one boundary notice naming the dropped definition — never a silent substitute restriction, never a bricked session. set()'s loud validation covers only the write path; a resumed log answers to the config it finds.

What if a deployment composes no user-interaction provider? Plan mode stays safe but manual: ctx.userInteraction.ask() throws NO_PROVIDER (and an absent seam never resolves at all), the tool returns the corrective isError, and the exit degrades to the user toggling modes — never to an unreviewed exit. The mode section tells the model to present its plan through exit_plan_mode — and to ask the user in prose if that fails — so it never thrashes against the gate.

Do subagents inherit the parent's mode? A fork child inherits for free — the parent's mode/set is inside the seeded prefix. A spawn child starts in the default mode unless its creator seeds AgentOptions.mode; automatic forwarding by subagent providers is deferred (Deferred).

Why aren't sandbox mode, approval policy, or the model themselves modes? They are individual environment knobs and belong to ACP's session/set_config_option; the division this proposal pins is picker-to-modes / knobs-to-config-options. The in-flight sandbox branch already ships both knobs as config-option selects and its feature-matrix stance records session modes as deliberately unmodeled — the one overlap between the two stacks; landing the picker supersedes that stance, and whichever side lands second amends the matrix rows. A mode definition may later bundle env facts (applied through ctx.envState where mounted) so a Codex-style preset stays a single mode; fusing approval policy into the mode CONCEPT itself is rejected in Alternatives considered.

Prior art

A survey of shipped plan modes (Claude Code, Cursor, Copilot, OpenCode, Gemini CLI, Cline, Windsurf, Codex) shows the same five parts everywhere — the low-authority tool policy, plan artifact, approval moment, execution-state switch, and durable state that Problem builds on.

The mode surface is a LIST everywhere it is advertised, never a boolean: Claude Code's picker offers plan beside acceptEdits (plus an auto-mode entry into plan), and Codex — whose plan feature itself is /plan — fills its list with its approval presets (read-only / agent / full-access). This is the surface the ACP feature matrix records as the gap, and what sizes the vocabulary as named modes rather than a flag.

The ecosystems that leave modes to convention show the failure shapes to avoid. Pi-style mode extensions fight over a last-wins global active-tool list, enforce "read-only" by prompt text alone (a hallucinated call to a still-registered tool executes), and re-inject plan state into every request to survive compaction. Each hole closes structurally here, but only because the mode is logged session state rather than plugin-private memory: per-agent folded state replaces the contested global list, the hard gate closes the prompt-only hole, and a log-only non-surface event that compaction cannot shadow makes the re-injection hack unnecessary.

Alternatives considered

Permission modes as the concept (the Claude Code shape). One permissionMode fusing approval policy and tool policy. Here those are two axes with two owners: the approval seam owns "who answers this question", modes own "what surface does the model get". ACP models them as related but distinct (a mode may select an approval policy later — a mode definition gains a field, not a merger).

A capability-seam trio. Interface/implementation/consumer fits a swappable backend; a mode's variable parts are config values, not implementations. Splitting would manufacture an empty implementation package — the same "don't split preemptively" call the approval seam and todo/ made.

Loop-owned mode state. Rejected on the standing rule (plugins, not loop changes): every hook the feature needs — assemble, pre-execute, turn boundaries, session events — is already a documented seam, so a loop edit would buy nothing but coupling.

Prompt-only plan mode (no hard gate). The Pi failure shape (Prior art): filtering schemas (or asking nicely) does not stop a dispatch of a still-registered tool. The pre-execute gate is the enforcement layer; the filter is UX and cache hygiene.

Runtime-only mode (UI- or bridge-local, unlogged). Resume and fork would silently drop the mode, and the header deltas a mode causes would have no attributable cause in the log. Logged state is what makes the mode auditable and restorable for free.

Mode flips as context/message via agent.inject(). Reuses an existing turn-enclosure path, but puts policy state into the model transcript — the model does not need to be told twice (the section already tells it), and a log-only fact should not occupy surface.

A plan-file store (.plans/ directory). A second durable home for what the log already carries replayably; a deployment wanting files can add a tool that writes them. One home per fact.

A boolean planMode instead of named modes. Too narrow for the surface the repo already tracks: ACP advertises a mode LIST and the shipped pickers fill it with more than plan (Prior art); generalizing later would rename durable event vocabulary. The string-shaped mechanism costs nothing extra now; only plan ships as a definition.

A tool-policy-stack service (the Pi-critique remedy). A dedicated composition service for tool policies is premature: waterfall listeners compose by construction, and the deny-by-default hard gate makes filter-order races non-exploitable. Formalize only if real conflicts appear.

Exit approval through the approval seam (a { kind: 'ask' } gate decision). The original sketch, natural while the approval seam was the only asking machinery in flight — but it seats a review in a permission chair: the seam's outcome vocabulary is deliberately closed and one-shot (allowed-once/rejected), so a rejection carries no feedback and an approval can never grow options (approve-and-accept-edits). The exit moment is a question, not a permission — the user-interaction seam gives it options plus the free-text channel, and the rejection feedback reaches the model verbatim. The approval seam remains the right seat for genuine permission gates (the sandbox escalation), and the registry's ask vocabulary stays available to deployments that want one there.

Exit by prose or steering instead of a tool. No artifact and no approval moment — the tool's argument IS the reviewable plan, and its review question is what gives the human a structured yes/no attached to the exact transition.

Consequences

What holds now, pinned by the unit, protocol, and snapshot tiers:

• The mode in force is a pure function of the session log: resume and fork restore it with no extra machinery, and a mode/set is followed by the matching request/header event (delta or fallback snapshot) on the next step with the dev invariant green throughout.
• A user-driven flip narrates exactly once at the next boundary and a net-zero flip sequence narrates nothing; a tool-driven exit narrates only through its tool result.
• In the default mode the plugin is invisible: assemblies are byte-identical with and without dsh-mode loaded, and every pre-existing snapshot golden is unchanged.
• In plan mode the filtered schemas and mode section reach both the wire request and the logged header; a call to a registered-but-filtered mutating tool is denied at tools/pre-execute with the mode-naming reason.
• Mode definitions (allowlist, section text) are changeable from cordis.yml with no code edit; an unknown mode name fails validation loudly at set() time.
• exit_plan_mode's approve path flips the mode and restores the full toolset on the next step; the keep-planning path returns the corrective isError carrying the user's feedback and stays in plan mode; the ACP session/set_mode round-trip updates current_mode_update, and the exit review prompts through each surface's user-interaction provider.
• The docs tail shipped with the landing: READMEs, regenerated catalogs (persistence log, config, cordis services, tools), the packages map and architecture rows, and the cookbook row.

The accepted costs: a pending user flip set while idle is lost if the process dies before the next turn (the UI re-applies; the idle-record primitive is the escape hatch if this bites in practice). Every mode transition is a logged header change and therefore a prefix-cache reset at the provider — inherent, visible in per-step usage, and an argument against mode-flapping UIs, not against the design. The mode filter prepends, so only a listener that ALSO prepends after dsh-mode loads can wrap outside it and re-widen filtered schemas — the one shipped instance is the structured runtime's per-spawn final-assembly wrapper, whose structured_output is on the plan allowlist precisely so the filter, that wrapper, and the gate agree; for any future such listener the hard gate keeps a re-widened tool non-executable, and the residual cost is cosmetic (the model sees a tool it cannot use), accepted rather than mechanized. Plan mode's shipped allowlist excludes bash and subagent, which costs real exploration power until the sandbox family and mode inheritance land — a deployment that accepts the risk can widen its own config today. Two in-flight stacks touch the ACP mode surface (this one and the sandbox branch's config options, whose feature-matrix stance records session modes as deliberately unmodeled): the picker-to-modes / knobs-to-config-options division pinned in the FAQ is the contract, and the sandbox branch owes its matrix rows an amendment on merge-down. The ACP spec's draft v2 direction reportedly slates session modes for removal in favor of config options; if that lands, the picker migrates to a config-option select mechanically — the mode state and both enforcement layers are wire-agnostic — accepted.