ompchamber 3.3.2 → 3.4.0

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/bundler/build-errors.server.ts

@@ -33,9 +33,9 @@
 import { join, relative } from 'path';
 import type { BuildOutput, BunPlugin } from 'bun';
 
-import { packageRoot } from '@/server/lib/assets/fonts.server';
+import { packageDir } from '@/server/lib/assets/fonts.server';
 
-/** The shell bundle's entrypoint, relative to the package root. */
+/** The shell bundle's entrypoint, relative to the package directory. */
 const SHELL_ENTRYPOINT = 'index.html';
 
 /** Bun's own config file, and the section naming the bundle's plugins. */
@@ -109,8 +109,13 @@ function formatLog(log: BundleLog, root: string): string {
 /**
  * The bundle errors behind a shell that would not render, or null when this
  * build is not the reason (a clean bundle means the failure lies elsewhere).
+ *
+ * `root` is the PACKAGE, not `packageRoot()`: the entrypoint is `index.html`
+ * beside the source, and in a hoisted install the first root holding
+ * `node_modules` is the parent, where `index.html` does not exist — so the probe
+ * would report no failure at all and the real build error would never be shown.
  */
-export async function describeShellBuildFailure(root = packageRoot()): Promise<string | null> {
+export async function describeShellBuildFailure(root = packageDir()): Promise<string | null> {
   const entrypoint = join(root, SHELL_ENTRYPOINT);
   if (!(await Bun.file(entrypoint).exists())) return null;
 

package/src/server/lib/bundler/css.ts

@@ -30,18 +30,17 @@
  *    rewrite inside the bundle can work.
  *
  *    The faces therefore leave the bundle. Each block is rewritten to
- *    `<FONT_ROUTE_PREFIX><basename>` and written to its own file under
- *    `FONT_FACE_DIR`, keyed by the stylesheet it came from — a document Bun
- *    never parses, which is what lets the urls survive. The server concatenates
- *    that directory into `/fonts.css` (`lib/assets/font-css.server.ts`) and the
- *    shell links it, so the layout rules stay bundled while the faces stay
+ *    `<FONT_ROUTE_PREFIX><basename>` and dropped from the module, and the server
+ *    re-declares them on `/fonts.css` from the SAME source stylesheets
+ *    (`lib/assets/font-css.server.ts`, `lib/assets/font-faces.ts`). The shell
+ *    links that route, so the layout rules stay bundled while the faces stay
  *    cacheable files.
  *
- *    Per-source files rather than one accumulated file because `onEnd` is NOT
- *    invoked by `serve.static` (verified: `onStart` and `onLoad` fire, `onEnd`
- *    never does), so there is no "build finished" moment to flush at. Writing
- *    each source's faces as its `onLoad` returns is order-independent and works
- *    identically under both entry points.
+ *    The server derives the faces from source rather than from a directory this
+ *    plugin wrote, because `onEnd` is NOT invoked by `serve.static` (verified:
+ *    `onStart` and `onLoad` fire, `onEnd` never does) and a written artifact is
+ *    produced exactly once per process — a `rm -rf` after boot, or a fresh clone
+ *    that never built, would leave `/fonts.css` empty for good.
  *
  * 3. **Nested at-rules are flattened** (`flattenNestedAtRules`, registered
  *    AFTER Tailwind so it sees the expanded tree). Bun's CSS minifier keeps the
@@ -53,57 +52,14 @@
  *    the measurement; this one only has to run it.
  */
 
-import { basename, dirname, isAbsolute, join, resolve as resolvePath } from 'path';
+import { dirname } from 'path';
 import postcss from 'postcss';
 import tailwind from '@tailwindcss/postcss';
 import type { BunPlugin } from 'bun';
 
-import { FONT_FACE_DIR } from '@/server/lib/assets/font-css.server';
-import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
+import { splitFontFaces } from '@/server/lib/assets/font-faces';
 import { flattenNestedAtRules } from '@/server/lib/bundler/nested-at-rules';
 
-/** A `url(...)` whose target is a font file. */
-const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
-const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
-/** Schemes Bun leaves alone, and the prefix this plugin itself emits. */
-const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
-
-/** One `@font-face` block, braces included. Faces cannot nest. */
-const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
-
-/** Absolute path of a local font url, or null when it is not one. */
-function localFont(specifier: string, cssDir: string): string | null {
-  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
-  if (!FONT_FILE.test(specifier)) return null;
-  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
-}
-
-/** Point every font `url()` at the served path. */
-function rewriteFontUrls(css: string, cssDir: string): string {
-  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
-    const absolute = localFont(specifier, cssDir);
-    if (!absolute) return whole;
-    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
-  });
-}
-
-/**
- * Split `@font-face` blocks out of a stylesheet.
- *
- * Only blocks whose `src` names a local font move: a face pointing at a remote
- * url is valid CSS the bundle can keep.
- */
-function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
-  const faces: string[] = [];
-  const rest = css.replace(FONT_FACE, (block) => {
-    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
-    if (!hasLocal) return block;
-    faces.push(rewriteFontUrls(block, cssDir));
-    return '';
-  });
-  return { rest, faces };
-}
-
 const plugin: BunPlugin = {
   name: 'ompchamber-css',
   setup(build) {
@@ -117,12 +73,7 @@ const plugin: BunPlugin = {
       const expanded = await postcss([tailwind(), flattenNestedAtRules()]).process(source, {
         from: args.path,
       });
-      const { rest, faces } = splitFontFaces(expanded.css, dirname(args.path));
-      if (faces.length > 0) {
-        const target = join(packageRoot(), FONT_FACE_DIR, `${basename(args.path)}`);
-        const header = `/* GENERATED from ${args.path} — do not edit. */\n`;
-        await Bun.write(target, header + faces.join('\n') + '\n');
-      }
+      const { rest } = splitFontFaces(expanded.css, dirname(args.path));
       return { contents: rest, loader: 'css' };
     });
   },

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.

package/src/server/lib/omp/rpc/session-commands.ts

@@ -15,6 +15,7 @@ import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
 import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
+import { isTuiOnlySlashCommand, tuiOnlyCommandNotice } from '@/shared/lib/chat/composer/tui-only';
 
 /** Runtime surface AgentSessionWrapper exposes to the command dispatcher. */
 export interface SessionCommandHost extends WebStateHost {
@@ -50,6 +51,44 @@ async function settleCommandTimeout(host: SessionCommandHost): Promise<never> {
   throw new WebRpcError('The OMP session stopped responding and was reset.', 'session_unresponsive');
 }
 
+/**
+ * Refuse a prompt that invokes a command omp implements only in its TUI, and
+ * report it the way omp reports a real command result.
+ *
+ * This is the SERVER half of the guard in
+ * `client/hooks/chat/timeline/tui-only-guard.ts`. It exists because one prompt
+ * path never passes through the composer: the follow-up queue's auto-delivery
+ * calls `session.send({ type: 'prompt' })` directly from
+ * `lib/queue/delivery.server.ts`. A `/plan` queued before a run would otherwise
+ * be delivered to the model as literal text once the run ends.
+ *
+ * The refusal is framed as a real command result — a `command_output` notice
+ * plus, for a non-streaming prompt, the `agentInvoked:false` ack — so the
+ * client's existing fold renders the notice and settles the optimistic spinner
+ * with no new protocol.
+ *
+ * `streaming` is the caller's own knowledge of whether a turn is running: a
+ * steer of a refused command must not clear the flags of the turn it was aimed
+ * at (omp runs `session.steer()` with no slash handling at all, so a steer of
+ * `/plan` is exactly as meaningless as a fresh one).
+ *
+ * Returns true when the prompt was refused (the caller must not dispatch).
+ */
+function refuseTuiOnlyPrompt(host: SessionCommandHost, message: unknown, streaming: boolean): boolean {
+  if (typeof message !== 'string' || !isTuiOnlySlashCommand(message)) return false;
+  host.emit({ type: 'command_output', text: tuiOnlyCommandNotice(message) });
+  if (!streaming) {
+    host.promptRunning = false;
+    host.awaitingAgentStart = false;
+    host.awaitingAgentStartDeadline = 0;
+    host.emit({ type: 'prompt_result', agentInvoked: false });
+    // Nothing ran, so the queue may hold the next item — give it the same
+    // delivery window a real consumed builtin or a run end would.
+    scheduleQueueDelivery(host);
+  }
+  return true;
+}
+
 export async function dispatchSessionCommand(host: SessionCommandHost, command: Record<string, unknown>): Promise<unknown> {
   if (host.restarting) throw new WebRpcError(RESTARTING_MESSAGE, 'session_restarting');
   if (!host.isAlive()) throw new Error('Session is no longer running');
@@ -66,6 +105,11 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
       if (host.bashRunning) {
         throw new Error('Cannot send a prompt while a shell command is running');
       }
+      // Checked before the streaming-behavior split: a steer of a TUI-only
+      // command is just as meaningless as a fresh one. `streaming` keeps the
+      // refusal from clearing a running turn's flags when the prompt was a
+      // steer aimed at that turn.
+      if (refuseTuiOnlyPrompt(host, command.message, Boolean(command.streamingBehavior))) return null;
       const streamingBehavior = command.streamingBehavior as 'steer' | 'followUp' | undefined;
       // The live `stream` row starts with the DISPATCH, not with agent_start:
       // the spawn/ack round trip that precedes agent_start must not read as
@@ -229,6 +273,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
       if (!host.isRunning()) {
         throw new WebRpcError('The session is idle — start a prompt first.', 'session_idle');
       }
+      if (refuseTuiOnlyPrompt(host, command.message, true)) return null;
       await host.proc.sendCommand({
         type,
         message: command.message as string,

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;
 }