ompchamber 3.3.3 → 3.5.0

package/src/server/lib/omp/session/merge-stored-notices.test.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Builtin-command output must survive a reload. omp writes NOTHING to the
+ * session JSONL for a `/context` or `/usage` turn — the output exists only in
+ * the live `command_output` frame — so the chamber's own copy is the only place
+ * it can be kept, and `mergeOmpAttachments` has to splice it back in.
+ *
+ * The anchor is the user turn that produced it, matched by CONTENT: the
+ * chamber's optimistic user row carries a `msg-…-user` id while the JSONL
+ * records omp's timestamp id, so an id match never fires.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { mergeOmpAttachments, type StoredMessage } from '@/server/lib/omp/session/merge-stored';
+
+const CONTEXT_NOTICE = 'Context window: 1000000 tokens (1% used)';
+
+/** What the JSONL yields for a turn whose command wrote no entry. */
+function jsonlTurn(): StoredMessage[] {
+  return [
+    { id: 'omp-user-1', role: 'user', content: '/context' },
+    { id: 'omp-ai-1', role: 'ai', content: 'Done.' },
+  ];
+}
+
+/** The chamber's own copy of that same conversation, plus the notice row. */
+function storedWithNotice(): string {
+  const stored: StoredMessage[] = [
+    { id: 'msg-1-user', role: 'user', content: '/context' },
+    { id: 'cmdout-1', role: 'ai', content: '', notice: CONTEXT_NOTICE },
+    { id: 'omp-ai-1', role: 'ai', content: 'Done.' },
+  ];
+  return JSON.stringify(stored);
+}
+
+describe('mergeOmpAttachments notice restoration', () => {
+  test('splices a stored notice back under its user turn', () => {
+    const merged = mergeOmpAttachments(jsonlTurn(), storedWithNotice());
+
+    expect(merged.map((m) => m.notice ?? m.content)).toEqual([
+      '/context',
+      CONTEXT_NOTICE,
+      'Done.',
+    ]);
+  });
+
+  test('leaves a conversation with no stored notices untouched', () => {
+    const stored = JSON.stringify([{ id: 'msg-1-user', role: 'user', content: '/context' }]);
+    const merged = mergeOmpAttachments(jsonlTurn(), stored);
+    expect(merged.some((m) => m.notice !== undefined)).toBe(false);
+    expect(merged).toHaveLength(2);
+  });
+
+  test('does not duplicate a notice the JSONL itself carried', () => {
+    const messages: StoredMessage[] = [
+      { id: 'omp-user-1', role: 'user', content: 'run it' },
+      { id: 'omp-notice-1', role: 'ai', content: '', notice: CONTEXT_NOTICE },
+    ];
+    const merged = mergeOmpAttachments(messages, storedWithNotice());
+    expect(merged.filter((m) => m.notice === CONTEXT_NOTICE)).toHaveLength(1);
+  });
+
+  test('appends an unanchorable notice instead of dropping it', () => {
+    // The stored user turn has no counterpart in the JSONL at all (omp rewrote
+    // or pruned it), so there is nothing to anchor to — the row must still show.
+    const stored = JSON.stringify([
+      { id: 'msg-x', role: 'user', content: 'a turn the JSONL never recorded' },
+      { id: 'cmdout-x', role: 'ai', content: '', notice: 'Orphan notice' },
+    ]);
+    const merged = mergeOmpAttachments(jsonlTurn(), stored);
+    expect(merged.map((m) => m.notice).filter(Boolean)).toContain('Orphan notice');
+  });
+
+  test('tolerates malformed stored JSON', () => {
+    const merged = mergeOmpAttachments(jsonlTurn(), '{not json');
+    expect(merged).toHaveLength(2);
+  });
+});

package/src/server/lib/omp/session/merge-stored.ts

@@ -42,6 +42,14 @@ export interface StoredMessage {
   date?: string;
   timestamp?: string;
   attachments?: StoredAttachment[];
+  /**
+   * A notice row — omp's own reminder/task-result entries, or the chamber's
+   * rendering of a builtin command's output. The JSONL cannot round-trip
+   * command output at all: a `/context` or `/usage` turn writes no entry to the
+   * session file, so the notice exists ONLY in the live frame, and without this
+   * the row vanished on reload.
+   */
+  notice?: string;
 }
 
 function isRawComposerInput(content: string): boolean {
@@ -158,7 +166,7 @@ export function mergeOmpAttachments(
       byContent.set(m.content, m.attachments);
     }
   }
-  return merged.map((m) => {
+  const merged2 = merged.map((m) => {
     if (m.role !== 'user' || m.attachments?.length) return m;
     // The JSONL content may carry inlined text-file blocks appended to the
     // original prompt, so match by prefix instead of exact equality.
@@ -168,4 +176,65 @@ export function mergeOmpAttachments(
         )?.[1];
     return atts ? { ...m, attachments: atts } : m;
   });
+  return spliceStoredNotices(merged2, stored);
+}
+
+/**
+ * Re-attach notice rows the chamber stored but the JSONL cannot carry.
+ *
+ * A builtin slash command writes NOTHING to the session file — omp answers it
+ * on the command path and the output lives only in the `command_output` frame —
+ * so a `/context` or `/usage` row disappeared on reload, leaving a timeline that
+ * had forgotten a command the user just ran. The chamber's own copy keeps them.
+ *
+ * Placement is by the USER TURN that produced them, never by id: the chamber's
+ * optimistic user row carries a `msg-…-user` id while the JSONL records omp's
+ * own timestamp id, so the two never match. The stored list is walked backwards
+ * to the nearest user message, and that message is located in the merged list
+ * with the same content relation the attachment merge uses (omp rewrites the
+ * delivered prompt, so equality alone would miss it). A notice whose anchor
+ * cannot be resolved is appended at the end rather than dropped — losing it
+ * again is the bug being fixed.
+ */
+function spliceStoredNotices(merged: StoredMessage[], stored: StoredMessage[]): StoredMessage[] {
+  const storedNotices = stored
+    .map((message, index) => ({ message, index }))
+    .filter(({ message }) => message?.role !== 'user' && typeof message?.notice === 'string' && message.notice.trim());
+  if (storedNotices.length === 0) return merged;
+
+  // Already present (a notice the JSONL itself carried, e.g. a task result):
+  // matching on the text keeps the JSONL's own row authoritative.
+  const present = new Set(merged.map((m) => (typeof m.notice === 'string' ? m.notice : '')).filter(Boolean));
+
+  const mergedUsers = merged
+    .map((message, index) => ({ message, index }))
+    .filter(({ message }) => message.role === 'user');
+
+  const insertions = new Map<number, StoredMessage[]>();
+  for (const { message, index } of storedNotices) {
+    if (present.has(message.notice as string)) continue;
+    let anchor = merged.length;
+    for (let i = index - 1; i >= 0; i -= 1) {
+      const candidate = stored[i];
+      if (candidate?.role !== 'user' || typeof candidate.content !== 'string') continue;
+      const hit = mergedUsers.find(({ message: user }) =>
+        user.id !== undefined && candidate.id !== undefined && user.id === candidate.id,
+      ) ?? mergedUsers.find(({ message: user }) => userTurnsRelate(user.content, candidate.content));
+      if (hit) {
+        anchor = hit.index + 1;
+        break;
+      }
+    }
+    const group = insertions.get(anchor);
+    if (group) group.push(message);
+    else insertions.set(anchor, [message]);
+  }
+  if (insertions.size === 0) return merged;
+
+  const next = [...merged];
+  for (const anchor of [...insertions.keys()].sort((a, b) => b - a)) {
+    const group = insertions.get(anchor);
+    if (group) next.splice(anchor, 0, ...group);
+  }
+  return next;
 }

package/src/server/lib/omp/session/messages.ts

@@ -235,6 +235,32 @@ export async function loadSessionModel(filePath: string): Promise<{ provider: st
  *  `thinking_level_change` entries (omp records the level string, e.g.
  *  "off" | "minimal" | "low" | "medium" | "high" | "max"). */
 export async function loadSessionThinkingLevel(filePath: string): Promise<string | undefined> {
+  return readThinkingSelector(filePath, (record) => normalizeThinkingLevel(record.thinkingLevel));
+}
+
+/**
+ * The thinking SELECTOR a session is configured with — `auto` when automatic
+ * per-turn classification is on, else the concrete level.
+ *
+ * omp writes both fields on one entry (`thinkingLevel` = the provisional
+ * concrete effort, `configured` = the selector) and restores with
+ * `parseConfiguredThinkingLevel(configured) ?? parseThinkingLevel(level)`, so a
+ * reader that takes `thinkingLevel` alone turns an `auto` session into a pinned
+ * one. Anything spawning a child that must classify its turns the way the
+ * session does has to read this, not the concrete level.
+ */
+export async function loadSessionThinkingSelector(filePath: string): Promise<string | undefined> {
+  return readThinkingSelector(filePath, (record) =>
+    typeof record.configured === 'string' && record.configured
+      ? record.configured
+      : normalizeThinkingLevel(record.thinkingLevel),
+  );
+}
+
+async function readThinkingSelector(
+  filePath: string,
+  read: (record: Record<string, unknown>) => string,
+): Promise<string | undefined> {
   try {
     const file = Bun.file(filePath);
     if ((await file.stat()).size > MAX_SESSION_LOAD_BYTES) return undefined;
@@ -247,8 +273,7 @@ export async function loadSessionThinkingLevel(filePath: string): Promise<string
     let last: string | undefined;
     for (const record of records) {
       if (record?.type !== 'thinking_level_change') continue;
-      // A change entry always yields a display level: null/unset → "off".
-      last = normalizeThinkingLevel(record.thinkingLevel);
+      last = read(record);
     }
     return last;
   } catch {

package/src/server/lib/omp/session/reader.ts

@@ -60,6 +60,19 @@ export async function loadOmpSidebarData(): Promise<OmpSidebarData> {
   return slot.inFlight;
 }
 
+/**
+ * Drop the cached dataset so the next load re-scans disk. For a mutation the
+ * TTL cannot see: deleting a session removes a row rather than changing one, so
+ * nothing in the cached snapshot is stale — it is simply wrong, and the refresh
+ * that follows the delete would otherwise serve it back for up to the TTL.
+ */
+export function invalidateOmpSidebarData(): void {
+  const slot = globalThis.__ompChamberSidebarDataCache;
+  if (!slot) return;
+  slot.data = undefined as unknown as OmpSidebarData;
+  slot.expiresAt = 0;
+}
+
 /** Resolve each unique cwd to its project root; bounded concurrency so 100+
  *  unique cwds don't spawn 100 parallel git processes. */
 async function resolveRootsByCwd(cwds: string[]): Promise<Map<string, string>> {

package/src/server/routes/agent/command.ts

@@ -5,8 +5,9 @@ import { WebRpcError, getRpcSession, resolveSpawnCwd, startRpcSession, type Agen
 import { getSpawnApprovalMode, reconcileSpawnApprovalMode } from '@/server/lib/omp/rpc/session-registry';
 import { isApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { loadPersistedAccessMode } from '@/shared/lib/omp/config/access-mode.server';
-import { OBSERVER_ONLY_COMMANDS } from '@/server/lib/omp/rpc/constants';
+import { CONVERSATION_MOVING_COMMANDS, OBSERVER_ONLY_COMMANDS } from '@/server/lib/omp/rpc/constants';
 import { rpcErrorResponse } from '@/server/lib/omp/rpc/errors';
+import { assertBtwIdle } from '@/server/lib/btw/service.server';
 
 // POST /api/agent/:sessionId — send a command to an existing session (or spawn
 // it lazily). Mirrors omp-web's /api/agent/[id].
@@ -28,6 +29,13 @@ export async function sendCommand({ params, request }: ActionFunctionArgs) {
     // default. omp has no RPC to change the mode after spawn.
     const explicitMode = isApprovalMode(body.accessMode) ? body.accessMode : null;
 
+    // A command that moves the conversation is refused while a side question is
+    // in flight on this session — the question's snapshot describes the
+    // transcript this command would replace (omp blocks the same operations).
+    if (CONVERSATION_MOVING_COMMANDS.has(body.type)) {
+      await assertBtwIdle(sessionId, body.type.replace(/_/g, ' '));
+    }
+
     // Fast path: already-running session.
     const existing = getRpcSession(sessionId);
     if (existing?.isAlive()) {

package/src/server/routes/btw/topics.ts

@@ -14,25 +14,15 @@
 
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { toImageContents, validateAgentImages } from '@/server/lib/omp/rpc/constants';
-import { isApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { AttachedTextFileData } from '@/shared/lib/chat/attachments';
 import { BtwError, type BtwImages } from '@/server/lib/btw/runtime.server';
-import {
-  abortBtw,
-  askBtw,
-  getBtwState,
-  promoteBtw,
-  removeBtw,
-  respondBtwDialog,
-  setBtwApprovalMode,
-  setBtwModel,
-  setBtwThinkingLevel,
-} from '@/server/lib/btw/service.server';
+import { abortBtw, askBtw, getBtwState, promoteBtw, removeBtw } from '@/server/lib/btw/service.server';
 
 /** Actions that can reject for a reason the client should show as-is. */
 const STATUS_BY_CODE: Record<string, number> = {
   btw_busy: 409,
   btw_stale: 409,
+  btw_multi_turn: 409,
   session_not_found: 404,
   btw_topic_not_found: 404,
 };
@@ -71,20 +61,6 @@ function readTextFiles(raw: unknown): AttachedTextFileData[] {
   });
 }
 
-/**
- * The response body for one dialog, in the shape omp's RPC accepts: an answer
- * value, a confirmation, or a cancellation. Anything else is refused rather
- * than forwarded — a malformed response would leave the child blocked.
- */
-function readDialogResponse(raw: unknown): Record<string, unknown> | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const response = raw as { value?: unknown; confirmed?: unknown; cancelled?: unknown };
-  if (response.cancelled === true) return { cancelled: true };
-  if (typeof response.confirmed === 'boolean') return { confirmed: response.confirmed };
-  if (typeof response.value === 'string') return { value: response.value };
-  return null;
-}
-
 export async function action({ params, request }: ActionFunctionArgs) {
   const { sessionId } = params;
   if (!sessionId) return json({ error: 'session id is required' }, { status: 400 });
@@ -100,8 +76,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
         const question = typeof body?.question === 'string' ? body.question : '';
         const parsed = readImages(body?.images);
         if ('error' in parsed) return json({ error: parsed.error, code: 'invalid_images' }, { status: 400 });
-        const provider = typeof body?.provider === 'string' ? body.provider : '';
-        const modelId = typeof body?.modelId === 'string' ? body.modelId : '';
         return json({
           success: true,
           data: await askBtw(sessionId, {
@@ -109,9 +83,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
             question,
             images: parsed.images,
             textFiles: readTextFiles(body?.textFiles),
-            ...(provider && modelId ? { model: { provider, id: modelId } } : {}),
-            ...(typeof body?.thinkingLevel === 'string' ? { thinkingLevel: body.thinkingLevel } : {}),
-            ...(isApprovalMode(body?.accessMode) ? { approvalMode: body.accessMode } : {}),
           }),
         });
       }
@@ -119,34 +90,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
         if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
         return json({ success: true, data: await abortBtw(sessionId, topicId) });
       }
-      case 'set_model': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const provider = typeof body?.provider === 'string' ? body.provider : '';
-        const modelId = typeof body?.modelId === 'string' ? body.modelId : '';
-        if (!provider || !modelId) return json({ error: 'provider and modelId are required', code: 'model_required' }, { status: 400 });
-        return json({ success: true, data: await setBtwModel(sessionId, topicId, provider, modelId) });
-      }
-      case 'set_thinking_level': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const level = typeof body?.level === 'string' ? body.level : '';
-        if (!level) return json({ error: 'level is required', code: 'level_required' }, { status: 400 });
-        return json({ success: true, data: await setBtwThinkingLevel(sessionId, topicId, level) });
-      }
-      case 'set_access_mode': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        if (!isApprovalMode(body?.accessMode)) {
-          return json({ error: 'accessMode must be always-ask, write or yolo', code: 'invalid_access_mode' }, { status: 400 });
-        }
-        return json({ success: true, data: await setBtwApprovalMode(sessionId, topicId, body.accessMode) });
-      }
-      case 'dialog_response': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const id = typeof body?.id === 'string' ? body.id : '';
-        if (!id) return json({ error: 'id is required', code: 'dialog_required' }, { status: 400 });
-        const response = readDialogResponse(body?.response);
-        if (!response) return json({ error: 'a response value is required', code: 'dialog_required' }, { status: 400 });
-        return json({ success: true, data: await respondBtwDialog(sessionId, topicId, id, response) });
-      }
       case 'promote': {
         if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
         return json({ success: true, data: await promoteBtw(sessionId, topicId) });

package/src/server/routes/sessions/delete.test.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The delete route's refusal branches.
+ *
+ * Each one guards a different failure, and two of them are about blast radius
+ * rather than tidiness: the id names a directory under the sessions root and
+ * another under the btw root, so a value that is not one segment deletes far
+ * more than the session it names (`.` normalized to the btw root itself and
+ * wiped every session's side questions — see `fs/path-segment`).
+ *
+ * The route is called directly, as the other route tests do: these are pure
+ * request-shape checks that must not reach the filesystem or spawn an omp
+ * child, and asserting that is half the point.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import path from 'path';
+import { deleteSession } from '@/server/routes/sessions/delete';
+
+/**
+ * The 404 branch resolves the id by scanning the sessions directory, so the
+ * agent dir is pointed at an empty temp tree. Without this the test walks the
+ * developer's real `~/.omp/agent/sessions` (read-only, but seconds of I/O and a
+ * result that depends on what happens to be installed).
+ */
+const AGENT_DIR = '/tmp/omc-delete-route-test/agent';
+
+beforeAll(() => {
+  fs.rmSync(AGENT_DIR, { recursive: true, force: true });
+  fs.mkdirSync(path.join(AGENT_DIR, 'sessions'), { recursive: true });
+  Bun.env.PI_CODING_AGENT_DIR = AGENT_DIR;
+});
+
+afterAll(() => {
+  delete Bun.env.PI_CODING_AGENT_DIR;
+  fs.rmSync('/tmp/omc-delete-route-test', { recursive: true, force: true });
+});
+
+function del(sessionId: string): Promise<Response> {
+  return deleteSession({
+    request: new Request(`http://localhost/api/sessions/${sessionId}`, { method: 'DELETE' }),
+    params: { sessionId },
+  } as never) as Promise<Response>;
+}
+
+describe('deleteSession refusals', () => {
+  test('a pending chat is refused — nothing is stored for it yet', async () => {
+    const res = await del('new-1758800000000');
+    expect(res.status).toBe(400);
+    expect(await res.json()).toMatchObject({ code: 'session_pending' });
+  });
+
+  test('`.` is refused instead of wiping the btw root', async () => {
+    const res = await del('.');
+    expect(res.status).toBe(400);
+    expect(await res.json()).toMatchObject({ error: 'Invalid session id' });
+  });
+
+  test('a traversal is refused', async () => {
+    for (const id of ['..', '../x', 'a/b', '..\\a']) {
+      expect((await del(id)).status).toBe(400);
+    }
+  });
+
+  test('an unknown but well-formed id is a 404, not a 400', async () => {
+    // Distinct from the branches above: the request is valid, the session is
+    // not there. Collapsing the two would report a typo as a malformed request.
+    const res = await del('00000000-0000-0000-0000-000000000000');
+    expect(res.status).toBe(404);
+  });
+
+  test('a wrong verb on the path is a 405', async () => {
+    const res = (await deleteSession({
+      request: new Request('http://localhost/api/sessions/x', { method: 'GET' }),
+      params: { sessionId: 'x' },
+    } as never)) as Response;
+    expect(res.status).toBe(405);
+  });
+});

package/src/server/routes/sessions/delete.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * DELETE /api/sessions/:sessionId — remove a session and everything keyed to
+ * it. The mirror of `archiveSession`: archive is reversible and keeps the
+ * transcript, this one is the destructive path the user opts into from the
+ * sidebar's trash button.
+ *
+ * Order matters and is enforced here, not by the callers:
+ *  1. refuse a session whose omp child is mid-turn (a run, a live subagent, or
+ *     a dialog the agent is blocked on) — the delete would kill work the user
+ *     can still see, and omp would flush the file back on shutdown anyway;
+ *  2. destroy the child and AWAIT its exit — omp writes session state on
+ *     shutdown and would otherwise recreate the transcript just removed;
+ *  3. purge side questions, then the transcript, artifacts and chamber rows.
+ *
+ * A pending `new-…` session is refused: it is a client-side placeholder with
+ * nothing stored anywhere yet, so deleting it is the same as navigating away.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getRpcSession } from '@/server/lib/omp/rpc/session-registry';
+import { purgeSessionData } from '@/server/lib/omp/session/delete.server';
+import { purgeBtwForSession } from '@/server/lib/btw/purge.server';
+import { isSinglePathSegment } from '@/server/lib/fs/path-segment';
+import { isMockMode } from '@/server/mock.server';
+
+export async function deleteSession({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'DELETE') {
+    return methodNotAllowed({ request, params });
+  }
+
+  const sessionId = params.sessionId;
+  if (!sessionId) return json({ error: 'Missing session id' }, { status: 400 });
+  if (sessionId.startsWith('new-')) {
+    return json({ error: 'This chat has not been created yet.', code: 'session_pending' }, { status: 400 });
+  }
+  // The id names a directory under the sessions root and another under the btw
+  // root, so it must be exactly one path segment — see `isSinglePathSegment`
+  // for the `.` case that made this load-bearing. Both purges re-check it
+  // independently; refusing here is what turns the attempt into a 400.
+  if (!isSinglePathSegment(sessionId)) {
+    return json({ error: 'Invalid session id' }, { status: 400 });
+  }
+
+  // A live child is the only other writer of the transcript. Busy means a turn,
+  // a live subagent, or a dialog omp is parked on — all things the user can
+  // still act on, so the delete is refused with a reason rather than silently
+  // taking them down.
+  const live = getRpcSession(sessionId);
+  if (live?.isAlive()) {
+    if (live.isBusy()) {
+      return json(
+        { error: 'This session is working. Stop the run before deleting it.', code: 'session_busy' },
+        { status: 409 },
+      );
+    }
+    await live.destroyAndWait();
+  }
+
+  // Side questions live outside the session file and are removed first: their
+  // children must be gone before the parent transcript they were snapshotted
+  // from disappears.
+  const btwTopicsRemoved = isMockMode() ? 0 : await purgeBtwForSession(sessionId);
+  const purged = await purgeSessionData(sessionId);
+
+  if (!purged.found) {
+    return json({ error: 'Session not found' }, { status: 404 });
+  }
+
+  return json({
+    success: true,
+    sessionId,
+    fileRemoved: purged.fileRemoved,
+    artifactsRemoved: purged.artifactsRemoved,
+    btwTopicsRemoved,
+  });
+}

package/src/server/routes/sessions/index.ts

@@ -10,10 +10,15 @@ import {
   renameSession,
 } from '@/server/routes/sessions/session';
 import { listSubagents, readSubagentTranscript } from '@/server/routes/sessions/subagents';
+import { deleteSession } from '@/server/routes/sessions/delete';
 
 export const sessionsBindings: HandlerBinding[] = [
   ...bindingsFor(sessionsList, '/api/sessions/list'),
   ...bindingsFor(sessionsFolder, '/api/sessions/:sessionId'),
+  // DELETE-only on the same path the folder loader answers GET on: mounting it
+  // through `actionBindings` would register a 405 GET fallback that Elysia
+  // applies after the loader, replacing the workspace listing with it.
+  { method: 'DELETE', path: '/api/sessions/:sessionId', handler: deleteSession },
   ...actionBindings(archiveSession, '/api/sessions/:sessionId/archive'),
   // Per-item queue routes. `actionBindings` mounts ALL four mutating verbs on
   // one path, and Elysia lets a later registration override an earlier one —

package/src/shared/lib/chat/btw/client.ts

@@ -15,7 +15,6 @@
 
 import type { AgentImage, BtwFrame, BtwState, StreamTransport } from '@/shared/types';
 import type { AttachedTextFileData } from '@/shared/lib/chat/attachments';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { connectEvents } from '@/shared/lib/chat/omp/sse';
 import { connectSocket } from '@/shared/lib/chat/omp/socket';
 import { btwEventsUrl, btwSocketUrl } from '@/shared/lib/chat/omp/transport';
@@ -74,11 +73,6 @@ export interface AskBtwInput {
   images?: AgentImage[];
   /** Text files inlined for this question (read at attach time by the composer). */
   textFiles?: AttachedTextFileData[];
-  /** Composer picks for a FIRST question — a topic that does not exist yet has
-   *  no row to hold them, so they ride the ask and reach the spawn. */
-  model?: { provider: string; id: string };
-  thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
 }
 
 export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<BtwState> {
@@ -88,9 +82,6 @@ export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<B
     ...(input.topicId ? { topicId: input.topicId } : {}),
     ...(input.images?.length ? { images: input.images } : {}),
     ...(input.textFiles?.length ? { textFiles: input.textFiles } : {}),
-    ...(input.model ? { provider: input.model.provider, modelId: input.model.id } : {}),
-    ...(input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {}),
-    ...(input.approvalMode ? { accessMode: input.approvalMode } : {}),
   });
 }
 
@@ -98,27 +89,6 @@ export function abortBtwQuestion(sessionId: string, topicId: string): Promise<Bt
   return requestBtw<BtwState>(sessionId, 'POST', { action: 'abort', topicId });
 }
 
-export function setBtwModel(sessionId: string, topicId: string, provider: string, modelId: string): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_model', topicId, provider, modelId });
-}
-
-export function setBtwThinkingLevel(sessionId: string, topicId: string, level: string): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_thinking_level', topicId, level });
-}
-
-export function setBtwAccessMode(sessionId: string, topicId: string, accessMode: ApprovalMode): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_access_mode', topicId, accessMode });
-}
-
-export function respondBtwDialog(
-  sessionId: string,
-  topicId: string,
-  id: string,
-  response: { value: string } | { confirmed: boolean } | { cancelled: true },
-): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'dialog_response', topicId, id, response });
-}
-
 export function promoteBtwTopic(sessionId: string, topicId: string): Promise<{ sessionId: string }> {
   return requestBtw<{ sessionId: string }>(sessionId, 'POST', { action: 'promote', topicId });
 }