feat(web): put legacy plan mode behind a setting, and adopt #6420 (#59)

* feat(web): put legacy plan mode behind a setting

Reverses the F6 decision recorded in the upstream ledger. Pylon kept the
composer's Build/Plan toggle when upstream removed it in #5551, on the
argument that plan mode is first-class in Claude Code and Codex. In practice
it goes unused here, so Pylon now matches upstream: the toggle and the /plan
and /default slash commands are gated behind a `planModeEnabled` client
setting, default off.

Ported rather than cherry-picked. #5551 is 338 commits back and touches
ChatComposer.tsx, which has diverged hard (4240 lines here vs upstream's
2824); its Beta-panel placement and sidebar-v2 search entries have since been
superseded upstream anyway. This implements upstream's current end state
against Pylon's tree.

Gating the composer's `showInteractionModeToggle` covers both entry points,
because Pylon already derives the /plan slash command from that same flag.
ChatView forces the effective mode back to "default" while the setting is off
so a thread saved in plan mode is not stranded with its toggle hidden.

Pylon Mobile already carries a device-local `planModeEnabled` preference,
documented as the counterpart of this key, so the two surfaces now agree.

This unblocks upstream #6420, which depends on the flag.

* fix(web): hide opencode's plan agent when legacy plan mode is off (#6420)

(cherry picked from commit 80c37f1a721d36bde86b31c475fcc8d3db75f706)

Adopted now that Pylon has the `planModeEnabled` flag it depends on. Skipped
in the third 2026-08-19 batch because it required the setting F6 had rejected.

Two adaptations. The import collisions in `modelSelection.ts` and
`SettingsPanels.tsx` were unioned — Pylon's `getBackgroundTextGenerationProviders`
and `providerInstancePrioritySortKey` sit alongside upstream's
`withoutPlanAgentSelection`. And the `legacy-plan-mode` settings-search id was
registered against `/settings/general`, matching where Pylon keeps its other
legacy rows.

* docs(upstream): record the F6 reversal on legacy plan mode

Author: rynfar

.agents/upstream-review.md

@@ -1839,6 +1839,38 @@ Still open from this batch, not acted on:
 - `flattenOpenCodeSkills` copies the full description into `shortDescription` and never
   sets `scope`, unlike the Codex and Claude adapters.
 
+## 2026-08-19 (F6 reversal) — legacy plan mode
+
+Not a batch: a reversal of a standing decision, recorded so the ledger does not
+keep asserting something that is no longer true.
+
+**F6 (`48aa875c0` / `#5551`) was skipped** on the argument that plan mode is
+first-class in Claude Code and Codex, so dropping the composer's Build/Plan
+toggle would cost Pylon more than it cost T3. **H1 extended it** by dropping
+upstream's plan-mode Settings row. The developer has since concluded the toggle
+goes unused in practice and asked to match upstream.
+
+Pylon now has a `planModeEnabled` client setting, default off, gating the
+composer toggle and the `/plan` and `/default` slash commands, with `ChatView`
+forcing the effective mode back to `"default"` while it is off so no thread is
+stranded in plan mode with its toggle hidden. Pylon Mobile already carried a
+device-local `planModeEnabled` preference documented as the counterpart of this
+key, so the surfaces now agree rather than diverge.
+
+**Ported, not cherry-picked.** `#5551` is 338 commits back and touches
+`ChatComposer.tsx`, which has diverged hard — 4240 lines here against upstream's
+2824 — and its Beta-panel placement plus `sidebar-v2` search entries were
+superseded upstream anyway. Replaying that snapshot would have imported a shape
+neither project has. Pylon implements upstream's current end state instead.
+
+With the flag in place, **`80c37f1a7` (`#6420`) was adopted**, closing the skip
+recorded in the third 2026-08-19 batch. Its two conflicts were additive and
+unioned; the `legacy-plan-mode` settings-search id is registered against
+`/settings/general`, where Pylon keeps its other legacy rows.
+
+F6 and H1 stay in their original batch tables as historical record — they
+describe what was decided then. This entry is what supersedes them.
+
 ## Deferred register
 
 _The register is currently empty. DEF-1 and DEF-2 were adopted on 2026-08-11

apps/web/src/components/ChatView.tsx

@@ -1661,8 +1661,13 @@ function ChatViewContent(props: ChatViewProps) {
   // the branch mismatch banner.
   const [, setThreadErrorBannerDismissTick] = useState(0);
   const runtimeMode = composerRuntimeMode ?? activeThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE;
-  const interactionMode =
-    composerInteractionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE;
+  const planModeEnabled = useClientSettings((clientSettings) => clientSettings.planModeEnabled);
+  // With legacy plan mode off, force the effective mode to "default" so a
+  // thread saved in plan mode is not stranded there with its toggle hidden.
+  // The next send persists "default" back to the thread.
+  const interactionMode = planModeEnabled
+    ? (composerInteractionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE)
+    : DEFAULT_INTERACTION_MODE;
   const isLocalDraftThread = !isServerThread && localDraftThread !== undefined;
   const canCheckoutPullRequestIntoThread = isLocalDraftThread;
   const activeThreadId = activeThread?.id ?? null;
@@ -5433,6 +5438,7 @@ function ChatViewContent(props: ChatViewProps) {
       return;
     }
     const standaloneSlashCommand =
+      planModeEnabled &&
       composerImages.length === 0 &&
       sendableComposerTerminalContexts.length === 0 &&
       composerElementContexts.length === 0 &&

apps/web/src/components/chat/ChatComposer.tsx

@@ -1593,6 +1593,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         models: selectedProviderModels,
         promptInjectionState: composerPromptInjectionState,
         modelOptions: composerModelOptions?.[selectedInstanceId],
+        planModeEnabled: settings.planModeEnabled,
       }),
     [
       composerModelOptions,
@@ -1601,21 +1602,28 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       selectedModel,
       selectedProvider,
       selectedProviderModels,
+      settings.planModeEnabled,
     ],
   );
 
   const selectedPromptEffort = composerProviderState.promptEffort;
   const selectedModelOptionsForDispatch = composerProviderState.modelOptionsForDispatch;
+  // Plan mode is legacy and off by default. Gating here covers both entry
+  // points, because the /plan and /default slash commands are derived from
+  // this same flag. ChatView forces the effective mode back to "default" while
+  // it is off, so hiding the toggle cannot strand a thread in plan mode.
+  const planModeUiEnabled = settings.planModeEnabled;
   const composerProviderControls = useMemo(
     () => ({
       showInteractionModeToggle:
-        selectedProviderEntry?.snapshot.showInteractionModeToggle ??
-        getProviderInteractionModeToggle(providerStatuses, selectedProvider),
+        planModeUiEnabled &&
+        (selectedProviderEntry?.snapshot.showInteractionModeToggle ??
+          getProviderInteractionModeToggle(providerStatuses, selectedProvider)),
       supportedRuntimeModes: getServerProviderSupportedRuntimeModes(
         selectedProviderEntry?.snapshot,
       ),
     }),
-    [providerStatuses, selectedProvider, selectedProviderEntry],
+    [planModeUiEnabled, providerStatuses, selectedProvider, selectedProviderEntry],
   );
   const resolvedRuntimeMode = resolveServerProviderRuntimeMode(
     selectedProviderEntry?.snapshot,
@@ -1972,6 +1980,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     modelOptions: composerModelOptions?.[selectedInstanceId],
     prompt,
     onPromptChange: setPromptFromTraits,
+    planModeEnabled: settings.planModeEnabled,
   });
   const providerTraitsPicker = renderProviderTraitsPicker({
     provider: selectedProvider,
@@ -1983,6 +1992,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     modelOptions: composerModelOptions?.[selectedInstanceId],
     prompt,
     onPromptChange: setPromptFromTraits,
+    planModeEnabled: settings.planModeEnabled,
   });
   const pendingPrimaryAction = useMemo(
     () =>

apps/web/src/components/chat/TraitsPicker.tsx

@@ -96,8 +96,9 @@ function getSelectedTraits(
   prompt: string,
   modelOptions: ProviderOptions | null | undefined,
   allowPromptInjectedEffort: boolean,
+  planModeEnabled: boolean,
 ) {
-  const caps = getProviderModelCapabilities(models, model, provider);
+  const caps = getProviderModelCapabilities(models, model, provider, planModeEnabled);
   const descriptors = getProviderOptionDescriptors({
     caps,
     selections: modelOptions,
@@ -167,6 +168,7 @@ function getTraitsSectionVisibility(input: {
   prompt: string;
   modelOptions: ProviderOptions | null | undefined;
   allowPromptInjectedEffort?: boolean;
+  planModeEnabled: boolean;
 }) {
   const selected = getSelectedTraits(
     input.provider,
@@ -175,6 +177,7 @@ function getTraitsSectionVisibility(input: {
     input.prompt,
     input.modelOptions,
     input.allowPromptInjectedEffort ?? true,
+    input.planModeEnabled,
   );
 
   const showEffort = selected.primarySelectDescriptor !== null;
@@ -201,6 +204,7 @@ export function shouldRenderTraitsControls(input: {
   prompt: string;
   modelOptions: ProviderOptions | null | undefined;
   allowPromptInjectedEffort?: boolean;
+  planModeEnabled: boolean;
 }): boolean {
   return getTraitsSectionVisibility(input).hasAnyControls;
 }
@@ -214,6 +218,7 @@ export interface TraitsMenuContentProps {
   onPromptChange: (prompt: string) => void;
   modelOptions?: ProviderOptions | null | undefined;
   allowPromptInjectedEffort?: boolean;
+  planModeEnabled: boolean;
   triggerVariant?: VariantProps<typeof buttonVariants>["variant"];
   triggerClassName?: string;
 }
@@ -227,6 +232,7 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
   onPromptChange,
   modelOptions,
   allowPromptInjectedEffort = true,
+  planModeEnabled,
   ...persistence
 }: TraitsMenuContentProps & TraitsPersistence) {
   const setProviderModelOptions = useComposerDraftStore((store) => store.setProviderModelOptions);
@@ -263,6 +269,7 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
     prompt,
     modelOptions,
     allowPromptInjectedEffort,
+    planModeEnabled,
   });
   const updateDescriptors = (nextDescriptors: ReadonlyArray<ProviderOptionDescriptor>) => {
     updateModelOptions(buildProviderOptionSelectionsFromDescriptors(nextDescriptors));
@@ -451,6 +458,7 @@ export const TraitsPicker = memo(function TraitsPicker({
   onPromptChange,
   modelOptions,
   allowPromptInjectedEffort = true,
+  planModeEnabled,
   triggerVariant,
   triggerClassName,
   ...persistence
@@ -464,6 +472,7 @@ export const TraitsPicker = memo(function TraitsPicker({
       prompt,
       modelOptions,
       allowPromptInjectedEffort,
+      planModeEnabled,
     });
   if (
     !shouldRenderTraitsControls({
@@ -473,6 +482,7 @@ export const TraitsPicker = memo(function TraitsPicker({
       prompt,
       modelOptions,
       allowPromptInjectedEffort,
+      planModeEnabled,
     })
   ) {
     return null;
@@ -543,6 +553,7 @@ export const TraitsPicker = memo(function TraitsPicker({
           onPromptChange={onPromptChange}
           modelOptions={modelOptions}
           allowPromptInjectedEffort={allowPromptInjectedEffort}
+          planModeEnabled={planModeEnabled}
           {...persistence}
         />
       </MenuPopup>

apps/web/src/components/chat/composerProviderState.test.tsx

@@ -80,6 +80,7 @@ describe("getComposerProviderState", () => {
         ]),
       ]),
       modelOptions: undefined,
+      planModeEnabled: true,
     });
 
     expect(state).toEqual({
@@ -101,6 +102,7 @@ describe("getComposerProviderState", () => {
         booleanDescriptor("fastMode"),
       ]),
       modelOptions: selections(["effort", "low"], ["fastMode", true]),
+      planModeEnabled: true,
     });
 
     expect(state).toEqual({
@@ -119,6 +121,7 @@ describe("getComposerProviderState", () => {
         booleanDescriptor("fastMode"),
       ]),
       modelOptions: selections(["effort", "high"], ["fastMode", false]),
+      planModeEnabled: true,
     });
 
     expect(state.modelOptionsForDispatch).toEqual(
@@ -132,6 +135,7 @@ describe("getComposerProviderState", () => {
       model: MODEL,
       models: modelWith([booleanDescriptor("thinking")]),
       modelOptions: selections(["effort", "max"], ["thinking", false]),
+      planModeEnabled: true,
     });
 
     expect(state).toEqual({
@@ -157,6 +161,7 @@ describe("getComposerProviderState", () => {
         ]),
       ]),
       modelOptions: selections(["agent", "plan"]),
+      planModeEnabled: true,
     });
 
     expect(state.promptEffort).toBe("high");
@@ -165,12 +170,65 @@ describe("getComposerProviderState", () => {
     );
   });
 
+  it("drops the plan agent from dispatch when legacy plan mode is disabled", () => {
+    const state = getComposerProviderState({
+      provider: PROVIDER,
+      model: MODEL,
+      models: modelWith([
+        selectDescriptor("agent", [
+          { id: "build", label: "Build", isDefault: true },
+          { id: "plan", label: "Plan" },
+        ]),
+      ]),
+      modelOptions: selections(["agent", "plan"]),
+      planModeEnabled: false,
+    });
+
+    expect(state.modelOptionsForDispatch).toEqual(selections(["agent", "build"]));
+  });
+
+  it("drops the agent descriptor entirely when plan is the only option and plan mode is disabled", () => {
+    const state = getComposerProviderState({
+      provider: PROVIDER,
+      model: MODEL,
+      models: modelWith([
+        selectDescriptor("agent", [{ id: "plan", label: "Plan", isDefault: true }]),
+      ]),
+      modelOptions: selections(["agent", "plan"]),
+      planModeEnabled: false,
+    });
+
+    expect(state).toEqual({
+      provider: PROVIDER,
+      promptEffort: null,
+      modelOptionsForDispatch: undefined,
+    });
+  });
+
+  it("falls back to a surviving agent when plan was the descriptor default and plan mode is disabled", () => {
+    const state = getComposerProviderState({
+      provider: PROVIDER,
+      model: MODEL,
+      models: modelWith([
+        selectDescriptor("agent", [
+          { id: "plan", label: "Plan", isDefault: true },
+          { id: "research", label: "Research" },
+        ]),
+      ]),
+      modelOptions: undefined,
+      planModeEnabled: false,
+    });
+
+    expect(state.modelOptionsForDispatch).toEqual(selections(["agent", "research"]));
+  });
+
   it("returns undefined dispatch options when the model declares no descriptors", () => {
     const state = getComposerProviderState({
       provider: PROVIDER,
       model: MODEL,
       models: modelWith([]),
       modelOptions: selections(["anything", "value"]),
+      planModeEnabled: true,
     });
 
     expect(state).toEqual({
@@ -199,6 +257,7 @@ describe("getComposerProviderState", () => {
         "Ultrathink:\nInvestigate this failure",
       ),
       modelOptions: selections(["effort", "medium"]),
+      planModeEnabled: true,
     });
 
     expect(state).toEqual({
@@ -220,6 +279,7 @@ describe("getComposerProviderState", () => {
         "Ultrathink:\nInvestigate this failure",
       ),
       modelOptions: undefined,
+      planModeEnabled: true,
     });
 
     expect(state).not.toHaveProperty("composerFrameClassName");
@@ -240,6 +300,7 @@ describe("provider traits render guards", () => {
       modelOptions: undefined,
       prompt: "",
       onPromptChange: () => {},
+      planModeEnabled: true,
     };
 
     expect(renderProviderTraitsPicker(args)).toBeNull();