ompchamber 3.3.3 → 3.4.0

package/src/server/lib/btw/runtime.server.ts

@@ -12,11 +12,14 @@
  * (no re-prompting it as text, and the parent's prompt-cache prefix survives)
  * and never writes the parent file.
  *
- * The child runs WITH tools, unlike omp's TUI `/btw` (`--no-tools`). The panel
- * offers a real access-control dropdown, and an approval mode that governs
- * nothing would be a lie in the UI — so the tool surface is whatever
- * `--approval-mode` allows, and a gated call parks the turn on an
- * `extension_ui_request` the panel answers (`PendingUiDialogs`).
+ * The child runs WITHOUT tools (`--no-tools`), the same end state omp's own
+ * `/btw` reaches through `runEphemeralTurn`: the side turn answers from the
+ * context it already has, never executes a tool, and discards any tool call the
+ * model emits anyway. With no tool surface there is no approval gate to park on,
+ * so no dialog can reach this child either.
+ *
+ * Model and thinking selector come from the CHAT (see `retarget`), never from a
+ * picker of this panel's own — omp's side turn reads `request.session.model`.
  *
  * The child is disposable by design: history lives in SQLite plus the topic
  * transcript, so an idle reclaim costs a respawn, not the conversation — a
@@ -28,7 +31,6 @@
 
 import { RpcProcess, type RpcFrame } from '@/server/lib/omp/rpc/process';
 import { GET_STATE_TIMEOUT_MS, READY_TIMEOUT_MS, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
-import { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
 import { resolveOmpBin } from '@/server/lib/omp/core/cli';
 import { buildBtwSpawnArgs, type BtwSpawnSettings } from '@/server/lib/btw/child.server';
 import {
@@ -42,10 +44,9 @@ import {
   trackTurnMessage,
   type BtwLifecycleHost,
 } from '@/server/lib/btw/lifecycle.server';
-import { setBtwTopicModel, setBtwTopicThinkingLevel } from '@/server/lib/btw/store.server';
+import { setBtwTopicLeaf, setBtwTopicModel } from '@/server/lib/btw/store.server';
 import { createBtwWorkspace, resolveBtwWorkspacePaths, type BtwWorkspace } from '@/server/lib/btw/session-copy.server';
-import { finalAnswer, finalStatus, isAnswerableUiMethod } from '@/server/lib/btw/frames';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { finalAnswer, finalStatus } from '@/server/lib/btw/frames';
 import type { AgentImage, BtwFrame, BtwLiveTurn, BtwModel, BtwTurnStatus, ChatMessageData } from '@/shared/types';
 
 /** Prompt images, validated by the route before they reach the child. */
@@ -59,7 +60,6 @@ export interface BtwRuntimeContext {
   cwd: string;
   model?: BtwModel;
   thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
 }
 
 /** Where the runtime reports what happened. */
@@ -94,10 +94,10 @@ export class BtwRuntime implements BtwLifecycleHost {
   /** Last activity phrase published, so repeats are not re-published. */
   activity = '';
   disposing: Promise<void> | null = null;
-  /** Ask/approval dialogs this child is blocked on (see the module note). */
-  readonly dialogs = new PendingUiDialogs();
-  /** The approval mode the live child was actually spawned with. */
-  spawnedApprovalMode: ApprovalMode | undefined;
+  /** Model the live child reports, so a retarget only sends a real change. */
+  private reportedModel: { provider: string; id: string } | null = null;
+  /** Thinking selector the live child reports (`auto` included). */
+  private reportedThinkingLevel: string | null = null;
 
   constructor(
     private readonly context: BtwRuntimeContext,
@@ -144,41 +144,27 @@ export class BtwRuntime implements BtwLifecycleHost {
   }
 
   /**
-   * Re-target the live child's model. `set_model` applies to the RUNNING turn
-   * (omp resolves it immediately), which is exactly what the panel's dropdown
-   * promises: the answer in flight continues on the model the user just chose.
+   * Adopt the chat's current model and thinking selector before a question is
+   * asked. omp's side turn reads `request.session.model` at run time, so a chat
+   * that switched model or level is mirrored here — a live child is re-targeted
+   * over RPC (`set_model` / `set_thinking_level` apply to the running session),
+   * and a cold one simply spawns with these values.
    */
-  async setModel(provider: string, modelId: string): Promise<void> {
-    await setBtwTopicModel(this.topicId, { provider, id: modelId });
-    this.sink.stateChanged();
+  async retarget(model: BtwModel | undefined, thinkingLevel: string | undefined): Promise<void> {
+    this.context.model = model;
+    this.context.thinkingLevel = thinkingLevel;
     const proc = this.proc;
     if (!proc?.isAlive) return;
-    await proc.sendCommand({ type: 'set_model', provider, modelId }, GET_STATE_TIMEOUT_MS);
-  }
-
-  /** Re-target the live child's thinking level (`auto` leaves omp alone). */
-  async setThinkingLevel(level: string): Promise<void> {
-    const proc = this.proc;
-    if (!proc?.isAlive || level === 'auto') return;
-    await proc.sendCommand({ type: 'set_thinking_level', level }, GET_STATE_TIMEOUT_MS);
-  }
-
-  /**
-   * Adopt a new approval mode. omp has no RPC for it — the flag is spawn-time
-   * only — so an idle child is destroyed and the next question respawns it.
-   * A running turn is never killed for this (same rule as the chat session's
-   * `reconcileSpawnApprovalMode`): the mode takes effect from the next child.
-   */
-  async setApprovalMode(mode: ApprovalMode): Promise<void> {
-    this.context.approvalMode = mode;
-    if (this.spawnedApprovalMode === mode || this.running) return;
-    await this.teardownChild();
-  }
-
-  /** Answer a dialog this child is blocked on. */
-  respondToDialog(id: string, response: Record<string, unknown>): void {
-    this.proc?.sendFrame({ type: 'extension_ui_response', id, ...response });
-    if (this.dialogs.resolve(id)) this.sink.stateChanged();
+    if (model && (this.reportedModel?.provider !== model.provider || this.reportedModel.id !== model.id)) {
+      await proc.sendCommand({ type: 'set_model', provider: model.provider, modelId: model.id }, GET_STATE_TIMEOUT_MS);
+      // Remember what was sent: without this the next question re-sends the same
+      // pair, because `reportedModel` would still hold the spawn-time value.
+      this.reportedModel = { provider: model.provider, id: model.id };
+    }
+    if (thinkingLevel && thinkingLevel !== this.reportedThinkingLevel) {
+      await proc.sendCommand({ type: 'set_thinking_level', level: thinkingLevel }, GET_STATE_TIMEOUT_MS);
+      this.reportedThinkingLevel = thinkingLevel;
+    }
   }
 
   /** Reclaim the child; the topic's history survives in SQLite and on disk. */
@@ -206,20 +192,31 @@ export class BtwRuntime implements BtwLifecycleHost {
   private async openWorkspace(): Promise<BtwWorkspace> {
     const paths = await resolveBtwWorkspacePaths(this.context.sessionId, this.context.topicId);
     const existing = await Bun.file(paths.sessionFile).exists();
-    const workspace = existing
-      ? { ...paths, leafId: null }
-      : await createBtwWorkspace({
-          parentSessionId: this.context.sessionId,
-          topicId: this.context.topicId,
-          parentSessionFile: this.context.parentSessionFile,
-        });
+    if (existing) {
+      this.workspace = { ...paths, leafId: null };
+      return this.workspace;
+    }
+    const workspace = await createBtwWorkspace({
+      parentSessionId: this.context.sessionId,
+      topicId: this.context.topicId,
+      parentSessionFile: this.context.parentSessionFile,
+    });
+    // The snapshot's leaf is the promotion guard's baseline: the branch may only
+    // be cut while the parent still ENDS at the entry this copy was taken from.
+    // Written here, where the snapshot is actually taken, because a later
+    // transcript cannot reconstruct which entry that was.
+    if (workspace.leafId) await setBtwTopicLeaf(this.context.topicId, workspace.leafId);
     this.workspace = workspace;
-    // The snapshot's leaf is what a later promotion must still find in the
-    // parent; a topic resumed from disk keeps the leaf it was created with.
     return workspace;
   }
 
   start(): Promise<RpcProcess> {
+    // Reuse the live child. Without this guard every question spawns ANOTHER
+    // `omp --resume` for the same topic and abandons the previous one — measured:
+    // two live children with the same transcript, the older one holding the
+    // pre-retarget `--model`, both appending to the same file. A child that died
+    // (`proc` nulled by `handleSideChildExit`) still gets a fresh spawn.
+    if (this.proc?.isAlive) return Promise.resolve(this.proc);
     if (this.starting) return this.starting;
     const started = this.spawnChild();
     this.starting = started;
@@ -238,7 +235,6 @@ export class BtwRuntime implements BtwLifecycleHost {
     const settings: BtwSpawnSettings = {
       model: this.context.model,
       thinkingLevel: this.context.thinkingLevel,
-      approvalMode: this.context.approvalMode,
     };
     const proc = new RpcProcess({
       cwd: this.context.cwd,
@@ -247,7 +243,8 @@ export class BtwRuntime implements BtwLifecycleHost {
       onExit: (info) => handleSideChildExit(this, info.stderrTail),
     });
     this.proc = proc;
-    this.spawnedApprovalMode = this.context.approvalMode;
+    this.reportedModel = null;
+    this.reportedThinkingLevel = null;
     const ready = await proc.waitReady(READY_TIMEOUT_MS);
     await proc.negotiateProtocol(ready);
     await this.captureModel(proc);
@@ -255,22 +252,29 @@ export class BtwRuntime implements BtwLifecycleHost {
   }
 
   /**
-   * Record what the child reports about itself, for the panel's model chip and
-   * the run footer: its display name and the thinking level it actually runs at.
-   * `get_state` is the only source — the topic row holds what was REQUESTED, and
-   * omp may resolve it differently.
+   * Record what the child reports about itself: the display name of the model
+   * it resolved (for the run footer) and the model/selector it runs with, so a
+   * `retarget` before the next question only sends a real change.
+   *
+   * The THINKING LEVEL is NOT written back to the topic. `get_state` reports the
+   * level the child RESOLVED (an `auto` chat resolves to a concrete effort), and
+   * storing that would pin every later spawn to it — the side conversation would
+   * stop re-classifying per turn while the chat it mirrors keeps doing so. The
+   * chat's own recorded selector is what each ask reads instead.
    */
   private async captureModel(proc: RpcProcess): Promise<void> {
     try {
       const state = await proc.sendCommand<RpcSessionState>({ type: 'get_state' }, GET_STATE_TIMEOUT_MS);
       const reported = state.model;
-      if (reported?.provider && reported.id && reported.name) {
-        await setBtwTopicModel(this.topicId, { provider: reported.provider, id: reported.id, name: reported.name });
-        this.sink.stateChanged();
+      if (reported?.provider && reported.id) {
+        this.reportedModel = { provider: reported.provider, id: reported.id };
+        if (reported.name) {
+          await setBtwTopicModel(this.topicId, { provider: reported.provider, id: reported.id, name: reported.name });
+          this.sink.stateChanged();
+        }
       }
       if (typeof state.thinkingLevel === 'string' && state.thinkingLevel) {
-        await setBtwTopicThinkingLevel(this.topicId, state.thinkingLevel);
-        this.sink.stateChanged();
+        this.reportedThinkingLevel = state.thinkingLevel;
       }
     } catch {
       // A chip without a display name is cosmetic; the topic keeps its model.
@@ -280,38 +284,25 @@ export class BtwRuntime implements BtwLifecycleHost {
   private handleFrame(frame: RpcFrame): void {
     if (frame.type === 'message_update' || frame.type === 'message_start') {
       // The turn's conversation is accumulated in the chat's own shape (see
-      // `trackTurnMessage`): thinking, prose, tool calls and their output all
-      // reach the panel through the same mapper the chat timeline uses.
+      // `trackTurnMessage`): thinking, prose and usage reach the panel through
+      // the same mapper the chat timeline uses.
       trackTurnMessage(this, frame);
       trackTurnActivity(this, frame);
     } else if (frame.type === 'message_end') {
       // The completed message is the authoritative copy: it carries the turn's
-      // real usage, where the streaming frames report zeros. Upserting it
-      // replaces the streaming row in place (same message id), which is what
-      // puts token counts on the panel's run footer.
-      trackTurnMessage(this, frame);
-    } else if (frame.type === 'tool_execution_start') {
-      trackTurnActivity(this, frame);
+      // real usage, where the streaming frames report zeros, and its thinking is
+      // no longer generating. Upserting it replaces the streaming row in place
+      // (same message id), which is what puts token counts on the run footer
+      // without leaving a pulsing accordion behind on the next reload.
+      trackTurnMessage(this, frame, false);
     } else if (frame.type === 'agent_end') {
       // `isTerminal: false` means maintenance scheduled more work; the turn is
       // not done until a terminal end arrives (mirrors the session wrapper).
       if (frame.isTerminal === false) return;
       void settleSideTurn(this, finalStatus(frame.messages), finalAnswer(frame.messages, ''));
-    } else if (frame.type === 'extension_ui_request') {
-      this.trackDialog(frame);
     }
     resetSideIdleTimer(this);
   }
-
-  /**
-   * Record an ask/approval dialog so the panel can render it. Unlike the TUI
-   * there is no tool card to host an `ask` inline, so every answerable request
-   * becomes a modal — and the state republish is what puts it on screen.
-   */
-  private trackDialog(frame: RpcFrame): void {
-    if (typeof frame.id !== 'string' || !isAnswerableUiMethod(frame.method)) return;
-    if (this.dialogs.track(frame)) this.sink.stateChanged();
-  }
 }
 
 export type { BtwTurnStatus };

package/src/server/lib/btw/schema.server.test.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The BTW schema's migrations.
+ *
+ * `ensureBtwSchema` runs once per database open, so every branch has to be safe
+ * on a database that already has the newest shape AND on one created before the
+ * column or the status word existed. The status rename is the one that is easy
+ * to get wrong: a stored `failed` is not a column, so it needs a data migration
+ * rather than an `ALTER`, and a database written before the vocabulary changed
+ * would otherwise render a turn that never completes.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { rmSync } from 'node:fs';
+import { createDb, type DbClient } from '@/server/lib/db/client';
+import { ensureBtwSchema } from '@/server/lib/btw/schema.server';
+
+const paths: string[] = [];
+
+function tempDb(): DbClient {
+  const path = join(tmpdir(), `btw-schema-${crypto.randomUUID()}.sqlite`);
+  paths.push(path);
+  return createDb(path);
+}
+
+describe('ensureBtwSchema', () => {
+  test('creates the tables on a fresh database', async () => {
+    const db = tempDb();
+    await ensureBtwSchema(db);
+
+    const columns = (await db.all('PRAGMA table_info(btw_topics)')) as { name: string }[];
+    expect(columns.map((column) => column.name)).toContain('leaf_id');
+    expect(columns.map((column) => column.name)).toContain('thinking_level');
+  });
+
+  test('is idempotent', async () => {
+    const db = tempDb();
+    await ensureBtwSchema(db);
+    await ensureBtwSchema(db);
+
+    const tables = (await db.all("SELECT name FROM sqlite_master WHERE type = 'table'")) as { name: string }[];
+    expect(tables.filter((table) => table.name === 'btw_turns')).toHaveLength(1);
+  });
+
+  test('rewrites a legacy failed turn as error', async () => {
+    const db = tempDb();
+    // A database from before the vocabulary change: the column set is old and a
+    // turn is recorded as `failed`.
+    await db.exec(`
+      CREATE TABLE btw_topics (
+        id TEXT PRIMARY KEY, session_id TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
+        provider TEXT, model_id TEXT, model_name TEXT, leaf_id TEXT, promoted_session_id TEXT,
+        created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE btw_turns (
+        topic_id TEXT NOT NULL, turn_index INTEGER NOT NULL, question TEXT NOT NULL DEFAULT '',
+        answer TEXT NOT NULL DEFAULT '', status TEXT NOT NULL,
+        created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+        PRIMARY KEY (topic_id, turn_index)
+      );
+    `);
+    await db.run(
+      "INSERT INTO btw_turns (topic_id, turn_index, status, created_at, updated_at) VALUES ('t', 0, 'failed', 1, 1)",
+    );
+
+    await ensureBtwSchema(db);
+
+    const turn = (await db.get("SELECT status FROM btw_turns WHERE topic_id = 't'")) as { status: string };
+    expect(turn.status).toBe('error');
+    // The additive columns arrive on the same pass.
+    const columns = (await db.all('PRAGMA table_info(btw_topics)')) as { name: string }[];
+    expect(columns.map((column) => column.name)).toContain('approval_mode');
+  });
+});
+
+process.on('exit', () => {
+  for (const path of paths) rmSync(path, { force: true });
+});

package/src/server/lib/btw/schema.server.ts

@@ -7,6 +7,10 @@
  * BTW schema, kept out of `db.server.ts`'s bootstrap block so that file's
  * growth stays attributable (it was already at the ceiling before this
  * feature). Called once per database open, like the other migrations there.
+ *
+ * `approval_mode` is retained for rows written while a side child ran WITH tools
+ * and an approval dropdown governed it; nothing writes or reads it now that the
+ * child runs `--no-tools`.
  */
 
 import type { DbClient } from '@/server/lib/db/client';
@@ -68,4 +72,8 @@ export async function ensureBtwSchema(db: DbClient): Promise<void> {
     if (await hasColumn(db, added.table, added.column)) continue;
     await db.exec(added.ddl);
   }
+  // A turn that ended in a provider error used to be recorded as `failed`; the
+  // vocabulary now matches omp's own (`error`). Row data, not a column, so it is
+  // an unconditional UPDATE — a second run matches nothing.
+  await db.run("UPDATE btw_turns SET status = 'error' WHERE status = 'failed'");
 }

package/src/server/lib/btw/service.server.ts

@@ -12,32 +12,32 @@
  *    cancel — a second question is refused, exactly like the TUI);
  *  - a new question is its own topic; only a follow-up continues one, and it
  *    sees only that topic's turns (plus the parent's context);
+ *  - the side conversation runs on the CHAT's model and thinking selector, read
+ *    from the parent transcript at every ask — the panel has no pickers of its
+ *    own, exactly like omp's `/btw`, which runs the side turn on
+ *    `request.session.model`;
  *  - promotion is refused once the parent transcript has moved past the point
- *    the topic was snapshotted at, and while a turn is still running.
+ *    the topic was snapshotted at, while a turn is still running, and for a
+ *    topic with follow-ups (a branch carries one question/answer pair).
  */
 
 import { isMockMode } from '@/server/mock.server';
 import { findSessionFileById } from '@/server/lib/omp/session/locator';
 import { readRawHeaderLine } from '@/server/lib/omp/session/files';
-import { loadSessionModel } from '@/server/lib/omp/session/messages';
-import { resolveSpawnCwd } from '@/server/lib/omp/rpc/manager';
-import { loadPersistedAccessMode } from '@/shared/lib/omp/config/access-mode.server';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { loadSessionModel, loadSessionThinkingSelector } from '@/server/lib/omp/session/messages';
+import { getRpcSession, resolveSpawnCwd } from '@/server/lib/omp/rpc/manager';
 import { composeMessageWithTextAttachments, type AttachedTextFileData } from '@/shared/lib/chat/attachments';
 import {
   createBtwTopic,
   deleteBtwTopic,
   getBtwTopic,
   readBtwTopicLeaf,
-  setBtwTopicApprovalMode,
-  setBtwTopicModel,
   setBtwTopicPromoted,
-  setBtwTopicThinkingLevel,
 } from '@/server/lib/btw/store.server';
 import { promoteBtwTopic as materializePromotedTopic, readTranscriptLeaf, removeBtwWorkspace, resolveBtwWorkspacePaths } from '@/server/lib/btw/session-copy.server';
 import { btwStateFor, ensureBtwRuntime, findRunningBtwRuntime, forgetBtwRuntime, getBtwRuntime, publishBtwState } from '@/server/lib/btw/registry.server';
 import { BtwError, type BtwImages } from '@/server/lib/btw/runtime.server';
-import type { BtwModel, BtwState } from '@/shared/types';
+import type { BtwState } from '@/shared/types';
 
 /** Longest a topic label may be, matching the sidebar's session-title length. */
 const TOPIC_TITLE_CHARS = 60;
@@ -93,15 +93,6 @@ export interface AskBtwInput {
    * be asked about a file the same way a chat turn can.
    */
   textFiles?: AttachedTextFileData[];
-  /**
-   * Composer picks for the FIRST question of a topic, which has no row to write
-   * them to yet. Later questions address an existing topic and are re-targeted
-   * through the dedicated `set_model` / `set_thinking_level` / `set_access_mode`
-   * actions instead.
-   */
-  model?: BtwModel;
-  thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
 }
 
 export async function askBtw(sessionId: string, input: AskBtwInput): Promise<BtwState> {
@@ -119,15 +110,18 @@ export async function askBtw(sessionId: string, input: AskBtwInput): Promise<Btw
     throw new BtwError('Unknown side question.', 'btw_topic_not_found');
   }
 
-  const approvalMode = input.approvalMode ?? (await loadPersistedAccessMode());
+  // The side conversation mirrors the chat: model and thinking selector are read
+  // from the parent transcript at every ask, so a change made in the chat reaches
+  // the next side question (omp reads `request.session.model` the same way).
+  const model = await topicModel(parent.sessionFile);
+  const thinkingLevel = await loadSessionThinkingSelector(parent.sessionFile);
   const topic =
     existing ??
     (await createBtwTopic({
       sessionId,
       title: topicTitle(question),
-      model: input.model ?? (await topicModel(parent.sessionFile)),
-      thinkingLevel: input.thinkingLevel,
-      approvalMode,
+      model,
+      thinkingLevel,
     }));
 
   const runtime = ensureBtwRuntime({
@@ -135,68 +129,17 @@ export async function askBtw(sessionId: string, input: AskBtwInput): Promise<Btw
     sessionId,
     parentSessionFile: parent.sessionFile,
     cwd: parent.cwd,
-    model: topic.model,
-    thinkingLevel: topic.thinkingLevel,
-    // The topic's own mode wins once set; a fresh topic adopts the composer's.
-    approvalMode: topic.approvalMode ?? approvalMode,
+    model,
+    thinkingLevel,
   });
 
+  // A live child keeps the model it was spawned with; re-target it before the
+  // prompt so this question runs on what the chat is on NOW.
+  await runtime.retarget(model, thinkingLevel);
   await runtime.ask(composeMessageWithTextAttachments(question, input.textFiles ?? []), input.images);
   return btwStateFor(sessionId);
 }
 
-/** One topic of this session, or a `btw_topic_not_found` refusal. */
-async function requireTopic(sessionId: string, topicId: string) {
-  const topic = await getBtwTopic(topicId);
-  if (!topic || topic.sessionId !== sessionId) throw new BtwError('Unknown side question.', 'btw_topic_not_found');
-  return topic;
-}
-
-/**
- * Re-target a topic's model. With a live child the change reaches it through
- * `set_model` (omp applies it to the running turn, which is what the dropdown
- * promises); an idle topic simply records it for the next spawn.
- */
-export async function setBtwModel(sessionId: string, topicId: string, provider: string, modelId: string): Promise<BtwState> {
-  await requireTopic(sessionId, topicId);
-  const runtime = getBtwRuntime(topicId);
-  if (runtime) {
-    await runtime.setModel(provider, modelId);
-  } else {
-    await setBtwTopicModel(topicId, { provider, id: modelId });
-    await publishBtwState(sessionId);
-  }
-  return btwStateFor(sessionId);
-}
-
-export async function setBtwThinkingLevel(sessionId: string, topicId: string, level: string): Promise<BtwState> {
-  await requireTopic(sessionId, topicId);
-  await setBtwTopicThinkingLevel(topicId, level === 'auto' ? null : level);
-  await getBtwRuntime(topicId)?.setThinkingLevel(level);
-  await publishBtwState(sessionId);
-  return btwStateFor(sessionId);
-}
-
-/**
- * Adopt a new tool-approval mode for a topic. omp has no RPC for it, so an idle
- * child is dropped and the next question respawns with the new flag; a running
- * turn keeps its child (and therefore its mode) until it settles.
- */
-export async function setBtwApprovalMode(sessionId: string, topicId: string, mode: ApprovalMode): Promise<BtwState> {
-  await requireTopic(sessionId, topicId);
-  await setBtwTopicApprovalMode(topicId, mode);
-  await getBtwRuntime(topicId)?.setApprovalMode(mode);
-  await publishBtwState(sessionId);
-  return btwStateFor(sessionId);
-}
-
-/** Answer an ask/approval dialog a side child is blocked on. */
-export async function respondBtwDialog(sessionId: string, topicId: string, id: string, response: Record<string, unknown>): Promise<BtwState> {
-  await requireTopic(sessionId, topicId);
-  getBtwRuntime(topicId)?.respondToDialog(id, response);
-  return btwStateFor(sessionId);
-}
-
 /** The parent's model, so the side conversation runs on the visible model. */
 async function topicModel(sessionFile: string) {
   const model = await loadSessionModel(sessionFile);
@@ -210,6 +153,19 @@ export async function abortBtw(sessionId: string, topicId: string): Promise<BtwS
   return btwStateFor(sessionId);
 }
 
+/**
+ * Refuse a session operation that would move the conversation out from under a
+ * running side question. omp blocks the same operations while a `/btw` answer is
+ * in flight or unsaved (`BtwController.withSessionMove` / `flush`); a chamber
+ * chat that switched sessions mid-question would leave the answer attached to a
+ * transcript nobody is looking at.
+ */
+export async function assertBtwIdle(sessionId: string, action: string): Promise<void> {
+  if (findRunningBtwRuntime(sessionId)) {
+    throw new BtwError(`A side question is still running — wait for it, or cancel it, before you ${action}.`, 'btw_busy');
+  }
+}
+
 /**
  * Turn the topic into a session of the chat's own: a branch of the parent
  * conversation whose tip is the side answer, opened by the caller.
@@ -225,8 +181,21 @@ export async function promoteBtw(sessionId: string, topicId: string): Promise<{
   if (topic.turns.some((turn) => turn.status === 'running')) {
     throw new BtwError('Wait for the side answer to finish, or cancel it, before promoting it.', 'btw_busy');
   }
+  // omp's branch action carries ONE question/answer pair and refuses a topic with
+  // follow-ups, so the earlier turns cannot be silently dropped from the branch.
+  if (topic.turns.length > 1) {
+    throw new BtwError(
+      'A side question with follow-ups cannot be promoted — omp branches one answer at a time.',
+      'btw_multi_turn',
+    );
+  }
 
   const parent = await resolveParent(sessionId);
+  // The branch is cut from the parent's transcript, so the chat must be idle:
+  // omp's guard refuses while `session.isStreaming`.
+  if (getRpcSession(sessionId)?.isRunning()) {
+    throw new BtwError('The chat is still running — wait for it to finish before promoting a side question.', 'btw_busy');
+  }
   const snapshotLeaf = await readBtwTopicLeaf(topicId);
   if (snapshotLeaf) {
     const currentLeaf = await readTranscriptLeaf(parent.sessionFile);

package/src/server/lib/btw/store.server.ts

@@ -15,10 +15,14 @@
  * `leaf_id` is the parent session's transcript leaf when the topic started.
  * Promotion refuses when the parent has moved on, exactly like omp's own
  * `/btw` branch guard ("session changed since /btw started").
+ *
+ * `thinking_level` holds the chat's thinking SELECTOR (`auto` included), not the
+ * effort the side child resolved; `approval_mode` is no longer written — a side
+ * child runs `--no-tools`, so there is no approval gate to configure. Both
+ * columns stay in the schema for existing rows.
  */
 
 import { getDb } from '@/server/db.server';
-import { isApprovalMode, type ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { BtwModel, BtwTopic, BtwTurn, BtwTurnStatus, ChatMessageData } from '@/shared/types';
 
 interface TopicRow {
@@ -51,7 +55,7 @@ const TURN_STATUSES: Record<string, true> = {
   running: true,
   complete: true,
   cancelled: true,
-  failed: true,
+  error: true,
   interrupted: true,
 };
 
@@ -72,7 +76,6 @@ function rowToTopic(row: TopicRow): BtwTopic {
     updatedAt: row.updated_at,
     ...(model ? { model } : {}),
     ...(row.thinking_level ? { thinkingLevel: row.thinking_level } : {}),
-    ...(isApprovalMode(row.approval_mode) ? { approvalMode: row.approval_mode } : {}),
     ...(row.promoted_session_id ? { promotedSessionId: row.promoted_session_id } : {}),
     turns: [],
   };
@@ -138,10 +141,8 @@ export interface NewBtwTopicInput {
   sessionId: string;
   title: string;
   model?: BtwModel;
+  /** The chat's thinking selector, so the side child classifies like the chat. */
   thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
-  /** Parent transcript leaf when the topic was created (promotion guard). */
-  leafId?: string | null;
 }
 
 export async function createBtwTopic(input: NewBtwTopicInput): Promise<BtwTopic> {
@@ -155,8 +156,8 @@ export async function createBtwTopic(input: NewBtwTopicInput): Promise<BtwTopic>
     model_id: input.model?.id ?? null,
     model_name: input.model?.name ?? null,
     thinking_level: input.thinkingLevel ?? null,
-    approval_mode: input.approvalMode ?? null,
-    leaf_id: input.leafId ?? null,
+    approval_mode: null,
+    leaf_id: null,
     promoted_session_id: null,
     created_at: now,
     updated_at: now,
@@ -262,18 +263,6 @@ export async function setBtwTopicModel(topicId: string, model: BtwModel): Promis
   ]);
 }
 
-/** Record the thinking level the side child runs at (`null` clears it). */
-export async function setBtwTopicThinkingLevel(topicId: string, level: string | null): Promise<void> {
-  const db = await getDb();
-  await db.run('UPDATE btw_topics SET thinking_level = ?, updated_at = ? WHERE id = ?', [level, Date.now(), topicId]);
-}
-
-/** Record the approval mode the side child was spawned with. */
-export async function setBtwTopicApprovalMode(topicId: string, mode: ApprovalMode): Promise<void> {
-  const db = await getDb();
-  await db.run('UPDATE btw_topics SET approval_mode = ?, updated_at = ? WHERE id = ?', [mode, Date.now(), topicId]);
-}
-
 export async function setBtwTopicPromoted(topicId: string, promotedSessionId: string): Promise<void> {
   const db = await getDb();
   await db.run('UPDATE btw_topics SET promoted_session_id = ?, updated_at = ? WHERE id = ?', [

package/src/server/lib/omp/rpc/constants.ts

@@ -134,6 +134,16 @@ export const PASSTHROUGH_COMMANDS = new Set([
 // whose liveness probe had just reported `running: false`).
 export const OBSERVER_ONLY_COMMANDS = new Set(['get_subagents', 'get_subagent_messages']);
 
+/**
+ * Commands that MOVE the conversation: they replace the transcript the session
+ * is running on, so a side question that snapshotted the old one would be left
+ * describing a conversation the chat has already left. omp blocks the same
+ * operations while a `/btw` answer is in flight or unsaved
+ * (`BtwController.withSessionMove` / `flush`); the chamber refuses them with
+ * `btw_busy` (409) instead.
+ */
+export const CONVERSATION_MOVING_COMMANDS = new Set(['switch_session', 'branch', 'new_session', 'handoff']);
+
 // Commands that can carry user-attached images to the model. All of them must
 // pass the same server-side per-image/count/aggregate validation before the
 // payload reaches omp — a client is free to POST any of them directly.