🤖 refactor: collapse PTC to exclusive-only (single PTC experiment, RLM sub-experiment)

scripts/rlm-eval/scenarios.ts

@@ -29,7 +29,6 @@ export interface EvalConfig {
   id: string;
   experiments: {
     programmaticToolCalling: boolean;
-    programmaticToolCallingExclusive?: boolean;
     rlm: boolean;
   };
   /** Optional prompting lever, sent as additionalSystemInstructions. */
@@ -236,13 +235,13 @@ export const CONFIGS: EvalConfig[] = [
     id: "flat-bash",
     experiments: { programmaticToolCalling: false, rlm: false },
   },
+  // PTC is exclusive-only (supplement mode measured ~2x flat tokens/cost and
+  // was removed): this measures the exclusive code_execution toolset without
+  // the persistent kernel.
   {
     id: "ptc-only",
     experiments: { programmaticToolCalling: true, rlm: false },
   },
-  // RLM is exclusive-only (supplement-mode RLM measured ~2x flat tokens/cost
-  // and was removed): the rlm flag alone yields the kernel-first exclusive
-  // toolset. The explicit exclusive flag is redundant but harmless.
   {
     id: "rlm-excl",
     experiments: { programmaticToolCalling: true, rlm: true },

src/browser/components/CommandPalette/CommandPalette.tsx

@@ -69,9 +69,6 @@ export const CommandPalette: React.FC<CommandPaletteProps> = ({ getSlashContext
   );
   const rlmExperimentEnabled = useExperimentValue(EXPERIMENT_IDS.RLM);
   const ptcExperimentEnabled = useExperimentValue(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
-  const ptcExclusiveExperimentEnabled = useExperimentValue(
-    EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING_EXCLUSIVE
-  );
   const slashContext = getSlashContext?.();
   const slashWorkspaceId = slashContext?.workspaceId;
 
@@ -306,7 +303,6 @@ export const CommandPalette: React.FC<CommandPaletteProps> = ({ getSlashContext
             memoryConsolidation: memoryConsolidationExperimentEnabled,
             rlm: rlmExperimentEnabled,
             programmaticToolCalling: ptcExperimentEnabled,
-            programmaticToolCallingExclusive: ptcExclusiveExperimentEnabled,
           }),
       });
       const section = "Slash Commands";
@@ -385,7 +381,6 @@ export const CommandPalette: React.FC<CommandPaletteProps> = ({ getSlashContext
     memoryConsolidationExperimentEnabled,
     rlmExperimentEnabled,
     ptcExperimentEnabled,
-    ptcExclusiveExperimentEnabled,
   ]);
 
   useEffect(() => {

src/browser/contexts/ExperimentsContext.test.tsx

@@ -4,7 +4,11 @@ import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promi
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { GlobalWindow } from "happy-dom";
-import { EXPERIMENT_IDS, getExperimentKey } from "@/common/constants/experiments";
+import {
+  EXPERIMENT_IDS,
+  getExperimentKey,
+  getLegacyPtcExclusiveExperimentKey,
+} from "@/common/constants/experiments";
 import { requireTestModule, type RecursivePartial } from "@/browser/testUtils";
 import type * as APIModule from "./API";
 import type { APIClient } from "./API";
@@ -248,4 +252,98 @@ describe("ExperimentsProvider", () => {
       expect(getByTestId("toggle").textContent).toBe("true");
     });
   });
+
+  test("initialization stamps the legacy mirror over a stale explicit false", async () => {
+    // An old renderer can leave ptc:true beside a stale legacy exclusive
+    // `false`; upgrading without touching the toggle previously never rewrote
+    // the mirror, and a downgraded renderer treats the stale explicit key as
+    // an override that wins over the backend flag — resuming the removed
+    // supplement posture (r33). Initialization reconciles it.
+    currentClientMock = {
+      experiments: {
+        setOverride: mock(() => Promise.resolve()),
+        getOverrides: mock(() => Promise.resolve({})),
+      },
+    };
+
+    globalThis.window.localStorage.setItem(
+      getExperimentKey(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING),
+      JSON.stringify(true)
+    );
+    globalThis.window.localStorage.setItem(
+      getLegacyPtcExclusiveExperimentKey(),
+      JSON.stringify(false)
+    );
+
+    function Probe() {
+      const enabled = useExperimentValue(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
+      return <div data-testid="probe">{String(enabled)}</div>;
+    }
+
+    const { getByTestId } = render(
+      <APIProvider client={currentClientMock as APIClient}>
+        <ExperimentsProvider>
+          <Probe />
+        </ExperimentsProvider>
+      </APIProvider>
+    );
+
+    expect(getByTestId("probe").textContent).toBe("true");
+    await waitFor(() => {
+      expect(globalThis.window.localStorage.getItem(getLegacyPtcExclusiveExperimentKey())).toBe(
+        "true"
+      );
+    });
+  });
+
+  test("stale legacy exclusive true reads as PTC on, and toggling PTC rewrites the legacy key", async () => {
+    currentClientMock = {
+      experiments: {
+        setOverride: mock(() => Promise.resolve()),
+        getOverrides: mock(() => Promise.resolve({})),
+      },
+    };
+
+    // Pre-merge state: "PTC Exclusive Mode" enabled — exactly the posture
+    // merged PTC activates, so the upgrade must keep PTC on.
+    globalThis.window.localStorage.setItem(
+      getLegacyPtcExclusiveExperimentKey(),
+      JSON.stringify(true)
+    );
+
+    function Toggle() {
+      const [enabled, setEnabled] = useExperiment(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
+      return (
+        <button data-testid="toggle" onClick={() => setEnabled(!enabled)}>
+          {String(enabled)}
+        </button>
+      );
+    }
+
+    const { getByTestId } = render(
+      <APIProvider client={currentClientMock as APIClient}>
+        <ExperimentsProvider>
+          <Toggle />
+        </ExperimentsProvider>
+      </APIProvider>
+    );
+
+    expect(getByTestId("toggle").textContent).toBe("true");
+
+    // Toggling PTC off must rewrite the legacy key too: a downgraded renderer
+    // treats it as an explicit override that wins over the mirrored backend
+    // value, so a stale entry would resurrect the pre-merge posture.
+    fireEvent.click(getByTestId("toggle"));
+    await waitFor(() => {
+      expect(getByTestId("toggle").textContent).toBe("false");
+    });
+    expect(globalThis.window.localStorage.getItem(getLegacyPtcExclusiveExperimentKey())).toBe(
+      "false"
+    );
+    expect(
+      globalThis.window.localStorage.getItem(
+        getExperimentKey(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING)
+      )
+    ).toBe("false");
+  });
 });

src/browser/contexts/ExperimentsContext.tsx

@@ -8,11 +8,14 @@ import React, {
 } from "react";
 import {
   type ExperimentId,
+  EXPERIMENT_IDS,
   EXPERIMENTS,
   getExperimentKey,
+  getLegacyPtcExclusiveExperimentKey,
   isExperimentSupportedOnPlatform,
 } from "@/common/constants/experiments";
 import { getStorageChangeEvent } from "@/common/constants/events";
+import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
 import { useAPI } from "@/browser/contexts/API";
 
 /**
@@ -43,11 +46,30 @@ function isExperimentSupported(experimentId: ExperimentId): boolean {
   return isExperimentSupportedOnPlatform(experimentId, getCurrentDesktopPlatform());
 }
 
+/**
+ * Upgrade alias (see LEGACY_PTC_EXCLUSIVE_EXPERIMENT_ID): a stored legacy
+ * exclusive `true` opted into exactly the posture merged PTC activates, so PTC
+ * reads as enabled — winning even over an explicit supplement-off value,
+ * matching the backend read alias. setExperimentState rewrites the legacy key
+ * on every PTC toggle, so the alias never overrides a choice made in this
+ * build.
+ */
+export function hasLegacyPtcExclusiveOverride(): boolean {
+  return readPersistedState<unknown>(getLegacyPtcExclusiveExperimentKey(), undefined) === true;
+}
+
 /**
  * Get explicit localStorage override for an experiment.
  * Returns undefined if no value is set or parsing fails.
  */
 function getExperimentOverrideSnapshot(experimentId: ExperimentId): boolean | undefined {
+  if (
+    experimentId === EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING &&
+    hasLegacyPtcExclusiveOverride()
+  ) {
+    return true;
+  }
+
   const key = getExperimentKey(experimentId);
 
   try {
@@ -97,6 +119,18 @@ function setExperimentState(experimentId: ExperimentId, enabled: boolean): void
   try {
     window.localStorage.setItem(key, JSON.stringify(enabled));
 
+    // Downgrade sync (see LEGACY_PTC_EXCLUSIVE_EXPERIMENT_ID): a downgraded
+    // renderer reads the pre-merge exclusive key as an explicit override that
+    // wins over the mirrored backend value in its send options, so a stale
+    // entry would resurrect supplement mode (stale false) or re-enable PTC
+    // after the user turned it off (stale true). Keep it equal to PTC.
+    // Routed through updatePersistedState so the mirror participates in the
+    // shared write-listener/subscriber notification path like other
+    // persisted preferences.
+    if (experimentId === EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING) {
+      updatePersistedState(getLegacyPtcExclusiveExperimentKey(), enabled);
+    }
+
     // Dispatch custom event for same-tab synchronization
     const customEvent = new CustomEvent(getStorageChangeEvent(key), {
       detail: { key, newValue: enabled },
@@ -107,6 +141,28 @@ function setExperimentState(experimentId: ExperimentId, enabled: boolean): void
   }
 }
 
+/**
+ * Upgrade reconciliation for the legacy exclusive mirror (r33): an old
+ * renderer can leave `programmatic-tool-calling: true` alongside a stale
+ * legacy exclusive `false` (or none), and setExperimentState rewrites the
+ * mirror only on toggles — a user who upgrades and never touches the setting
+ * would downgrade into the removed supplement posture, because a downgraded
+ * renderer treats the stale explicit legacy key as an override that wins over
+ * the backend's mirrored flag. Keep the mirror stamped whenever the EFFECTIVE
+ * PTC state (local override first, else the backend override) is enabled.
+ * Only the enabled state needs stamping: a legacy `true` already aliases
+ * effective PTC to true, so a disagreeing pair can only be
+ * (ptc: true, legacy: false/absent).
+ */
+function reconcileLegacyPtcExclusiveMirror(
+  backendOverrides: Partial<Record<ExperimentId, boolean>> | null
+): void {
+  const local = getExperimentOverrideSnapshot(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
+  const effective = local ?? backendOverrides?.[EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING];
+  if (effective !== true || hasLegacyPtcExclusiveOverride()) return;
+  updatePersistedState(getLegacyPtcExclusiveExperimentKey(), true);
+}
+
 /**
  * Context value type - provides setter function.
  * Individual experiment values are accessed via useExperimentValue hook.
@@ -179,10 +235,14 @@ export function ExperimentsProvider(props: { children: React.ReactNode }) {
         const overrides = await api.experiments.getOverrides();
         if (!cancelled) {
           setBackendOverrides(overrides);
+          reconcileLegacyPtcExclusiveMirror(overrides);
         }
       } catch {
         if (!cancelled) {
           setBackendOverrides(null);
+          // Still reconciles the purely-local stale pair (ptc: true,
+          // legacy: false/absent) even when the backend is unreachable.
+          reconcileLegacyPtcExclusiveMirror(null);
         }
       }
     };

src/browser/features/ChatInput/index.tsx

@@ -326,9 +326,6 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
   );
   const rlmExperimentEnabled = useExperimentValue(EXPERIMENT_IDS.RLM);
   const ptcExperimentEnabled = useExperimentValue(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
-  const ptcExclusiveExperimentEnabled = useExperimentValue(
-    EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING_EXCLUSIVE
-  );
   const atMentionProjectPath =
     variant === "creation" && props.kind !== "scratch" ? props.projectPath : null;
   const asyncCommandScopeRef = useRef<{ variant: typeof variant; workspaceId: string | null }>({
@@ -1752,7 +1749,6 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
           memoryConsolidation: memoryConsolidationExperimentEnabled,
           rlm: rlmExperimentEnabled,
           programmaticToolCalling: ptcExperimentEnabled,
-          programmaticToolCallingExclusive: ptcExclusiveExperimentEnabled,
         }),
     });
     setCommandSuggestions((prev) => replaceSuggestions(prev, suggestions));
@@ -1769,7 +1765,6 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
     memoryConsolidationExperimentEnabled,
     rlmExperimentEnabled,
     ptcExperimentEnabled,
-    ptcExclusiveExperimentEnabled,
   ]);
 
   // Watch input/cursor for `\symbol` backslash commands and surface the menu.
@@ -1807,7 +1802,6 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
         memoryConsolidation: memoryConsolidationExperimentEnabled,
         rlm: rlmExperimentEnabled,
         programmaticToolCalling: ptcExperimentEnabled,
-        programmaticToolCallingExclusive: ptcExclusiveExperimentEnabled,
       }),
   });
 

src/browser/features/Settings/Sections/ExperimentsSection.tsx

@@ -695,9 +695,6 @@ export function ExperimentsSection() {
   const workspaceHeartbeatsEnabled = useExperimentValue(EXPERIMENT_IDS.WORKSPACE_HEARTBEATS);
   const memoryEnabled = useExperimentValue(EXPERIMENT_IDS.MEMORY);
   const ptcEnabled = useExperimentValue(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING);
-  const ptcExclusiveEnabled = useExperimentValue(
-    EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING_EXCLUSIVE
-  );
   const settingsConfigRequestRef = useRef<{
     api: APIClient;
     request: Promise<SettingsConfig>;
@@ -808,16 +805,6 @@ export function ExperimentsSection() {
                   <SubExperimentRows experimentIds={PTC_SUB_EXPERIMENT_IDS} />
                 </ExperimentSettingsPanel>
               )}
-              {/* RLM rides EITHER accepted PTC parent (toolAssembly accepts
-                  exclusive + rlm too); render under Exclusive only when plain
-                  PTC is off so the row never appears twice. */}
-              {exp.id === EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING_EXCLUSIVE &&
-                ptcExclusiveEnabled &&
-                !ptcEnabled && (
-                  <ExperimentSettingsPanel>
-                    <SubExperimentRows experimentIds={PTC_SUB_EXPERIMENT_IDS} />
-                  </ExperimentSettingsPanel>
-                )}
               {exp.id === EXPERIMENT_IDS.PORTABLE_DESKTOP && <PortableDesktopExperimentWarning />}
               {exp.id === EXPERIMENT_IDS.CONFIGURABLE_BIND_URL && <ConfigurableBindUrlControls />}
             </React.Fragment>

src/browser/hooks/useExperiments.test.ts

@@ -8,7 +8,11 @@
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { GlobalWindow } from "happy-dom";
-import { EXPERIMENT_IDS, getExperimentKey } from "@/common/constants/experiments";
+import {
+  EXPERIMENT_IDS,
+  getExperimentKey,
+  getLegacyPtcExclusiveExperimentKey,
+} from "@/common/constants/experiments";
 import { isExperimentEnabled } from "./useExperiments";
 
 describe("isExperimentEnabled", () => {
@@ -60,4 +64,29 @@ describe("isExperimentEnabled", () => {
     globalThis.window.localStorage.setItem(key, JSON.stringify("test"));
     expect(isExperimentEnabled(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING)).toBeUndefined();
   });
+
+  test("legacy exclusive true reads as PTC enabled, winning over an explicit PTC false", () => {
+    // Pre-merge builds stored "PTC Exclusive Mode" under its own key; that
+    // posture is exactly what merged PTC activates, so it must keep PTC on
+    // even when the old supplement flag was explicitly off.
+    globalThis.window.localStorage.setItem(
+      getLegacyPtcExclusiveExperimentKey(),
+      JSON.stringify(true)
+    );
+    expect(isExperimentEnabled(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING)).toBe(true);
+
+    globalThis.window.localStorage.setItem(
+      getExperimentKey(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING),
+      JSON.stringify(false)
+    );
+    expect(isExperimentEnabled(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING)).toBe(true);
+  });
+
+  test("legacy exclusive false does not alias onto PTC", () => {
+    globalThis.window.localStorage.setItem(
+      getLegacyPtcExclusiveExperimentKey(),
+      JSON.stringify(false)
+    );
+    expect(isExperimentEnabled(EXPERIMENT_IDS.PROGRAMMATIC_TOOL_CALLING)).toBeUndefined();
+  });
 });