ompchamber 1.2.1 → 2.0.0

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

@@ -9,27 +9,44 @@
  * The side question runs in a second `omp --mode rpc-ui` child that resumes the
  * topic's own transcript — a snapshot of the parent session taken when the
  * topic first asks. That gives the parent's context as real provider messages
- * (no re-prompting it as text, and the parent's prompt-cache prefix survives),
- * never writes the parent file, and disables the tool surface exactly like
- * omp's TUI `/btw` (`--no-tools`; the prompt itself says "NEVER use tools").
+ * (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 is disposable by design: history lives in SQLite plus the topic
  * transcript, so an idle reclaim costs a respawn, not the conversation — a
  * follow-up resumes the transcript and still sees every earlier turn.
+ *
+ * This class owns the process and the frame routing; the rules about what a turn
+ * is worth live in `lifecycle.server.ts`.
  */
 
 import { RpcProcess, type RpcFrame } from '@/server/lib/omp/rpc/process';
-import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, PROMPT_ACK_TIMEOUT_MS, READY_TIMEOUT_MS, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
+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 { buildBtwPrompt } from '@/server/lib/btw/prompt';
-import { appendBtwTurn, setBtwTopicLeaf, setBtwTopicModel, settleRunningBtwTurns, updateBtwTurn } from '@/server/lib/btw/store.server';
+import { buildBtwSpawnArgs, type BtwSpawnSettings } from '@/server/lib/btw/child.server';
+import {
+  abortSideTurn,
+  askSideQuestion,
+  handleSideChildExit,
+  resetSideIdleTimer,
+  settleSideTurn,
+  teardownSideChild,
+  trackTurnActivity,
+  trackTurnMessage,
+  type BtwLifecycleHost,
+} from '@/server/lib/btw/lifecycle.server';
+import { setBtwTopicModel, setBtwTopicThinkingLevel } from '@/server/lib/btw/store.server';
 import { createBtwWorkspace, resolveBtwWorkspacePaths, type BtwWorkspace } from '@/server/lib/btw/session-copy.server';
-import { isRecord } from '@/shared/lib/util/guards';
 import { finalAnswer, finalStatus, isAnswerableUiMethod } from '@/server/lib/btw/frames';
-import type { AgentImage, BtwFrame, BtwModel, BtwTurnStatus } from '@/shared/types';
-
-/** Longest an aborted turn may stay unsettled before its child is reclaimed. */
-const ABORT_GRACE_MS = 10_000;
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import type { AgentImage, BtwFrame, BtwLiveTurn, BtwModel, BtwTurnStatus, ChatMessageData } from '@/shared/types';
 
 /** Prompt images, validated by the route before they reach the child. */
 export type BtwImages = AgentImage[];
@@ -41,6 +58,8 @@ export interface BtwRuntimeContext {
   parentSessionFile: string;
   cwd: string;
   model?: BtwModel;
+  thinkingLevel?: string;
+  approvalMode?: ApprovalMode;
 }
 
 /** Where the runtime reports what happened. */
@@ -61,21 +80,28 @@ export class BtwError extends Error {
   }
 }
 
-export class BtwRuntime {
-  private proc: RpcProcess | null = null;
+export class BtwRuntime implements BtwLifecycleHost {
+  proc: RpcProcess | null = null;
   private starting: Promise<RpcProcess> | null = null;
   private workspace: BtwWorkspace | null = null;
-  private idleTimer: NodeJS.Timeout | null = null;
-  private abortTimer: NodeJS.Timeout | null = null;
-  private lastIdleReset = 0;
-  private turnIndex: number | null = null;
-  private settling = false;
-  private answer = '';
-  private disposing: Promise<void> | null = null;
+  idleTimer: NodeJS.Timeout | null = null;
+  abortTimer: NodeJS.Timeout | null = null;
+  lastIdleReset = 0;
+  turnIndex: number | null = null;
+  settling = false;
+  /** The turn's conversation so far (chat-shaped; see `trackTurnMessage`). */
+  messages: ChatMessageData[] = [];
+  /** 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;
 
   constructor(
     private readonly context: BtwRuntimeContext,
-    private readonly sink: BtwRuntimeSink,
+    readonly sink: BtwRuntimeSink,
   ) {}
 
   get topicId(): string {
@@ -98,49 +124,61 @@ export class BtwRuntime {
     return this.settling;
   }
 
-  /** Ask (or follow up) — the caller has already refused concurrent turns. */
-  async ask(question: string, images?: BtwImages): Promise<void> {
-    if (this.running) throw new BtwError('A side question is already running here.', 'btw_busy');
-    this.turnIndex = await appendBtwTurn(this.topicId, question);
-    this.answer = '';
+  /** The in-flight turn as the server has accumulated it, for `btw_state`. */
+  liveTurn(): BtwLiveTurn | null {
+    if (this.turnIndex === null) return null;
+    return {
+      topicId: this.topicId,
+      turnIndex: this.turnIndex,
+      messages: this.messages,
+      activity: this.activity,
+    };
+  }
+
+  ask(question: string, images?: BtwImages): Promise<void> {
+    return askSideQuestion(this, question, images);
+  }
+
+  abort(): Promise<void> {
+    return abortSideTurn(this);
+  }
+
+  /**
+   * 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.
+   */
+  async setModel(provider: string, modelId: string): Promise<void> {
+    await setBtwTopicModel(this.topicId, { provider, id: modelId });
     this.sink.stateChanged();
-    try {
-      const proc = await this.start();
-      await proc.sendCommand(
-        { type: 'prompt', message: buildBtwPrompt(question), ...(images?.length ? { images } : {}) },
-        PROMPT_ACK_TIMEOUT_MS,
-      );
-    } catch (error) {
-      await this.settle('failed');
-      this.sink.publish({
-        type: 'btw_error',
-        topicId: this.topicId,
-        message: error instanceof Error ? error.message : String(error),
-      });
-    }
-    this.resetIdleTimer(true);
+    const proc = this.proc;
+    if (!proc?.isAlive) return;
+    await proc.sendCommand({ type: 'set_model', provider, modelId }, GET_STATE_TIMEOUT_MS);
   }
 
-  /** Cancel the running question, keeping whatever text already arrived. */
-  async abort(): Promise<void> {
-    if (!this.running) return;
+  /** 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) {
-      await this.settle('cancelled');
-      return;
-    }
-    try {
-      await proc.sendCommand({ type: 'abort' }, GET_STATE_TIMEOUT_MS);
-    } catch {
-      // An unanswered abort is the escalate-to-cancel path below, not an error.
-    }
-    if (this.abortTimer) clearTimeout(this.abortTimer);
-    const timer = setTimeout(() => {
-      this.abortTimer = null;
-      void this.disposeIfUnsettled();
-    }, ABORT_GRACE_MS);
-    timer.unref?.();
-    this.abortTimer = timer;
+    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();
   }
 
   /** Reclaim the child; the topic's history survives in SQLite and on disk. */
@@ -148,26 +186,14 @@ export class BtwRuntime {
     if (this.disposing) return this.disposing;
     if (this.running) {
       // A turn would die with the child — settle it rather than lose the answer.
-      await this.settle('cancelled');
+      await settleSideTurn(this, 'cancelled');
     }
-    this.disposing = this.teardown();
+    this.disposing = this.teardownChild();
     return this.disposing;
   }
 
-  private async teardown(): Promise<void> {
-    if (this.idleTimer) clearTimeout(this.idleTimer);
-    if (this.abortTimer) clearTimeout(this.abortTimer);
-    this.idleTimer = null;
-    this.abortTimer = null;
-    const proc = this.proc;
-    this.proc = null;
-    if (proc) await proc.dispose().catch(() => {});
-    this.disposing = null;
-  }
-
-  private async disposeIfUnsettled(): Promise<void> {
-    if (this.running) await this.settle('cancelled');
-    await this.dispose();
+  async teardownChild(): Promise<void> {
+    await teardownSideChild(this);
   }
 
   private ensureWorkspace(): Promise<BtwWorkspace> {
@@ -190,11 +216,10 @@ export class BtwRuntime {
     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.
-    if (workspace.leafId) await setBtwTopicLeaf(this.context.topicId, workspace.leafId);
     return workspace;
   }
 
-  private start(): Promise<RpcProcess> {
+  start(): Promise<RpcProcess> {
     if (this.starting) return this.starting;
     const started = this.spawnChild();
     this.starting = started;
@@ -210,35 +235,41 @@ export class BtwRuntime {
     const bin = resolveOmpBin();
     if (!bin) throw new BtwError('The omp binary could not be found.', 'btw_unavailable');
     const workspace = await this.ensureWorkspace();
-    const model = this.context.model;
+    const settings: BtwSpawnSettings = {
+      model: this.context.model,
+      thinkingLevel: this.context.thinkingLevel,
+      approvalMode: this.context.approvalMode,
+    };
     const proc = new RpcProcess({
       cwd: this.context.cwd,
-      extraArgs: [
-        '--resume',
-        workspace.sessionFile,
-        // Side questions never touch tools, so no approval mode is needed.
-        '--no-tools',
-        // Auto-titling would spend a model call on a transcript nobody lists.
-        '--no-title',
-        ...(model ? ['--model', `${model.provider}/${model.id}`] : []),
-      ],
+      extraArgs: buildBtwSpawnArgs(workspace.sessionFile, settings),
       onFrame: (frame) => this.handleFrame(frame),
-      onExit: (info) => this.handleExit(info.stderrTail),
+      onExit: (info) => handleSideChildExit(this, info.stderrTail),
     });
     this.proc = proc;
+    this.spawnedApprovalMode = this.context.approvalMode;
     const ready = await proc.waitReady(READY_TIMEOUT_MS);
     await proc.negotiateProtocol(ready);
     await this.captureModel(proc);
     return proc;
   }
 
-  /** Record the display name the child reports, for the panel's model chip. */
+  /**
+   * 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.
+   */
   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.context.topicId, { provider: reported.provider, id: reported.id, name: 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();
       }
     } catch {
@@ -247,78 +278,40 @@ export class BtwRuntime {
   }
 
   private handleFrame(frame: RpcFrame): void {
-    if (frame.type === 'message_update') {
-      const event = frame.assistantMessageEvent;
-      if (isRecord(event) && event.type === 'text_delta' && typeof event.delta === 'string' && this.turnIndex !== null) {
-        this.answer += event.delta;
-        this.sink.publish({ type: 'btw_delta', topicId: this.topicId, turnIndex: this.turnIndex, text: event.delta });
-      }
+    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(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);
     } 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 this.settle(finalStatus(frame.messages), finalAnswer(frame.messages, this.answer));
+      void settleSideTurn(this, finalStatus(frame.messages), finalAnswer(frame.messages, ''));
     } else if (frame.type === 'extension_ui_request') {
-      this.answerExtensionUi(frame);
+      this.trackDialog(frame);
     }
-    this.resetIdleTimer();
+    resetSideIdleTimer(this);
   }
 
-  /** A side session has no UI: release any dialog omp parks on, so it can
-   *  never block a turn that the panel is waiting on. */
-  private answerExtensionUi(frame: RpcFrame): void {
-    const id = frame.id;
-    if (typeof id !== 'string' || !isAnswerableUiMethod(frame.method)) return;
-    this.proc?.sendFrame({ type: 'extension_ui_response', id, cancelled: true });
-  }
-
-  private async settle(status: BtwTurnStatus, answer?: string): Promise<void> {
-    const turnIndex = this.turnIndex;
-    if (turnIndex === null) return;
-    this.turnIndex = null;
-    const text = answer ?? this.answer;
-    this.answer = '';
-    // `busy` holds the topic live across the write: a state read that lands in
-    // this window must not settle the row as `interrupted` (see `btwStateFor`).
-    this.settling = true;
-    try {
-      await updateBtwTurn(this.topicId, turnIndex, { answer: text, status });
-    } finally {
-      this.settling = false;
-      this.sink.stateChanged();
-    }
-  }
-
-  private handleExit(stderrTail: string): void {
-    const wasRunning = this.running;
-    this.proc = null;
-    if (!wasRunning) return;
-    void settleRunningBtwTurns(this.topicId, 'interrupted').then(() => {
-      this.turnIndex = null;
-      this.answer = '';
-      this.sink.stateChanged();
-      const detail = stderrTail.trim().split('\n').pop();
-      this.sink.publish({
-        type: 'btw_error',
-        topicId: this.topicId,
-        message: `The side session exited before answering${detail ? `: ${detail}` : '.'}`,
-      });
-    });
-  }
-
-  private resetIdleTimer(force = false): void {
-    const now = Date.now();
-    if (!force && this.idleTimer && now - this.lastIdleReset < 5_000) return;
-    this.lastIdleReset = now;
-    if (this.idleTimer) clearTimeout(this.idleTimer);
-    const timer = setTimeout(() => {
-      if (this.running) {
-        this.resetIdleTimer(true);
-        return;
-      }
-      void this.dispose();
-    }, IDLE_DESTROY_MS);
-    timer.unref?.();
-    this.idleTimer = timer;
+  /**
+   * 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.ts

@@ -19,6 +19,8 @@ const BTW_SCHEMA_SQL = `
     provider TEXT,
     model_id TEXT,
     model_name TEXT,
+    thinking_level TEXT,
+    approval_mode TEXT,
     leaf_id TEXT,
     promoted_session_id TEXT,
     created_at INTEGER NOT NULL,
@@ -31,6 +33,7 @@ const BTW_SCHEMA_SQL = `
     turn_index INTEGER NOT NULL,
     question TEXT NOT NULL DEFAULT '',
     answer TEXT NOT NULL DEFAULT '',
+    messages TEXT NOT NULL DEFAULT '[]',
     status TEXT NOT NULL,
     created_at INTEGER NOT NULL,
     updated_at INTEGER NOT NULL,
@@ -38,7 +41,31 @@ const BTW_SCHEMA_SQL = `
   );
 `;
 
+/**
+ * Columns added after the tables shipped. `CREATE TABLE IF NOT EXISTS` leaves an
+ * existing table alone, so an install created before these existed would miss
+ * them and every read would fail on the absent column. Additive only: a column
+ * is added once, and a fresh database already has it from the DDL above.
+ */
+const BTW_ADDED_COLUMNS: { table: string; column: string; ddl: string }[] = [
+  { table: 'btw_topics', column: 'thinking_level', ddl: 'ALTER TABLE btw_topics ADD COLUMN thinking_level TEXT' },
+  { table: 'btw_topics', column: 'approval_mode', ddl: 'ALTER TABLE btw_topics ADD COLUMN approval_mode TEXT' },
+  // A turn's conversation used to be the plain `answer` string alone; the panel
+  // now renders the chat's own ChatMessageData, so the column arrives with the
+  // default an empty conversation has.
+  { table: 'btw_turns', column: 'messages', ddl: "ALTER TABLE btw_turns ADD COLUMN messages TEXT NOT NULL DEFAULT '[]'" },
+];
+
+async function hasColumn(db: DbClient, table: string, column: string): Promise<boolean> {
+  const rows = (await db.all(`PRAGMA table_info(${table})`)) as { name?: string }[];
+  return rows.some((row) => row.name === column);
+}
+
 /** Idempotent: side questions live beside the session they belong to. */
 export async function ensureBtwSchema(db: DbClient): Promise<void> {
   await db.exec(BTW_SCHEMA_SQL);
+  for (const added of BTW_ADDED_COLUMNS) {
+    if (await hasColumn(db, added.table, added.column)) continue;
+    await db.exec(added.ddl);
+  }
 }

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

@@ -21,15 +21,42 @@ 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 { createBtwTopic, deleteBtwTopic, getBtwTopic, readBtwTopicLeaf, setBtwTopicPromoted } from '@/server/lib/btw/store.server';
+import { loadPersistedAccessMode } from '@/shared/lib/omp/config/access-mode.server';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+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 { BtwState } from '@/shared/types';
+import type { BtwModel, BtwState } from '@/shared/types';
 
 /** Longest a topic label may be, matching the sidebar's session-title length. */
 const TOPIC_TITLE_CHARS = 60;
 
+/**
+ * Marks a session that was promoted out of a side question, in the sidebar list
+ * the user reads. Applied to the PROMOTED SESSION only — the topic's own label
+ * in the panel keeps the plain question.
+ *
+ * It lives in the session title because that is what the sidebar renders, and
+ * the title slot (line 1) is authoritative over the header. omp's auto-title
+ * cannot overwrite it: its latch is `autoTitlePending = messageCount === 0`, and
+ * a promoted transcript always carries the parent's history.
+ *
+ * Note the sidebar capitalizes the first character (`SessionItem`), so this
+ * renders as `Btw: …`.
+ */
+const PROMOTED_TITLE_PREFIX = 'btw: ';
+
 function topicTitle(question: string): string {
   const firstLine = question.trim().split('\n')[0].trim();
   return firstLine.slice(0, TOPIC_TITLE_CHARS);
@@ -59,6 +86,22 @@ export interface AskBtwInput {
   topicId?: string;
   question: string;
   images?: BtwImages;
+  /**
+   * Inline-able text files, read by the client at attach time and sent with the
+   * question. They are appended to the prompt body exactly as a chat prompt
+   * carries them (`composeMessageWithTextAttachments`), so a side question can
+   * 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> {
@@ -76,12 +119,15 @@ 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());
   const topic =
     existing ??
     (await createBtwTopic({
       sessionId,
       title: topicTitle(question),
-      model: await topicModel(parent.sessionFile),
+      model: input.model ?? (await topicModel(parent.sessionFile)),
+      thinkingLevel: input.thinkingLevel,
+      approvalMode,
     }));
 
   const runtime = ensureBtwRuntime({
@@ -90,9 +136,64 @@ export async function askBtw(sessionId: string, input: AskBtwInput): Promise<Btw
     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,
   });
 
-  await runtime.ask(question, input.images);
+  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);
 }
 
@@ -145,7 +246,7 @@ export async function promoteBtw(sessionId: string, topicId: string): Promise<{
   }
 
   const paths = await resolveBtwWorkspacePaths(sessionId, topicId);
-  const title = topicTitle(topic.turns[0].question);
+  const title = `${PROMOTED_TITLE_PREFIX}${topicTitle(topic.turns[0].question)}`;
   const created = await materializePromotedTopic({
     parentSessionFile: parent.sessionFile,
     topicSessionFile: paths.sessionFile,