diff --git a/README.md b/README.md
index 18700a8..4ad0321 100644
--- a/README.md
+++ b/README.md
@@ -105,8 +105,8 @@ coding-agent configuration into a new or existing Sandpi Environment. See
 - Same-Turn Codex steering while tools are running, with native message ordering
 - Sandbox/Codex process self-recovery with a bounded visible continuation
 - Live native context-window and Sandbox CPU/memory usage in the composer
-- Codex tools, Skills, MCP configuration, approvals and supported slash-command
-  surfaces
+- Codex tools, Skills, MCP configuration, approvals and browser-native Session
+  and Workspace controls
 - Persistent multi-Environment and multi-Session Web UI with compact,
   progressively paginated Session lists that keep every running Session
   visible, and completion state distinct from archival that automatically
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 63d84ce..eabfe16 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -97,7 +97,7 @@ Environment。如果多个 Session 本来就应该共享文件、工具和执行
 - 支持在工具运行期间向同一个 Codex Turn 追加消息，并保留原生消息顺序
 - Sandbox/Codex 进程自恢复，以及有上限的可见 continuation
 - 在输入框实时显示原生上下文窗口和 Sandbox CPU/内存使用率
-- Codex tools、Skills、MCP 配置、审批和已支持的 slash-command 界面
+- Codex tools、Skills、MCP 配置、审批，以及浏览器原生的 Session 和 Workspace 操作
 - 持久化多 Environment、多 Session Web UI；Session 列表保持紧凑并支持渐进分页，
   默认显示所有运行中的 Session，同时提供独立于归档语义、并会在新 Turn 开始时
   自动恢复为未完成的完成状态
diff --git a/docs/architecture/native-session-authority.md b/docs/architecture/native-session-authority.md
index b2a0a7e..69d5dea 100644
--- a/docs/architecture/native-session-authority.md
+++ b/docs/architecture/native-session-authority.md
@@ -495,128 +495,21 @@ Thread; the Activity tab is added only when a selected Session supplies its
 harness-owned renderer. Environment settings remain a sidebar management
 action and do not replace these Workspace operations.
 
-## Codex slash command boundary
-
-Slash completion is part of the Codex harness adapter, not the shared
-conversation dispatcher. The New Session and active Session composers use one
-Codex registry and parser, support pointer plus Up/Down/Tab/Enter/Escape
-interaction, and reject unknown commands locally instead of sending them to the
-model as user text. Each registry entry also names a stable browser intent.
-Dispatch switches on that intent rather than command text. The Codex TUI is the
-behavioral reference for command meaning, while app-server remains the data and
-mutation authority; redundant aliases and terminal-only presentation commands
-are not copied into the browser.
-
-The model-visible input boundary is strict. Sandpi submits only text the user
-can see in a composer, validated native image inputs, or the verbatim Codex TUI
-`/init` prompt after the user explicitly invokes that command. It never supplies
-Sandpi-authored `baseInstructions` or `developerInstructions`, calls
-`thread/inject_items`, or replays a user mutation after runtime repair. The only
-Sandpi-authored model input is the visible, versioned, single-attempt recovery
-Turn described above. Custom review instructions remain user input and go only
-through Codex's native `review/start` contract.
-
-Commands preserve Sandpi product ownership where a browser-native surface
-already exists:
-
-- `/new [name]` and `/clear [name]` navigate to the Environment's New Session
-  composer, preserve the optional name until creation, and pass Codex the
-  matching `startup` or `clear` native Session start source. They remain
-  unavailable during an active Turn, matching Codex TUI command availability.
-- `/fork` calls native `thread/fork`, creates a child product Session and
-  selects it.
-- `/rename [name]` updates only the product Session title; native Thread
-  metadata remains harness-owned. Bare `/rename` opens the same product
-  operation in a dialog. `/archive`
-  updates product Session metadata.
-- User-managed completion is also product Session metadata. It only changes
-  attention treatment in Session navigation; it neither archives the Session
-  nor changes the harness-native runtime status. A later authoritative native
-  `turn/started` transition atomically clears completion, while input steered
-  into the already-active Turn does not.
-- `/mention`, `/diff`, `/skills`, `/mcp [verbose]` and `/permissions` open the
-  corresponding composer, Inspector or Environment settings surface. MCP
-  verbose requests full native status and renders server tools, resources and
-  resource templates.
-- `/ide` opens the Workspace Inspector. `/agent` opens the dedicated native
-  Agent Threads picker described below. `/logout` opens the Codex account
-  connection so the user retains the existing confirmation and reconnect flow.
-- `/copy` copies the latest assistant message.
-- `/compact` calls `thread/compact/start`; `/review` calls inline
-  `review/start` with either the native `uncommittedChanges` target or a custom
-  target. Their ordinary native Turn/item notifications remain authoritative.
-  Inline review can also expose Codex's private one-shot reviewer Turn beside
-  the completed review wrapper in `thread/read`. Sandpi derives that exact
-  adjacent relationship from the native review markers and matching output:
-  the wrapper remains the Session control Turn and owns the visible result,
-  while the private delegate is omitted from conversation and interruption
-  state. The raw native snapshot is not rewritten or persisted separately.
-- `/goal` reads, creates and edits native `thread/goal/*` state; `pause`,
-  `resume` and `clear` map to native status updates or goal removal.
-- `/personality` offers the same Friendly and Pragmatic choices as Codex TUI,
-  reads the live model capability, writes native config, rereads the effective
-  layered value, and applies that value with
-  `thread/settings/update` on a loaded Thread. `/usage
-  daily|weekly|cumulative` projects `account/usage/read` token activity and is
-  deliberately separate from Sandpi/Sandbox0 billing usage.
-- `/memories` writes `features.memories` and native memory policy. Its feature
-  switch enables or disables both memory use and generation together; after
-  enabling, either policy can still be adjusted independently. Sandpi rereads
-  the effective layered values, updates the selected Thread's
-  `thread/memoryMode/set` eligibility, and exposes
-  `memory/reset`. `/hooks` reads `hooks/list` and only upserts user-controlled
-  enablement or the reviewed current hash under `hooks.state`.
-- `/ps` lists `thread/backgroundTerminals/list`; `/stop` cleans every native
-  background terminal, while the process dialog can terminate one process.
-- Fast is a
-  first-class composer switch that sends the service-tier id returned by the
-  selected model's live `model/list` entry and is absent when Codex reports no
-  Fast tier for that model.
-- `/plan` sends the selected live model and effort through Codex's native Plan
-  collaboration-mode settings. `/init` submits the same visible user prompt
-  vendored from Codex TUI's `prompt_for_init_command.md`; Sandpi does not add
-  hidden instructions around it.
-
-### Native Agent Threads
-
-Session Activity is a parent-Thread execution and audit feed; it is not the
-Codex Agent picker. Sandpi initializes app-server with
-`capabilities.experimentalApi`, then `/agent` uses
-`thread/list(ancestorThreadId)` to page the persisted spawn tree at any depth.
-The Agent picker contains the main Agent thread and its spawned subagent
-threads. This preserves completed descendants across Sandpi, app-server and
-Sandbox restarts. Selecting a row calls `thread/read(includeTurns: true)` and
-projects that native child transcript with the same Codex message, tool and
-Turn renderers used by the main conversation. A child that has not materialized
-history yet falls back to metadata-only display.
-
-The server re-reads the ancestor tree before accepting a child Thread id, so a
-caller cannot use the endpoint to inspect an unrelated Thread in the same
-Environment. Child metadata and transcripts are never copied into PostgreSQL
-or converted into product Sessions. The browser records the open picker as
-`agents=1` and a selected child as `agent={threadId}` so refresh restores the
-same GUI state. Closing the picker removes both parameters.
-
-Codex app-server does not expose the TUI slash catalog as a runtime capability.
-Sandpi therefore keeps an explicit, reviewed command registry instead of
-pretending to discover it dynamically. Future command maintenance should
-compare the pinned Codex TUI source with that registry, map browser-relevant
-commands to an existing or new intent, and deliberately exclude TUI-only
-commands. Native protocol types should continue moving toward output generated
-from the Sandbox0-pinned Codex version (`@openai/codex` 0.144.1 at the time of
-this document) rather than adding parallel Sandpi protocol models. Browser API
-projections may normalize validated native values, but must not invent harness
-behavior.
-
-`/resume` is intentionally absent because Sandpi's sidebar and URL own product
-Session selection. `/model` and `/fast` are absent because the composer owns
-those controls, and `/status` is absent because the browser already presents
-the relevant state. TUI terminal styling, local-login and debug commands are
-likewise omitted rather than emulated or forwarded. Commands for Apps, plugins,
-experimental flags, feedback and permanent deletion stay absent until Sandpi
-has a faithful product surface and lifecycle contract for them. A native
-mutation that cannot safely overlap a Turn is hidden and rejected while the
-current Turn is active.
+## Codex composer boundary
+
+Sandpi does not implement a browser slash-command grammar or mirror the Codex
+TUI command catalog. Text entered in either Codex composer is submitted as
+visible user input, including text whose first character is `/`. Product
+operations such as creating, forking, renaming or archiving a Session; opening
+Workspace and Environment settings; copying responses; and selecting models,
+reasoning effort or Fast mode remain explicit browser controls.
+
+This boundary keeps Sandpi coupled to the app-server capabilities it actually
+uses instead of the independently evolving Codex TUI command surface. Native
+review and compaction events that already exist in durable Thread history remain
+readable, but Sandpi does not expose command-only mutations for starting them.
+Environment memory configuration remains an explicit API because the Sandpi CLI
+uses it independently of the browser composer.
 
 Uploaded composer files use the Sandbox0 File API and live under
 `/workspace/.sandpi/uploads/{upload-id}/{safe-name}`. Sandpi validates a
diff --git a/e2e/smoke.spec.ts b/e2e/smoke.spec.ts
index 24e900c..5821e73 100644
--- a/e2e/smoke.spec.ts
+++ b/e2e/smoke.spec.ts
@@ -21,7 +21,6 @@ import type {
   CodexFileUpdateChange,
   CodexNativeSnapshot,
   CodexSession,
-  CodexThread,
   CodexThreadItem,
   CodexTurn,
 } from "../src/harnesses/codex/types";
@@ -3768,27 +3767,28 @@ test("interrupts a persisted running Session before its native snapshot arrives"
   await expect.poll(() => interruptBody).toEqual({});
 });
 
-test("deduplicates native models and sends Plan plus composer Fast mode", async ({
+test("deduplicates native models and submits leading slash text verbatim", async ({
   page,
-  request,
 }) => {
-  const workspace = await activeWorkspace(request);
-  test.skip(
-    !workspace ||
-      workspace.environment.status !== "ready" ||
-      workspace.environment.codingAgent.status !== "connected",
-    "A ready Environment with Codex connected is required for this check.",
+  const bootstrap = getMockBootstrap();
+  useEnglishUi(bootstrap);
+  const environment = bootstrap.environments.find(
+    (candidate) =>
+      candidate.status === "ready" &&
+      candidate.codingAgent.status === "connected",
   );
-  if (
-    !workspace ||
-    workspace.environment.status !== "ready" ||
-    workspace.environment.codingAgent.status !== "connected"
-  ) {
-    return;
-  }
-  const { environment } = workspace;
+  expect(environment).toBeTruthy();
+  if (!environment) return;
+  bootstrap.selectedEnvironmentId = environment.id;
+  bootstrap.selectedSessionId = "";
   let createBody: Record<string, unknown> | undefined;
 
+  await page.route(
+    (url) => url.pathname === "/api/v1/bootstrap",
+    async (route) => {
+      await route.fulfill({ json: { data: bootstrap } });
+    },
+  );
   await page.route(
     `**/api/v1/environments/${encodeURIComponent(environment.id)}/harnesses/codex/models`,
     async (route) => {
@@ -3856,285 +3856,26 @@ test("deduplicates native models and sends Plan plus composer Fast mode", async
   const composer = page.locator(
     'textarea[name="new-session-instruction"]',
   );
-  await composer.fill("/plan");
-  await composer.press("Enter");
-  await expect(page.locator(".codex-composer-mode")).toBeVisible();
-  await expect(composer).toHaveValue("");
+  await composer.fill("/plan Design the persistence change");
+  await expect(page.locator(".codex-slash-command-menu")).toHaveCount(0);
+  await expect(page.locator(".codex-composer-mode")).toHaveCount(0);
   const fastToggle = page.getByTestId("codex-fast-toggle");
   await expect(fastToggle).toHaveAttribute("aria-pressed", "false");
   await fastToggle.click();
   await expect(fastToggle).toHaveAttribute("aria-pressed", "true");
-  await expect(page.locator(".codex-composer-mode")).toHaveCount(1);
 
-  await composer.fill("Design the persistence change");
   await page.locator(".composer-shell .send-button").click();
   await expect
     .poll(() => createBody)
     .toMatchObject({
       environmentId: environment.id,
-      prompt: "Design the persistence change",
+      prompt: "/plan Design the persistence change",
       modelId: "e2e-plan-model",
       reasoningEffort: "high",
-      collaborationMode: "plan",
       serviceTier: "e2e-native-priority",
     });
-});
-
-test("maps Codex slash commands to Sandpi new and fork Session flows", async ({
-  page,
-  request,
-}) => {
-  const workspace = await activeWorkspace(request);
-  test.skip(!workspace, "An active Session is required for this check.");
-  if (!workspace) return;
-  const { environment, session } = workspace;
-  const eventPath = `/api/v1/sessions/${session.id}/events`;
-  const nativeThreadId = "thread-e2e-slash-commands";
-  const forkedSessionId = "session-e2e-slash-fork";
-  const now = Date.now() / 1_000;
-  const snapshot: CodexNativeSnapshot = {
-    protocol: "codex-app-server",
-    nativeSessionId: nativeThreadId,
-    historyRevision: 1,
-    modelId: "e2e-slash-model",
-    reasoningEffort: "high",
-    sessionStatus: "waiting",
-    forkableTurnIds: [],
-    activity: {
-      source: "codex-rollout",
-      availability: "available",
-      error: null,
-      records: [],
-    },
-    thread: {
-      id: nativeThreadId,
-      createdAt: now,
-      updatedAt: now,
-      status: { type: "idle" },
-      turns: [],
-    },
-  };
-  let forkBody: unknown;
-  const browserErrors: string[] = [];
-  page.on("console", (message) => {
-    if (message.type() === "error") browserErrors.push(message.text());
-  });
-  page.on("pageerror", (error) => browserErrors.push(error.message));
-
-  await installDarkUiPreferences(page);
-  await installControlledEventSource(page);
-  await page.route("**/api/v1/**/models", async (route) => {
-    await route.fulfill({
-      json: {
-        data: {
-          data: [
-            {
-              id: snapshot.modelId,
-              displayName: "E2E slash model",
-              isDefault: true,
-              defaultReasoningEffort: "high",
-              supportedReasoningEfforts: [
-                {
-                  reasoningEffort: "high",
-                  description: "Deep reasoning",
-                },
-              ],
-            },
-          ],
-        },
-        meta: { availability: "available", source: "codex" },
-      },
-    });
-  });
-  await page.route(
-    `**/api/v1/sessions/${encodeURIComponent(session.id)}/fork`,
-    async (route) => {
-      forkBody = route.request().postDataJSON();
-      await route.fulfill({
-        status: 201,
-        json: {
-          data: {
-            ...session,
-            id: forkedSessionId,
-            title: "Forked from slash command",
-            status: "waiting",
-            archived: false,
-            createdAt: now,
-            updatedAt: now,
-          },
-        },
-      });
-    },
-  );
-  const agentThread: CodexThread = {
-    id: "thread-e2e-subagent",
-    parentThreadId: nativeThreadId,
-    agentNickname: "Scout",
-    agentRole: "explorer",
-    preview: "Inspect the native Agent flow",
-    createdAt: now + 1,
-    updatedAt: now + 2,
-    status: { type: "idle" },
-    turns: [
-      {
-        id: "turn-e2e-subagent",
-        itemsView: "full",
-        status: "completed",
-        error: null,
-        startedAt: now + 1,
-        completedAt: now + 2,
-        durationMs: 1_000,
-        items: [
-          {
-            type: "userMessage",
-            id: "item-e2e-subagent-prompt",
-            clientId: null,
-            content: [
-              {
-                type: "text",
-                text: "Inspect the native Agent flow",
-                text_elements: [],
-              },
-            ],
-          },
-          {
-            type: "agentMessage",
-            id: "item-e2e-subagent-answer",
-            text: "Sub-agent result from its own native Thread.",
-            phase: "final_answer",
-            memoryCitation: null,
-          },
-        ],
-      },
-    ],
-  };
-  await page.route(
-    `**/api/v1/sessions/${encodeURIComponent(session.id)}/agents**`,
-    async (route) => {
-      const path = new URL(route.request().url()).pathname;
-      if (path.endsWith("/agents")) {
-        await route.fulfill({
-          json: {
-            data: {
-              root: snapshot.thread,
-              descendants: [{ ...agentThread, turns: [] }],
-            },
-          },
-        });
-        return;
-      }
-      const requestedThreadId = decodeURIComponent(path.split("/").at(-1)!);
-      await route.fulfill({
-        json: {
-          data:
-            requestedThreadId === agentThread.id
-              ? agentThread
-              : snapshot.thread,
-        },
-      });
-    },
-  );
-
-  const sourceUrl =
-    `/?environment=${encodeURIComponent(environment.id)}` +
-    `&session=${encodeURIComponent(session.id)}`;
-  await page.goto(sourceUrl);
-  await emitControlledEvent(page, eventPath, "snapshot", snapshot);
-  await expect(page.getByText("Loading conversation…")).toBeHidden();
-
-  const composer = page.locator('textarea[name="message"]');
-  await composer.fill("/");
-  const menu = page.getByRole("listbox", {
-    name: /Codex slash commands|Codex 斜杠命令/,
-  });
-  await expect(menu).toBeVisible();
-  await expect(
-    menu.locator(".codex-slash-command-name", { hasText: "/new" }),
-  ).toHaveCount(1);
-  await expect(
-    menu.locator(".codex-slash-command-name", { hasText: "/fork" }),
-  ).toHaveCount(1);
-  await expect(menu).not.toContainText("/resume");
-  await expect(menu).not.toContainText("/side");
-  await expect(menu).not.toContainText("/btw");
-  await expect(menu).not.toContainText("/fast");
-  await expect(menu).not.toContainText("/status");
-
-  await composer.fill("/agent");
-  await composer.press("Enter");
-  const agentDialog = page.getByRole("dialog", { name: "Agent Threads" });
-  await expect(agentDialog).toBeVisible();
-  await expect
-    .poll(() => new URL(page.url()).searchParams.get("agents"))
-    .toBe("1");
-  await expect(
-    page.getByRole("complementary", { name: "Inspector" }),
-  ).toBeHidden();
-  await agentDialog.getByRole("button", { name: /Scout/ }).click();
-  await expect
-    .poll(() => new URL(page.url()).searchParams.get("agent"))
-    .toBe(agentThread.id);
-  await expect(
-    agentDialog.getByText("Sub-agent result from its own native Thread."),
-  ).toBeVisible();
-  await expect(page.locator("html")).toHaveAttribute(
-    "data-resolved-theme",
-    "dark",
-  );
-  const parentAgentMessage = agentDialog.locator(
-    'article[data-role="user"] .markdown-content',
-  );
-  await expect(parentAgentMessage).toHaveCSS(
-    "background-color",
-    "rgb(32, 56, 42)",
-  );
-  await expect(parentAgentMessage).toHaveCSS(
-    "color",
-    "rgb(240, 239, 233)",
-  );
-  await page.reload();
-  await emitControlledEvent(page, eventPath, "snapshot", snapshot);
-  await expect(agentDialog).toBeVisible();
-  await expect(
-    agentDialog.getByText("Sub-agent result from its own native Thread."),
-  ).toBeVisible();
-  await agentDialog
-    .getByRole("button", { name: "Close Agent Threads" })
-    .click();
-  await expect
-    .poll(() => new URL(page.url()).searchParams.get("agents"))
-    .toBeNull();
-  expect(new URL(page.url()).searchParams.get("agent")).toBeNull();
-
-  await composer.fill("/subagents");
-  await composer.press("Enter");
-  await expect(agentDialog).toBeHidden();
-  await expect(
-    page
-      .getByRole("region", { name: "Codex conversation" })
-      .getByRole("alert"),
-  ).toContainText("Unknown command /subagents");
-
-  await composer.fill("/new");
-  await composer.press("Enter");
-  await expect
-    .poll(() => new URL(page.url()).searchParams.get("session"))
-    .toBeNull();
-  await expect(
-    page.locator('textarea[name="new-session-instruction"]'),
-  ).toBeVisible();
-
-  await page.goto(sourceUrl);
-  await emitControlledEvent(page, eventPath, "snapshot", snapshot);
-  await expect(page.getByText("Loading conversation…")).toBeHidden();
-  const resumedComposer = page.locator('textarea[name="message"]');
-  await resumedComposer.fill("/fork");
-  await resumedComposer.press("Enter");
-  await expect.poll(() => forkBody).toEqual({});
-  await expect
-    .poll(() => new URL(page.url()).searchParams.get("session"))
-    .toBe(forkedSessionId);
-  expect(browserErrors).toEqual([]);
+  expect(createBody).not.toHaveProperty("collaborationMode");
+  expect(createBody).not.toHaveProperty("sessionStartSource");
 });
 
 test("keeps an optimistic prompt ahead of Activity and folds it for the streamed answer", async ({
diff --git a/openapi.yaml b/openapi.yaml
index 0f4c8b6..53aa9c3 100644
--- a/openapi.yaml
+++ b/openapi.yaml
@@ -156,58 +156,6 @@ components:
       required:
         - type
       additionalProperties: false
-    CodexAgentThreads:
-      type: object
-      properties:
-        root:
-          $ref: "#/components/schemas/CodexThread"
-        descendants:
-          type: array
-          items:
-            $ref: "#/components/schemas/CodexThread"
-      required:
-        - root
-        - descendants
-      additionalProperties: false
-    CodexBackgroundTerminals:
-      type: object
-      properties:
-        terminals:
-          type: array
-          items:
-            type: object
-            properties:
-              itemId:
-                type: string
-              processId:
-                type: string
-              command:
-                type: string
-              cwd:
-                type: string
-              osPid:
-                nullable: true
-                type: integer
-                minimum: -9007199254740991
-                maximum: 9007199254740991
-              cpuPercent:
-                nullable: true
-                type: number
-              rssKb:
-                nullable: true
-                type: number
-            required:
-              - itemId
-              - processId
-              - command
-              - cwd
-              - osPid
-              - cpuPercent
-              - rssKb
-            additionalProperties: false
-      required:
-        - terminals
-      additionalProperties: false
     CodexComposerUpload:
       type: object
       properties:
@@ -280,94 +228,6 @@ components:
         - createdAt
         - updatedAt
       additionalProperties: false
-    CodexHooksInventory:
-      type: object
-      properties:
-        cwd:
-          type: string
-        hooks:
-          type: array
-          items:
-            type: object
-            properties:
-              key:
-                type: string
-              eventName:
-                type: string
-              handlerType:
-                type: string
-              isManaged:
-                type: boolean
-              matcher:
-                nullable: true
-                type: string
-              command:
-                nullable: true
-                type: string
-              timeoutSec:
-                type: number
-              statusMessage:
-                nullable: true
-                type: string
-              sourcePath:
-                type: string
-              source:
-                type: string
-              pluginId:
-                nullable: true
-                type: string
-              displayOrder:
-                type: number
-              enabled:
-                type: boolean
-              currentHash:
-                type: string
-              trustStatus:
-                type: string
-                enum:
-                  - trusted
-                  - untrusted
-                  - modified
-                  - managed
-            required:
-              - key
-              - eventName
-              - handlerType
-              - isManaged
-              - matcher
-              - command
-              - timeoutSec
-              - statusMessage
-              - sourcePath
-              - source
-              - pluginId
-              - displayOrder
-              - enabled
-              - currentHash
-              - trustStatus
-            additionalProperties: false
-        warnings:
-          type: array
-          items:
-            type: string
-        errors:
-          type: array
-          items:
-            type: object
-            properties:
-              path:
-                type: string
-              message:
-                type: string
-            required:
-              - message
-            additionalProperties: false
-      required:
-        - cwd
-        - hooks
-        - warnings
-        - errors
-      additionalProperties: false
     CodexMcpInventory:
       type: object
       properties:
@@ -542,21 +402,6 @@ components:
         - activity
         - forkableTurnIds
       additionalProperties: {}
-    CodexPersonalitySettings:
-      type: object
-      properties:
-        personality:
-          type: string
-          enum:
-            - friendly
-            - pragmatic
-            - none
-        supported:
-          type: boolean
-      required:
-        - personality
-        - supported
-      additionalProperties: false
     CodexRateLimitResetResult:
       type: object
       properties:
@@ -570,34 +415,6 @@ components:
       required:
         - outcome
       additionalProperties: false
-    CodexSessionGoal:
-      type: object
-      properties:
-        goal:
-          nullable: true
-          type: object
-          properties:
-            objective:
-              type: string
-            status:
-              type: string
-            tokenBudget:
-              nullable: true
-              type: number
-            tokensUsed:
-              type: number
-            timeUsedSeconds:
-              type: number
-          required:
-            - objective
-            - status
-            - tokenBudget
-            - tokensUsed
-            - timeUsedSeconds
-          additionalProperties: false
-      required:
-        - goal
-      additionalProperties: false
     CodexSkillsInventory:
       type: object
       properties:
@@ -808,51 +625,6 @@ components:
         - status
         - turns
       additionalProperties: {}
-    CodexTokenUsage:
-      type: object
-      properties:
-        summary:
-          type: object
-          properties:
-            lifetimeTokens:
-              nullable: true
-              type: number
-            peakDailyTokens:
-              nullable: true
-              type: number
-            longestRunningTurnSec:
-              nullable: true
-              type: number
-            currentStreakDays:
-              nullable: true
-              type: number
-            longestStreakDays:
-              nullable: true
-              type: number
-          required:
-            - lifetimeTokens
-            - peakDailyTokens
-            - longestRunningTurnSec
-            - currentStreakDays
-            - longestStreakDays
-          additionalProperties: false
-        dailyUsageBuckets:
-          type: array
-          items:
-            type: object
-            properties:
-              startDate:
-                type: string
-              tokens:
-                type: number
-            required:
-              - startDate
-              - tokens
-            additionalProperties: false
-      required:
-        - summary
-        - dailyUsageBuckets
-      additionalProperties: false
     CodingSession:
       type: object
       properties:
@@ -5234,90 +5006,6 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/hooks:
-    get:
-      operationId: listEnvironmentCodexHooks
-      summary: List Environment Codex hooks
-      tags:
-        - Codex
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: environmentId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexHooksInventory"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-    put:
-      operationId: updateEnvironmentCodexHook
-      summary: Update one Environment Codex hook
-      tags:
-        - Codex
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                key:
-                  type: string
-                  minLength: 1
-                  maxLength: 8192
-                enabled:
-                  type: boolean
-                trustedHash:
-                  type: string
-                  minLength: 1
-                  maxLength: 512
-              required:
-                - key
-              description: At least one of enabled or trustedHash is required.
-        description: At least one of enabled or trustedHash is required.
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: environmentId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexHooksInventory"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
   /api/v1/environments/{environmentId}/harnesses/codex/mcp-servers:
     get:
       operationId: listEnvironmentCodexMcpServers
@@ -5840,10 +5528,10 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/personality:
+  /api/v1/environments/{environmentId}/harnesses/codex/rate-limits:
     get:
-      operationId: getEnvironmentCodexPersonality
-      summary: Get the Environment Codex personality
+      operationId: getCodexRateLimits
+      summary: Get Codex account rate limits
       tags:
         - Codex
       parameters:
@@ -5862,7 +5550,7 @@ paths:
                 type: object
                 properties:
                   data:
-                    $ref: "#/components/schemas/CodexPersonalitySettings"
+                    $ref: "#/components/schemas/CodexAccountRateLimits"
                 required:
                   - data
                 additionalProperties: false
@@ -5872,9 +5560,10 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
+  /api/v1/environments/{environmentId}/harnesses/codex/rate-limits/reset:
     put:
-      operationId: setEnvironmentCodexPersonality
-      summary: Set the Environment Codex personality
+      operationId: resetCodexRateLimit
+      summary: Consume one Codex rate-limit reset credit
       tags:
         - Codex
       requestBody:
@@ -5884,13 +5573,13 @@ paths:
             schema:
               type: object
               properties:
-                personality:
+                idempotencyKey:
                   type: string
-                  enum:
-                    - friendly
-                    - pragmatic
+                  minLength: 16
+                  maxLength: 128
               required:
-                - personality
+                - idempotencyKey
+              additionalProperties: false
       parameters:
         - schema:
             type: string
@@ -5907,7 +5596,7 @@ paths:
                 type: object
                 properties:
                   data:
-                    $ref: "#/components/schemas/CodexPersonalitySettings"
+                    $ref: "#/components/schemas/CodexRateLimitResetResult"
                 required:
                   - data
                 additionalProperties: false
@@ -5917,13 +5606,20 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/rate-limits:
+  /api/v1/environments/{environmentId}/harnesses/codex/skills:
     get:
-      operationId: getCodexRateLimits
-      summary: Get Codex account rate limits
+      operationId: listEnvironmentCodexSkills
+      summary: List Environment Codex skills
       tags:
         - Codex
       parameters:
+        - schema:
+            type: string
+            enum:
+              - "1"
+          in: query
+          name: force
+          required: false
         - schema:
             type: string
             minLength: 1
@@ -5939,7 +5635,7 @@ paths:
                 type: object
                 properties:
                   data:
-                    $ref: "#/components/schemas/CodexAccountRateLimits"
+                    $ref: "#/components/schemas/CodexSkillsInventory"
                 required:
                   - data
                 additionalProperties: false
@@ -5949,10 +5645,10 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/rate-limits/reset:
+  /api/v1/environments/{environmentId}/harnesses/codex/skills/config:
     put:
-      operationId: resetCodexRateLimit
-      summary: Consume one Codex rate-limit reset credit
+      operationId: setEnvironmentCodexSkillEnabled
+      summary: Enable or disable one Environment Codex skill
       tags:
         - Codex
       requestBody:
@@ -5962,100 +5658,15 @@ paths:
             schema:
               type: object
               properties:
-                idempotencyKey:
+                path:
                   type: string
-                  minLength: 16
-                  maxLength: 128
+                  minLength: 1
+                  maxLength: 4096
+                enabled:
+                  type: boolean
               required:
-                - idempotencyKey
-              additionalProperties: false
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: environmentId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexRateLimitResetResult"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/skills:
-    get:
-      operationId: listEnvironmentCodexSkills
-      summary: List Environment Codex skills
-      tags:
-        - Codex
-      parameters:
-        - schema:
-            type: string
-            enum:
-              - "1"
-          in: query
-          name: force
-          required: false
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: environmentId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexSkillsInventory"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/skills/config:
-    put:
-      operationId: setEnvironmentCodexSkillEnabled
-      summary: Enable or disable one Environment Codex skill
-      tags:
-        - Codex
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                path:
-                  type: string
-                  minLength: 1
-                  maxLength: 4096
-                enabled:
-                  type: boolean
-              required:
-                - path
-                - enabled
+                - path
+                - enabled
       parameters:
         - schema:
             type: string
@@ -6201,38 +5812,6 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/environments/{environmentId}/harnesses/codex/token-usage:
-    get:
-      operationId: getCodexTokenUsage
-      summary: Get Codex account token usage
-      tags:
-        - Codex
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: environmentId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexTokenUsage"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
   /api/v1/environments/{environmentId}/harnesses/codex/uploads:
     post:
       operationId: uploadCodexComposerFile
@@ -8180,11 +7759,6 @@ paths:
                   type: string
                   minLength: 1
                   maxLength: 100
-                sessionStartSource:
-                  type: string
-                  enum:
-                    - startup
-                    - clear
                 images:
                   default: []
                   maxItems: 6
@@ -8283,10 +7857,10 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/agents:
+  /api/v1/sessions/{sessionId}/events:
     get:
-      operationId: listSessionAgentThreads
-      summary: List the native Codex agent-thread tree
+      operationId: streamSessionEvents
+      summary: Stream the native Session snapshot and live events
       tags:
         - Sessions
       parameters:
@@ -8296,32 +7870,55 @@ paths:
           in: path
           name: sessionId
           required: true
+      x-sandpi-sse:
+        events:
+          snapshot:
+            schema:
+              $ref: "#/components/schemas/CodexNativeSnapshot"
+          activity:
+            schema:
+              type: object
+          notification:
+            schema:
+              $ref: "#/components/schemas/NativeHarnessEvent"
+          invalidation:
+            schema:
+              type: object
+          stream-error:
+            schema:
+              type: object
       x-sandpi-native-schema: codex-app-server
       responses:
         "200":
           description: Successful response.
           content:
-            application/json:
+            text/event-stream:
               schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexAgentThreads"
-                required:
-                  - data
-                additionalProperties: false
+                type: string
         default:
           description: Sandpi error.
           content:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/agents/{nativeThreadId}:
-    get:
-      operationId: getSessionAgentThread
-      summary: Read one native Codex agent Thread
+  /api/v1/sessions/{sessionId}/fork:
+    post:
+      operationId: forkSession
+      summary: Fork a Session from its current native branch
       tags:
         - Sessions
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              default: {}
+              type: object
+              properties:
+                title:
+                  type: string
+                  minLength: 1
+                  maxLength: 200
       parameters:
         - schema:
             type: string
@@ -8329,23 +7926,17 @@ paths:
           in: path
           name: sessionId
           required: true
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: nativeThreadId
-          required: true
-      x-sandpi-native-schema: codex-app-server
+      x-sandpi-optional-request-body: true
       responses:
-        "200":
-          description: Successful response.
+        "201":
+          description: Created.
           content:
             application/json:
               schema:
                 type: object
                 properties:
                   data:
-                    $ref: "#/components/schemas/CodexThread"
+                    $ref: "#/components/schemas/CodingSession"
                 required:
                   - data
                 additionalProperties: false
@@ -8355,12 +7946,33 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/background-terminals:
-    get:
-      operationId: listSessionBackgroundTerminals
-      summary: List Codex background terminals
+  /api/v1/sessions/{sessionId}/metadata:
+    put:
+      operationId: updateSessionMetadata
+      summary: Update product Session metadata
       tags:
         - Sessions
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                title:
+                  type: string
+                  minLength: 1
+                  maxLength: 200
+                pinned:
+                  type: boolean
+                completed:
+                  type: boolean
+                archived:
+                  type: boolean
+                unread:
+                  type: boolean
+              description: At least one metadata field is required.
+        description: At least one metadata field is required.
       parameters:
         - schema:
             type: string
@@ -8377,7 +7989,7 @@ paths:
                 type: object
                 properties:
                   data:
-                    $ref: "#/components/schemas/CodexBackgroundTerminals"
+                    $ref: "#/components/schemas/CodingSession"
                 required:
                   - data
                 additionalProperties: false
@@ -8387,9 +7999,10 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-    delete:
-      operationId: cleanSessionBackgroundTerminals
-      summary: Clean completed Codex background terminals
+  /api/v1/sessions/{sessionId}/models:
+    get:
+      operationId: listSessionCodexModels
+      summary: List native Codex model capabilities for a Session
       tags:
         - Sessions
       parameters:
@@ -8399,6 +8012,7 @@ paths:
           in: path
           name: sessionId
           required: true
+      x-sandpi-native-schema: codex-app-server
       responses:
         "200":
           description: Successful response.
@@ -8410,484 +8024,29 @@ paths:
                   data:
                     type: object
                     properties:
-                      cleaned:
-                        type: boolean
+                      data:
+                        type: array
+                        items: {}
                     required:
-                      - cleaned
+                      - data
                     additionalProperties: false
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/background-terminals/{processId}:
-    delete:
-      operationId: terminateSessionBackgroundTerminal
-      summary: Terminate one Codex background terminal
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: processId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
+                  meta:
                     type: object
                     properties:
-                      terminated:
-                        type: boolean
+                      availability:
+                        type: string
+                        enum:
+                          - available
+                          - runtime-unavailable
+                      source:
+                        type: string
+                        enum:
+                          - codex
+                      message:
+                        type: string
                     required:
-                      - terminated
-                    additionalProperties: false
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/compact:
-    post:
-      operationId: compactSession
-      summary: Start native Session compaction
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "202":
-          description: Accepted.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    type: object
-                    properties:
-                      accepted:
-                        type: boolean
-                    required:
-                      - accepted
-                    additionalProperties: false
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/events:
-    get:
-      operationId: streamSessionEvents
-      summary: Stream the native Session snapshot and live events
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      x-sandpi-sse:
-        events:
-          snapshot:
-            schema:
-              $ref: "#/components/schemas/CodexNativeSnapshot"
-          activity:
-            schema:
-              type: object
-          notification:
-            schema:
-              $ref: "#/components/schemas/NativeHarnessEvent"
-          invalidation:
-            schema:
-              type: object
-          stream-error:
-            schema:
-              type: object
-      x-sandpi-native-schema: codex-app-server
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            text/event-stream:
-              schema:
-                type: string
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/fork:
-    post:
-      operationId: forkSession
-      summary: Fork a Session from its current native branch
-      tags:
-        - Sessions
-      requestBody:
-        required: false
-        content:
-          application/json:
-            schema:
-              default: {}
-              type: object
-              properties:
-                title:
-                  type: string
-                  minLength: 1
-                  maxLength: 200
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      x-sandpi-optional-request-body: true
-      responses:
-        "201":
-          description: Created.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodingSession"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/goal:
-    get:
-      operationId: getSessionGoal
-      summary: Get the native Session goal
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexSessionGoal"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-    put:
-      operationId: updateSessionGoal
-      summary: Update the native Session goal
-      tags:
-        - Sessions
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                objective:
-                  type: string
-                  minLength: 1
-                  maxLength: 10000
-                status:
-                  type: string
-                  enum:
-                    - active
-                    - paused
-              description: At least one of objective or status is required.
-        description: At least one of objective or status is required.
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexSessionGoal"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-    delete:
-      operationId: clearSessionGoal
-      summary: Clear the native Session goal
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexSessionGoal"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/memories:
-    get:
-      operationId: getSessionCodexMemories
-      summary: Get Session Codex memory settings
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexMemoriesSettings"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-    put:
-      operationId: setSessionCodexMemories
-      summary: Set Session Codex memory settings
-      tags:
-        - Sessions
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                featureEnabled:
-                  type: boolean
-                useMemories:
-                  type: boolean
-                generateMemories:
-                  type: boolean
-              required:
-                - featureEnabled
-                - useMemories
-                - generateMemories
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexMemoriesSettings"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/metadata:
-    put:
-      operationId: updateSessionMetadata
-      summary: Update product Session metadata
-      tags:
-        - Sessions
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                title:
-                  type: string
-                  minLength: 1
-                  maxLength: 200
-                pinned:
-                  type: boolean
-                completed:
-                  type: boolean
-                archived:
-                  type: boolean
-                unread:
-                  type: boolean
-              description: At least one metadata field is required.
-        description: At least one metadata field is required.
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodingSession"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/models:
-    get:
-      operationId: listSessionCodexModels
-      summary: List native Codex model capabilities for a Session
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      x-sandpi-native-schema: codex-app-server
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    type: object
-                    properties:
-                      data:
-                        type: array
-                        items: {}
-                    required:
-                      - data
-                    additionalProperties: false
-                  meta:
-                    type: object
-                    properties:
-                      availability:
-                        type: string
-                        enum:
-                          - available
-                          - runtime-unavailable
-                      source:
-                        type: string
-                        enum:
-                          - codex
-                      message:
-                        type: string
-                    required:
-                      - availability
-                      - source
+                      - availability
+                      - source
                     additionalProperties: false
                 required:
                   - data
@@ -8899,134 +8058,6 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/personality:
-    get:
-      operationId: getSessionCodexPersonality
-      summary: Get the Session Codex personality
-      tags:
-        - Sessions
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexPersonalitySettings"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-    put:
-      operationId: setSessionCodexPersonality
-      summary: Set the Session Codex personality
-      tags:
-        - Sessions
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                personality:
-                  type: string
-                  enum:
-                    - friendly
-                    - pragmatic
-              required:
-                - personality
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      responses:
-        "200":
-          description: Successful response.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    $ref: "#/components/schemas/CodexPersonalitySettings"
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
-  /api/v1/sessions/{sessionId}/review:
-    post:
-      operationId: startSessionReview
-      summary: Start an inline native code review
-      tags:
-        - Sessions
-      requestBody:
-        required: false
-        content:
-          application/json:
-            schema:
-              default: {}
-              type: object
-              properties:
-                instructions:
-                  type: string
-                  minLength: 1
-                  maxLength: 100000
-      parameters:
-        - schema:
-            type: string
-            minLength: 1
-          in: path
-          name: sessionId
-          required: true
-      x-sandpi-optional-request-body: true
-      responses:
-        "202":
-          description: Accepted.
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  data:
-                    type: object
-                    properties:
-                      nativeTurnId:
-                        type: string
-                    required:
-                      - nativeTurnId
-                    additionalProperties: false
-                required:
-                  - data
-                additionalProperties: false
-        default:
-          description: Sandpi error.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
   /api/v1/sessions/{sessionId}/turns:
     post:
       operationId: startSessionTurn
diff --git a/src/app/globals.css b/src/app/globals.css
index 94ea547..7e22eb9 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -3037,71 +3037,7 @@ code.codex-compact-activity-subject {
     0 2px 8px rgb(30 30 24 / 8%);
 }
 
-.codex-slash-command-menu {
-  position: absolute;
-  z-index: 30;
-  right: 0;
-  bottom: calc(100% + 8px);
-  left: 0;
-  display: grid;
-  max-height: min(360px, 48dvh);
-  overflow-y: auto;
-  padding: 5px;
-  border: 1px solid var(--line);
-  border-radius: 12px;
-  background: var(--panel-strong);
-  box-shadow:
-    0 18px 48px rgb(30 30 24 / 18%),
-    0 2px 9px rgb(30 30 24 / 10%);
-}
-
-.codex-slash-command-menu > button {
-  display: grid;
-  grid-template-columns: minmax(130px, 0.4fr) minmax(0, 1fr);
-  align-items: baseline;
-  gap: 12px;
-  min-height: 36px;
-  padding: 8px 9px;
-  border: 0;
-  border-radius: 7px;
-  background: transparent;
-  color: var(--ink);
-  text-align: left;
-  cursor: pointer;
-}
-
-.codex-slash-command-menu > button.is-active,
-.codex-slash-command-menu > button:hover {
-  background: var(--selected);
-}
-
-.codex-slash-command-name {
-  overflow: hidden;
-  font-family: var(--font-mono);
-  font-size: 11px;
-  font-weight: 650;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.codex-slash-command-name i {
-  margin-left: 5px;
-  color: var(--ink-faint);
-  font-style: normal;
-  font-weight: 450;
-}
-
-.codex-slash-command-description {
-  overflow: hidden;
-  color: var(--ink-soft);
-  font-size: 10.5px;
-  line-height: 1.35;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.codex-composer-notice,
-.codex-composer-mode {
+.codex-composer-notice {
   display: flex;
   min-height: 28px;
   align-items: center;
@@ -3120,38 +3056,16 @@ code.codex-compact-activity-subject {
   color: var(--red);
 }
 
-.codex-composer-notice strong,
-.codex-composer-mode strong {
+.codex-composer-notice strong {
   color: var(--ink);
   font-weight: 650;
 }
 
-.codex-composer-notice > span,
-.codex-composer-mode > span {
+.codex-composer-notice > span {
   min-width: 0;
   flex: 1;
 }
 
-.codex-composer-mode > button {
-  display: inline-flex;
-  width: 22px;
-  height: 22px;
-  flex: 0 0 auto;
-  align-items: center;
-  justify-content: center;
-  padding: 0;
-  border: 0;
-  border-radius: 5px;
-  background: transparent;
-  color: var(--ink-faint);
-  cursor: pointer;
-}
-
-.codex-composer-mode > button:hover {
-  background: var(--hover);
-  color: var(--ink);
-}
-
 .composer-shell:focus-within {
   border-color: var(--ink-faint);
   box-shadow:
@@ -3159,13 +3073,6 @@ code.codex-compact-activity-subject {
     0 2px 9px rgb(30 30 24 / 10%);
 }
 
-@media (max-width: 640px) {
-  .codex-slash-command-menu > button {
-    grid-template-columns: minmax(112px, 0.46fr) minmax(0, 1fr);
-    gap: 8px;
-  }
-}
-
 .native-context-reset-notice {
   display: grid;
   grid-template-columns: auto minmax(0, 1fr);
diff --git a/src/components/conversation.tsx b/src/components/conversation.tsx
index 67a5150..7277255 100644
--- a/src/components/conversation.tsx
+++ b/src/components/conversation.tsx
@@ -28,10 +28,7 @@ interface ConversationProps {
   onInspectorTabChange: (tab: InspectorTab) => void;
   onInspectorWidthRatioChange: (ratio: number, persist: boolean) => void;
   onToggleTerminal: () => void;
-  onNewSession: (options?: {
-    title?: string;
-    source?: "startup" | "clear";
-  }) => void;
+  onNewSession: () => void;
   onOpenEnvironmentSettings: (
     tab: EnvironmentSettingsTab,
     options?: EnvironmentSettingsOpenOptions,
@@ -49,7 +46,7 @@ interface ConversationProps {
 
 /**
  * Thin harness dispatcher. It selects a complete harness-owned conversation experience and
- * intentionally exposes no shared message, tool, approval, slash-command or composer contract.
+ * intentionally exposes no shared message, tool, approval or composer contract.
  */
 export function Conversation(props: ConversationProps) {
   if (isCodexSession(props.session)) {
diff --git a/src/components/new-session-workspace.tsx b/src/components/new-session-workspace.tsx
index d9829b0..9009695 100644
--- a/src/components/new-session-workspace.tsx
+++ b/src/components/new-session-workspace.tsx
@@ -1,10 +1,6 @@
 "use client";
 
 import { CodexNewSessionWorkspace } from "@/harnesses/codex/new-session-workspace";
-import type {
-  EnvironmentSettingsOpenOptions,
-  EnvironmentSettingsTab,
-} from "@/components/environment-settings";
 import type { CodexSession } from "@/harnesses/codex/types";
 import type { OperationLanguage, SendShortcut } from "@/lib/operation-ui";
 import type { CodingSession, Environment } from "@/lib/types";
@@ -16,13 +12,7 @@ interface NewSessionWorkspaceProps {
   canManageEnvironment: boolean;
   onEnvironmentChange: (environment: Environment) => void;
   onCreated: (session: CodingSession) => void;
-  initialTitle?: string;
-  sessionStartSource?: "startup" | "clear";
   onOpenAgentHarnessSettings: () => void;
-  onOpenEnvironmentSettings: (
-    tab: EnvironmentSettingsTab,
-    options?: EnvironmentSettingsOpenOptions,
-  ) => void;
   onToggleSidebar: () => void;
   inspectorOpen: boolean;
   onToggleInspector: () => void;
diff --git a/src/components/sandpi-app.tsx b/src/components/sandpi-app.tsx
index 123873a..f6c2b44 100644
--- a/src/components/sandpi-app.tsx
+++ b/src/components/sandpi-app.tsx
@@ -107,10 +107,6 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
     initialTab: EnvironmentSettingsTab;
     mcpVerbose?: boolean;
   } | null>(null);
-  const [newSessionPreset, setNewSessionPreset] = useState<{
-    title?: string;
-    source?: "startup" | "clear";
-  } | null>(null);
   const [newEnvironmentOpen, setNewEnvironmentOpen] = useState(false);
   const [inspectorOpen, setInspectorOpen] = useState(false);
   const [terminalOpen, setTerminalOpen] = useState(false);
@@ -220,7 +216,6 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
       );
       if (environmentChanged) setTerminalOpen(false);
       if (selectionChanged) {
-        setNewSessionPreset(null);
         const environment = next.environments.find(
           (candidate) => candidate.id === next.selectedEnvironmentId,
         );
@@ -576,17 +571,13 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
         setSelectedSessionId("");
         replaceWorkspaceUrl(environmentId);
       }
-      setNewSessionPreset(null);
       setSidebarOpen(false);
     },
     [environments, hydrateSession, sessions],
   );
 
   const handleNewSession = useCallback(
-    (
-      environmentId: string,
-      options?: { title?: string; source?: "startup" | "clear" },
-    ) => {
+    (environmentId: string) => {
       if (
         !environments.some(
           (environment) => environment.id === environmentId,
@@ -596,7 +587,6 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
       }
       setSelectedEnvironmentId(environmentId);
       setSelectedSessionId("");
-      setNewSessionPreset(options ?? null);
       replaceWorkspaceUrl(environmentId);
       setSidebarOpen(false);
     },
@@ -745,7 +735,6 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
       ]);
       setSelectedEnvironmentId(session.environmentId);
       setSelectedSessionId(session.id);
-      setNewSessionPreset(null);
       replaceWorkspaceUrl(session.environmentId, session.id);
       setTerminalOpen(false);
     },
@@ -1123,9 +1112,7 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
           onInspectorTabChange={handleInspectorTabChange}
           onInspectorWidthRatioChange={handleInspectorWidthRatioChange}
           onToggleTerminal={() => setTerminalOpen((open) => !open)}
-          onNewSession={(options) =>
-            handleNewSession(selectedEnvironment.id, options)
-          }
+          onNewSession={() => handleNewSession(selectedEnvironment.id)}
           onOpenEnvironmentSettings={(tab, options) =>
             openEnvironmentSettings(selectedEnvironment.id, tab, options)
           }
@@ -1148,14 +1135,9 @@ export function SandpiApp({ initialData }: SandpiAppProps) {
           canManageEnvironment={canManageEnvironment(selectedEnvironment)}
           onEnvironmentChange={handleEnvironmentChange}
           onCreated={handleSessionCreated}
-          initialTitle={newSessionPreset?.title}
-          sessionStartSource={newSessionPreset?.source}
           onOpenAgentHarnessSettings={() =>
             openEnvironmentSettings(selectedEnvironment.id, "credentials")
           }
-          onOpenEnvironmentSettings={(tab, options) =>
-            openEnvironmentSettings(selectedEnvironment.id, tab, options)
-          }
           onToggleSidebar={handleToggleNavigation}
           inspectorOpen={showInspector}
           onToggleInspector={() => handleInspectorOpenChange(!showInspector)}
diff --git a/src/harnesses/codex/agent-threads-dialog.module.css b/src/harnesses/codex/agent-threads-dialog.module.css
deleted file mode 100644
index 4e226ba..0000000
--- a/src/harnesses/codex/agent-threads-dialog.module.css
+++ /dev/null
@@ -1,571 +0,0 @@
-.backdrop {
-  position: fixed;
-  z-index: 95;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 20px;
-  background: rgb(24 24 21 / 38%);
-  backdrop-filter: blur(2px);
-}
-
-.dialog {
-  --agent-dialog-chrome: var(--panel-strong);
-  --agent-dialog-sidebar: var(--sidebar);
-  --agent-dialog-content: var(--panel-strong);
-  --agent-dialog-user-surface: var(--green-soft);
-  --agent-dialog-user-border: color-mix(
-    in srgb,
-    var(--green) 32%,
-    var(--line)
-  );
-
-  display: grid;
-  width: min(1120px, 100%);
-  height: min(760px, calc(100dvh - 40px));
-  grid-template-rows: auto minmax(0, 1fr) auto;
-  overflow: hidden;
-  border: 1px solid var(--line);
-  border-radius: 14px;
-  outline: 0;
-  background: var(--agent-dialog-content);
-  box-shadow: 0 26px 80px rgb(24 24 20 / 26%);
-}
-
-.header {
-  display: flex;
-  min-height: 62px;
-  align-items: center;
-  gap: 11px;
-  padding: 10px 12px 10px 17px;
-  border-bottom: 1px solid var(--line);
-  background: var(--agent-dialog-chrome);
-}
-
-.headerIcon {
-  display: inline-flex;
-  width: 34px;
-  height: 34px;
-  flex: 0 0 auto;
-  align-items: center;
-  justify-content: center;
-  border: 1px solid var(--line);
-  border-radius: 9px;
-  background: var(--sidebar);
-  color: var(--ink-soft);
-}
-
-.headerCopy {
-  display: flex;
-  min-width: 0;
-  flex: 1;
-  flex-direction: column;
-  gap: 3px;
-}
-
-.headerCopy strong {
-  color: var(--ink);
-  font-size: 13px;
-  font-weight: 680;
-}
-
-.headerCopy small {
-  overflow: hidden;
-  color: var(--ink-faint);
-  font-size: 10px;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.header > button {
-  display: inline-flex;
-  width: 32px;
-  height: 32px;
-  align-items: center;
-  justify-content: center;
-  padding: 0;
-  border: 0;
-  border-radius: 7px;
-  background: transparent;
-  color: var(--ink-faint);
-  cursor: pointer;
-}
-
-.header > button:hover {
-  background: var(--hover);
-  color: var(--ink);
-}
-
-.body {
-  display: grid;
-  min-height: 0;
-  grid-template-columns: minmax(230px, 29%) minmax(0, 1fr);
-}
-
-.threadList {
-  min-height: 0;
-  overflow-y: auto;
-  border-right: 1px solid var(--line);
-  background: var(--agent-dialog-sidebar);
-  scrollbar-width: thin;
-}
-
-.listHeading {
-  position: sticky;
-  z-index: 1;
-  top: 0;
-  display: flex;
-  min-height: 39px;
-  align-items: center;
-  justify-content: space-between;
-  padding: 0 13px;
-  border-bottom: 1px solid var(--line-soft);
-  background: var(--agent-dialog-sidebar);
-  color: var(--ink-faint);
-  font-size: 9px;
-  font-weight: 700;
-  letter-spacing: 0.055em;
-  text-transform: uppercase;
-}
-
-.listHeading small {
-  font-size: 9px;
-}
-
-.threadList > button {
-  display: grid;
-  width: calc(100% - 10px);
-  min-height: 57px;
-  grid-template-columns: 12px minmax(0, 1fr) auto;
-  align-items: center;
-  gap: 8px;
-  margin: 5px;
-  padding: 8px 9px;
-  border: 0;
-  border-radius: 8px;
-  background: transparent;
-  color: var(--ink-soft);
-  text-align: left;
-  cursor: pointer;
-}
-
-.threadList > button:hover {
-  background: var(--hover);
-}
-
-.threadList > button.selected {
-  background: var(--selected);
-  color: var(--ink);
-  box-shadow: inset 0 0 0 1px
-    color-mix(in srgb, var(--ink-faint) 12%, transparent);
-}
-
-.status {
-  width: 7px;
-  height: 7px;
-  border-radius: 50%;
-  background: var(--ink-faint);
-}
-
-.status[data-status="active"] {
-  background: var(--green);
-  box-shadow: 0 0 0 3px color-mix(in srgb, var(--green) 14%, transparent);
-}
-
-.status[data-status="idle"] {
-  background: var(--blue);
-}
-
-.status[data-status="systemError"] {
-  background: var(--red);
-}
-
-.threadCopy {
-  display: flex;
-  min-width: 0;
-  flex-direction: column;
-  gap: 4px;
-}
-
-.threadCopy strong,
-.threadCopy small {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.threadCopy strong {
-  color: var(--ink);
-  font-size: 11px;
-  font-weight: 650;
-}
-
-.threadCopy small {
-  color: var(--ink-faint);
-  font-size: 9px;
-}
-
-.threadState {
-  color: var(--ink-faint);
-  font-size: 8px;
-  white-space: nowrap;
-}
-
-.loading,
-.error {
-  display: flex;
-  align-items: center;
-  gap: 7px;
-  margin: 10px;
-  padding: 10px;
-  color: var(--ink-faint);
-  font-size: 10px;
-}
-
-.loading svg,
-.detailLoading svg {
-  animation: spin 0.9s linear infinite;
-}
-
-.error {
-  border: 1px solid color-mix(in srgb, var(--red) 22%, var(--line));
-  border-radius: 7px;
-  background: var(--red-soft);
-  color: var(--red);
-  line-height: 1.45;
-}
-
-.detail {
-  display: grid;
-  min-width: 0;
-  min-height: 0;
-  grid-template-rows: auto minmax(0, 1fr);
-  background: var(--agent-dialog-content);
-}
-
-.detailHeader {
-  display: flex;
-  min-height: 58px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 16px;
-  padding: 9px 18px;
-  border-bottom: 1px solid var(--line-soft);
-  background: var(--agent-dialog-chrome);
-}
-
-.detailHeader > span:first-child {
-  display: flex;
-  min-width: 0;
-  flex-direction: column;
-  gap: 3px;
-}
-
-.detailHeader strong,
-.detailHeader small {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.detailHeader strong {
-  color: var(--ink);
-  font-size: 12px;
-  font-weight: 670;
-}
-
-.detailHeader small {
-  color: var(--ink-faint);
-  font-size: 9px;
-}
-
-.detailMeta {
-  display: flex;
-  flex: 0 0 auto;
-  align-items: center;
-  gap: 8px;
-  color: var(--ink-faint);
-  font-size: 8px;
-}
-
-.detailMeta b {
-  padding: 3px 7px;
-  border-radius: 999px;
-  background: var(--sidebar);
-  color: var(--ink-soft);
-  font-weight: 650;
-}
-
-.detailMeta b[data-status="active"] {
-  background: var(--green-soft);
-  color: var(--green);
-}
-
-.detailMeta b[data-status="systemError"] {
-  background: var(--red-soft);
-  color: var(--red);
-}
-
-.detailScroll {
-  min-height: 0;
-  overflow-y: auto;
-  scrollbar-width: thin;
-}
-
-.detailLoading,
-.detailError,
-.emptyTranscript {
-  display: flex;
-  min-height: 220px;
-  align-items: center;
-  justify-content: center;
-  flex-direction: column;
-  gap: 8px;
-  padding: 24px;
-  color: var(--ink-faint);
-  text-align: center;
-}
-
-.detailLoading {
-  flex-direction: row;
-  font-size: 10px;
-}
-
-.detailError strong,
-.emptyTranscript strong {
-  color: var(--ink-soft);
-  font-size: 11px;
-}
-
-.detailError p,
-.emptyTranscript p {
-  max-width: 460px;
-  margin: 0;
-  font-size: 9.5px;
-  line-height: 1.55;
-}
-
-.detailError {
-  color: var(--red);
-}
-
-.transcript {
-  width: min(100%, 760px);
-  margin: 0 auto;
-  padding: 30px 24px 80px;
-}
-
-.transcriptMessage {
-  display: flex;
-  width: min(100%, 650px);
-  flex-direction: column;
-  gap: 7px;
-  margin: 0 0 25px;
-}
-
-.transcriptMessage[data-role="user"] {
-  width: fit-content;
-  max-width: min(100%, 580px);
-  margin-left: auto;
-}
-
-.transcriptAuthor {
-  color: var(--ink-faint);
-  font-size: 9px;
-  font-weight: 650;
-}
-
-.transcriptMessage[data-role="user"] .transcriptAuthor {
-  text-align: right;
-}
-
-.transcriptMessage[data-role="user"] :global(.markdown-content) {
-  padding: 10px 12px;
-  border: 1px solid var(--agent-dialog-user-border);
-  border-radius: 10px 10px 3px 10px;
-  background: var(--agent-dialog-user-surface);
-  color: var(--ink);
-}
-
-.transcript :global(.message) {
-  margin-bottom: 23px;
-}
-
-.transcript :global(.message-codex-activity),
-.transcript :global(.message-codex-turn-activity) {
-  grid-template-columns: 0 minmax(0, 1fr) 0;
-}
-
-.attachments {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
-  gap: 7px;
-}
-
-.attachments img {
-  width: 100%;
-  height: auto;
-  max-height: 260px;
-  border: 1px solid var(--line);
-  border-radius: 8px;
-  object-fit: cover;
-}
-
-.attachmentNote {
-  color: var(--ink-faint);
-  font-size: 9px;
-}
-
-.streaming {
-  display: inline-flex;
-  gap: 4px;
-}
-
-.streaming i {
-  width: 5px;
-  height: 5px;
-  border-radius: 50%;
-  background: var(--ink-faint);
-  animation: pulse 1s ease-in-out infinite;
-}
-
-.streaming i:nth-child(2) {
-  animation-delay: 120ms;
-}
-
-.streaming i:nth-child(3) {
-  animation-delay: 240ms;
-}
-
-.footer {
-  display: flex;
-  min-height: 38px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 7px 14px;
-  border-top: 1px solid var(--line);
-  background: var(--agent-dialog-sidebar);
-  color: var(--ink-faint);
-  font-size: 8.5px;
-}
-
-.footer code {
-  color: var(--ink-soft);
-  font-size: 8.5px;
-}
-
-:global(html[data-resolved-theme="dark"]) .backdrop {
-  background: rgb(0 0 0 / 58%);
-  backdrop-filter: blur(4px) saturate(0.72);
-}
-
-:global(html[data-resolved-theme="dark"]) .dialog {
-  --agent-dialog-chrome: color-mix(
-    in srgb,
-    var(--panel-strong) 88%,
-    var(--canvas)
-  );
-  --agent-dialog-sidebar: color-mix(
-    in srgb,
-    var(--sidebar) 86%,
-    var(--canvas)
-  );
-  --agent-dialog-content: color-mix(
-    in srgb,
-    var(--panel-strong) 94%,
-    var(--canvas)
-  );
-
-  border-color: color-mix(in srgb, var(--ink-faint) 28%, var(--line));
-  box-shadow:
-    0 30px 96px rgb(0 0 0 / 58%),
-    inset 0 1px 0 rgb(255 255 255 / 3%);
-}
-
-:global(html[data-resolved-theme="dark"]) .headerIcon {
-  border-color: color-mix(in srgb, var(--ink-faint) 22%, var(--line));
-  background: color-mix(
-    in srgb,
-    var(--agent-dialog-sidebar) 76%,
-    var(--panel-strong)
-  );
-  color: var(--ink-soft);
-}
-
-:global(html[data-resolved-theme="dark"]) .header > button:hover {
-  background: color-mix(in srgb, var(--hover) 82%, var(--panel-strong));
-}
-
-:global(html[data-resolved-theme="dark"]) .threadList > button.selected {
-  background: color-mix(in srgb, var(--selected) 88%, var(--blue-soft));
-  box-shadow: inset 0 0 0 1px
-    color-mix(in srgb, var(--blue) 18%, var(--line));
-}
-
-:global(html[data-resolved-theme="dark"]) .detailMeta b {
-  border: 1px solid color-mix(in srgb, var(--ink-faint) 16%, var(--line-soft));
-}
-
-:global(html[data-resolved-theme="dark"])
-  .transcriptMessage[data-role="user"]
-  :global(.markdown-content) {
-  box-shadow: inset 0 1px 0 rgb(255 255 255 / 4%);
-}
-
-@keyframes spin {
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-@keyframes pulse {
-  0%,
-  100% {
-    opacity: 0.35;
-  }
-
-  50% {
-    opacity: 1;
-  }
-}
-
-@media (max-width: 760px) {
-  .backdrop {
-    align-items: stretch;
-    padding: 0;
-  }
-
-  .dialog {
-    height: 100dvh;
-    border: 0;
-    border-radius: 0;
-  }
-
-  .body {
-    grid-template-columns: 1fr;
-    grid-template-rows: minmax(150px, 32%) minmax(0, 1fr);
-  }
-
-  .threadList {
-    border-right: 0;
-    border-bottom: 1px solid var(--line);
-  }
-
-  .detailHeader {
-    padding-inline: 13px;
-  }
-
-  .detailMeta time {
-    display: none;
-  }
-
-  .transcript {
-    padding: 22px 14px 60px;
-  }
-
-  .footer > span:last-child {
-    display: none;
-  }
-}
diff --git a/src/harnesses/codex/agent-threads-dialog.tsx b/src/harnesses/codex/agent-threads-dialog.tsx
deleted file mode 100644
index 3b4cb91..0000000
--- a/src/harnesses/codex/agent-threads-dialog.tsx
+++ /dev/null
@@ -1,678 +0,0 @@
-"use client";
-
-import Image from "next/image";
-import {
-  Bot,
-  LoaderCircle,
-  RefreshCw,
-  UsersRound,
-  X,
-} from "lucide-react";
-import {
-  Fragment,
-  useEffect,
-  useId,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-
-import { MarkdownContent } from "@/components/markdown-content";
-import {
-  CodexCommandActivity,
-  CodexFileChangeActivity,
-  CodexNativeItemActivity,
-  CodexNativeToolActivity,
-  CodexTurnActivity,
-  CodexTurnResult,
-} from "@/harnesses/codex/activity";
-import {
-  codexAgentThreadName,
-  codexAgentThreadRows,
-} from "@/harnesses/codex/agent-threads";
-import {
-  projectCodexTimeline,
-  type CodexTimelineEntry,
-} from "@/harnesses/codex/events";
-import {
-  groupCodexTimelineByTurn,
-  type CodexTurnTimelineGroup,
-} from "@/harnesses/codex/timeline";
-import type {
-  CodexAgentThreads,
-  CodexThread,
-} from "@/harnesses/codex/types";
-import { formatUnixTimestamp } from "@/lib/time";
-import {
-  apiFetch,
-  type ApiEnvelope,
-} from "@/lib/api-client";
-import type { OperationLanguage } from "@/lib/operation-ui";
-
-import styles from "./agent-threads-dialog.module.css";
-
-interface CodexAgentThreadsDialogProps {
-  language: OperationLanguage;
-  timeZone: string;
-  sessionId: string;
-  sessionTitle: string;
-  harnessLabel: string;
-  selectedThreadId?: string;
-  onSelectedThreadChange: (threadId?: string) => void;
-  onOpenWorkspacePath: (path: string) => void;
-  onOpenFiles: (path?: string) => void;
-  onClose: () => void;
-}
-
-function threadStatusLabel(
-  thread: CodexThread,
-  language: OperationLanguage,
-) {
-  if (thread.status.type === "active") {
-    if (thread.status.activeFlags.includes("waitingOnApproval")) {
-      return language === "zh-CN" ? "等待审批" : "Waiting for approval";
-    }
-    if (thread.status.activeFlags.includes("waitingOnUserInput")) {
-      return language === "zh-CN" ? "等待输入" : "Waiting for input";
-    }
-    return language === "zh-CN" ? "运行中" : "Running";
-  }
-  if (thread.status.type === "idle") {
-    return language === "zh-CN" ? "空闲" : "Idle";
-  }
-  if (thread.status.type === "systemError") {
-    return language === "zh-CN" ? "错误" : "Error";
-  }
-  return language === "zh-CN" ? "已停止" : "Stopped";
-}
-
-function threadUpdatedAt(
-  thread: CodexThread,
-  language: OperationLanguage,
-  timeZone: string,
-) {
-  if (thread.updatedAt === undefined) return "";
-  return formatUnixTimestamp(
-    thread.updatedAt,
-    language === "zh-CN" ? "zh-CN" : "en",
-    timeZone,
-    {
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-    },
-  );
-}
-
-function AgentThreadTranscript({
-  thread,
-  agentName,
-  root,
-  harnessLabel,
-  language,
-  onOpenWorkspacePath,
-  onOpenFiles,
-}: {
-  thread: CodexThread;
-  agentName: string;
-  root: boolean;
-  harnessLabel: string;
-  language: OperationLanguage;
-  onOpenWorkspacePath: (path: string) => void;
-  onOpenFiles: (path?: string) => void;
-}) {
-  const projection = useMemo(() => projectCodexTimeline(thread), [thread]);
-  const turns = useMemo(
-    () => groupCodexTimelineByTurn(projection),
-    [projection],
-  );
-  const now = Date.now();
-
-  function renderActivity(entry: CodexTimelineEntry) {
-    if (entry.kind === "command") {
-      return (
-        <CodexCommandActivity
-          key={entry.id}
-          activity={entry}
-          language={language}
-          compact
-        />
-      );
-    }
-    if (entry.kind === "fileChange") {
-      return (
-        <CodexFileChangeActivity
-          key={entry.id}
-          activity={entry}
-          language={language}
-          onOpenFiles={onOpenFiles}
-          compact
-        />
-      );
-    }
-    if (entry.kind === "nativeItem") {
-      return (
-        <CodexNativeItemActivity
-          key={entry.id}
-          activity={entry}
-          language={language}
-          compact
-        />
-      );
-    }
-    if (
-      entry.kind === "mcpToolCall" ||
-      entry.kind === "dynamicToolCall" ||
-      entry.kind === "webSearch" ||
-      entry.kind === "collabAgentToolCall" ||
-      entry.kind === "subAgentActivity" ||
-      entry.kind === "imageGeneration"
-    ) {
-      return (
-        <CodexNativeToolActivity
-          key={entry.id}
-          activity={entry}
-          language={language}
-          compact
-        />
-      );
-    }
-    if (entry.kind === "turnResult") {
-      return (
-        <CodexTurnResult key={entry.id} result={entry} language={language} />
-      );
-    }
-
-    return (
-      <article
-        className={styles.transcriptMessage}
-        data-role={entry.role}
-        key={entry.id}
-      >
-        <span className={styles.transcriptAuthor}>
-          {entry.role === "assistant"
-            ? agentName || harnessLabel
-            : root
-              ? language === "zh-CN"
-                ? "你"
-                : "You"
-              : language === "zh-CN"
-                ? "父 Agent"
-                : "Parent agent"}
-        </span>
-        {entry.attachments?.length ? (
-          <div className={styles.attachments}>
-            {entry.attachments.map((attachment) => (
-              <Image
-                key={attachment.id}
-                src={attachment.previewUrl}
-                alt={attachment.name}
-                width={420}
-                height={280}
-                sizes="(max-width: 760px) 78vw, 420px"
-                unoptimized
-              />
-            ))}
-          </div>
-        ) : null}
-        {entry.localImages?.length ? (
-          <small className={styles.attachmentNote}>
-            {language === "zh-CN"
-              ? `${entry.localImages.length} 个工作区图片引用`
-              : `${entry.localImages.length} Workspace image reference${
-                  entry.localImages.length === 1 ? "" : "s"
-                }`}
-          </small>
-        ) : null}
-        {entry.content ? (
-          <MarkdownContent
-            content={entry.content}
-            onOpenWorkspacePath={onOpenWorkspacePath}
-          />
-        ) : entry.streaming ? (
-          <span className={styles.streaming}>
-            <i />
-            <i />
-            <i />
-          </span>
-        ) : null}
-      </article>
-    );
-  }
-
-  function renderTurn(turn: CodexTurnTimelineGroup) {
-    const lastActivityIndex = turn.blocks.findLastIndex(
-      (block) => block.kind === "activity",
-    );
-    return (
-      <Fragment key={turn.turnId}>
-        {turn.blocks.map((block, index) => {
-          if (block.kind === "message" || block.kind === "result") {
-            return renderActivity(block.entry);
-          }
-          const activeTurn =
-            block.id === turn.activeActivityBlockId
-              ? projection.activeTurn
-              : undefined;
-          if (block.entries.length === 0 && !activeTurn) return null;
-          return (
-            <CodexTurnActivity
-              key={block.id}
-              activeTurn={activeTurn}
-              turn={index === lastActivityIndex ? turn.turn : undefined}
-              language={language}
-              now={now}
-            >
-              {block.entries.map(renderActivity)}
-            </CodexTurnActivity>
-          );
-        })}
-      </Fragment>
-    );
-  }
-
-  if (turns.length === 0) {
-    return (
-      <div className={styles.emptyTranscript}>
-        <Bot size={22} aria-hidden="true" />
-        <strong>
-          {language === "zh-CN"
-            ? "这个 Agent Thread 暂无可回放内容"
-            : "No replayable content in this Agent Thread"}
-        </strong>
-        <p>
-          {language === "zh-CN"
-            ? "它可能刚创建、仍未写入首个 Turn，或只提供元数据。"
-            : "It may be newly created, before its first Turn, or metadata-only."}
-        </p>
-      </div>
-    );
-  }
-
-  return <div className={styles.transcript}>{turns.map(renderTurn)}</div>;
-}
-
-export function CodexAgentThreadsDialog({
-  language,
-  timeZone,
-  sessionId,
-  sessionTitle,
-  harnessLabel,
-  selectedThreadId,
-  onSelectedThreadChange,
-  onOpenWorkspacePath,
-  onOpenFiles,
-  onClose,
-}: CodexAgentThreadsDialogProps) {
-  const titleId = useId();
-  const dialogRef = useRef<HTMLElement>(null);
-  const [tree, setTree] = useState<CodexAgentThreads>();
-  const [activeThreadId, setActiveThreadId] = useState(
-    selectedThreadId ?? "",
-  );
-  const [thread, setThread] = useState<CodexThread>();
-  const [listLoading, setListLoading] = useState(true);
-  const [threadLoading, setThreadLoading] = useState(false);
-  const [listError, setListError] = useState("");
-  const [threadError, setThreadError] = useState("");
-  const [refreshSequence, setRefreshSequence] = useState(0);
-  const rows = useMemo(
-    () => (tree ? codexAgentThreadRows(tree) : []),
-    [tree],
-  );
-  const activeRow = rows.find((row) => row.thread.id === activeThreadId);
-  const activeName = activeRow
-    ? activeRow.root
-      ? sessionTitle
-      : codexAgentThreadName(activeRow.thread)
-    : "";
-
-  useEffect(() => {
-    const previouslyFocused = document.activeElement as HTMLElement | null;
-    const previousOverflow = document.body.style.overflow;
-    document.body.style.overflow = "hidden";
-    const frame = window.requestAnimationFrame(() => dialogRef.current?.focus());
-    return () => {
-      window.cancelAnimationFrame(frame);
-      document.body.style.overflow = previousOverflow;
-      previouslyFocused?.focus();
-    };
-  }, []);
-
-  useEffect(() => {
-    setTree(undefined);
-    setThread(undefined);
-    setActiveThreadId("");
-    setListError("");
-    setThreadError("");
-  }, [sessionId]);
-
-  useEffect(() => {
-    if (selectedThreadId) setActiveThreadId(selectedThreadId);
-  }, [selectedThreadId]);
-
-  useEffect(() => {
-    let disposed = false;
-    let controller: AbortController | undefined;
-    const load = async (initial: boolean) => {
-      controller?.abort();
-      const requestController = new AbortController();
-      controller = requestController;
-      if (initial) setListLoading(true);
-      try {
-        const response = await apiFetch<ApiEnvelope<CodexAgentThreads>>(
-          `/api/v1/sessions/${encodeURIComponent(sessionId)}/agents`,
-          { signal: requestController.signal },
-        );
-        if (disposed) return;
-        setTree(response.data);
-        setListError("");
-        setActiveThreadId((current) => {
-          const available = new Set([
-            response.data.root.id,
-            ...response.data.descendants.map((candidate) => candidate.id),
-          ]);
-          if (current && available.has(current)) return current;
-          if (current) onSelectedThreadChange(undefined);
-          return response.data.root.id;
-        });
-      } catch (cause) {
-        if (!disposed && !requestController.signal.aborted) {
-          setListError(
-            cause instanceof Error
-              ? cause.message
-              : language === "zh-CN"
-                ? "无法读取 Agent Threads。"
-                : "Could not load Agent Threads.",
-          );
-        }
-      } finally {
-        if (!disposed && initial) setListLoading(false);
-      }
-    };
-    void load(true);
-    const timer = window.setInterval(() => void load(false), 3_000);
-    return () => {
-      disposed = true;
-      controller?.abort();
-      window.clearInterval(timer);
-    };
-  }, [language, onSelectedThreadChange, refreshSequence, sessionId]);
-
-  useEffect(() => {
-    if (!activeThreadId) return;
-    let disposed = false;
-    let controller: AbortController | undefined;
-    const load = async (background: boolean) => {
-      controller?.abort();
-      const requestController = new AbortController();
-      controller = requestController;
-      if (!background) setThreadLoading(true);
-      try {
-        const response = await apiFetch<ApiEnvelope<CodexThread>>(
-          `/api/v1/sessions/${encodeURIComponent(sessionId)}/agents/${encodeURIComponent(activeThreadId)}`,
-          { signal: requestController.signal },
-        );
-        if (disposed) return;
-        setThread(response.data);
-        setThreadError("");
-      } catch (cause) {
-        if (!disposed && !requestController.signal.aborted) {
-          setThreadError(
-            cause instanceof Error
-              ? cause.message
-              : language === "zh-CN"
-                ? "无法读取 Agent Thread。"
-                : "Could not load the Agent Thread.",
-          );
-        }
-      } finally {
-        if (!disposed && !background) setThreadLoading(false);
-      }
-    };
-    setThread(undefined);
-    setThreadError("");
-    void load(false);
-    const shouldPoll =
-      activeThreadId !== tree?.root.id &&
-      activeRow?.thread.status.type === "active";
-    const timer = shouldPoll
-      ? window.setInterval(() => void load(true), 3_000)
-      : undefined;
-    return () => {
-      disposed = true;
-      controller?.abort();
-      if (timer !== undefined) window.clearInterval(timer);
-    };
-  }, [
-    activeRow?.thread.status.type,
-    activeThreadId,
-    language,
-    refreshSequence,
-    sessionId,
-    tree?.root.id,
-  ]);
-
-  return (
-    <div
-      className={styles.backdrop}
-      role="presentation"
-      onMouseDown={(event) => {
-        if (event.target === event.currentTarget) onClose();
-      }}
-    >
-      <section
-        ref={dialogRef}
-        className={styles.dialog}
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={titleId}
-        tabIndex={-1}
-        onKeyDown={(event) => {
-          if (event.key === "Tab") {
-            const focusable = Array.from(
-              dialogRef.current?.querySelectorAll<HTMLElement>(
-                'button:not([disabled]), [href], [tabindex]:not([tabindex="-1"])',
-              ) ?? [],
-            );
-            const first = focusable[0];
-            const last = focusable[focusable.length - 1];
-            if (event.shiftKey && document.activeElement === first) {
-              event.preventDefault();
-              last?.focus();
-            } else if (!event.shiftKey && document.activeElement === last) {
-              event.preventDefault();
-              first?.focus();
-            }
-          } else if (event.key === "Escape") {
-            event.preventDefault();
-            onClose();
-          }
-        }}
-      >
-        <header className={styles.header}>
-          <span className={styles.headerIcon}>
-            <UsersRound size={18} aria-hidden="true" />
-          </span>
-          <span className={styles.headerCopy}>
-            <strong id={titleId}>Agent Threads</strong>
-            <small>
-              {language === "zh-CN"
-                ? "Codex 原生线程树与各子 Agent 对话"
-                : "Native Codex thread tree and sub-agent conversations"}
-            </small>
-          </span>
-          <button
-            type="button"
-            aria-label={language === "zh-CN" ? "刷新" : "Refresh"}
-            title={language === "zh-CN" ? "刷新" : "Refresh"}
-            onClick={() => setRefreshSequence((value) => value + 1)}
-          >
-            <RefreshCw size={16} aria-hidden="true" />
-          </button>
-          <button
-            type="button"
-            aria-label={
-              language === "zh-CN" ? "关闭 Agent Threads" : "Close Agent Threads"
-            }
-            onClick={onClose}
-          >
-            <X size={17} aria-hidden="true" />
-          </button>
-        </header>
-
-        <div className={styles.body}>
-          <nav
-            className={styles.threadList}
-            aria-label={
-              language === "zh-CN"
-                ? "Codex Agent Threads"
-                : "Codex Agent Threads"
-            }
-          >
-            <div className={styles.listHeading}>
-              <span>{language === "zh-CN" ? "线程" : "Threads"}</span>
-              <small>{rows.length}</small>
-            </div>
-            {listLoading && rows.length === 0 ? (
-              <div className={styles.loading}>
-                <LoaderCircle size={17} aria-hidden="true" />
-                {language === "zh-CN" ? "读取中…" : "Loading…"}
-              </div>
-            ) : null}
-            {listError ? (
-              <div className={styles.error} role="alert">
-                {listError}
-              </div>
-            ) : null}
-            {rows.map((row) => {
-              const name = row.root
-                ? sessionTitle
-                : codexAgentThreadName(row.thread);
-              return (
-                <button
-                  type="button"
-                  className={
-                    activeThreadId === row.thread.id ? styles.selected : undefined
-                  }
-                  aria-current={
-                    activeThreadId === row.thread.id ? "true" : undefined
-                  }
-                  style={{
-                    paddingLeft: `${10 + Math.min(row.depth, 5) * 13}px`,
-                  }}
-                  key={row.thread.id}
-                  onClick={() => {
-                    setActiveThreadId(row.thread.id);
-                    onSelectedThreadChange(row.root ? undefined : row.thread.id);
-                  }}
-                >
-                  <span
-                    className={styles.status}
-                    data-status={row.thread.status.type}
-                    aria-hidden="true"
-                  />
-                  <span className={styles.threadCopy}>
-                    <strong>{name}</strong>
-                    <small>
-                      {row.root
-                        ? language === "zh-CN"
-                          ? "主线程"
-                          : "Main thread"
-                        : row.thread.agentRole ||
-                          (language === "zh-CN" ? "子 Agent" : "Sub-agent")}
-                    </small>
-                  </span>
-                  <span className={styles.threadState}>
-                    {threadStatusLabel(row.thread, language)}
-                  </span>
-                </button>
-              );
-            })}
-          </nav>
-
-          <section
-            className={styles.detail}
-            aria-label={
-              language === "zh-CN"
-                ? "Agent Thread 详情"
-                : "Agent Thread details"
-            }
-          >
-            {activeRow ? (
-              <header className={styles.detailHeader}>
-                <span>
-                  <strong>{activeName}</strong>
-                  <small>
-                    {activeRow.thread.agentRole
-                      ? activeRow.thread.agentRole
-                      : activeRow.root
-                        ? language === "zh-CN"
-                          ? "当前 Sandpi Session"
-                          : "Current Sandpi Session"
-                        : language === "zh-CN"
-                          ? "Codex 子 Agent"
-                          : "Codex sub-agent"}
-                  </small>
-                </span>
-                <span className={styles.detailMeta}>
-                  <b data-status={activeRow.thread.status.type}>
-                    {threadStatusLabel(activeRow.thread, language)}
-                  </b>
-                  {threadUpdatedAt(activeRow.thread, language, timeZone) ? (
-                    <time>
-                      {threadUpdatedAt(activeRow.thread, language, timeZone)}
-                    </time>
-                  ) : null}
-                </span>
-              </header>
-            ) : null}
-            <div className={styles.detailScroll}>
-              {threadLoading ? (
-                <div className={styles.detailLoading} role="status">
-                  <LoaderCircle size={19} aria-hidden="true" />
-                  {language === "zh-CN"
-                    ? "读取原生 Agent Thread…"
-                    : "Loading native Agent Thread…"}
-                </div>
-              ) : null}
-              {threadError ? (
-                <div className={styles.detailError} role="alert">
-                  <strong>
-                    {language === "zh-CN"
-                      ? "无法打开 Agent Thread"
-                      : "Could not open Agent Thread"}
-                  </strong>
-                  <p>{threadError}</p>
-                </div>
-              ) : null}
-              {thread && !threadLoading ? (
-                <AgentThreadTranscript
-                  thread={thread}
-                  agentName={activeRow?.root ? harnessLabel : activeName}
-                  root={activeRow?.root ?? false}
-                  harnessLabel={harnessLabel}
-                  language={language}
-                  onOpenWorkspacePath={onOpenWorkspacePath}
-                  onOpenFiles={onOpenFiles}
-                />
-              ) : null}
-            </div>
-          </section>
-        </div>
-
-        <footer className={styles.footer}>
-          <span>
-            <code>/agent</code>
-          </span>
-          <span>
-            {language === "zh-CN"
-              ? "Activity 仍用于查看父线程的审计记录"
-              : "Activity remains the parent-thread audit trail"}
-          </span>
-        </footer>
-      </section>
-    </div>
-  );
-}
diff --git a/src/harnesses/codex/agent-threads.test.ts b/src/harnesses/codex/agent-threads.test.ts
deleted file mode 100644
index 7aede95..0000000
--- a/src/harnesses/codex/agent-threads.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  codexAgentThreadName,
-  codexAgentThreadRows,
-} from "./agent-threads";
-import type { CodexAgentThreads, CodexThread } from "./types";
-
-function thread(
-  id: string,
-  parentThreadId?: string,
-  createdAt = 1,
-): CodexThread {
-  return {
-    id,
-    parentThreadId,
-    createdAt,
-    status: { type: "notLoaded" },
-    turns: [],
-  };
-}
-
-test("orders native Agent Threads by their parent relation", () => {
-  const tree: CodexAgentThreads = {
-    root: thread("root"),
-    descendants: [
-      thread("grandchild", "child-a", 3),
-      thread("child-b", "root", 2),
-      thread("child-a", "root", 1),
-    ],
-  };
-
-  assert.deepEqual(
-    codexAgentThreadRows(tree).map(({ thread: value, depth, root }) => ({
-      id: value.id,
-      depth,
-      root,
-    })),
-    [
-      { id: "root", depth: 0, root: true },
-      { id: "child-a", depth: 1, root: false },
-      { id: "grandchild", depth: 2, root: false },
-      { id: "child-b", depth: 1, root: false },
-    ],
-  );
-});
-
-test("uses native nickname, role, preview and id fallbacks for Agent names", () => {
-  assert.equal(
-    codexAgentThreadName({
-      ...thread("one"),
-      agentNickname: "Scout",
-      agentRole: "explorer",
-    }),
-    "Scout",
-  );
-  assert.equal(
-    codexAgentThreadName({ ...thread("two"), agentRole: "reviewer" }),
-    "reviewer",
-  );
-  assert.equal(
-    codexAgentThreadName({ ...thread("three"), preview: "Inspect auth\nlater" }),
-    "Inspect auth",
-  );
-  assert.equal(codexAgentThreadName(thread("thread-12345678")), "Agent 12345678");
-});
diff --git a/src/harnesses/codex/agent-threads.ts b/src/harnesses/codex/agent-threads.ts
deleted file mode 100644
index e696572..0000000
--- a/src/harnesses/codex/agent-threads.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import type { CodexAgentThreads, CodexThread } from "./types";
-
-export interface CodexAgentThreadRow {
-  thread: CodexThread;
-  depth: number;
-  root: boolean;
-}
-
-function compareThreads(left: CodexThread, right: CodexThread) {
-  const createdDifference = (left.createdAt ?? 0) - (right.createdAt ?? 0);
-  return createdDifference || left.id.localeCompare(right.id);
-}
-
-/** Flatten the native parent graph into a stable tree suitable for a picker. */
-export function codexAgentThreadRows(
-  tree: CodexAgentThreads,
-): CodexAgentThreadRow[] {
-  const children = new Map<string, CodexThread[]>();
-  for (const thread of tree.descendants) {
-    const parentId = thread.parentThreadId ?? tree.root.id;
-    const siblings = children.get(parentId) ?? [];
-    siblings.push(thread);
-    children.set(parentId, siblings);
-  }
-  for (const siblings of children.values()) {
-    siblings.sort(compareThreads);
-  }
-
-  const rows: CodexAgentThreadRow[] = [
-    { thread: tree.root, depth: 0, root: true },
-  ];
-  const visited = new Set([tree.root.id]);
-  const appendChildren = (parentId: string, depth: number) => {
-    for (const thread of children.get(parentId) ?? []) {
-      if (visited.has(thread.id)) continue;
-      visited.add(thread.id);
-      rows.push({ thread, depth, root: false });
-      appendChildren(thread.id, depth + 1);
-    }
-  };
-  appendChildren(tree.root.id, 1);
-
-  // The server validates ancestry. Keep malformed mocked or older responses
-  // visible instead of silently losing them in the browser.
-  for (const thread of [...tree.descendants].sort(compareThreads)) {
-    if (!visited.has(thread.id)) {
-      rows.push({ thread, depth: 1, root: false });
-    }
-  }
-  return rows;
-}
-
-export function codexAgentThreadName(thread: CodexThread, root = false) {
-  if (root) return thread.name?.trim() || "Main";
-  return (
-    thread.agentNickname?.trim() ||
-    thread.name?.trim() ||
-    thread.agentRole?.trim() ||
-    thread.preview?.trim().split("\n", 1)[0]?.slice(0, 72) ||
-    `Agent ${thread.id.slice(-8)}`
-  );
-}
diff --git a/src/harnesses/codex/composer.tsx b/src/harnesses/codex/composer.tsx
index 364bf5a..9fb2dc5 100644
--- a/src/harnesses/codex/composer.tsx
+++ b/src/harnesses/codex/composer.tsx
@@ -70,7 +70,6 @@ interface CodexComposerToolbarProps {
   fastEnabled: boolean;
   fastDisabled: boolean;
   onFastEnabledChange: (enabled: boolean) => void;
-  mentionOpenRequest?: number;
   contextUsedPercent?: number | null;
   status: CodexComposerStatus;
   action: ReactNode;
@@ -86,7 +85,6 @@ interface CodexComposerProps {
   > & {
     value: string;
   };
-  slashCommandMenu: ReactNode;
   images: readonly CodexComposerImage[];
   onRemoveImage: (id: string) => void;
   localImages: CodexComposerLocalImage[];
@@ -96,12 +94,6 @@ interface CodexComposerProps {
     tone: "info" | "error";
     message: string;
   } | null;
-  mode?: {
-    label: string;
-    description: string;
-    exitLabel: string;
-    onExit: () => void;
-  } | null;
   toolbar: Omit<CodexComposerToolbarProps, "language" | "localImages">;
 }
 
@@ -410,14 +402,12 @@ export function CodexComposer({
   language,
   inputRef,
   inputProps,
-  slashCommandMenu,
   images,
   onRemoveImage,
   localImages,
   onRemoveLocalImage,
   attachmentError,
   notice,
-  mode,
   toolbar,
 }: CodexComposerProps) {
   const copy = composerCopy[language];
@@ -428,7 +418,6 @@ export function CodexComposer({
 
   return (
     <div className={`composer-shell${className ? ` ${className}` : ""}`}>
-      {slashCommandMenu}
       {images.length > 0 ? (
         <div className="composer-image-previews" aria-label={copy.attachedImages}>
           {images.map((image) => (
@@ -466,22 +455,6 @@ export function CodexComposer({
           <span>{notice.message}</span>
         </div>
       ) : null}
-      {mode ? (
-        <div className="codex-composer-mode" role="status">
-          <span>
-            <strong>{mode.label}</strong>
-            {" · "}
-            {mode.description}
-          </span>
-          <button
-            type="button"
-            aria-label={mode.exitLabel}
-            onClick={mode.onExit}
-          >
-            <X size={12} aria-hidden="true" />
-          </button>
-        </div>
-      ) : null}
       <CodexComposerLocalImages
         language={language}
         localImages={localImages}
@@ -523,7 +496,6 @@ function CodexComposerToolbar({
   fastEnabled,
   fastDisabled,
   onFastEnabledChange,
-  mentionOpenRequest,
   contextUsedPercent,
   status,
   action,
@@ -551,15 +523,6 @@ function CodexComposerToolbar({
     setMentionState("idle");
   }, [environmentId]);
 
-  useEffect(() => {
-    if (!mentionOpenRequest) return;
-    setMentionOpen(true);
-    setMentionQuery("");
-    setMentionResults([]);
-    setMentionState("idle");
-    onAttachmentError("");
-  }, [mentionOpenRequest, onAttachmentError]);
-
   useEffect(() => {
     if (!mentionOpen) return;
     const frame = window.requestAnimationFrame(() =>
diff --git a/src/harnesses/codex/conversation.tsx b/src/harnesses/codex/conversation.tsx
index 8aedcf6..17f9ede 100644
--- a/src/harnesses/codex/conversation.tsx
+++ b/src/harnesses/codex/conversation.tsx
@@ -48,15 +48,6 @@ import {
   encodeCodexComposerLocalImages,
 } from "@/harnesses/codex/composer";
 import { insertCodexFileMentions } from "@/harnesses/codex/file-mentions";
-import {
-  CodexSlashCommandMenu,
-  useCodexSlashCommandMenu,
-} from "@/harnesses/codex/slash-command-menu";
-import {
-  CODEX_INIT_COMMAND_PROMPT,
-  parseCodexSlashInvocation,
-  type CodexSlashCommand,
-} from "@/harnesses/codex/slash-commands";
 import {
   codexModelOptionsFromNativeResult,
   codexReasoningEffortForModel,
@@ -87,12 +78,6 @@ import {
   CodexTurnResult,
 } from "@/harnesses/codex/activity";
 import { CodexSessionActivityView } from "@/harnesses/codex/session-activity-view";
-import { CodexAgentThreadsDialog } from "@/harnesses/codex/agent-threads-dialog";
-import {
-  CodexNativeCommandDialog,
-  type CodexNativeDialogMode,
-} from "@/harnesses/codex/native-command-dialog";
-import { parseCodexTokenUsageView } from "@/harnesses/codex/token-usage";
 import {
   codexContextUsedPercent,
   normalizeCodexThreadTokenUsage,
@@ -165,10 +150,7 @@ interface ConversationProps {
   onInspectorTabChange: (tab: InspectorTab) => void;
   onInspectorWidthRatioChange: (ratio: number, persist: boolean) => void;
   onToggleTerminal: () => void;
-  onNewSession: (options?: {
-    title?: string;
-    source?: "startup" | "clear";
-  }) => void;
+  onNewSession: () => void;
   onOpenEnvironmentSettings: (
     tab: EnvironmentSettingsTab,
     options?: EnvironmentSettingsOpenOptions,
@@ -223,23 +205,6 @@ interface PendingCodexSteer {
   phase: "submitting" | "accepted";
 }
 
-interface SubmitCodexMessageOptions {
-  content?: string;
-  collaborationMode?: "plan";
-  bypassSlash?: boolean;
-  restoreDraft?: string;
-}
-
-interface CodexGoalProjection {
-  goal: {
-    objective: string;
-    status: string;
-    tokenBudget: number | null;
-    tokensUsed: number;
-    timeUsedSeconds: number;
-  } | null;
-}
-
 export function CodexConversation({
   language,
   timeZone,
@@ -339,7 +304,6 @@ export function CodexConversation({
     id: selectedModelId || session.harnessState.modelId || "default",
     displayName: selectedModelId || session.harnessState.modelId || "Default",
     isDefault: false,
-    supportsPersonality: false,
     defaultReasoningEffort: fallbackReasoningEffort,
     supportedReasoningEfforts: fallbackReasoningEffort
       ? [
@@ -363,9 +327,7 @@ export function CodexConversation({
     tone: "info" | "error";
     message: string;
   } | null>(null);
-  const [planMode, setPlanMode] = useState(false);
   const [fastMode, setFastMode] = useState(false);
-  const [mentionOpenRequest, setMentionOpenRequest] = useState(0);
   const [sending, setSending] = useState(false);
   const [interrupting, setInterrupting] = useState(false);
   const [openingAgentsFile, setOpeningAgentsFile] = useState(false);
@@ -386,15 +348,6 @@ export function CodexConversation({
   const [activityClock, setActivityClock] = useState(() => Date.now());
   const [pendingTurn, setPendingTurn] = useState<PendingCodexTurn | null>(null);
   const [pendingSteers, setPendingSteers] = useState<PendingCodexSteer[]>([]);
-  const [agentThreadsOpen, setAgentThreadsOpen] = useState(false);
-  const [nativeDialog, setNativeDialog] = useState<{
-    mode: CodexNativeDialogMode;
-    usageView?: "daily" | "weekly" | "cumulative";
-    editGoalImmediately?: boolean;
-  }>();
-  const [selectedAgentThreadId, setSelectedAgentThreadId] = useState<
-    string | undefined
-  >();
   const composerRef = useRef<HTMLTextAreaElement>(null);
   const scrollbarHideTimerRef = useRef<number | null>(null);
   const pendingTurnStartedAtRef = useRef<number | null>(null);
@@ -600,13 +553,6 @@ export function CodexConversation({
   const nativeHistoryLoading = !nativeSnapshot && !nativeHistoryError;
   const nativeHistorySyncing =
     nativeSnapshotFromCache && !nativeStreamReady && !nativeHistoryError;
-  const slashMenu = useCodexSlashCommandMenu({
-    value: draft,
-    context: "session",
-    turnRunning,
-    onComplete: setComposerDraft,
-    onExecute: (command) => void executeSlashCommand(command, ""),
-  });
   const {
     scrollRef: conversationScrollRef,
     contentRef: conversationContentRef,
@@ -615,44 +561,6 @@ export function CodexConversation({
     following: followingLatest,
   } = useConversationAutoScroll({ resetKey: session.id });
 
-  const updateAgentThreadsUrl = useCallback(
-    (open: boolean, threadId?: string) => {
-      const url = new URL(window.location.href);
-      if (open) {
-        url.searchParams.set("agents", "1");
-        if (threadId) {
-          url.searchParams.set("agent", threadId);
-        } else {
-          url.searchParams.delete("agent");
-        }
-      } else {
-        url.searchParams.delete("agents");
-        url.searchParams.delete("agent");
-      }
-      window.history.replaceState(window.history.state, "", url);
-    },
-    [],
-  );
-
-  const openAgentThreads = useCallback(() => {
-    setAgentThreadsOpen(true);
-    updateAgentThreadsUrl(true, selectedAgentThreadId);
-  }, [selectedAgentThreadId, updateAgentThreadsUrl]);
-
-  const closeAgentThreads = useCallback(() => {
-    setAgentThreadsOpen(false);
-    setSelectedAgentThreadId(undefined);
-    updateAgentThreadsUrl(false);
-  }, [updateAgentThreadsUrl]);
-
-  const selectAgentThread = useCallback(
-    (threadId?: string) => {
-      setSelectedAgentThreadId(threadId);
-      updateAgentThreadsUrl(true, threadId);
-    },
-    [updateAgentThreadsUrl],
-  );
-
   useEffect(() => {
     sessionRef.current = session;
   }, [session]);
@@ -728,21 +636,10 @@ export function CodexConversation({
     setLocalImages([]);
     setAttachmentError("");
     setCommandNotice(null);
-    setPlanMode(false);
     setFastMode(false);
-    setMentionOpenRequest(0);
     setSending(false);
     setInterrupting(false);
     setForkingMessageId(null);
-    const agentThreadUrl = new URL(window.location.href);
-    const requestedAgentThread =
-      agentThreadUrl.searchParams.get("agent")?.trim() || undefined;
-    setSelectedAgentThreadId(requestedAgentThread);
-    setAgentThreadsOpen(
-      agentThreadUrl.searchParams.get("agents") === "1" ||
-        Boolean(requestedAgentThread),
-    );
-    setNativeDialog(undefined);
     setNativeSnapshot(cachedSnapshot ?? null);
     setNativeSnapshotFromCache(Boolean(cachedSnapshot));
     setLiveNotifications([]);
@@ -1333,400 +1230,11 @@ export function CodexConversation({
     });
   }
 
-  function setComposerDraft(value: string) {
-    setDraft(value);
-    window.requestAnimationFrame(() => {
-      const textarea = composerRef.current;
-      if (!textarea) return;
-      textarea.focus();
-      textarea.setSelectionRange(value.length, value.length);
-    });
-  }
-
-  function clearComposerDraft() {
-    setDraft("");
-    window.requestAnimationFrame(() => {
-      const textarea = composerRef.current;
-      if (!textarea) return;
-      textarea.focus();
-    });
-  }
-
-  function markNativeCommandRunning() {
-    const current = sessionRef.current;
-    const next: CodexSession = {
-      ...current,
-      status: "running",
-      unread: false,
-      completed: false,
-    };
-    sessionRef.current = next;
-    onSessionChange(next);
-  }
-
-  async function executeSlashCommand(
-    command: CodexSlashCommand,
-    argumentsValue: string,
-  ) {
-    if (command.unavailableWhileTurnRunning && turnRunning) {
-      setCommandNotice({
-        tone: "error",
-        message:
-          language === "zh-CN"
-            ? `请等待当前 Turn 完成后再运行 /${command.name}。`
-            : `Wait for the current Turn to finish before running /${command.name}.`,
-      });
-      return;
-    }
-    clearComposerDraft();
-    setCommandNotice(null);
-
-    if (command.intent === "session.new") {
-      onNewSession({
-        ...(argumentsValue ? { title: argumentsValue } : {}),
-        source: command.name === "clear" ? "clear" : "startup",
-      });
-      return;
-    }
-    if (command.intent === "composer.mention") {
-      setMentionOpenRequest((request) => request + 1);
-      return;
-    }
-    if (command.intent === "workspace.open") {
-      onOpenInspector("files");
-      return;
-    }
-    if (command.intent === "agents.open") {
-      openAgentThreads();
-      return;
-    }
-    if (command.intent === "environment.skills") {
-      onOpenEnvironmentSettings("skills");
-      return;
-    }
-    if (command.intent === "environment.mcp") {
-      if (argumentsValue && argumentsValue.toLowerCase() !== "verbose") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? "/mcp 仅支持可选参数 verbose。"
-              : "/mcp only accepts the optional verbose argument.",
-        });
-        return;
-      }
-      onOpenEnvironmentSettings("mcp", {
-        mcpVerbose: argumentsValue.toLowerCase() === "verbose",
-      });
-      return;
-    }
-    if (command.intent === "environment.network") {
-      onOpenEnvironmentSettings("network");
-      return;
-    }
-    if (command.intent === "environment.credentials") {
-      onOpenEnvironmentSettings("credentials");
-      return;
-    }
-    if (
-      command.intent === "codex.personality" ||
-      command.intent === "codex.memories" ||
-      command.intent === "codex.hooks" ||
-      command.intent === "codex.processes"
-    ) {
-      setNativeDialog({
-        mode:
-          command.intent === "codex.personality"
-            ? "personality"
-            : command.intent === "codex.memories"
-              ? "memories"
-              : command.intent === "codex.hooks"
-                ? "hooks"
-                : "processes",
-      });
-      return;
-    }
-    if (command.intent === "codex.usage") {
-      const view = parseCodexTokenUsageView(argumentsValue);
-      if (!view) {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? "/usage 参数必须是 daily、weekly 或 cumulative。"
-              : "/usage expects daily, weekly, or cumulative.",
-        });
-        return;
-      }
-      setNativeDialog({ mode: "usage", usageView: view });
-      return;
-    }
-    if (
-      command.intent === "codex.goal" &&
-      (!argumentsValue || argumentsValue.toLowerCase() === "edit")
-    ) {
-      setNativeDialog({
-        mode: "goal",
-        editGoalImmediately: argumentsValue.toLowerCase() === "edit",
-      });
-      return;
-    }
-    if (command.intent === "session.rename" && !argumentsValue) {
-      setNativeDialog({ mode: "rename" });
-      return;
-    }
-    if (command.intent === "response.copy") {
-      const latest = [...visibleTimeline.entries]
-        .reverse()
-        .find(
-          (entry): entry is CodexMessageView =>
-            entry.kind === "message" &&
-            entry.role === "assistant" &&
-            Boolean(entry.content.trim()),
-        );
-      if (!latest) {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? "当前 Session 还没有可复制的助手回复。"
-              : "This Session has no assistant response to copy yet.",
-        });
-        return;
-      }
-      await copyMessage(latest);
-      setCommandNotice({
-        tone: "info",
-        message:
-          language === "zh-CN"
-            ? "已复制最近一条助手回复。"
-            : "Copied the latest assistant response.",
-      });
-      return;
-    }
-    if (command.intent === "composer.plan") {
-      setPlanMode(true);
-      if (argumentsValue) {
-        await submitMessage({
-          content: argumentsValue,
-          collaborationMode: "plan",
-          bypassSlash: true,
-          restoreDraft: `/plan ${argumentsValue}`,
-        });
-      } else {
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? "计划模式已开启，将应用到后续消息。"
-              : "Plan mode is active for subsequent messages.",
-        });
-      }
-      return;
-    }
-    if (command.intent === "codex.init") {
-      await submitMessage({
-        content: CODEX_INIT_COMMAND_PROMPT,
-        bypassSlash: true,
-        restoreDraft: "/init",
-      });
-      return;
-    }
-
-    const originalDraft =
-      draft || `/${command.name}${argumentsValue ? ` ${argumentsValue}` : ""}`;
-    clearComposerDraft();
-    setSending(true);
-    setAttachmentError("");
-    try {
-      if (command.intent === "codex.goal") {
-        const action = argumentsValue.toLowerCase();
-        const clear = action === "clear";
-        const status =
-          action === "pause"
-            ? ("paused" as const)
-            : action === "resume"
-              ? ("active" as const)
-              : undefined;
-        const response = await apiFetch<ApiEnvelope<CodexGoalProjection>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/goal`,
-          clear
-            ? { method: "DELETE" }
-            : {
-                method: "PUT",
-                body: JSON.stringify(
-                  status ? { status } : { objective: argumentsValue },
-                ),
-              },
-        );
-        const goal = response.data.goal;
-        setCommandNotice({
-          tone: "info",
-          message: clear
-            ? language === "zh-CN"
-              ? "已清除 Codex 原生 Session 目标。"
-              : "Cleared the native Codex Session goal."
-            : goal
-              ? [
-                  language === "zh-CN" ? "目标" : "Goal",
-                  goal.status,
-                  goal.objective,
-                  goal.tokenBudget === null
-                    ? `${goal.tokensUsed} tokens`
-                    : `${goal.tokensUsed}/${goal.tokenBudget} tokens`,
-                ].join(" · ")
-              : language === "zh-CN"
-                ? "当前没有 Codex Session 目标。"
-                : "This Codex Session has no goal.",
-        });
-        return;
-      }
-      if (command.intent === "codex.stop") {
-        await apiFetch<ApiEnvelope<{ cleaned: boolean }>>(
-          `/api/v1/sessions/${encodeURIComponent(
-            session.id,
-          )}/background-terminals`,
-          { method: "DELETE" },
-        );
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? "已停止并清理所有 Codex 后台终端。"
-              : "Stopped and cleaned all Codex background terminals.",
-        });
-        return;
-      }
-      if (command.intent === "session.fork") {
-        const response = await apiFetch<ApiEnvelope<CodexSession>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/fork`,
-          { method: "POST", body: JSON.stringify({}) },
-        );
-        onDerivedSessionCreated(response.data);
-        return;
-      }
-      if (command.intent === "codex.compact") {
-        await apiFetch<ApiEnvelope<{ accepted: boolean }>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/compact`,
-          { method: "POST", body: JSON.stringify({}) },
-        );
-        markNativeCommandRunning();
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? "Codex 正在压缩当前 Session 上下文。"
-              : "Codex is compacting this Session context.",
-        });
-        return;
-      }
-      if (command.intent === "codex.review") {
-        await apiFetch<ApiEnvelope<{ nativeTurnId: string }>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/review`,
-          {
-            method: "POST",
-            body: JSON.stringify(
-              argumentsValue ? { instructions: argumentsValue } : {},
-            ),
-          },
-        );
-        markNativeCommandRunning();
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? "Codex 原生代码审查已开始。"
-              : "The native Codex review has started.",
-        });
-        return;
-      }
-      if (command.intent === "session.rename") {
-        const response = await apiFetch<ApiEnvelope<CodexSession>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/metadata`,
-          {
-            method: "PUT",
-            body: JSON.stringify({ title: argumentsValue }),
-          },
-        );
-        onSessionChange(response.data);
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? `Session 已重命名为“${response.data.title}”。`
-              : `Renamed the Session to “${response.data.title}”.`,
-        });
-        return;
-      }
-      if (command.intent === "session.archive") {
-        const response = await apiFetch<ApiEnvelope<CodexSession>>(
-          `/api/v1/sessions/${encodeURIComponent(session.id)}/metadata`,
-          {
-            method: "PUT",
-            body: JSON.stringify({ archived: true }),
-          },
-        );
-        onSessionChange(response.data);
-        onNewSession();
-      }
-    } catch (error) {
-      setComposerDraft(originalDraft);
-      setCommandNotice({
-        tone: "error",
-        message:
-          error instanceof Error
-            ? error.message
-            : language === "zh-CN"
-              ? `无法运行 /${command.name}。`
-              : `Could not run /${command.name}.`,
-      });
-    } finally {
-      setSending(false);
-    }
-  }
-
-  async function submitMessage(options: SubmitCodexMessageOptions = {}) {
-    if (!options.bypassSlash) {
-      const invocation = parseCodexSlashInvocation(draft, "session");
-      if (invocation.kind === "command") {
-        await executeSlashCommand(invocation.command, invocation.arguments);
-        return;
-      }
-      if (invocation.kind === "unknown") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `未知命令 /${invocation.name}。输入 / 查看可用命令。`
-              : `Unknown command /${invocation.name}. Type / to see available commands.`,
-        });
-        return;
-      }
-      if (invocation.kind === "unavailable") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `/${invocation.command.name} 不适用于当前输入框。`
-              : `/${invocation.command.name} is not available in this composer.`,
-        });
-        return;
-      }
-      if (invocation.kind === "missing-arguments") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `/${invocation.command.name} 需要${invocation.command.argumentHint?.[language] ?? "参数"}。`
-              : `/${invocation.command.name} requires ${invocation.command.argumentHint?.[language] ?? "an argument"}.`,
-        });
-        return;
-      }
-    }
-    const submittedDraft = options.restoreDraft ?? draft;
+  async function submitMessage() {
+    const submittedDraft = draft;
     const submittedImages = pastedImages;
     const submittedLocalImages = localImages;
-    const content = (options.content ?? draft).trim();
+    const content = draft.trim();
     if (
       !content &&
       submittedImages.length === 0 &&
@@ -1795,14 +1303,6 @@ export function CodexConversation({
                   ...(selectedReasoningEffort
                     ? { reasoningEffort: selectedReasoningEffort }
                     : {}),
-                  ...((options.collaborationMode ??
-                  (planMode ? "plan" : undefined))
-                    ? {
-                        collaborationMode:
-                          options.collaborationMode ??
-                          (planMode ? ("plan" as const) : undefined),
-                      }
-                    : {}),
                   ...(fastMode && selectedModel.fastServiceTier
                     ? { serviceTier: selectedModel.fastServiceTier.id }
                     : {}),
@@ -2480,10 +1980,6 @@ export function CodexConversation({
               <span>{ui.jumpToLatest}</span>
             </button>
           ) : null}
-          {/*
-            Slash commands, approvals, steering and other composer behavior are Codex-native.
-            Do not lift them into the shared dispatcher when additional harnesses are added.
-          */}
           <CodexComposer
             language={language}
             inputRef={composerRef}
@@ -2492,7 +1988,6 @@ export function CodexConversation({
               value: draft,
               onChange: (event) => {
                 setDraft(event.target.value);
-                slashMenu.show();
                 setCommandNotice(null);
               },
               onPaste: (event) => {
@@ -2504,7 +1999,6 @@ export function CodexConversation({
                 void addPastedImages(imageFiles);
               },
               onKeyDown: (event) => {
-                if (slashMenu.handleKeyDown(event)) return;
                 if (
                   shouldSubmitComposer(
                     {
@@ -2521,26 +2015,11 @@ export function CodexConversation({
                   void submitMessage();
                 }
               },
-              "aria-controls":
-                slashMenu.commands.length > 0 ? slashMenu.id : undefined,
-              "aria-activedescendant": slashMenu.activeCommand
-                ? `${slashMenu.id}-${slashMenu.activeCommand.name}`
-                : undefined,
               "aria-label": ui.messageAgent(environment.codingAgent.label),
               placeholder: turnRunning
                 ? ui.steerPlaceholder(environment.codingAgent.label)
                 : ui.askPlaceholder(environment.codingAgent.label),
             }}
-            slashCommandMenu={
-              <CodexSlashCommandMenu
-                id={slashMenu.id}
-                language={language}
-                commands={slashMenu.commands}
-                activeIndex={slashMenu.activeIndex}
-                onActiveIndexChange={slashMenu.setActiveIndex}
-                onSelect={slashMenu.select}
-              />
-            }
             images={pastedImages}
             onRemoveImage={(id) => {
               setPastedImages((current) =>
@@ -2557,23 +2036,6 @@ export function CodexConversation({
             }}
             attachmentError={attachmentError}
             notice={commandNotice}
-            mode={
-              planMode
-                ? {
-                    label: language === "zh-CN" ? "计划模式" : "Plan mode",
-                    description:
-                      language === "zh-CN"
-                        ? "后续消息使用 Codex 计划协作模式"
-                        : "Subsequent messages use Codex Plan collaboration mode",
-                    exitLabel:
-                      language === "zh-CN" ? "退出计划模式" : "Exit Plan mode",
-                    onExit: () => {
-                      setPlanMode(false);
-                      setCommandNotice(null);
-                    },
-                  }
-                : null
-            }
             toolbar={{
               environmentId: environment.id,
               agentLabel: environment.codingAgent.label,
@@ -2597,7 +2059,6 @@ export function CodexConversation({
                 setFastMode(enabled);
                 setCommandNotice(null);
               },
-              mentionOpenRequest,
               contextUsedPercent,
               status: {
                 state: nativeHistoryError
@@ -2679,38 +2140,6 @@ export function CodexConversation({
           </p>
         </div>
       </section>
-      {nativeDialog ? (
-        <CodexNativeCommandDialog
-          mode={nativeDialog.mode}
-          language={language}
-          environmentId={environment.id}
-          session={session}
-          initialUsageView={nativeDialog.usageView}
-          editGoalImmediately={nativeDialog.editGoalImmediately}
-          onSessionChange={onSessionChange}
-          onClose={() => setNativeDialog(undefined)}
-        />
-      ) : null}
-      {agentThreadsOpen ? (
-        <CodexAgentThreadsDialog
-          language={language}
-          timeZone={timeZone}
-          sessionId={session.id}
-          sessionTitle={session.title}
-          harnessLabel={session.harnessLabel}
-          selectedThreadId={selectedAgentThreadId}
-          onSelectedThreadChange={selectAgentThread}
-          onOpenWorkspacePath={(path) => {
-            closeAgentThreads();
-            onOpenWorkspacePath(path);
-          }}
-          onOpenFiles={(path) => {
-            closeAgentThreads();
-            openChangedFile(path);
-          }}
-          onClose={closeAgentThreads}
-        />
-      ) : null}
       {inspectorOpen ||
       mountedInspectorEnvironmentId === environment.id ? (
         <Inspector
diff --git a/src/harnesses/codex/models.test.ts b/src/harnesses/codex/models.test.ts
index 010cb17..4a79a98 100644
--- a/src/harnesses/codex/models.test.ts
+++ b/src/harnesses/codex/models.test.ts
@@ -29,7 +29,6 @@ test("projects the native Codex model/list result without sharing a cross-harnes
             },
           ],
           additionalSpeedTiers: ["fast"],
-          supportsPersonality: true,
           serviceTiers: [
             {
               id: "native-priority",
@@ -61,7 +60,6 @@ test("projects the native Codex model/list result without sharing a cross-harnes
             description: "Deeper reasoning for complex tasks",
           },
         ],
-        supportsPersonality: true,
         fastServiceTier: {
           id: "native-priority",
           name: "Fast",
@@ -94,7 +92,6 @@ test("keeps a future model-defined effort without requiring a Sandpi enum", () =
         supportedReasoningEfforts: [
           { id: "focused", description: "Focused" },
         ],
-        supportsPersonality: false,
       },
     ],
   );
@@ -135,7 +132,6 @@ test("stably deduplicates the live Codex catalog by native model id", () => {
         supportedReasoningEfforts: [
           { id: "medium", description: "Medium" },
         ],
-        supportsPersonality: false,
       },
       {
         id: "native-next",
@@ -143,7 +139,6 @@ test("stably deduplicates the live Codex catalog by native model id", () => {
         isDefault: false,
         defaultReasoningEffort: "",
         supportedReasoningEfforts: [],
-        supportsPersonality: false,
       },
     ],
   );
diff --git a/src/harnesses/codex/models.ts b/src/harnesses/codex/models.ts
index d593b19..ad9bb54 100644
--- a/src/harnesses/codex/models.ts
+++ b/src/harnesses/codex/models.ts
@@ -9,7 +9,6 @@ export interface CodexModelOption {
   isDefault: boolean;
   defaultReasoningEffort: string;
   supportedReasoningEfforts: CodexReasoningEffortOption[];
-  supportsPersonality: boolean;
   fastServiceTier?: {
     id: string;
     name: string;
@@ -27,7 +26,6 @@ interface NativeCodexModel {
   supportedReasoningEfforts?: unknown;
   additionalSpeedTiers?: unknown;
   serviceTiers?: unknown;
-  supportsPersonality?: unknown;
 }
 
 function reasoningEffortOptions(value: unknown) {
@@ -144,7 +142,6 @@ export function codexModelOptionsFromNativeResult(result: unknown) {
           ? nativeDefaultReasoningEffort
           : (supportedReasoningEfforts[0]?.id ?? ""),
         supportedReasoningEfforts,
-        supportsPersonality: model.supportsPersonality === true,
         ...(nativeFastServiceTier
           ? { fastServiceTier: nativeFastServiceTier }
           : {}),
diff --git a/src/harnesses/codex/native-capabilities.ts b/src/harnesses/codex/native-capabilities.ts
index 989cd64..fa538c6 100644
--- a/src/harnesses/codex/native-capabilities.ts
+++ b/src/harnesses/codex/native-capabilities.ts
@@ -3,46 +3,6 @@
  * the Sandbox0-pinned @openai/codex 0.144.1 protocol; they normalize native
  * values but must not introduce alternate harness behavior.
  */
-export type CodexPersonality = "friendly" | "pragmatic" | "none";
-export type CodexPersonalitySelection = Exclude<CodexPersonality, "none">;
-
-export interface CodexPersonalitySettings {
-  personality: CodexPersonality;
-  supported: boolean;
-}
-
-export interface CodexTokenUsageSummary {
-  lifetimeTokens: number | null;
-  peakDailyTokens: number | null;
-  longestRunningTurnSec: number | null;
-  currentStreakDays: number | null;
-  longestStreakDays: number | null;
-}
-
-export interface CodexTokenUsageDailyBucket {
-  startDate: string;
-  tokens: number;
-}
-
-export interface CodexTokenUsage {
-  summary: CodexTokenUsageSummary;
-  dailyUsageBuckets: CodexTokenUsageDailyBucket[];
-}
-
-export interface CodexBackgroundTerminal {
-  itemId: string;
-  processId: string;
-  command: string;
-  cwd: string;
-  osPid: number | null;
-  cpuPercent: number | null;
-  rssKb: number | null;
-}
-
-export interface CodexBackgroundTerminals {
-  terminals: CodexBackgroundTerminal[];
-}
-
 export interface CodexMemoriesSettings {
   featureEnabled: boolean;
   useMemories: boolean;
@@ -58,39 +18,3 @@ export function codexMemoriesFeatureToggleSettings(
     generateMemories: featureEnabled,
   };
 }
-
-export type CodexHookTrustStatus =
-  | "trusted"
-  | "untrusted"
-  | "modified"
-  | "managed";
-
-export interface CodexHook {
-  key: string;
-  eventName: string;
-  handlerType: string;
-  isManaged: boolean;
-  matcher: string | null;
-  command: string | null;
-  timeoutSec: number;
-  statusMessage: string | null;
-  sourcePath: string;
-  source: string;
-  pluginId: string | null;
-  displayOrder: number;
-  enabled: boolean;
-  currentHash: string;
-  trustStatus: CodexHookTrustStatus;
-}
-
-export interface CodexHookIssue {
-  path?: string;
-  message: string;
-}
-
-export interface CodexHooksInventory {
-  cwd: string;
-  hooks: CodexHook[];
-  warnings: string[];
-  errors: CodexHookIssue[];
-}
diff --git a/src/harnesses/codex/native-command-dialog.module.css b/src/harnesses/codex/native-command-dialog.module.css
deleted file mode 100644
index 8711f8e..0000000
--- a/src/harnesses/codex/native-command-dialog.module.css
+++ /dev/null
@@ -1,611 +0,0 @@
-.backdrop {
-  position: fixed;
-  z-index: 96;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 20px;
-  background: rgb(24 24 21 / 38%);
-  backdrop-filter: blur(2px);
-}
-
-.dialog {
-  display: grid;
-  width: min(760px, 100%);
-  max-height: min(760px, calc(100dvh - 40px));
-  grid-template-rows: auto minmax(0, 1fr);
-  overflow: hidden;
-  border: 1px solid var(--line);
-  border-radius: 14px;
-  outline: 0;
-  background: var(--panel-strong);
-  box-shadow: var(--shadow-lg);
-}
-
-.header {
-  display: flex;
-  min-height: 64px;
-  align-items: center;
-  gap: 11px;
-  padding: 10px 12px 10px 17px;
-  border-bottom: 1px solid var(--line);
-  background: var(--panel);
-}
-
-.headerIcon {
-  display: inline-flex;
-  width: 34px;
-  height: 34px;
-  flex: 0 0 auto;
-  align-items: center;
-  justify-content: center;
-  border: 1px solid var(--line);
-  border-radius: 9px;
-  background: var(--sidebar);
-  color: var(--ink-soft);
-}
-
-.headerCopy {
-  display: flex;
-  min-width: 0;
-  flex: 1;
-  flex-direction: column;
-  gap: 3px;
-}
-
-.headerCopy strong {
-  color: var(--ink);
-  font-size: 13px;
-}
-
-.headerCopy small {
-  overflow: hidden;
-  color: var(--ink-faint);
-  font-size: 10px;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.header > button,
-.iconButton {
-  display: inline-flex;
-  width: 32px;
-  height: 32px;
-  align-items: center;
-  justify-content: center;
-  padding: 0;
-  border: 0;
-  border-radius: 7px;
-  background: transparent;
-  color: var(--ink-faint);
-  cursor: pointer;
-}
-
-.header > button:hover,
-.iconButton:hover {
-  background: var(--hover);
-  color: var(--ink);
-}
-
-.body {
-  min-height: 0;
-  overflow: auto;
-  padding: 20px;
-  scrollbar-width: thin;
-}
-
-.stack {
-  display: flex;
-  flex-direction: column;
-  gap: 12px;
-}
-
-.choiceGrid {
-  display: grid;
-  gap: 9px;
-}
-
-.choiceGrid > button {
-  display: flex;
-  min-height: 72px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 16px;
-  padding: 13px 15px;
-  border: 1px solid var(--line);
-  border-radius: 10px;
-  background: var(--panel);
-  color: var(--ink-soft);
-  text-align: left;
-  cursor: pointer;
-}
-
-.choiceGrid > button:hover:not(:disabled) {
-  border-color: color-mix(in srgb, var(--green) 35%, var(--line));
-  background: color-mix(in srgb, var(--green-soft) 42%, var(--panel));
-}
-
-.choiceGrid > button.selectedChoice {
-  border-color: color-mix(in srgb, var(--green) 45%, var(--line));
-  background: var(--green-soft);
-  color: var(--green);
-}
-
-.choiceGrid > button > span:first-child {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-}
-
-.choiceGrid strong,
-.settingRow strong {
-  color: var(--ink);
-  font-size: 12px;
-}
-
-.choiceGrid small,
-.settingRow small {
-  color: var(--ink-faint);
-  font-size: 10px;
-  line-height: 1.5;
-}
-
-.toolbar {
-  display: flex;
-  min-height: 34px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  color: var(--ink-faint);
-  font-size: 10px;
-}
-
-.toolbarActions,
-.actionRow,
-.hookActions {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-.segmented {
-  display: inline-flex;
-  padding: 3px;
-  border: 1px solid var(--line);
-  border-radius: 8px;
-  background: var(--sidebar);
-}
-
-.segmented button {
-  padding: 6px 10px;
-  border: 0;
-  border-radius: 5px;
-  background: transparent;
-  color: var(--ink-faint);
-  font-size: 10px;
-  text-transform: capitalize;
-  cursor: pointer;
-}
-
-.segmented button[aria-pressed="true"] {
-  background: var(--panel-strong);
-  color: var(--ink);
-  box-shadow: 0 1px 3px rgb(24 24 20 / 10%);
-}
-
-.summaryGrid {
-  display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
-  gap: 8px;
-}
-
-.summaryMetric {
-  display: flex;
-  min-width: 0;
-  min-height: 66px;
-  flex-direction: column;
-  justify-content: center;
-  gap: 6px;
-  padding: 10px 12px;
-  border: 1px solid var(--line-soft);
-  border-radius: 9px;
-  background: var(--panel);
-}
-
-.summaryMetric small {
-  color: var(--ink-faint);
-  font-size: 9px;
-}
-
-.summaryMetric strong {
-  overflow: hidden;
-  color: var(--ink);
-  font-size: 15px;
-  text-overflow: ellipsis;
-}
-
-.chart {
-  display: flex;
-  height: 210px;
-  align-items: flex-end;
-  gap: 3px;
-  overflow-x: auto;
-  padding: 16px 12px 0;
-  border: 1px solid var(--line-soft);
-  border-radius: 10px;
-  background:
-    repeating-linear-gradient(
-      to top,
-      transparent 0,
-      transparent 51px,
-      var(--line-soft) 52px
-    ),
-    var(--panel);
-}
-
-.barColumn {
-  display: flex;
-  min-width: 8px;
-  height: 100%;
-  flex: 1 0 8px;
-  align-items: flex-end;
-}
-
-.barColumn i {
-  display: block;
-  width: 100%;
-  min-height: 3px;
-  border-radius: 3px 3px 1px 1px;
-  background: color-mix(in srgb, var(--green) 82%, var(--blue));
-}
-
-.chartCaption {
-  display: flex;
-  justify-content: space-between;
-  color: var(--ink-faint);
-  font-family: "SFMono-Regular", Consolas, monospace;
-  font-size: 8px;
-}
-
-.settingRow {
-  display: flex;
-  min-height: 72px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 18px;
-  padding: 13px 15px;
-  border: 1px solid var(--line-soft);
-  border-radius: 10px;
-  background: var(--panel);
-}
-
-.settingRow > span {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-}
-
-.switch {
-  position: relative;
-  width: 34px;
-  height: 20px;
-  flex: 0 0 auto;
-  padding: 0;
-  border: 1px solid var(--line);
-  border-radius: 999px;
-  background: var(--selected);
-  cursor: pointer;
-}
-
-.switch span {
-  position: absolute;
-  top: 2px;
-  left: 2px;
-  width: 14px;
-  height: 14px;
-  border-radius: 50%;
-  background: var(--panel-strong);
-  box-shadow: 0 1px 3px rgb(24 24 20 / 24%);
-  transition: transform 120ms ease;
-}
-
-.switch[data-checked="true"] {
-  border-color: var(--green);
-  background: var(--green);
-}
-
-.switch[data-checked="true"] span {
-  transform: translateX(14px);
-}
-
-.switch:disabled {
-  opacity: 0.48;
-}
-
-.actionRow {
-  flex-wrap: wrap;
-  padding-top: 4px;
-}
-
-.actionRow button,
-.hookActions > button,
-.processRow > button {
-  display: inline-flex;
-  min-height: 32px;
-  align-items: center;
-  justify-content: center;
-  gap: 6px;
-  padding: 6px 10px;
-  border: 1px solid var(--line);
-  border-radius: 7px;
-  background: var(--panel);
-  color: var(--ink-soft);
-  font-size: 10px;
-  cursor: pointer;
-}
-
-.actionRow button:hover:not(:disabled),
-.hookActions > button:hover:not(:disabled),
-.processRow > button:hover:not(:disabled) {
-  background: var(--hover);
-  color: var(--ink);
-}
-
-.actionRow button.primaryButton {
-  border-color: var(--green);
-  background: var(--green);
-  color: #fff;
-}
-
-.actionRow button.dangerButton,
-.toolbar button.dangerButton {
-  display: inline-flex;
-  min-height: 30px;
-  align-items: center;
-  gap: 6px;
-  padding: 5px 9px;
-  border: 1px solid color-mix(in srgb, var(--red) 32%, var(--line));
-  border-radius: 7px;
-  background: var(--red-soft);
-  color: var(--red);
-  font-size: 10px;
-  cursor: pointer;
-}
-
-.confirmText {
-  color: var(--red);
-  font-size: 10px;
-}
-
-.hookList,
-.processList {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-}
-
-.hookRow,
-.processRow {
-  display: flex;
-  align-items: center;
-  gap: 13px;
-  padding: 12px 13px;
-  border: 1px solid var(--line-soft);
-  border-radius: 9px;
-  background: var(--panel);
-}
-
-.hookMain,
-.processRow > div {
-  display: flex;
-  min-width: 0;
-  flex: 1;
-  flex-direction: column;
-  gap: 6px;
-}
-
-.hookHeading {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-}
-
-.hookHeading strong {
-  color: var(--ink);
-  font-size: 11px;
-}
-
-.hookHeading span {
-  padding: 2px 5px;
-  border: 1px solid var(--line);
-  border-radius: 4px;
-  color: var(--ink-faint);
-  font-size: 8px;
-}
-
-.hookHeading span[data-tone="warning"] {
-  border-color: color-mix(in srgb, var(--amber) 35%, var(--line));
-  background: var(--amber-soft);
-  color: var(--amber);
-}
-
-.hookMain code,
-.processRow code {
-  overflow: hidden;
-  color: var(--ink-soft);
-  font-size: 9px;
-  line-height: 1.45;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.hookMain small,
-.processRow small {
-  overflow: hidden;
-  color: var(--ink-faint);
-  font-size: 8px;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.processId {
-  min-width: 42px;
-  padding: 4px 6px;
-  border-radius: 5px;
-  background: var(--sidebar);
-  color: var(--ink-faint);
-  font-family: "SFMono-Regular", Consolas, monospace;
-  font-size: 9px;
-  text-align: center;
-}
-
-.goalStatus {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 10px 12px;
-  border: 1px solid var(--line-soft);
-  border-radius: 8px;
-  background: var(--panel);
-}
-
-.goalStatus span {
-  padding: 3px 7px;
-  border-radius: 999px;
-  background: var(--green-soft);
-  color: var(--green);
-  font-size: 9px;
-  font-weight: 700;
-}
-
-.goalStatus span:not([data-status="active"]) {
-  background: var(--amber-soft);
-  color: var(--amber);
-}
-
-.goalStatus small {
-  color: var(--ink-faint);
-  font-size: 9px;
-}
-
-.field {
-  display: flex;
-  flex-direction: column;
-  gap: 7px;
-  color: var(--ink-soft);
-  font-size: 10px;
-}
-
-.field input,
-.field textarea {
-  width: 100%;
-  padding: 10px 11px;
-  resize: vertical;
-  border: 1px solid var(--line);
-  border-radius: 8px;
-  outline: 0;
-  background: var(--panel);
-  color: var(--ink);
-  font-size: 12px;
-  line-height: 1.5;
-}
-
-.field input:focus,
-.field textarea:focus {
-  border-color: color-mix(in srgb, var(--blue) 55%, var(--line));
-  box-shadow: 0 0 0 3px color-mix(in srgb, var(--blue-soft) 65%, transparent);
-}
-
-.loading,
-.empty,
-.error,
-.notice {
-  padding: 12px 13px;
-  border-radius: 8px;
-  font-size: 10px;
-  line-height: 1.5;
-}
-
-.loading {
-  display: flex;
-  min-height: 120px;
-  align-items: center;
-  justify-content: center;
-  gap: 8px;
-  color: var(--ink-faint);
-}
-
-.empty {
-  border: 1px dashed var(--line);
-  background: var(--panel);
-  color: var(--ink-faint);
-  text-align: center;
-}
-
-.error {
-  border: 1px solid color-mix(in srgb, var(--red) 25%, var(--line));
-  background: var(--red-soft);
-  color: var(--red);
-}
-
-.notice {
-  border: 1px solid color-mix(in srgb, var(--blue) 24%, var(--line));
-  background: var(--blue-soft);
-  color: var(--blue);
-}
-
-.footnote {
-  margin: 2px 0 0;
-  color: var(--ink-faint);
-  font-size: 9px;
-  line-height: 1.5;
-}
-
-.footnote code {
-  color: var(--ink-soft);
-}
-
-.spin {
-  animation: spin 0.9s linear infinite;
-}
-
-@keyframes spin {
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-@media (max-width: 640px) {
-  .backdrop {
-    align-items: flex-end;
-    padding: 0;
-  }
-
-  .dialog {
-    width: 100%;
-    max-height: 92dvh;
-    border-width: 1px 0 0;
-    border-radius: 14px 14px 0 0;
-  }
-
-  .body {
-    padding: 15px;
-  }
-
-  .summaryGrid {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
-  .hookRow,
-  .processRow {
-    align-items: flex-start;
-    flex-wrap: wrap;
-  }
-
-  .hookActions {
-    width: 100%;
-    justify-content: flex-end;
-  }
-}
diff --git a/src/harnesses/codex/native-command-dialog.tsx b/src/harnesses/codex/native-command-dialog.tsx
deleted file mode 100644
index 7781267..0000000
--- a/src/harnesses/codex/native-command-dialog.tsx
+++ /dev/null
@@ -1,1347 +0,0 @@
-"use client";
-
-import {
-  Activity,
-  Brain,
-  Check,
-  Flag,
-  Gauge,
-  LoaderCircle,
-  RefreshCw,
-  SlidersHorizontal,
-  Sparkles,
-  SquareTerminal,
-  Trash2,
-  Webhook,
-  X,
-} from "lucide-react";
-import {
-  useCallback,
-  useEffect,
-  useId,
-  useMemo,
-  useRef,
-  useState,
-  type ReactNode,
-} from "react";
-
-import {
-  codexMemoriesFeatureToggleSettings,
-  type CodexBackgroundTerminals,
-  type CodexHooksInventory,
-  type CodexMemoriesSettings,
-  type CodexPersonalitySelection,
-  type CodexPersonalitySettings,
-  type CodexTokenUsage,
-} from "@/harnesses/codex/native-capabilities";
-import {
-  codexTokenUsagePoints,
-  type CodexTokenUsageView,
-} from "@/harnesses/codex/token-usage";
-import type { CodexSession } from "@/harnesses/codex/types";
-import { apiFetch, type ApiEnvelope } from "@/lib/api-client";
-import type { OperationLanguage } from "@/lib/operation-ui";
-
-import styles from "./native-command-dialog.module.css";
-
-export type CodexNativeDialogMode =
-  | "goal"
-  | "hooks"
-  | "memories"
-  | "personality"
-  | "processes"
-  | "rename"
-  | "usage";
-
-interface CodexNativeCommandDialogProps {
-  mode: CodexNativeDialogMode;
-  language: OperationLanguage;
-  environmentId: string;
-  session?: CodexSession;
-  initialUsageView?: CodexTokenUsageView;
-  editGoalImmediately?: boolean;
-  onSessionChange?: (session: CodexSession) => void;
-  onClose: () => void;
-}
-
-const MODE_META: Record<
-  CodexNativeDialogMode,
-  { title: string; description: string; icon: typeof Activity }
-> = {
-  goal: {
-    title: "Goal",
-    description: "Manage the persisted goal on this native Codex Thread.",
-    icon: Flag,
-  },
-  hooks: {
-    title: "Lifecycle hooks",
-    description: "Review, trust, enable, or disable hooks discovered by Codex.",
-    icon: Webhook,
-  },
-  memories: {
-    title: "Memories",
-    description: "Control memory use and future memory generation in this Environment.",
-    icon: Brain,
-  },
-  personality: {
-    title: "Personality",
-    description: "Choose the response style used by Codex on subsequent Turns.",
-    icon: Sparkles,
-  },
-  processes: {
-    title: "Background terminals",
-    description: "Native shell processes that outlived their initiating command.",
-    icon: SquareTerminal,
-  },
-  rename: {
-    title: "Rename Session",
-    description: "Change the Sandpi Session title.",
-    icon: SlidersHorizontal,
-  },
-  usage: {
-    title: "Token activity",
-    description: "ChatGPT account token activity reported directly by Codex.",
-    icon: Gauge,
-  },
-};
-
-export function CodexNativeCommandDialog({
-  mode,
-  language,
-  environmentId,
-  session,
-  initialUsageView = "daily",
-  editGoalImmediately = false,
-  onSessionChange,
-  onClose,
-}: CodexNativeCommandDialogProps) {
-  const titleId = useId();
-  const dialogRef = useRef<HTMLElement>(null);
-  const meta = MODE_META[mode];
-  const Icon = meta.icon;
-
-  useEffect(() => {
-    const previouslyFocused = document.activeElement as HTMLElement | null;
-    const previousOverflow = document.body.style.overflow;
-    document.body.style.overflow = "hidden";
-    const frame = window.requestAnimationFrame(() => dialogRef.current?.focus());
-    return () => {
-      window.cancelAnimationFrame(frame);
-      document.body.style.overflow = previousOverflow;
-      previouslyFocused?.focus();
-    };
-  }, []);
-
-  return (
-    <div
-      className={styles.backdrop}
-      role="presentation"
-      onMouseDown={(event) => {
-        if (event.target === event.currentTarget) onClose();
-      }}
-    >
-      <section
-        ref={dialogRef}
-        className={styles.dialog}
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={titleId}
-        tabIndex={-1}
-        onKeyDown={(event) => {
-          if (event.key === "Escape") {
-            event.preventDefault();
-            onClose();
-            return;
-          }
-          if (event.key !== "Tab") return;
-          const focusable = Array.from(
-            dialogRef.current?.querySelectorAll<HTMLElement>(
-              'button:not([disabled]), input:not([disabled]), textarea:not([disabled]), [href], [tabindex]:not([tabindex="-1"])',
-            ) ?? [],
-          );
-          const first = focusable[0];
-          const last = focusable.at(-1);
-          if (event.shiftKey && document.activeElement === first) {
-            event.preventDefault();
-            last?.focus();
-          } else if (!event.shiftKey && document.activeElement === last) {
-            event.preventDefault();
-            first?.focus();
-          }
-        }}
-      >
-        <header className={styles.header}>
-          <span className={styles.headerIcon}>
-            <Icon size={18} aria-hidden="true" />
-          </span>
-          <span className={styles.headerCopy}>
-            <strong id={titleId}>{meta.title}</strong>
-            <small>{meta.description}</small>
-          </span>
-          <button
-            type="button"
-            aria-label={language === "zh-CN" ? "关闭" : "Close"}
-            onClick={onClose}
-          >
-            <X size={17} aria-hidden="true" />
-          </button>
-        </header>
-        <div className={styles.body}>
-          {mode === "personality" ? (
-            <PersonalityPanel
-              language={language}
-              environmentId={environmentId}
-              sessionId={session?.id}
-            />
-          ) : mode === "usage" ? (
-            <UsagePanel
-              language={language}
-              environmentId={environmentId}
-              initialView={initialUsageView}
-            />
-          ) : mode === "memories" ? (
-            <MemoriesPanel
-              language={language}
-              environmentId={environmentId}
-              sessionId={session?.id}
-            />
-          ) : mode === "hooks" ? (
-            <HooksPanel language={language} environmentId={environmentId} />
-          ) : mode === "processes" && session ? (
-            <ProcessesPanel language={language} sessionId={session.id} />
-          ) : mode === "goal" && session ? (
-            <GoalPanel
-              language={language}
-              sessionId={session.id}
-              editImmediately={editGoalImmediately}
-            />
-          ) : mode === "rename" && session ? (
-            <RenamePanel
-              language={language}
-              session={session}
-              onSessionChange={onSessionChange}
-              onClose={onClose}
-            />
-          ) : (
-            <PanelError
-              message={
-                language === "zh-CN"
-                  ? "此命令需要一个活动 Session。"
-                  : "This command requires an active Session."
-              }
-            />
-          )}
-        </div>
-      </section>
-    </div>
-  );
-}
-
-function PersonalityPanel({
-  language,
-  environmentId,
-  sessionId,
-}: {
-  language: OperationLanguage;
-  environmentId: string;
-  sessionId?: string;
-}) {
-  const [settings, setSettings] = useState<CodexPersonalitySettings>();
-  const [loading, setLoading] = useState(true);
-  const [busy, setBusy] = useState<CodexPersonalitySelection>();
-  const [error, setError] = useState("");
-  const endpoint = sessionId
-    ? `/api/v1/sessions/${encodeURIComponent(sessionId)}/personality`
-    : `/api/v1/environments/${encodeURIComponent(environmentId)}/harnesses/codex/personality`;
-
-  useEffect(() => {
-    const controller = new AbortController();
-    void apiFetch<ApiEnvelope<CodexPersonalitySettings>>(endpoint, {
-      signal: controller.signal,
-    })
-      .then((response) => setSettings(response.data))
-      .catch((cause) => {
-        if (!controller.signal.aborted) {
-          setError(errorMessage(cause, "Could not read Codex personality."));
-        }
-      })
-      .finally(() => {
-        if (!controller.signal.aborted) setLoading(false);
-      });
-    return () => controller.abort();
-  }, [endpoint]);
-
-  async function select(personality: CodexPersonalitySelection) {
-    if (busy || !settings?.supported) return;
-    setBusy(personality);
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<CodexPersonalitySettings>>(
-        endpoint,
-        {
-          method: "PUT",
-          body: JSON.stringify({ personality }),
-        },
-      );
-      setSettings(response.data);
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not update Codex personality."));
-    } finally {
-      setBusy(undefined);
-    }
-  }
-
-  if (loading) return <PanelLoading label="Loading personality…" />;
-  if (error && !settings) return <PanelError message={error} />;
-  const choices: Array<{
-    id: CodexPersonalitySelection;
-    title: string;
-    detail: string;
-  }> = [
-    {
-      id: "friendly",
-      title: language === "zh-CN" ? "友好" : "Friendly",
-      detail:
-        language === "zh-CN"
-          ? "更温暖、自然，也更愿意解释上下文。"
-          : "Warmer, more conversational, and more willing to explain context.",
-    },
-    {
-      id: "pragmatic",
-      title: language === "zh-CN" ? "务实" : "Pragmatic",
-      detail:
-        language === "zh-CN"
-          ? "直接、紧凑，优先给出可执行结论。"
-          : "Direct and compact, prioritizing actionable outcomes.",
-    },
-  ];
-  return (
-    <div className={styles.stack}>
-      {!settings?.supported ? (
-        <PanelNotice>
-          {language === "zh-CN"
-            ? "当前模型不支持 personality。请选择支持该能力的 Codex 模型。"
-            : "The current model does not support personality. Choose a compatible Codex model first."}
-        </PanelNotice>
-      ) : null}
-      {error ? <PanelError message={error} /> : null}
-      <div className={styles.choiceGrid}>
-        {choices.map((choice) => (
-          <button
-            type="button"
-            className={
-              settings?.personality === choice.id ? styles.selectedChoice : ""
-            }
-            disabled={Boolean(busy) || !settings?.supported}
-            key={choice.id}
-            onClick={() => void select(choice.id)}
-          >
-            <span>
-              <strong>{choice.title}</strong>
-              <small>{choice.detail}</small>
-            </span>
-            {busy === choice.id ? (
-              <LoaderCircle className={styles.spin} size={17} />
-            ) : settings?.personality === choice.id ? (
-              <Check size={17} />
-            ) : null}
-          </button>
-        ))}
-      </div>
-      <PanelFootnote>
-        {sessionId
-          ? "The choice is saved to Codex config and queued on this loaded Thread."
-          : "The choice is saved to this Environment's native Codex config."}
-      </PanelFootnote>
-    </div>
-  );
-}
-
-function UsagePanel({
-  language,
-  environmentId,
-  initialView,
-}: {
-  language: OperationLanguage;
-  environmentId: string;
-  initialView: CodexTokenUsageView;
-}) {
-  const [usage, setUsage] = useState<CodexTokenUsage>();
-  const [view, setView] = useState(initialView);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState("");
-  const load = useCallback(async () => {
-    setLoading(true);
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<CodexTokenUsage>>(
-        `/api/v1/environments/${encodeURIComponent(environmentId)}/harnesses/codex/token-usage`,
-      );
-      setUsage(response.data);
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not load Codex token activity."));
-    } finally {
-      setLoading(false);
-    }
-  }, [environmentId]);
-
-  useEffect(() => void load(), [load]);
-  const points = useMemo(
-    () => (usage ? codexTokenUsagePoints(usage, view) : []),
-    [usage, view],
-  );
-  const maximum = Math.max(1, ...points.map((point) => point.value));
-
-  if (loading && !usage) return <PanelLoading label="Loading token activity…" />;
-  return (
-    <div className={styles.stack}>
-      <div className={styles.toolbar}>
-        <div className={styles.segmented} aria-label="Token activity view">
-          {(["daily", "weekly", "cumulative"] as const).map((candidate) => (
-            <button
-              type="button"
-              aria-pressed={view === candidate}
-              key={candidate}
-              onClick={() => setView(candidate)}
-            >
-              {candidate}
-            </button>
-          ))}
-        </div>
-        <button
-          type="button"
-          className={styles.iconButton}
-          aria-label={language === "zh-CN" ? "刷新用量" : "Refresh usage"}
-          disabled={loading}
-          onClick={() => void load()}
-        >
-          <RefreshCw className={loading ? styles.spin : ""} size={16} />
-        </button>
-      </div>
-      {error ? <PanelError message={error} /> : null}
-      {usage ? (
-        <>
-          <div className={styles.summaryGrid}>
-            <SummaryMetric
-              label={language === "zh-CN" ? "累计" : "Lifetime"}
-              value={formatTokens(usage.summary.lifetimeTokens)}
-            />
-            <SummaryMetric
-              label={language === "zh-CN" ? "单日峰值" : "Daily peak"}
-              value={formatTokens(usage.summary.peakDailyTokens)}
-            />
-            <SummaryMetric
-              label={language === "zh-CN" ? "连续天数" : "Current streak"}
-              value={
-                usage.summary.currentStreakDays === null
-                  ? "—"
-                  : `${usage.summary.currentStreakDays}d`
-              }
-            />
-            <SummaryMetric
-              label={language === "zh-CN" ? "最长任务" : "Longest task"}
-              value={formatDuration(usage.summary.longestRunningTurnSec)}
-            />
-          </div>
-          {points.length ? (
-            <div className={styles.chart} aria-label={`${view} token activity`}>
-              {points.map((point) => (
-                <span
-                  className={styles.barColumn}
-                  title={`${point.label}: ${point.value.toLocaleString()} tokens`}
-                  key={point.label}
-                >
-                  <i
-                    style={{
-                      height: `${Math.max(3, (point.value / maximum) * 100)}%`,
-                    }}
-                  />
-                </span>
-              ))}
-            </div>
-          ) : (
-            <PanelEmpty>
-              {language === "zh-CN"
-                ? "Codex 尚未返回每日 token 活动。"
-                : "Codex has not returned daily token activity yet."}
-            </PanelEmpty>
-          )}
-          {points.length ? (
-            <div className={styles.chartCaption}>
-              <span>{points[0]?.label}</span>
-              <span>{points.at(-1)?.label}</span>
-            </div>
-          ) : null}
-        </>
-      ) : null}
-      <PanelFootnote>
-        This is account token activity from <code>account/usage/read</code>, not
-        Sandpi Sandbox billing usage.
-      </PanelFootnote>
-    </div>
-  );
-}
-
-function MemoriesPanel({
-  language,
-  environmentId,
-  sessionId,
-}: {
-  language: OperationLanguage;
-  environmentId: string;
-  sessionId?: string;
-}) {
-  const [settings, setSettings] = useState<CodexMemoriesSettings>();
-  const [draft, setDraft] = useState<CodexMemoriesSettings>();
-  const [loading, setLoading] = useState(true);
-  const [saving, setSaving] = useState(false);
-  const [resetting, setResetting] = useState(false);
-  const [confirmReset, setConfirmReset] = useState(false);
-  const [notice, setNotice] = useState("");
-  const [error, setError] = useState("");
-  const endpoint = sessionId
-    ? `/api/v1/sessions/${encodeURIComponent(sessionId)}/memories`
-    : `/api/v1/environments/${encodeURIComponent(environmentId)}/harnesses/codex/memories`;
-
-  useEffect(() => {
-    const controller = new AbortController();
-    void apiFetch<ApiEnvelope<CodexMemoriesSettings>>(endpoint, {
-      signal: controller.signal,
-    })
-      .then((response) => {
-        setSettings(response.data);
-        setDraft(response.data);
-      })
-      .catch((cause) => {
-        if (!controller.signal.aborted) {
-          setError(errorMessage(cause, "Could not read Codex memories."));
-        }
-      })
-      .finally(() => {
-        if (!controller.signal.aborted) setLoading(false);
-      });
-    return () => controller.abort();
-  }, [endpoint]);
-
-  async function save() {
-    if (!draft || saving) return;
-    setSaving(true);
-    setError("");
-    setNotice("");
-    try {
-      const response = await apiFetch<ApiEnvelope<CodexMemoriesSettings>>(
-        endpoint,
-        { method: "PUT", body: JSON.stringify(draft) },
-      );
-      setSettings(response.data);
-      setDraft(response.data);
-      setNotice(
-        language === "zh-CN"
-          ? "Codex 记忆设置已保存。"
-          : "Codex memory settings were saved.",
-      );
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not update Codex memories."));
-    } finally {
-      setSaving(false);
-    }
-  }
-
-  async function reset() {
-    if (!confirmReset || resetting) return;
-    setResetting(true);
-    setError("");
-    try {
-      await apiFetch(
-        `/api/v1/environments/${encodeURIComponent(environmentId)}/harnesses/codex/memories`,
-        { method: "DELETE" },
-      );
-      setConfirmReset(false);
-      setNotice(
-        language === "zh-CN"
-          ? "本环境中的 Codex 本地记忆已清除。"
-          : "Local Codex memories were cleared for this Environment.",
-      );
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not reset Codex memories."));
-    } finally {
-      setResetting(false);
-    }
-  }
-
-  if (loading) return <PanelLoading label="Loading memory settings…" />;
-  if (!draft) return <PanelError message={error || "Memories unavailable."} />;
-  const changed = JSON.stringify(settings) !== JSON.stringify(draft);
-  return (
-    <div className={styles.stack}>
-      {error ? <PanelError message={error} /> : null}
-      {notice ? <PanelNotice>{notice}</PanelNotice> : null}
-      <SettingRow
-        title={language === "zh-CN" ? "启用 Memories" : "Enable memories"}
-        detail={
-          language === "zh-CN"
-            ? "开启时同步启用记忆读取和写入，关闭时同步禁用两者。"
-            : "Turn memory reading and writing on or off together."
-        }
-        checked={draft.featureEnabled}
-        onChange={(featureEnabled) =>
-          setDraft(codexMemoriesFeatureToggleSettings(featureEnabled))
-        }
-      />
-      <SettingRow
-        title={language === "zh-CN" ? "使用记忆" : "Use memories"}
-        detail={
-          language === "zh-CN"
-            ? "将已整理的记忆作为未来任务的参考上下文。"
-            : "Use consolidated memories as reference context for future work."
-        }
-        checked={draft.useMemories}
-        disabled={!draft.featureEnabled}
-        onChange={(useMemories) =>
-          setDraft((current) =>
-            current ? { ...current, useMemories } : current,
-          )
-        }
-      />
-      <SettingRow
-        title={language === "zh-CN" ? "生成记忆" : "Generate memories"}
-        detail={
-          language === "zh-CN"
-            ? "允许符合条件的 Session 产生新的本地记忆。"
-            : "Allow eligible Sessions to produce new local memories."
-        }
-        checked={draft.generateMemories}
-        disabled={!draft.featureEnabled}
-        onChange={(generateMemories) =>
-          setDraft((current) =>
-            current ? { ...current, generateMemories } : current,
-          )
-        }
-      />
-      <div className={styles.actionRow}>
-        <button
-          type="button"
-          className={styles.primaryButton}
-          disabled={!changed || saving}
-          onClick={() => void save()}
-        >
-          {saving ? <LoaderCircle className={styles.spin} size={14} /> : null}
-          {language === "zh-CN" ? "保存设置" : "Save settings"}
-        </button>
-        {!confirmReset ? (
-          <button
-            type="button"
-            className={styles.dangerButton}
-            onClick={() => setConfirmReset(true)}
-          >
-            <Trash2 size={14} />
-            {language === "zh-CN" ? "重置记忆" : "Reset memories"}
-          </button>
-        ) : (
-          <>
-            <span className={styles.confirmText}>
-              {language === "zh-CN"
-                ? "确认清除所有本地记忆？"
-                : "Clear all local memories?"}
-            </span>
-            <button
-              type="button"
-              className={styles.dangerButton}
-              disabled={resetting}
-              onClick={() => void reset()}
-            >
-              {resetting ? (
-                <LoaderCircle className={styles.spin} size={14} />
-              ) : null}
-              {language === "zh-CN" ? "确认清除" : "Confirm reset"}
-            </button>
-            <button type="button" onClick={() => setConfirmReset(false)}>
-              {language === "zh-CN" ? "取消" : "Cancel"}
-            </button>
-          </>
-        )}
-      </div>
-    </div>
-  );
-}
-
-function HooksPanel({
-  language,
-  environmentId,
-}: {
-  language: OperationLanguage;
-  environmentId: string;
-}) {
-  const [inventory, setInventory] = useState<CodexHooksInventory>();
-  const [loading, setLoading] = useState(true);
-  const [busyKey, setBusyKey] = useState("");
-  const [error, setError] = useState("");
-  const endpoint = `/api/v1/environments/${encodeURIComponent(environmentId)}/harnesses/codex/hooks`;
-  const load = useCallback(async () => {
-    setLoading(true);
-    setError("");
-    try {
-      const response =
-        await apiFetch<ApiEnvelope<CodexHooksInventory>>(endpoint);
-      setInventory(response.data);
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not load Codex hooks."));
-    } finally {
-      setLoading(false);
-    }
-  }, [endpoint]);
-
-  useEffect(() => void load(), [load]);
-
-  async function update(
-    key: string,
-    update: { enabled?: boolean; trustedHash?: string },
-  ) {
-    if (busyKey) return;
-    setBusyKey(key);
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<CodexHooksInventory>>(
-        endpoint,
-        {
-          method: "PUT",
-          body: JSON.stringify({ key, ...update }),
-        },
-      );
-      setInventory(response.data);
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not update the Codex hook."));
-    } finally {
-      setBusyKey("");
-    }
-  }
-
-  if (loading && !inventory) return <PanelLoading label="Loading hooks…" />;
-  return (
-    <div className={styles.stack}>
-      <div className={styles.toolbar}>
-        <span>
-          {inventory
-            ? `${inventory.hooks.length} ${inventory.hooks.length === 1 ? "hook" : "hooks"}`
-            : "Hooks"}
-        </span>
-        <button
-          type="button"
-          className={styles.iconButton}
-          aria-label={language === "zh-CN" ? "刷新 hooks" : "Refresh hooks"}
-          disabled={loading}
-          onClick={() => void load()}
-        >
-          <RefreshCw className={loading ? styles.spin : ""} size={16} />
-        </button>
-      </div>
-      {error ? <PanelError message={error} /> : null}
-      {inventory?.warnings.map((warning) => (
-        <PanelNotice key={warning}>{warning}</PanelNotice>
-      ))}
-      {inventory?.errors.map((issue) => (
-        <PanelError
-          key={`${issue.path ?? ""}:${issue.message}`}
-          message={`${issue.message}${issue.path ? ` · ${issue.path}` : ""}`}
-        />
-      ))}
-      {inventory?.hooks.length ? (
-        <div className={styles.hookList}>
-          {inventory.hooks.map((hook) => {
-            const needsTrust =
-              hook.trustStatus === "untrusted" ||
-              hook.trustStatus === "modified";
-            return (
-              <article className={styles.hookRow} key={hook.key}>
-                <div className={styles.hookMain}>
-                  <div className={styles.hookHeading}>
-                    <strong>{hook.eventName}</strong>
-                    <span>{hook.handlerType}</span>
-                    <span data-tone={needsTrust ? "warning" : "neutral"}>
-                      {hook.trustStatus}
-                    </span>
-                  </div>
-                  <code>{hook.command ?? hook.key}</code>
-                  <small>
-                    {[hook.source, hook.matcher, hook.sourcePath]
-                      .filter(Boolean)
-                      .join(" · ")}
-                  </small>
-                </div>
-                <div className={styles.hookActions}>
-                  {needsTrust ? (
-                    <button
-                      type="button"
-                      disabled={Boolean(busyKey) || hook.isManaged}
-                      onClick={() =>
-                        void update(hook.key, {
-                          trustedHash: hook.currentHash,
-                        })
-                      }
-                    >
-                      {busyKey === hook.key ? (
-                        <LoaderCircle className={styles.spin} size={13} />
-                      ) : null}
-                      {language === "zh-CN" ? "信任" : "Trust"}
-                    </button>
-                  ) : null}
-                  <NativeSwitch
-                    checked={hook.enabled}
-                    disabled={
-                      Boolean(busyKey) || hook.isManaged || needsTrust
-                    }
-                    label={`${hook.enabled ? "Disable" : "Enable"} ${hook.eventName}`}
-                    onChange={(enabled) =>
-                      void update(hook.key, { enabled })
-                    }
-                  />
-                </div>
-              </article>
-            );
-          })}
-        </div>
-      ) : (
-        <PanelEmpty>
-          {language === "zh-CN"
-            ? "当前 Workspace 未发现 Codex hooks。"
-            : "No Codex hooks were discovered for this Workspace."}
-        </PanelEmpty>
-      )}
-      <PanelFootnote>
-        Unmanaged hook definitions must be trusted at their current hash before
-        Codex can run them.
-      </PanelFootnote>
-    </div>
-  );
-}
-
-function ProcessesPanel({
-  language,
-  sessionId,
-}: {
-  language: OperationLanguage;
-  sessionId: string;
-}) {
-  const [inventory, setInventory] = useState<CodexBackgroundTerminals>();
-  const [loading, setLoading] = useState(true);
-  const [busy, setBusy] = useState("");
-  const [error, setError] = useState("");
-  const endpoint = `/api/v1/sessions/${encodeURIComponent(sessionId)}/background-terminals`;
-  const load = useCallback(async () => {
-    setLoading(true);
-    setError("");
-    try {
-      const response =
-        await apiFetch<ApiEnvelope<CodexBackgroundTerminals>>(endpoint);
-      setInventory(response.data);
-    } catch (cause) {
-      setError(
-        errorMessage(cause, "Could not load Codex background terminals."),
-      );
-    } finally {
-      setLoading(false);
-    }
-  }, [endpoint]);
-  useEffect(() => void load(), [load]);
-
-  async function terminate(processId: string) {
-    if (busy) return;
-    setBusy(processId);
-    setError("");
-    try {
-      await apiFetch(`${endpoint}/${encodeURIComponent(processId)}`, {
-        method: "DELETE",
-      });
-      await load();
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not stop the background terminal."));
-    } finally {
-      setBusy("");
-    }
-  }
-
-  async function clean() {
-    if (busy) return;
-    setBusy("*");
-    setError("");
-    try {
-      await apiFetch(endpoint, { method: "DELETE" });
-      setInventory({ terminals: [] });
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not stop background terminals."));
-    } finally {
-      setBusy("");
-    }
-  }
-
-  if (loading && !inventory) {
-    return <PanelLoading label="Loading background terminals…" />;
-  }
-  return (
-    <div className={styles.stack}>
-      <div className={styles.toolbar}>
-        <span>
-          {inventory?.terminals.length ?? 0}{" "}
-          {language === "zh-CN" ? "个后台终端" : "background terminals"}
-        </span>
-        <div className={styles.toolbarActions}>
-          <button
-            type="button"
-            className={styles.iconButton}
-            aria-label={language === "zh-CN" ? "刷新" : "Refresh"}
-            disabled={loading || Boolean(busy)}
-            onClick={() => void load()}
-          >
-            <RefreshCw className={loading ? styles.spin : ""} size={16} />
-          </button>
-          <button
-            type="button"
-            className={styles.dangerButton}
-            disabled={!inventory?.terminals.length || Boolean(busy)}
-            onClick={() => void clean()}
-          >
-            {busy === "*" ? (
-              <LoaderCircle className={styles.spin} size={13} />
-            ) : (
-              <Trash2 size={13} />
-            )}
-            {language === "zh-CN" ? "全部停止" : "Stop all"}
-          </button>
-        </div>
-      </div>
-      {error ? <PanelError message={error} /> : null}
-      {inventory?.terminals.length ? (
-        <div className={styles.processList}>
-          {inventory.terminals.map((terminal) => (
-            <article className={styles.processRow} key={terminal.processId}>
-              <span className={styles.processId}>{terminal.processId}</span>
-              <div>
-                <code>{terminal.command}</code>
-                <small>
-                  {terminal.cwd}
-                  {terminal.osPid !== null ? ` · PID ${terminal.osPid}` : ""}
-                  {terminal.cpuPercent !== null
-                    ? ` · ${terminal.cpuPercent.toFixed(1)}% CPU`
-                    : ""}
-                  {terminal.rssKb !== null
-                    ? ` · ${formatBytes(terminal.rssKb * 1024)}`
-                    : ""}
-                </small>
-              </div>
-              <button
-                type="button"
-                disabled={Boolean(busy)}
-                onClick={() => void terminate(terminal.processId)}
-              >
-                {busy === terminal.processId ? (
-                  <LoaderCircle className={styles.spin} size={13} />
-                ) : null}
-                {language === "zh-CN" ? "停止" : "Stop"}
-              </button>
-            </article>
-          ))}
-        </div>
-      ) : (
-        <PanelEmpty>
-          {language === "zh-CN"
-            ? "当前 Thread 没有后台终端。"
-            : "This Thread has no background terminals."}
-        </PanelEmpty>
-      )}
-    </div>
-  );
-}
-
-interface GoalProjection {
-  goal: {
-    objective: string;
-    status: string;
-    tokenBudget: number | null;
-    tokensUsed: number;
-    timeUsedSeconds: number;
-  } | null;
-}
-
-function GoalPanel({
-  language,
-  sessionId,
-  editImmediately,
-}: {
-  language: OperationLanguage;
-  sessionId: string;
-  editImmediately: boolean;
-}) {
-  const inputRef = useRef<HTMLTextAreaElement>(null);
-  const [projection, setProjection] = useState<GoalProjection>();
-  const [objective, setObjective] = useState("");
-  const [loading, setLoading] = useState(true);
-  const [busy, setBusy] = useState("");
-  const [error, setError] = useState("");
-  const endpoint = `/api/v1/sessions/${encodeURIComponent(sessionId)}/goal`;
-  useEffect(() => {
-    const controller = new AbortController();
-    void apiFetch<ApiEnvelope<GoalProjection>>(endpoint, {
-      signal: controller.signal,
-    })
-      .then((response) => {
-        setProjection(response.data);
-        setObjective(response.data.goal?.objective ?? "");
-        if (editImmediately) {
-          window.requestAnimationFrame(() => {
-            inputRef.current?.focus();
-            inputRef.current?.select();
-          });
-        }
-      })
-      .catch((cause) => {
-        if (!controller.signal.aborted) {
-          setError(errorMessage(cause, "Could not load the Codex goal."));
-        }
-      })
-      .finally(() => {
-        if (!controller.signal.aborted) setLoading(false);
-      });
-    return () => controller.abort();
-  }, [editImmediately, endpoint]);
-
-  async function update(
-    body: { objective?: string; status?: "active" | "paused" },
-    action: string,
-  ) {
-    if (busy) return;
-    setBusy(action);
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<GoalProjection>>(endpoint, {
-        method: "PUT",
-        body: JSON.stringify(body),
-      });
-      setProjection(response.data);
-      setObjective(response.data.goal?.objective ?? "");
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not update the Codex goal."));
-    } finally {
-      setBusy("");
-    }
-  }
-
-  async function clear() {
-    if (busy) return;
-    setBusy("clear");
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<GoalProjection>>(endpoint, {
-        method: "DELETE",
-      });
-      setProjection(response.data);
-      setObjective("");
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not clear the Codex goal."));
-    } finally {
-      setBusy("");
-    }
-  }
-
-  if (loading) return <PanelLoading label="Loading goal…" />;
-  return (
-    <div className={styles.stack}>
-      {error ? <PanelError message={error} /> : null}
-      {projection?.goal ? (
-        <div className={styles.goalStatus}>
-          <span data-status={projection.goal.status}>
-            {projection.goal.status}
-          </span>
-          <small>
-            {projection.goal.tokenBudget === null
-              ? `${projection.goal.tokensUsed.toLocaleString()} tokens`
-              : `${projection.goal.tokensUsed.toLocaleString()} / ${projection.goal.tokenBudget.toLocaleString()} tokens`}
-            {" · "}
-            {formatDuration(projection.goal.timeUsedSeconds)}
-          </small>
-        </div>
-      ) : (
-        <PanelNotice>
-          {language === "zh-CN"
-            ? "当前 Thread 还没有目标。"
-            : "This Thread does not have a goal yet."}
-        </PanelNotice>
-      )}
-      <label className={styles.field}>
-        <span>{language === "zh-CN" ? "目标" : "Objective"}</span>
-        <textarea
-          ref={inputRef}
-          rows={5}
-          maxLength={10_000}
-          value={objective}
-          placeholder={
-            language === "zh-CN"
-              ? "描述需要持续推进的目标…"
-              : "Describe the objective Codex should keep pursuing…"
-          }
-          onChange={(event) => setObjective(event.target.value)}
-        />
-      </label>
-      <div className={styles.actionRow}>
-        <button
-          type="button"
-          className={styles.primaryButton}
-          disabled={!objective.trim() || Boolean(busy)}
-          onClick={() =>
-            void update({ objective: objective.trim() }, "objective")
-          }
-        >
-          {busy === "objective" ? (
-            <LoaderCircle className={styles.spin} size={14} />
-          ) : null}
-          {projection?.goal
-            ? language === "zh-CN"
-              ? "保存目标"
-              : "Save objective"
-            : language === "zh-CN"
-              ? "创建目标"
-              : "Create goal"}
-        </button>
-        {projection?.goal ? (
-          <>
-            <button
-              type="button"
-              disabled={Boolean(busy)}
-              onClick={() =>
-                void update(
-                  {
-                    status:
-                      projection.goal?.status === "active"
-                        ? "paused"
-                        : "active",
-                  },
-                  "status",
-                )
-              }
-            >
-              {busy === "status" ? (
-                <LoaderCircle className={styles.spin} size={14} />
-              ) : null}
-              {projection.goal.status === "active"
-                ? language === "zh-CN"
-                  ? "暂停"
-                  : "Pause"
-                : language === "zh-CN"
-                  ? "恢复"
-                  : "Resume"}
-            </button>
-            <button
-              type="button"
-              className={styles.dangerButton}
-              disabled={Boolean(busy)}
-              onClick={() => void clear()}
-            >
-              {busy === "clear" ? (
-                <LoaderCircle className={styles.spin} size={14} />
-              ) : (
-                <Trash2 size={14} />
-              )}
-              {language === "zh-CN" ? "清除" : "Clear"}
-            </button>
-          </>
-        ) : null}
-      </div>
-    </div>
-  );
-}
-
-function RenamePanel({
-  language,
-  session,
-  onSessionChange,
-  onClose,
-}: {
-  language: OperationLanguage;
-  session: CodexSession;
-  onSessionChange?: (session: CodexSession) => void;
-  onClose: () => void;
-}) {
-  const inputRef = useRef<HTMLInputElement>(null);
-  const [name, setName] = useState(session.title);
-  const [saving, setSaving] = useState(false);
-  const [error, setError] = useState("");
-  useEffect(() => {
-    inputRef.current?.focus();
-    inputRef.current?.select();
-  }, []);
-
-  async function save() {
-    const normalized = name.trim();
-    if (!normalized || saving) return;
-    setSaving(true);
-    setError("");
-    try {
-      const response = await apiFetch<ApiEnvelope<CodexSession>>(
-        `/api/v1/sessions/${encodeURIComponent(session.id)}/metadata`,
-        {
-          method: "PUT",
-          body: JSON.stringify({ title: normalized }),
-        },
-      );
-      onSessionChange?.(response.data);
-      onClose();
-    } catch (cause) {
-      setError(errorMessage(cause, "Could not rename the Session."));
-      setSaving(false);
-    }
-  }
-
-  return (
-    <form
-      className={styles.stack}
-      onSubmit={(event) => {
-        event.preventDefault();
-        void save();
-      }}
-    >
-      {error ? <PanelError message={error} /> : null}
-      <label className={styles.field}>
-        <span>{language === "zh-CN" ? "Session 名称" : "Session name"}</span>
-        <input
-          ref={inputRef}
-          maxLength={200}
-          value={name}
-          onChange={(event) => setName(event.target.value)}
-        />
-      </label>
-      <div className={styles.actionRow}>
-        <button
-          type="submit"
-          className={styles.primaryButton}
-          disabled={!name.trim() || saving}
-        >
-          {saving ? <LoaderCircle className={styles.spin} size={14} /> : null}
-          {language === "zh-CN" ? "保存" : "Save"}
-        </button>
-        <button type="button" onClick={onClose}>
-          {language === "zh-CN" ? "取消" : "Cancel"}
-        </button>
-      </div>
-    </form>
-  );
-}
-
-function SettingRow({
-  title,
-  detail,
-  checked,
-  disabled = false,
-  onChange,
-}: {
-  title: string;
-  detail: string;
-  checked: boolean;
-  disabled?: boolean;
-  onChange: (checked: boolean) => void;
-}) {
-  return (
-    <div className={styles.settingRow}>
-      <span>
-        <strong>{title}</strong>
-        <small>{detail}</small>
-      </span>
-      <NativeSwitch
-        checked={checked}
-        disabled={disabled}
-        label={title}
-        onChange={onChange}
-      />
-    </div>
-  );
-}
-
-function NativeSwitch({
-  checked,
-  disabled = false,
-  label,
-  onChange,
-}: {
-  checked: boolean;
-  disabled?: boolean;
-  label: string;
-  onChange: (checked: boolean) => void;
-}) {
-  return (
-    <button
-      type="button"
-      role="switch"
-      aria-checked={checked}
-      aria-label={label}
-      className={styles.switch}
-      data-checked={checked ? "true" : "false"}
-      disabled={disabled}
-      onClick={() => onChange(!checked)}
-    >
-      <span />
-    </button>
-  );
-}
-
-function SummaryMetric({ label, value }: { label: string; value: string }) {
-  return (
-    <div className={styles.summaryMetric}>
-      <small>{label}</small>
-      <strong>{value}</strong>
-    </div>
-  );
-}
-
-function PanelLoading({ label }: { label: string }) {
-  return (
-    <div className={styles.loading} role="status">
-      <LoaderCircle className={styles.spin} size={18} />
-      <span>{label}</span>
-    </div>
-  );
-}
-
-function PanelError({ message }: { message: string }) {
-  return (
-    <div className={styles.error} role="alert">
-      {message}
-    </div>
-  );
-}
-
-function PanelNotice({ children }: { children: ReactNode }) {
-  return <div className={styles.notice}>{children}</div>;
-}
-
-function PanelEmpty({ children }: { children: ReactNode }) {
-  return <div className={styles.empty}>{children}</div>;
-}
-
-function PanelFootnote({ children }: { children: ReactNode }) {
-  return <p className={styles.footnote}>{children}</p>;
-}
-
-function errorMessage(error: unknown, fallback: string) {
-  return error instanceof Error ? error.message : fallback;
-}
-
-function formatTokens(value: number | null) {
-  if (value === null) return "—";
-  if (value >= 1_000_000_000) return `${(value / 1_000_000_000).toFixed(1)}B`;
-  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
-  if (value >= 1_000) return `${(value / 1_000).toFixed(1)}K`;
-  return value.toLocaleString();
-}
-
-function formatDuration(value: number | null) {
-  if (value === null) return "—";
-  if (value < 60) return `${value}s`;
-  if (value < 3_600) return `${Math.floor(value / 60)}m ${value % 60}s`;
-  const hours = Math.floor(value / 3_600);
-  const minutes = Math.floor((value % 3_600) / 60);
-  return `${hours}h ${minutes}m`;
-}
-
-function formatBytes(value: number) {
-  if (value >= 1024 ** 3) return `${(value / 1024 ** 3).toFixed(1)} GiB`;
-  if (value >= 1024 ** 2) return `${(value / 1024 ** 2).toFixed(1)} MiB`;
-  return `${Math.round(value / 1024)} KiB`;
-}
diff --git a/src/harnesses/codex/new-session-workspace.tsx b/src/harnesses/codex/new-session-workspace.tsx
index 8d8ea3e..e4c4f88 100644
--- a/src/harnesses/codex/new-session-workspace.tsx
+++ b/src/harnesses/codex/new-session-workspace.tsx
@@ -15,24 +15,11 @@ import {
 } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
 
-import type {
-  EnvironmentSettingsOpenOptions,
-  EnvironmentSettingsTab,
-} from "@/components/environment-settings";
 import {
   CodexComposer,
   encodeCodexComposerLocalImages,
 } from "@/harnesses/codex/composer";
 import { insertCodexFileMentions } from "@/harnesses/codex/file-mentions";
-import {
-  CodexSlashCommandMenu,
-  useCodexSlashCommandMenu,
-} from "@/harnesses/codex/slash-command-menu";
-import {
-  CODEX_INIT_COMMAND_PROMPT,
-  parseCodexSlashInvocation,
-  type CodexSlashCommand,
-} from "@/harnesses/codex/slash-commands";
 import {
   shouldSubmitComposer,
   type OperationLanguage,
@@ -58,11 +45,6 @@ import {
   reconcileCodexComposerPreference,
   type CodexModelOption,
 } from "@/harnesses/codex/models";
-import {
-  CodexNativeCommandDialog,
-  type CodexNativeDialogMode,
-} from "@/harnesses/codex/native-command-dialog";
-import { parseCodexTokenUsageView } from "@/harnesses/codex/token-usage";
 import {
   beginSessionCreation,
   failSessionCreation,
@@ -87,13 +69,7 @@ interface NewSessionWorkspaceProps {
   canManageEnvironment: boolean;
   onEnvironmentChange: (environment: Environment) => void;
   onCreated: (session: CodexSession) => void;
-  initialTitle?: string;
-  sessionStartSource?: "startup" | "clear";
   onOpenAgentHarnessSettings: () => void;
-  onOpenEnvironmentSettings: (
-    tab: EnvironmentSettingsTab,
-    options?: EnvironmentSettingsOpenOptions,
-  ) => void;
   onToggleSidebar: () => void;
   inspectorOpen: boolean;
   onToggleInspector: () => void;
@@ -102,13 +78,6 @@ interface NewSessionWorkspaceProps {
   onOpenWorkspacePath: (path: string) => void;
 }
 
-interface CreateCodexSessionOptions {
-  instruction?: string;
-  collaborationMode?: "plan";
-  bypassSlash?: boolean;
-  restorePrompt?: string;
-}
-
 export function CodexNewSessionWorkspace({
   language,
   sendShortcut,
@@ -116,10 +85,7 @@ export function CodexNewSessionWorkspace({
   canManageEnvironment,
   onEnvironmentChange,
   onCreated,
-  initialTitle,
-  sessionStartSource,
   onOpenAgentHarnessSettings,
-  onOpenEnvironmentSettings,
   onToggleSidebar,
   inspectorOpen,
   onToggleInspector,
@@ -146,13 +112,7 @@ export function CodexNewSessionWorkspace({
     tone: "info" | "error";
     message: string;
   } | null>(null);
-  const [planMode, setPlanMode] = useState(false);
   const [fastMode, setFastMode] = useState(false);
-  const [mentionOpenRequest, setMentionOpenRequest] = useState(0);
-  const [nativeDialog, setNativeDialog] = useState<{
-    mode: CodexNativeDialogMode;
-    usageView?: "daily" | "weekly" | "cumulative";
-  }>();
   const [images, setImages] = useState<CodexComposerImage[]>([]);
   const [localImages, setLocalImages] = useState<CodexComposerLocalImage[]>([]);
   const promptRef = useRef<HTMLTextAreaElement>(null);
@@ -164,13 +124,6 @@ export function CodexNewSessionWorkspace({
     selectedModel,
     selectedModel ? reasoningEfforts[selectedModel.id] : undefined,
   );
-  const slashMenu = useCodexSlashCommandMenu({
-    value: prompt,
-    context: "new-session",
-    onComplete: setComposerPrompt,
-    onExecute: (command) => void executeSlashCommand(command, ""),
-  });
-
   useEffect(() => {
     if (!window.matchMedia("(min-width: 641px)").matches) {
       return;
@@ -200,9 +153,7 @@ export function CodexNewSessionWorkspace({
     setModelCatalogError("");
     setModelCatalogState("idle");
     setCommandNotice(null);
-    setPlanMode(false);
     setFastMode(false);
-    setMentionOpenRequest(0);
     if (
       environment.status !== "ready" ||
       environment.codingAgent.status !== "connected"
@@ -304,21 +255,6 @@ export function CodexNewSessionWorkspace({
     });
   }
 
-  function setComposerPrompt(value: string) {
-    setPrompt(value);
-    window.requestAnimationFrame(() => {
-      const textarea = promptRef.current;
-      if (!textarea) return;
-      textarea.focus();
-      textarea.setSelectionRange(value.length, value.length);
-    });
-  }
-
-  function clearComposerPrompt() {
-    setPrompt("");
-    window.requestAnimationFrame(() => promptRef.current?.focus());
-  }
-
   async function openAgentsFile() {
     if (openingAgentsFile) return;
     setOpeningAgentsFile(true);
@@ -337,142 +273,7 @@ export function CodexNewSessionWorkspace({
     }
   }
 
-  async function executeSlashCommand(
-    command: CodexSlashCommand,
-    argumentsValue: string,
-  ) {
-    clearComposerPrompt();
-    setCommandNotice(null);
-    setError("");
-    if (command.intent === "composer.mention") {
-      setMentionOpenRequest((request) => request + 1);
-      return;
-    }
-    if (command.intent === "environment.skills") {
-      onOpenEnvironmentSettings("skills");
-      return;
-    }
-    if (command.intent === "environment.mcp") {
-      if (argumentsValue && argumentsValue.toLowerCase() !== "verbose") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? "/mcp 仅支持可选参数 verbose。"
-              : "/mcp only accepts the optional verbose argument.",
-        });
-        return;
-      }
-      onOpenEnvironmentSettings("mcp", {
-        mcpVerbose: argumentsValue.toLowerCase() === "verbose",
-      });
-      return;
-    }
-    if (command.intent === "environment.network") {
-      onOpenEnvironmentSettings("network");
-      return;
-    }
-    if (command.intent === "environment.credentials") {
-      onOpenEnvironmentSettings("credentials");
-      return;
-    }
-    if (
-      command.intent === "codex.personality" ||
-      command.intent === "codex.memories" ||
-      command.intent === "codex.hooks"
-    ) {
-      setNativeDialog({
-        mode:
-          command.intent === "codex.personality"
-            ? "personality"
-            : command.intent === "codex.memories"
-              ? "memories"
-              : "hooks",
-      });
-      return;
-    }
-    if (command.intent === "codex.usage") {
-      const view = parseCodexTokenUsageView(argumentsValue);
-      if (!view) {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? "/usage 参数必须是 daily、weekly 或 cumulative。"
-              : "/usage expects daily, weekly, or cumulative.",
-        });
-        return;
-      }
-      setNativeDialog({ mode: "usage", usageView: view });
-      return;
-    }
-    if (command.intent === "composer.plan") {
-      setPlanMode(true);
-      if (argumentsValue) {
-        await createSession({
-          instruction: argumentsValue,
-          collaborationMode: "plan",
-          bypassSlash: true,
-          restorePrompt: `/plan ${argumentsValue}`,
-        });
-      } else {
-        setCommandNotice({
-          tone: "info",
-          message:
-            language === "zh-CN"
-              ? "计划模式已开启，将应用到新 Session。"
-              : "Plan mode is active for the new Session.",
-        });
-      }
-      return;
-    }
-    if (command.intent === "codex.init") {
-      await createSession({
-        instruction: CODEX_INIT_COMMAND_PROMPT,
-        bypassSlash: true,
-        restorePrompt: "/init",
-      });
-    }
-  }
-
-  async function createSession(options: CreateCodexSessionOptions = {}) {
-    if (!options.bypassSlash) {
-      const invocation = parseCodexSlashInvocation(prompt, "new-session");
-      if (invocation.kind === "command") {
-        await executeSlashCommand(invocation.command, invocation.arguments);
-        return;
-      }
-      if (invocation.kind === "unknown") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `未知命令 /${invocation.name}。输入 / 查看可用命令。`
-              : `Unknown command /${invocation.name}. Type / to see available commands.`,
-        });
-        return;
-      }
-      if (invocation.kind === "unavailable") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `/${invocation.command.name} 需要先打开一个 Session。`
-              : `/${invocation.command.name} requires an active Session.`,
-        });
-        return;
-      }
-      if (invocation.kind === "missing-arguments") {
-        setCommandNotice({
-          tone: "error",
-          message:
-            language === "zh-CN"
-              ? `/${invocation.command.name} 缺少参数。`
-              : `/${invocation.command.name} requires an argument.`,
-        });
-        return;
-      }
-    }
+  async function createSession() {
     if (environment.status !== "ready") {
       setError(
         environment.status === "error"
@@ -493,7 +294,7 @@ export function CodexNewSessionWorkspace({
       setError(modelCatalogError || ui.waitForModels);
       return;
     }
-    const instruction = (options.instruction ?? prompt).trim();
+    const instruction = prompt.trim();
     if (!instruction && images.length === 0 && localImages.length === 0) {
       setError(ui.emptyInstruction(environment.codingAgent.label));
       promptRef.current?.focus();
@@ -502,8 +303,6 @@ export function CodexNewSessionWorkspace({
 
     const requestInput = {
       environmentId: environment.id,
-      ...(initialTitle?.trim() ? { title: initialTitle.trim() } : {}),
-      ...(sessionStartSource ? { sessionStartSource } : {}),
       prompt: instruction,
       images: images.map(encodeCodexComposerImage),
       localImages: encodeCodexComposerLocalImages(localImages),
@@ -511,13 +310,6 @@ export function CodexNewSessionWorkspace({
       ...(selectedReasoningEffort
         ? { reasoningEffort: selectedReasoningEffort }
         : {}),
-      ...((options.collaborationMode ?? (planMode ? "plan" : undefined))
-        ? {
-            collaborationMode:
-              options.collaborationMode ??
-              (planMode ? ("plan" as const) : undefined),
-          }
-        : {}),
       ...(fastMode && selectedModel.fastServiceTier
         ? { serviceTier: selectedModel.fastServiceTier.id }
         : {}),
@@ -549,9 +341,6 @@ export function CodexNewSessionWorkspace({
         isDefinitiveSessionCreationFailure(cause),
       );
       setError(cause instanceof Error ? cause.message : ui.startFailed);
-      if (options.restorePrompt) {
-        setComposerPrompt(options.restorePrompt);
-      }
       setCreating(false);
     }
   }
@@ -770,10 +559,6 @@ export function CodexNewSessionWorkspace({
         </div>
       </div>
       <div className={styles.composerRegion}>
-        {/*
-          Codex slash-command completion belongs in this Codex composer. Future harnesses
-          provide their own composer instead of registering commands in a shared catalog.
-        */}
         <CodexComposer
           className={styles.composer}
           language={language}
@@ -784,7 +569,6 @@ export function CodexNewSessionWorkspace({
             placeholder: ui.placeholder(environment.codingAgent.label),
             onChange: (event) => {
               setPrompt(event.target.value);
-              slashMenu.show();
               setCommandNotice(null);
               if (error && event.target.value.trim()) {
                 setError("");
@@ -798,7 +582,6 @@ export function CodexNewSessionWorkspace({
               void addImages(pasted);
             },
             onKeyDown: (event) => {
-              if (slashMenu.handleKeyDown(event)) return;
               if (
                 shouldSubmitComposer(
                   {
@@ -815,22 +598,7 @@ export function CodexNewSessionWorkspace({
                 void createSession();
               }
             },
-            "aria-controls":
-              slashMenu.commands.length > 0 ? slashMenu.id : undefined,
-            "aria-activedescendant": slashMenu.activeCommand
-              ? `${slashMenu.id}-${slashMenu.activeCommand.name}`
-              : undefined,
           }}
-          slashCommandMenu={
-            <CodexSlashCommandMenu
-              id={slashMenu.id}
-              language={language}
-              commands={slashMenu.commands}
-              activeIndex={slashMenu.activeIndex}
-              onActiveIndexChange={slashMenu.setActiveIndex}
-              onSelect={slashMenu.select}
-            />
-          }
           images={images}
           onRemoveImage={(id) => {
             setImages((current) =>
@@ -846,23 +614,6 @@ export function CodexNewSessionWorkspace({
             setError("");
           }}
           notice={commandNotice}
-          mode={
-            planMode
-              ? {
-                  label: language === "zh-CN" ? "计划模式" : "Plan mode",
-                  description:
-                    language === "zh-CN"
-                      ? "新 Session 使用 Codex 计划协作模式"
-                      : "The new Session uses Codex Plan collaboration mode",
-                  exitLabel:
-                    language === "zh-CN" ? "退出计划模式" : "Exit Plan mode",
-                  onExit: () => {
-                    setPlanMode(false);
-                    setCommandNotice(null);
-                  },
-                }
-              : null
-          }
           toolbar={{
             environmentId: environment.id,
             agentLabel: environment.codingAgent.label,
@@ -894,7 +645,6 @@ export function CodexNewSessionWorkspace({
               setFastMode(enabled);
               setCommandNotice(null);
             },
-            mentionOpenRequest,
             status: {
               state:
                 environment.codingAgent.status !== "connected" ||
@@ -939,15 +689,6 @@ export function CodexNewSessionWorkspace({
           }}
         />
       </div>
-      {nativeDialog ? (
-        <CodexNativeCommandDialog
-          mode={nativeDialog.mode}
-          language={language}
-          environmentId={environment.id}
-          initialUsageView={nativeDialog.usageView}
-          onClose={() => setNativeDialog(undefined)}
-        />
-      ) : null}
     </section>
   );
 }
diff --git a/src/harnesses/codex/slash-command-menu.tsx b/src/harnesses/codex/slash-command-menu.tsx
deleted file mode 100644
index 814e14a..0000000
--- a/src/harnesses/codex/slash-command-menu.tsx
+++ /dev/null
@@ -1,179 +0,0 @@
-"use client";
-
-import {
-  useEffect,
-  useId,
-  useMemo,
-  useRef,
-  useState,
-  type KeyboardEvent,
-} from "react";
-
-import {
-  codexSlashCommandCompletion,
-  codexSlashMenuCommands,
-  type CodexSlashCommand,
-  type CodexSlashCommandContext,
-} from "@/harnesses/codex/slash-commands";
-import type { OperationLanguage } from "@/lib/operation-ui";
-
-interface CodexSlashCommandMenuProps {
-  id: string;
-  language: OperationLanguage;
-  commands: readonly CodexSlashCommand[];
-  activeIndex: number;
-  onActiveIndexChange: (index: number) => void;
-  onSelect: (command: CodexSlashCommand) => void;
-}
-
-interface UseCodexSlashCommandMenuInput {
-  value: string;
-  context: CodexSlashCommandContext;
-  turnRunning?: boolean;
-  onComplete: (value: string) => void;
-  onExecute: (command: CodexSlashCommand) => void;
-}
-
-/**
- * Keeps completion, pointer selection and keyboard behavior identical across
- * the two Codex-owned composers without leaking slash commands into the
- * harness-neutral conversation dispatcher.
- */
-export function useCodexSlashCommandMenu({
-  value,
-  context,
-  turnRunning = false,
-  onComplete,
-  onExecute,
-}: UseCodexSlashCommandMenuInput) {
-  const id = useId();
-  const [activeIndex, setActiveIndex] = useState(0);
-  const [dismissed, setDismissed] = useState(false);
-  const commands = useMemo(
-    () =>
-      dismissed
-        ? []
-        : codexSlashMenuCommands(value, context, turnRunning),
-    [context, dismissed, turnRunning, value],
-  );
-  const resolvedActiveIndex = Math.min(
-    activeIndex,
-    Math.max(0, commands.length - 1),
-  );
-  const activeCommand = commands[resolvedActiveIndex];
-
-  useEffect(() => {
-    setActiveIndex(0);
-    setDismissed(false);
-  }, [value]);
-
-  function select(command: CodexSlashCommand, completeOnly = false) {
-    if (completeOnly || command.argumentMode === "required") {
-      onComplete(codexSlashCommandCompletion(command));
-      return;
-    }
-    onExecute(command);
-  }
-
-  function handleKeyDown(event: KeyboardEvent<HTMLTextAreaElement>) {
-    if (commands.length === 0) return false;
-    if (event.key === "ArrowDown") {
-      event.preventDefault();
-      setActiveIndex((index) => (index + 1) % commands.length);
-      return true;
-    }
-    if (event.key === "ArrowUp") {
-      event.preventDefault();
-      setActiveIndex(
-        (index) => (index - 1 + commands.length) % commands.length,
-      );
-      return true;
-    }
-    if (event.key === "Escape") {
-      event.preventDefault();
-      setDismissed(true);
-      return true;
-    }
-    if (event.key === "Tab" && activeCommand) {
-      event.preventDefault();
-      select(activeCommand, true);
-      return true;
-    }
-    if (
-      event.key === "Enter" &&
-      !event.shiftKey &&
-      !event.metaKey &&
-      !event.ctrlKey &&
-      activeCommand
-    ) {
-      event.preventDefault();
-      select(activeCommand);
-      return true;
-    }
-    return false;
-  }
-
-  return {
-    id,
-    commands,
-    activeCommand,
-    activeIndex: resolvedActiveIndex,
-    setActiveIndex,
-    select,
-    handleKeyDown,
-    show: () => setDismissed(false),
-  };
-}
-
-export function CodexSlashCommandMenu({
-  id,
-  language,
-  commands,
-  activeIndex,
-  onActiveIndexChange,
-  onSelect,
-}: CodexSlashCommandMenuProps) {
-  const menuRef = useRef<HTMLDivElement>(null);
-  useEffect(() => {
-    const active = menuRef.current?.querySelector<HTMLElement>(
-      '[role="option"][aria-selected="true"]',
-    );
-    active?.scrollIntoView({ block: "nearest" });
-  }, [activeIndex]);
-  if (commands.length === 0) return null;
-  return (
-    <div
-      ref={menuRef}
-      id={id}
-      className="codex-slash-command-menu"
-      role="listbox"
-      aria-label={
-        language === "zh-CN" ? "Codex 斜杠命令" : "Codex slash commands"
-      }
-    >
-      {commands.map((command, index) => (
-        <button
-          id={`${id}-${command.name}`}
-          type="button"
-          role="option"
-          aria-selected={index === activeIndex}
-          className={index === activeIndex ? "is-active" : ""}
-          key={command.name}
-          onPointerMove={() => onActiveIndexChange(index)}
-          onMouseDown={(event) => event.preventDefault()}
-          onClick={() => onSelect(command)}
-        >
-          <span className="codex-slash-command-name">
-            /{command.name}
-            {command.argumentMode !== "none" && command.argumentHint ? (
-              <i>{command.argumentHint[language]}</i>
-            ) : null}
-          </span>
-          <span className="codex-slash-command-description">
-            {command.description[language]}
-          </span>
-        </button>
-      ))}
-    </div>
-  );
-}
diff --git a/src/harnesses/codex/slash-commands.test.ts b/src/harnesses/codex/slash-commands.test.ts
deleted file mode 100644
index 7aa0353..0000000
--- a/src/harnesses/codex/slash-commands.test.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  CODEX_INIT_COMMAND_PROMPT,
-  CODEX_SLASH_COMMANDS,
-  codexSlashCommandCompletion,
-  codexSlashMenuCommands,
-  parseCodexSlashInvocation,
-} from "./slash-commands";
-
-test("keeps /init aligned with Codex's visible TUI prompt", () => {
-  assert.match(
-    CODEX_INIT_COMMAND_PROMPT,
-    /If it does, do not overwrite or modify it\./,
-  );
-  assert.match(CODEX_INIT_COMMAND_PROMPT, /200-400 words is optimal\./);
-  assert.doesNotMatch(CODEX_INIT_COMMAND_PROMPT, /create or improve AGENTS\.md/);
-});
-
-test("keeps unsupported terminal-only commands out of the browser catalog", () => {
-  const names = new Set<string>(
-    CODEX_SLASH_COMMANDS.map((command) => command.name),
-  );
-  assert.equal(names.has("resume"), false);
-  assert.equal(names.has("side"), false);
-  assert.equal(names.has("btw"), false);
-  assert.equal(names.has("personality"), true);
-  assert.equal(names.has("memories"), true);
-  assert.equal(names.has("hooks"), true);
-  assert.equal(names.has("ps"), true);
-  assert.equal(names.has("stop"), true);
-  assert.equal(names.has("fast"), false);
-  assert.equal(names.has("model"), false);
-  assert.equal(names.has("status"), false);
-  assert.equal(names.has("subagents"), false);
-});
-
-test("preserves Codex task-time availability for native slash behavior", () => {
-  const byName = new Map(
-    CODEX_SLASH_COMMANDS.map((command) => [command.name, command]),
-  );
-  for (const name of ["new", "clear", "memories"] as const) {
-    assert.equal(byName.get(name)?.unavailableWhileTurnRunning, true);
-  }
-  for (const name of [
-    "goal",
-    "hooks",
-    "personality",
-    "ps",
-    "stop",
-    "usage",
-  ] as const) {
-    assert.notEqual(byName.get(name)?.unavailableWhileTurnRunning, true);
-  }
-});
-
-test("maps /agent to the native Agent Threads intent", () => {
-  const agentCommands = CODEX_SLASH_COMMANDS.filter(
-    (command) => command.intent === "agents.open",
-  );
-  assert.deepEqual(
-    agentCommands.map((command) => command.name),
-    ["agent"],
-  );
-  assert.equal(
-    agentCommands.every(
-      (command) => !command.description.en.toLowerCase().includes("activity"),
-    ),
-    true,
-  );
-});
-
-test("filters commands by Sandpi composer context and query", () => {
-  assert.deepEqual(
-    codexSlashMenuCommands("/fo", "session").map((command) => command.name),
-    ["fork"],
-  );
-  assert.deepEqual(
-    codexSlashMenuCommands("/fo", "new-session").map(
-      (command) => command.name,
-    ),
-    [],
-  );
-  assert.equal(
-    codexSlashMenuCommands("/fork ", "session").length,
-    0,
-  );
-});
-
-test("hides unsafe native mutations while a Turn is running", () => {
-  const runningNames = new Set<string>(
-    codexSlashMenuCommands(
-      "/",
-      "session",
-      true,
-    ).map((command) => command.name),
-  );
-  assert.equal(runningNames.has("fork"), false);
-  assert.equal(runningNames.has("compact"), false);
-  assert.equal(runningNames.has("review"), false);
-  assert.equal(runningNames.has("new"), false);
-  assert.equal(runningNames.has("status"), false);
-});
-
-test("parses arguments and rejects unavailable or unknown commands", () => {
-  assert.deepEqual(parseCodexSlashInvocation("/rename Release work", "session"), {
-    kind: "command",
-    command: CODEX_SLASH_COMMANDS.find(
-      (command) => command.name === "rename",
-    ),
-    arguments: "Release work",
-  });
-  assert.equal(
-    parseCodexSlashInvocation("/rename", "session").kind,
-    "command",
-  );
-  assert.equal(
-    parseCodexSlashInvocation("/usage weekly", "new-session").kind,
-    "command",
-  );
-  assert.deepEqual(parseCodexSlashInvocation("/side explain this", "session"), {
-    kind: "unknown",
-    name: "side",
-  });
-  assert.equal(
-    parseCodexSlashInvocation("/fork", "new-session").kind,
-    "unavailable",
-  );
-  assert.deepEqual(parseCodexSlashInvocation("/resume", "session"), {
-    kind: "unknown",
-    name: "resume",
-  });
-  assert.deepEqual(parseCodexSlashInvocation("/model", "session"), {
-    kind: "unknown",
-    name: "model",
-  });
-  assert.deepEqual(parseCodexSlashInvocation("/subagents", "session"), {
-    kind: "unknown",
-    name: "subagents",
-  });
-});
-
-test("completes argument commands without executing them", () => {
-  const rename = CODEX_SLASH_COMMANDS.find(
-    (command) => command.name === "rename",
-  );
-  assert.ok(rename);
-  assert.equal(codexSlashCommandCompletion(rename), "/rename ");
-});
diff --git a/src/harnesses/codex/slash-commands.ts b/src/harnesses/codex/slash-commands.ts
deleted file mode 100644
index 2d72213..0000000
--- a/src/harnesses/codex/slash-commands.ts
+++ /dev/null
@@ -1,488 +0,0 @@
-import type { OperationLanguage } from "@/lib/operation-ui";
-
-export type CodexSlashCommandContext = "new-session" | "session";
-
-/**
- * Stable browser intents decouple Codex command spelling from Sandpi UI
- * execution while keeping the registry independent from shared conversation
- * dispatch.
- */
-export type CodexCommandIntent =
-  | "agents.open"
-  | "codex.compact"
-  | "codex.goal"
-  | "codex.hooks"
-  | "codex.init"
-  | "codex.memories"
-  | "codex.personality"
-  | "codex.processes"
-  | "codex.review"
-  | "codex.stop"
-  | "codex.usage"
-  | "composer.mention"
-  | "composer.plan"
-  | "environment.credentials"
-  | "environment.mcp"
-  | "environment.network"
-  | "environment.skills"
-  | "response.copy"
-  | "session.archive"
-  | "session.fork"
-  | "session.new"
-  | "session.rename"
-  | "workspace.open";
-
-export type CodexSlashCommandName =
-  | "agent"
-  | "archive"
-  | "clear"
-  | "compact"
-  | "copy"
-  | "diff"
-  | "fork"
-  | "goal"
-  | "hooks"
-  | "init"
-  | "ide"
-  | "logout"
-  | "mcp"
-  | "memories"
-  | "mention"
-  | "new"
-  | "permissions"
-  | "plan"
-  | "personality"
-  | "ps"
-  | "rename"
-  | "review"
-  | "skills"
-  | "stop"
-  | "usage";
-
-// Kept verbatim with codex-rs/tui/prompt_for_init_command.md from the Codex
-// version pinned by Sandbox0: openai/codex@rust-v0.144.1
-// (44918ea10c0f99151c6710411b4322c2f5c96bea).
-export const CODEX_INIT_COMMAND_PROMPT = `Generate a file named AGENTS.md that serves as a contributor guide for this repository.
-Before writing, check whether AGENTS.md already exists in the current working directory. If it does, do not overwrite or modify it.
-Your goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.
-Follow the outline below, but adapt as needed — add sections if relevant, and omit those that do not apply to this project.
-
-Document Requirements
-
-- Title the document "Repository Guidelines".
-- Use Markdown headings (#, ##, etc.) for structure.
-- Keep the document concise. 200-400 words is optimal.
-- Keep explanations short, direct, and specific to this repository.
-- Provide examples where helpful (commands, directory paths, naming patterns).
-- Maintain a professional, instructional tone.
-
-Recommended Sections
-
-Project Structure & Module Organization
-
-- Outline the project structure, including where the source code, tests, and assets are located.
-
-Build, Test, and Development Commands
-
-- List key commands for building, testing, and running locally (e.g., npm test, make build).
-- Briefly explain what each command does.
-
-Coding Style & Naming Conventions
-
-- Specify indentation rules, language-specific style preferences, and naming patterns.
-- Include any formatting or linting tools used.
-
-Testing Guidelines
-
-- Identify testing frameworks and coverage requirements.
-- State test naming conventions and how to run tests.
-
-Commit & Pull Request Guidelines
-
-- Summarize commit message conventions found in the project’s Git history.
-- Outline pull request requirements (descriptions, linked issues, screenshots, etc.).
-
-(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.
-`;
-
-export interface CodexSlashCommand {
-  name: CodexSlashCommandName;
-  intent: CodexCommandIntent;
-  contexts: readonly CodexSlashCommandContext[];
-  argumentMode: "none" | "optional" | "required";
-  unavailableWhileTurnRunning?: boolean;
-  description: Record<OperationLanguage, string>;
-  argumentHint?: Record<OperationLanguage, string>;
-}
-
-const BOTH_CONTEXTS: readonly CodexSlashCommandContext[] = [
-  "new-session",
-  "session",
-];
-
-/**
- * Browser commands belong to the Codex harness and map to either a native
- * app-server operation or an existing Sandpi product surface. Terminal-only
- * commands are intentionally absent. In particular, Sandpi does not expose
- * `/resume`, `/side`, its `/btw` alias, `/fast`, or `/status`. Fast is a
- * composer control, while the browser already presents Session status.
- */
-export const CODEX_SLASH_COMMANDS: readonly CodexSlashCommand[] = [
-  {
-    name: "new",
-    intent: "session.new",
-    contexts: ["session"],
-    argumentMode: "optional",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Start a new Sandpi Session",
-      "zh-CN": "新建一个 Sandpi Session",
-    },
-    argumentHint: {
-      en: "name",
-      "zh-CN": "名称",
-    },
-  },
-  {
-    name: "fork",
-    intent: "session.fork",
-    contexts: ["session"],
-    argumentMode: "none",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Fork this Session and switch to the child",
-      "zh-CN": "派生当前 Session 并切换到子 Session",
-    },
-  },
-  {
-    name: "clear",
-    intent: "session.new",
-    contexts: ["session"],
-    argumentMode: "optional",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Start a clean Sandpi Session",
-      "zh-CN": "新建一个干净的 Sandpi Session",
-    },
-    argumentHint: {
-      en: "name",
-      "zh-CN": "名称",
-    },
-  },
-  {
-    name: "compact",
-    intent: "codex.compact",
-    contexts: ["session"],
-    argumentMode: "none",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Compact this native Codex Session",
-      "zh-CN": "压缩当前 Codex 原生 Session 上下文",
-    },
-  },
-  {
-    name: "review",
-    intent: "codex.review",
-    contexts: ["session"],
-    argumentMode: "optional",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Review uncommitted changes or custom instructions",
-      "zh-CN": "审查未提交改动，或按自定义要求审查",
-    },
-    argumentHint: {
-      en: "instructions",
-      "zh-CN": "审查要求",
-    },
-  },
-  {
-    name: "plan",
-    intent: "composer.plan",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "optional",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Enter Plan mode, optionally with a prompt",
-      "zh-CN": "进入计划模式，可同时输入任务",
-    },
-    argumentHint: {
-      en: "prompt",
-      "zh-CN": "任务",
-    },
-  },
-  {
-    name: "goal",
-    intent: "codex.goal",
-    contexts: ["session"],
-    argumentMode: "optional",
-    description: {
-      en: "Show, edit, pause, resume, or clear the native Codex goal",
-      "zh-CN": "查看、编辑、暂停、恢复或清除 Codex 原生目标",
-    },
-    argumentHint: {
-      en: "objective | edit | pause | resume | clear",
-      "zh-CN": "目标 | edit | pause | resume | clear",
-    },
-  },
-  {
-    name: "rename",
-    intent: "session.rename",
-    contexts: ["session"],
-    argumentMode: "optional",
-    description: {
-      en: "Rename this Sandpi Session",
-      "zh-CN": "重命名当前 Sandpi Session",
-    },
-    argumentHint: {
-      en: "name",
-      "zh-CN": "名称",
-    },
-  },
-  {
-    name: "archive",
-    intent: "session.archive",
-    contexts: ["session"],
-    argumentMode: "none",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Archive this Sandpi Session",
-      "zh-CN": "归档当前 Sandpi Session",
-    },
-  },
-  {
-    name: "init",
-    intent: "codex.init",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Create AGENTS.md when it does not exist",
-      "zh-CN": "仅在不存在时创建 AGENTS.md 项目说明",
-    },
-  },
-  {
-    name: "personality",
-    intent: "codex.personality",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "Choose the Codex response personality",
-      "zh-CN": "选择 Codex 回复风格",
-    },
-  },
-  {
-    name: "mention",
-    intent: "composer.mention",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "Mention files from the Environment Workspace",
-      "zh-CN": "引用环境工作区中的文件",
-    },
-  },
-  {
-    name: "diff",
-    intent: "workspace.open",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "Open changed Workspace files",
-      "zh-CN": "打开工作区改动文件",
-    },
-  },
-  {
-    name: "ide",
-    intent: "workspace.open",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "Open the Sandpi Workspace IDE",
-      "zh-CN": "打开 Sandpi 工作区 IDE",
-    },
-  },
-  {
-    name: "agent",
-    intent: "agents.open",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "Switch or inspect native Codex agent threads",
-      "zh-CN": "切换或查看 Codex 原生 Agent Threads",
-    },
-  },
-  {
-    name: "copy",
-    intent: "response.copy",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "Copy the latest assistant response",
-      "zh-CN": "复制最近一条助手回复",
-    },
-  },
-  {
-    name: "skills",
-    intent: "environment.skills",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "Open Environment Skills",
-      "zh-CN": "打开环境 Skills",
-    },
-  },
-  {
-    name: "mcp",
-    intent: "environment.mcp",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "optional",
-    description: {
-      en: "Open Environment MCP servers",
-      "zh-CN": "打开环境 MCP servers",
-    },
-    argumentHint: {
-      en: "verbose",
-      "zh-CN": "verbose",
-    },
-  },
-  {
-    name: "permissions",
-    intent: "environment.network",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "Open Environment network permissions",
-      "zh-CN": "打开环境网络权限",
-    },
-  },
-  {
-    name: "usage",
-    intent: "codex.usage",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "optional",
-    description: {
-      en: "Open Codex account token activity",
-      "zh-CN": "打开 Codex 账户 token 活动",
-    },
-    argumentHint: {
-      en: "daily | weekly | cumulative",
-      "zh-CN": "daily | weekly | cumulative",
-    },
-  },
-  {
-    name: "memories",
-    intent: "codex.memories",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    unavailableWhileTurnRunning: true,
-    description: {
-      en: "Configure Codex memory use and generation",
-      "zh-CN": "配置 Codex 记忆读取与生成",
-    },
-  },
-  {
-    name: "hooks",
-    intent: "codex.hooks",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "View and manage Codex lifecycle hooks",
-      "zh-CN": "查看和管理 Codex 生命周期 hooks",
-    },
-  },
-  {
-    name: "ps",
-    intent: "codex.processes",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "List native Codex background terminals",
-      "zh-CN": "列出 Codex 原生后台终端",
-    },
-  },
-  {
-    name: "stop",
-    intent: "codex.stop",
-    contexts: ["session"],
-    argumentMode: "none",
-    description: {
-      en: "Stop all native Codex background terminals",
-      "zh-CN": "停止所有 Codex 原生后台终端",
-    },
-  },
-  {
-    name: "logout",
-    intent: "environment.credentials",
-    contexts: BOTH_CONTEXTS,
-    argumentMode: "none",
-    description: {
-      en: "Open the Codex account connection",
-      "zh-CN": "打开 Codex 账户连接设置",
-    },
-  },
-];
-
-export interface CodexSlashInvocation {
-  command: CodexSlashCommand;
-  arguments: string;
-}
-
-export type CodexSlashInvocationResult =
-  | { kind: "not-command" }
-  | { kind: "unknown"; name: string }
-  | { kind: "unavailable"; command: CodexSlashCommand }
-  | { kind: "missing-arguments"; command: CodexSlashCommand }
-  | ({ kind: "command" } & CodexSlashInvocation);
-
-function commandByName(name: string) {
-  return CODEX_SLASH_COMMANDS.find((command) => command.name === name);
-}
-
-export function parseCodexSlashInvocation(
-  value: string,
-  context: CodexSlashCommandContext,
-): CodexSlashInvocationResult {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith("/")) return { kind: "not-command" };
-
-  const match = /^\/([^\s/]+)(?:\s+([\s\S]*))?$/.exec(trimmed);
-  if (!match) return { kind: "unknown", name: trimmed.slice(1) };
-  const name = match[1].toLowerCase();
-  const command = commandByName(name);
-  if (!command) return { kind: "unknown", name };
-  if (!command.contexts.includes(context)) {
-    return { kind: "unavailable", command };
-  }
-  const argumentsValue = (match[2] ?? "").trim();
-  if (command.argumentMode === "required" && !argumentsValue) {
-    return { kind: "missing-arguments", command };
-  }
-  return { kind: "command", command, arguments: argumentsValue };
-}
-
-export function codexSlashMenuCommands(
-  value: string,
-  context: CodexSlashCommandContext,
-  turnRunning = false,
-) {
-  if (!value.startsWith("/") || value.includes("\n")) return [];
-  const query = value.slice(1);
-  if (/\s/.test(query)) return [];
-  const normalizedQuery = query.toLowerCase();
-  return CODEX_SLASH_COMMANDS.filter(
-    (command) =>
-      command.contexts.includes(context) &&
-      !(turnRunning && command.unavailableWhileTurnRunning) &&
-      command.name.includes(normalizedQuery),
-  ).sort((left, right) => {
-    const leftPrefix = left.name.startsWith(normalizedQuery);
-    const rightPrefix = right.name.startsWith(normalizedQuery);
-    if (leftPrefix !== rightPrefix) return leftPrefix ? -1 : 1;
-    return 0;
-  });
-}
-
-export function codexSlashCommandCompletion(
-  command: CodexSlashCommand,
-) {
-  return `/${command.name}${command.argumentMode === "none" ? "" : " "}`;
-}
diff --git a/src/harnesses/codex/token-usage.test.ts b/src/harnesses/codex/token-usage.test.ts
deleted file mode 100644
index 954eea6..0000000
--- a/src/harnesses/codex/token-usage.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  codexTokenUsagePoints,
-  parseCodexTokenUsageView,
-} from "./token-usage";
-
-const usage = {
-  summary: {
-    lifetimeTokens: 100,
-    peakDailyTokens: 20,
-    longestRunningTurnSec: 5,
-    currentStreakDays: 2,
-    longestStreakDays: 3,
-  },
-  dailyUsageBuckets: [
-    { startDate: "2026-07-19", tokens: 10 },
-    { startDate: "2026-07-20", tokens: 20 },
-    { startDate: "2026-07-20", tokens: 5 },
-    { startDate: "2026-02-31", tokens: 999 },
-    { startDate: "invalid", tokens: 999 },
-  ],
-};
-
-test("parses Codex usage view aliases without silently accepting invalid input", () => {
-  assert.equal(parseCodexTokenUsageView(""), "daily");
-  assert.equal(parseCodexTokenUsageView("week"), "weekly");
-  assert.equal(parseCodexTokenUsageView("cumulative"), "cumulative");
-  assert.equal(parseCodexTokenUsageView("month"), undefined);
-});
-
-test("deduplicates daily buckets and groups weekly activity from Sunday", () => {
-  assert.deepEqual(codexTokenUsagePoints(usage, "daily"), [
-    { label: "2026-07-19", value: 10 },
-    { label: "2026-07-20", value: 25 },
-  ]);
-  assert.deepEqual(codexTokenUsagePoints(usage, "weekly"), [
-    { label: "2026-07-19", value: 35 },
-  ]);
-});
-
-test("accumulates activity within the displayed weekly window", () => {
-  assert.deepEqual(codexTokenUsagePoints(usage, "cumulative"), [
-    { label: "2026-07-19", value: 35 },
-  ]);
-});
diff --git a/src/harnesses/codex/token-usage.ts b/src/harnesses/codex/token-usage.ts
deleted file mode 100644
index 1cc368b..0000000
--- a/src/harnesses/codex/token-usage.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import type {
-  CodexTokenUsage,
-  CodexTokenUsageDailyBucket,
-} from "@/harnesses/codex/native-capabilities";
-
-export type CodexTokenUsageView = "daily" | "weekly" | "cumulative";
-
-export interface CodexTokenUsagePoint {
-  label: string;
-  value: number;
-}
-
-export function parseCodexTokenUsageView(
-  value: string,
-): CodexTokenUsageView | undefined {
-  switch (value.trim().toLowerCase()) {
-    case "":
-    case "day":
-    case "daily":
-      return "daily";
-    case "week":
-    case "weekly":
-      return "weekly";
-    case "cumulative":
-      return "cumulative";
-    default:
-      return undefined;
-  }
-}
-
-export function codexTokenUsagePoints(
-  usage: CodexTokenUsage,
-  view: CodexTokenUsageView,
-): CodexTokenUsagePoint[] {
-  const days = normalizedDays(usage.dailyUsageBuckets);
-  if (view === "daily") {
-    return days.slice(-35).map((day) => ({
-      label: day.startDate,
-      value: day.tokens,
-    }));
-  }
-
-  const weekly = new Map<string, number>();
-  for (const day of days) {
-    const week = sundayStart(day.startDate);
-    if (!week) continue;
-    weekly.set(week, (weekly.get(week) ?? 0) + day.tokens);
-  }
-  const points = [...weekly.entries()]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .slice(-52)
-    .map(([label, value]) => ({ label, value }));
-  if (view === "weekly") return points;
-
-  let total = 0;
-  return points.map((point) => {
-    total += point.value;
-    return { label: point.label, value: total };
-  });
-}
-
-function normalizedDays(buckets: CodexTokenUsageDailyBucket[]) {
-  const totals = new Map<string, number>();
-  for (const bucket of buckets) {
-    if (!validDate(bucket.startDate)) continue;
-    totals.set(
-      bucket.startDate,
-      (totals.get(bucket.startDate) ?? 0) + Math.max(0, bucket.tokens),
-    );
-  }
-  return [...totals.entries()]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([startDate, tokens]) => ({ startDate, tokens }));
-}
-
-function sundayStart(value: string) {
-  if (!validDate(value)) return undefined;
-  const date = new Date(`${value}T00:00:00Z`);
-  date.setUTCDate(date.getUTCDate() - date.getUTCDay());
-  return date.toISOString().slice(0, 10);
-}
-
-function validDate(value: string) {
-  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
-  const date = new Date(`${value}T00:00:00Z`);
-  return (
-    !Number.isNaN(date.valueOf()) &&
-    date.toISOString().slice(0, 10) === value
-  );
-}
diff --git a/src/harnesses/codex/types.ts b/src/harnesses/codex/types.ts
index e0546c4..f633b97 100644
--- a/src/harnesses/codex/types.ts
+++ b/src/harnesses/codex/types.ts
@@ -248,11 +248,6 @@ export interface CodexThread {
 }
 
 /** Native root plus every persisted AgentControl descendant in one Session tree. */
-export interface CodexAgentThreads {
-  root: CodexThread;
-  descendants: CodexThread[];
-}
-
 export interface CodexTokenUsageBreakdown {
   inputTokens: number;
   cachedInputTokens: number;
diff --git a/src/server/api-schemas.ts b/src/server/api-schemas.ts
index c1ddd2b..fe41c32 100644
--- a/src/server/api-schemas.ts
+++ b/src/server/api-schemas.ts
@@ -232,28 +232,12 @@ export const environmentProvisioningSchema = z.object({
   desiredState: z.literal("ready"),
 });
 
-export const codexPersonalitySelectionSchema = z.object({
-  personality: z.enum(["friendly", "pragmatic"]),
-});
-
 export const codexMemoriesSettingsSchema = z.object({
   featureEnabled: z.boolean(),
   useMemories: z.boolean(),
   generateMemories: z.boolean(),
 });
 
-export const codexHookUpdateSchema = z
-  .object({
-    key: z.string().trim().min(1).max(8_192),
-    enabled: z.boolean().optional(),
-    trustedHash: z.string().trim().min(1).max(512).optional(),
-  })
-  .refine(
-    (value) => value.enabled !== undefined || value.trustedHash !== undefined,
-    { message: "A hook update is required." },
-  )
-  .describe("At least one of enabled or trustedHash is required.");
-
 export const codexSkillConfigurationSchema = z.object({
   path: z.string().trim().min(1).max(4_096),
   enabled: z.boolean(),
@@ -402,7 +386,6 @@ export const sessionCreateSchema = z
     reasoningEffort: codexReasoningEffortSchema.optional(),
     collaborationMode: z.literal("plan").optional(),
     serviceTier: z.string().trim().min(1).max(100).optional(),
-    sessionStartSource: z.enum(["startup", "clear"]).optional(),
     images: codexInputImagesSchema,
     localImages: codexLocalImagesSchema,
   })
@@ -467,23 +450,6 @@ export const turnInterruptSchema = z.object({
   turnId: z.string().trim().min(1).max(200).optional(),
 });
 
-export const sessionReviewSchema = z
-  .object({
-    instructions: z.string().trim().min(1).max(100_000).optional(),
-  })
-  .default({});
-
-export const sessionGoalUpdateSchema = z
-  .object({
-    objective: z.string().trim().min(1).max(10_000).optional(),
-    status: z.enum(["active", "paused"]).optional(),
-  })
-  .refine(
-    (value) => value.objective !== undefined || value.status !== undefined,
-    { message: "A goal update is required." },
-  )
-  .describe("At least one of objective or status is required.");
-
 export const sessionForkSchema = z
   .object({ title: z.string().trim().min(1).max(200).optional() })
   .default({});
diff --git a/src/server/harnesses/codex/service.test.ts b/src/server/harnesses/codex/service.test.ts
index f88506d..1c4fcac 100644
--- a/src/server/harnesses/codex/service.test.ts
+++ b/src/server/harnesses/codex/service.test.ts
@@ -532,39 +532,6 @@ function fixture(
       const params = message.params as { expectedTurnId: string };
       return { id, result: { turnId: params.expectedTurnId } };
     }
-    if (message.method === "review/start") {
-      return {
-        id,
-        result: {
-          turn: { id: "turn-review", status: "inProgress", items: [] },
-          reviewThreadId: "thread-one",
-        },
-      };
-    }
-    if (
-      message.method === "thread/goal/get" ||
-      message.method === "thread/goal/set"
-    ) {
-      const params = message.params as {
-        objective?: string;
-        status?: string;
-      };
-      return {
-        id,
-        result: {
-          goal: {
-            threadId: "thread-one",
-            objective: params.objective ?? "Existing native goal",
-            status: params.status ?? "active",
-            tokenBudget: 10_000,
-            tokensUsed: 250,
-            timeUsedSeconds: 12,
-            createdAt: 1,
-            updatedAt: 2,
-          },
-        },
-      };
-    }
     if (message.method === "thread/read") {
       const params = message.params as {
         threadId: string;
@@ -2062,185 +2029,6 @@ test("restarts a warm app-server before publishing a replacement account credent
   }
 });
 
-test("lists persisted native Agent descendants across paginated tree pages", async () => {
-  const context = fixture({
-    onRequest(message) {
-      if (message.method !== "thread/list") return undefined;
-      const params = message.params as {
-        ancestorThreadId?: string;
-        cursor?: string;
-        limit?: number;
-      };
-      assert.equal(params.ancestorThreadId, "thread-one");
-      assert.equal(params.limit, 100);
-      return params.cursor
-        ? {
-            id: message.id,
-            result: {
-              data: [
-                {
-                  id: "agent-child",
-                  parentThreadId: "thread-one",
-                  status: { type: "idle" },
-                  turns: [],
-                },
-              ],
-              nextCursor: null,
-            },
-          }
-        : {
-            id: message.id,
-            result: {
-              data: [
-                {
-                  id: "agent-grandchild",
-                  parentThreadId: "agent-child",
-                  agentNickname: "Scout",
-                  agentRole: "explorer",
-                  status: { type: "notLoaded" },
-                  turns: [],
-                },
-              ],
-              nextCursor: "agent-page-two",
-            },
-          };
-    },
-  });
-  try {
-    const tree = await context.service.listSessionAgentThreads({
-      userId: "user",
-      sessionId: "session-one",
-    });
-
-    assert.equal(tree.root.id, "thread-one");
-    assert.deepEqual(
-      tree.descendants.map((thread) => ({
-        id: thread.id,
-        parentThreadId: thread.parentThreadId,
-      })),
-      [
-        {
-          id: "agent-grandchild",
-          parentThreadId: "agent-child",
-        },
-        {
-          id: "agent-child",
-          parentThreadId: "thread-one",
-        },
-      ],
-    );
-    assert.deepEqual(
-      context.writes
-        .filter(({ message }) => message.method === "thread/list")
-        .map(({ message }) => message.params),
-      [
-        { ancestorThreadId: "thread-one", limit: 100 },
-        {
-          ancestorThreadId: "thread-one",
-          limit: 100,
-          cursor: "agent-page-two",
-        },
-      ],
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("reads only a native Agent Thread owned by the Session tree", async () => {
-  const context = fixture({
-    onRequest(message) {
-      if (message.method === "thread/list") {
-        return {
-          id: message.id,
-          result: {
-            data: [
-              {
-                id: "agent-child",
-                parentThreadId: "thread-one",
-                status: { type: "idle" },
-                turns: [],
-              },
-            ],
-            nextCursor: null,
-          },
-        };
-      }
-      if (
-        message.method === "thread/read" &&
-        (message.params as { threadId?: string }).threadId === "agent-child"
-      ) {
-        return {
-          id: message.id,
-          result: {
-            thread: {
-              id: "agent-child",
-              parentThreadId: "thread-one",
-              agentNickname: "Scout",
-              status: { type: "idle" },
-              turns: [completedTurn("agent-turn")],
-            },
-          },
-        };
-      }
-      return undefined;
-    },
-  });
-  try {
-    const thread = await context.service.readSessionAgentThread({
-      userId: "user",
-      sessionId: "session-one",
-      nativeThreadId: "agent-child",
-    });
-    assert.equal(thread.id, "agent-child");
-    assert.equal(thread.agentNickname, "Scout");
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) =>
-          message.method === "thread/read" &&
-          (message.params as { threadId?: string }).threadId === "agent-child",
-      )?.message.params,
-      { threadId: "agent-child", includeTurns: true },
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("rejects a same-Environment Thread outside the native Agent tree", async () => {
-  const context = fixture({
-    onRequest(message) {
-      if (message.method !== "thread/list") return undefined;
-      return {
-        id: message.id,
-        result: { data: [], nextCursor: null },
-      };
-    },
-  });
-  try {
-    await assert.rejects(
-      context.service.readSessionAgentThread({
-        userId: "user",
-        sessionId: "session-one",
-        nativeThreadId: "thread-two",
-      }),
-      (error: unknown) =>
-        error instanceof HttpError &&
-        error.code === "codex_agent_thread_not_found",
-    );
-    assert.equal(
-      context.writes.some(
-        ({ message }) =>
-          message.method === "thread/read" &&
-          (message.params as { threadId?: string }).threadId === "thread-two",
-      ),
-      false,
-    );
-  } finally {
-    await context.close();
-  }
-});
-
 test("starts the Environment app-server before listing New Session models", async () => {
   const context = fixture();
   try {
@@ -2582,7 +2370,6 @@ test("starts the first Turn on a newly created loaded Thread without resume", as
       images: [],
       modelId: "gpt-test",
       reasoningEffort: "high",
-      sessionStartSource: "clear",
     });
 
     assert.equal(context.sessions.get(sessionId)?.title, "New native Session");
@@ -2607,7 +2394,7 @@ test("starts the first Turn on a newly created loaded Thread without resume", as
       "tools.experimental_request_user_input.enabled": false,
       model_reasoning_effort: "high",
     });
-    assert.equal(threadStart?.sessionStartSource, "clear");
+    assert.equal(Object.hasOwn(threadStart ?? {}, "sessionStartSource"), false);
     assert.equal(
       threadStart?.threadSource,
       `sandpi-session:${sessionId}`,
@@ -2846,152 +2633,7 @@ test("fails closed when a creation key resolves to multiple native Threads", asy
   }
 });
 
-test("starts native compaction on the current Codex Thread", async () => {
-  const context = fixture();
-  try {
-    assert.deepEqual(
-      await context.service.compactSession({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      { accepted: true },
-    );
-    const compact = context.writes.find(
-      ({ message }) => message.method === "thread/compact/start",
-    )?.message;
-    assert.deepEqual(compact?.params, { threadId: "thread-one" });
-  } finally {
-    await context.close();
-  }
-});
-
-test("starts native inline reviews with Codex-owned review targets", async () => {
-  const context = fixture();
-  try {
-    assert.deepEqual(
-      await context.service.startReview({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      { nativeTurnId: "turn-review" },
-    );
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "review/start",
-      )?.message.params,
-      {
-        threadId: "thread-one",
-        delivery: "inline",
-        target: { type: "uncommittedChanges" },
-      },
-    );
-
-    await context.service.startReview({
-      userId: "user",
-      sessionId: "session-one",
-      instructions: "Focus on persistence races",
-    });
-    assert.deepEqual(
-      context.writes
-        .filter(({ message }) => message.method === "review/start")
-        .at(-1)?.message.params,
-      {
-        threadId: "thread-one",
-        delivery: "inline",
-        target: {
-          type: "custom",
-          instructions: "Focus on persistence races",
-        },
-      },
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("reads, sets, and clears the native Codex Session goal", async () => {
-  const context = fixture();
-  try {
-    assert.deepEqual(
-      await context.service.readSessionGoal({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      {
-        goal: {
-          objective: "Existing native goal",
-          status: "active",
-          tokenBudget: 10_000,
-          tokensUsed: 250,
-          timeUsedSeconds: 12,
-        },
-      },
-    );
-    assert.deepEqual(
-      await context.service.setSessionGoal({
-        userId: "user",
-        sessionId: "session-one",
-        objective: "Ship the native integration",
-      }),
-      {
-        goal: {
-          objective: "Ship the native integration",
-          status: "active",
-          tokenBudget: 10_000,
-          tokensUsed: 250,
-          timeUsedSeconds: 12,
-        },
-      },
-    );
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "thread/goal/set",
-      )?.message.params,
-      {
-        threadId: "thread-one",
-        objective: "Ship the native integration",
-      },
-    );
-    assert.equal(
-      (
-        await context.service.setSessionGoal({
-          userId: "user",
-          sessionId: "session-one",
-          status: "paused",
-        })
-      ).goal?.status,
-      "paused",
-    );
-    assert.deepEqual(
-      context.writes
-        .filter(({ message }) => message.method === "thread/goal/set")
-        .at(-1)?.message.params,
-      {
-        threadId: "thread-one",
-        status: "paused",
-      },
-    );
-    assert.deepEqual(
-      await context.service.clearSessionGoal({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      { goal: null },
-    );
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "thread/goal/clear",
-      )?.message.params,
-      { threadId: "thread-one" },
-    );
-
-  } finally {
-    await context.close();
-  }
-});
-
-test("projects native personality, usage, and memory settings", async () => {
-  let personality = "friendly";
+test("reads, updates, and resets Environment Codex memories", async () => {
   let featureEnabled = true;
   let useMemories = true;
   let generateMemories = false;
@@ -3002,7 +2644,6 @@ test("projects native personality, usage, and memory settings", async () => {
           id: message.id,
           result: {
             config: {
-              personality,
               features: { memories: featureEnabled },
               memories: {
                 use_memories: useMemories,
@@ -3013,23 +2654,6 @@ test("projects native personality, usage, and memory settings", async () => {
           },
         };
       }
-      if (message.method === "model/list") {
-        return {
-          id: message.id,
-          result: {
-            data: [{ id: "gpt-test", supportsPersonality: true }],
-            nextCursor: null,
-          },
-        };
-      }
-      if (message.method === "config/value/write") {
-        const params = message.params as {
-          keyPath: string;
-          value: string;
-        };
-        if (params.keyPath === "personality") personality = params.value;
-        return { id: message.id, result: { status: "ok" } };
-      }
       if (message.method === "config/batchWrite") {
         const edits = (message.params as {
           edits: Array<{ keyPath: string; value: boolean }>;
@@ -3045,130 +2669,36 @@ test("projects native personality, usage, and memory settings", async () => {
         }
         return { id: message.id, result: { status: "ok" } };
       }
-      if (
-        message.method === "thread/settings/update" ||
-        message.method === "thread/memoryMode/set" ||
-        message.method === "memory/reset"
-      ) {
+      if (message.method === "memory/reset") {
         return { id: message.id, result: {} };
       }
-      if (message.method === "account/usage/read") {
-        return {
-          id: message.id,
-          result: {
-            summary: {
-              lifetimeTokens: 12_000,
-              peakDailyTokens: 2_500,
-              longestRunningTurnSec: 90,
-              currentStreakDays: 4,
-              longestStreakDays: 9,
-            },
-            dailyUsageBuckets: [
-              { startDate: "2026-07-26", tokens: 1_200 },
-              { startDate: "2026-07-27", tokens: 800 },
-            ],
-          },
-        };
-      }
       return undefined;
     },
   });
   try {
     assert.deepEqual(
-      await context.service.readSessionPersonality({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      { personality: "friendly", supported: true },
-    );
-    assert.deepEqual(
-      await context.service.setSessionPersonality({
-        userId: "user",
-        sessionId: "session-one",
-        personality: "pragmatic",
-      }),
-      { personality: "pragmatic", supported: true },
-    );
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "thread/settings/update",
-      )?.message.params,
-      { threadId: "thread-one", personality: "pragmatic" },
-    );
-
-    assert.deepEqual(
-      await context.service.accountTokenUsageForEnvironment(
-        "user",
-        environment.id,
-      ),
-      {
-        summary: {
-          lifetimeTokens: 12_000,
-          peakDailyTokens: 2_500,
-          longestRunningTurnSec: 90,
-          currentStreakDays: 4,
-          longestStreakDays: 9,
-        },
-        dailyUsageBuckets: [
-          { startDate: "2026-07-26", tokens: 1_200 },
-          { startDate: "2026-07-27", tokens: 800 },
-        ],
-      },
-    );
-    assert.equal(
-      Object.hasOwn(
-        context.writes.find(
-          ({ message }) => message.method === "account/usage/read",
-        )?.message ?? {},
-        "params",
-      ),
-      false,
-    );
-
-    assert.deepEqual(
-      await context.service.readSessionMemories({
-        userId: "user",
-        sessionId: "session-one",
-      }),
+      await context.service.readEnvironmentMemories("user", environment.id),
       {
         featureEnabled: true,
         useMemories: true,
         generateMemories: false,
       },
     );
-    const memorySettings = {
-      featureEnabled: true,
-      useMemories: false,
-      generateMemories: true,
-    };
-    assert.deepEqual(
-      await context.service.setSessionMemories({
-        userId: "user",
-        sessionId: "session-one",
-        settings: memorySettings,
-      }),
-      memorySettings,
-    );
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "thread/memoryMode/set",
-      )?.message.params,
-      { threadId: "thread-one", mode: "enabled" },
-    );
+
     assert.deepEqual(
-      await context.service.setSessionMemories({
+      await context.service.setEnvironmentMemories({
         userId: "user",
-        sessionId: "session-one",
+        environmentId: environment.id,
         settings: {
-          featureEnabled: false,
-          useMemories: true,
+          featureEnabled: true,
+          useMemories: false,
           generateMemories: true,
         },
       }),
       {
-        featureEnabled: false,
+        featureEnabled: true,
         useMemories: false,
-        generateMemories: false,
+        generateMemories: true,
       },
     );
     assert.deepEqual(
@@ -3179,7 +2709,7 @@ test("projects native personality, usage, and memory settings", async () => {
         edits: [
           {
             keyPath: "features.memories",
-            value: false,
+            value: true,
             mergeStrategy: "replace",
           },
           {
@@ -3189,64 +2719,20 @@ test("projects native personality, usage, and memory settings", async () => {
           },
           {
             keyPath: "memories.generate_memories",
-            value: false,
+            value: true,
             mergeStrategy: "replace",
           },
         ],
         reloadUserConfig: true,
       },
     );
-    assert.deepEqual(
-      context.writes
-        .filter(
-          ({ message }) => message.method === "thread/memoryMode/set",
-        )
-        .at(-1)?.message.params,
-      { threadId: "thread-one", mode: "disabled" },
-    );
-    assert.deepEqual(
-      await context.service.resetEnvironmentMemories("user", environment.id),
-      { reset: true },
-    );
-  } finally {
-    await context.close();
-  }
-});
 
-test("uses effective Codex configuration after native writes", async () => {
-  const context = fixture({
-    onRequest(message) {
-      if (message.method === "config/read") {
-        return {
-          id: message.id,
-          result: {
-            config: {
-              features: { memories: false },
-              memories: {
-                use_memories: true,
-                generate_memories: true,
-              },
-            },
-            layers: [],
-          },
-        };
-      }
-      if (message.method === "config/batchWrite") {
-        return { id: message.id, result: { status: "ok" } };
-      }
-      if (message.method === "thread/memoryMode/set") {
-        return { id: message.id, result: {} };
-      }
-      return undefined;
-    },
-  });
-  try {
     assert.deepEqual(
-      await context.service.setSessionMemories({
+      await context.service.setEnvironmentMemories({
         userId: "user",
-        sessionId: "session-one",
+        environmentId: environment.id,
         settings: {
-          featureEnabled: true,
+          featureEnabled: false,
           useMemories: true,
           generateMemories: true,
         },
@@ -3258,247 +2744,8 @@ test("uses effective Codex configuration after native writes", async () => {
       },
     );
     assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "thread/memoryMode/set",
-      )?.message.params,
-      { threadId: "thread-one", mode: "disabled" },
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("rejects Codex configuration writes overridden by a higher layer", async () => {
-  const context = fixture({
-    onRequest(message) {
-      if (message.method === "model/list") {
-        return {
-          id: message.id,
-          result: {
-            data: [{ id: "gpt-test", supportsPersonality: true }],
-            nextCursor: null,
-          },
-        };
-      }
-      if (message.method === "config/value/write") {
-        return {
-          id: message.id,
-          result: {
-            status: "okOverridden",
-            overriddenMetadata: {
-              message: "overridden",
-              overridingLayer: { name: { type: "system" }, version: "1" },
-              effectiveValue: "friendly",
-            },
-          },
-        };
-      }
-      return undefined;
-    },
-  });
-  try {
-    await assert.rejects(
-      context.service.setSessionPersonality({
-        userId: "user",
-        sessionId: "session-one",
-        personality: "pragmatic",
-      }),
-      (error: unknown) =>
-        error instanceof HttpError &&
-        error.statusCode === 409 &&
-        error.code === "codex_config_overridden",
-    );
-    assert.equal(
-      context.writes.some(
-        ({ message }) => message.method === "thread/settings/update",
-      ),
-      false,
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("lists and manages native hooks and background terminals", async () => {
-  let trusted = false;
-  const context = fixture({
-    onRequest(message) {
-      if (message.method === "hooks/list") {
-        return {
-          id: message.id,
-          result: {
-            data: [
-              {
-                cwd: "/workspace",
-                hooks: [
-                  {
-                    key: "project-hook",
-                    eventName: "preToolUse",
-                    handlerType: "command",
-                    matcher: "exec",
-                    command: "./check.sh",
-                    timeoutSec: 10,
-                    statusMessage: null,
-                    sourcePath: "/workspace/.codex/hooks.json",
-                    source: "project",
-                    pluginId: null,
-                    displayOrder: -1,
-                    enabled: trusted,
-                    isManaged: false,
-                    currentHash: "sha256:current",
-                    trustStatus: trusted ? "trusted" : "untrusted",
-                  },
-                ],
-                warnings: [],
-                errors: [],
-              },
-            ],
-          },
-        };
-      }
-      if (message.method === "config/batchWrite") {
-        trusted = true;
-        return { id: message.id, result: { status: "ok" } };
-      }
-      if (message.method === "thread/backgroundTerminals/list") {
-        return {
-          id: message.id,
-          result: {
-            data: [
-              {
-                itemId: "item-shell",
-                processId: "process-shell",
-                command: "npm run dev",
-                cwd: "/workspace",
-                osPid: 42,
-                cpuPercent: 3.5,
-                rssKb: 1_024,
-              },
-            ],
-            nextCursor: null,
-          },
-        };
-      }
-      if (message.method === "thread/backgroundTerminals/terminate") {
-        return { id: message.id, result: { terminated: true } };
-      }
-      return undefined;
-    },
-  });
-  try {
-    const hooks = await context.service.listEnvironmentHooks(
-      "user",
-      environment.id,
-    );
-    assert.equal(hooks.hooks[0]?.trustStatus, "untrusted");
-    assert.equal(hooks.hooks[0]?.displayOrder, -1);
-    const updated = await context.service.updateEnvironmentHook({
-      userId: "user",
-      environmentId: environment.id,
-      key: "project-hook",
-      trustedHash: "sha256:current",
-      enabled: true,
-    });
-    assert.equal(updated.hooks[0]?.trustStatus, "trusted");
-    assert.deepEqual(
-      context.writes.find(
-        ({ message }) => message.method === "config/batchWrite",
-      )?.message.params,
-      {
-        edits: [
-          {
-            keyPath: "hooks.state",
-            value: {
-              "project-hook": {
-                enabled: true,
-                trusted_hash: "sha256:current",
-              },
-            },
-            mergeStrategy: "upsert",
-          },
-        ],
-        reloadUserConfig: true,
-      },
-    );
-
-    assert.deepEqual(
-      await context.service.listSessionBackgroundTerminals({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      {
-        terminals: [
-          {
-            itemId: "item-shell",
-            processId: "process-shell",
-            command: "npm run dev",
-            cwd: "/workspace",
-            osPid: 42,
-            cpuPercent: 3.5,
-            rssKb: 1_024,
-          },
-        ],
-      },
-    );
-    assert.deepEqual(
-      await context.service.terminateSessionBackgroundTerminal({
-        userId: "user",
-        sessionId: "session-one",
-        processId: "process-shell",
-      }),
-      { terminated: true },
-    );
-    assert.deepEqual(
-      await context.service.cleanSessionBackgroundTerminals({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      { cleaned: true },
-    );
-  } finally {
-    await context.close();
-  }
-});
-
-test("rejects native slash mutations while the Session has an active Turn", async () => {
-  const context = fixture({
-    sessions: [
-      {
-        id: "session-one",
-        nativeSessionId: "thread-one",
-        status: "running",
-        activeNativeTurnId: "turn-active",
-      },
-    ],
-  });
-  try {
-    await assert.rejects(
-      context.service.compactSession({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      (error: unknown) =>
-        error instanceof HttpError &&
-        error.statusCode === 409 &&
-        error.code === "codex_compact_not_ready",
-    );
-    await assert.rejects(
-      context.service.startReview({
-        userId: "user",
-        sessionId: "session-one",
-      }),
-      (error: unknown) =>
-        error instanceof HttpError &&
-        error.statusCode === 409 &&
-        error.code === "codex_review_not_ready",
-    );
-    assert.equal(
-      context.writes.some(({ message }) =>
-        ["thread/compact/start", "review/start"].includes(
-          String(message.method),
-        ),
-      ),
-      false,
+      await context.service.resetEnvironmentMemories("user", environment.id),
+      { reset: true },
     );
   } finally {
     await context.close();
diff --git a/src/server/harnesses/codex/service.ts b/src/server/harnesses/codex/service.ts
index 28b6b1c..ffd4cef 100644
--- a/src/server/harnesses/codex/service.ts
+++ b/src/server/harnesses/codex/service.ts
@@ -10,7 +10,6 @@ import {
 } from "@/harnesses/codex/inline-review";
 import {
   CODEX_SESSION_NOTIFICATION_METHODS,
-  type CodexAgentThreads,
   type CodexEventEnvelope,
   type CodexNativeSnapshot,
   type CodexServerNotification,
@@ -43,16 +42,7 @@ import type {
 } from "@/harnesses/codex/environment-tools";
 import {
   codexMemoriesFeatureToggleSettings,
-  type CodexBackgroundTerminal,
-  type CodexBackgroundTerminals,
-  type CodexHook,
-  type CodexHookIssue,
-  type CodexHooksInventory,
   type CodexMemoriesSettings,
-  type CodexPersonality,
-  type CodexPersonalitySelection,
-  type CodexPersonalitySettings,
-  type CodexTokenUsage,
 } from "@/harnesses/codex/native-capabilities";
 import type { Environment } from "@/lib/types";
 import { toUnixTimestamp } from "@/lib/time";
@@ -141,30 +131,9 @@ const CODEX_APPLY_PATCH_STREAMING_CONFIG =
   "features.apply_patch_streaming_events";
 const CODEX_REQUEST_USER_INPUT_CONFIG =
   "tools.experimental_request_user_input.enabled";
-const CODEX_AGENT_THREAD_PAGE_LIMIT = 100;
-const MAX_CODEX_AGENT_THREADS = 1_000;
 const CODEX_THREAD_CREATION_PAGE_LIMIT = 100;
 const MAX_CODEX_THREAD_CREATION_LOOKUP = 1_000;
 const CODEX_THREAD_CREATION_SOURCE_PREFIX = "sandpi-session:";
-const CODEX_BACKGROUND_TERMINAL_PAGE_LIMIT = 100;
-const MAX_CODEX_BACKGROUND_TERMINALS = 1_000;
-const CODEX_PERSONALITIES = new Set<CodexPersonality>([
-  "friendly",
-  "pragmatic",
-  "none",
-]);
-const CODEX_PERSONALITY_SELECTIONS = new Set<CodexPersonalitySelection>([
-  "friendly",
-  "pragmatic",
-]);
-const CODEX_GOAL_STATUSES = new Set([
-  "active",
-  "paused",
-  "blocked",
-  "usageLimited",
-  "budgetLimited",
-  "complete",
-]);
 const CODEX_ACCOUNT_PLAN_TYPES = new Set<CodexAccountPlanType>([
   "free",
   "go",
@@ -339,7 +308,6 @@ interface CreateSessionInput {
   reasoningEffort?: string;
   collaborationMode?: "plan";
   serviceTier?: string;
-  sessionStartSource?: "startup" | "clear";
   idempotencyKey?: string;
 }
 
@@ -629,7 +597,6 @@ export class CodexService {
       reasoningEffort?: string;
       collaborationMode?: "plan";
       serviceTier?: string;
-      sessionStartSource?: "startup" | "clear";
     },
     sessionId: string,
     environmentRuntime: StoredEnvironmentRuntime,
@@ -655,15 +622,12 @@ export class CodexService {
       method: "thread/start",
       id: rpcId("thread-start", sessionId),
       params: {
-        ...threadConfiguration(
-          {
-            modelId: input.modelId,
-            reasoningEffort: input.reasoningEffort,
-            collaborationMode: input.collaborationMode,
-            serviceTier: input.serviceTier,
-          },
-          input.sessionStartSource,
-        ),
+        ...threadConfiguration({
+          modelId: input.modelId,
+          reasoningEffort: input.reasoningEffort,
+          collaborationMode: input.collaborationMode,
+          serviceTier: input.serviceTier,
+        }),
         threadSource,
       },
     };
@@ -759,289 +723,6 @@ export class CodexService {
     });
   }
 
-  /**
-   * Manual compaction is a native Codex operation on the existing Thread.
-   * Progress remains authoritative in the regular Turn/item event stream.
-   */
-  async compactSession(input: { userId: string; sessionId: string }) {
-    const response = await this.requestNativeSessionRpc({
-      ...input,
-      method: "thread/compact/start",
-      requestKind: "thread-compact",
-      requireIdleOperation: "compact",
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_compact_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return { accepted: true };
-  }
-
-  /**
-   * Reviews run inline on the current native Thread, so Sandpi keeps one
-   * product Session and receives the review as an ordinary native Turn.
-   */
-  async startReview(input: {
-    userId: string;
-    sessionId: string;
-    instructions?: string;
-  }) {
-    const response = await this.requestNativeSessionRpc({
-      userId: input.userId,
-      sessionId: input.sessionId,
-      method: "review/start",
-      requestKind: "review-start",
-      requireIdleOperation: "review",
-      params: {
-        delivery: "inline",
-        target: input.instructions
-          ? { type: "custom", instructions: input.instructions }
-          : { type: "uncommittedChanges" },
-      },
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_review_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    const nativeTurnId = turnIdFromRpcResponse(response);
-    if (!nativeTurnId) {
-      throw new HttpError(
-        502,
-        "codex_review_failed",
-        "Codex did not return the native review Turn.",
-      );
-    }
-    return { nativeTurnId };
-  }
-
-  async readSessionGoal(input: { userId: string; sessionId: string }) {
-    const response = await this.requestNativeSessionRpc({
-      ...input,
-      method: "thread/goal/get",
-      requestKind: "thread-goal-get",
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_goal_read_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return nativeThreadGoal(response);
-  }
-
-  async setSessionGoal(input: {
-    userId: string;
-    sessionId: string;
-    objective?: string;
-    status?: string;
-  }) {
-    if (input.objective === undefined && input.status === undefined) {
-      throw new HttpError(
-        400,
-        "codex_goal_update_required",
-        "A Codex goal objective or status update is required.",
-      );
-    }
-    if (
-      input.status !== undefined &&
-      !CODEX_GOAL_STATUSES.has(input.status)
-    ) {
-      throw new HttpError(
-        400,
-        "codex_goal_status_invalid",
-        "The requested Codex goal status is invalid.",
-      );
-    }
-    const response = await this.requestNativeSessionRpc({
-      userId: input.userId,
-      sessionId: input.sessionId,
-      method: "thread/goal/set",
-      requestKind: "thread-goal-set",
-      params: {
-        ...(input.objective !== undefined
-          ? { objective: input.objective }
-          : {}),
-        ...(input.status !== undefined ? { status: input.status } : {}),
-      },
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_goal_update_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return nativeThreadGoal(response);
-  }
-
-  async clearSessionGoal(input: { userId: string; sessionId: string }) {
-    const response = await this.requestNativeSessionRpc({
-      ...input,
-      method: "thread/goal/clear",
-      requestKind: "thread-goal-clear",
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_goal_clear_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return { goal: null };
-  }
-
-  async readSessionPersonality(input: {
-    userId: string;
-    sessionId: string;
-  }): Promise<CodexPersonalitySettings> {
-    const sessionRuntime = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
-    const runtime = await this.environmentRuntimeForSession(
-      input.userId,
-      input.sessionId,
-    );
-    const [config, models] = await Promise.all([
-      this.readEnvironmentCodexConfig(sessionRuntime.environmentId, runtime),
-      this.listModelsFromRuntime(
-        sessionRuntime.environmentId,
-        runtime,
-        input.sessionId,
-        input.sessionId,
-      ),
-    ]);
-    return {
-      personality: codexPersonality(config.config.personality),
-      supported: modelSupportsPersonality(
-        models.data,
-        sessionRuntime.modelId,
-      ),
-    };
-  }
-
-  async readEnvironmentPersonality(
-    userId: string,
-    environmentId: string,
-  ): Promise<CodexPersonalitySettings> {
-    const runtime = await this.environmentRuntimeForEnvironment(
-      userId,
-      environmentId,
-    );
-    const config = await this.readEnvironmentCodexConfig(
-      environmentId,
-      runtime,
-    );
-    return {
-      personality: codexPersonality(config.config.personality),
-      supported: true,
-    };
-  }
-
-  async setSessionPersonality(input: {
-    userId: string;
-    sessionId: string;
-    personality: CodexPersonalitySelection;
-  }): Promise<CodexPersonalitySettings> {
-    requireCodexPersonality(input.personality);
-    const sessionRuntime = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
-    const runtime = await this.environmentRuntimeForSession(
-      input.userId,
-      input.sessionId,
-    );
-    const models = await this.listModelsFromRuntime(
-      sessionRuntime.environmentId,
-      runtime,
-      input.sessionId,
-      input.sessionId,
-    );
-    if (!modelSupportsPersonality(models.data, sessionRuntime.modelId)) {
-      throw new HttpError(
-        409,
-        "codex_personality_unsupported",
-        "The current Codex model does not support personalities.",
-      );
-    }
-    await this.writeCodexConfigValue(sessionRuntime.environmentId, runtime, {
-      keyPath: "personality",
-      value: input.personality,
-    });
-    const effectiveConfig = await this.readEnvironmentCodexConfig(
-      sessionRuntime.environmentId,
-      runtime,
-    );
-    const personality = codexPersonality(effectiveConfig.config.personality);
-    const response = await this.requestNativeSessionRpc({
-      userId: input.userId,
-      sessionId: input.sessionId,
-      method: "thread/settings/update",
-      requestKind: "thread-personality-update",
-      params: { personality },
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_personality_update_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return { personality, supported: true };
-  }
-
-  async setEnvironmentPersonality(input: {
-    userId: string;
-    environmentId: string;
-    personality: CodexPersonalitySelection;
-  }): Promise<CodexPersonalitySettings> {
-    requireCodexPersonality(input.personality);
-    const runtime = await this.environmentRuntimeForEnvironment(
-      input.userId,
-      input.environmentId,
-    );
-    await this.writeCodexConfigValue(input.environmentId, runtime, {
-      keyPath: "personality",
-      value: input.personality,
-    });
-    const config = await this.readEnvironmentCodexConfig(
-      input.environmentId,
-      runtime,
-    );
-    return {
-      personality: codexPersonality(config.config.personality),
-      supported: true,
-    };
-  }
-
-  async accountTokenUsageForEnvironment(
-    userId: string,
-    environmentId: string,
-  ): Promise<CodexTokenUsage> {
-    const runtime = await this.environmentRuntimeForEnvironment(
-      userId,
-      environmentId,
-    );
-    const response = await this.requestCodex(environmentId, runtime, {
-      method: "account/usage/read",
-      id: rpcId("account-token-usage", environmentId),
-    });
-    const result = requireSafeRpcResult(
-      response,
-      "codex_account_usage_read_failed",
-      "Codex could not read account token activity.",
-    );
-    return codexTokenUsage(result);
-  }
-
   async readEnvironmentMemories(
     userId: string,
     environmentId: string,
@@ -1073,58 +754,6 @@ export class CodexService {
     );
   }
 
-  async readSessionMemories(input: {
-    userId: string;
-    sessionId: string;
-  }): Promise<CodexMemoriesSettings> {
-    const session = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
-    return this.readEnvironmentMemories(input.userId, session.environmentId);
-  }
-
-  async setSessionMemories(input: {
-    userId: string;
-    sessionId: string;
-    settings: CodexMemoriesSettings;
-  }): Promise<CodexMemoriesSettings> {
-    const session = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
-    const runtime = await this.environmentRuntimeForSession(
-      input.userId,
-      input.sessionId,
-    );
-    const settings = await this.writeEnvironmentMemorySettings(
-      session.environmentId,
-      runtime,
-      input.settings,
-    );
-    const response = await this.requestNativeSessionRpc({
-      userId: input.userId,
-      sessionId: input.sessionId,
-      method: "thread/memoryMode/set",
-      requestKind: "thread-memory-mode-set",
-      params: {
-        mode:
-          settings.featureEnabled &&
-          settings.generateMemories
-            ? "enabled"
-            : "disabled",
-      },
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_memory_mode_update_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return settings;
-  }
-
   async resetEnvironmentMemories(userId: string, environmentId: string) {
     const runtime = await this.environmentRuntimeForEnvironment(
       userId,
@@ -1142,159 +771,6 @@ export class CodexService {
     return { reset: true };
   }
 
-  async listEnvironmentHooks(
-    userId: string,
-    environmentId: string,
-  ): Promise<CodexHooksInventory> {
-    const runtime = await this.environmentRuntimeForEnvironment(
-      userId,
-      environmentId,
-    );
-    return this.readEnvironmentHooks(environmentId, runtime);
-  }
-
-  async updateEnvironmentHook(input: {
-    userId: string;
-    environmentId: string;
-    key: string;
-    enabled?: boolean;
-    trustedHash?: string;
-  }): Promise<CodexHooksInventory> {
-    const runtime = await this.environmentRuntimeForEnvironment(
-      input.userId,
-      input.environmentId,
-    );
-    const inventory = await this.readEnvironmentHooks(
-      input.environmentId,
-      runtime,
-    );
-    const hook = inventory.hooks.find((candidate) => candidate.key === input.key);
-    if (!hook) {
-      throw new HttpError(
-        404,
-        "codex_hook_not_found",
-        "The Codex hook is no longer available in this Environment.",
-      );
-    }
-    if (hook.isManaged) {
-      throw new HttpError(
-        409,
-        "codex_hook_managed",
-        "Managed Codex hooks cannot be changed by the user.",
-      );
-    }
-    if (
-      input.trustedHash !== undefined &&
-      input.trustedHash !== hook.currentHash
-    ) {
-      throw new HttpError(
-        409,
-        "codex_hook_definition_changed",
-        "The Codex hook changed before it could be trusted. Refresh and review it again.",
-      );
-    }
-    const state: Record<string, unknown> = {};
-    if (input.enabled !== undefined) state.enabled = input.enabled;
-    if (input.trustedHash !== undefined) {
-      state.trusted_hash = input.trustedHash;
-    }
-    const response = await this.requestCodex(input.environmentId, runtime, {
-      method: "config/batchWrite",
-      id: rpcId("hooks-config-write", input.environmentId),
-      params: {
-        edits: [
-          {
-            keyPath: "hooks.state",
-            value: { [hook.key]: state },
-            mergeStrategy: "upsert",
-          },
-        ],
-        reloadUserConfig: true,
-      },
-    });
-    requireEffectiveConfigWrite(
-      response,
-      "codex_hook_update_failed",
-      "Codex could not update the hook.",
-    );
-    return this.readEnvironmentHooks(input.environmentId, runtime);
-  }
-
-  async listSessionBackgroundTerminals(input: {
-    userId: string;
-    sessionId: string;
-  }): Promise<CodexBackgroundTerminals> {
-    const terminals: CodexBackgroundTerminal[] = [];
-    let cursor: string | undefined;
-    do {
-      const response = await this.requestNativeSessionRpc({
-        userId: input.userId,
-        sessionId: input.sessionId,
-        method: "thread/backgroundTerminals/list",
-        requestKind: "background-terminals-list",
-        params: {
-          limit: CODEX_BACKGROUND_TERMINAL_PAGE_LIMIT,
-          ...(cursor ? { cursor } : {}),
-        },
-      });
-      const result = requireRpcResult(
-        response,
-        "codex_background_terminals_list_failed",
-        "Codex could not list background terminals.",
-      );
-      const page = codexBackgroundTerminalsPage(result);
-      terminals.push(...page.data);
-      if (terminals.length > MAX_CODEX_BACKGROUND_TERMINALS) {
-        throw new HttpError(
-          502,
-          "codex_background_terminals_list_failed",
-          "Codex returned too many background terminals.",
-        );
-      }
-      cursor = page.nextCursor;
-    } while (cursor);
-    return { terminals };
-  }
-
-  async cleanSessionBackgroundTerminals(input: {
-    userId: string;
-    sessionId: string;
-  }) {
-    const response = await this.requestNativeSessionRpc({
-      ...input,
-      method: "thread/backgroundTerminals/clean",
-      requestKind: "background-terminals-clean",
-    });
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_background_terminals_clean_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    return { cleaned: true };
-  }
-
-  async terminateSessionBackgroundTerminal(input: {
-    userId: string;
-    sessionId: string;
-    processId: string;
-  }) {
-    const response = await this.requestNativeSessionRpc({
-      userId: input.userId,
-      sessionId: input.sessionId,
-      method: "thread/backgroundTerminals/terminate",
-      requestKind: "background-terminal-terminate",
-      params: { processId: input.processId },
-    });
-    const result = requireRpcResult(
-      response,
-      "codex_background_terminal_terminate_failed",
-      "Codex could not terminate the background terminal.",
-    );
-    return { terminated: objectBoolean(result, "terminated") === true };
-  }
-
   /**
    * A native fork always becomes a child product Session. Do not replace the
    * source Session's Thread to emulate edit/delete: Codex history can branch,
@@ -2053,23 +1529,6 @@ export class CodexService {
     return codexMemoriesSettings(config.config);
   }
 
-  private async readEnvironmentHooks(
-    environmentId: string,
-    runtime: StoredEnvironmentRuntime,
-  ): Promise<CodexHooksInventory> {
-    const response = await this.requestCodex(environmentId, runtime, {
-      method: "hooks/list",
-      id: rpcId("hooks-list", environmentId),
-      params: { cwds: [CODEX_ENVIRONMENT_CWD] },
-    });
-    const result = requireRpcResult(
-      response,
-      "codex_hooks_list_failed",
-      "Codex could not list Environment hooks.",
-    );
-    return codexHooksInventory(result);
-  }
-
   private async writeCodexConfigValue(
     environmentId: string,
     runtime: StoredEnvironmentRuntime,
@@ -2466,117 +1925,21 @@ export class CodexService {
       this.ensureEnvironmentWorker(sessionRuntime.environmentId);
       return { requestId, clientMessageId, nativeTurnId };
     } finally {
-      releaseInteractiveOperation();
-    }
-  }
-
-  async listModels(userId: string, sessionId: string) {
-    const environmentRuntime = await this.environmentRuntimeForSession(
-      userId,
-      sessionId,
-    );
-    return this.listModelsFromRuntime(
-      environmentRuntime.id,
-      environmentRuntime,
-      sessionId,
-      sessionId,
-    );
-  }
-
-  /**
-   * Reads the native AgentControl tree directly from Codex. The relationship
-   * query is persisted by app-server, so completed descendants remain visible
-   * after either Sandpi or the Environment runtime restarts.
-   */
-  async listSessionAgentThreads(input: {
-    userId: string;
-    sessionId: string;
-  }): Promise<CodexAgentThreads> {
-    const sessionRuntime = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
-    const environmentRuntime = await this.environmentRuntimeForSession(
-      input.userId,
-      input.sessionId,
-    );
-    return this.readNativeAgentTree(
-      environmentRuntime,
-      sessionRuntime,
-      input.sessionId,
-    );
+      releaseInteractiveOperation();
+    }
   }
 
-  /**
-   * Reads one root or descendant Thread without converting it into a Sandpi
-   * Session. The ancestor check prevents arbitrary same-Environment Thread
-   * reads while keeping Codex as the only transcript authority.
-   */
-  async readSessionAgentThread(input: {
-    userId: string;
-    sessionId: string;
-    nativeThreadId: string;
-  }) {
-    const sessionRuntime = await this.requireNativeSessionRuntime(
-      input.userId,
-      input.sessionId,
-    );
+  async listModels(userId: string, sessionId: string) {
     const environmentRuntime = await this.environmentRuntimeForSession(
-      input.userId,
-      input.sessionId,
+      userId,
+      sessionId,
     );
-    const tree = await this.readNativeAgentTree(
+    return this.listModelsFromRuntime(
+      environmentRuntime.id,
       environmentRuntime,
-      sessionRuntime,
-      input.sessionId,
+      sessionId,
+      sessionId,
     );
-    if (
-      input.nativeThreadId !== tree.root.id &&
-      !tree.descendants.some((thread) => thread.id === input.nativeThreadId)
-    ) {
-      throw new HttpError(
-        404,
-        "codex_agent_thread_not_found",
-        "The requested Codex Agent Thread does not belong to this Session.",
-      );
-    }
-
-    const read = (includeTurns: boolean) =>
-      this.requestCodex(
-        sessionRuntime.environmentId,
-        environmentRuntime,
-        {
-          method: "thread/read",
-          id: rpcId("agent-thread-read", input.sessionId),
-          params: {
-            threadId: input.nativeThreadId,
-            includeTurns,
-          },
-        },
-        input.sessionId,
-      );
-    let response = await read(true);
-    if (
-      response.error &&
-      canFallbackFromAgentThreadHistoryError(response.error)
-    ) {
-      response = await read(false);
-    }
-    if (response.error) {
-      throw new HttpError(
-        502,
-        "codex_agent_thread_read_failed",
-        rpcErrorMessage(response.error),
-      );
-    }
-    const thread = threadFromRpcResponse(response);
-    if (!thread || thread.id !== input.nativeThreadId) {
-      throw invalidCodexResponse(
-        "codex_agent_thread_read_failed",
-        "Codex returned an invalid Agent Thread.",
-      );
-    }
-    return thread;
   }
 
   async listEnvironmentModels(userId: string, environmentId: string) {
@@ -4988,84 +4351,6 @@ export class CodexService {
     return thread;
   }
 
-  private async readNativeAgentTree(
-    environmentRuntime: StoredEnvironmentRuntime,
-    sessionRuntime: StoredSessionRuntime & { nativeSessionId: string },
-    ownerSessionId: string,
-  ): Promise<CodexAgentThreads> {
-    const rootResponse = await this.requestCodex(
-      sessionRuntime.environmentId,
-      environmentRuntime,
-      {
-        method: "thread/read",
-        id: rpcId("agent-root-read", ownerSessionId),
-        params: {
-          threadId: sessionRuntime.nativeSessionId,
-          includeTurns: false,
-        },
-      },
-      ownerSessionId,
-    );
-    if (rootResponse.error) {
-      throw nativeSessionUnavailable(rootResponse.error);
-    }
-    const root = threadFromRpcResponse(rootResponse);
-    if (!root || root.id !== sessionRuntime.nativeSessionId) {
-      throw invalidCodexResponse(
-        "codex_agent_threads_list_failed",
-        "Codex returned an invalid root Agent Thread.",
-      );
-    }
-
-    const descendants: CodexThread[] = [];
-    const cursors = new Set<string>();
-    let cursor: string | undefined;
-    do {
-      const response = await this.requestCodex(
-        sessionRuntime.environmentId,
-        environmentRuntime,
-        {
-          method: "thread/list",
-          id: rpcId("agent-thread-list", ownerSessionId),
-          params: {
-            ancestorThreadId: sessionRuntime.nativeSessionId,
-            limit: CODEX_AGENT_THREAD_PAGE_LIMIT,
-            ...(cursor ? { cursor } : {}),
-          },
-        },
-        ownerSessionId,
-      );
-      if (response.error) {
-        throw new HttpError(
-          502,
-          "codex_agent_threads_list_failed",
-          rpcErrorMessage(response.error),
-        );
-      }
-      const page = threadListPage(response.result);
-      descendants.push(...page.data);
-      if (descendants.length > MAX_CODEX_AGENT_THREADS) {
-        throw invalidCodexResponse(
-          "codex_agent_threads_list_failed",
-          "Codex returned too many Agent Threads.",
-        );
-      }
-      cursor = page.nextCursor;
-      if (cursor && cursors.has(cursor)) {
-        throw invalidCodexResponse(
-          "codex_agent_threads_list_failed",
-          "Codex returned a repeated Agent Thread cursor.",
-        );
-      }
-      if (cursor) cursors.add(cursor);
-    } while (cursor);
-
-    return {
-      root,
-      descendants: validateAgentThreadTree(root.id, descendants),
-    };
-  }
-
   /**
    * A native Thread is durable before app-server answers thread/start or
    * thread/fork. The Sandpi Session id is carried in ThreadSource so a lost
@@ -5847,7 +5132,7 @@ function threadConfiguration(input: {
   reasoningEffort?: string;
   collaborationMode?: "plan";
   serviceTier?: string;
-}, sessionStartSource?: "startup" | "clear") {
+}) {
   return {
     ...(input.modelId ? { model: input.modelId } : {}),
     config: {
@@ -5866,7 +5151,6 @@ function threadConfiguration(input: {
     cwd: CODEX_ENVIRONMENT_CWD,
     approvalPolicy: "never",
     sandbox: "danger-full-access",
-    ...(sessionStartSource ? { sessionStartSource } : {}),
   };
 }
 
@@ -5921,60 +5205,6 @@ function threadListPage(
   };
 }
 
-function validateAgentThreadTree(
-  rootThreadId: string,
-  descendants: CodexThread[],
-) {
-  const byId = new Map<string, CodexThread>();
-  for (const thread of descendants) {
-    if (thread.id === rootThreadId || byId.has(thread.id)) {
-      throw invalidCodexResponse(
-        "codex_agent_threads_list_failed",
-        "Codex returned a duplicate Agent Thread.",
-      );
-    }
-    if (!thread.parentThreadId) {
-      throw invalidCodexResponse(
-        "codex_agent_threads_list_failed",
-        "Codex returned an Agent Thread without its parent relation.",
-      );
-    }
-    byId.set(thread.id, thread);
-  }
-
-  const accepted = new Set([rootThreadId]);
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const thread of descendants) {
-      if (
-        !accepted.has(thread.id) &&
-        thread.parentThreadId &&
-        accepted.has(thread.parentThreadId)
-      ) {
-        accepted.add(thread.id);
-        changed = true;
-      }
-    }
-  }
-  if (accepted.size !== descendants.length + 1) {
-    throw invalidCodexResponse(
-      "codex_agent_threads_list_failed",
-      "Codex returned an Agent Thread outside the requested Session tree.",
-    );
-  }
-  return descendants;
-}
-
-function canFallbackFromAgentThreadHistoryError(error: unknown) {
-  const message = rpcErrorMessage(error).toLowerCase();
-  return (
-    message.includes("does not support thread/read(includeturns=true)") ||
-    message.includes("includeTurns is unavailable".toLowerCase()) ||
-    message.includes("ephemeral threads do not support includeturns")
-  );
-}
-
 function isUnmaterializedNativeThreadError(error: unknown) {
   const message = rpcErrorMessage(error).toLowerCase();
   return (
@@ -5991,31 +5221,6 @@ function steeredTurnIdFromRpcResponse(response: Record<string, unknown>) {
   return objectString(objectRecord(response.result), "turnId");
 }
 
-function nativeThreadGoal(response: Record<string, unknown>) {
-  const result = objectRecord(response.result);
-  const goalValue = result?.goal;
-  if (goalValue === null || goalValue === undefined) return { goal: null };
-  const goal = objectRecord(goalValue);
-  const objective = objectString(goal, "objective");
-  const status = objectString(goal, "status");
-  if (!goal || !objective || !status) {
-    throw new HttpError(
-      502,
-      "codex_goal_invalid_response",
-      "Codex returned an invalid native Session goal.",
-    );
-  }
-  return {
-    goal: {
-      objective,
-      status,
-      tokenBudget: objectNumber(goal, "tokenBudget") ?? null,
-      tokensUsed: objectNumber(goal, "tokensUsed") ?? 0,
-      timeUsedSeconds: objectNumber(goal, "timeUsedSeconds") ?? 0,
-    },
-  };
-}
-
 function requireRpcResult(
   response: Record<string, unknown>,
   code: string,
@@ -6626,97 +5831,6 @@ function codexMcpAuthStatus(value: string | undefined): CodexMcpAuthStatus {
     : "unknown";
 }
 
-function requireCodexPersonality(
-  value: string,
-): asserts value is CodexPersonalitySelection {
-  if (!CODEX_PERSONALITY_SELECTIONS.has(value as CodexPersonalitySelection)) {
-    throw new HttpError(
-      400,
-      "codex_personality_invalid",
-      "Codex personality must be friendly or pragmatic.",
-    );
-  }
-}
-
-function codexPersonality(value: unknown): CodexPersonality {
-  // Codex TUI presents its absent config value as Friendly and offers only the
-  // Friendly and Pragmatic choices. Preserve that native command behavior.
-  if (value === undefined || value === null) return "friendly";
-  if (
-    typeof value === "string" &&
-    CODEX_PERSONALITIES.has(value as CodexPersonality)
-  ) {
-    return value as CodexPersonality;
-  }
-  throw invalidCodexResponse(
-    "codex_config_read_failed",
-    "Codex returned an unknown effective personality.",
-  );
-}
-
-function modelSupportsPersonality(
-  models: readonly unknown[],
-  modelId: string | undefined,
-) {
-  if (!modelId) return false;
-  const model = models
-    .map(objectRecord)
-    .find(
-      (candidate) =>
-        objectString(candidate, "id") === modelId ||
-        objectString(candidate, "model") === modelId,
-    );
-  return objectBoolean(model, "supportsPersonality") === true;
-}
-
-function codexTokenUsage(result: Record<string, unknown>): CodexTokenUsage {
-  const summary = objectRecord(result.summary);
-  if (!summary) {
-    throw invalidCodexResponse(
-      "codex_account_usage_read_failed",
-      "Codex returned an invalid account token-activity summary.",
-    );
-  }
-  const bucketsValue = result.dailyUsageBuckets;
-  if (
-    bucketsValue !== undefined &&
-    bucketsValue !== null &&
-    !Array.isArray(bucketsValue)
-  ) {
-    throw invalidCodexResponse(
-      "codex_account_usage_read_failed",
-      "Codex returned invalid account token-activity buckets.",
-    );
-  }
-  const dailyUsageBuckets = (Array.isArray(bucketsValue)
-    ? bucketsValue
-    : []
-  ).map((value) => {
-    const bucket = objectRecord(value);
-    const startDate = objectString(bucket, "startDate");
-    const tokens = boundedNonnegativeInteger(bucket?.tokens);
-    if (!startDate || tokens === undefined) {
-      throw invalidCodexResponse(
-        "codex_account_usage_read_failed",
-        "Codex returned an invalid account token-activity bucket.",
-      );
-    }
-    return { startDate, tokens };
-  });
-  return {
-    summary: {
-      lifetimeTokens: nullableNonnegativeInteger(summary.lifetimeTokens),
-      peakDailyTokens: nullableNonnegativeInteger(summary.peakDailyTokens),
-      longestRunningTurnSec: nullableNonnegativeInteger(
-        summary.longestRunningTurnSec,
-      ),
-      currentStreakDays: nullableNonnegativeInteger(summary.currentStreakDays),
-      longestStreakDays: nullableNonnegativeInteger(summary.longestStreakDays),
-    },
-    dailyUsageBuckets,
-  };
-}
-
 function codexMemoriesSettings(
   config: Record<string, unknown>,
 ): CodexMemoriesSettings {
@@ -6734,201 +5848,6 @@ function codexMemoriesSettings(
   };
 }
 
-function codexHooksInventory(
-  result: Record<string, unknown>,
-): CodexHooksInventory {
-  if (!Array.isArray(result.data)) {
-    throw invalidCodexResponse(
-      "codex_hooks_list_failed",
-      "Codex returned an invalid hooks inventory.",
-    );
-  }
-  const entry = result.data
-    .map(objectRecord)
-    .find((candidate) => objectString(candidate, "cwd") === CODEX_ENVIRONMENT_CWD);
-  if (!entry) {
-    return {
-      cwd: CODEX_ENVIRONMENT_CWD,
-      hooks: [],
-      warnings: [],
-      errors: [],
-    };
-  }
-  if (
-    !Array.isArray(entry.hooks) ||
-    !Array.isArray(entry.warnings) ||
-    !Array.isArray(entry.errors)
-  ) {
-    throw invalidCodexResponse(
-      "codex_hooks_list_failed",
-      "Codex returned an invalid hooks inventory entry.",
-    );
-  }
-  const hooks = entry.hooks.map(codexHook);
-  const warnings = entry.warnings.filter(
-    (value): value is string => typeof value === "string",
-  );
-  const errors = entry.errors.flatMap((value): CodexHookIssue[] => {
-    const issue = objectRecord(value);
-    const message = objectString(issue, "message");
-    if (!message) return [];
-    const issuePath = objectString(issue, "path");
-    return [{ ...(issuePath ? { path: issuePath } : {}), message }];
-  });
-  return {
-    cwd: CODEX_ENVIRONMENT_CWD,
-    hooks: hooks.sort(
-      (left, right) =>
-        left.displayOrder - right.displayOrder ||
-        left.eventName.localeCompare(right.eventName),
-    ),
-    warnings,
-    errors,
-  };
-}
-
-function codexHook(value: unknown): CodexHook {
-  const hook = objectRecord(value);
-  if (!hook) {
-    throw invalidCodexResponse(
-      "codex_hooks_list_failed",
-      "Codex returned an invalid hook.",
-    );
-  }
-  const key = objectString(hook, "key");
-  const eventName = objectString(hook, "eventName");
-  const handlerType = objectString(hook, "handlerType");
-  const source = objectString(hook, "source");
-  const currentHash = objectString(hook, "currentHash");
-  const trustStatus = objectString(hook, "trustStatus");
-  const displayOrder = boundedInteger(hook?.displayOrder);
-  const timeoutSec = boundedNonnegativeInteger(hook.timeoutSec);
-  const enabled = objectBoolean(hook, "enabled");
-  const isManaged = objectBoolean(hook, "isManaged");
-  const sourcePath = objectString(hook, "sourcePath");
-  if (
-    !key ||
-    !eventName ||
-    !handlerType ||
-    !source ||
-    !currentHash ||
-    !["managed", "untrusted", "trusted", "modified"].includes(
-      trustStatus ?? "",
-    ) ||
-    displayOrder === undefined ||
-    timeoutSec === undefined ||
-    enabled === undefined ||
-    isManaged === undefined ||
-    !sourcePath
-  ) {
-    throw invalidCodexResponse(
-      "codex_hooks_list_failed",
-      "Codex returned an invalid hook.",
-    );
-  }
-  return {
-    key,
-    eventName,
-    handlerType,
-    isManaged,
-    source,
-    displayOrder,
-    enabled,
-    currentHash,
-    trustStatus: trustStatus as CodexHook["trustStatus"],
-    matcher: objectString(hook, "matcher") ?? null,
-    command: objectString(hook, "command") ?? null,
-    timeoutSec,
-    statusMessage: objectString(hook, "statusMessage") ?? null,
-    sourcePath,
-    pluginId: objectString(hook, "pluginId") ?? null,
-  };
-}
-
-function codexBackgroundTerminalsPage(result: Record<string, unknown>) {
-  if (!Array.isArray(result.data)) {
-    throw invalidCodexResponse(
-      "codex_background_terminals_list_failed",
-      "Codex returned an invalid background-terminal list.",
-    );
-  }
-  const data = result.data.map((value): CodexBackgroundTerminal => {
-    const terminal = objectRecord(value);
-    const itemId = objectString(terminal, "itemId");
-    const processId = objectString(terminal, "processId");
-    const command = objectString(terminal, "command");
-    const cwd = objectString(terminal, "cwd");
-    if (!itemId || !processId || command === undefined || !cwd) {
-      throw invalidCodexResponse(
-        "codex_background_terminals_list_failed",
-        "Codex returned an invalid background terminal.",
-      );
-    }
-    return {
-      itemId,
-      processId,
-      command,
-      cwd,
-      osPid: nullableNonnegativeInteger(terminal?.osPid),
-      cpuPercent: nullableFiniteNumber(terminal?.cpuPercent),
-      rssKb: nullableNonnegativeInteger(terminal?.rssKb),
-    };
-  });
-  const nextCursor = result.nextCursor;
-  if (
-    nextCursor !== undefined &&
-    nextCursor !== null &&
-    typeof nextCursor !== "string"
-  ) {
-    throw invalidCodexResponse(
-      "codex_background_terminals_list_failed",
-      "Codex returned an invalid background-terminal cursor.",
-    );
-  }
-  return {
-    data,
-    nextCursor:
-      typeof nextCursor === "string" && nextCursor ? nextCursor : undefined,
-  };
-}
-
-function boundedNonnegativeInteger(value: unknown) {
-  return typeof value === "number" &&
-    Number.isSafeInteger(value) &&
-    value >= 0
-    ? value
-    : undefined;
-}
-
-function boundedInteger(value: unknown) {
-  return typeof value === "number" && Number.isSafeInteger(value)
-    ? value
-    : undefined;
-}
-
-function nullableNonnegativeInteger(value: unknown): number | null {
-  if (value === undefined || value === null) return null;
-  const parsed = boundedNonnegativeInteger(value);
-  if (parsed === undefined) {
-    throw invalidCodexResponse(
-      "codex_native_number_invalid",
-      "Codex returned an invalid numeric value.",
-    );
-  }
-  return parsed;
-}
-
-function nullableFiniteNumber(value: unknown): number | null {
-  if (value === undefined || value === null) return null;
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw invalidCodexResponse(
-      "codex_native_number_invalid",
-      "Codex returned an invalid numeric value.",
-    );
-  }
-  return value;
-}
-
 function modelListPage(result: unknown) {
   const page = objectRecord(result);
   if (!page || !Array.isArray(page.data)) {
@@ -7134,7 +6053,6 @@ function sessionCreationRequestFingerprint(input: CreateSessionInput) {
         input.reasoningEffort ?? null,
         input.collaborationMode ?? null,
         input.serviceTier ?? null,
-        input.sessionStartSource ?? null,
       ]),
     )
     .digest("hex");
diff --git a/src/server/openapi/contracts.ts b/src/server/openapi/contracts.ts
index 2be0071..675dc06 100644
--- a/src/server/openapi/contracts.ts
+++ b/src/server/openapi/contracts.ts
@@ -5,11 +5,9 @@ import { WORKSPACE_ROOT } from "@/lib/workspace-path-policy";
 import {
   billingCheckoutSchema,
   codexComposerUploadSchema,
-  codexHookUpdateSchema,
   codexMcpServerConfigurationSchema,
   codexMcpServerEnabledSchema,
   codexMemoriesSettingsSchema,
-  codexPersonalitySelectionSchema,
   codexRateLimitResetSchema,
   codexSkillConfigurationSchema,
   codexSkillPutSchema,
@@ -23,9 +21,7 @@ import {
   rotateEnvironmentWebhookSecretSchema,
   sessionCreateSchema,
   sessionForkSchema,
-  sessionGoalUpdateSchema,
   sessionMetadataSchema,
-  sessionReviewSchema,
   turnCreateSchema,
   turnInterruptSchema,
   turnSteerSchema,
@@ -41,16 +37,12 @@ import {
   rotateEnvironmentEgressCredentialSchema,
 } from "@/server/environment-credentials-schema";
 import {
-  acceptedResultSchema,
-  backgroundTerminalsSchema,
   billingSummarySchema,
   bootstrapSchema,
   checkoutResultSchema,
   cloudSnapshotSchema,
   codexAccountSchema,
-  codexAgentThreadsSchema,
   codexRateLimitsSchema,
-  codexThreadSchema,
   codingSessionSchema,
   composerUploadSchema,
   customerPortalResultSchema,
@@ -69,20 +61,15 @@ import {
   environmentWebhookSetupSchema,
   environmentSchema,
   errorSchema,
-  hooksInventorySchema,
   idResultSchema,
   mcpInventorySchema,
   mcpOAuthLoginSchema,
   memoriesSettingsSchema,
-  nativeTurnResultSchema,
-  personalitySettingsSchema,
   principalSchema,
   rateLimitResetResultSchema,
   resourceMetricsSchema,
   sandpiPreferencesSchema,
-  sessionGoalSchema,
   skillsInventorySchema,
-  tokenUsageSchema,
   turnInterruptResultSchema,
   turnSubmissionResultSchema,
   workspaceBackupSchema,
@@ -1017,37 +1004,6 @@ export const openApiRouteContracts: readonly OpenApiRouteContract[] = [
       "x-sandpi-native-schema": "codex-app-server",
     },
   }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/environments/:environmentId/harnesses/codex/personality",
-    schema: {
-      operationId: "getEnvironmentCodexPersonality",
-      summary: "Get the Environment Codex personality",
-      tags: ["Codex"],
-      response: { 200: dataEnvelope(personalitySettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "PUT",
-    url: "/api/v1/environments/:environmentId/harnesses/codex/personality",
-    schema: {
-      operationId: "setEnvironmentCodexPersonality",
-      summary: "Set the Environment Codex personality",
-      tags: ["Codex"],
-      body: codexPersonalitySelectionSchema,
-      response: { 200: dataEnvelope(personalitySettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/environments/:environmentId/harnesses/codex/token-usage",
-    schema: {
-      operationId: "getCodexTokenUsage",
-      summary: "Get Codex account token usage",
-      tags: ["Codex"],
-      response: { 200: dataEnvelope(tokenUsageSchema) },
-    },
-  }),
   defineContract({
     method: "GET",
     url: "/api/v1/environments/:environmentId/harnesses/codex/memories",
@@ -1081,27 +1037,6 @@ export const openApiRouteContracts: readonly OpenApiRouteContract[] = [
       },
     },
   }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/environments/:environmentId/harnesses/codex/hooks",
-    schema: {
-      operationId: "listEnvironmentCodexHooks",
-      summary: "List Environment Codex hooks",
-      tags: ["Codex"],
-      response: { 200: dataEnvelope(hooksInventorySchema) },
-    },
-  }),
-  defineContract({
-    method: "PUT",
-    url: "/api/v1/environments/:environmentId/harnesses/codex/hooks",
-    schema: {
-      operationId: "updateEnvironmentCodexHook",
-      summary: "Update one Environment Codex hook",
-      tags: ["Codex"],
-      body: codexHookUpdateSchema,
-      response: { 200: dataEnvelope(hooksInventorySchema) },
-    },
-  }),
   defineContract({
     method: "POST",
     url: "/api/v1/environments/:environmentId/harnesses/codex/uploads",
@@ -1286,135 +1221,6 @@ export const openApiRouteContracts: readonly OpenApiRouteContract[] = [
       response: { 202: dataEnvelope(turnInterruptResultSchema) },
     },
   }),
-  defineContract({
-    method: "POST",
-    url: "/api/v1/sessions/:sessionId/compact",
-    schema: {
-      operationId: "compactSession",
-      summary: "Start native Session compaction",
-      tags: ["Sessions"],
-      response: { 202: dataEnvelope(acceptedResultSchema) },
-    },
-  }),
-  defineContract({
-    method: "POST",
-    url: "/api/v1/sessions/:sessionId/review",
-    schema: {
-      operationId: "startSessionReview",
-      summary: "Start an inline native code review",
-      tags: ["Sessions"],
-      body: sessionReviewSchema,
-      response: { 202: dataEnvelope(nativeTurnResultSchema) },
-      "x-sandpi-optional-request-body": true,
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/goal",
-    schema: {
-      operationId: "getSessionGoal",
-      summary: "Get the native Session goal",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(sessionGoalSchema) },
-    },
-  }),
-  defineContract({
-    method: "PUT",
-    url: "/api/v1/sessions/:sessionId/goal",
-    schema: {
-      operationId: "updateSessionGoal",
-      summary: "Update the native Session goal",
-      tags: ["Sessions"],
-      body: sessionGoalUpdateSchema,
-      response: { 200: dataEnvelope(sessionGoalSchema) },
-    },
-  }),
-  defineContract({
-    method: "DELETE",
-    url: "/api/v1/sessions/:sessionId/goal",
-    schema: {
-      operationId: "clearSessionGoal",
-      summary: "Clear the native Session goal",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(sessionGoalSchema) },
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/personality",
-    schema: {
-      operationId: "getSessionCodexPersonality",
-      summary: "Get the Session Codex personality",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(personalitySettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "PUT",
-    url: "/api/v1/sessions/:sessionId/personality",
-    schema: {
-      operationId: "setSessionCodexPersonality",
-      summary: "Set the Session Codex personality",
-      tags: ["Sessions"],
-      body: codexPersonalitySelectionSchema,
-      response: { 200: dataEnvelope(personalitySettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/memories",
-    schema: {
-      operationId: "getSessionCodexMemories",
-      summary: "Get Session Codex memory settings",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(memoriesSettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "PUT",
-    url: "/api/v1/sessions/:sessionId/memories",
-    schema: {
-      operationId: "setSessionCodexMemories",
-      summary: "Set Session Codex memory settings",
-      tags: ["Sessions"],
-      body: codexMemoriesSettingsSchema,
-      response: { 200: dataEnvelope(memoriesSettingsSchema) },
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/background-terminals",
-    schema: {
-      operationId: "listSessionBackgroundTerminals",
-      summary: "List Codex background terminals",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(backgroundTerminalsSchema) },
-    },
-  }),
-  defineContract({
-    method: "DELETE",
-    url: "/api/v1/sessions/:sessionId/background-terminals",
-    schema: {
-      operationId: "cleanSessionBackgroundTerminals",
-      summary: "Clean completed Codex background terminals",
-      tags: ["Sessions"],
-      response: {
-        200: dataEnvelope(z.object({ cleaned: z.boolean() })),
-      },
-    },
-  }),
-  defineContract({
-    method: "DELETE",
-    url: "/api/v1/sessions/:sessionId/background-terminals/:processId",
-    schema: {
-      operationId: "terminateSessionBackgroundTerminal",
-      summary: "Terminate one Codex background terminal",
-      tags: ["Sessions"],
-      response: {
-        200: dataEnvelope(z.object({ terminated: z.boolean() })),
-      },
-    },
-  }),
   defineContract({
     method: "POST",
     url: "/api/v1/sessions/:sessionId/fork",
@@ -1450,28 +1256,6 @@ export const openApiRouteContracts: readonly OpenApiRouteContract[] = [
       "x-sandpi-native-schema": "codex-app-server",
     },
   }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/agents",
-    schema: {
-      operationId: "listSessionAgentThreads",
-      summary: "List the native Codex agent-thread tree",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(codexAgentThreadsSchema) },
-      "x-sandpi-native-schema": "codex-app-server",
-    },
-  }),
-  defineContract({
-    method: "GET",
-    url: "/api/v1/sessions/:sessionId/agents/:nativeThreadId",
-    schema: {
-      operationId: "getSessionAgentThread",
-      summary: "Read one native Codex agent Thread",
-      tags: ["Sessions"],
-      response: { 200: dataEnvelope(codexThreadSchema) },
-      "x-sandpi-native-schema": "codex-app-server",
-    },
-  }),
   defineContract({
     method: "GET",
     url: "/api/v1/sessions/:sessionId/events",
diff --git a/src/server/openapi/models.ts b/src/server/openapi/models.ts
index 67da178..6d0b0e9 100644
--- a/src/server/openapi/models.ts
+++ b/src/server/openapi/models.ts
@@ -44,14 +44,9 @@ import type {
   CodexSkillsInventory,
 } from "@/harnesses/codex/environment-tools";
 import type {
-  CodexBackgroundTerminals,
-  CodexHooksInventory,
   CodexMemoriesSettings,
-  CodexPersonalitySettings,
-  CodexTokenUsage,
 } from "@/harnesses/codex/native-capabilities";
 import type {
-  CodexAgentThreads,
   CodexComposerUpload,
   CodexThread,
 } from "@/harnesses/codex/types";
@@ -718,30 +713,6 @@ export const rateLimitResetResultSchema = component(
   }),
 );
 
-export const personalitySettingsSchema = component(
-  "CodexPersonalitySettings",
-  z.object({
-    personality: z.enum(["friendly", "pragmatic", "none"]),
-    supported: z.boolean(),
-  }),
-);
-
-export const tokenUsageSchema = component(
-  "CodexTokenUsage",
-  z.object({
-    summary: z.object({
-      lifetimeTokens: z.number().nullable(),
-      peakDailyTokens: z.number().nullable(),
-      longestRunningTurnSec: z.number().nullable(),
-      currentStreakDays: z.number().nullable(),
-      longestStreakDays: z.number().nullable(),
-    }),
-    dailyUsageBuckets: z.array(
-      z.object({ startDate: z.string(), tokens: z.number() }),
-    ),
-  }),
-);
-
 export const memoriesSettingsSchema = component(
   "CodexMemoriesSettings",
   z.object({
@@ -751,36 +722,6 @@ export const memoriesSettingsSchema = component(
   }),
 );
 
-export const hooksInventorySchema = component(
-  "CodexHooksInventory",
-  z.object({
-    cwd: z.string(),
-    hooks: z.array(
-      z.object({
-        key: z.string(),
-        eventName: z.string(),
-        handlerType: z.string(),
-        isManaged: z.boolean(),
-        matcher: z.string().nullable(),
-        command: z.string().nullable(),
-        timeoutSec: z.number(),
-        statusMessage: z.string().nullable(),
-        sourcePath: z.string(),
-        source: z.string(),
-        pluginId: z.string().nullable(),
-        displayOrder: z.number(),
-        enabled: z.boolean(),
-        currentHash: z.string(),
-        trustStatus: z.enum(["trusted", "untrusted", "modified", "managed"]),
-      }),
-    ),
-    warnings: z.array(z.string()),
-    errors: z.array(
-      z.object({ path: z.string().optional(), message: z.string() }),
-    ),
-  }),
-);
-
 export const composerUploadSchema = component(
   "CodexComposerUpload",
   z.object({
@@ -872,38 +813,6 @@ export const mcpOAuthLoginSchema = component(
   }),
 );
 
-export const sessionGoalSchema = component(
-  "CodexSessionGoal",
-  z.object({
-    goal: z
-      .object({
-        objective: z.string(),
-        status: z.string(),
-        tokenBudget: z.number().nullable(),
-        tokensUsed: z.number(),
-        timeUsedSeconds: z.number(),
-      })
-      .nullable(),
-  }),
-);
-
-export const backgroundTerminalsSchema = component(
-  "CodexBackgroundTerminals",
-  z.object({
-    terminals: z.array(
-      z.object({
-        itemId: z.string(),
-        processId: z.string(),
-        command: z.string(),
-        cwd: z.string(),
-        osPid: z.number().int().nullable(),
-        cpuPercent: z.number().nullable(),
-        rssKb: z.number().nullable(),
-      }),
-    ),
-  }),
-);
-
 const codexThreadStatusSchema = z.union([
   z.object({ type: z.enum(["notLoaded", "idle", "systemError"]) }),
   z.object({
@@ -958,14 +867,6 @@ export const codexThreadSchema = component(
   }),
 );
 
-export const codexAgentThreadsSchema = component(
-  "CodexAgentThreads",
-  z.object({
-    root: codexThreadSchema,
-    descendants: z.array(codexThreadSchema),
-  }),
-);
-
 export const workspaceFileSchema: z.ZodType<WorkspaceFile> = component(
   "WorkspaceFile",
   z.lazy(() =>
@@ -1303,19 +1204,14 @@ const publicModelTypeChecks: {
   credential: z.ZodType<EnvironmentEgressCredential>;
   deviceAuth: z.ZodType<PublicCodexDeviceAuthFlow>;
   codexAccount: z.ZodType<CodexAccountSummary>;
-  codexBackgroundTerminals: z.ZodType<CodexBackgroundTerminals>;
   codexRateLimits: z.ZodType<CodexAccountRateLimits>;
   codexRateLimitReset: z.ZodType<CodexRateLimitResetResult>;
-  codexPersonality: z.ZodType<CodexPersonalitySettings>;
-  codexTokenUsage: z.ZodType<CodexTokenUsage>;
   codexMemories: z.ZodType<CodexMemoriesSettings>;
-  codexHooks: z.ZodType<CodexHooksInventory>;
   codexUpload: z.ZodType<CodexComposerUpload>;
   codexSkills: z.ZodType<CodexSkillsInventory>;
   codexMcp: z.ZodType<CodexMcpInventory>;
   codexMcpOAuth: z.ZodType<CodexMcpOAuthLogin>;
   codexThread: z.ZodType<CodexThread>;
-  codexAgentThreads: z.ZodType<CodexAgentThreads>;
   workspaceFile: z.ZodType<WorkspaceFile>;
   workspaceSearch: z.ZodType<WorkspaceFileSearchResult>;
   workspaceListing: z.ZodType<WorkspaceDirectoryListing>;
@@ -1349,19 +1245,14 @@ const publicModelTypeChecks: {
   credential: egressCredentialSchema,
   deviceAuth: deviceAuthFlowSchema,
   codexAccount: codexAccountSchema,
-  codexBackgroundTerminals: backgroundTerminalsSchema,
   codexRateLimits: codexRateLimitsSchema,
   codexRateLimitReset: rateLimitResetResultSchema,
-  codexPersonality: personalitySettingsSchema,
-  codexTokenUsage: tokenUsageSchema,
   codexMemories: memoriesSettingsSchema,
-  codexHooks: hooksInventorySchema,
   codexUpload: composerUploadSchema,
   codexSkills: skillsInventorySchema,
   codexMcp: mcpInventorySchema,
   codexMcpOAuth: mcpOAuthLoginSchema,
   codexThread: codexThreadSchema,
-  codexAgentThreads: codexAgentThreadsSchema,
   workspaceFile: workspaceFileSchema,
   workspaceSearch: workspaceSearchResultSchema,
   workspaceListing: workspaceDirectoryListingSchema,
diff --git a/src/server/openapi/openapi.test.ts b/src/server/openapi/openapi.test.ts
index a220450..795ecf3 100644
--- a/src/server/openapi/openapi.test.ts
+++ b/src/server/openapi/openapi.test.ts
@@ -24,7 +24,7 @@ test("OpenAPI publishes every supported operation with a unique id", async () =>
   const operations = allOperations(document);
   const operationIds = operations.map((operation) => operation.operationId);
 
-  assert.equal(operations.length, 121);
+  assert.equal(operations.length, 102);
   assert.ok(operationIds.every(Boolean));
   assert.equal(new Set(operationIds).size, operationIds.length);
   assert.ok(Object.keys(document.paths).every((path) => !path.includes(":")));
@@ -85,7 +85,6 @@ test("OpenAPI excludes the removed Browser API and preserves streaming semantics
   );
 
   for (const [path, method] of [
-    ["/api/v1/sessions/{sessionId}/review", "post"],
     ["/api/v1/sessions/{sessionId}/fork", "post"],
     [
       "/api/v1/sessions/{sessionId}/turns/{nativeTurnId}/fork",
@@ -97,6 +96,23 @@ test("OpenAPI excludes the removed Browser API and preserves streaming semantics
     assert.equal(requestBody.required, false);
   }
 
+  for (const path of [
+    "/api/v1/environments/{environmentId}/harnesses/codex/personality",
+    "/api/v1/environments/{environmentId}/harnesses/codex/token-usage",
+    "/api/v1/environments/{environmentId}/harnesses/codex/hooks",
+    "/api/v1/sessions/{sessionId}/compact",
+    "/api/v1/sessions/{sessionId}/review",
+    "/api/v1/sessions/{sessionId}/goal",
+    "/api/v1/sessions/{sessionId}/personality",
+    "/api/v1/sessions/{sessionId}/memories",
+    "/api/v1/sessions/{sessionId}/background-terminals",
+    "/api/v1/sessions/{sessionId}/background-terminals/{processId}",
+    "/api/v1/sessions/{sessionId}/agents",
+    "/api/v1/sessions/{sessionId}/agents/{nativeThreadId}",
+  ]) {
+    assert.equal(document.paths[path], undefined);
+  }
+
   const sessionEvents = operation(
     document,
     "/api/v1/sessions/{sessionId}/events",
diff --git a/src/server/server.ts b/src/server/server.ts
index 0fe9ce6..d97808f 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -98,11 +98,9 @@ import { TerminalInputQueue } from "@/server/terminal-input-queue";
 import {
   billingCheckoutSchema,
   codexComposerUploadSchema,
-  codexHookUpdateSchema,
   codexMcpServerConfigurationSchema,
   codexMcpServerEnabledSchema,
   codexMemoriesSettingsSchema,
-  codexPersonalitySelectionSchema,
   codexRateLimitResetSchema,
   codexSkillConfigurationSchema,
   codexSkillPutSchema,
@@ -116,9 +114,7 @@ import {
   rotateEnvironmentWebhookSecretSchema,
   sessionCreateSchema,
   sessionForkSchema,
-  sessionGoalUpdateSchema,
   sessionMetadataSchema,
-  sessionReviewSchema,
   terminalInputSchema,
   turnCreateSchema,
   turnInterruptSchema,
@@ -1366,37 +1362,6 @@ export function registerApiRoutes(
       meta: { availability: "available", source: "codex" },
     }),
   );
-  app.get<{ Params: { environmentId: string } }>(
-    "/api/v1/environments/:environmentId/harnesses/codex/personality",
-    async (request) => ({
-      data: await services.codex.readEnvironmentPersonality(
-        request.principal.userId,
-        request.params.environmentId,
-      ),
-    }),
-  );
-  app.put<{ Params: { environmentId: string } }>(
-    "/api/v1/environments/:environmentId/harnesses/codex/personality",
-    async (request) => {
-      const body = codexPersonalitySelectionSchema.parse(request.body);
-      return {
-        data: await services.codex.setEnvironmentPersonality({
-          userId: request.principal.userId,
-          environmentId: request.params.environmentId,
-          personality: body.personality,
-        }),
-      };
-    },
-  );
-  app.get<{ Params: { environmentId: string } }>(
-    "/api/v1/environments/:environmentId/harnesses/codex/token-usage",
-    async (request) => ({
-      data: await services.codex.accountTokenUsageForEnvironment(
-        request.principal.userId,
-        request.params.environmentId,
-      ),
-    }),
-  );
   app.get<{ Params: { environmentId: string } }>(
     "/api/v1/environments/:environmentId/harnesses/codex/memories",
     async (request) => ({
@@ -1428,28 +1393,6 @@ export function registerApiRoutes(
       ),
     }),
   );
-  app.get<{ Params: { environmentId: string } }>(
-    "/api/v1/environments/:environmentId/harnesses/codex/hooks",
-    async (request) => ({
-      data: await services.codex.listEnvironmentHooks(
-        request.principal.userId,
-        request.params.environmentId,
-      ),
-    }),
-  );
-  app.put<{ Params: { environmentId: string } }>(
-    "/api/v1/environments/:environmentId/harnesses/codex/hooks",
-    async (request) => {
-      const body = codexHookUpdateSchema.parse(request.body);
-      return {
-        data: await services.codex.updateEnvironmentHook({
-          userId: request.principal.userId,
-          environmentId: request.params.environmentId,
-          ...body,
-        }),
-      };
-    },
-  );
   app.post<{ Params: { environmentId: string }; Body: unknown }>(
     "/api/v1/environments/:environmentId/harnesses/codex/uploads",
     { bodyLimit: CODEX_UPLOAD_BODY_LIMIT_BYTES },
@@ -1619,7 +1562,6 @@ export function registerApiRoutes(
         reasoningEffort: body.reasoningEffort,
         collaborationMode: body.collaborationMode,
         serviceTier: body.serviceTier,
-        sessionStartSource: body.sessionStartSource,
       });
       return reply.status(201).send({
         data: await services.store.getSession(
@@ -1705,142 +1647,6 @@ export function registerApiRoutes(
       return reply.status(202).send({ data: result });
     },
   );
-  app.post<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/compact",
-    async (request, reply) =>
-      reply.status(202).send({
-        data: await services.codex.compactSession({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-        }),
-      }),
-  );
-  app.post<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/review",
-    async (request, reply) => {
-      const body = sessionReviewSchema.parse(request.body);
-      return reply.status(202).send({
-        data: await services.codex.startReview({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          instructions: body.instructions,
-        }),
-      });
-    },
-  );
-  app.get<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/goal",
-    async (request) => ({
-      data: await services.codex.readSessionGoal({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.put<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/goal",
-    async (request) => {
-      const body = sessionGoalUpdateSchema.parse(request.body);
-      return {
-        data: await services.codex.setSessionGoal({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          ...body,
-        }),
-      };
-    },
-  );
-  app.delete<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/goal",
-    async (request) => ({
-      data: await services.codex.clearSessionGoal({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.get<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/personality",
-    async (request) => ({
-      data: await services.codex.readSessionPersonality({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.put<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/personality",
-    async (request) => {
-      const body = codexPersonalitySelectionSchema.parse(request.body);
-      return {
-        data: await services.codex.setSessionPersonality({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          personality: body.personality,
-        }),
-      };
-    },
-  );
-  app.get<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/memories",
-    async (request) => ({
-      data: await services.codex.readSessionMemories({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.put<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/memories",
-    async (request) => {
-      const settings = codexMemoriesSettingsSchema.parse(request.body);
-      return {
-        data: await services.codex.setSessionMemories({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          settings,
-        }),
-      };
-    },
-  );
-  app.get<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/background-terminals",
-    async (request) => ({
-      data: await services.codex.listSessionBackgroundTerminals({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.delete<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/background-terminals",
-    async (request) => ({
-      data: await services.codex.cleanSessionBackgroundTerminals({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.delete<{
-    Params: { sessionId: string; processId: string };
-  }>(
-    "/api/v1/sessions/:sessionId/background-terminals/:processId",
-    async (request) => {
-      const processId = z
-        .string()
-        .trim()
-        .min(1)
-        .max(200)
-        .parse(request.params.processId);
-      return {
-        data: await services.codex.terminateSessionBackgroundTerminal({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          processId,
-        }),
-      };
-    },
-  );
   app.post<{ Params: { sessionId: string } }>(
     "/api/v1/sessions/:sessionId/fork",
     async (request, reply) => {
@@ -1908,35 +1714,6 @@ export function registerApiRoutes(
       }
     },
   );
-  app.get<{ Params: { sessionId: string } }>(
-    "/api/v1/sessions/:sessionId/agents",
-    async (request) => ({
-      data: await services.codex.listSessionAgentThreads({
-        userId: request.principal.userId,
-        sessionId: request.params.sessionId,
-      }),
-    }),
-  );
-  app.get<{
-    Params: { sessionId: string; nativeThreadId: string };
-  }>(
-    "/api/v1/sessions/:sessionId/agents/:nativeThreadId",
-    async (request) => {
-      const nativeThreadId = z
-        .string()
-        .trim()
-        .min(1)
-        .max(200)
-        .parse(request.params.nativeThreadId);
-      return {
-        data: await services.codex.readSessionAgentThread({
-          userId: request.principal.userId,
-          sessionId: request.params.sessionId,
-          nativeThreadId,
-        }),
-      };
-    },
-  );
   app.get<{ Params: { sessionId: string } }>(
     "/api/v1/sessions/:sessionId/events",
     async (request, reply) => {