test(server): require one turn's events to share an identical turn id

Matching only the ordinal let two events of one turn pass with different
nonces. The session matcher binds the nonce from the first id it sees, so
every later id with the same ordinal must be the exact same string.

.github/workflows/desktop-release.yml

@@ -135,32 +135,6 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      # Backport electron-builder#10172 to the pinned build tool only.
-      # Remove this step when app-builder-lib is upgraded to a release containing it.
-      - name: Repair temporary keychain password in signing tool
-        shell: bash
-        run: |
-          node <<'KEYCHAIN_FIX'
-          const fs = require('node:fs');
-          const path = require('node:path');
-          const manifestPath = require.resolve('app-builder-lib/package.json');
-          if (JSON.parse(fs.readFileSync(manifestPath, 'utf8')).version !== '26.8.1') {
-            throw new Error('Reassess/remove the signing backport for the new app-builder-lib version');
-          }
-          const sourcePath = path.join(path.dirname(manifestPath), 'out/codeSign/macCodeSign.js');
-          let source = fs.readFileSync(sourcePath, 'utf8');
-          const replacements = [
-            ['importCerts(keychainFile, certPaths, cscPasswords)', 'importCerts(keychainFile, certPaths, cscPasswords, keychainPassword)'],
-            ['importCerts(keychainFile, paths, keyPasswords)', 'importCerts(keychainFile, paths, keyPasswords, keychainPassword)'],
-            ['["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", password, keychainFile]', '["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", keychainPassword, keychainFile]'],
-          ];
-          for (const [before, after] of replacements) {
-            if (source.split(before).length !== 2) throw new Error('Unexpected signing tool source; refusing to patch');
-            source = source.replace(before, after);
-          }
-          fs.writeFileSync(sourcePath, source);
-          KEYCHAIN_FIX
-
       - name: Set desktop package version from tag
         shell: bash
         run: |

docs/connected-hosts.md

@@ -74,7 +74,10 @@ registrations remain inspectable; a changed destination requires explicit identi
 
 Both daemons advertise `connectedHosts`; the shared link additionally requires `hostMultiplexing`.
 A completes capability and pinned-identity checks on each physical recovery before admitting channels. There is no local fallback. An older daemon continues to serve existing local
-operations; requesting this feature gives update guidance.
+operations; requesting this feature gives update guidance. The registry retries an older destination
+with capped backoff, so it comes online once updated. Self, duplicate, changed-identity, and
+authentication failures stay in `error` until an update changes the connection, `enabled`, or
+`replaceIdentity`, or A restarts.
 
 Disposing a routed API releases its observations and session. It does not remove the saved host or
 affect sibling API scopes. Disposing the origin cascades to its derived scopes. Observations restore

docs/data-model.md

@@ -92,7 +92,6 @@ Each agent is stored as a separate JSON file, grouped by project directory.
 | `lastUserMessageAt`  | `string?` (ISO 8601)                     | Last user message timestamp                                                                                                                                                                                                                                                                                                                                                         |
 | `title`              | `string?`                                | User-visible title                                                                                                                                                                                                                                                                                                                                                                  |
 | `labels`             | `Record<string, string>`                 | Key-value labels (default `{}`). Paseo uses `paseo.parent-agent-id` for parentage and client-scoped `paseo.open-agent-tab.*` labels while managed subagent tabs are open — see [agent-lifecycle.md](./agent-lifecycle.md)                                                                                                                                                           |
-| `metadata`           | `Record<string, JsonValue>`              | Plugin-owned data (default `{}`). Paseo stores and forwards it and never reads a key. Set at creation or through `agent.metadata.update.request`; `null` in a patch removes a key                                                                                                                                                                                                   |
 | `lastStatus`         | `AgentStatus`                            | One of: `"initializing"`, `"idle"`, `"running"`, `"error"`, `"closed"`. `closed` means the record is resumable but has no live provider runtime; archive remains represented separately by `archivedAt`.                                                                                                                                                                            |
 | `lastModeId`         | `string?`                                | Last active mode ID                                                                                                                                                                                                                                                                                                                                                                 |
 | `config`             | `SerializableConfig?`                    | Agent session configuration (see below)                                                                                                                                                                                                                                                                                                                                             |
@@ -479,7 +478,6 @@ Array of workspace records. A workspace is a specific working directory within a
 | `archivedAt`                   | `string \| null` (ISO 8601)                                  | Soft-delete; required nullable                                                                                                                                                                |
 | `autoArchivedChangeRequestUrl` | `string \| null`                                             | Change request whose merged state triggered auto-archive. Restore replaces it with the current merged change request, when present, so repeated snapshots cannot archive the workspace again. |
 | `labels`                       | `string[]?`                                                  | Normalized display names assigned from this host's shared label catalog. Missing means unlabelled.                                                                                            |
-| `metadata`                     | `Record<string, JsonValue>`                                  | Plugin-owned data (default `{}`). Paseo stores and forwards it and never reads a key. Set at creation or through `workspace.metadata.update.request`.                                         |
 | `pinnedAt`                     | `string \| null` (ISO 8601)                                  | Pinned-to-top-of-sidebar timestamp; null means "not pinned"                                                                                                                                   |
 | `untrustedSource`              | `{ kind: "change_request", forge, number, headRepository }?` | Provenance captured when a cross-repository change request creates the workspace. Missing means repository automation is allowed; explicit setup removes the field.                           |
 

docs/plugins.md

@@ -511,21 +511,13 @@ need no change. See [catalogue ownership](providers.md#provider-snapshot-refresh
 `send()` resolves after acceptance. Publish operation completion, prompt disposition, turn state,
 configuration, permissions, persistence, and complete timeline snapshots through `onEvent()`.
 Route messages, structured commands, steering, and command side effects through `session.prompt`.
-A provider's configuration is the opaque `ProviderSessionConfig.providerOptions` object on
-`session.open`. It contains the provider defaults and per-agent overrides merged by the daemon.
+Provider settings are toggle/select data that Paseo renders in the composer. Keep private options in
+the opaque `ProviderSessionConfig.providerOptions` object on `session.open`.
+It contains the provider defaults and per-agent overrides merged by the daemon.
 Validate and apply it inside the provider; core does not know your option shape.
 See [provider options](custom-providers.md#provider-options) for configuration and
 merge semantics.
 
-The provider draws some of those keys in the composer by reporting `controls` and the values it runs
-(`providerOptions`) in `session.config`. A running-agent change arrives as
-`session.configure` with `changes.providerOptions` and follows the same apply-or-throw contract as
-built-in providers ([options flow](providers.md#options-flow)). `PluginAgentSession` in
-`packages/server/src/server/agent/plugin-provider.ts` is that adapter. A provider still reporting
-`settings` is read through `plugin-provider-options.ts`, which turns each setting into a control and
-its value into an option and is sent both shapes in `session.configure`; delete it with
-`COMPAT(plugin-provider-settings)`. The ACP shim still reports `settings`.
-
 Providers add an optional veto to daemon baseline cleanup through the per-session
 [runtime safety query](../public-docs/plugins/providers.md#permit-idle-runtime-cleanup).
 The daemon calls the same `AgentSession.canStopRuntime()` interface for built-ins and plugins;
@@ -644,35 +636,6 @@ Mounted surfaces and command invocations have shorter API lifetimes.
 Keep the client entry synchronous: return its cleanup function immediately and start asynchronous
 work inside it. See the maintained [composer pill example](../plugin-examples/local-plugin/client/main.tsx).
 
-## Contribute composer items
-
-`addComposerItem` mounts a plugin component in the agent, draft and New workspace composers. The
-public contract is the [composer items reference](../public-docs/plugins/reference.md#composer-items).
-
-The composer is two contexts, provided by two owners (`packages/app/src/composer/session.tsx`).
-`Composer` provides `ComposerInput` (prompt and attachments). `AgentControls` and
-`DraftAgentControls` provide `ComposerAgent` (provider, model, mode, thinking, options, metadata and
-their commands). `toPluginComposer` (`packages/app/src/plugins/composer-items/`) joins them into the
-`PluginComposer` an item reads, so a plugin cannot tell which composer a command reaches. Add a
-capability to `ComposerAgent` and both implementations; never branch on `context` in the model.
-
-Plugin `Toggle`, `Select` and `Action`, the thinking select and provider option controls all
-render through `ComposerControl` (`packages/app/src/composer/agent-controls/composer-control.tsx`),
-a toolbar icon or a row in the overflow sheet. Model and mode stay specialized but share its trigger,
-density and overflow. Plugin items count in the density presence in `layout.ts`, so a composer
-condenses to make room for them. A custom component renders wherever its item is placed, and an
-item that renders nothing still counts for density; there is no registration for either.
-
-A command runs against the owner's current state, not the render that built the callback. The
-draft's form (`openAgentForm`) and options (`openDraftOptions`) are plain stores for that reason,
-and `draftComposerAgent` rejects a provider the host does not offer or a model its loaded catalog
-does not list. `ComposerControl` owns the pending state and the error toast for callbacks that
-return a promise.
-
-The overflow sheet's content portals to the app root, away from the composer. Pass
-`useComposerSheetBridge()` as the sheet's `contextBridge`, or `useComposer()` returns nothing and
-the sheet draws no plugin rows.
-
 ## Contribute timeline items
 
 Timeline transformers and renderers are client contributions. The daemon's canonical rows and

docs/providers.md

@@ -30,65 +30,6 @@ at session startup. See [provider configuration](custom-providers.md#provider-op
 for defaults and merge rules, and the [SDK guide](../public-docs/sdk/provider-options.md)
 for native keys and examples.
 
-### Options flow
-
-`options` on the agent snapshot is the only option state. Controls describe how to draw an
-option and read `options`; they hold no value of their own. Any option can be read and set with
-or without a control.
-
-- **Create and resume.** The provider opens with the options it is given and emits nothing about
-  them while opening. `openOptionsPatch` carries every option the session ended up with that
-  differs from what it was given, including a setting nobody asked for (a native default such as
-  Cursor opening with Fast on). It is set before `createSession`/`resumeSession` resolves and the
-  daemon stores it before the agent is published. A reopened agent resumes that state, so a
-  native default the provider later changes does not follow. `options` on the snapshot is what
-  the session opened with, and afterwards it moves only through an apply or an `options_changed`.
-  Editing a provider default in `config.json` affects agents the next time they open.
-- **Live apply.** `applyOptions` receives the keys the patch touches, resolved against the
-  `config.json` defaults. A removal arrives as the default the key falls back to, or `null` when
-  there is none; the provider returns the setting to its own default if it can, or throws to
-  reject. A key the running session cannot apply (one the provider reads only when it opens) is
-  rejected too, so a stored option always describes what runs. Claude reads most options when it
-  starts its query, and replacing a started query would end its background work, so after the
-  first prompt only Fast can change. Codex fixes its approval policy and sandbox when the thread
-  starts, so it applies only `service_tier` and `plan_mode` live. A session with no
-  `applyOptions` rejects every patch; the daemon enforces this. The provider returns the options
-  it ended up with when they differ from the request. The daemon
-  stores the patch and that result in one step after the call resolves, onto the agent's options
-  as they are at that moment, so the last write wins. Throwing rejects the whole patch and
-  none of it is stored. Emit nothing from inside the call. If the provider's own state moved
-  before it refused, it reports the moved values once as `options_changed` after the call has
-  ended, because the stored options must match what runs.
-- **Old data converts in the agent manager.** Codex used to take `fast_mode`; it takes
-  `service_tier` now. `AgentManager` runs `convertLegacyOptions` (`option-controls.ts`) on an
-  agent's own options when it creates, resumes, imports, reloads or applies to it, and on draft
-  controls, before defaults merge and before anything is stored (`true` is `"fast"`, `false` is
-  `"default"`, and a `service_tier` in the same input wins). The manager converts for the adapter
-  behind the provider id, following `derivedFromProviderId`, so a custom provider with
-  `extends: "codex"` is converted too. Configured defaults convert in the provider registry. A
-  stored record keeps `fast_mode` until the agent is next opened or applied to, and is stored
-  converted from then on. Nothing past the manager sees `fast_mode` for Codex. Codex resolves
-  `"fast"` to the model's Fast tier and reports the id it runs through `openOptionsPatch` or the
-  `applyOptions` result like any other value. The `featureValues` to `options` fold is separate
-  and provider-agnostic; it stays at the protocol and legacy edges.
-- **Clients draw from the daemon's answer.** The app reads `controls` and `options` from the
-  agent snapshot for a running or closed agent. A draft and a profile form send everything they
-  would create with (seed, the provider's last-used control values once the provider has said it
-  still draws them, and the user's edits) in `provider.controls.list.request` and draw only what
-  comes back, so an alias such as a legacy Fast profile's `service_tier: "fast"` is resolved once,
-  by the daemon. A toggle shows over the last answer until its own answer arrives. The draft's
-  layers live in a plain model (`agent-controls/draft-options-model.ts`): applying a profile
-  replaces provider and options in one step, while choosing a provider by hand starts over. A
-  profile saves its stored options plus the form's edits, so options no control draws survive an
-  edit. A daemon without `server_info.features.providerOptionControls` sends `features` and
-  `featureValues`; `packages/client/src/compat/legacy-provider-options.ts` is the one place that
-  turns those into `controls` and `options` and back, so nothing in the app branches on it. A
-  create that carries options first lists the controls for its own provider, model, mode and
-  thinking level, since which options are controls differs by model, and sends those as
-  `featureValues`; callers do not prime anything.
-- **Provider-initiated changes.** A setting the provider changes on its own is an
-  `options_changed` event. The daemon stores and forwards it and does not push the old value back.
-
 Exact MCP preapproval is a separate daemon-owned contract. A new provider must fail
 closed for Hub unattended execution until it can approve one exact injected MCP
 server and tool identity without approving native tools.
@@ -174,7 +115,7 @@ Submitted user-message wire items carry the same Paseo ID in `messageId` and `cl
 
 Provider adapters must terminalize every transient timeline row before emitting the turn's terminal event. Codex may omit the completed `contextCompaction` item when a turn ends during compaction, so its adapter closes any pending root compaction before forwarding `turn_completed`, `turn_failed`, or `turn_canceled`. A terminal turn must never leave the client showing an operation as still loading.
 
-Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.fetchCatalog`, `listCommands`, or `listControls` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs. `fetchCatalog` is the single discovery API for models and modes — provider implementations may use one process, separate upstream calls, or static data internally, but callers outside the provider do not get separate runtime model/mode probes. Draft command listing and scratch-session control listing require an explicit draft model. Do not resolve a default model through catalog discovery. A client-level `listControls` implementation may return controls from an incomplete, model-less draft and owns which features are valid in that state.
+Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.fetchCatalog`, `listCommands`, or `listFeatures` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs. `fetchCatalog` is the single discovery API for models and modes — provider implementations may use one process, separate upstream calls, or static data internally, but callers outside the provider do not get separate runtime model/mode probes. Draft command listing and scratch-session feature listing require an explicit draft model. Do not resolve a default model through catalog discovery. A client-level `listFeatures` implementation may return features from an incomplete, model-less draft and owns which features are valid in that state.
 
 Provider session import has its own contract. The picker calls `listImportableSessions` and receives rows only: provider handle, cwd, title, prompt previews, and last activity. Import calls `importSession({ providerHandleId, cwd })` for the selected row and must not call listing again. The provider returns the resumed session, storage config, persistence handle, and hydrated timeline for that one native session; `AgentManager.importProviderSession` seeds the daemon timeline and publishes the Paseo agent only after it is ready.
 
@@ -537,7 +478,7 @@ interface AgentSession {
   readonly provider: AgentProvider;
   readonly id: string | null;
   readonly capabilities: AgentCapabilityFlags;
-  readonly controls?: AgentOptionControl[];
+  readonly features?: AgentFeature[];
   run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
   startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
   steerActiveTurn?(prompt: AgentPromptInput, options: SteerActiveTurnOptions): Promise<SteerResult>;
@@ -559,7 +500,7 @@ interface AgentSession {
   listCommands?(): Promise<AgentSlashCommand[]>;
   setModel?(modelId: string | null): Promise<void>;
   setThinkingOption?(thinkingOptionId: string | null): Promise<void | AgentProviderNotice>;
-  applyOptions?(options: ProviderOptions): Promise<void>;
+  setFeature?(featureId: string, value: unknown): Promise<void>;
   tryHandleOutOfBand?(prompt: AgentPromptInput): {
     run(ctx: { emit: (event: AgentStreamEvent) => void }): Promise<void>;
   } | null;

nix/desktop-package.nix

@@ -127,7 +127,7 @@ buildNpmPackage {
         # The Nix output is not a distributable DMG, so leave it unsigned and
         # disable the hardened runtime that requires a matching signature.
         CSC_IDENTITY_AUTO_DISCOVERY=false \
-          ../../node_modules/.bin/electron-builder \
+          npm exec --offline -- electron-builder \
             --config electron-builder.yml \
             --dir \
             --mac \

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-CeT2PtYIAFwvBC9LIku8VkTl0pvKxYzSCn0QW2ManfU=
+sha256-KN/AVZV/o0TleLLpmggSrdJqjFDJ/NJYVHiC54xb4jQ=

packages/app/e2e/browser/agent-profile-modeless-preferences.spec.ts

@@ -62,7 +62,7 @@ async function readProviderFeaturePreferences(page: Page, provider: string): Pro
       const raw = localStorage.getItem(preferencesKey);
       if (!raw) return null;
       const preferences = JSON.parse(raw) as FormPreferences;
-      return preferences.providerPreferences?.[providerId]?.options ?? null;
+      return preferences.providerPreferences?.[providerId]?.featureValues ?? null;
     },
     { preferencesKey: CREATE_AGENT_PREFERENCES_KEY, providerId: provider },
   );
@@ -145,7 +145,7 @@ test.describe("Agent profiles repair modeless provider preferences", () => {
         provider: featureProviderId,
         model: featureModelId,
         modeId: "bypassPermissions",
-        options: { fast_mode: true },
+        featureValues: { fast_mode: true },
       },
     ]);
     const provider = await seedModelProvider({
@@ -181,7 +181,7 @@ test.describe("Agent profiles repair modeless provider preferences", () => {
       expect(createAgentRequest).toMatchObject({
         config: {
           provider: featureProviderId,
-          providerOptions: { fast_mode: true },
+          featureValues: { fast_mode: true },
         },
       });
     } finally {

packages/app/e2e/browser/composer-recall.spec.ts

@@ -3,7 +3,7 @@ import {
   composerLocator,
   expectComposerDraft,
   expectComposerVisible,
-  submitMessage,
+  fillComposerDraft,
   typeIntoFocusedComposer,
 } from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
@@ -12,8 +12,14 @@ function userMessages(page: Page) {
   return page.getByTestId("user-message");
 }
 
+async function sendDraftWhenReady(page: Page) {
+  await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeEnabled();
+  await pressInComposer(page, "Enter");
+}
+
 async function sendAndWaitForMessage(page: Page, text: string, expectedCount: number) {
-  await submitMessage(page, text);
+  await fillComposerDraft(page, text);
+  await sendDraftWhenReady(page);
   await expect(userMessages(page)).toHaveCount(expectedCount, { timeout: 30_000 });
   await expectComposerDraft(page, "");
 }
@@ -49,7 +55,7 @@ test.describe("Composer recall", () => {
       await pressInComposer(page, "ArrowUp");
       await expectComposerDraft(page, "add tests for login");
 
-      await pressInComposer(page, "Enter");
+      await sendDraftWhenReady(page);
       await expect(userMessages(page)).toHaveCount(3, { timeout: 30_000 });
       await expect(userMessages(page).last()).toContainText("add tests for login");
     } finally {

packages/app/e2e/browser/plugin-composer-items.spec.ts

@@ -1,12 +0,0 @@
-import { test } from "../support/fixtures";
-import { withComposerControlsExample } from "../support/helpers/plugin-composer-items";
-
-test("a narrow composer's overflow sheet shows a plugin item's row", async ({ page }) => {
-  test.setTimeout(120_000);
-  await withComposerControlsExample(page, async (composer) => {
-    await composer.narrowTheWindow();
-    await composer.openAgentFeatures();
-    await composer.expectFeatureRow("Needs review");
-    await composer.expectFeatureRow("Insert checklist");
-  });
-});

packages/app/e2e/support/helpers/plugin-composer-items.ts

@@ -1,59 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-import { gotoAppShell } from "./app";
-import { openAgentRoute } from "./mock-agent";
-import { connectNewWorkspaceDaemonClient } from "./new-workspace";
-import { copyPluginExample } from "./plugin-fixture";
-import { seedWorkspace } from "./seed-client";
-
-const PLUGIN_ID = "composer-controls-example";
-const NARROW = { width: 500, height: 800 };
-
-/** Runs `run` in an agent's composer with the composer-controls example installed. */
-export async function withComposerControlsExample(
-  page: Page,
-  run: (composer: {
-    narrowTheWindow(): Promise<void>;
-    openAgentFeatures(): Promise<void>;
-    expectFeatureRow(name: string): Promise<void>;
-  }) => Promise<void>,
-) {
-  const workspace = await seedWorkspace({
-    repoPrefix: "composer-items-",
-    title: "Composer items",
-  });
-  const agent = await workspace.client.createAgent({
-    provider: "mock",
-    cwd: workspace.repoPath,
-    workspaceId: workspace.workspaceId,
-    title: "Composer items agent",
-    model: "ten-second-stream",
-    modeId: "load-test",
-  });
-  const client = await connectNewWorkspaceDaemonClient({ ownProjects: false });
-  const previous = await client.getDaemonConfig();
-  const example = await copyPluginExample("composer-controls");
-  try {
-    await client.patchDaemonConfig({ pluginsEnabled: true });
-    await client.installDirectoryPlugin(example.directory);
-    await gotoAppShell(page);
-    await openAgentRoute(page, { workspaceId: workspace.workspaceId, agentId: agent.id });
-    await run({
-      narrowTheWindow: () =>
-        test.step("narrow the window until the composer folds its controls away", () =>
-          page.setViewportSize(NARROW)),
-      openAgentFeatures: () =>
-        test.step("open the agent features sheet", async () => {
-          await page.getByRole("button", { name: "Open agent features", exact: true }).click();
-        }),
-      expectFeatureRow: (name) =>
-        test.step(`the sheet has a row for "${name}"`, () =>
-          expect(page.getByRole("button", { name, exact: true })).toBeVisible()),
-    });
-  } finally {
-    await client.removePlugin(PLUGIN_ID);
-    await client.patchDaemonConfig({ pluginsEnabled: previous.config.pluginsEnabled });
-    await client.close();
-    await example.cleanup();
-    await workspace.cleanup();
-  }
-}

packages/app/src/agent-commands/cache/index.ts

@@ -18,7 +18,7 @@ export interface AgentCommandsDraftConfig {
   modeId?: string;
   model?: string;
   thinkingOptionId?: string;
-  providerOptions?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }
 
 export function normalizeAgentCommandsCwd(cwd: string): string {
@@ -98,7 +98,7 @@ export function draftAgentCommandsQueryKey(input: {
     "thinking",
     draftConfig.thinkingOptionId ?? null,
     "features",
-    draftConfig.providerOptions ?? null,
+    draftConfig.featureValues ?? null,
   ] as const;
 }
 

packages/app/src/agent-controls/draft-options-model.test.ts

@@ -1,149 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AgentOptionControl } from "@getpaseo/protocol/agent-types";
-import { isControlActive } from "./option-controls";
-import {
-  draftControlsRequest,
-  openDraftOptions,
-  ownDraftOptions,
-  viewDraftOptions,
-} from "./draft-options-model";
-
-const SPEED: AgentOptionControl = {
-  type: "select",
-  key: "service_tier",
-  label: "Speed",
-  defaultValue: "default",
-  choices: [
-    { value: "default", label: "Standard" },
-    { value: "priority", label: "Fast" },
-  ],
-};
-const WEB_SEARCH: AgentOptionControl = { type: "toggle", key: "web_search", label: "Web search" };
-
-function answer(
-  provider: string,
-  requestKey: string,
-  options: Record<string, unknown>,
-  controls = [SPEED, WEB_SEARCH],
-) {
-  return { provider, requestKey, controls, options };
-}
-
-describe("draft options model", () => {
-  it("draws a legacy Fast profile as the Fast tier the daemon resolved", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { service_tier: "fast" } });
-    model.applyResolved(answer("codex", "k1", { service_tier: "priority" }));
-
-    const view = viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k1" });
-
-    expect(view?.options).toEqual({ service_tier: "priority" });
-    expect(view && isControlActive(SPEED, view.options)).toBe(true);
-    // The daemon still gets the stored value to resolve, and so does create.
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "fast" });
-  });
-
-  it("applying a profile from another provider keeps its options through the provider change", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", {}));
-
-    model.applyProfile({
-      provider: "codex",
-      options: { sandbox_mode: "read-only", service_tier: "fast" },
-    });
-    // The form follows the profile to its provider.
-    model.observeProvider("codex");
-
-    expect(ownDraftOptions(model.getState())).toEqual({
-      sandbox_mode: "read-only",
-      service_tier: "fast",
-    });
-    expect(model.getState().resolved).toBeNull();
-  });
-
-  it("choosing another provider by hand starts the options over", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { sandbox_mode: "read-only" } });
-    model.setOption("web_search", true);
-
-    model.observeProvider("claude");
-
-    expect(ownDraftOptions(model.getState())).toBeUndefined();
-    expect(model.getState().resolved).toBeNull();
-  });
-
-  it("never pairs a manually chosen provider with the previous provider's options", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", { fast_mode: true }));
-    model.setOption("fast_mode", true);
-    const form = { provider: "claude", cwd: "/repo" };
-    expect(draftControlsRequest(model.getState(), form)).toMatchObject({
-      provider: "claude",
-      providerOptions: { fast_mode: true },
-    });
-
-    // The form shows OpenCode on its next render; the model has not observed it yet.
-    expect(draftControlsRequest(model.getState(), { ...form, provider: "opencode" })).toBeNull();
-
-    model.observeProvider("opencode");
-    const request = draftControlsRequest(model.getState(), { ...form, provider: "opencode" });
-    expect(request).toEqual({ provider: "opencode", cwd: "/repo" });
-  });
-
-  it("keeps a draft's seed when the first provider is chosen", () => {
-    const model = openDraftOptions({ provider: null, seed: { web_search: true } });
-
-    model.observeProvider("claude");
-
-    expect(ownDraftOptions(model.getState())).toEqual({ web_search: true });
-  });
-
-  it("sends a remembered value to the daemon, and draws only what comes back", () => {
-    const model = openDraftOptions({ provider: "codex" });
-    model.setRemembered({ service_tier: "fast", retired: true });
-    // Nothing is known about the provider's controls yet.
-    expect(ownDraftOptions(model.getState())).toBeUndefined();
-
-    model.applyResolved(answer("codex", "k1", { service_tier: "default" }));
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "fast" });
-    // The answer to the first request does not show the remembered value as if it applied.
-    expect(
-      viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k2" })?.options,
-    ).toEqual({ service_tier: "default" });
-
-    model.applyResolved(answer("codex", "k2", { service_tier: "priority" }));
-    expect(
-      viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k2" })?.options,
-    ).toEqual({ service_tier: "priority" });
-  });
-
-  it("does not let a remembered value override the seed", () => {
-    const model = openDraftOptions({ provider: "codex", seed: { service_tier: "default" } });
-    model.applyResolved(answer("codex", "k1", { service_tier: "default" }));
-    model.setRemembered({ service_tier: "fast" });
-
-    expect(ownDraftOptions(model.getState())).toEqual({ service_tier: "default" });
-  });
-
-  it("lays a toggle over the previous answer until the new one arrives", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", { web_search: false }));
-
-    model.setOption("web_search", true);
-
-    expect(
-      viewDraftOptions(model.getState(), { provider: "claude", requestKey: "k2" })?.options,
-    ).toEqual({ web_search: true });
-    model.applyResolved(answer("claude", "k2", { web_search: true }));
-    expect(
-      viewDraftOptions(model.getState(), { provider: "claude", requestKey: "k2" })?.options,
-    ).toEqual({ web_search: true });
-  });
-
-  it("draws nothing for a provider the answer is not for", () => {
-    const model = openDraftOptions({ provider: "claude" });
-    model.applyResolved(answer("claude", "k1", {}));
-
-    expect(viewDraftOptions(model.getState(), { provider: "codex", requestKey: "k1" })).toBe(
-      undefined,
-    );
-  });
-});

packages/app/src/agent-controls/draft-options-model.ts

@@ -1,199 +0,0 @@
-import type {
-  AgentOptionControl,
-  AgentSessionConfig,
-  ProviderOptions,
-} from "@getpaseo/protocol/agent-types";
-
-/**
- * The options of one draft agent, as a plain model (see docs/forms.md). It owns which layers
- * make up the draft's options; the daemon owns what they mean. Every layer is sent to the daemon
- * (`ownDraftOptions`) and the UI draws what comes back (`viewDraftOptions`), so no alias,
- * default or legacy key is resolved here.
- *
- * - `seed`: options the draft started from (a profile, a forked agent).
- * - `remembered`: the provider's last-used control values.
- * - `edits`: toggles made in this draft.
- *
- * An edit of `null` removes the key from every layer, the way a patch does on a running agent, so
- * the provider's default applies again.
- *
- * Choosing a provider by hand starts the options over; applying a profile replaces the provider
- * and the options in one step, so the provider change that follows does not clear them.
- */
-export interface ResolvedDraftOptions {
-  provider: string;
-  /** Names the request that produced this answer; see `viewDraftOptions`. */
-  requestKey: string;
-  controls: AgentOptionControl[];
-  options: ProviderOptions;
-}
-
-export interface DraftOptionsState {
-  provider: string | null;
-  seed: ProviderOptions;
-  remembered: ProviderOptions;
-  edits: ProviderOptions;
-  resolved: ResolvedDraftOptions | null;
-}
-
-export interface DraftOptionsModel {
-  getState: () => DraftOptionsState;
-  subscribe: (listener: () => void) => () => void;
-  /** The provider the draft's form now has. A different one than the model's is a manual choice. */
-  observeProvider: (provider: string | null) => void;
-  applyProfile: (profile: { provider: string; options: ProviderOptions }) => void;
-  setRemembered: (remembered: ProviderOptions) => void;
-  setOption: (key: string, value: unknown) => void;
-  applyResolved: (resolved: ResolvedDraftOptions) => void;
-}
-
-export function openDraftOptions(input: {
-  provider: string | null;
-  seed?: ProviderOptions;
-  /**
-   * The provider the draft's form has now. An edit belongs to it even before the screen has
-   * rendered the change, so `setOption` observes it first.
-   */
-  currentProvider?: () => string | null;
-}): DraftOptionsModel {
-  let state: DraftOptionsState = {
-    provider: input.provider,
-    seed: input.seed ?? {},
-    remembered: {},
-    edits: {},
-    resolved: null,
-  };
-  const listeners = new Set<() => void>();
-
-  function publish(update: (current: DraftOptionsState) => DraftOptionsState): void {
-    const next = update(state);
-    if (next === state) return;
-    state = next;
-    for (const listener of listeners) listener();
-  }
-
-  function observeProvider(provider: string | null): void {
-    publish((current) => {
-      if (provider === current.provider) return current;
-      // The first provider a draft picks does not discard what it was opened with.
-      if (current.provider === null) return { ...current, provider };
-      return { ...current, provider, seed: {}, edits: {}, resolved: null };
-    });
-  }
-
-  return {
-    getState: () => state,
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    observeProvider,
-    applyProfile: (profile) =>
-      publish((current) => ({
-        ...current,
-        provider: profile.provider,
-        seed: profile.options,
-        edits: {},
-        resolved: current.provider === profile.provider ? current.resolved : null,
-      })),
-    setRemembered: (remembered) => publish((current) => ({ ...current, remembered })),
-    setOption: (key, value) => {
-      if (input.currentProvider) observeProvider(input.currentProvider());
-      publish((current) =>
-        Object.is(current.edits[key], value)
-          ? current
-          : { ...current, edits: { ...current.edits, [key]: value } },
-      );
-    },
-    applyResolved: (resolved) => publish((current) => ({ ...current, resolved })),
-  };
-}
-
-/**
- * Everything the draft would create with, for the daemon to resolve. A last-used value applies
- * once the provider has told us it still draws a control for that key, and never over the seed.
- */
-export function ownDraftOptions(state: DraftOptionsState): ProviderOptions | undefined {
-  const controlKeys = new Set((state.resolved?.controls ?? []).map((control) => control.key));
-  const remembered = Object.fromEntries(
-    Object.entries(state.remembered).filter(
-      ([key]) => controlKeys.has(key) && !(key in state.seed),
-    ),
-  );
-  const own = withoutRemovals({ ...state.seed, ...remembered, ...state.edits });
-  return Object.keys(own).length > 0 ? own : undefined;
-}
-
-function withoutRemovals(options: ProviderOptions): ProviderOptions {
-  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== null));
-}
-
-export type DraftControlsRequest = Pick<
-  AgentSessionConfig,
-  "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId" | "providerOptions"
->;
-
-/**
- * The listing request for the draft's form, built from one snapshot of the model. The form
- * reaches a new provider before the model has observed it, and the model still holds the
- * previous provider's options until it does; that render has no request, so a request never
- * pairs one provider with another's options.
- */
-export function draftControlsRequest(
-  state: DraftOptionsState,
-  form: {
-    provider: string | null;
-    cwd: string;
-    modeId?: string | null;
-    modelId?: string | null;
-    thinkingOptionId?: string | null;
-  },
-): DraftControlsRequest | null {
-  if (!form.provider || !form.cwd || form.provider !== state.provider) return null;
-  const providerOptions = ownDraftOptions(state);
-  return {
-    provider: form.provider,
-    cwd: form.cwd,
-    ...(form.modeId ? { modeId: form.modeId } : {}),
-    ...(form.modelId ? { model: form.modelId } : {}),
-    ...(form.thinkingOptionId ? { thinkingOptionId: form.thinkingOptionId } : {}),
-    ...(providerOptions ? { providerOptions } : {}),
-  };
-}
-
-/**
- * What the controls draw: the daemon's answer for this provider. The last answer stays up while
- * a newer request is in flight, with the toggles made since laid over it, so a switch does not
- * wait for the round trip. It never carries a seed or remembered value the daemon has not
- * resolved.
- */
-export function viewDraftOptions(
-  state: DraftOptionsState,
-  current: { provider: string | null; requestKey: string },
-): { controls: AgentOptionControl[]; options: ProviderOptions } | undefined {
-  const { resolved } = state;
-  if (!resolved || resolved.provider !== current.provider) return undefined;
-  return {
-    controls: resolved.controls,
-    options:
-      resolved.requestKey === current.requestKey
-        ? resolved.options
-        : withoutRemovals({ ...resolved.options, ...state.edits }),
-  };
-}
-
-const NO_OPTIONS: ProviderOptions = {};
-
-/**
- * The options the draft will create with, for a plugin or a control to read: the daemon's answer
- * for this provider when there is one, otherwise the draft's own layers, so an edit shows before
- * the daemon has answered.
- */
-export function shownDraftOptions(
-  state: DraftOptionsState,
-  current: { provider: string | null; requestKey: string },
-): ProviderOptions {
-  return viewDraftOptions(state, current)?.options ?? ownDraftOptions(state) ?? NO_OPTIONS;
-}

packages/app/src/agent-controls/icons.test.ts

@@ -1,16 +0,0 @@
-import { Settings2 } from "lucide-react-native";
-import { describe, expect, it } from "vitest";
-import { getAgentFeatureIcon } from "./icons";
-
-describe("getAgentFeatureIcon", () => {
-  it("draws the Lucide icon a plugin provider names", () => {
-    const icon = getAgentFeatureIcon("Mic");
-    expect(icon).not.toBe(Settings2);
-    expect(getAgentFeatureIcon("Mic")).toBe(icon);
-  });
-
-  it("falls back to the generic icon for a missing or unknown name", () => {
-    expect(getAgentFeatureIcon()).toBe(Settings2);
-    expect(getAgentFeatureIcon("not-an-icon")).toBe(Settings2);
-  });
-});

packages/app/src/agent-controls/icons.ts

@@ -13,7 +13,6 @@ import {
   ShieldQuestionMark,
   Zap,
 } from "lucide-react-native";
-import { isLucideIconName, pluginIconComponent } from "@/plugins/icons";
 import { getModeVisuals, type AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 
 export interface AgentControlIconProps {
@@ -61,9 +60,6 @@ export function getAgentModeOptionIcon(
   return icon ? MODE_ICONS[icon] : undefined;
 }
 
-/** A built-in control names its icon in kebab case; a plugin provider names a Lucide icon. */
 export function getAgentFeatureIcon(icon?: string): AgentControlIcon {
-  if (!icon) return Settings2;
-  if (FEATURE_ICONS[icon]) return FEATURE_ICONS[icon];
-  return isLucideIconName(icon) ? pluginIconComponent(icon) : Settings2;
+  return (icon ? FEATURE_ICONS[icon] : undefined) ?? Settings2;
 }

packages/app/src/agent-controls/option-controls.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AgentOptionControl } from "@getpaseo/protocol/agent-types";
-import {
-  getControlTooltip,
-  isControlActive,
-  readSelectOption,
-  readToggleOption,
-} from "./option-controls";
-
-const speed: AgentOptionControl = {
-  type: "select",
-  key: "service_tier",
-  label: "Speed",
-  defaultValue: "default",
-  choices: [
-    { value: "default", label: "Normal" },
-    { value: "priority", label: "Fast" },
-  ],
-};
-const fast: AgentOptionControl = { type: "toggle", key: "fast_mode", label: "Fast" };
-
-describe("option controls", () => {
-  it("reads a select from options and falls back to the control's default", () => {
-    if (speed.type !== "select") throw new Error("select expected");
-    expect(readSelectOption(speed, { service_tier: "priority" })).toBe("priority");
-    expect(readSelectOption(speed, {})).toBe("default");
-    expect(readSelectOption(speed, { service_tier: "unknown-tier" })).toBe("default");
-  });
-
-  it("reads a toggle from options and is off when unset", () => {
-    if (fast.type !== "toggle") throw new Error("toggle expected");
-    expect(readToggleOption(fast, { fast_mode: true })).toBe(true);
-    expect(readToggleOption(fast, {})).toBe(false);
-  });
-
-  it("is active when the option differs from the control's default", () => {
-    expect(isControlActive(speed, { service_tier: "priority" })).toBe(true);
-    expect(isControlActive(speed, { service_tier: "default" })).toBe(false);
-    expect(isControlActive(speed, {})).toBe(false);
-    expect(isControlActive(fast, { fast_mode: true })).toBe(true);
-    expect(isControlActive(fast, {})).toBe(false);
-  });
-
-  it("prefers a control's tooltip over its label", () => {
-    expect(getControlTooltip({ label: "Plan", tooltip: "Toggle plan mode" })).toBe(
-      "Toggle plan mode",
-    );
-    expect(getControlTooltip({ label: "Custom" })).toBe("Custom");
-  });
-});

packages/app/src/agent-controls/option-controls.ts

@@ -1,47 +0,0 @@
-import type {
-  AgentOptionControl,
-  AgentOptionSelectControl,
-  AgentOptionToggleControl,
-  ProviderOptions,
-} from "@getpaseo/protocol/agent-types";
-
-/**
- * The composer's option controls. A control only describes how to draw one option key; the
- * value is read from `options`, which the daemon resolved (defaults, aliases, what runs).
- */
-export interface ComposerOptionControls {
-  controls: AgentOptionControl[];
-  options: ProviderOptions;
-  onSetOption: (key: string, value: unknown) => void;
-}
-
-export function readToggleOption(
-  control: AgentOptionToggleControl,
-  options: ProviderOptions,
-): boolean {
-  const value = options[control.key];
-  return typeof value === "boolean" ? value : (control.defaultValue ?? false);
-}
-
-/** The selected choice's value, or the control's default when the option names no choice. */
-export function readSelectOption(
-  control: AgentOptionSelectControl,
-  options: ProviderOptions,
-): string | null {
-  const value = options[control.key];
-  if (typeof value === "string" && control.choices.some((choice) => choice.value === value)) {
-    return value;
-  }
-  return control.defaultValue ?? null;
-}
-
-/** Whether the option is set to something other than the control's default. */
-export function isControlActive(control: AgentOptionControl, options: ProviderOptions): boolean {
-  if (control.type === "toggle") return readToggleOption(control, options);
-  const value = readSelectOption(control, options);
-  return value !== null && value !== control.defaultValue;
-}
-
-export function getControlTooltip(control: Pick<AgentOptionControl, "label" | "tooltip">): string {
-  return control.tooltip ?? control.label;
-}

packages/app/src/agent-profiles/internal/materialize-profile.test.ts

@@ -23,7 +23,7 @@ describe("materializeAgentProfile", () => {
           model: "claude-opus-5",
           modeId: "plan",
           thinkingOptionId: "think-hard",
-          options: { web_search: true },
+          featureValues: { web_search: true },
         }),
       ),
     ).toEqual({
@@ -31,7 +31,7 @@ describe("materializeAgentProfile", () => {
       modelId: "claude-opus-5",
       modeId: "plan",
       thinkingOptionId: "think-hard",
-      options: { web_search: true },
+      featureValues: { web_search: true },
     });
   });
 
@@ -41,7 +41,7 @@ describe("materializeAgentProfile", () => {
       modelId: "",
       modeId: "",
       thinkingOptionId: "",
-      options: {},
+      featureValues: {},
     });
   });
 
@@ -61,7 +61,7 @@ describe("toAgentConfigApply", () => {
             model: "claude-opus-5",
             modeId: "plan",
             thinkingOptionId: "think-hard",
-            options: { web_search: true },
+            featureValues: { web_search: true },
           }),
         ),
       ),
@@ -69,7 +69,7 @@ describe("toAgentConfigApply", () => {
       modelId: "claude-opus-5",
       modeId: "plan",
       thinkingOptionId: "think-hard",
-      options: { web_search: true },
+      featureValues: { web_search: true },
     });
   });
 
@@ -81,8 +81,8 @@ describe("toAgentConfigApply", () => {
 
   it("omits an empty feature map so the agent keeps its own feature values", () => {
     expect(
-      toAgentConfigApply(materializeAgentProfile(profile({ options: {} }))),
-    ).not.toHaveProperty("options");
+      toAgentConfigApply(materializeAgentProfile(profile({ featureValues: {} }))),
+    ).not.toHaveProperty("featureValues");
   });
 
   it("never carries a provider, which a running agent cannot change", () => {

packages/app/src/agent-profiles/internal/materialize-profile.ts

@@ -12,7 +12,7 @@ export interface MaterializedAgentProfile {
   modelId: string;
   modeId: string;
   thinkingOptionId: string;
-  options: Record<string, unknown>;
+  featureValues: Record<string, unknown>;
 }
 
 function trimmed(value: string | undefined): string {
@@ -25,7 +25,7 @@ export function materializeAgentProfile(profile: AgentProfile): MaterializedAgen
     modelId: trimmed(profile.model),
     modeId: trimmed(profile.modeId),
     thinkingOptionId: trimmed(profile.thinkingOptionId),
-    options: profile.options ?? {},
+    featureValues: profile.featureValues ?? {},
   };
 }
 
@@ -52,6 +52,8 @@ export function toAgentConfigApply(profile: MaterializedAgentProfile): AgentConf
     ...(profile.modelId ? { modelId: profile.modelId } : {}),
     ...(profile.modeId ? { modeId: profile.modeId } : {}),
     ...(profile.thinkingOptionId ? { thinkingOptionId: profile.thinkingOptionId } : {}),
-    ...(Object.keys(profile.options).length > 0 ? { options: profile.options } : {}),
+    ...(Object.keys(profile.featureValues).length > 0
+      ? { featureValues: profile.featureValues }
+      : {}),
   };
 }

packages/app/src/agent-profiles/internal/profile-form-model.test.ts

@@ -1,7 +1,7 @@
 import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
 import { describe, expect, it } from "vitest";
 import {
-  buildControlsRequestKey,
+  buildFeatureRequestKey,
   openAgentProfileForm,
   type AgentProfileFormModel,
 } from "./profile-form-model";
@@ -173,7 +173,7 @@ describe("openAgentProfileForm", () => {
         model: "claude-opus-5",
         modeId: "plan",
         thinkingOptionId: "think-hard",
-        options: { webSearch: true },
+        featureValues: { webSearch: true },
         notes: "Visual work only.",
       },
     });
@@ -229,11 +229,10 @@ describe("openAgentProfileForm", () => {
       selectClaude(model);
       model.setModel("claude-opus-5", { label: "Opus 5" });
       model.setThinking("think-hard", { label: "Think hard" });
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      model.setOption("webSearch", true);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      model.setFeatureValue("webSearch", true);
 
       model.setProvider("codex", { label: "Codex" });
       const state = model.getState();
@@ -243,9 +242,8 @@ describe("openAgentProfileForm", () => {
       expect(state.modelDisplay).toEqual({ label: "GPT-5.2 Codex" });
       expect(state.thinkingOptionId).toBe("");
       expect(state.thinkingDisplay).toBeNull();
-      expect(state.options).toEqual({});
-      expect(state.optionEdits).toEqual({});
-      expect(state.controls).toEqual([]);
+      expect(state.featureValues).toEqual({});
+      expect(state.features).toEqual([]);
       expect(state.name).toBe("Test writer");
     });
 
@@ -336,28 +334,23 @@ describe("openAgentProfileForm", () => {
     });
   });
 
-  const WEB_SEARCH_CONTROLS = {
-    controls: [{ type: "toggle" as const, key: "webSearch", label: "Web search" }],
-    options: { webSearch: false },
-  };
-
-  describe("controls", () => {
-    it("asks for controls per provider/model/mode/thinking combination", () => {
+  describe("features", () => {
+    it("asks for features per provider/model/mode/thinking combination", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
 
-      expect(model.getState().controlsRequest).toEqual({
+      expect(model.getState().featureRequest).toEqual({
         provider: "claude",
         model: "claude-opus-5",
         modeId: "plan",
         thinkingOptionId: "think",
       });
-      const firstKey = model.getState().controlsRequestKey;
+      const firstKey = model.getState().featureRequestKey;
 
       model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
 
-      expect(model.getState().controlsRequestKey).not.toBe(firstKey);
-      expect(model.getState().controlsRequest).toEqual({
+      expect(model.getState().featureRequestKey).not.toBe(firstKey);
+      expect(model.getState().featureRequest).toEqual({
         provider: "claude",
         model: "claude-haiku-4-5",
         modeId: "plan",
@@ -368,168 +361,77 @@ describe("openAgentProfileForm", () => {
     it("moves from pending to complete only for the current request", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
-      const key = model.getState().controlsRequestKey ?? "";
-      expect(model.getState().controlsResolution).toBe("pending");
+      const key = model.getState().featureRequestKey ?? "";
+      expect(model.getState().featureResolution).toBe("pending");
 
-      model.applyControls("stale-key", {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      expect(model.getState().controlsResolution).toBe("pending");
-      expect(model.getState().controls).toEqual([]);
+      model.applyFeatures("stale-key", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      expect(model.getState().featureResolution).toBe("pending");
+      expect(model.getState().features).toEqual([]);
 
-      model.applyControls(key, {
-        controls: [{ type: "toggle", key: "webSearch", label: "Web search" }],
-        options: { webSearch: false },
-      });
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().disclosure.showControlsField).toBe(true);
+      model.applyFeatures(key, [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
+      expect(model.getState().featureResolution).toBe("complete");
+      expect(model.getState().disclosure.showFeaturesField).toBe(true);
     });
 
-    it("reflects a set option back into the rendered controls", () => {
+    it("reflects a set feature value back into the rendered feature", () => {
       const model = openWithCatalog({ mode: "create" });
-      model.setName("Searcher");
       selectClaude(model);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
 
-      model.setOption("webSearch", true);
+      model.setFeatureValue("webSearch", true);
 
-      expect(model.getState().controls[0]).toMatchObject({ key: "webSearch" });
-      expect(model.getState().controlOptions).toEqual({ webSearch: true });
-      expect(model.getState().submitValue?.options).toEqual({ webSearch: true });
+      expect(model.getState().features[0]).toMatchObject({ id: "webSearch", value: true });
+      expect(model.getState().featureValues).toEqual({ webSearch: true });
     });
 
-    it("keeps stored options while the controls are still pending", () => {
-      const model = openAgentProfileForm({
-        mode: "edit",
-        profile: { id: "p1", name: "UI work", provider: "claude", options: { webSearch: true } },
-      });
-      model.applyProviderCatalog(ENTRIES);
-
-      expect(model.getState().controlsResolution).toBe("pending");
-      expect(model.getState().submitValue?.options).toEqual({ webSearch: true });
-    });
-
-    it("keeps options no control draws, so editing a profile does not drop them", () => {
+    it("keeps stored feature values while the feature list is still pending", () => {
       const model = openAgentProfileForm({
         mode: "edit",
         profile: {
           id: "p1",
           name: "UI work",
           provider: "claude",
-          options: { webSearch: true, sandbox_mode: "read-only" },
+          featureValues: { webSearch: true },
         },
       });
       model.applyProviderCatalog(ENTRIES);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
-      model.setOption("webSearch", false);
 
-      expect(model.getState().submitValue?.options).toEqual({
-        webSearch: false,
-        sandbox_mode: "read-only",
-      });
+      expect(model.getState().featureResolution).toBe("pending");
+      expect(model.getState().submitValue?.featureValues).toEqual({ webSearch: true });
     });
 
-    it("draws the options the daemon resolved from the stored ones, then the edits", () => {
-      const model = openAgentProfileForm({
-        mode: "edit",
-        profile: { id: "p1", name: "Fast", provider: "codex", options: { service_tier: "fast" } },
-      });
-      model.applyProviderCatalog(ENTRIES);
-
-      // The request carries the stored options so the daemon can resolve the legacy tier.
-      expect(model.getState().controlsRequest?.providerOptions).toEqual({ service_tier: "fast" });
-
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        controls: [
-          {
-            type: "select",
-            key: "service_tier",
-            label: "Speed",
-            defaultValue: "default",
-            choices: [
-              { value: "default", label: "Standard" },
-              { value: "priority", label: "Fast" },
-            ],
-          },
-        ],
-        options: { service_tier: "priority" },
-      });
-
-      expect(model.getState().controlOptions).toEqual({ service_tier: "priority" });
-      // Nothing was edited, so the stored value is saved as it was.
-      expect(model.getState().submitValue?.options).toEqual({ service_tier: "fast" });
-    });
-
-    it("sends an edit to the daemon with the stored options, and draws the answer", () => {
+    it("prunes stored values the provider no longer reports", () => {
       const model = openAgentProfileForm({
         mode: "edit",
         profile: {
           id: "p1",
-          name: "Fast",
-          provider: "codex",
-          options: { service_tier: "fast", sandbox_mode: "read-only" },
+          name: "UI work",
+          provider: "claude",
+          featureValues: { webSearch: true, retiredFlag: true },
         },
       });
       model.applyProviderCatalog(ENTRIES);
-      const speed = {
-        controls: [
-          {
-            type: "select" as const,
-            key: "service_tier",
-            label: "Speed",
-            defaultValue: "default",
-            choices: [
-              { value: "default", label: "Standard" },
-              { value: "priority", label: "Fast" },
-            ],
-          },
-        ],
-        options: { service_tier: "priority", sandbox_mode: "read-only" },
-      };
-      model.applyControls(model.getState().controlsRequestKey ?? "", speed);
+      model.applyFeatures(model.getState().featureRequestKey ?? "", [
+        { type: "toggle", id: "webSearch", label: "Web search", value: false },
+      ]);
 
-      model.setOption("service_tier", "default");
-
-      // The controls stay up while the daemon answers, with the toggle laid over the last answer.
-      expect(model.getState().controls).toHaveLength(1);
-      expect(model.getState().controlOptions).toMatchObject({ service_tier: "default" });
-      // The request carries everything the profile would save, so the daemon resolves it.
-      expect(model.getState().controlsRequest?.providerOptions).toEqual({
-        service_tier: "default",
-        sandbox_mode: "read-only",
-      });
-      expect(model.getState().controlsResolution).toBe("pending");
-
-      model.applyControls(model.getState().controlsRequestKey ?? "", {
-        ...speed,
-        options: { service_tier: "default", sandbox_mode: "read-only" },
-      });
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().controlOptions).toEqual({
-        service_tier: "default",
-        sandbox_mode: "read-only",
-      });
-    });
-
-    it("draws no controls for the previous model while another model's answer is pending", () => {
-      const model = openWithCatalog({ mode: "create" });
-      selectClaude(model);
-      model.applyControls(model.getState().controlsRequestKey ?? "", WEB_SEARCH_CONTROLS);
-
-      model.setModel("claude-haiku-4-5", { label: "Haiku 4.5" });
-
-      expect(model.getState().controls).toEqual([]);
+      expect(model.getState().featureValues).toEqual({ webSearch: true });
     });
 
     it("resolves an unavailable feature listing without showing the field", () => {
       const model = openWithCatalog({ mode: "create" });
       selectClaude(model);
 
-      model.applyControlsUnavailable(model.getState().controlsRequestKey ?? "");
+      model.applyFeaturesUnavailable(model.getState().featureRequestKey ?? "");
 
-      expect(model.getState().controlsResolution).toBe("complete");
-      expect(model.getState().disclosure.showControlsField).toBe(false);
+      expect(model.getState().featureResolution).toBe("complete");
+      expect(model.getState().disclosure.showFeaturesField).toBe(false);
     });
   });
 
@@ -562,15 +464,15 @@ describe("openAgentProfileForm", () => {
   });
 });
 
-describe("buildControlsRequestKey", () => {
+describe("buildFeatureRequestKey", () => {
   it("is null without a provider", () => {
-    expect(buildControlsRequestKey(null)).toBeNull();
+    expect(buildFeatureRequestKey(null)).toBeNull();
   });
 
   it("separates the fields so a value cannot bleed across positions", () => {
-    expect(buildControlsRequestKey({ provider: "claude", model: "a|b" })).toBe("claude|a|b||");
-    expect(buildControlsRequestKey({ provider: "claude", modeId: "a" })).not.toBe(
-      buildControlsRequestKey({ provider: "claude", model: "a" }),
+    expect(buildFeatureRequestKey({ provider: "claude", model: "a|b" })).toBe("claude|a|b||");
+    expect(buildFeatureRequestKey({ provider: "claude", modeId: "a" })).not.toBe(
+      buildFeatureRequestKey({ provider: "claude", model: "a" }),
     );
   });
 });

packages/app/src/agent-profiles/internal/profile-form-model.ts

@@ -1,6 +1,5 @@
 import type {
-  AgentOptionControl,
-  ProviderOptions,
+  AgentFeature,
   AgentMode,
   AgentModelDefinition,
   AgentSelectOption,
@@ -8,6 +7,7 @@ import type {
 } from "@getpaseo/protocol/agent-types";
 import type { AgentProfile } from "@getpaseo/protocol/messages";
 import { formatAgentModeLabel, formatThinkingOptionLabel } from "@/agent-controls/labels";
+import { applyFeatureValues, pruneFeatureValues } from "@/hooks/feature-preferences";
 import { filterSelectableModels } from "@/provider-selection/model-catalog";
 
 /**
@@ -57,15 +57,11 @@ export interface AgentProfileFormSnapshot {
 }
 
 /**
- * The inputs a controls listing needs. Controls are provider-scoped and change
- * with model/mode/thinking, so every one of those is part of the request. The
- * profile's own options ride along so the daemon can resolve them (a legacy
- * `service_tier: "fast"` is drawn as the model's Fast tier); they are the same
- * for the life of one provider, so they are not part of the key.
+ * The inputs a feature listing needs. Features are provider-scoped and change
+ * with model/mode/thinking, so every one of those is part of the request.
  */
-export interface AgentProfileControlsRequest {
+export interface AgentProfileFeatureRequest {
   provider: string;
-  providerOptions?: ProviderOptions;
   model?: string;
   modeId?: string;
   thinkingOptionId?: string;
@@ -77,7 +73,7 @@ export interface AgentProfileFormDisclosure {
   showModelField: boolean;
   showModeField: boolean;
   showThinkingField: boolean;
-  showControlsField: boolean;
+  showFeaturesField: boolean;
 }
 
 export interface AgentProfileFormState {
@@ -90,18 +86,13 @@ export interface AgentProfileFormState {
   modelId: string;
   modeId: string;
   thinkingOptionId: string;
-  /** The options the profile was opened with, including ones no control draws. */
-  options: ProviderOptions;
-  /** Changes made in this form, over `options`. */
-  optionEdits: ProviderOptions;
+  featureValues: Record<string, unknown>;
 
   providerOptions: AgentProfileFormOption[];
   modelOptions: AgentProfileFormOption[];
   modeOptions: AgentProfileFormOption[];
   thinkingOptions: AgentProfileFormOption[];
-  controls: AgentOptionControl[];
-  /** What the controls show: the options the daemon resolved from `options`, then the edits. */
-  controlOptions: ProviderOptions;
+  features: AgentFeature[];
 
   providerDisplay: AgentProfileFormDisplay | null;
   modelDisplay: AgentProfileFormDisplay | null;
@@ -109,9 +100,9 @@ export interface AgentProfileFormState {
   thinkingDisplay: AgentProfileFormDisplay | null;
 
   catalogResolution: AgentProfileResolutionStatus;
-  controlsResolution: AgentProfileResolutionStatus;
-  controlsRequest: AgentProfileControlsRequest | null;
-  controlsRequestKey: string | null;
+  featureResolution: AgentProfileResolutionStatus;
+  featureRequest: AgentProfileFeatureRequest | null;
+  featureRequestKey: string | null;
 
   disclosure: AgentProfileFormDisclosure;
   isSubmitting: boolean;
@@ -127,12 +118,9 @@ export interface AgentProfileFormModel {
   /** Late input: the host-scoped provider catalog. Never touches selections. */
   applyProviderCatalog: (entries: readonly ProviderSnapshotEntry[]) => void;
   /** Late input: the feature list for one request. Stale keys are ignored. */
-  applyControls: (
-    requestKey: string,
-    resolved: { controls: readonly AgentOptionControl[]; options: ProviderOptions },
-  ) => void;
+  applyFeatures: (requestKey: string, features: readonly AgentFeature[]) => void;
   /** Resolve a request that produced no usable features (provider error). */
-  applyControlsUnavailable: (requestKey: string) => void;
+  applyFeaturesUnavailable: (requestKey: string) => void;
   setName: (value: string) => void;
   setAppearance: (value: { icon: string; color: string }) => void;
   setNotes: (value: string) => void;
@@ -140,7 +128,7 @@ export interface AgentProfileFormModel {
   setModel: (modelId: string, display: AgentProfileFormDisplay | null) => void;
   setMode: (modeId: string, display: AgentProfileFormDisplay | null) => void;
   setThinking: (thinkingOptionId: string, display: AgentProfileFormDisplay | null) => void;
-  setOption: (key: string, value: unknown) => void;
+  setFeatureValue: (featureId: string, value: unknown) => void;
   setSubmitting: (value: boolean) => void;
   setSubmitError: (value: string | null) => void;
 }
@@ -324,29 +312,19 @@ function refineDisplay(
   return current ?? { label: selectedId };
 }
 
-function buildControlsRequest(state: AgentProfileFormState): AgentProfileControlsRequest | null {
+function buildFeatureRequest(state: AgentProfileFormState): AgentProfileFeatureRequest | null {
   if (!state.provider) {
     return null;
   }
-  const ownOptions = ownOptionsOf(state);
   return {
     provider: state.provider,
     ...(state.modelId ? { model: state.modelId } : {}),
     ...(state.modeId ? { modeId: state.modeId } : {}),
     ...(state.thinkingOptionId ? { thinkingOptionId: state.thinkingOptionId } : {}),
-    ...(Object.keys(ownOptions).length > 0 ? { providerOptions: ownOptions } : {}),
   };
 }
 
-/** Everything the profile would save as its options; the daemon resolves them for the form. */
-function ownOptionsOf(
-  state: Pick<AgentProfileFormState, "options" | "optionEdits">,
-): ProviderOptions {
-  return { ...state.options, ...state.optionEdits };
-}
-
-/** The part of a request that decides which controls exist; options only change their values. */
-function buildControlsScopeKey(request: AgentProfileControlsRequest | null): string | null {
+export function buildFeatureRequestKey(request: AgentProfileFeatureRequest | null): string | null {
   if (!request) {
     return null;
   }
@@ -358,25 +336,12 @@ function buildControlsScopeKey(request: AgentProfileControlsRequest | null): str
   ].join("|");
 }
 
-export function buildControlsRequestKey(
-  request: AgentProfileControlsRequest | null,
-): string | null {
-  if (!request) {
-    return null;
-  }
-  const scope = buildControlsScopeKey(request);
-  return request.providerOptions
-    ? `${scope}|${JSON.stringify(Object.entries(request.providerOptions).sort(([a], [b]) => a.localeCompare(b)))}`
-    : scope;
-}
-
 function buildSubmitValue(state: AgentProfileFormState): AgentProfileValue | null {
   const name = state.name.trim();
   const notes = state.notes.trim();
   if (!name || !state.provider) {
     return null;
   }
-  const options = ownOptionsOf(state);
   return {
     name,
     ...(state.icon ? { icon: state.icon } : {}),
@@ -385,16 +350,16 @@ function buildSubmitValue(state: AgentProfileFormState): AgentProfileValue | nul
     ...(state.modelId ? { model: state.modelId } : {}),
     ...(state.modeId ? { modeId: state.modeId } : {}),
     ...(state.thinkingOptionId ? { thinkingOptionId: state.thinkingOptionId } : {}),
-    ...(Object.keys(options).length > 0 ? { options } : {}),
+    ...(Object.keys(state.featureValues).length > 0 ? { featureValues: state.featureValues } : {}),
     ...(notes ? { notes } : {}),
   };
 }
 
-function resolveControlsStatus(
-  controlsRequestKey: string | null,
+function resolveFeatureStatus(
+  featureRequestKey: string | null,
   featuresAreCurrent: boolean,
 ): AgentProfileResolutionStatus {
-  if (controlsRequestKey === null) {
+  if (featureRequestKey === null) {
     return "idle";
   }
   return featuresAreCurrent ? "complete" : "pending";
@@ -427,27 +392,25 @@ function buildInitialState(snapshot: AgentProfileFormSnapshot): AgentProfileForm
     modelId,
     modeId: profile.modeId ?? "",
     thinkingOptionId: profile.thinkingOptionId ?? "",
-    options: { ...profile.options },
-    optionEdits: {},
+    featureValues: { ...profile.featureValues },
     providerOptions: [],
     modelOptions: [],
     modeOptions: [],
     thinkingOptions: [],
-    controls: [],
-    controlOptions: {},
+    features: [],
     providerDisplay: seedDisplay(provider),
     modelDisplay: seedDisplay(modelId),
     modeDisplay: seedDisplay(profile.modeId),
     thinkingDisplay: seedDisplay(profile.thinkingOptionId),
     catalogResolution: "idle",
-    controlsResolution: "idle",
-    controlsRequest: null,
-    controlsRequestKey: null,
+    featureResolution: "idle",
+    featureRequest: null,
+    featureRequestKey: null,
     disclosure: {
       showModelField: false,
       showModeField: false,
       showThinkingField: false,
-      showControlsField: false,
+      showFeaturesField: false,
     },
     isSubmitting: false,
     submitError: null,
@@ -459,10 +422,8 @@ function buildInitialState(snapshot: AgentProfileFormSnapshot): AgentProfileForm
 export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentProfileFormModel {
   let entries: readonly ProviderSnapshotEntry[] = [];
   let catalogResolution: AgentProfileResolutionStatus = "idle";
-  let resolvedControlsKey: string | null = null;
-  let resolvedScopeKey: string | null = null;
-  let resolvedControls: AgentOptionControl[] = [];
-  let resolvedOptions: ProviderOptions = {};
+  let resolvedFeatureKey: string | null = null;
+  let resolvedFeatures: AgentFeature[] = [];
   let listeners = new Set<() => void>();
   let closed = false;
 
@@ -475,23 +436,14 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       modes,
     });
     const thinking = resolveThinkingOptions(entries, next.provider, next.modelId);
-    const controlsRequest = buildControlsRequest(next);
-    const controlsRequestKey = buildControlsRequestKey(controlsRequest);
-    const controlsScopeKey = buildControlsScopeKey(controlsRequest);
+    const featureRequest = buildFeatureRequest(next);
+    const featureRequestKey = buildFeatureRequestKey(featureRequest);
     const featuresAreCurrent =
-      controlsRequestKey !== null && controlsRequestKey === resolvedControlsKey;
-    // A toggle changes only the options, so the controls stay up while the daemon answers and the
-    // toggle shows over the last answer. A change of provider, model, mode or thinking draws none
-    // until its own answer arrives.
-    const controlsApply = controlsScopeKey !== null && controlsScopeKey === resolvedScopeKey;
-    const controls = controlsApply ? resolvedControls : [];
-    let controlOptions: ProviderOptions = next.options;
-    if (controlsApply) {
-      controlOptions = featuresAreCurrent
-        ? resolvedOptions
-        : { ...resolvedOptions, ...next.optionEdits };
-    }
-    const controlsResolution = resolveControlsStatus(controlsRequestKey, featuresAreCurrent);
+      featureRequestKey !== null && featureRequestKey === resolvedFeatureKey;
+    const features = featuresAreCurrent
+      ? applyFeatureValues(resolvedFeatures, next.featureValues)
+      : [];
+    const featureResolution = resolveFeatureStatus(featureRequestKey, featuresAreCurrent);
 
     const withOptions: AgentProfileFormState = {
       ...next,
@@ -499,8 +451,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       modelOptions: buildModelOptions(models),
       modeOptions: buildModeOptions(modes),
       thinkingOptions: buildThinkingOptions(thinking),
-      controls,
-      controlOptions,
+      features,
       providerDisplay: refineDisplay(
         next.providerDisplay,
         next.provider,
@@ -528,9 +479,9 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
         })(),
       ),
       catalogResolution,
-      controlsResolution,
-      controlsRequest,
-      controlsRequestKey,
+      featureResolution,
+      featureRequest,
+      featureRequestKey,
     };
 
     // A field appears once the catalog can populate it, and stays visible while
@@ -541,7 +492,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       showModeField: hasProvider && (modes.length > 0 || Boolean(withOptions.modeId)),
       showThinkingField:
         hasProvider && (thinking.length > 0 || Boolean(withOptions.thinkingOptionId)),
-      showControlsField: hasProvider && controls.length > 0,
+      showFeaturesField: hasProvider && features.length > 0,
     };
     const canSubmit =
       withOptions.name.trim().length > 0 &&
@@ -580,24 +531,23 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       catalogResolution = "complete";
       publish((current) => current);
     },
-    applyControls: (requestKey, resolved) => {
-      if (requestKey !== state.controlsRequestKey) {
+    applyFeatures: (requestKey, features) => {
+      if (requestKey !== state.featureRequestKey) {
         return;
       }
-      resolvedControlsKey = requestKey;
-      resolvedScopeKey = buildControlsScopeKey(state.controlsRequest);
-      resolvedControls = [...resolved.controls];
-      resolvedOptions = resolved.options;
-      publish((current) => current);
+      resolvedFeatureKey = requestKey;
+      resolvedFeatures = [...features];
+      publish((current) => ({
+        ...current,
+        featureValues: pruneFeatureValues(current.featureValues, resolvedFeatures),
+      }));
     },
-    applyControlsUnavailable: (requestKey) => {
-      if (requestKey !== state.controlsRequestKey) {
+    applyFeaturesUnavailable: (requestKey) => {
+      if (requestKey !== state.featureRequestKey) {
         return;
       }
-      resolvedControlsKey = requestKey;
-      resolvedScopeKey = buildControlsScopeKey(state.controlsRequest);
-      resolvedControls = [];
-      resolvedOptions = {};
+      resolvedFeatureKey = requestKey;
+      resolvedFeatures = [];
       publish((current) => current);
     },
     setName: (value) => publish((current) => ({ ...current, name: value })),
@@ -622,8 +572,7 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
           modeDisplay: null,
           thinkingOptionId: "",
           thinkingDisplay: null,
-          options: {},
-          optionEdits: {},
+          featureValues: {},
         };
       }),
     setModel: (modelId, display) =>
@@ -649,10 +598,10 @@ export function openAgentProfileForm(snapshot: AgentProfileFormSnapshot): AgentP
       publish((current) => ({ ...current, modeId, modeDisplay: display })),
     setThinking: (thinkingOptionId, display) =>
       publish((current) => ({ ...current, thinkingOptionId, thinkingDisplay: display })),
-    setOption: (key, value) =>
+    setFeatureValue: (featureId, value) =>
       publish((current) => ({
         ...current,
-        optionEdits: { ...current.optionEdits, [key]: value },
+        featureValues: { ...current.featureValues, [featureId]: value },
       })),
     setSubmitting: (value) => publish((current) => ({ ...current, isSubmitting: value })),
     setSubmitError: (value) => publish((current) => ({ ...current, submitError: value })),

packages/app/src/agent-profiles/internal/profile-summary.ts

@@ -47,7 +47,7 @@ export function buildAgentProfileTags(input: {
     tags.push({ id: "thinking", label: formatThinkingOptionLabel({ id: thinkingOptionId }) });
   }
 
-  const featureCount = Object.keys(input.profile.options ?? {}).length;
+  const featureCount = Object.keys(input.profile.featureValues ?? {}).length;
   if (featureCount > 0) {
     tags.push({ id: "features", label: input.formatFeatureCount(featureCount) });
   }

packages/app/src/agent-profiles/internal/use-agent-profile-picker.ts

@@ -117,7 +117,9 @@ export function useAgentProfilePicker(
           modelId: resolved.modelId,
           modeId: resolved.modeId,
           thinkingOptionId: resolved.thinkingOptionId,
-          ...(Object.keys(resolved.options).length > 0 ? { options: resolved.options } : {}),
+          ...(Object.keys(resolved.featureValues).length > 0
+            ? { featureValues: resolved.featureValues }
+            : {}),
         }),
       ).catch((error) => {
         console.warn("[useAgentProfilePicker] persist profile selection failed", error);

packages/app/src/agent-profiles/internal/use-profile-form-inputs.ts

@@ -27,7 +27,7 @@ export function useAgentProfileFormCatalog(input: {
   }, [entries, input.model]);
 }
 
-export function useAgentProfileFormControls(input: {
+export function useAgentProfileFormFeatures(input: {
   serverId: string;
   model: AgentProfileFormModel;
   state: AgentProfileFormState;
@@ -35,14 +35,14 @@ export function useAgentProfileFormControls(input: {
   const { t } = useTranslation();
   const client = useHostRuntimeClient(input.serverId);
   const isConnected = useHostRuntimeIsConnected(input.serverId);
-  const request = input.state.controlsRequest;
-  const requestKey = input.state.controlsRequestKey;
+  const request = input.state.featureRequest;
+  const requestKey = input.state.featureRequestKey;
 
   // `dataShape: "value"` and not `"list"`: a list shape keeps the previous
   // page's data while the next request is in flight, which would hand the
   // features of one provider/model combination to the key of another.
-  const controlsQuery = useFetchQuery({
-    queryKey: ["agentProfileControls", input.serverId, requestKey],
+  const featuresQuery = useFetchQuery({
+    queryKey: ["agentProfileFeatures", input.serverId, requestKey],
     dataShape: "value",
     staleTimeMs: 5 * 60 * 1000,
     enabled: Boolean(client && isConnected && request),
@@ -51,28 +51,28 @@ export function useAgentProfileFormControls(input: {
       if (!client || !request) {
         throw new Error(t("workspace.terminal.hostDisconnected"));
       }
-      const payload = await client.listProviderControls({ ...request, cwd: HOME_SCOPE_CWD });
+      const payload = await client.listProviderFeatures({ ...request, cwd: HOME_SCOPE_CWD });
       if (payload.error) {
         throw new Error(payload.error);
       }
-      return { controls: payload.controls ?? [], options: payload.options ?? {} };
+      return payload.features ?? [];
     },
   });
 
-  const { data, isError } = controlsQuery;
+  const { data, isError } = featuresQuery;
   const { model } = input;
 
   useEffect(() => {
     if (!requestKey || !data) {
       return;
     }
-    model.applyControls(requestKey, data);
+    model.applyFeatures(requestKey, data);
   }, [data, model, requestKey]);
 
   useEffect(() => {
     if (!requestKey || !isError) {
       return;
     }
-    model.applyControlsUnavailable(requestKey);
+    model.applyFeaturesUnavailable(requestKey);
   }, [isError, model, requestKey]);
 }

packages/app/src/agent-profiles/settings/agent-profile-edit-modal.tsx

@@ -2,8 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState, type ReactElement }
 import { Text, View } from "react-native";
 import { useTranslation } from "react-i18next";
 import { StyleSheet } from "react-native-unistyles";
-import type { AgentOptionControl, ProviderOptions } from "@getpaseo/protocol/agent-types";
-import { readSelectOption, readToggleOption } from "@/agent-controls/option-controls";
+import type { AgentFeature } from "@getpaseo/protocol/agent-types";
 import type { AgentProfile } from "@getpaseo/protocol/messages";
 import { AdaptiveModalSheet, type SheetHeader } from "@/components/adaptive-modal-sheet";
 import { Button } from "@/components/ui/button";
@@ -26,7 +25,7 @@ import type {
 } from "../internal/profile-form-model";
 import {
   useAgentProfileFormCatalog,
-  useAgentProfileFormControls,
+  useAgentProfileFormFeatures,
 } from "../internal/use-profile-form-inputs";
 import {
   useAgentProfileFormModel,
@@ -142,7 +141,7 @@ function OpenAgentProfileEditModal({
   const model = useAgentProfileFormModel(snapshot);
   const state = useAgentProfileFormState(model);
   useAgentProfileFormCatalog({ serverId, model });
-  useAgentProfileFormControls({ serverId, model, state });
+  useAgentProfileFormFeatures({ serverId, model, state });
 
   const sheetHeader = useMemo<SheetHeader>(
     () => ({
@@ -329,17 +328,16 @@ function OpenAgentProfileEditModal({
           />
         ) : null}
 
-        {state.disclosure.showControlsField ? (
+        {state.disclosure.showFeaturesField ? (
           <Field
             label={t("settings.host.agentProfiles.featuresLabel")}
             testID="agent-profile-features-field"
           >
             <View style={styles.featureCard} testID="agent-profile-features-card">
-              {state.controls.map((control, index) => (
-                <AgentProfileControlRow
-                  key={control.key}
-                  control={control}
-                  options={state.controlOptions}
+              {state.features.map((feature, index) => (
+                <AgentProfileFeatureRow
+                  key={feature.id}
+                  feature={feature}
                   isFirst={index === 0}
                   disabled={state.isSubmitting}
                   size={controlSize}
@@ -402,16 +400,14 @@ function OpenAgentProfileEditModal({
   );
 }
 
-function AgentProfileControlRow({
-  control,
-  options,
+function AgentProfileFeatureRow({
+  feature,
   isFirst,
   disabled,
   size,
   model,
 }: {
-  control: AgentOptionControl;
-  options: ProviderOptions;
+  feature: AgentFeature;
   isFirst: boolean;
   disabled: boolean;
   size: FieldControlSize;
@@ -422,75 +418,74 @@ function AgentProfileControlRow({
     [isFirst],
   );
   const handleToggle = useCallback(
-    (value: boolean) => model.setOption(control.key, value),
-    [control.key, model],
+    (value: boolean) => model.setFeatureValue(feature.id, value),
+    [feature.id, model],
   );
   const handleSelect = useCallback(
-    (value: string) => model.setOption(control.key, value),
-    [control.key, model],
+    (value: string) => model.setFeatureValue(feature.id, value),
+    [feature.id, model],
   );
   const selectOptions = useMemo<SelectFieldOption<string>[]>(
     () =>
-      control.type === "select"
-        ? control.choices.map((choice) => ({
-            id: choice.value,
-            value: choice.value,
-            label: choice.label,
-            ...(choice.description ? { description: choice.description } : {}),
-            testID: `agent-profile-feature-option-${control.key}-${choice.value}`,
+      feature.type === "select"
+        ? feature.options.map((option) => ({
+            id: option.id,
+            value: option.id,
+            label: option.label,
+            ...(option.description ? { description: option.description } : {}),
+            testID: `agent-profile-feature-option-${feature.id}-${option.id}`,
           }))
         : [],
-    [control],
+    [feature],
   );
-  const selectedValue = control.type === "select" ? readSelectOption(control, options) : null;
   const selectedDisplay = useMemo<SelectFieldDisplay | null>(() => {
-    if (control.type !== "select" || !selectedValue) {
+    if (feature.type !== "select" || !feature.value) {
       return null;
     }
-    const choice = control.choices.find((candidate) => candidate.value === selectedValue);
-    return { label: choice?.label ?? selectedValue };
-  }, [control, selectedValue]);
+    const option = feature.options.find((candidate) => candidate.id === feature.value);
+    return { label: option?.label ?? feature.value };
+  }, [feature]);
 
-  if (control.type === "select") {
+  if (feature.type === "select") {
     return (
-      <View style={rowStyle} testID={`agent-profile-feature-row-${control.key}`}>
+      <View style={rowStyle} testID={`agent-profile-feature-row-${feature.id}`}>
         <SelectField
-          label={control.label}
-          value={selectedValue}
+          label={feature.label}
+          value={feature.value}
           selectedDisplay={selectedDisplay}
           options={selectOptions}
           onChange={handleSelect}
-          placeholder={control.label}
-          emptyText={control.label}
+          placeholder={feature.label}
+          emptyText={feature.label}
           disabled={disabled}
-          {...(control.description ? { hint: control.description } : {})}
-          title={control.label}
+          {...(feature.description ? { hint: feature.description } : {})}
+          title={feature.label}
           size={size}
-          testID={`agent-profile-feature-field-${control.key}`}
-          triggerTestID={`agent-profile-feature-trigger-${control.key}`}
+          testID={`agent-profile-feature-field-${feature.id}`}
+          triggerTestID={`agent-profile-feature-trigger-${feature.id}`}
         />
       </View>
     );
   }
 
   return (
-    <View style={rowStyle} testID={`agent-profile-feature-row-${control.key}`}>
+    <View style={rowStyle} testID={`agent-profile-feature-row-${feature.id}`}>
       <View style={styles.featureMeta}>
         <Text style={styles.featureLabel} numberOfLines={1}>
-          {control.label}
+          {feature.label}
         </Text>
-        {control.description ? (
+        {feature.description ? (
           <Text style={styles.featureDescription} numberOfLines={2}>
-            {control.description}
+            {feature.description}
           </Text>
         ) : null}
       </View>
       <Switch
-        value={readToggleOption(control, options)}
+        value={feature.value === true}
         onValueChange={handleToggle}
         disabled={disabled}
-        accessibilityLabel={control.label}
-        testID={`agent-profile-feature-switch-${control.key}`}
+        accessibilityLabel={feature.label}
+        testID={`agent-profile-feature-switch-${feature.id}`}
       />
     </View>
   );

packages/app/src/agent-stream/view.tsx

@@ -1304,8 +1304,7 @@ function collectAgentSetupDiffs(left: AgentScreenAgent, right: AgentScreenAgent)
   if (left.runtimeInfo?.thinkingOptionId !== right.runtimeInfo?.thinkingOptionId) {
     reasons.push("agent.runtimeInfo.thinkingOptionId");
   }
-  if (left.options !== right.options) reasons.push("agent.options");
-  if (left.controls !== right.controls) reasons.push("agent.controls");
+  if (left.features !== right.features) reasons.push("agent.features");
   return reasons;
 }
 

packages/app/src/client-slash-commands/index.test.ts

@@ -40,7 +40,16 @@ function createAgent(overrides: Partial<Agent> = {}): Agent {
     cwd: "/repo",
     model: "agent-model",
     thinkingOptionId: "think-hard",
-    options: { "web-search": true, effort: "high" },
+    features: [
+      { type: "toggle", id: "web-search", label: "Web search", value: true },
+      {
+        type: "select",
+        id: "effort",
+        label: "Effort",
+        value: "high",
+        options: [{ id: "high", label: "High" }],
+      },
+    ],
     parentAgentId: null,
     labels: {},
     ...overrides,
@@ -105,7 +114,7 @@ describe("buildDraftAgentSetup", () => {
       modeId: "mode-current",
       model: "agent-model",
       thinkingOptionId: "think-hard",
-      providerOptions: {
+      featureValues: {
         "web-search": true,
         effort: "high",
       },

packages/app/src/client-slash-commands/index.ts

@@ -65,12 +65,17 @@ export function resolveClientSlashCommand(input: {
 }
 
 export function buildDraftAgentSetup(agent: Agent): WorkspaceDraftTabSetup {
+  const featureValues: Record<string, unknown> = {};
+  for (const feature of agent.features ?? []) {
+    featureValues[feature.id] = feature.value;
+  }
+
   return {
     provider: agent.provider,
     cwd: agent.cwd,
     modeId: agent.currentModeId ?? agent.runtimeInfo?.modeId ?? null,
     model: agent.model ?? agent.runtimeInfo?.model ?? null,
     thinkingOptionId: agent.thinkingOptionId ?? agent.runtimeInfo?.thinkingOptionId ?? null,
-    providerOptions: { ...agent.options },
+    featureValues,
   };
 }

packages/app/src/command-center/agent-control-contributions.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, it } from "vitest";
-import type {
-  AgentMode,
-  AgentOptionControl,
-  AgentSelectOption,
-} from "@getpaseo/protocol/agent-types";
+import type { AgentFeature, AgentMode, AgentSelectOption } from "@getpaseo/protocol/agent-types";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import type { CommandCenterContribution } from "./contributions";
 import {
@@ -35,7 +31,7 @@ const ICONS: AgentControlContributionSource["icons"] = {
   thinking: TestIcon,
   planMode: TestIcon,
   mode: () => TestIcon,
-  control: () => TestIcon,
+  feature: () => TestIcon,
 };
 
 function provider(input: {
@@ -69,8 +65,8 @@ function provider(input: {
   };
 }
 
-function toggleControl(key: string, icon?: string): AgentOptionControl {
-  return { type: "toggle", key, label: key, icon };
+function toggleFeature(id: string, value = false, icon?: string): AgentFeature {
+  return { type: "toggle", id, label: id, value, icon };
 }
 
 function makeSource(
@@ -79,7 +75,7 @@ function makeSource(
     models?: Partial<AgentControlContributionSource["models"]>;
     thinking?: Partial<AgentControlContributionSource["thinking"]>;
     modes?: Partial<NonNullable<AgentControlContributionSource["modes"]>>;
-    optionControls?: Partial<AgentControlContributionSource["optionControls"]>;
+    features?: Partial<AgentControlContributionSource["features"]>;
   } = {},
 ): AgentControlContributionSource {
   return {
@@ -108,11 +104,10 @@ function makeSource(
       select: () => undefined,
       ...overrides.modes,
     },
-    optionControls: {
-      controls: [],
-      options: {},
-      onSetOption: () => undefined,
-      ...overrides.optionControls,
+    features: {
+      list: [],
+      set: () => undefined,
+      ...overrides.features,
     },
   };
 }
@@ -138,7 +133,7 @@ describe("Command Center agent-control contributions", () => {
     const contributions = buildAgentControlContributions({
       ...makeSource({
         models: { providers: [provider({ id: "claude", label: "Claude" })] },
-        optionControls: { controls: [toggleControl("plan_mode")], options: { plan_mode: true } },
+        features: { list: [toggleFeature("plan_mode", true)] },
       }),
       modes: undefined,
     });
@@ -328,10 +323,9 @@ describe("Command Center agent-control contributions", () => {
           selectedId: "default",
           defaultModeId: "default",
         },
-        optionControls: {
-          controls: [toggleControl("plan_mode", "list-todo")],
-          options: { plan_mode: true },
-          onSetOption: (id, value) => {
+        features: {
+          list: [toggleFeature("plan_mode", true, "list-todo")],
+          set: (id, value) => {
             calls.push([id, value]);
           },
         },
@@ -347,10 +341,9 @@ describe("Command Center agent-control contributions", () => {
     const calls: [string, unknown][] = [];
     const contributions = buildAgentControlContributions(
       makeSource({
-        optionControls: {
-          controls: [toggleControl("fast_mode", "zap"), toggleControl("auto_accept")],
-          options: { fast_mode: false, auto_accept: true },
-          onSetOption: (id, value) => {
+        features: {
+          list: [toggleFeature("fast_mode", false, "zap"), toggleFeature("auto_accept", true)],
+          set: (id, value) => {
             calls.push([id, value]);
           },
         },
@@ -383,7 +376,7 @@ describe("Command Center agent-control contributions", () => {
           selectedId: "default",
           defaultModeId: "default",
         },
-        optionControls: { controls: [toggleControl("fast_mode")], options: {} },
+        features: { list: [toggleFeature("fast_mode")] },
       }),
     );
     const ranks = new Map<string, number>();

packages/app/src/command-center/agent-control-contributions.ts

@@ -1,10 +1,9 @@
 import type {
+  AgentFeature,
   AgentMode,
-  AgentOptionControl,
   AgentProvider,
   AgentSelectOption,
 } from "@getpaseo/protocol/agent-types";
-import { readToggleOption, type ComposerOptionControls } from "@/agent-controls/option-controls";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import { formatAgentModeLabel, formatThinkingOptionLabel } from "@/agent-controls/labels";
 import {
@@ -62,7 +61,7 @@ export interface AgentControlContributionIcons {
   thinking: CommandCenterIcon;
   planMode: CommandCenterIcon;
   mode(modeId: string): CommandCenterIcon;
-  control(control: AgentOptionControl): CommandCenterIcon;
+  feature(feature: AgentFeature): CommandCenterIcon;
 }
 
 interface CommandCenterChoice {
@@ -106,7 +105,10 @@ export interface AgentControlContributionSource {
     defaultModeId: string | null;
     select(modeId: string): void | Promise<void>;
   };
-  optionControls: ComposerOptionControls;
+  features: {
+    list: readonly AgentFeature[];
+    set(featureId: string, value: unknown): void | Promise<void>;
+  };
 }
 
 function buildContributions(
@@ -240,19 +242,18 @@ function toggleChoices(input: {
 }
 
 function buildPlanModeGroup(source: AgentControlContributionSource): CommandCenterChoiceGroup {
-  const { controls, options, onSetOption } = source.optionControls;
-  const planControl = controls.find(
-    (control) => control.key === PLAN_MODE_FEATURE_ID && control.type === "toggle",
+  const planFeature = source.features.list.find(
+    (feature) => feature.id === PLAN_MODE_FEATURE_ID && feature.type === "toggle",
   );
   let choices: CommandCenterChoice[] = [];
-  if (planControl?.type === "toggle") {
+  if (planFeature?.type === "toggle") {
     choices = toggleChoices({
       source,
       key: "plan",
-      icon: source.icons.control(planControl),
-      isOn: readToggleOption(planControl, options),
-      turnOn: () => onSetOption(PLAN_MODE_FEATURE_ID, true),
-      turnOff: () => onSetOption(PLAN_MODE_FEATURE_ID, false),
+      icon: source.icons.feature(planFeature),
+      isOn: planFeature.value,
+      turnOn: () => source.features.set(PLAN_MODE_FEATURE_ID, true),
+      turnOff: () => source.features.set(PLAN_MODE_FEATURE_ID, false),
     });
   } else if (source.modes) {
     const modes = source.modes;
@@ -279,19 +280,18 @@ function buildPlanModeGroup(source: AgentControlContributionSource): CommandCent
 }
 
 function buildFastModeGroup(source: AgentControlContributionSource): CommandCenterChoiceGroup {
-  const { controls, options, onSetOption } = source.optionControls;
-  const fastControl = controls.find(
-    (control) => control.key === FAST_MODE_FEATURE_ID && control.type === "toggle",
+  const fastFeature = source.features.list.find(
+    (feature) => feature.id === FAST_MODE_FEATURE_ID && feature.type === "toggle",
   );
   const choices =
-    fastControl?.type === "toggle"
+    fastFeature?.type === "toggle"
       ? toggleChoices({
           source,
           key: "fast",
-          icon: source.icons.control(fastControl),
-          isOn: readToggleOption(fastControl, options),
-          turnOn: () => onSetOption(FAST_MODE_FEATURE_ID, true),
-          turnOff: () => onSetOption(FAST_MODE_FEATURE_ID, false),
+          icon: source.icons.feature(fastFeature),
+          isOn: fastFeature.value,
+          turnOn: () => source.features.set(FAST_MODE_FEATURE_ID, true),
+          turnOff: () => source.features.set(FAST_MODE_FEATURE_ID, false),
         })
       : [];
   return {

packages/app/src/command-center/agent-control-registration.tsx

@@ -1,6 +1,11 @@
 import { useMemo } from "react";
 import { useTranslation } from "react-i18next";
-import type { AgentMode, AgentProvider, AgentSelectOption } from "@getpaseo/protocol/agent-types";
+import type {
+  AgentFeature,
+  AgentMode,
+  AgentProvider,
+  AgentSelectOption,
+} from "@getpaseo/protocol/agent-types";
 import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 import {
   getAgentFeatureIcon,
@@ -9,7 +14,6 @@ import {
   ThinkingIcon,
 } from "@/agent-controls/icons";
 import { useProviderIcons } from "@/components/provider-icons";
-import type { ComposerOptionControls } from "@/agent-controls/option-controls";
 import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
 import {
   buildAgentControlContributions,
@@ -40,15 +44,15 @@ export interface AgentControlCommandCenterSource {
     selectedId: string | null | undefined;
     select(modeId: string): void | Promise<void>;
   };
-  /** Absent when the surface cannot change options (the agent has no client). */
-  optionControls: ComposerOptionControls | null;
+  features: {
+    list: readonly AgentFeature[] | undefined;
+    set?: (featureId: string, value: unknown) => void | Promise<void>;
+  };
 }
 
-const NO_OPTION_CONTROLS: ComposerOptionControls = {
-  controls: [],
-  options: {},
-  onSetOption: () => undefined,
-};
+function ignoreAgentFeatureChange(): void {
+  return;
+}
 
 function resolveDefaultModeId(
   provider: string | null | undefined,
@@ -83,7 +87,7 @@ export function useAgentControlCommandCenterActions(input: {
 }): void {
   const { t } = useTranslation();
   const { controls } = input;
-  const { optionControls, models, modes, thinking } = controls;
+  const { features, models, modes, thinking } = controls;
   const getProviderIcon = useProviderIcons(controls.serverId);
   const actions = useMemo(
     () =>
@@ -100,7 +104,7 @@ export function useAgentControlCommandCenterActions(input: {
             getCommandCenterIcon(
               getAgentModeIcon(controls.provider ?? "", modeId, controls.providerDefinitions),
             ),
-          control: (control) => getCommandCenterIcon(getAgentFeatureIcon(control.icon)),
+          feature: (feature) => getCommandCenterIcon(getAgentFeatureIcon(feature.icon)),
         },
         models: {
           providers: models.providers,
@@ -119,7 +123,10 @@ export function useAgentControlCommandCenterActions(input: {
           modes?.select,
           resolveDefaultModeId(controls.provider, controls.providerDefinitions),
         ),
-        optionControls: optionControls ?? NO_OPTION_CONTROLS,
+        features: {
+          list: features.set ? (features.list ?? []) : [],
+          set: features.set ?? ignoreAgentFeatureChange,
+        },
       }),
     [
       getProviderIcon,
@@ -127,7 +134,8 @@ export function useAgentControlCommandCenterActions(input: {
       controls.provider,
       controls.providerDefinitions,
       controls.serverId,
-      optionControls,
+      features.list,
+      features.set,
       models.providers,
       models.select,
       models.selectedModelId,

packages/app/src/composer/agent-controls/composer-control.browser.test.tsx

@@ -1,175 +0,0 @@
-import React from "react";
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { Scan } from "lucide-react-native";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentOptionControl } from "@getpaseo/protocol/agent-types";
-import type { ToastApi } from "@/components/toast-host";
-import { ToastApiProvider } from "@/contexts/toast-api-context";
-import { ComposerControls, type ComposerControlItem } from "./composer-control";
-import { useAgentControlItems } from "./control-items";
-import { resolveComposerControlPresentation } from "./layout";
-
-beforeEach(() => vi.stubGlobal("React", React));
-afterEach(cleanup);
-
-const base = { id: "x", title: "Context", icon: Scan };
-
-type RecordingToast = ToastApi & { error: ReturnType<typeof vi.fn> };
-
-function createToast(): RecordingToast {
-  return { error: vi.fn() } as unknown as RecordingToast;
-}
-
-function ignoreOpenChange() {}
-
-function Controls({
-  items,
-  surface,
-  toast,
-}: {
-  items: ComposerControlItem[];
-  surface: "toolbar" | "sheet";
-  toast: ToastApi;
-}) {
-  return (
-    <ToastApiProvider api={toast}>
-      <ComposerControls
-        items={items}
-        surface={surface}
-        openId={null}
-        onOpenIdChange={ignoreOpenChange}
-      />
-    </ToastApiProvider>
-  );
-}
-
-function renderControls(items: ComposerControlItem[], surface: "toolbar" | "sheet" = "toolbar") {
-  const toast = createToast();
-  render(<Controls items={items} surface={surface} toast={toast} />);
-  return toast;
-}
-
-describe("ComposerControls", () => {
-  it("shows a select's chosen label, or only its icon when asked", () => {
-    const select: ComposerControlItem = {
-      ...base,
-      type: "select",
-      value: "large",
-      choices: [
-        { value: "small", label: "Small" },
-        { value: "large", label: "Large" },
-      ],
-      onChange: () => undefined,
-    };
-    renderControls([select]);
-    expect(screen.getByRole("button", { name: "Context" }).textContent).toContain("Large");
-  });
-
-  it("names the choice on an icon-only select, without drawing it", () => {
-    renderControls([
-      {
-        ...base,
-        type: "select",
-        value: "large",
-        iconOnly: true,
-        choices: [{ value: "large", label: "Large" }],
-        onChange: () => undefined,
-      },
-    ]);
-    const trigger = screen.getByRole("button", { name: "Context: Large" });
-    expect(trigger.textContent).not.toContain("Large");
-  });
-
-  it("flips a toggle on press in the toolbar", () => {
-    const onChange = vi.fn();
-    renderControls([{ ...base, type: "toggle", value: true, onChange }]);
-    fireEvent.click(screen.getByRole("button", { name: "Context" }));
-    expect(onChange).toHaveBeenCalledWith(false);
-  });
-
-  it("lists a toggle as On or Off in the sheet", () => {
-    renderControls([{ ...base, type: "toggle", value: true, onChange: () => undefined }], "sheet");
-    expect(screen.getByRole("button", { name: "Context" }).textContent).toContain("On");
-  });
-
-  it("reports a failed command the way a built-in control does, and frees the control", async () => {
-    let reject: (error: Error) => void = () => undefined;
-    const onPress = vi.fn(
-      () =>
-        new Promise<void>((_resolve, rejectPromise) => {
-          reject = rejectPromise;
-        }),
-    );
-    const toast = renderControls([{ ...base, type: "action", onPress }]);
-    const button = screen.getByRole("button", { name: "Context" });
-
-    fireEvent.click(button);
-    // While the command is in flight the control cannot be pressed again.
-    await waitFor(() => expect(button.getAttribute("aria-disabled")).toBe("true"));
-    fireEvent.click(button);
-    expect(onPress).toHaveBeenCalledTimes(1);
-
-    reject(new Error("Unknown or unavailable provider: x"));
-    await waitFor(() =>
-      expect(toast.error).toHaveBeenCalledWith("Unknown or unavailable provider: x"),
-    );
-    await waitFor(() => expect(button.getAttribute("aria-disabled")).not.toBe("true"));
-  });
-
-  it("reports a command that throws before it returns", () => {
-    const toast = renderControls([
-      {
-        ...base,
-        type: "action",
-        onPress: () => {
-          throw new Error("No such control");
-        },
-      },
-    ]);
-    fireEvent.click(screen.getByRole("button", { name: "Context" }));
-    expect(toast.error).toHaveBeenCalledWith("No such control");
-  });
-});
-
-const FAST_ON = { fast_mode: true };
-
-describe("provider option controls", () => {
-  const fastMode: AgentOptionControl = {
-    type: "toggle",
-    key: "fast_mode",
-    label: "Fast",
-    defaultValue: false,
-  };
-  function OptionControls({
-    options,
-    onSetOption,
-  }: {
-    options: Record<string, unknown>;
-    onSetOption: (key: string, value: unknown) => void;
-  }) {
-    const optionControls = React.useMemo(
-      () => ({ controls: [fastMode], options, onSetOption }),
-      [onSetOption, options],
-    );
-    const items = useAgentControlItems({
-      surface: "toolbar",
-      presentation: resolveComposerControlPresentation("full"),
-      thinking: null,
-      optionControls,
-    });
-    return <Controls items={items.features} surface="toolbar" toast={TOAST} />;
-  }
-  const TOAST = createToast();
-
-  function recordWrites(writes: Array<[string, unknown]>) {
-    return (key: string, value: unknown) => void writes.push([key, value]);
-  }
-
-  it("write the toggled option from the agent's current options", () => {
-    const writes: Array<[string, unknown]> = [];
-    const onSetOption = recordWrites(writes);
-    render(<OptionControls options={FAST_ON} onSetOption={onSetOption} />);
-    fireEvent.click(screen.getByTestId("agent-feature-fast_mode"));
-    expect(writes).toEqual([["fast_mode", false]]);
-  });
-});

packages/app/src/composer/agent-controls/composer-control.tsx

@@ -1,306 +0,0 @@
-import {
-  createContext,
-  useCallback,
-  useContext,
-  useMemo,
-  useRef,
-  useState,
-  type ReactElement,
-} from "react";
-import type { TFunction } from "i18next";
-import { useTranslation } from "react-i18next";
-import { Text, View } from "react-native";
-import { StyleSheet } from "react-native-unistyles";
-import type { AgentControlIcon } from "@/agent-controls/icons";
-import type { SheetHeader } from "@/components/adaptive-modal-sheet";
-import { Combobox, type ComboboxOption } from "@/components/ui/combobox";
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
-import { AgentControlTrigger } from "@/composer/agent-controls/control";
-import { useToast } from "@/contexts/toast-api-context";
-import { toErrorMessage } from "@/utils/error-messages";
-
-interface ComposerControlBase {
-  id: string;
-  title: string;
-  icon: AgentControlIcon;
-  /** Tints the icon; muted when absent. */
-  highlight?: "blue" | "green" | "yellow";
-  /** Defaults to the title, or to "title: choice" on an icon-only select. */
-  tooltip?: string;
-  /** Defaults to the tooltip. */
-  accessibilityLabel?: string;
-  testID?: string;
-}
-
-export interface ComposerControlChoice {
-  value: string;
-  label: string;
-  description?: string;
-}
-
-/**
- * One control in the composer's toolbar, drawn from data. Provider option controls, thinking and
- * plugin controls all come through here, so each is an icon in the toolbar and a row in the sheet.
- */
-export type ComposerControlItem =
-  | (ComposerControlBase & {
-      type: "toggle";
-      value: boolean;
-      onChange: (value: boolean) => void | Promise<void>;
-    })
-  | (ComposerControlBase & {
-      type: "select";
-      value: string | null;
-      choices: readonly ComposerControlChoice[];
-      onChange: (value: string) => void | Promise<void>;
-      /** The toolbar trigger shows only the icon. */
-      iconOnly?: boolean;
-      showCaret?: boolean;
-      searchable?: boolean;
-      desktopMinWidth?: number;
-      renderOption?: (args: {
-        option: ComboboxOption;
-        selected: boolean;
-        active: boolean;
-        onPress: () => void;
-      }) => ReactElement;
-    })
-  | (ComposerControlBase & {
-      type: "action";
-      onPress: () => void | Promise<void>;
-    });
-
-export type ComposerControlSurface = "toolbar" | "sheet";
-
-const ComposerControlSurfaceContext = createContext<ComposerControlSurface>("toolbar");
-export const ComposerControlSurfaceProvider = ComposerControlSurfaceContext.Provider;
-
-/** Where the control being drawn sits: the toolbar, or a row in the overflow sheet. */
-export function useComposerControlSurface(): ComposerControlSurface {
-  return useContext(ComposerControlSurfaceContext);
-}
-
-interface ComposerControlProps {
-  item: ComposerControlItem;
-  surface: ComposerControlSurface;
-  disabled?: boolean;
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  /** Runs after a toolbar toggle or action, so the composer can take focus back. */
-  onActionComplete?: () => void;
-}
-
-interface ControlView {
-  options: ComboboxOption[];
-  /** The list's selected id. */
-  selectedId: string;
-  /** What the trigger shows beside the icon. */
-  value: string;
-  iconOnly: boolean;
-  tooltip: string;
-  /** Whether pressing the trigger opens a list instead of acting. */
-  opensList: boolean;
-}
-
-function describeControl(
-  item: ComposerControlItem,
-  surface: ComposerControlSurface,
-  t: TFunction,
-): ControlView {
-  const isSheet = surface === "sheet";
-  if (item.type === "action") {
-    return {
-      options: [],
-      selectedId: "",
-      value: "",
-      iconOnly: true,
-      tooltip: item.tooltip ?? item.title,
-      opensList: false,
-    };
-  }
-  if (item.type === "toggle") {
-    const label = item.value ? t("agentControls.features.on") : t("agentControls.features.off");
-    return {
-      options: [
-        { id: "true", label: t("agentControls.features.on") },
-        { id: "false", label: t("agentControls.features.off") },
-      ],
-      selectedId: String(item.value),
-      value: label,
-      iconOnly: true,
-      tooltip: item.tooltip ?? item.title,
-      opensList: isSheet,
-    };
-  }
-  const choiceLabel =
-    item.choices.find((choice) => choice.value === item.value)?.label ?? item.title;
-  const iconOnly = item.iconOnly === true;
-  return {
-    options: item.choices.map((choice) => ({
-      id: choice.value,
-      label: choice.label,
-      description: choice.description,
-    })),
-    selectedId: String(item.value ?? ""),
-    value: choiceLabel,
-    iconOnly,
-    tooltip: item.tooltip ?? (iconOnly ? `${item.title}: ${choiceLabel}` : item.title),
-    opensList: true,
-  };
-}
-
-export function ComposerControl({
-  item,
-  surface,
-  disabled = false,
-  open,
-  onOpenChange,
-  onActionComplete,
-}: ComposerControlProps) {
-  const { t } = useTranslation();
-  const anchorRef = useRef<View>(null);
-  const isSheet = surface === "sheet";
-  const sheetHeader = useMemo<SheetHeader>(() => ({ title: item.title }), [item.title]);
-  const view = useMemo(() => describeControl(item, surface, t), [item, surface, t]);
-
-  // A command that returns a promise keeps the control pending until it settles, and a failure
-  // reaches the user the way a built-in live control's does.
-  const toast = useToast();
-  const [pending, setPending] = useState(false);
-  const run = useCallback(
-    (invoke: () => void | Promise<void>) => {
-      try {
-        const result = invoke();
-        if (!result) return;
-        setPending(true);
-        result
-          .catch((error: unknown) => toast.error(toErrorMessage(error)))
-          .finally(() => setPending(false));
-      } catch (error) {
-        toast.error(toErrorMessage(error));
-      }
-    },
-    [toast],
-  );
-  const handlePress = useCallback(() => {
-    if (item.type === "toggle") run(() => item.onChange(!item.value));
-    else if (item.type === "action") run(item.onPress);
-    onActionComplete?.();
-  }, [item, onActionComplete, run]);
-  const handleOpenPress = useCallback(() => onOpenChange(!open), [onOpenChange, open]);
-  const handleSelect = useCallback(
-    (value: string) => {
-      if (item.type === "select") run(() => item.onChange(value));
-      else if (item.type === "toggle") run(() => item.onChange(value === "true"));
-    },
-    [item, run],
-  );
-
-  const select = item.type === "select" ? item : null;
-  const trigger = (
-    <AgentControlTrigger
-      ref={anchorRef}
-      icon={item.icon}
-      iconColor={item.highlight ? styles[item.highlight].color : undefined}
-      surface={surface}
-      label={item.title}
-      value={view.value}
-      showToolbarLabel={!view.iconOnly}
-      showCaret={select?.showCaret === true && !isSheet}
-      open={view.opensList && open}
-      disabled={disabled || pending}
-      onPress={view.opensList ? handleOpenPress : handlePress}
-      accessibilityLabel={item.accessibilityLabel ?? view.tooltip}
-      testID={item.testID}
-    />
-  );
-
-  return (
-    <>
-      {isSheet ? (
-        trigger
-      ) : (
-        <Tooltip delayDuration={0} enabledOnDesktop enabledOnMobile={false}>
-          <TooltipTrigger asChild triggerRefProp="ref">
-            {trigger}
-          </TooltipTrigger>
-          <TooltipContent side="top" align="center" offset={8}>
-            <Text style={styles.tooltipText}>{view.tooltip}</Text>
-          </TooltipContent>
-        </Tooltip>
-      )}
-      {view.opensList ? (
-        <Combobox
-          options={view.options}
-          value={view.selectedId}
-          onSelect={handleSelect}
-          open={open}
-          onOpenChange={onOpenChange}
-          anchorRef={anchorRef}
-          presentation={isSheet ? "push" : undefined}
-          desktopPlacement={isSheet ? undefined : "top-start"}
-          desktopMinWidth={select?.desktopMinWidth}
-          searchable={select ? select.searchable : false}
-          renderOption={select?.renderOption}
-          header={isSheet ? sheetHeader : undefined}
-        />
-      ) : null}
-    </>
-  );
-}
-
-interface ComposerControlsProps {
-  items: readonly ComposerControlItem[];
-  surface: ComposerControlSurface;
-  disabled?: boolean;
-  /** The id of the item whose list is open. */
-  openId: string | null;
-  onOpenIdChange: (id: string | null) => void;
-  onActionComplete?: () => void;
-}
-
-/** A row of Paseo-owned controls that share one open list at a time. */
-export function ComposerControls({
-  items,
-  onOpenIdChange,
-  openId,
-  ...rest
-}: ComposerControlsProps) {
-  return (
-    <>
-      {items.map((item) => (
-        <ComposerControlSlot
-          key={item.id}
-          item={item}
-          open={openId === item.id}
-          onOpenIdChange={onOpenIdChange}
-          {...rest}
-        />
-      ))}
-    </>
-  );
-}
-
-function ComposerControlSlot({
-  item,
-  open,
-  onOpenIdChange,
-  ...rest
-}: Omit<ComposerControlsProps, "items" | "openId"> & { item: ComposerControlItem; open: boolean }) {
-  const handleOpenChange = useCallback(
-    (next: boolean) => onOpenIdChange(next ? item.id : null),
-    [item.id, onOpenIdChange],
-  );
-  return <ComposerControl item={item} open={open} onOpenChange={handleOpenChange} {...rest} />;
-}
-
-const styles = StyleSheet.create((theme) => ({
-  blue: { color: theme.colors.palette.blue[400] },
-  green: { color: theme.colors.palette.green[400] },
-  yellow: { color: theme.colors.palette.yellow[400] },
-  tooltipText: {
-    color: theme.colors.foreground,
-    fontSize: theme.fontSize.base,
-    lineHeight: theme.fontSize.base * 1.4,
-  },
-}));

packages/app/src/composer/agent-controls/control-items.tsx

@@ -1,165 +0,0 @@
-import { useMemo } from "react";
-import type { TFunction } from "i18next";
-import { useTranslation } from "react-i18next";
-import { StyleSheet } from "react-native-unistyles";
-import type { AgentOptionControl, ProviderOptions } from "@getpaseo/protocol/agent-types";
-import { getAgentFeatureIcon, ThinkingIcon } from "@/agent-controls/icons";
-import {
-  getControlTooltip,
-  isControlActive,
-  readSelectOption,
-  readToggleOption,
-  type ComposerOptionControls,
-} from "@/agent-controls/option-controls";
-import { ComboboxItem, type ComboboxOption } from "@/components/ui/combobox";
-import {
-  type ComposerControlItem,
-  type ComposerControlSurface,
-} from "@/composer/agent-controls/composer-control";
-import type { ComposerControlPresentation } from "@/composer/agent-controls/layout";
-import { getAgentControlHintKey, getFeatureHighlightColor } from "@/composer/agent-controls/utils";
-
-const SEARCH_THRESHOLD = 6;
-
-function getFeatureHighlight(
-  control: AgentOptionControl,
-  options: ProviderOptions,
-): ComposerControlItem["highlight"] {
-  if (!isControlActive(control, options)) return undefined;
-  const color = getFeatureHighlightColor(control.key);
-  return color === "default" ? undefined : color;
-}
-
-function toFeatureItem(
-  control: AgentOptionControl,
-  optionControls: ComposerOptionControls,
-): ComposerControlItem {
-  const { options, onSetOption } = optionControls;
-  const base = {
-    id: `feature-${control.key}`,
-    title: control.label,
-    icon: getAgentFeatureIcon(control.icon),
-    highlight: getFeatureHighlight(control, options),
-    testID: `agent-feature-${control.key}`,
-  };
-  if (control.type === "toggle") {
-    return {
-      ...base,
-      type: "toggle",
-      tooltip: getControlTooltip(control),
-      value: readToggleOption(control, options),
-      onChange: (value) => onSetOption(control.key, value),
-    };
-  }
-  const iconOnly = control.desktopTrigger === "icon";
-  return {
-    ...base,
-    type: "select",
-    tooltip: iconOnly ? undefined : getControlTooltip(control),
-    value: readSelectOption(control, options),
-    choices: control.choices,
-    iconOnly,
-    onChange: (value) => onSetOption(control.key, value),
-  };
-}
-
-interface ThinkingControl {
-  options: readonly { id: string; label: string }[];
-  selectedId: string | undefined;
-  onSelect: (id: string) => void;
-  /** The select's displayed label, falling back like the compact model sheet. */
-  displayLabel: string;
-}
-
-/** The thinking select and the option controls, as the data `ComposerControl` draws. */
-export function useAgentControlItems({
-  surface,
-  presentation,
-  thinking,
-  optionControls,
-}: {
-  surface: ComposerControlSurface;
-  presentation: ComposerControlPresentation;
-  thinking: ThinkingControl | null;
-  optionControls: ComposerOptionControls | undefined;
-}): { thinking: ComposerControlItem[]; features: ComposerControlItem[] } {
-  const { t } = useTranslation();
-
-  const thinkingItem = useMemo(
-    () => (thinking ? [toThinkingItem({ thinking, surface, presentation, t })] : []),
-    [presentation, surface, t, thinking],
-  );
-  const features = useMemo(
-    () =>
-      optionControls
-        ? optionControls.controls.map((control) => toFeatureItem(control, optionControls))
-        : [],
-    [optionControls],
-  );
-  return { thinking: thinkingItem, features };
-}
-
-function toThinkingItem({
-  thinking,
-  surface,
-  presentation,
-  t,
-}: {
-  thinking: ThinkingControl;
-  surface: ComposerControlSurface;
-  presentation: ComposerControlPresentation;
-  t: TFunction;
-}): ComposerControlItem {
-  const isSheet = surface === "sheet";
-  return {
-    id: "thinking",
-    type: "select",
-    title: t("agentControls.thinking.title"),
-    icon: ThinkingIcon,
-    tooltip: t(getAgentControlHintKey("thinking")),
-    accessibilityLabel: t("agentControls.thinking.selectWithValue", {
-      value: thinking.displayLabel,
-    }),
-    testID: isSheet ? "agent-controls-thinking" : "agent-thinking-selector",
-    value: thinking.options.some((option) => option.id === thinking.selectedId)
-      ? (thinking.selectedId ?? null)
-      : (thinking.options[0]?.id ?? null),
-    choices: thinking.options.map((option) => ({ value: option.id, label: option.label })),
-    onChange: thinking.onSelect,
-    iconOnly: !presentation.showThinkingLabel,
-    showCaret: presentation.showCarets,
-    searchable: !isSheet && thinking.options.length > SEARCH_THRESHOLD,
-    desktopMinWidth: 200,
-    renderOption: (args) => <ThinkingOption {...args} />,
-  };
-}
-
-function ThinkingOption({
-  option,
-  selected,
-  active,
-  onPress,
-}: {
-  option: ComboboxOption;
-  selected: boolean;
-  active: boolean;
-  onPress: () => void;
-}) {
-  const leadingSlot = useMemo(
-    () => <ThinkingIcon size={16} color={styles.thinkingIcon.color} />,
-    [],
-  );
-  return (
-    <ComboboxItem
-      label={option.label}
-      selected={selected}
-      active={active}
-      onPress={onPress}
-      leadingSlot={leadingSlot}
-    />
-  );
-}
-
-const styles = StyleSheet.create((theme) => ({
-  thinkingIcon: { color: theme.colors.foreground },
-}));

packages/app/src/composer/agent-controls/layout.test.ts

@@ -34,7 +34,6 @@ describe("composer control layout", () => {
       hasThinking: true,
       hasMode: true,
       features: [{ type: "toggle" as const }],
-      pluginItems: 0,
       fontScale: 1,
     };
 
@@ -96,7 +95,6 @@ describe("composer control layout", () => {
           hasThinking: true,
           hasMode: true,
           features: [{ type: "toggle" }],
-          pluginItems: 0,
           fontScale: 1,
         },
       }),
@@ -109,7 +107,6 @@ describe("composer control layout", () => {
           hasThinking: true,
           hasMode: true,
           features: [{ type: "toggle" }, { type: "select", label: "Tools" }],
-          pluginItems: 0,
           fontScale: 1,
         },
       }),
@@ -122,7 +119,6 @@ describe("composer control layout", () => {
           hasThinking: true,
           hasMode: true,
           features: [{ type: "toggle" }],
-          pluginItems: 0,
           fontScale: 1.25,
         },
       }),
@@ -137,7 +133,6 @@ describe("composer control layout", () => {
         hasModel: true,
         hasThinking: true,
         hasMode: true,
-        pluginItems: 0,
         fontScale: 1,
       },
     };
@@ -159,34 +154,6 @@ describe("composer control layout", () => {
     ).toBe("condensed");
   });
 
-  it("condenses to make room for plugin items and keeps them in the overflow", () => {
-    const base = {
-      availableWidth: 430,
-      currentDensity: "full" as const,
-      controls: {
-        hasModel: true,
-        hasThinking: true,
-        hasMode: true,
-        features: [],
-        fontScale: 1,
-      },
-    };
-
-    expect(
-      resolveComposerControlDensity({ ...base, controls: { ...base.controls, pluginItems: 0 } }),
-    ).toBe("full");
-    expect(
-      resolveComposerControlDensity({ ...base, controls: { ...base.controls, pluginItems: 2 } }),
-    ).toBe("condensed");
-    expect(
-      resolveComposerControlDensity({
-        ...base,
-        availableWidth: 250,
-        controls: { ...base.controls, pluginItems: 2 },
-      }),
-    ).toBe("tight");
-  });
-
   it("gives every toolbar control one shell and one platform glyph envelope", () => {
     expect(COMPOSER_TOOLBAR_GEOMETRY).toEqual({
       controlSize: 28,

packages/app/src/composer/agent-controls/layout.ts

@@ -5,8 +5,6 @@ export interface ComposerControlPresence {
   hasThinking: boolean;
   hasMode: boolean;
   features: readonly ComposerFeatureControlPresence[];
-  /** Plugin composer items. Each is budgeted like a select with a short label. */
-  pluginItems: number;
   fontScale: number;
 }
 
@@ -28,7 +26,6 @@ export const COMPOSER_TOOLBAR_GEOMETRY = {
 } as const;
 
 const DENSITY_HYSTERESIS = 12;
-const PLUGIN_ITEM_LABEL = "Plugin item";
 
 function normalizedFontScale(fontScale: number): number {
   return Number.isFinite(fontScale) ? Math.max(1, fontScale) : 1;
@@ -65,9 +62,7 @@ function resolveCondensedFloor(controls: ComposerControlPresence): number {
   if (controls.hasModel) widths.push(36 + 60 * fontScale);
   if (controls.hasThinking) widths.push(COMPOSER_TOOLBAR_GEOMETRY.controlSize);
   if (controls.hasMode) widths.push(36 + 96 * fontScale);
-  if (controls.features.length > 0 || controls.pluginItems > 0) {
-    widths.push(COMPOSER_TOOLBAR_GEOMETRY.controlSize);
-  }
+  if (controls.features.length > 0) widths.push(COMPOSER_TOOLBAR_GEOMETRY.controlSize);
   return sumControlWidths(widths);
 }
 
@@ -80,11 +75,6 @@ function resolveFullFloor(controls: ComposerControlPresence): number {
   for (const feature of controls.features) {
     widths.push(resolveFeatureControlWidth(feature, fontScale));
   }
-  for (let index = 0; index < controls.pluginItems; index++) {
-    widths.push(
-      resolveFeatureControlWidth({ type: "select", label: PLUGIN_ITEM_LABEL }, fontScale),
-    );
-  }
   return sumControlWidths(widths);
 }
 

packages/app/src/composer/agent-controls/mode.test.ts

@@ -25,19 +25,15 @@ describe("resolveAgentControlsMode", () => {
         onSelectMode: () => undefined,
         models: [],
         selectedModel: "",
-        onSelectModel: () => true,
+        onSelectModel: () => undefined,
         isModelLoading: false,
         modelSelectorProviders: [],
         isAllModelsLoading: false,
-        onSelectProviderAndModel: () => true,
-        options: {},
-        onSetOption: () => undefined,
+        onSelectProviderAndModel: () => undefined,
         thinkingOptions: [],
         selectedThinkingOptionId: "",
         onSelectThinkingOption: () => undefined,
         onApplyAgentProfile: () => undefined,
-        metadata: {},
-        onSetMetadata: () => undefined,
       }),
     ).toBe("draft");
   });

packages/app/src/composer/agent-controls/model-sheet.tsx

@@ -5,7 +5,6 @@ import { StyleSheet } from "react-native-unistyles";
 import type { AgentProvider } from "@getpaseo/protocol/agent-types";
 import type { AgentProfilePicker, AgentProfileSeed } from "@/agent-profiles";
 import { AdaptiveModalSheet } from "@/components/adaptive-modal-sheet";
-import type { ContextBridge } from "@/components/ui/isolated-bottom-sheet-modal";
 import { ComboboxTrigger } from "@/components/ui/combobox-trigger";
 import { useProviderIcon } from "@/components/provider-icons";
 import { ModelBrowser, useModelBrowser } from "@/components/model-browser";
@@ -44,8 +43,6 @@ interface CompactModelSheetProps {
   serverId?: string | null;
   glyphSize: number;
   canSwitchProvider: boolean;
-  /** Carries the composer's contexts into the sheets, which draw away from it. */
-  contextBridge?: ContextBridge | null;
   children: ReactNode;
 }
 
@@ -98,7 +95,6 @@ export function CompactModelSheet({
   serverId = null,
   glyphSize,
   canSwitchProvider,
-  contextBridge = null,
   children,
 }: CompactModelSheetProps) {
   const { t } = useTranslation();
@@ -303,7 +299,6 @@ export function CompactModelSheet({
         snapPoints={SNAP_POINTS}
         scrollable={false}
         contentStyle={styles.sheetBody}
-        contextBridge={contextBridge}
         testID="agent-controls-model-sheet"
       >
         <View
@@ -352,7 +347,6 @@ export function CompactModelSheet({
           scrollable={false}
           presentation="push"
           contentStyle={styles.sheetBody}
-          contextBridge={contextBridge}
           testID="agent-controls-model-browser-sheet"
         >
           <View

packages/app/src/composer/agent-controls/sheet-bridge.tsx

@@ -1,43 +0,0 @@
-import { useCallback } from "react";
-import { QueryClientProvider, useQueryClient } from "@tanstack/react-query";
-import type { ContextBridge } from "@/components/ui/isolated-bottom-sheet-modal";
-import { ComposerControlLayoutProvider, useComposerControlLayout } from "./layout-context";
-import {
-  ComposerAgentProvider,
-  ComposerInputProvider,
-  useComposerAgent,
-  useComposerInput,
-} from "@/composer/session";
-import { ToastApiProvider, useToast } from "@/contexts/toast-api-context";
-
-/**
- * A phone's overflow draws in a sheet whose content lands at the app root, away from the
- * composer. This carries across what a control in it reads from the composer: the agent and input
- * a plugin's `useComposer()` sits on, the layout, and the toast and query client the controls use.
- * Call it from inside the composer, outside any sheet.
- */
-export function useComposerSheetBridge(): ContextBridge {
-  const layout = useComposerControlLayout();
-  const agent = useComposerAgent();
-  const input = useComposerInput();
-  const toast = useToast();
-  const queryClient = useQueryClient();
-  return useCallback<ContextBridge>(
-    (content) => (
-      <QueryClientProvider client={queryClient}>
-        <ToastApiProvider api={toast}>
-          <ComposerControlLayoutProvider value={layout}>
-            <ComposerAgentProvider value={agent}>
-              {input ? (
-                <ComposerInputProvider value={input}>{content}</ComposerInputProvider>
-              ) : (
-                content
-              )}
-            </ComposerAgentProvider>
-          </ComposerControlLayoutProvider>
-        </ToastApiProvider>
-      </QueryClientProvider>
-    ),
-    [agent, input, layout, queryClient, toast],
-  );
-}

packages/app/src/composer/agent-controls/utils.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, it } from "vitest";
 import {
   getFeatureHighlightColor,
+  getFeatureTooltip,
   getAgentControlHintKey,
+  isFeatureActive,
   normalizeModelId,
   resolveAgentModelSelection,
 } from "./utils";
@@ -15,12 +17,51 @@ describe("getAgentControlHintKey", () => {
 });
 
 describe("feature metadata helpers", () => {
+  it("prefers explicit feature tooltip copy", () => {
+    expect(
+      getFeatureTooltip({
+        label: "Plan",
+        tooltip: "Toggle plan mode",
+      }),
+    ).toBe("Toggle plan mode");
+  });
+
+  it("falls back to the feature label when no tooltip is provided", () => {
+    expect(
+      getFeatureTooltip({
+        label: "Custom",
+      }),
+    ).toBe("Custom");
+  });
+
   it("maps feature highlight colors by feature id", () => {
     expect(getFeatureHighlightColor("fast_mode")).toBe("yellow");
     expect(getFeatureHighlightColor("service_tier")).toBe("yellow");
     expect(getFeatureHighlightColor("plan_mode")).toBe("blue");
     expect(getFeatureHighlightColor("other")).toBe("default");
   });
+
+  it("treats a select feature as active when a non-default option is selected", () => {
+    const speed = {
+      type: "select" as const,
+      id: "service_tier",
+      label: "Speed",
+      options: [
+        { id: "default", label: "Normal", isDefault: true },
+        { id: "fast", label: "Fast" },
+      ],
+    };
+    expect(isFeatureActive({ ...speed, value: "default" })).toBe(false);
+    expect(isFeatureActive({ ...speed, value: "fast" })).toBe(true);
+    expect(
+      isFeatureActive({
+        type: "toggle",
+        id: "fast_mode",
+        label: "Fast",
+        value: true,
+      }),
+    ).toBe(true);
+  });
 });
 
 describe("normalizeModelId", () => {

packages/app/src/composer/agent-controls/utils.ts

@@ -1,4 +1,4 @@
-import type { AgentModelDefinition } from "@getpaseo/protocol/agent-types";
+import type { AgentFeature, AgentModelDefinition } from "@getpaseo/protocol/agent-types";
 import { i18n } from "@/i18n/i18next";
 import { formatThinkingOptionLabel } from "@/agent-controls/labels";
 import {
@@ -35,6 +35,16 @@ export function normalizeModelId(modelId: string | null | undefined): string | n
   return normalized;
 }
 
+export function getFeatureTooltip(feature: Pick<AgentFeature, "label" | "tooltip">): string {
+  return feature.tooltip ?? feature.label;
+}
+
+export function isFeatureActive(feature: AgentFeature): boolean {
+  if (feature.type === "toggle") return feature.value;
+  const selectedOption = feature.options.find((option) => option.id === feature.value);
+  return selectedOption !== undefined && !selectedOption.isDefault;
+}
+
 export function getFeatureHighlightColor(featureId: string): FeatureHighlightColor {
   switch (featureId) {
     case FAST_MODE_FEATURE_ID:

packages/app/src/composer/draft/composer-agent.test.ts

@@ -1,182 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AgentModelDefinition } from "@getpaseo/protocol/agent-types";
-import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
-import {
-  draftControlsRequest,
-  openDraftOptions,
-  shownDraftOptions,
-} from "@/agent-controls/draft-options-model";
-import { openAgentForm, type AgentFormCatalog } from "@/provider-selection/agent-form-store";
-import { draftComposerAgent } from "./composer-agent";
-
-function definition(id: string, modeId: string): AgentProviderDefinition {
-  return {
-    id,
-    label: id,
-    description: id,
-    defaultModeId: modeId,
-    modes: [{ id: modeId, label: modeId, icon: "ShieldCheck", colorTier: "safe" }],
-  };
-}
-
-function model(provider: string, id: string, isDefault = false): AgentModelDefinition {
-  return { provider, id, label: id, isDefault };
-}
-
-/** The host: two providers with catalogs, and one that is ready but lists no models. */
-const catalog: AgentFormCatalog = {
-  selectableProviders: new Map([
-    ["claude", definition("claude", "default")],
-    ["codex", definition("codex", "auto")],
-    ["opencode", definition("opencode", "build")],
-  ]),
-  models: new Map([
-    ["claude", [model("claude", "sonnet", true)]],
-    ["codex", [model("codex", "gpt-5.4", true), model("codex", "gpt-5.5")]],
-    ["opencode", []],
-  ]),
-  providerPreferences: () => undefined,
-};
-
-/** A draft composer on the real form and options models. */
-function openDraft(context: "draft" | "new-workspace") {
-  const form = openAgentForm(() => catalog);
-  const options = openDraftOptions({
-    provider: null,
-    currentProvider: () => form.getState().form.provider,
-  });
-  // The screen hands the options the provider the form reaches.
-  form.subscribe(() => options.observeProvider(form.getState().form.provider));
-  form.setProviderAndModel("claude", "");
-
-  function agent() {
-    const { form: current } = form.getState();
-    return draftComposerAgent({
-      context,
-      selectedProvider: current.provider,
-      selectedModel: current.model,
-      selectedMode: current.modeId,
-      thinking: current.thinkingOptionId || null,
-      isLocked: () => false,
-      options: shownDraftOptions(options.getState(), {
-        provider: current.provider,
-        requestKey: "",
-      }),
-      metadata: {},
-      onSelectProviderAndModel: form.setProviderAndModel,
-      onSelectModel: form.setModel,
-      onSelectMode: () => undefined,
-      onSelectThinkingOption: () => undefined,
-      onSetOption: options.setOption,
-      onSetMetadata: () => undefined,
-    });
-  }
-
-  /** What the daemon is asked to resolve for the agent this draft would create. */
-  function request() {
-    const { form: current } = form.getState();
-    return draftControlsRequest(options.getState(), {
-      provider: current.provider,
-      cwd: "/repo",
-      modeId: current.modeId,
-      modelId: current.model,
-    });
-  }
-
-  return { form, agent, request };
-}
-
-describe("a draft's options", () => {
-  it("belong to the provider the form has now, before the screen has rendered the change", () => {
-    const form = openAgentForm(() => catalog);
-    const options = openDraftOptions({
-      provider: null,
-      currentProvider: () => form.getState().form.provider,
-    });
-    // No subscription: the screen observes the provider in an effect, after the command ran.
-    form.setProviderAndModel("claude", "");
-    options.observeProvider("claude");
-    options.setOption("context", "1m");
-
-    form.setProviderAndModel("codex", "");
-    options.setOption("effort", "high");
-
-    expect(options.getState()).toMatchObject({ provider: "codex", edits: { effort: "high" } });
-  });
-});
-
-describe.each(["draft", "new-workspace"] as const)("the %s composer's agent", (context) => {
-  it("applies each awaited command before the next one runs", async () => {
-    const draft = openDraft(context);
-    // A plugin keeps the object it was handed across its awaits.
-    const retained = draft.agent();
-
-    await retained.setProvider("codex");
-    await retained.setModel("gpt-5.5");
-    await retained.setOptions({ context: "1m" });
-
-    const agent = draft.agent();
-    expect(agent).toMatchObject({
-      context,
-      provider: "codex",
-      model: "gpt-5.5",
-      options: { context: "1m" },
-    });
-    expect(draft.request()).toMatchObject({
-      provider: "codex",
-      model: "gpt-5.5",
-      providerOptions: { context: "1m" },
-    });
-  });
-
-  it("starts the options over when the provider is chosen by hand", async () => {
-    const draft = openDraft(context);
-    const retained = draft.agent();
-
-    await retained.setOptions({ context: "1m" });
-    expect(draft.agent().options).toEqual({ context: "1m" });
-    await retained.setProvider("codex");
-
-    expect(draft.agent().options).toEqual({});
-  });
-
-  it("creates with the provider's default again once a plugin resets an option", async () => {
-    const draft = openDraft(context);
-    const retained = draft.agent();
-
-    await retained.setOptions({ context: "1m", effort: "high" });
-    await retained.setOptions({ context: null });
-
-    expect(draft.agent().options).toEqual({ effort: "high" });
-    expect(draft.request()?.providerOptions).toEqual({ effort: "high" });
-
-    await retained.setOptions({ effort: null });
-
-    expect(draft.agent().options).toEqual({});
-    expect(draft.request()?.providerOptions).toBeUndefined();
-  });
-
-  it("rejects a provider the host cannot run and a model the catalog does not list", async () => {
-    const draft = openDraft(context);
-    const retained = draft.agent();
-
-    await expect(retained.setProvider("nope")).rejects.toThrow(
-      "Unknown or unavailable provider: nope",
-    );
-    expect(draft.agent().provider).toBe("claude");
-
-    await retained.setProvider("codex");
-    await expect(retained.setModel("missing")).rejects.toThrow("Unknown model: missing");
-    expect(draft.agent()).toMatchObject({ provider: "codex", model: "gpt-5.4" });
-  });
-
-  it("keeps a model id as given when the provider lists no catalog", async () => {
-    const draft = openDraft(context);
-    const retained = draft.agent();
-
-    await retained.setProvider("opencode");
-    await retained.setModel("anthropic/claude-x");
-
-    expect(draft.agent().model).toBe("anthropic/claude-x");
-  });
-});

packages/app/src/composer/draft/composer-agent.ts

@@ -1,52 +0,0 @@
-import type { ComposerAgent } from "@/composer/session";
-import type { DraftAgentControlsProps } from "@/composer/agent-controls";
-
-/**
- * The agent a draft composer creates, as a plugin sees it. Its commands go to the form and the
- * options model, which apply them as they run, so a plugin can `await` one and issue the next.
- */
-export function draftComposerAgent(
-  props: Pick<
-    DraftAgentControlsProps,
-    | "context"
-    | "disabled"
-    | "selectedProvider"
-    | "selectedModel"
-    | "selectedMode"
-    | "options"
-    | "metadata"
-    | "onSelectProviderAndModel"
-    | "onSelectModel"
-    | "onSelectMode"
-    | "onSelectThinkingOption"
-    | "onSetOption"
-    | "onSetMetadata"
-  > & { thinking: string | null; isLocked: () => boolean },
-): ComposerAgent {
-  return {
-    context: props.context ?? "draft",
-    locked: props.disabled ?? false,
-    isLocked: props.isLocked,
-    provider: props.selectedProvider,
-    model: props.selectedModel || null,
-    mode: props.selectedMode || null,
-    thinking: props.thinking,
-    options: props.options,
-    metadata: props.metadata,
-    // An empty model id picks the provider's default model.
-    setProvider: async (provider) => {
-      if (!props.onSelectProviderAndModel(provider, "")) {
-        throw new Error(`Unknown or unavailable provider: ${provider}`);
-      }
-    },
-    setModel: async (modelId) => {
-      if (!props.onSelectModel(modelId)) throw new Error(`Unknown model: ${modelId}`);
-    },
-    setMode: async (modeId) => props.onSelectMode(modeId),
-    setThinking: async (thinkingOptionId) => props.onSelectThinkingOption(thinkingOptionId),
-    setOptions: async (patch) => {
-      for (const [key, value] of Object.entries(patch)) props.onSetOption(key, value);
-    },
-    setMetadata: async (patch) => props.onSetMetadata(patch),
-  };
-}

packages/app/src/composer/draft/input-draft-core.ts

@@ -1,4 +1,3 @@
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
 import type { UserComposerAttachment } from "@/attachments/types";
 import type { DraftAgentControlsProps } from "@/composer/agent-controls";
 import type { UseAgentFormStateResult } from "@/hooks/use-agent-form-state";
@@ -21,26 +20,12 @@ export function resolveDraftKey(input: {
 
 export function buildDraftAgentControls(input: {
   formState: UseAgentFormStateResult;
-  optionControls?: DraftAgentControlsProps["optionControls"];
-  options: DraftAgentControlsProps["options"];
-  onSetOption: DraftAgentControlsProps["onSetOption"];
+  features?: DraftAgentControlsProps["features"];
+  onSetFeature?: DraftAgentControlsProps["onSetFeature"];
   onApplyAgentProfile: DraftAgentControlsProps["onApplyAgentProfile"];
   onDropdownClose?: DraftAgentControlsProps["onDropdownClose"];
-  context: NonNullable<DraftAgentControlsProps["context"]>;
-  metadata: Record<string, JsonValue>;
-  onSetMetadata: (patch: Record<string, JsonValue>) => void;
 }): DraftAgentControlsProps {
-  const {
-    formState,
-    optionControls,
-    options,
-    onSetOption,
-    onApplyAgentProfile,
-    onDropdownClose,
-    context,
-    metadata,
-    onSetMetadata,
-  } = input;
+  const { formState, features, onSetFeature, onApplyAgentProfile, onDropdownClose } = input;
   return {
     providerDefinitions: formState.providerDefinitions,
     selectedProvider: formState.selectedProvider,
@@ -58,17 +43,13 @@ export function buildDraftAgentControls(input: {
     selectedThinkingOptionId: formState.selectedThinkingOptionId,
     onSelectThinkingOption: formState.setThinkingOptionFromUser,
     onApplyAgentProfile,
-    optionControls,
-    options,
-    onSetOption,
+    features,
+    onSetFeature,
     onDropdownClose,
     onModelSelectorOpen: formState.refetchProviderModelsIfStale,
     onRetryModelProvider: formState.refreshProviderModels,
     isRetryingModelProvider: formState.isProviderModelsRefreshing,
     modelSelectorServerId: formState.selectedServerId,
-    context,
-    metadata,
-    onSetMetadata,
   };
 }
 

packages/app/src/composer/draft/input-draft.ts

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
 import type { UserComposerAttachment } from "@/attachments/types";
 import type { TextReplacement } from "@/composer/types";
 import type { DraftAgentControlsProps } from "@/composer/agent-controls";
@@ -9,7 +8,7 @@ import {
   type CreateAgentInitialValues,
   type UseAgentFormStateResult,
 } from "@/hooks/use-agent-form-state";
-import { useDraftProviderOptions } from "@/hooks/use-draft-provider-options";
+import { useDraftAgentFeatures } from "@/hooks/use-draft-agent-features";
 import {
   buildDraftAgentControls,
   hasDraftContent,
@@ -29,8 +28,6 @@ import { useShallow } from "zustand/shallow";
 import type { ComposerTextSource } from "@/composer/text-source";
 import { isWeb } from "@/constants/platform";
 
-const NO_METADATA: Record<string, JsonValue> = {};
-
 type AttachmentUpdater =
   | UserComposerAttachment[]
   | ((prev: UserComposerAttachment[]) => UserComposerAttachment[]);
@@ -38,9 +35,7 @@ type AttachmentUpdater =
 interface AgentInputDraftComposerOptions {
   initialServerId: string | null;
   initialValues?: CreateAgentInitialValues;
-  initialProviderOptions?: Record<string, unknown>;
-  /** Which composer a plugin's `useComposer()` reports. */
-  context?: "draft" | "new-workspace";
+  initialFeatureValues?: Record<string, unknown>;
   isVisible?: boolean;
   lockedWorkingDir?: string;
 }
@@ -55,9 +50,7 @@ type DraftComposerState = UseAgentFormStateResult & {
   effectiveModeId: string;
   effectiveModelId: string;
   effectiveThinkingOptionId: string;
-  providerOptions: Record<string, unknown> | undefined;
-  /** What plugins set on the agent this draft creates. */
-  metadata: Record<string, JsonValue>;
+  featureValues: Record<string, unknown> | undefined;
   agentControls: DraftAgentControlsProps;
   commandDraft: DraftCommandTarget;
 };
@@ -198,18 +191,10 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
     [saveDraft],
   );
 
-  const metadata = useDraftStore((state) => state.metadataByDraftKey[draftKey] ?? NO_METADATA);
-  const setMetadata = useCallback(
-    (patch: Record<string, JsonValue>) =>
-      useDraftStore.getState().patchDraftMetadata({ draftKey, patch }),
-    [draftKey],
-  );
-
   const clear = useCallback(
     (lifecycle: "sent" | "abandoned") => {
       textPublication.cancel();
       useDraftStore.getState().clearDraftInput({ draftKey, lifecycle });
-      if (lifecycle === "sent") useDraftStore.getState().clearDraftMetadata({ draftKey });
     },
     [draftKey, textPublication],
   );
@@ -289,28 +274,26 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
   );
 
   const {
-    optionControls: draftOptionControls,
-    options: draftOptions,
-    shownOptions: draftShownOptions,
-    setOption: setDraftOption,
-    applyProfile: applyProfileOptions,
-  } = useDraftProviderOptions({
+    features: draftFeatures,
+    featureValues: draftFeatureValues,
+    setFeatureValue: setDraftFeatureValue,
+    applyProfileFeatureValues,
+  } = useDraftAgentFeatures({
     serverId: formState.selectedServerId,
     provider: formState.selectedProvider,
-    getProvider: formState.getSelectedProvider,
     cwd: workingDir,
     modeId: formState.selectedMode,
     modelId: effectiveModelId,
     thinkingOptionId: effectiveThinkingOptionId,
-    initialOptions: composerOptions?.initialProviderOptions,
+    initialFeatureValues: composerOptions?.initialFeatureValues,
   });
 
   const applyDraftAgentProfile = useCallback(
     (profile: Parameters<typeof formState.applyProfileFromUser>[0]) => {
       formState.applyProfileFromUser(profile);
-      applyProfileOptions({ provider: profile.provider, options: profile.options });
+      applyProfileFeatureValues(profile.featureValues);
     },
-    [applyProfileOptions, formState],
+    [applyProfileFeatureValues, formState],
   );
 
   const commandDraft = useMemo(
@@ -320,9 +303,15 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
         cwd: workingDir,
         effectiveModelId,
         effectiveThinkingOptionId,
-        providerOptions: draftOptions,
+        featureValues: draftFeatureValues,
       }),
-    [effectiveModelId, effectiveThinkingOptionId, draftOptions, providerSelection, workingDir],
+    [
+      effectiveModelId,
+      effectiveThinkingOptionId,
+      draftFeatureValues,
+      providerSelection,
+      workingDir,
+    ],
   );
 
   const composerState = useMemo<DraftComposerState | null>(() => {
@@ -336,17 +325,12 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
       effectiveModeId,
       effectiveModelId,
       effectiveThinkingOptionId,
-      providerOptions: draftOptions,
-      metadata,
+      featureValues: draftFeatureValues,
       agentControls: buildDraftAgentControls({
         formState,
-        optionControls: draftOptionControls,
-        options: draftShownOptions,
-        onSetOption: setDraftOption,
+        features: draftFeatures,
+        onSetFeature: setDraftFeatureValue,
         onApplyAgentProfile: applyDraftAgentProfile,
-        context: composerOptions.context ?? "draft",
-        metadata,
-        onSetMetadata: setMetadata,
       }),
       commandDraft,
     };
@@ -356,14 +340,11 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
     effectiveModeId,
     effectiveModelId,
     effectiveThinkingOptionId,
-    draftOptionControls,
-    draftOptions,
-    draftShownOptions,
-    setDraftOption,
+    draftFeatures,
+    draftFeatureValues,
     applyDraftAgentProfile,
     formState,
-    metadata,
-    setMetadata,
+    setDraftFeatureValue,
     workingDir,
   ]);
 

packages/app/src/composer/draft/metadata.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applyMetadataPatch } from "./metadata";
-
-describe("applyMetadataPatch", () => {
-  it("replaces top-level keys and removes keys patched to null", () => {
-    expect(
-      applyMetadataPatch(
-        { "linear.issue": { id: "ENG-1" }, review: true },
-        { "linear.issue": { id: "ENG-2" }, review: null, extra: [1] },
-      ),
-    ).toEqual({ "linear.issue": { id: "ENG-2" }, extra: [1] });
-  });
-
-  it("leaves the current record untouched", () => {
-    const current = { review: true };
-    applyMetadataPatch(current, { review: null });
-    expect(current).toEqual({ review: true });
-  });
-});

packages/app/src/composer/draft/metadata.ts

@@ -1,14 +0,0 @@
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
-
-/** Top-level keys replace; `null` removes the key. The daemon applies the same rule to an agent. */
-export function applyMetadataPatch(
-  current: Readonly<Record<string, JsonValue>>,
-  patch: Readonly<Record<string, JsonValue>>,
-): Record<string, JsonValue> {
-  const next = { ...current };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === null) delete next[key];
-    else next[key] = value;
-  }
-  return next;
-}

packages/app/src/composer/draft/workspace-tab.tsx

@@ -1,6 +1,4 @@
-import type { ComposerOptionControls } from "@/agent-controls/option-controls";
 import { useCallback, useEffect, useMemo, useRef } from "react";
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
 import { Keyboard, ScrollView, StyleSheet as RNStyleSheet, Text, View } from "react-native";
 import { useTranslation } from "react-i18next";
 import { StyleSheet } from "react-native-unistyles";
@@ -67,7 +65,7 @@ interface AutoSubmitConfig {
   modeId: string | null;
   model: string | null;
   thinkingOptionId: string | null;
-  providerOptions: Record<string, unknown>;
+  featureValues: Record<string, unknown>;
 }
 
 function resolveAutoSubmitConfig(
@@ -76,7 +74,7 @@ function resolveAutoSubmitConfig(
     modeId?: string | null;
     model?: string | null;
     thinkingOptionId?: string | null;
-    providerOptions?: Record<string, unknown>;
+    featureValues?: Record<string, unknown>;
   } | null,
 ): AutoSubmitConfig | null {
   if (!pending) return null;
@@ -85,7 +83,7 @@ function resolveAutoSubmitConfig(
     modeId: pending.modeId ?? null,
     model: pending.model ?? null,
     thinkingOptionId: pending.thinkingOptionId ?? null,
-    providerOptions: pending.providerOptions ?? {},
+    featureValues: pending.featureValues ?? {},
   };
 }
 
@@ -133,8 +131,7 @@ async function submitDraftCreateRequest(input: {
     effectiveModeId: string;
     effectiveModelId: string | null;
     effectiveThinkingOptionId: string | null;
-    providerOptions: Record<string, unknown> | undefined;
-    metadata: Record<string, JsonValue>;
+    featureValues: Record<string, unknown> | undefined;
   };
   hostDisconnectedMessage: string;
   selectModelMessage: string;
@@ -173,7 +170,7 @@ async function submitDraftCreateRequest(input: {
     model: autoSubmitConfig?.model ?? (composerState.effectiveModelId || undefined),
     thinkingOptionId:
       autoSubmitConfig?.thinkingOptionId ?? (composerState.effectiveThinkingOptionId || undefined),
-    providerOptions: autoSubmitConfig?.providerOptions ?? composerState.providerOptions,
+    featureValues: autoSubmitConfig?.featureValues ?? composerState.featureValues,
   });
 
   const attachmentsArray = Array.isArray(attachments) ? attachments : undefined;
@@ -184,7 +181,6 @@ async function submitDraftCreateRequest(input: {
     workspaceId,
     initialPrompt: text,
     clientMessageId: attempt.clientMessageId,
-    ...(Object.keys(composerState.metadata).length > 0 ? { metadata: composerState.metadata } : {}),
     ...(imagesData && imagesData.length > 0 ? { images: imagesData } : {}),
     ...(attachmentsArray && attachmentsArray.length > 0 ? { attachments: attachmentsArray } : {}),
   };
@@ -208,7 +204,7 @@ function buildDraftAgentSnapshot(input: {
     effectiveThinkingOptionId: string | null;
     effectiveModeId: string;
     selectedProvider: string | null;
-    agentControls: { optionControls?: ComposerOptionControls };
+    agentControls: { features?: Agent["features"] };
   };
   selectModelMessage: string;
 }): Agent {
@@ -245,8 +241,7 @@ function buildDraftAgentSnapshot(input: {
     title: "Agent",
     cwd: workspaceDirectory,
     model,
-    options: composerState.agentControls.optionControls?.options,
-    controls: composerState.agentControls.optionControls?.controls,
+    features: composerState.agentControls.features,
     thinkingOptionId,
     parentAgentId: null,
     labels: {},
@@ -338,7 +333,7 @@ export function WorkspaceDraftAgentTab({
     composer: {
       initialServerId: serverId,
       initialValues: draftInitialValues,
-      initialProviderOptions: draftSetup?.providerOptions,
+      initialFeatureValues: draftSetup?.featureValues,
       isVisible: true,
       lockedWorkingDir: draftWorkingDirectory ?? undefined,
     },
@@ -356,7 +351,8 @@ export function WorkspaceDraftAgentTab({
   const draftModeOptions = composerState.modeOptions;
   const draftSelectedMode = composerState.selectedMode;
   const draftSetMode = composerState.setModeFromUser;
-  const draftOptionControls = composerState.agentControls.optionControls;
+  const draftFeatures = composerState.agentControls.features;
+  const draftOnSetFeature = composerState.agentControls.onSetFeature;
 
   const clearDraftInput = draftInput.clear;
   const replaceDraftText = draftInput.replaceText;
@@ -513,9 +509,7 @@ export function WorkspaceDraftAgentTab({
         providers: composerState.modelSelectorProviders,
         selectedProvider: draftProvider,
         selectedModelId: composerState.effectiveModelId,
-        select: (provider, modelId) => {
-          composerState.setProviderAndModelFromUser(provider, modelId);
-        },
+        select: composerState.setProviderAndModelFromUser,
       },
       thinking: {
         options: draftThinkingOptions,
@@ -527,7 +521,10 @@ export function WorkspaceDraftAgentTab({
         selectedId: draftSelectedMode,
         select: draftSetMode,
       },
-      optionControls: draftOptionControls ?? null,
+      features: {
+        list: draftFeatures,
+        set: draftOnSetFeature,
+      },
     },
   });
   const isReadyForPendingAutoSubmit = Boolean(

packages/app/src/composer/index.tsx

@@ -139,8 +139,6 @@ import type {
 } from "@/attachments/types";
 import type { SelectedFile } from "@/attachments/selected-file";
 import { resolveComposerAttachmentSubmitFormat } from "@/composer/attachments/submit";
-import { ComposerInputProvider, type ComposerInput } from "@/composer/session";
-import { insertAtSelection } from "@/composer/insert-text";
 import { composerWorkspaceAttachment } from "@/composer/attachments/workspace";
 import { useWorkspaceAttachmentsForScopes } from "@/attachments/workspace-attachments-store";
 import { droppedItemsToSelectedFiles } from "@/composer/attachments/drop";
@@ -1421,40 +1419,6 @@ function ComposerContentImpl({
     [onChangeText],
   );
 
-  const insertUserInput = useCallback(
-    (text: string) => {
-      const input = messageInputRef.current;
-      if (!input) {
-        onChangeText(textSource.getSnapshot() + text);
-        return;
-      }
-      const inserted = insertAtSelection(input.getInputSnapshot(), text);
-      input.replaceText(inserted.text, inserted.selection);
-    },
-    [onChangeText, textSource],
-  );
-  const isComposerLockedRef = useRef(isComposerLocked);
-  isComposerLockedRef.current = isComposerLocked;
-  const composerInput = useMemo<ComposerInput>(
-    () => ({
-      locked: isComposerLocked,
-      isLocked: () => isComposerLockedRef.current,
-      textSource,
-      setText: replaceUserInput,
-      insertText: insertUserInput,
-      attachments,
-      changeAttachments: setSelectedAttachments,
-    }),
-    [
-      attachments,
-      insertUserInput,
-      isComposerLocked,
-      replaceUserInput,
-      setSelectedAttachments,
-      textSource,
-    ],
-  );
-
   const runClientSlashCommand = useCallback(
     (command: ClientSlashCommand): boolean => {
       if (command.execution !== "immediate" || !onClientSlashCommand) {
@@ -2259,27 +2223,18 @@ function ComposerContentImpl({
     [attachments, setSelectedAttachments, setGithubSearchQuery, setIsGithubPickerOpen],
   );
 
-  const leftContent = useMemo(() => {
-    const controls = renderLeftContent({
-      agentControls,
-      agentId,
-      serverId,
-      focusInput,
-      isCompactLayout,
-      showAgentControls: mode.showAgentControls,
-    });
-    return controls ? (
-      <ComposerInputProvider value={composerInput}>{controls}</ComposerInputProvider>
-    ) : null;
-  }, [
-    agentControls,
-    agentId,
-    composerInput,
-    focusInput,
-    isCompactLayout,
-    mode.showAgentControls,
-    serverId,
-  ]);
+  const leftContent = useMemo(
+    () =>
+      renderLeftContent({
+        agentControls,
+        agentId,
+        serverId,
+        focusInput,
+        isCompactLayout,
+        showAgentControls: mode.showAgentControls,
+      }),
+    [agentControls, agentId, focusInput, isCompactLayout, mode.showAgentControls, serverId],
+  );
 
   const handleAttachButtonRef = useCallback((node: View | null) => {
     attachButtonRef.current = node;

packages/app/src/composer/insert-text.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { insertAtSelection } from "./insert-text";
-
-describe("insertAtSelection", () => {
-  it("inserts at the caret and moves the caret after the insertion", () => {
-    expect(insertAtSelection({ text: "ab", selection: { start: 1, end: 1 } }, "XY")).toEqual({
-      text: "aXYb",
-      selection: { start: 3, end: 3 },
-    });
-  });
-
-  it("replaces the selection, however it was dragged", () => {
-    expect(insertAtSelection({ text: "abcd", selection: { start: 3, end: 1 } }, "-")).toEqual({
-      text: "a-d",
-      selection: { start: 2, end: 2 },
-    });
-  });
-});

packages/app/src/composer/insert-text.ts

@@ -1,15 +0,0 @@
-import type { ComposerInputSnapshot } from "@/composer/input/input";
-
-/** The text with `inserted` in place of the selection, and the caret after it. */
-export function insertAtSelection(
-  { text, selection }: ComposerInputSnapshot,
-  inserted: string,
-): ComposerInputSnapshot {
-  const start = Math.min(selection.start, selection.end);
-  const end = Math.max(selection.start, selection.end);
-  const caret = start + inserted.length;
-  return {
-    text: text.slice(0, start) + inserted + text.slice(end),
-    selection: { start: caret, end: caret },
-  };
-}

packages/app/src/composer/session.tsx

@@ -1,89 +0,0 @@
-import { createContext, useContext, type ReactNode } from "react";
-import type { JsonValue, ProviderOptions } from "@getpaseo/protocol/agent-types";
-import type { UserComposerAttachment } from "@/attachments/types";
-import type { ComposerTextSource } from "@/composer/text-source";
-
-/**
- * The text and attachments of the composer a control sits in. `Composer` provides it, so a
- * control reaches the prompt without knowing which screen mounted the composer.
- */
-export interface ComposerInput {
-  /** The prompt is held while the composer submits; the built-in input is read-only meanwhile. */
-  locked: boolean;
-  /** `locked` as it is now. A command a plugin kept from an earlier render asks this. */
-  isLocked: () => boolean;
-  textSource: ComposerTextSource;
-  setText: (text: string) => void;
-  /** Inserts at the cursor, replacing the selection. */
-  insertText: (text: string) => void;
-  attachments: readonly UserComposerAttachment[];
-  changeAttachments: (
-    updater: (current: UserComposerAttachment[]) => UserComposerAttachment[],
-  ) => void;
-}
-
-/**
- * The agent a composer configures, as one set of reads and commands. A running agent sends each
- * command to the daemon; a draft keeps it locally until the agent is created. Controls call the
- * same command either way.
- */
-export interface ComposerAgent {
-  context: "agent" | "draft" | "new-workspace";
-  /** The agent is being created; the built-in controls are disabled meanwhile. */
-  locked: boolean;
-  /** `locked` as it is now. A command a plugin kept from an earlier render asks this. */
-  isLocked: () => boolean;
-  provider: string | null;
-  model: string | null;
-  mode: string | null;
-  thinking: string | null;
-  /** The options the agent runs with, defaults included. */
-  options: ProviderOptions;
-  metadata: Record<string, JsonValue>;
-  setProvider: (provider: string) => Promise<void>;
-  setModel: (modelId: string) => Promise<void>;
-  setMode: (modeId: string) => Promise<void>;
-  setThinking: (thinkingOptionId: string) => Promise<void>;
-  /** Top-level keys replace; `null` removes the agent's own value. */
-  setOptions: (patch: ProviderOptions) => Promise<void>;
-  /** Top-level keys replace; `null` removes the key. */
-  setMetadata: (patch: Record<string, JsonValue>) => Promise<void>;
-}
-
-const ComposerInputContext = createContext<ComposerInput | null>(null);
-const ComposerAgentContext = createContext<ComposerAgent | null>(null);
-
-export function ComposerInputProvider({
-  value,
-  children,
-}: {
-  value: ComposerInput;
-  children: ReactNode;
-}) {
-  return <ComposerInputContext.Provider value={value}>{children}</ComposerInputContext.Provider>;
-}
-
-export function ComposerAgentProvider({
-  value,
-  children,
-}: {
-  value: ComposerAgent | null;
-  children: ReactNode;
-}) {
-  return <ComposerAgentContext.Provider value={value}>{children}</ComposerAgentContext.Provider>;
-}
-
-export function useComposerInput(): ComposerInput | null {
-  return useContext(ComposerInputContext);
-}
-
-export function useComposerAgent(): ComposerAgent | null {
-  return useContext(ComposerAgentContext);
-}
-
-/** True while the composer holds its prompt or its agent's settings for a submit in flight. */
-export function useComposerLocked(): boolean {
-  const input = useComposerInput();
-  const agent = useComposerAgent();
-  return Boolean(input?.locked || agent?.locked);
-}

packages/app/src/create-agent-preferences/preferences.test.ts

@@ -80,7 +80,7 @@ describe("create agent preferences", () => {
         modelId: "gpt-5.5",
         modeId: "full-access",
         thinkingOptionId: "high",
-        options: { fast_mode: true },
+        featureValues: { fast_mode: true },
       }),
     );
 
@@ -95,7 +95,7 @@ describe("create agent preferences", () => {
           model: "gpt-5.5",
           mode: "full-access",
           thinkingByModel: { "gpt-5.5": "high" },
-          options: { fast_mode: true },
+          featureValues: { fast_mode: true },
         },
       },
     });
@@ -119,7 +119,7 @@ describe("create agent preferences", () => {
           model: "gpt-5.6",
           mode: undefined,
           thinkingByModel: undefined,
-          options: undefined,
+          featureValues: undefined,
         },
       }),
     ).toEqual({
@@ -167,13 +167,13 @@ describe("create agent preferences", () => {
         modelId: "one-minute-stream",
         modeId: "approval-test",
         thinkingOptionId: "",
-        options: {},
+        featureValues: {},
       }),
     ).toEqual({
       provider: "mock",
       providerPreferences: {
         pi: { model: "anthropic/sonnet" },
-        mock: { model: "one-minute-stream", mode: "approval-test", options: {} },
+        mock: { model: "one-minute-stream", mode: "approval-test", featureValues: {} },
       },
     });
   });
@@ -208,29 +208,6 @@ describe("create agent preferences", () => {
     });
   });
 
-  it("reads preferences saved as featureValues as options", () => {
-    expect(
-      parseFormPreferences({
-        provider: "codex",
-        providerPreferences: { codex: { featureValues: { service_tier: "priority" } } },
-      }),
-    ).toEqual({
-      provider: "codex",
-      providerPreferences: { codex: { options: { service_tier: "priority" } } },
-    });
-  });
-
-  it("keeps options that are not booleans or strings, such as a profile's sandbox settings", () => {
-    const options = {
-      sandbox_workspace_write: { network_access: true, writable_roots: ["/tmp"] },
-      max_turns: 3,
-    };
-
-    expect(
-      parseFormPreferences({ provider: "codex", providerPreferences: { codex: { options } } }),
-    ).toEqual({ provider: "codex", providerPreferences: { codex: { options } } });
-  });
-
   it("rejects unknown persisted fields outside the explicit legacy shape", () => {
     expect(parseFormPreferences({ provider: "codex", surprise: true })).toEqual({});
   });

packages/app/src/create-agent-preferences/preferences.ts

@@ -1,14 +1,13 @@
 import { z } from "zod";
 import type { AgentProvider } from "@getpaseo/protocol/agent-types";
 
-const optionsSchema = z.record(z.string(), z.json());
+const featureValuesSchema = z.record(z.string(), z.union([z.boolean(), z.string(), z.null()]));
 
 export interface ProviderPreferences {
   model?: string;
   mode?: string;
   thinkingByModel?: Record<string, string>;
-  /** Last-used values of the provider's option controls, by option key. */
-  options?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }
 
 export type LaunchTarget = { kind: "chat" } | { kind: "terminal"; profileId: string };
@@ -21,23 +20,12 @@ export interface FormPreferences {
   launchTarget?: LaunchTarget;
 }
 
-// COMPAT(providerOptionControls): added in v0.15.0, remove after 2027-05-01. Preferences written
-// before the rename stored the same record as `featureValues`.
-function renameLegacyFeatureValues(value: unknown): unknown {
-  if (typeof value !== "object" || value === null || !("featureValues" in value)) return value;
-  const { featureValues, ...rest } = value as { featureValues: unknown } & Record<string, unknown>;
-  return "options" in rest ? rest : { ...rest, options: featureValues };
-}
-
-const providerPreferencesSchema: z.ZodType<ProviderPreferences> = z.preprocess(
-  renameLegacyFeatureValues,
-  z.strictObject({
-    model: z.string().optional(),
-    mode: z.string().optional(),
-    thinkingByModel: z.record(z.string(), z.string()).optional(),
-    options: optionsSchema.optional(),
-  }),
-);
+const providerPreferencesSchema: z.ZodType<ProviderPreferences> = z.strictObject({
+  model: z.string().optional(),
+  mode: z.string().optional(),
+  thinkingByModel: z.record(z.string(), z.string()).optional(),
+  featureValues: featureValuesSchema.optional(),
+});
 
 const launchTargetSchema: z.ZodType<LaunchTarget> = z.discriminatedUnion("kind", [
   z.strictObject({ kind: z.literal("chat") }),
@@ -128,7 +116,7 @@ function applyProviderPreferenceUpdates(
 ): ProviderPreferences {
   const next: ProviderPreferences = { ...existing };
   const nextThinkingByModel = mergeDefinedRecord(existing.thinkingByModel, updates.thinkingByModel);
-  const nextOptions = mergeDefinedRecord(existing.options, updates.options);
+  const nextFeatureValues = mergeDefinedRecord(existing.featureValues, updates.featureValues);
 
   if (updates.model !== undefined) {
     next.model = updates.model;
@@ -141,8 +129,8 @@ function applyProviderPreferenceUpdates(
   if (nextThinkingByModel !== undefined) {
     next.thinkingByModel = nextThinkingByModel;
   }
-  if (nextOptions !== undefined) {
-    next.options = nextOptions;
+  if (nextFeatureValues !== undefined) {
+    next.featureValues = nextFeatureValues;
   }
 
   return next;
@@ -173,7 +161,7 @@ export function mergeCreateAgentSelectionPreferences(args: {
   modelId?: string | null;
   modeId?: string | null;
   thinkingOptionId?: string | null;
-  options?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }): FormPreferences {
   if (!args.provider) {
     return args.preferences;
@@ -182,7 +170,7 @@ export function mergeCreateAgentSelectionPreferences(args: {
   const modelId = args.modelId?.trim() ?? "";
   const modeId = args.modeId?.trim() ?? "";
   const thinkingOptionId = args.thinkingOptionId?.trim() ?? "";
-  const options = optionsSchema.safeParse(args.options);
+  const featureValues = featureValuesSchema.safeParse(args.featureValues);
 
   return mergeProviderPreferences({
     preferences: args.preferences,
@@ -191,7 +179,7 @@ export function mergeCreateAgentSelectionPreferences(args: {
       model: modelId || undefined,
       mode: args.modeId === undefined ? undefined : modeId || null,
       ...(modelId && thinkingOptionId ? { thinkingByModel: { [modelId]: thinkingOptionId } } : {}),
-      ...(options.success ? { options: options.data } : {}),
+      ...(featureValues.success ? { featureValues: featureValues.data } : {}),
     },
   });
 }
@@ -204,7 +192,7 @@ export function applyAgentProfilePreferences(args: {
   modelId: string;
   modeId: string;
   thinkingOptionId: string;
-  options: Record<string, unknown>;
+  featureValues: Record<string, unknown>;
 }): FormPreferences {
   let next = args.preferences;
   if (args.previousProvider) {
@@ -227,7 +215,7 @@ export function applyAgentProfilePreferences(args: {
       ...(args.modelId && args.thinkingOptionId
         ? { thinkingByModel: { [args.modelId]: args.thinkingOptionId } }
         : {}),
-      options: args.options,
+      featureValues: args.featureValues,
     },
   });
 }

packages/app/src/hooks/feature-preferences.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveFeatureValues } from "./feature-preferences";
+
+describe("feature-preferences", () => {
+  const features = [
+    {
+      type: "toggle" as const,
+      id: "fast_mode",
+      label: "Fast",
+      value: false,
+    },
+    {
+      type: "toggle" as const,
+      id: "plan_mode",
+      label: "Plan",
+      value: false,
+    },
+  ];
+
+  it("restores persisted values for available features", () => {
+    expect(
+      resolveFeatureValues({
+        features,
+        persistedFeatureValues: {
+          fast_mode: true,
+          unknown_feature: true,
+        },
+        localFeatureValues: {},
+      }),
+    ).toEqual({
+      fast_mode: true,
+    });
+  });
+
+  it("prefers local values over persisted values", () => {
+    expect(
+      resolveFeatureValues({
+        features,
+        persistedFeatureValues: {
+          fast_mode: true,
+          plan_mode: false,
+        },
+        localFeatureValues: {
+          fast_mode: false,
+        },
+      }),
+    ).toEqual({
+      fast_mode: false,
+      plan_mode: false,
+    });
+  });
+});

packages/app/src/hooks/feature-preferences.ts

@@ -0,0 +1,60 @@
+import type { AgentFeature } from "@getpaseo/protocol/agent-types";
+
+export function pruneFeatureValues(
+  featureValues: Record<string, unknown>,
+  features: AgentFeature[],
+): Record<string, unknown> {
+  const allowedFeatureIds = new Set(features.map((feature) => feature.id));
+  let changed = false;
+  const next: Record<string, unknown> = {};
+
+  for (const [featureId, value] of Object.entries(featureValues)) {
+    if (!allowedFeatureIds.has(featureId)) {
+      changed = true;
+      continue;
+    }
+    next[featureId] = value;
+  }
+
+  return changed ? next : featureValues;
+}
+
+export function applyFeatureValues(
+  features: AgentFeature[],
+  featureValues: Record<string, unknown>,
+): AgentFeature[] {
+  if (Object.keys(featureValues).length === 0) {
+    return features;
+  }
+
+  return features.map((feature) => {
+    if (!Object.prototype.hasOwnProperty.call(featureValues, feature.id)) {
+      return feature;
+    }
+
+    return {
+      ...feature,
+      value: featureValues[feature.id],
+    } as AgentFeature;
+  });
+}
+
+export function resolveFeatureValues(args: {
+  features: AgentFeature[];
+  persistedFeatureValues: Record<string, unknown>;
+  localFeatureValues: Record<string, unknown>;
+}): Record<string, unknown> {
+  const next: Record<string, unknown> = {};
+
+  for (const feature of args.features) {
+    if (Object.prototype.hasOwnProperty.call(args.localFeatureValues, feature.id)) {
+      next[feature.id] = args.localFeatureValues[feature.id];
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(args.persistedFeatureValues, feature.id)) {
+      next[feature.id] = args.persistedFeatureValues[feature.id];
+    }
+  }
+
+  return next;
+}

packages/app/src/hooks/use-agent-autocomplete.ts

@@ -128,14 +128,14 @@ function resolveDraftQueryConfig(draft?: DraftCommandTarget): DraftCommandConfig
   const modeId = draftConfig.modeId?.trim() ?? "";
   const model = draftConfig.model?.trim() ?? "";
   const thinkingOptionId = draftConfig.thinkingOptionId?.trim() ?? "";
-  const providerOptions = draftConfig.providerOptions;
+  const featureValues = draftConfig.featureValues;
   return {
     provider: draftConfig.provider,
     cwd,
     ...(modeId ? { modeId } : {}),
     ...(model ? { model } : {}),
     ...(thinkingOptionId ? { thinkingOptionId } : {}),
-    ...(providerOptions && Object.keys(providerOptions).length > 0 ? { providerOptions } : {}),
+    ...(featureValues && Object.keys(featureValues).length > 0 ? { featureValues } : {}),
   };
 }
 

packages/app/src/hooks/use-agent-form-state.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { useCallback, useEffect, useMemo, useReducer, useRef } from "react";
 import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 import type {
   AgentMode,
@@ -28,13 +28,14 @@ import {
   mergeSelectedComposerPreferences,
   buildProviderDefinitionMap,
   buildProviderDefinitionMapForStatuses,
+  INITIAL_AGENT_FORM_RESOLUTION,
+  INITIAL_USER_MODIFIED,
   RESOLVABLE_PROVIDER_STATUSES,
   SELECTABLE_PROVIDER_STATUSES,
   type FormInitialValues,
   type FormState,
   type ProviderModelsByProvider,
 } from "@/provider-selection/resolve-agent-form";
-import { openAgentForm, type AgentFormCatalog } from "@/provider-selection/agent-form-store";
 import { useHostRuntimeIsConnected } from "@/runtime/host-runtime";
 import type { MaterializedAgentProfile } from "@/agent-profiles";
 
@@ -51,13 +52,10 @@ export interface UseAgentFormStateOptions {
 export interface UseAgentFormStateResult {
   selectedServerId: string | null;
   selectedProvider: AgentProvider | null;
-  /** The provider as it is now, which a render may not have reached yet. */
-  getSelectedProvider: () => AgentProvider | null;
   selectedMode: string;
   setModeFromUser: (modeId: string) => void;
   selectedModel: string;
-  /** `false` when the provider's loaded catalog does not list the model. */
-  setModelFromUser: (modelId: string) => boolean;
+  setModelFromUser: (modelId: string) => void;
   selectedThinkingOptionId: string;
   setThinkingOptionFromUser: (thinkingOptionId: string) => void;
   workingDir: string;
@@ -76,20 +74,13 @@ export interface UseAgentFormStateResult {
   modelError: string | null;
   refreshProviderModels: (provider?: AgentProvider) => void;
   refetchProviderModelsIfStale: () => void;
-  /** `false` when the provider is unknown or not ready. */
-  setProviderAndModelFromUser: (provider: AgentProvider, modelId: string) => boolean;
+  setProviderAndModelFromUser: (provider: AgentProvider, modelId: string) => void;
   applyProfileFromUser: (profile: MaterializedAgentProfile) => void;
   clearProviderSelectionFromUser: () => void;
   workingDirIsEmpty: boolean;
   persistFormPreferences: () => Promise<void>;
 }
 
-const EMPTY_CATALOG: AgentFormCatalog = {
-  selectableProviders: new Map(),
-  models: new Map(),
-  providerPreferences: () => undefined,
-};
-
 function resolveSelectedProviderModes(input: {
   selectedEntry: ProviderSnapshotEntry | null;
   provider: AgentProvider | null;
@@ -181,15 +172,11 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
     [updatePreferences],
   );
 
-  // The store reads what the host offers when a command runs; each render publishes the latest.
-  const catalogRef = useRef<AgentFormCatalog>(EMPTY_CATALOG);
-  const [formStore] = useState(() => openAgentForm(() => catalogRef.current));
-  const { form: formState, resolution } = useSyncExternalStore(
-    formStore.subscribe,
-    formStore.getState,
-    formStore.getState,
-  );
-  const dispatch = formStore.dispatch;
+  const [{ form: formState, userModified, resolution }, dispatch] = useReducer(resolveAgentForm, {
+    form: { provider: null, modeId: "", model: "", thinkingOptionId: "" },
+    userModified: INITIAL_USER_MODIFIED,
+    resolution: INITIAL_AGENT_FORM_RESOLUTION,
+  });
 
   const {
     entries: snapshotEntries,
@@ -259,12 +246,6 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
   const providerDefinitionMap = snapshotProviderDefinitionMap;
   const selectableProviderDefinitionMap = snapshotSelectableProviderDefinitionMap;
   const allProviderModels = snapshotAllProviderModels;
-  catalogRef.current = {
-    selectableProviders: selectableProviderDefinitionMap,
-    models: allProviderModels,
-    providerPreferences: (provider) =>
-      preferenceOverlayRef.current.current().providerPreferences?.[provider],
-  };
   const modelSelectorProviders = snapshotModelSelectorProviders;
   const availableModels = snapshotSelectedProviderModels;
   const modeOptions = snapshotSelectedProviderModes;
@@ -296,15 +277,27 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
     preferences,
     snapshotProviderModelsByProvider,
     snapshotResolvableProviderDefinitionMap,
-    dispatch,
   ]);
 
   const setProviderAndModelFromUser = useCallback(
-    (provider: AgentProvider, modelId: string): boolean => {
-      if (!formStore.setProviderAndModel(provider, modelId)) return false;
+    (provider: AgentProvider, modelId: string) => {
+      if (!selectableProviderDefinitionMap.has(provider)) {
+        return;
+      }
+      const providerDef = selectableProviderDefinitionMap.get(provider);
       const providerModels = allProviderModels.get(provider) ?? null;
-      const nextModelId =
-        normalizeSelectedModelId(modelId) || resolveDefaultModelId(providerModels);
+      const providerPrefs = preferenceOverlayRef.current.current().providerPreferences?.[provider];
+      const normalizedModelId = normalizeSelectedModelId(modelId);
+      const nextModelId = normalizedModelId || resolveDefaultModelId(providerModels);
+
+      dispatch({
+        type: "SET_PROVIDER_AND_MODEL_FROM_USER",
+        provider,
+        modelId,
+        providerDef,
+        providerModels,
+        providerPrefs,
+      });
       void updateCurrentPreferences((current) =>
         mergeSelectedComposerPreferences({
           preferences: current,
@@ -314,14 +307,13 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
           },
         }),
       );
-      return true;
     },
-    [allProviderModels, formStore, updateCurrentPreferences],
+    [allProviderModels, selectableProviderDefinitionMap, updateCurrentPreferences],
   );
 
   const clearProviderSelectionFromUser = useCallback(() => {
     dispatch({ type: "CLEAR_PROVIDER_SELECTION_FROM_USER" });
-  }, [dispatch]);
+  }, []);
 
   const applyProfileFromUser = useCallback(
     (profile: MaterializedAgentProfile) => {
@@ -330,8 +322,7 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
         return;
       }
 
-      const formBefore = formStore.getState();
-      const previousProvider = formBefore.form.provider;
+      const previousProvider = formState.provider;
       const providerDef = selectableProviderDefinitionMap.get(provider);
       const providerModels = allProviderModels.get(provider) ?? null;
       const providerPrefs = preferenceOverlayRef.current.current().providerPreferences?.[provider];
@@ -345,7 +336,7 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
         providerModels,
         providerPrefs,
       };
-      const nextState = resolveAgentForm(formBefore, action);
+      const nextState = resolveAgentForm({ form: formState, userModified, resolution }, action);
       const previousProviderModeIds = previousProvider
         ? (providerDefinitionMap.get(previousProvider)?.modes.map((mode) => mode.id) ?? [])
         : [];
@@ -361,7 +352,7 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
           modelId: model,
           modeId,
           thinkingOptionId,
-          options: profile.options,
+          featureValues: profile.featureValues,
         });
       }).catch((error) => {
         console.warn("[useAgentFormState] persist profile preference failed", error);
@@ -369,18 +360,19 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
     },
     [
       allProviderModels,
-      dispatch,
-      formStore,
+      formState,
       providerDefinitionMap,
+      resolution,
       selectableProviderDefinitionMap,
       updateCurrentPreferences,
+      userModified,
     ],
   );
 
   const setModeFromUser = useCallback(
     (modeId: string) => {
       dispatch({ type: "SET_MODE_FROM_USER", modeId });
-      const { provider } = formStore.getState().form;
+      const provider = formState.provider;
       if (provider) {
         void updateCurrentPreferences((current) =>
           mergeSelectedComposerPreferences({
@@ -393,18 +385,24 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
         );
       }
     },
-    [dispatch, formStore, updateCurrentPreferences],
+    [formState.provider, updateCurrentPreferences],
   );
 
   const setModelFromUser = useCallback(
-    (modelId: string): boolean => {
-      if (!formStore.setModel(modelId)) return false;
-      const { provider } = formStore.getState().form;
+    (modelId: string) => {
+      const provider = formState.provider;
+      const providerPrefs = provider
+        ? preferenceOverlayRef.current.current().providerPreferences?.[provider]
+        : undefined;
+      dispatch({
+        type: "SET_MODEL_FROM_USER",
+        modelId,
+        availableModels,
+        providerPrefs,
+      });
       if (provider) {
-        const listed = allProviderModels.get(provider);
-        const nextModelId =
-          normalizeSelectedModelId(modelId) ||
-          resolveDefaultModelId(listed?.length ? listed : null);
+        const normalizedModelId = normalizeSelectedModelId(modelId);
+        const nextModelId = normalizedModelId || resolveDefaultModelId(availableModels);
         void updateCurrentPreferences((current) =>
           mergeSelectedComposerPreferences({
             preferences: current,
@@ -415,15 +413,14 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
           }),
         );
       }
-      return true;
     },
-    [allProviderModels, formStore, updateCurrentPreferences],
+    [availableModels, formState.provider, updateCurrentPreferences],
   );
 
   const setThinkingOptionFromUser = useCallback(
     (thinkingOptionId: string) => {
       dispatch({ type: "SET_THINKING_OPTION_FROM_USER", thinkingOptionId });
-      const { provider, model: modelId } = formStore.getState().form;
+      const { provider, model: modelId } = formState;
       if (provider && modelId) {
         void updateCurrentPreferences((current) =>
           mergeSelectedComposerPreferences({
@@ -438,11 +435,9 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
         );
       }
     },
-    [dispatch, formStore, updateCurrentPreferences],
+    [formState, updateCurrentPreferences],
   );
 
-  const getSelectedProvider = useCallback(() => formStore.getState().form.provider, [formStore]);
-
   const refreshProviderModels = useCallback(
     (provider?: AgentProvider) => {
       void refreshSnapshot(provider ? [provider] : undefined);
@@ -484,7 +479,6 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
     () => ({
       selectedServerId: serverId,
       selectedProvider: formState.provider,
-      getSelectedProvider,
       selectedMode: formState.modeId,
       setModeFromUser,
       selectedModel: formState.model,
@@ -515,7 +509,6 @@ export function useAgentFormState(options: UseAgentFormStateOptions): UseAgentFo
     }),
     [
       serverId,
-      getSelectedProvider,
       formState.provider,
       formState.modeId,
       formState.model,

packages/app/src/hooks/use-agent-screen-state-machine.ts

@@ -1,6 +1,9 @@
 import { useRef } from "react";
-import type { AgentCapabilityFlags, AgentProvider } from "@getpaseo/protocol/agent-types";
-import type { Agent } from "@/stores/session-store";
+import type {
+  AgentCapabilityFlags,
+  AgentFeature,
+  AgentProvider,
+} from "@getpaseo/protocol/agent-types";
 import type { ViewedTimelineStatus } from "@/timeline/viewed-timeline-sync";
 
 export interface AgentScreenAgent {
@@ -19,8 +22,7 @@ export interface AgentScreenAgent {
     modeId?: string | null;
     thinkingOptionId?: string | null;
   } | null;
-  options?: Agent["options"];
-  controls?: Agent["controls"];
+  features?: readonly AgentFeature[];
   lastError?: string | null;
   projectPlacement?: {
     projectKey?: string;

packages/app/src/hooks/use-draft-agent-features.ts

@@ -0,0 +1,159 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import type { AgentProvider, AgentSessionConfig } from "@getpaseo/protocol/agent-types";
+import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
+import { mergeProviderPreferences, useFormPreferences } from "./use-form-preferences";
+import {
+  applyFeatureValues,
+  pruneFeatureValues,
+  resolveFeatureValues,
+} from "./feature-preferences";
+
+type DraftFeatureConfig = Pick<
+  AgentSessionConfig,
+  "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId"
+>;
+
+export function useDraftAgentFeatures(input: {
+  serverId: string | null | undefined;
+  provider: AgentProvider | null;
+  cwd: string | null | undefined;
+  modeId: string | null | undefined;
+  modelId: string | null | undefined;
+  thinkingOptionId: string | null | undefined;
+  initialFeatureValues?: Record<string, unknown>;
+}) {
+  const { t } = useTranslation();
+  const { serverId, provider, cwd, modeId, modelId, thinkingOptionId, initialFeatureValues } =
+    input;
+  const [localFeatureValues, setLocalFeatureValues] = useState<Record<string, unknown>>(
+    () => initialFeatureValues ?? {},
+  );
+  const client = useHostRuntimeClient(serverId ?? "");
+  const isConnected = useHostRuntimeIsConnected(serverId ?? "");
+  const { preferences, updatePreferences } = useFormPreferences();
+  const normalizedCwd = cwd?.trim() || "";
+  const normalizedProvider = provider ?? null;
+  const previousProviderRef = useRef<AgentProvider | null>(normalizedProvider);
+  const persistedFeatureValues = useMemo(
+    () => (provider ? (preferences.providerPreferences?.[provider]?.featureValues ?? {}) : {}),
+    [preferences.providerPreferences, provider],
+  );
+
+  const draftConfig = useMemo<DraftFeatureConfig | null>(() => {
+    if (!normalizedProvider || !normalizedCwd) {
+      return null;
+    }
+
+    return {
+      provider: normalizedProvider,
+      cwd: normalizedCwd,
+      ...(modeId ? { modeId } : {}),
+      ...(modelId ? { model: modelId } : {}),
+      ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+  }, [modeId, modelId, normalizedCwd, normalizedProvider, thinkingOptionId]);
+
+  const featuresQuery = useQuery({
+    queryKey: [
+      "providerFeatures",
+      serverId ?? null,
+      normalizedProvider,
+      normalizedCwd || null,
+      modeId ?? null,
+      modelId ?? null,
+      thinkingOptionId ?? null,
+    ],
+    enabled: Boolean(serverId && client && isConnected && draftConfig),
+    staleTime: 5 * 60 * 1000,
+    queryFn: async () => {
+      if (!client || !draftConfig) {
+        throw new Error(t("workspace.terminal.hostDisconnected"));
+      }
+      const payload = await client.listProviderFeatures(draftConfig);
+      if (payload.error) {
+        throw new Error(payload.error);
+      }
+      return payload.features ?? [];
+    },
+  });
+  const availableFeaturesRaw = featuresQuery.data;
+  const availableFeatures = useMemo(() => availableFeaturesRaw ?? [], [availableFeaturesRaw]);
+  const featureValues = useMemo(
+    () =>
+      resolveFeatureValues({
+        features: availableFeatures,
+        persistedFeatureValues,
+        localFeatureValues,
+      }),
+    [availableFeatures, localFeatureValues, persistedFeatureValues],
+  );
+
+  const features = useMemo(() => {
+    return applyFeatureValues(availableFeatures, featureValues);
+  }, [availableFeatures, featureValues]);
+
+  useEffect(() => {
+    const previousProvider = previousProviderRef.current;
+    previousProviderRef.current = normalizedProvider;
+    if (previousProvider === null) {
+      return;
+    }
+    if (previousProvider !== normalizedProvider) {
+      setLocalFeatureValues({});
+    }
+  }, [normalizedProvider]);
+
+  useEffect(() => {
+    if (availableFeaturesRaw === undefined) {
+      return;
+    }
+    const next = pruneFeatureValues(localFeatureValues, availableFeatures);
+    if (next !== localFeatureValues) {
+      setLocalFeatureValues(next);
+    }
+  }, [availableFeatures, availableFeaturesRaw, localFeatureValues]);
+
+  const effectiveFeatureValues = Object.keys(featureValues).length > 0 ? featureValues : undefined;
+  const setFeatureValue = useCallback(
+    (featureId: string, value: unknown) => {
+      setLocalFeatureValues((current) => {
+        if (Object.is(current[featureId], value)) {
+          return current;
+        }
+
+        return { ...current, [featureId]: value };
+      });
+      if (!provider) {
+        return;
+      }
+      void updatePreferences((current) =>
+        mergeProviderPreferences({
+          preferences: current,
+          provider,
+          updates: {
+            featureValues: {
+              [featureId]: value,
+            },
+          },
+        }),
+      ).catch((error) => {
+        console.warn("[useDraftAgentFeatures] persist feature preference failed", error);
+      });
+    },
+    [provider, updatePreferences],
+  );
+
+  const applyProfileFeatureValues = useCallback((values: Record<string, unknown>) => {
+    setLocalFeatureValues(values);
+  }, []);
+
+  return {
+    features,
+    featureValues: effectiveFeatureValues,
+    isLoading: featuresQuery.isLoading,
+    setFeatureValue,
+    applyProfileFeatureValues,
+  };
+}

packages/app/src/hooks/use-draft-provider-options.ts

@@ -1,134 +0,0 @@
-import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
-import { useTranslation } from "react-i18next";
-import type { AgentProvider, ProviderOptions } from "@getpaseo/protocol/agent-types";
-import {
-  draftControlsRequest,
-  openDraftOptions,
-  ownDraftOptions,
-  shownDraftOptions,
-  viewDraftOptions,
-} from "@/agent-controls/draft-options-model";
-import type { ComposerOptionControls } from "@/agent-controls/option-controls";
-import { useFetchQuery } from "@/data/query";
-import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
-import { mergeProviderPreferences, useFormPreferences } from "./use-form-preferences";
-
-/**
- * Adapter between a draft's options model and the screen: it sends the model's complete options
- * to the daemon, hands the answer back, and persists the user's toggles as last-used values.
- */
-export function useDraftProviderOptions(input: {
-  serverId: string | null | undefined;
-  provider: AgentProvider | null;
-  /** The form's provider as it is now, which a render may not have reached yet. */
-  getProvider: () => AgentProvider | null;
-  cwd: string | null | undefined;
-  modeId: string | null | undefined;
-  modelId: string | null | undefined;
-  thinkingOptionId: string | null | undefined;
-  initialOptions?: ProviderOptions;
-}) {
-  const { t } = useTranslation();
-  const {
-    serverId,
-    provider,
-    getProvider,
-    cwd,
-    modeId,
-    modelId,
-    thinkingOptionId,
-    initialOptions,
-  } = input;
-  const [model] = useState(() =>
-    openDraftOptions({ provider, seed: initialOptions, currentProvider: getProvider }),
-  );
-  const state = useSyncExternalStore(model.subscribe, model.getState, model.getState);
-  const client = useHostRuntimeClient(serverId ?? "");
-  const isConnected = useHostRuntimeIsConnected(serverId ?? "");
-  const { preferences, updatePreferences } = useFormPreferences();
-  const normalizedCwd = cwd?.trim() || "";
-  const persisted = preferences.providerPreferences?.[provider ?? ""]?.options;
-
-  useEffect(() => model.observeProvider(provider), [model, provider]);
-  useEffect(() => model.setRemembered(persisted ?? {}), [model, persisted]);
-
-  const ownOptions = ownDraftOptions(state);
-  const draftConfig = useMemo(
-    () =>
-      draftControlsRequest(state, {
-        provider,
-        cwd: normalizedCwd,
-        modeId,
-        modelId,
-        thinkingOptionId,
-      }),
-    [modeId, modelId, normalizedCwd, provider, state, thinkingOptionId],
-  );
-  const queryKey = useMemo(
-    () => ["providerControls", serverId ?? null, draftConfig],
-    [draftConfig, serverId],
-  );
-  const requestKey = JSON.stringify(queryKey);
-
-  const { data } = useFetchQuery({
-    queryKey,
-    dataShape: "value",
-    staleTimeMs: 5 * 60 * 1000,
-    enabled: Boolean(serverId && client && isConnected && draftConfig),
-    queryFn: async () => {
-      if (!client || !draftConfig) {
-        throw new Error(t("workspace.terminal.hostDisconnected"));
-      }
-      const payload = await client.listProviderControls(draftConfig);
-      if (payload.error) {
-        throw new Error(payload.error);
-      }
-      return { controls: payload.controls ?? [], options: payload.options ?? {} };
-    },
-  });
-
-  useEffect(() => {
-    if (provider && data) model.applyResolved({ provider, requestKey, ...data });
-  }, [data, model, provider, requestKey]);
-
-  // An edit belongs to the provider the form has now, even before the render that shows it.
-  const setOption = useCallback(
-    (key: string, value: unknown) => {
-      model.setOption(key, value);
-      const current = getProvider();
-      if (!current) return;
-      void updatePreferences((stored) =>
-        mergeProviderPreferences({
-          preferences: stored,
-          provider: current,
-          updates: { options: { [key]: value } },
-        }),
-      ).catch((error) => {
-        console.warn("[useDraftProviderOptions] persist option preference failed", error);
-      });
-    },
-    [getProvider, model, updatePreferences],
-  );
-
-  const view = viewDraftOptions(state, { provider, requestKey });
-  const viewControls = view?.controls;
-  const viewOptions = view?.options;
-  const optionControls = useMemo<ComposerOptionControls | undefined>(
-    () =>
-      viewControls && viewOptions
-        ? { controls: viewControls, options: viewOptions, onSetOption: setOption }
-        : undefined,
-    [setOption, viewControls, viewOptions],
-  );
-
-  // What the draft will create with, the plugin's own edits included, before the daemon answers.
-  const shownOptions = shownDraftOptions(state, { provider, requestKey });
-
-  return {
-    optionControls,
-    options: ownOptions,
-    shownOptions,
-    setOption,
-    applyProfile: model.applyProfile,
-  };
-}

packages/app/src/hooks/use-fork-agent.ts

@@ -36,7 +36,7 @@ export type ForkAgentSource = Pick<
   | "model"
   | "thinkingOptionId"
   | "runtimeInfo"
-  | "options"
+  | "features"
   | "projectPlacement"
 >;
 
@@ -95,13 +95,18 @@ function buildForkDraftSetup(agent: ForkAgentSource): WorkspaceDraftTabSetup | u
     return undefined;
   }
 
+  const featureValues: Record<string, unknown> = {};
+  for (const feature of agent.features ?? []) {
+    featureValues[feature.id] = feature.value;
+  }
+
   return {
     provider: agent.provider,
     cwd: agent.cwd,
     modeId: agent.currentModeId ?? agent.runtimeInfo?.modeId ?? null,
     model: agent.model ?? agent.runtimeInfo?.model ?? null,
     thinkingOptionId: agent.thinkingOptionId ?? agent.runtimeInfo?.thinkingOptionId ?? null,
-    providerOptions: { ...agent.options },
+    featureValues,
   };
 }
 

packages/app/src/hooks/use-form-preferences.test.ts

@@ -63,7 +63,7 @@ describe("mergeProviderPreferences", () => {
           providerPreferences: {
             codex: {
               model: "gpt-5.4",
-              options: {
+              featureValues: {
                 fast_mode: true,
               },
             },
@@ -71,7 +71,7 @@ describe("mergeProviderPreferences", () => {
         },
         provider: "codex",
         updates: {
-          options: {
+          featureValues: {
             plan_mode: true,
           },
         },
@@ -81,7 +81,7 @@ describe("mergeProviderPreferences", () => {
       providerPreferences: {
         codex: {
           model: "gpt-5.4",
-          options: {
+          featureValues: {
             fast_mode: true,
             plan_mode: true,
           },

packages/app/src/panels/agent-panel.tsx

@@ -118,8 +118,7 @@ interface ChatAgentStateShape {
   model?: Agent["model"];
   thinkingOptionId?: Agent["thinkingOptionId"];
   runtimeInfo?: Agent["runtimeInfo"];
-  options?: Agent["options"];
-  controls?: Agent["controls"];
+  features?: Agent["features"];
   lastError?: Agent["lastError"] | null;
 }
 
@@ -178,8 +177,7 @@ function selectChatAgentState(
     model: agent.model,
     thinkingOptionId: agent.thinkingOptionId,
     runtimeInfo: agent.runtimeInfo,
-    options: agent.options,
-    controls: agent.controls,
+    features: agent.features,
     lastError: agent.lastError ?? null,
     archivedAt: agent.archivedAt ?? null,
     requiresAttention: agent.requiresAttention ?? false,
@@ -206,8 +204,7 @@ function buildChatAgentFromState(
     model: state.model,
     thinkingOptionId: state.thinkingOptionId,
     runtimeInfo: state.runtimeInfo,
-    options: state.options,
-    controls: state.controls,
+    features: state.features,
     lastError: state.lastError ?? null,
     projectPlacement,
   };
@@ -640,8 +637,7 @@ function AgentPanelBody({
           model: agentState.model,
           thinkingOptionId: agentState.thinkingOptionId,
           runtimeInfo: agentState.runtimeInfo,
-          options: agentState.options,
-          controls: agentState.controls,
+          features: agentState.features,
           lastError: agentState.lastError ?? null,
           projectPlacement,
         }

packages/app/src/plugins/buttons/model.test.ts

@@ -23,7 +23,6 @@ function installation(): InstalledPlugin {
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/client-state/snapshots.test.ts

@@ -53,7 +53,6 @@ const agent: Agent = {
   attentionReason: "permission",
   parentAgentId: null,
   labels: { phase: "implementation" },
-  metadata: { "linear.issue": { id: "ENG-1" } },
 };
 
 describe("plugin context snapshots", () => {
@@ -108,16 +107,12 @@ describe("plugin context snapshots", () => {
       attentionReason: "permission",
       parentAgentId: null,
       labels: { phase: "implementation" },
-      metadata: { "linear.issue": { id: "ENG-1" } },
     });
     expect(snapshot.labels).not.toBe(agent.labels);
     expect(Object.isFrozen(snapshot)).toBe(true);
     expect(Object.isFrozen(snapshot.labels)).toBe(true);
     expect(Reflect.set(snapshot, "title", "Hostile rename")).toBe(false);
     expect(Reflect.set(snapshot.labels, "phase", "hostile")).toBe(false);
-    const issue = snapshot.metadata["linear.issue"] as { id: string };
-    expect(Reflect.set(issue, "id", "hostile")).toBe(false);
-    expect(agent.metadata?.["linear.issue"]).toEqual({ id: "ENG-1" });
     expect(snapshot.title).toBe("Implement plugin panels");
     expect(snapshot.labels).toEqual({ phase: "implementation" });
     expect(agent.title).toBe("Implement plugin panels");

packages/app/src/plugins/client-state/snapshots.ts

@@ -1,6 +1,5 @@
 import type { PluginAgentSnapshot, PluginWorkspaceSnapshot } from "@getpaseo/plugin";
 import type { Agent, WorkspaceDescriptor } from "@/stores/session-store";
-import { cloneAndFreeze } from "../freeze";
 
 const workspaceSnapshots = new WeakMap<WorkspaceDescriptor, PluginWorkspaceSnapshot>();
 const agentSnapshots = new WeakMap<Agent, Map<string, PluginAgentSnapshot>>();
@@ -50,7 +49,6 @@ export function createPluginAgentSnapshot(agent: Agent, workspaceId: string): Pl
     attentionReason: agent.attentionReason ?? null,
     parentAgentId: agent.parentAgentId,
     labels: Object.freeze({ ...agent.labels }),
-    metadata: cloneAndFreeze(agent.metadata ?? {}),
   });
   const byWorkspace = agentSnapshots.get(agent) ?? new Map<string, PluginAgentSnapshot>();
   byWorkspace.set(workspaceId, snapshot);

packages/app/src/plugins/command-center/contributions.test.ts

@@ -46,7 +46,6 @@ const agent: PluginAgentSnapshot = {
   attentionReason: null,
   parentAgentId: null,
   labels: {},
-  metadata: {},
 };
 
 const inspect = defineRpc({
@@ -83,7 +82,6 @@ function plugin(onAgentSelect: AgentCommandItem["onSelect"]): InstalledPlugin {
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [
       {
         id: "details",

packages/app/src/plugins/composer-items/index.tsx

@@ -1,138 +0,0 @@
-import { useMemo, useSyncExternalStore } from "react";
-import type { PluginHostProps } from "@getpaseo/plugin/client";
-import { PluginComposerProvider } from "@getpaseo/plugin/client/host";
-import { withUnistyles } from "react-native-unistyles";
-import {
-  ComposerControlSurfaceProvider,
-  type ComposerControlSurface,
-} from "@/composer/agent-controls/composer-control";
-import { useComposerAgent, useComposerInput } from "@/composer/session";
-import { useIsCompactFormFactor } from "@/constants/layout";
-import { useToast } from "@/contexts/toast-api-context";
-import { useHosts } from "@/runtime/host-runtime";
-import type { Theme } from "@/styles/theme";
-import { createPluginClientStateSource } from "../client-state/source";
-import { resolvePluginPlatform } from "../platform";
-import { PluginEnvironmentProvider, type PluginEnvironment } from "../popover";
-import { useInstalledPlugins } from "../registry";
-import { SurfaceErrorBoundary } from "../surface-error-boundary";
-import { toPluginTheme } from "../theme";
-import type { InstalledPlugin } from "../types";
-import { toPluginComposer } from "./model";
-
-const pluginThemeMapping = (theme: Theme) => ({ theme: toPluginTheme(theme) });
-
-function renderNothing() {
-  return null;
-}
-
-function useServerPlugins(serverId: string | null): InstalledPlugin[] {
-  const installed = useInstalledPlugins();
-  return useMemo(
-    () =>
-      serverId === null
-        ? []
-        : installed.filter(
-            (plugin) => plugin.serverId === serverId && plugin.composerItems.length > 0,
-          ),
-    [installed, serverId],
-  );
-}
-
-/** How many composer items the host's plugins registered; the toolbar budgets room for them. */
-export function usePluginComposerItemCount(serverId: string | null): number {
-  const plugins = useServerPlugins(serverId);
-  return plugins.reduce((count, plugin) => count + plugin.composerItems.length, 0);
-}
-
-/**
- * The host's plugin composer items. They read and command the composer they are mounted in, so
- * they render only where a composer provides its input and agent.
- */
-export function PluginComposerItems({
-  serverId,
-  surface,
-}: {
-  serverId: string | null;
-  surface: ComposerControlSurface;
-}) {
-  const plugins = useServerPlugins(serverId);
-  if (serverId === null || plugins.length === 0) return null;
-  return (
-    <ComposerControlSurfaceProvider value={surface}>
-      {plugins.map((plugin) => (
-        <ThemedPluginComposerItems key={plugin.id} plugin={plugin} uniProps={pluginThemeMapping} />
-      ))}
-    </ComposerControlSurfaceProvider>
-  );
-}
-
-function PluginComposerItemsHost({
-  plugin,
-  theme,
-}: {
-  plugin: InstalledPlugin;
-  theme: PluginHostProps["theme"];
-}) {
-  const agent = useComposerAgent();
-  const composerInput = useComposerInput();
-  const toast = useToast();
-  const compact = useIsCompactFormFactor();
-  const hosts = useHosts();
-  const hostLabel =
-    hosts.find((host) => host.serverId === plugin.serverId)?.label ?? plugin.serverId;
-  const textSource = composerInput?.textSource;
-  const prompt = useSyncExternalStore(
-    textSource?.subscribe ?? subscribeNothing,
-    textSource?.getSnapshot ?? emptyText,
-    textSource?.getSnapshot ?? emptyText,
-  );
-  const environment = useMemo<PluginEnvironment>(
-    () => ({
-      installation: plugin,
-      toast,
-      state: createPluginClientStateSource(plugin.serverId),
-    }),
-    [plugin, toast],
-  );
-  const composer = useMemo(
-    () =>
-      agent && composerInput ? toPluginComposer({ plugin, agent, composerInput, prompt }) : null,
-    [agent, composerInput, plugin, prompt],
-  );
-  const props = useMemo<PluginHostProps>(
-    () => ({
-      theme,
-      host: { id: plugin.serverId, label: hostLabel },
-      layout: { compact, platform: resolvePluginPlatform() },
-    }),
-    [compact, hostLabel, plugin.serverId, theme],
-  );
-  if (!composer) return null;
-  return (
-    <PluginEnvironmentProvider environment={environment}>
-      <PluginComposerProvider composer={composer}>
-        {plugin.composerItems.map(({ id, Component }) => (
-          <SurfaceErrorBoundary
-            key={id}
-            installation={plugin}
-            Surface={Component}
-            renderError={renderNothing}
-          >
-            <Component {...props} />
-          </SurfaceErrorBoundary>
-        ))}
-      </PluginComposerProvider>
-    </PluginEnvironmentProvider>
-  );
-}
-
-const ThemedPluginComposerItems = withUnistyles(PluginComposerItemsHost);
-
-function subscribeNothing() {
-  return () => undefined;
-}
-
-function emptyText() {
-  return "";
-}

packages/app/src/plugins/composer-items/model.test.ts

@@ -1,311 +0,0 @@
-import { defineRpc } from "@getpaseo/plugin";
-import { PluginTranslationRuntime } from "@getpaseo/plugin/client/host";
-import { QueryClient } from "@tanstack/react-query";
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
-import { z } from "zod";
-import { describe, expect, it } from "vitest";
-import type { UserComposerAttachment } from "@/attachments/types";
-import type { ComposerAgent, ComposerInput } from "@/composer/session";
-import type { InstalledPlugin } from "../types";
-import { toPluginComposer } from "./model";
-
-function installed(): InstalledPlugin {
-  return {
-    id: "review",
-    serverId: "host-1",
-    clientBundle: "bundle",
-    lifetime: new AbortController(),
-    locale: "en",
-    i18n: new PluginTranslationRuntime({ getLocale: () => "en", subscribe: () => () => {} }),
-    queryClient: new QueryClient(),
-    paseo: {} as InstalledPlugin["paseo"],
-    invoke: async () => undefined,
-    cleanup: () => {},
-    settingsScreens: [],
-    surfaces: [],
-    sidebarItems: { header: [], footer: [] },
-    legacySidebarItems: [],
-    filePanels: [],
-    composerItems: [],
-    workspacePanels: [],
-    commandCenterItems: [],
-    clientSlashCommands: [],
-    attachmentSources: [
-      {
-        id: "issues",
-        title: "Issues",
-        pickerTitle: "Issues",
-        searchPlaceholder: "Search issues",
-        icon: "Bug",
-        search: defineRpc({
-          name: "issues.search",
-          input: z.object({}),
-          output: z.array(z.object({})),
-        }),
-      },
-    ],
-    themes: [],
-    timelineTransformers: [],
-    timelineRenderers: [],
-  };
-}
-
-const issue = {
-  id: "ISS-1",
-  identifier: "ISS-1",
-  title: "Fix it",
-  url: "https://example.com/ISS-1",
-  text: "Fix it",
-  resourceType: "issue",
-};
-
-function fakeAgent(context: ComposerAgent["context"], locked = false) {
-  const calls: string[] = [];
-  const agent: ComposerAgent = {
-    context,
-    locked,
-    isLocked: () => locked,
-    provider: "claude",
-    model: "sonnet",
-    mode: "default",
-    thinking: null,
-    options: { effort: "high" },
-    metadata: { flag: true },
-    // A running agent keeps its provider, as the real adapter does.
-    setProvider: async (provider) => {
-      if (context === "agent") throw new Error("A running agent cannot change provider.");
-      calls.push(`provider:${provider}`);
-    },
-    setModel: async (model) => void calls.push(`model:${model}`),
-    setMode: async (mode) => void calls.push(`mode:${mode}`),
-    setThinking: async (thinking) => void calls.push(`thinking:${thinking}`),
-    setOptions: async (patch) => void calls.push(`options:${JSON.stringify(patch)}`),
-    setMetadata: async (patch: Record<string, JsonValue>) =>
-      void calls.push(`metadata:${JSON.stringify(patch)}`),
-  };
-  return { agent, calls };
-}
-
-function fakeInput(initial: UserComposerAttachment[] = [], locked = false) {
-  const state = { text: "", attachments: initial };
-  const input: ComposerInput = {
-    locked,
-    isLocked: () => locked,
-    textSource: { getSnapshot: () => state.text, subscribe: () => () => {} },
-    setText: (text) => {
-      state.text = text;
-    },
-    insertText: (text) => {
-      state.text += text;
-    },
-    get attachments() {
-      return state.attachments;
-    },
-    changeAttachments: (updater) => {
-      state.attachments = updater(state.attachments);
-    },
-  };
-  return { input, state };
-}
-
-describe("toPluginComposer", () => {
-  it("reads the agent the composer configures and the context it sits in", () => {
-    const { agent } = fakeAgent("new-workspace");
-    const { input } = fakeInput();
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "hello",
-    });
-    expect(composer.context).toBe("new-workspace");
-    expect(composer.prompt).toBe("hello");
-    expect(composer.agent).toEqual({
-      provider: "claude",
-      model: "sonnet",
-      mode: "default",
-      thinking: null,
-      options: { effort: "high" },
-      metadata: { flag: true },
-    });
-  });
-
-  it.each(["agent", "draft"] as const)(
-    "sends every command to the %s composer's agent",
-    async (context) => {
-      const { agent, calls } = fakeAgent(context);
-      const { input } = fakeInput();
-      const composer = toPluginComposer({
-        plugin: installed(),
-        agent,
-        composerInput: input,
-        prompt: "",
-      });
-      await composer.setModel("gpt");
-      await composer.setMode("plan");
-      await composer.setThinking("high");
-      await composer.setOptions({ effort: "low" });
-      await composer.setMetadata({ flag: null });
-      expect(calls).toEqual([
-        "model:gpt",
-        "mode:plan",
-        "thinking:high",
-        'options:{"effort":"low"}',
-        'metadata:{"flag":null}',
-      ]);
-    },
-  );
-
-  it("lets a draft change provider and tells a running agent it cannot", async () => {
-    const { input } = fakeInput();
-    const draft = fakeAgent("draft");
-    await toPluginComposer({
-      plugin: installed(),
-      agent: draft.agent,
-      composerInput: input,
-      prompt: "",
-    }).setProvider("codex");
-    expect(draft.calls).toEqual(["provider:codex"]);
-
-    const running = fakeAgent("agent");
-    await expect(
-      toPluginComposer({
-        plugin: installed(),
-        agent: running.agent,
-        composerInput: input,
-        prompt: "",
-      }).setProvider("codex"),
-    ).rejects.toThrow("A running agent cannot change provider.");
-    expect(running.calls).toEqual([]);
-  });
-
-  it("changes the prompt and inserts at the cursor", () => {
-    const { agent } = fakeAgent("draft");
-    const { input, state } = fakeInput();
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-    composer.setPrompt("a");
-    composer.insertText("b");
-    expect(state.text).toBe("ab");
-  });
-
-  it("refuses every prompt and agent command while the composer is locked", async () => {
-    const { agent, calls } = fakeAgent("new-workspace", true);
-    const { input, state } = fakeInput([], true);
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-
-    expect(() => composer.setPrompt("a")).toThrow("The composer is locked");
-    expect(() => composer.insertText("b")).toThrow("The composer is locked");
-    expect(() => composer.addAttachment({ sourceId: "issues", item: issue })).toThrow(
-      "The composer is locked",
-    );
-    await expect(composer.setProvider("codex")).rejects.toThrow("The composer is locked");
-    await expect(composer.setModel("gpt")).rejects.toThrow("The composer is locked");
-    await expect(composer.setMode("plan")).rejects.toThrow("The composer is locked");
-    await expect(composer.setThinking("high")).rejects.toThrow("The composer is locked");
-    await expect(composer.setOptions({ effort: "low" })).rejects.toThrow("The composer is locked");
-    await expect(composer.setMetadata({ flag: null })).rejects.toThrow("The composer is locked");
-    expect(state.text).toBe("");
-    expect(calls).toEqual([]);
-  });
-
-  it("refuses a command a plugin kept from before the composer locked", async () => {
-    const { agent } = fakeAgent("new-workspace");
-    const { input } = fakeInput();
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-
-    // The plugin's action was awaiting an RPC when the user submitted.
-    const lock = { locked: true };
-    agent.isLocked = () => lock.locked;
-    input.isLocked = () => lock.locked;
-
-    expect(() => composer.insertText("late")).toThrow("The composer is locked");
-    expect(() => composer.addAttachment({ sourceId: "issues", item: issue })).toThrow(
-      "The composer is locked",
-    );
-    expect(() => composer.removeAttachment({ sourceId: "issues", itemId: issue.id })).toThrow(
-      "The composer is locked",
-    );
-    await expect(composer.setOptions({ effort: "low" })).rejects.toThrow("The composer is locked");
-  });
-
-  it("hands out options and metadata a plugin cannot change", () => {
-    const { agent } = fakeAgent("draft");
-    agent.metadata = { nested: { list: [1] } };
-    const { input } = fakeInput();
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-
-    expect(Object.isFrozen(composer.agent.options)).toBe(true);
-    expect(Object.isFrozen(composer.agent.metadata)).toBe(true);
-    expect(Object.isFrozen((composer.agent.metadata as { nested: object }).nested)).toBe(true);
-    expect(agent.metadata).toEqual({ nested: { list: [1] } });
-    expect(Object.isFrozen(agent.metadata)).toBe(false);
-  });
-
-  it("adds and removes the plugin's own attachments only", () => {
-    const { agent } = fakeAgent("agent");
-    const other: UserComposerAttachment = {
-      kind: "plugin_resource",
-      pluginId: "other",
-      sourceId: "issues",
-      sourceTitle: "Issues",
-      sourceIcon: "Bug",
-      item: issue,
-    };
-    const { input, state } = fakeInput([other]);
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-
-    composer.addAttachment({ sourceId: "issues", item: issue });
-    composer.addAttachment({ sourceId: "issues", item: issue });
-    expect(state.attachments).toHaveLength(2);
-
-    const next = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-    expect(next.attachments).toEqual([{ sourceId: "issues", item: issue }]);
-
-    composer.removeAttachment({ sourceId: "issues", itemId: "ISS-1" });
-    expect(state.attachments).toEqual([other]);
-  });
-
-  it("rejects an attachment from a source the plugin did not register", () => {
-    const { agent } = fakeAgent("agent");
-    const { input } = fakeInput();
-    const composer = toPluginComposer({
-      plugin: installed(),
-      agent,
-      composerInput: input,
-      prompt: "",
-    });
-    expect(() => composer.addAttachment({ sourceId: "nope", item: issue })).toThrow(
-      "Unknown attachment source: nope",
-    );
-  });
-});

packages/app/src/plugins/composer-items/model.ts

@@ -1,103 +0,0 @@
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
-import type { PluginComposer } from "@getpaseo/plugin/client";
-import type { UserComposerAttachment } from "@/attachments/types";
-import type { ComposerAgent, ComposerInput } from "@/composer/session";
-import type { InstalledPlugin } from "../types";
-import { createPluginResourceAttachment } from "../attachments/model";
-import { cloneAndFreeze } from "../freeze";
-
-function isPluginAttachment(
-  attachment: UserComposerAttachment,
-  pluginId: string,
-  sourceId: string,
-  itemId?: string,
-): boolean {
-  return (
-    attachment.kind === "plugin_resource" &&
-    attachment.pluginId === pluginId &&
-    attachment.sourceId === sourceId &&
-    (itemId === undefined || attachment.item.id === itemId)
-  );
-}
-
-const LOCKED_MESSAGE = "The composer is locked while the agent is being created.";
-
-function assertUnlocked(isLocked: () => boolean): void {
-  if (isLocked()) throw new Error(LOCKED_MESSAGE);
-}
-
-async function whenUnlocked(agent: ComposerAgent, command: () => Promise<void>): Promise<void> {
-  assertUnlocked(agent.isLocked);
-  await command();
-}
-
-/**
- * What a plugin sees of the composer it sits in. `agent` and `input` are the composer's own
- * halves, so the plugin's commands reach the same models the built-in controls use.
- */
-export function toPluginComposer(input: {
-  plugin: InstalledPlugin;
-  agent: ComposerAgent;
-  composerInput: ComposerInput;
-  prompt: string;
-}): PluginComposer {
-  const { plugin, agent, composerInput, prompt } = input;
-  return {
-    context: agent.context,
-    prompt,
-    attachments: composerInput.attachments.flatMap((attachment) =>
-      attachment.kind === "plugin_resource" && attachment.pluginId === plugin.id
-        ? [{ sourceId: attachment.sourceId, item: attachment.item }]
-        : [],
-    ),
-    // Provider options are JSON on the wire.
-    agent: {
-      provider: agent.provider,
-      model: agent.model,
-      mode: agent.mode,
-      thinking: agent.thinking,
-      options: cloneAndFreeze(agent.options as Record<string, JsonValue>),
-      metadata: cloneAndFreeze(agent.metadata),
-    },
-    setPrompt: (text) => {
-      assertUnlocked(composerInput.isLocked);
-      composerInput.setText(text);
-    },
-    insertText: (text) => {
-      assertUnlocked(composerInput.isLocked);
-      composerInput.insertText(text);
-    },
-    addAttachment({ sourceId, item }) {
-      assertUnlocked(composerInput.isLocked);
-      const source = plugin.attachmentSources.find((candidate) => candidate.id === sourceId);
-      if (!source) throw new Error(`Unknown attachment source: ${sourceId}`);
-      const attachment = createPluginResourceAttachment(
-        {
-          pluginId: plugin.id,
-          sourceId,
-          sourceTitle: plugin.i18n.resolve(source.title, plugin.locale),
-          sourceIcon: source.icon,
-        },
-        item,
-      );
-      composerInput.changeAttachments((current) =>
-        current.some((candidate) => isPluginAttachment(candidate, plugin.id, sourceId, item.id))
-          ? current
-          : [...current, attachment],
-      );
-    },
-    removeAttachment({ sourceId, itemId }) {
-      assertUnlocked(composerInput.isLocked);
-      composerInput.changeAttachments((current) =>
-        current.filter((candidate) => !isPluginAttachment(candidate, plugin.id, sourceId, itemId)),
-      );
-    },
-    setProvider: (provider) => whenUnlocked(agent, () => agent.setProvider(provider)),
-    setModel: (modelId) => whenUnlocked(agent, () => agent.setModel(modelId)),
-    setMode: (modeId) => whenUnlocked(agent, () => agent.setMode(modeId)),
-    setThinking: (thinkingOptionId) =>
-      whenUnlocked(agent, () => agent.setThinking(thinkingOptionId)),
-    setOptions: (patch) => whenUnlocked(agent, () => agent.setOptions(patch)),
-    setMetadata: (patch) => whenUnlocked(agent, () => agent.setMetadata(patch)),
-  };
-}

packages/app/src/plugins/evaluate.test.ts

@@ -531,38 +531,6 @@ describe("evaluatePluginClientBundle", () => {
     ).toThrow("Duplicate Command Center item: review");
   });
 
-  it("collects composer items and releases an id on removal", () => {
-    const plugin = evaluatePluginClientBundle(
-      "review",
-      bundle(`
-        function Item() { return null; }
-        const remove = plugin.addComposerItem({ id: "flag", Component: Item });
-        remove();
-        plugin.addComposerItem({ id: "flag", Component: Item });
-      `),
-    );
-    expect(plugin.composerItems.map((item) => item.id)).toEqual(["flag"]);
-  });
-
-  it("rejects duplicate and non-component composer items", () => {
-    expect(() =>
-      evaluatePluginClientBundle(
-        "review",
-        bundle(`
-          function Item() { return null; }
-          plugin.addComposerItem({ id: "flag", Component: Item });
-          plugin.addComposerItem({ id: "flag", Component: Item });
-        `),
-      ),
-    ).toThrow("Duplicate composer item: flag");
-    expect(() =>
-      evaluatePluginClientBundle(
-        "review",
-        bundle(`plugin.addComposerItem({ id: "flag", Component: "nope" })`),
-      ),
-    ).toThrow("Composer item flag is not a component");
-  });
-
   it("runs the client entry with the full runtime context", () => {
     const plugin = evaluatePluginClientBundle(
       "review",

packages/app/src/plugins/evaluate.ts

@@ -131,7 +131,6 @@ export function runPluginClientBundle(
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],
@@ -147,7 +146,6 @@ export function runPluginClientBundle(
     footer: new Set(),
   };
   const filePanelIds = new Set<string>();
-  const composerItemIds = new Set<string>();
   const workspacePanelIds = new Set<string>();
   const commandCenterItemIds = new Set<string>();
   const clientSlashCommandNames = new Set<string>();
@@ -271,20 +269,6 @@ export function runPluginClientBundle(
         () => surfaceIds.delete(normalizedId),
       );
     },
-    addComposerItem(contribution) {
-      const normalizedId = requireId(contribution.id, "composer item id");
-      if (composerItemIds.has(normalizedId))
-        throw new Error(`Duplicate composer item: ${normalizedId}`);
-      if (!isComponentType(contribution.Component)) {
-        throw new Error(`Composer item ${normalizedId} is not a component`);
-      }
-      composerItemIds.add(normalizedId);
-      return register(
-        collector.composerItems,
-        { id: normalizedId, Component: contribution.Component },
-        () => composerItemIds.delete(normalizedId),
-      );
-    },
     addSidebarHeaderItem(contribution: PluginSidebarItemContribution) {
       return addSidebarItem("header", contribution);
     },
@@ -601,7 +585,6 @@ export function runPluginClientBundle(
     sidebarItems: collector.sidebarItems,
     legacySidebarItems: collector.legacySidebarItems,
     filePanels: collector.filePanels,
-    composerItems: collector.composerItems,
     workspacePanels: collector.workspacePanels as EvaluatedPlugin["workspacePanels"],
     commandCenterItems: collector.commandCenterItems,
     clientSlashCommands: collector.clientSlashCommands,

packages/app/src/plugins/freeze.ts

@@ -1,12 +0,0 @@
-/** A deep copy no plugin can change. Plugins read data through it, never the host's own objects. */
-export function cloneAndFreeze<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return Object.freeze(value.map((entry) => cloneAndFreeze(entry))) as T;
-  }
-  if (value !== null && typeof value === "object") {
-    return Object.freeze(
-      Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneAndFreeze(entry)])),
-    ) as T;
-  }
-  return value;
-}

packages/app/src/plugins/icons.ts

@@ -25,11 +25,6 @@ function findLucideIcon(name: string): LucideIcon | null {
   return isComponent(candidate) ? (candidate as LucideIcon) : null;
 }
 
-/** Whether `name` is a Lucide icon, so a caller can fall back before drawing nothing. */
-export function isLucideIconName(name: string): boolean {
-  return findLucideIcon(name) !== null;
-}
-
 function isComponent(value: unknown): boolean {
   return (
     typeof value === "function" ||

packages/app/src/plugins/installation-provider.test.tsx

@@ -36,7 +36,6 @@ function installation(invoked: string[]): InstalledPlugin {
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/react-native/composer-controls.tsx

@@ -1,87 +0,0 @@
-import type { ActionProps, SelectProps, ToggleProps } from "@getpaseo/plugin/client/ui";
-import { useMemo, useState } from "react";
-import {
-  ComposerControl,
-  useComposerControlSurface,
-  type ComposerControlItem,
-} from "@/composer/agent-controls/composer-control";
-import { useComposerLocked } from "@/composer/session";
-import { parsePluginIcon, pluginIconComponent } from "../icons";
-
-/** Icons resolve at render, so an invalid one throws to the item's boundary. */
-function usePluginControlIcon(icon: ToggleProps["icon"]) {
-  return useMemo(() => pluginIconComponent(parsePluginIcon("Composer control", icon)), [icon]);
-}
-
-/** Draws one plugin control where its composer item sits: inline, or as a row in the sheet. */
-function PluginComposerControl({
-  item,
-  disabled,
-}: {
-  item: ComposerControlItem;
-  disabled: boolean | undefined;
-}) {
-  const surface = useComposerControlSurface();
-  const locked = useComposerLocked();
-  const [open, setOpen] = useState(false);
-  return (
-    <ComposerControl
-      item={item}
-      surface={surface}
-      disabled={disabled || locked}
-      open={open}
-      onOpenChange={setOpen}
-    />
-  );
-}
-
-export function Toggle({ title, icon, disabled, value, onValueChange }: ToggleProps) {
-  const Icon = usePluginControlIcon(icon);
-  const item = useMemo<ComposerControlItem>(
-    () => ({
-      id: "plugin-toggle",
-      type: "toggle",
-      title,
-      icon: Icon,
-      highlight: value ? "blue" : undefined,
-      value,
-      onChange: (next) => onValueChange({ value: next }),
-    }),
-    [Icon, onValueChange, title, value],
-  );
-  return <PluginComposerControl item={item} disabled={disabled} />;
-}
-
-export function Select<Value extends string>({
-  title,
-  icon,
-  disabled,
-  value,
-  options,
-  onValueChange,
-}: SelectProps<Value>) {
-  const Icon = usePluginControlIcon(icon);
-  const item = useMemo<ComposerControlItem>(
-    () => ({
-      id: "plugin-select",
-      type: "select",
-      title,
-      icon: Icon,
-      value,
-      choices: options,
-      onChange: (next) => onValueChange({ value: next as Value }),
-      showCaret: true,
-    }),
-    [Icon, onValueChange, options, title, value],
-  );
-  return <PluginComposerControl item={item} disabled={disabled} />;
-}
-
-export function Action({ title, icon, disabled, onPress }: ActionProps) {
-  const Icon = usePluginControlIcon(icon);
-  const item = useMemo<ComposerControlItem>(
-    () => ({ id: "plugin-action", type: "action", title, icon: Icon, onPress: () => onPress({}) }),
-    [Icon, onPress, title],
-  );
-  return <PluginComposerControl item={item} disabled={disabled} />;
-}

packages/app/src/plugins/react-native/ui.ts

@@ -20,7 +20,6 @@ export { FilePanelLoading as Loading } from "@/file-panels/loading";
 export { SettingsGroup } from "@/components/settings";
 
 export { Icon } from "../icons";
-export { Action, Select, Toggle } from "./composer-controls";
 export { Modal } from "./modal";
 export { ScrollView, FlatList } from "./scroll-view";
 export { TextInput } from "./text-input";

packages/app/src/plugins/registry.ts

@@ -106,7 +106,6 @@ export class PluginRegistry {
           sidebarItems: { header: [], footer: [] },
           legacySidebarItems: [],
           filePanels: [],
-          composerItems: [],
           workspacePanels: [],
           commandCenterItems: [],
           clientSlashCommands: [],

packages/app/src/plugins/sidebar-groups.test.ts

@@ -34,7 +34,6 @@ function installed(
     },
     legacySidebarItems,
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/surface-contribution.test.ts

@@ -36,7 +36,6 @@ function installation(
       icon: "Blocks",
     })),
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/theme.test.ts

@@ -61,7 +61,6 @@ function installed(serverId: string, themes: PluginThemeContribution[]): Install
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/timeline/model.test.ts

@@ -24,7 +24,6 @@ function plugin(input: {
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [],
     commandCenterItems: [],
     clientSlashCommands: [],

packages/app/src/plugins/timeline/projection.ts

@@ -1,6 +1,5 @@
 import type { AgentTimelineItem, ToolCallTimelineItem } from "@getpaseo/protocol/agent-types";
 import type { AgentToolCallData, PluginTimelineStreamItem, StreamItem } from "@/types/stream";
-import { cloneAndFreeze } from "../freeze";
 import type { TimelineItemTransform } from "./model";
 
 type AssistantPhase = "streaming" | "complete";
@@ -10,6 +9,18 @@ const projectionCache = new WeakMap<
   WeakMap<StreamItem, Partial<Record<AssistantPhase, StreamItem[]>>>
 >();
 
+function cloneAndFreeze<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((entry) => cloneAndFreeze(entry))) as T;
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.freeze(
+      Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneAndFreeze(entry)])),
+    ) as T;
+  }
+  return value;
+}
+
 function sourceToolCallTimelineItem(data: AgentToolCallData): ToolCallTimelineItem {
   const { callId, name, status, error, detail, metadata } = data;
   const base = {

packages/app/src/plugins/types.ts

@@ -11,7 +11,6 @@ import type {
   PluginFilePanelContribution as SDKPluginFilePanelContribution,
   PluginCommandCenterItemContribution as SDKPluginCommandCenterItemContribution,
   PluginClientSlashCommandContribution as SDKPluginClientSlashCommandContribution,
-  PluginComposerItemContribution,
   PluginComposerPillContribution as SDKPluginComposerPillContribution,
   PluginSidebarContribution as SDKPluginSidebarContribution,
   PluginSidebarItemContribution as SDKPluginSidebarItemContribution,
@@ -54,7 +53,6 @@ export interface EvaluatedPlugin {
   /** `addSidebarItem` registrations, so `/plugin/<id>/sidebar/<item>` routes keep resolving. */
   legacySidebarItems: PluginSidebarContribution[];
   filePanels: PluginFilePanelContribution[];
-  composerItems: PluginComposerItemContribution[];
   workspacePanels: EvaluatedPluginWorkspacePanelContribution[];
   commandCenterItems: PluginCommandCenterItemContribution[];
   clientSlashCommands: PluginClientSlashCommandContribution[];
@@ -84,7 +82,6 @@ export type {
   PluginAttachmentSourceContribution,
   PluginCommandCenterItemContribution,
   PluginClientSlashCommandContribution,
-  PluginComposerItemContribution,
   PluginComposerPillContribution,
   PluginSidebarContribution,
   PluginSidebarItemContribution,

packages/app/src/plugins/workspace-panels/resolution.test.ts

@@ -21,7 +21,6 @@ function installed(): InstalledPlugin {
     sidebarItems: { header: [], footer: [] },
     legacySidebarItems: [],
     filePanels: [],
-    composerItems: [],
     workspacePanels: [
       {
         id: "details",

packages/app/src/provider-selection/agent-form-store.ts

@@ -1,93 +0,0 @@
-import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
-import type { AgentModelDefinition, AgentProvider } from "@getpaseo/protocol/agent-types";
-import type { FormPreferences } from "@/hooks/use-form-preferences";
-import {
-  INITIAL_AGENT_FORM_RESOLUTION,
-  INITIAL_USER_MODIFIED,
-  isUnlistedModel,
-  resolveAgentForm,
-  type AgentFormAction,
-  type AgentFormReducerState,
-} from "@/provider-selection/resolve-agent-form";
-
-/** What the host offers right now. The store reads it when a command runs, never earlier. */
-export interface AgentFormCatalog {
-  /** The providers the host can run. */
-  selectableProviders: ReadonlyMap<AgentProvider, AgentProviderDefinition>;
-  /** Each provider's selectable models; empty when the host has listed none. */
-  models: ReadonlyMap<string, AgentModelDefinition[]>;
-  providerPreferences: (
-    provider: AgentProvider,
-  ) => NonNullable<FormPreferences["providerPreferences"]>[AgentProvider] | undefined;
-}
-
-/**
- * The draft form as a plain model: `resolveAgentForm` applied synchronously. A command reads
- * `getState()` and the catalog when it runs, so the one after `await setProvider(...)` sees the
- * new provider instead of the render that created it.
- */
-export interface AgentFormStore {
-  getState: () => AgentFormReducerState;
-  dispatch: (action: AgentFormAction) => void;
-  subscribe: (listener: () => void) => () => void;
-  /** `false` when the provider is unknown or not ready; the form is left as it was. */
-  setProviderAndModel: (provider: AgentProvider, modelId: string) => boolean;
-  /**
-   * `false` when the provider's catalog is loaded and does not list the model. A catalog that has
-   * not arrived keeps the id as given.
-   */
-  setModel: (modelId: string) => boolean;
-}
-
-export function openAgentForm(catalog: () => AgentFormCatalog): AgentFormStore {
-  let state: AgentFormReducerState = {
-    form: { provider: null, modeId: "", model: "", thinkingOptionId: "" },
-    userModified: INITIAL_USER_MODIFIED,
-    resolution: INITIAL_AGENT_FORM_RESOLUTION,
-  };
-  const listeners = new Set<() => void>();
-  function dispatch(action: AgentFormAction): void {
-    const next = resolveAgentForm(state, action);
-    if (next === state) return;
-    state = next;
-    for (const listener of listeners) listener();
-  }
-  return {
-    getState: () => state,
-    dispatch,
-    setProviderAndModel: (provider, modelId) => {
-      const host = catalog();
-      const providerDef = host.selectableProviders.get(provider);
-      if (!providerDef) return false;
-      dispatch({
-        type: "SET_PROVIDER_AND_MODEL_FROM_USER",
-        provider,
-        modelId,
-        providerDef,
-        providerModels: host.models.get(provider) ?? null,
-        providerPrefs: host.providerPreferences(provider),
-      });
-      return true;
-    },
-    setModel: (modelId) => {
-      const { provider } = state.form;
-      const host = catalog();
-      const listed = provider ? host.models.get(provider) : undefined;
-      const models = listed?.length ? listed : null;
-      if (isUnlistedModel(models, modelId)) return false;
-      dispatch({
-        type: "SET_MODEL_FROM_USER",
-        modelId,
-        availableModels: models,
-        providerPrefs: provider ? host.providerPreferences(provider) : undefined,
-      });
-      return true;
-    },
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-  };
-}

packages/app/src/provider-selection/provider-selection.ts

@@ -312,7 +312,7 @@ export function buildDraftCommandTarget(input: {
   cwd: string;
   effectiveModelId: string;
   effectiveThinkingOptionId: string;
-  providerOptions?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }): DraftCommandTarget {
   const cwd = input.cwd.trim();
   if (!cwd) {
@@ -332,7 +332,7 @@ export function buildDraftCommandTarget(input: {
     ...(input.effectiveThinkingOptionId
       ? { thinkingOptionId: input.effectiveThinkingOptionId }
       : {}),
-    ...(input.providerOptions ? { providerOptions: input.providerOptions } : {}),
+    ...(input.featureValues ? { featureValues: input.featureValues } : {}),
   };
   return { status: "ready", config };
 }

packages/app/src/provider-selection/resolve-agent-form.test.ts

@@ -3,7 +3,6 @@ import {
   resolveAgentForm,
   resolveFormState,
   resolveEffectiveModel,
-  isUnlistedModel,
   resolveThinkingOptionId,
   mergeSelectedComposerPreferences,
   buildProviderDefinitionMap,
@@ -132,19 +131,6 @@ describe("resolveDefaultModel", () => {
   });
 });
 
-describe("isUnlistedModel", () => {
-  it("rejects an id the provider's catalog lacks, and accepts a listed id or alias", () => {
-    expect(isUnlistedModel(ALIASED_CODEX_MODELS, "not-in-the-catalog")).toBe(true);
-    expect(isUnlistedModel(ALIASED_CODEX_MODELS, "gpt-5.3-codex")).toBe(false);
-    expect(isUnlistedModel(ALIASED_CODEX_MODELS, "gpt-5.3-codex-legacy")).toBe(false);
-  });
-
-  it("accepts any id while the provider has listed no models", () => {
-    expect(isUnlistedModel(null, "anything")).toBe(false);
-    expect(isUnlistedModel([], "anything")).toBe(false);
-  });
-});
-
 describe("model aliases", () => {
   it("canonicalizes a retired preferred model and restores thinking from its alias key", () => {
     const resolved = resolveFormState(
@@ -298,7 +284,7 @@ describe("mergeSelectedComposerPreferences", () => {
             codex: {
               mode: "full-access",
               thinkingByModel: { "gpt-5.4-mini": "medium" },
-              options: { fast_mode: true },
+              featureValues: { fast_mode: true },
             },
             claude: { model: "claude-sonnet-4-6" },
           },
@@ -313,7 +299,7 @@ describe("mergeSelectedComposerPreferences", () => {
           model: "gpt-5.4",
           mode: "full-access",
           thinkingByModel: { "gpt-5.4-mini": "medium" },
-          options: { fast_mode: true },
+          featureValues: { fast_mode: true },
         },
         claude: { model: "claude-sonnet-4-6" },
       },

packages/app/src/provider-selection/resolve-agent-form.ts

@@ -153,19 +153,6 @@ export function resolveEffectiveModel(
   return findModelByReference(availableModels, modelId) ?? null;
 }
 
-/**
- * True when the provider has listed its models and this id is not among them. A provider that
- * lists none accepts any id.
- */
-export function isUnlistedModel(
-  availableModels: AgentModelDefinition[] | null,
-  modelId: string,
-): boolean {
-  if (!availableModels || availableModels.length === 0) return false;
-  if (!normalizeSelectedModelId(modelId)) return false;
-  return !resolveEffectiveModel(availableModels, modelId);
-}
-
 function resolvePreferredThinkingOptionId(input: {
   availableModels: AgentModelDefinition[] | null;
   providerPrefs: ProviderPrefs | undefined;

packages/app/src/screens/new-workspace-screen.tsx

@@ -271,7 +271,7 @@ interface WorkspaceDraftSubmissionConfig {
   modeId: string | null;
   model: string | null;
   thinkingOptionId: string | null;
-  providerOptions: Record<string, unknown> | undefined;
+  featureValues: Record<string, unknown> | undefined;
   target: WorkspaceTabTarget;
 }
 
@@ -374,7 +374,7 @@ function buildWorkspaceDraftSetupFromComposer(input: {
     modeId: input.composerState.effectiveModeId || null,
     model: input.composerState.effectiveModelId || null,
     thinkingOptionId: input.composerState.effectiveThinkingOptionId || null,
-    providerOptions: input.composerState.providerOptions ?? {},
+    featureValues: input.composerState.featureValues ?? {},
   };
 }
 
@@ -454,9 +454,8 @@ async function createWorkspaceChatAgent(input: CreateChatAgentInput): Promise<Su
       modeId: composerState.effectiveModeId || undefined,
       model: composerState.effectiveModelId || undefined,
       thinkingOptionId: composerState.effectiveThinkingOptionId || undefined,
-      providerOptions: composerState.providerOptions,
+      featureValues: composerState.featureValues,
     },
-    ...(Object.keys(composerState.metadata).length > 0 ? { metadata: composerState.metadata } : {}),
     initialPrompt: text,
     clientMessageId: `${input.draftId}:initial-message`,
     images: images?.length ? images : undefined,
@@ -535,8 +534,7 @@ function buildComposerConfig(input: {
   return {
     initialServerId: serverId || null,
     initialValues: buildComposerInitialValues({ initialSetup }),
-    initialProviderOptions: initialSetup?.providerOptions,
-    context: "new-workspace" as const,
+    initialFeatureValues: initialSetup?.featureValues,
     isVisible: true,
     lockedWorkingDir: workingDir,
   };
@@ -569,7 +567,7 @@ function resolveWorkspaceDraftSubmissionConfig(input: {
       modeId: initialSetup.modeId,
       model: initialSetup.model,
       thinkingOptionId: initialSetup.thinkingOptionId,
-      providerOptions: initialSetup.providerOptions,
+      featureValues: initialSetup.featureValues,
       target: { kind: "draft", draftId, setup: initialSetup },
     };
   }
@@ -579,7 +577,7 @@ function resolveWorkspaceDraftSubmissionConfig(input: {
     modeId: composerState.effectiveModeId || null,
     model: composerState.effectiveModelId || null,
     thinkingOptionId: composerState.effectiveThinkingOptionId || null,
-    providerOptions: composerState.providerOptions,
+    featureValues: composerState.featureValues,
     target: { kind: "draft", draftId },
   };
 }
@@ -637,7 +635,7 @@ function submitWorkspaceDraft(input: SubmitDraftInput): SubmitOutcome {
     ...(submission.modeId ? { modeId: submission.modeId } : {}),
     ...(submission.model ? { model: submission.model } : {}),
     ...(submission.thinkingOptionId ? { thinkingOptionId: submission.thinkingOptionId } : {}),
-    ...(submission.providerOptions ? { providerOptions: submission.providerOptions } : {}),
+    ...(submission.featureValues ? { featureValues: submission.featureValues } : {}),
     allowEmptyText: true,
     agentCreation: input.agentCreation,
   });

packages/app/src/screens/new-workspace/background-handoff.test.ts

@@ -69,7 +69,7 @@ describe("createWorkspaceAgentInBackground", () => {
           modeId: null,
           model: null,
           thinkingOptionId: null,
-          providerOptions: {},
+          featureValues: {},
         },
       });
     });
@@ -89,7 +89,7 @@ describe("createWorkspaceAgentInBackground", () => {
         modeId: null,
         model: null,
         thinkingOptionId: null,
-        providerOptions: {},
+        featureValues: {},
       },
     });
 

packages/app/src/screens/workspace/workspace-draft-agent-config.ts

@@ -6,7 +6,7 @@ export function buildWorkspaceDraftAgentConfig(input: {
   modeId?: string;
   model?: string;
   thinkingOptionId?: string;
-  providerOptions?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
 }): AgentSessionConfig {
   return {
     provider: input.provider,
@@ -14,6 +14,6 @@ export function buildWorkspaceDraftAgentConfig(input: {
     ...(input.modeId ? { modeId: input.modeId } : {}),
     ...(input.model ? { model: input.model } : {}),
     ...(input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}),
-    ...(input.providerOptions ? { providerOptions: input.providerOptions } : {}),
+    ...(input.featureValues ? { featureValues: input.featureValues } : {}),
   };
 }

packages/app/src/stores/draft-store/index.ts

@@ -36,8 +36,6 @@ import {
 } from "./migration";
 import { createDraftPersistStorage } from "./persistence";
 import { createValidatedPersistStorage } from "@/storage/validated-persist-storage";
-import type { JsonValue } from "@getpaseo/protocol/agent-types";
-import { applyMetadataPatch } from "@/composer/draft/metadata";
 
 export type { DraftInput, DraftLifecycleState } from "./state";
 
@@ -51,9 +49,6 @@ interface DraftStoreActions {
     draftKey: string;
     lifecycle?: Exclude<DraftLifecycleState, "active">;
   }) => void;
-  /** Plugin metadata the draft will create its agent with; see `composer/draft/metadata`. */
-  patchDraftMetadata: (input: { draftKey: string; patch: Record<string, JsonValue> }) => void;
-  clearDraftMetadata: (input: { draftKey: string }) => void;
   attachWorkspaceFile: (input: {
     draftKey: string;
     attachment: WorkspaceFileComposerAttachment;
@@ -65,11 +60,6 @@ interface DraftStoreActions {
 
 interface DraftStoreRuntimeState {
   attachmentFocusRequestByDraftKey: Record<string, number>;
-  /**
-   * Kept beside the prompt so a composer that remounts finds it. Not persisted, and not cleared
-   * with an emptied prompt: a plugin's choice outlives the text until the draft is sent.
-   */
-  metadataByDraftKey: Record<string, Record<string, JsonValue>>;
 }
 
 type DraftStore = DraftStoreState & DraftStoreRuntimeState & DraftStoreActions;
@@ -266,7 +256,6 @@ export const useDraftStore = create<DraftStore>()(
       drafts: {},
       createModalDraft: null,
       attachmentFocusRequestByDraftKey: {},
-      metadataByDraftKey: {},
 
       getDraftInput: (draftKey) => {
         const record = get().drafts[draftKey];
@@ -385,25 +374,6 @@ export const useDraftStore = create<DraftStore>()(
         scheduleAttachmentGc();
       },
 
-      patchDraftMetadata: ({ draftKey, patch }) => {
-        set((state) => {
-          const next = applyMetadataPatch(state.metadataByDraftKey[draftKey] ?? {}, patch);
-          const { [draftKey]: _previous, ...others } = state.metadataByDraftKey;
-          return {
-            metadataByDraftKey:
-              Object.keys(next).length > 0 ? { ...others, [draftKey]: next } : others,
-          };
-        });
-      },
-
-      clearDraftMetadata: ({ draftKey }) => {
-        set((state) => {
-          if (!(draftKey in state.metadataByDraftKey)) return state;
-          const { [draftKey]: _removed, ...others } = state.metadataByDraftKey;
-          return { metadataByDraftKey: others };
-        });
-      },
-
       attachWorkspaceFile: async ({ draftKey, attachment }) => {
         await get().hydrateDraftInput({ draftKey });
         set((state) => {

packages/app/src/stores/draft-store/metadata.test.ts

@@ -1,35 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { useDraftStore } from "./index";
-
-const draftKey = "draft:metadata";
-
-describe("a draft's plugin metadata", () => {
-  beforeEach(() => {
-    useDraftStore.setState({ drafts: {}, metadataByDraftKey: {} });
-  });
-
-  it("is there when the draft's composer mounts again", () => {
-    const store = useDraftStore.getState();
-    store.editDraftText({ draftKey, text: "review this" });
-    store.patchDraftMetadata({ draftKey, patch: { "plugin.review": true, "plugin.tag": "a" } });
-    store.patchDraftMetadata({ draftKey, patch: { "plugin.tag": null } });
-
-    // A remount reads the store again; nothing from the unmounted composer is kept.
-    const remounted = useDraftStore.getState();
-    expect(remounted.getDraftInput(draftKey)?.text).toBe("review this");
-    expect(remounted.metadataByDraftKey[draftKey]).toEqual({ "plugin.review": true });
-  });
-
-  it("is dropped with the prompt once the draft is sent, and not before", () => {
-    const store = useDraftStore.getState();
-    store.patchDraftMetadata({ draftKey, patch: { "plugin.review": true } });
-
-    store.clearDraftInput({ draftKey, lifecycle: "abandoned" });
-    expect(useDraftStore.getState().metadataByDraftKey[draftKey]).toEqual({
-      "plugin.review": true,
-    });
-
-    store.clearDraftMetadata({ draftKey });
-    expect(useDraftStore.getState().metadataByDraftKey[draftKey]).toBeUndefined();
-  });
-});

packages/app/src/stores/session-store.ts

@@ -26,9 +26,7 @@ import type { ComposerAttachment } from "@/attachments/types";
 import type { AgentLifecycleStatus } from "@getpaseo/protocol/agent-lifecycle";
 import type {
   AgentPermissionRequest,
-  AgentOptionControl,
-  JsonValue,
-  ProviderOptions,
+  AgentFeature,
   AgentProvider,
   AgentMode,
   AgentCapabilityFlags,
@@ -93,8 +91,7 @@ export interface Agent {
   cwd: string;
   workspaceId?: string;
   model: string | null;
-  options?: ProviderOptions;
-  controls?: AgentOptionControl[];
+  features?: AgentFeature[];
   thinkingOptionId?: string | null;
   requiresAttention?: boolean;
   attentionReason?: "finished" | "error" | "permission" | null;
@@ -102,7 +99,6 @@ export interface Agent {
   archivedAt?: Date | null;
   parentAgentId: string | null;
   labels: Record<string, string>;
-  metadata?: Record<string, JsonValue>;
   projectPlacement?: ProjectPlacementPayload | null;
 }
 

packages/app/src/stores/workspace-draft-submission-store.ts

@@ -23,7 +23,7 @@ export interface PendingWorkspaceDraftSubmission {
   modeId?: string;
   model?: string;
   thinkingOptionId?: string;
-  providerOptions?: Record<string, unknown>;
+  featureValues?: Record<string, unknown>;
   allowEmptyText?: boolean;
 }