ompchamber 1.2.1 → 2.0.1

package/src/server/routes/fs/search.ts

@@ -1,8 +1,8 @@
 import { json, type ActionFunctionArgs } from '@/server/lib/remix-compat';
-import { ripgrep } from 'ripgrep';
 import { isMockMode } from '@/server/mock.server';
 import { getDefaultFsRoot, resolveRoot } from '@/server/lib/fs/root';
 import { scopeToRepo } from '@/server/lib/fs/repo-scope';
+import { runRipgrep } from '@/server/lib/fs/ripgrep';
 import { createSseStream } from '@/server/lib/sse';
 
 export interface SearchMatch {
@@ -86,38 +86,29 @@ export async function action({ request }: ActionFunctionArgs) {
     async onStart(handlers) {
       const send = (event: string, data: unknown) => handlers.send(event, data);
 
-      // WASI preopens map the guest "." onto the real target directory.
-      const preopens = { '.': targetDir };
       const decoder = new TextDecoder();
       let pending = '';
       let count = 0;
       let stderrText = '';
 
       try {
-        const { code } = await ripgrep(buildArgs(q, matchCase, wholeWord, useRegex, includeFiles), {
-          preopens,
-          // ripgrep accepts any `{ write(chunk) }` sink — feed it the raw
-          // WritableStream sink so matches flush incrementally.
-          stdout: {
-            write(chunk) {
-              pending += decoder.decode(chunk, { stream: true });
-              const lines = pending.split('\n');
-              pending = lines.pop() ?? '';
-              const batch: SearchMatch[] = [];
-              for (const line of lines) {
-                const match = parseRgLine(line);
-                if (match) batch.push(match);
-              }
-              if (batch.length) {
-                count += batch.length;
-                send('matches', batch);
-              }
-            },
+        const code = await runRipgrep(buildArgs(q, matchCase, wholeWord, useRegex, includeFiles), targetDir, {
+          onStdout(chunk) {
+            pending += decoder.decode(chunk, { stream: true });
+            const lines = pending.split('\n');
+            pending = lines.pop() ?? '';
+            const batch: SearchMatch[] = [];
+            for (const line of lines) {
+              const match = parseRgLine(line);
+              if (match) batch.push(match);
+            }
+            if (batch.length) {
+              count += batch.length;
+              send('matches', batch);
+            }
           },
-          stderr: {
-            write(chunk) {
-              stderrText += decoder.decode(chunk, { stream: true });
-            },
+          onStderr(chunk) {
+            stderrText += decoder.decode(chunk, { stream: true });
           },
         });
         // rg exit codes: 0 = matches, 1 = no matches, 2 = error (bad regex, IO failure).

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

@@ -22,7 +22,7 @@ import {
   reorderQueue,
 } from '@/server/lib/queue/store.server';
 import { getRpcSession } from '@/server/lib/omp/rpc/manager';
-import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
+import { deliverQueueNow } from '@/server/lib/queue/delivery.server';
 
 /** GET — the session's queued follow-ups in delivery order. */
 export async function getQueue({ params }: LoaderFunctionArgs) {
@@ -108,6 +108,17 @@ export async function reorderQueueItems({ request, params }: ActionFunctionArgs)
  * the server a delivery slot. The server-side claim makes this a no-op when a
  * run is active or the head was already claimed; an idle session with queued
  * items gets its head delivered exactly once.
+ *
+ * The attempt runs IMMEDIATELY rather than arming the usual settle timer. This
+ * is the recovery path, and the failure it recovers from is a lost timer — a
+ * long-lived `--hot` dev server whose `setTimeout` callbacks stop firing leaves
+ * `scheduleQueueDelivery` scheduling into the void, so a nudge that merely
+ * re-armed another timer would fail exactly like the delivery it was meant to
+ * rescue. The 500ms settle exists to let omp's own turn-end bookkeeping finish;
+ * by the time a client nudges, that window has long passed.
+ *
+ * The response carries the CANONICAL queue, so a client polling this as a
+ * safety net gets its panel reconciled in the same round trip.
  */
 export async function nudgeQueueDelivery({ request, params }: ActionFunctionArgs) {
   const sessionId = requireParam(params, 'sessionId');
@@ -115,7 +126,9 @@ export async function nudgeQueueDelivery({ request, params }: ActionFunctionArgs
   if (request.method !== 'POST') return json({ error: 'Method not allowed' }, { status: 405 });
 
   const session = getRpcSession(sessionId);
-  if (!session?.isAlive()) return json({ success: true, delivered: false, reason: 'session-not-live' });
-  scheduleQueueDelivery(session);
-  return json({ success: true });
+  if (!session?.isAlive()) {
+    return json({ success: true, delivered: false, reason: 'session-not-live', queue: await listQueue(sessionId) });
+  }
+  const delivered = await deliverQueueNow(session);
+  return json({ success: true, delivered, queue: await listQueue(sessionId) });
 }

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

@@ -4,6 +4,7 @@ import * as settingsAgents from '@/server/routes/settings/agents';
 import * as settingsBehavior from '@/server/routes/settings/behavior';
 import * as settingsCommands from '@/server/routes/settings/commands';
 import * as settingsMcp from '@/server/routes/settings/mcp';
+import * as settingsModelOverride from '@/server/routes/settings/model-override';
 import * as settingsMcpTest from '@/server/routes/settings/mcp-test';
 import * as settingsOmpConfig from '@/server/routes/settings/omp-config';
 import * as settingsProjects from '@/server/routes/settings/projects';
@@ -18,6 +19,7 @@ export const settingsBindings: HandlerBinding[] = [
   ...bindingsFor(settingsBehavior, '/api/settings/behavior'),
   ...bindingsFor(settingsCommands, '/api/settings/commands'),
   ...bindingsFor(settingsMcp, '/api/settings/mcp'),
+  ...bindingsFor(settingsModelOverride, '/api/settings/model-override'),
   ...bindingsFor(settingsMcpTest, '/api/settings/mcp-test'),
   ...bindingsFor(settingsOmpConfig, '/api/settings/omp-config'),
   ...bindingsFor(settingsProjects, '/api/settings/projects'),

package/src/server/routes/settings/model-override.ts

@@ -0,0 +1,69 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { isMockMode } from '@/server/mock.server';
+import { writeModelOverride, type ReasoningEffort } from '@/server/lib/omp/config/model-overrides';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+
+/**
+ * PUT /api/settings/model-override — the per-model knobs omp actually honours.
+ *
+ * omp resolves `maxTokens` and the reasoning `thinking` block per model from
+ * models.yml `modelOverrides`, and has no per-model temperature/topP at all
+ * (those exist only as global `config.yml` settings, editable in Settings →
+ * OMP Engine). Writing the chamber's model dialog anywhere else made its
+ * controls inert, so this route is the one that reaches the agent.
+ *
+ * Body: { provider, modelId, maxTokens?: number|null, reasoningEffort?: string|null }
+ */
+
+const EFFORTS: readonly ReasoningEffort[] = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'PUT' && request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  try {
+    const body = await request.json() as {
+      provider?: unknown;
+      modelId?: unknown;
+      maxTokens?: unknown;
+      reasoningEffort?: unknown;
+    };
+    const provider = typeof body.provider === 'string' ? body.provider.trim() : '';
+    const modelId = typeof body.modelId === 'string' ? body.modelId.trim() : '';
+    if (!provider || !modelId) {
+      return json({ error: 'provider and modelId are required' }, { status: 400 });
+    }
+
+    // `null` means "clear the override"; `undefined` means "leave it alone".
+    let maxTokens: number | null | undefined;
+    if (body.maxTokens === null) maxTokens = null;
+    else if (typeof body.maxTokens === 'number' && Number.isFinite(body.maxTokens) && body.maxTokens > 0) {
+      maxTokens = Math.round(body.maxTokens);
+    } else if (body.maxTokens !== undefined) {
+      return json({ error: 'maxTokens must be a positive number or null' }, { status: 400 });
+    }
+
+    let reasoningEffort: ReasoningEffort | null | undefined;
+    if (body.reasoningEffort === null) reasoningEffort = null;
+    else if (typeof body.reasoningEffort === 'string' && (EFFORTS as readonly string[]).includes(body.reasoningEffort)) {
+      reasoningEffort = body.reasoningEffort as ReasoningEffort;
+    } else if (body.reasoningEffort !== undefined) {
+      return json({ error: `reasoningEffort must be one of ${EFFORTS.join(', ')} or null` }, { status: 400 });
+    }
+
+    if (maxTokens === undefined && reasoningEffort === undefined) {
+      return json({ error: 'nothing to write' }, { status: 400 });
+    }
+
+    // Mock mode has no models.yml to edit; the overlay already carries the value.
+    if (isMockMode()) return json({ success: true, written: false, isMock: true });
+
+    const result = await writeModelOverride({ provider, modelId, maxTokens, reasoningEffort });
+    if (result.written) invalidateModelsCaches();
+    return json({ success: result.written, ...result });
+  } catch (error) {
+    return json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+  }
+}

package/src/server/routes/settings/provider-models.ts

@@ -124,10 +124,26 @@ async function fetchRemoteModels(baseUrl: string, apiKey?: string): Promise<Fetc
   };
 }
 
+/**
+ * omp's `api` for a custom provider, inferred from its endpoint. omp accepts
+ * eleven `api` values and there is no way to ask a gateway which one it speaks,
+ * so the chamber only claims the two dialects it can recognise by URL; every
+ * other endpoint gets the OpenAI-compatible default, which is what the
+ * model-listing probe already assumes. A gateway that speaks something else
+ * (Azure, Bedrock, Vertex, …) needs its `api` set by hand in models.yml.
+ */
+function inferProviderApi(baseUrl: string): 'openai-completions' | 'anthropic-messages' | 'google-generative-ai' {
+  if (/anthropic\./i.test(baseUrl)) return 'anthropic-messages';
+  if (/generativelanguage\.googleapis\.com/i.test(baseUrl)) return 'google-generative-ai';
+  return 'openai-completions';
+}
+
 /**
  * omp's models.yml schema requires all four cost fields when cost is present,
  * so a price is only seeded when both sides are known; missing ones default
  * to 0. Context/output labels ("128K ctx · 16K out") parse back to tokens.
+ * Cache prices come from the catalog and are kept when known — dropping them
+ * makes every cached turn look free in omp's usage accounting.
  */
 function toOmpSeed(model: ProviderModel): {
   id: string;
@@ -148,7 +164,14 @@ function toOmpSeed(model: ProviderModel): {
   };
   const contextWindow = parseTokens(model.contextWindow, 'ctx');
   const outTokens = parseTokens(model.contextWindow, 'out');
-  const hasCost = typeof model.priceInput === 'number' && typeof model.priceOutput === 'number';
+  // omp rejects the whole file on a non-finite number, so a price has to be a
+  // real finite value before it may be written at all.
+  const price = (value: unknown): number | undefined => (
+    typeof value === 'number' && Number.isFinite(value) ? value : undefined
+  );
+  const priceInput = price(model.priceInput);
+  const priceOutput = price(model.priceOutput);
+  const hasCost = priceInput !== undefined && priceOutput !== undefined;
   return {
     id: model.id,
     ...(model.name && model.name !== model.id ? { name: model.name } : {}),
@@ -158,10 +181,10 @@ function toOmpSeed(model: ProviderModel): {
     ...(outTokens && outTokens > 0 ? { maxTokens: Math.round(outTokens) } : {}),
     ...(hasCost ? {
       cost: {
-        input: model.priceInput as number,
-        output: model.priceOutput as number,
-        cacheRead: 0,
-        cacheWrite: 0,
+        input: priceInput,
+        output: priceOutput,
+        cacheRead: price(model.priceCacheRead) ?? 0,
+        cacheWrite: price(model.priceCacheWrite) ?? 0,
       },
     } : {}),
   };
@@ -170,8 +193,8 @@ function toOmpSeed(model: ProviderModel): {
 /**
  * Fill in metadata the listing endpoint did not provide from the models.dev
  * catalog: vision/reasoning/tool flags, context + output window, and
- * per-1M-token pricing. Only empty fields are filled — anything the provider
- * reported itself is kept.
+ * per-1M-token pricing (cache rates included). Only empty fields are filled —
+ * anything the provider reported itself is kept.
  */
 async function enrichFromCatalog(
   models: ProviderModel[],
@@ -201,6 +224,10 @@ async function enrichFromCatalog(
       hasTools: model.hasTools || info.tool_call === true,
       priceInput: model.priceInput ?? (typeof info.cost?.input === 'number' ? info.cost.input : undefined),
       priceOutput: model.priceOutput ?? (typeof info.cost?.output === 'number' ? info.cost.output : undefined),
+      priceCacheRead: model.priceCacheRead
+        ?? (typeof info.cost?.cache_read === 'number' ? info.cost.cache_read : undefined),
+      priceCacheWrite: model.priceCacheWrite
+        ?? (typeof info.cost?.cache_write === 'number' ? info.cost.cache_write : undefined),
     };
   });
 }
@@ -244,11 +271,7 @@ export async function action({ request }: ActionFunctionArgs) {
         const upsert = await upsertOmpProviderModels(providerSlug, {
           baseUrl,
           apiKey,
-          api: /anthropic\.com/i.test(baseUrl)
-            ? 'anthropic-messages'
-            : /generativelanguage\.googleapis\.com/i.test(baseUrl)
-              ? 'google-generative-ai'
-              : 'openai-completions',
+          api: inferProviderApi(baseUrl),
           models: enriched.map(toOmpSeed),
         });
         if (upsert.written) invalidateModelsCaches();

package/src/server/routes/settings/providers.ts

@@ -7,6 +7,7 @@ import { isMockMode } from '@/server/mock.server';
 import type { ProviderItem } from '@/shared/types';
 import { createSettingsListStore } from '@/server/lib/db/settings-store';
 import { disableNativeProvider, enableNativeProvider } from '@/server/lib/omp/config/disabled-providers';
+import { removeOmpProvider } from '@/server/lib/omp/config/providers';
 import { PROVIDERS_SETTINGS_KEY as SETTINGS_KEY, deduplicateProviderItems, mergeProviders } from '@/server/lib/models/provider-registry.server';
 import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
 
@@ -111,8 +112,37 @@ export async function action({ request, params }: ActionFunctionArgs) {
       const id = url.searchParams.get('id');
       if (!id) return json({ error: 'id is required' }, { status: 400 });
 
+      const stored = await readStoredProviders();
+      const target = stored.find((provider) => provider.id === id);
       const list = await providersStore.remove(db, id, { absent: DEFAULT_PROVIDERS_LIST, empty: DEFAULT_PROVIDERS_LIST });
-      return respondWithProviders(list);
+
+      // Removing the overlay row alone left the provider registered in
+      // models.yml, so omp kept serving it and the next load merged it straight
+      // back into this list — a delete that visibly did nothing. Unregister it
+      // from the agent's own registry too.
+      let removedFromOmp = false;
+      if (target?.slug && !isMockMode()) {
+        try {
+          removedFromOmp = (await removeOmpProvider(target.slug)).removed;
+          // A provider omp still holds in disabledProviders would linger as a
+          // "disconnected" ghost entry after its models are gone.
+          await enableNativeProvider(target.slug);
+        } catch (error) {
+          // The overlay row is already gone; report the native failure instead
+          // of failing the whole request, so the UI can tell the user the entry
+          // is still in models.yml.
+          const merged = await mergeProviders(list).catch(() => null);
+          return json({
+            success: true,
+            providers: merged?.providers ?? list,
+            removedFromOmp: false,
+            warning: error instanceof Error ? error.message : 'models.yml cleanup failed',
+          });
+        }
+      }
+      invalidateModelsCaches();
+      const merged = await mergeProviders(list);
+      return json({ success: true, providers: merged.providers, removedFromOmp });
     }
 
     if (request.method === 'POST' || request.method === 'PUT') {

package/src/server/routes/settings/root.ts

@@ -3,7 +3,7 @@ import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-
 import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { getDb } from '@/server/db.server';
 import { isMockMode } from '@/server/mock.server';
-import { readAllSettingsJson, writeSettingsJson, writeSettingsRaw } from '@/server/lib/db/settings-store';
+import { isPlainObject, mergeSettingsJson, readAllSettingsJson, writeSettingsJson, writeSettingsRaw } from '@/server/lib/db/settings-store';
 
 export async function loader({ request: _request }: LoaderFunctionArgs) {
   try {
@@ -24,9 +24,14 @@ export async function action({ request, params }: ActionFunctionArgs) {
     const data = await request.json();
     const db = await getDb();
 
-    // Data should be an object of key-value pairs
+    // Data should be an object of key-value pairs. Object values merge into
+    // whatever the key already holds, so a writer that sends one key's patch —
+    // the settings modal now sends only what changed — cannot discard the keys
+    // another writer stored in between. Arrays and scalars still replace.
     for (const [key, value] of Object.entries(data)) {
-      if (typeof value === 'object') {
+      if (isPlainObject(value)) {
+        await mergeSettingsJson(db, key, value);
+      } else if (typeof value === 'object') {
         await writeSettingsJson(db, key, value);
       } else {
         await writeSettingsRaw(db, key, String(value));

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

@@ -14,6 +14,8 @@
  */
 
 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';
@@ -70,6 +72,13 @@ export interface AskBtwInput {
   topicId?: string;
   question: string;
   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> {
@@ -78,6 +87,10 @@ export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<B
     question: input.question,
     ...(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 } : {}),
   });
 }
 
@@ -85,6 +98,27 @@ 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 });
 }

package/src/shared/lib/chat/timeline/tool-phrases.ts

@@ -90,10 +90,17 @@ export const DEVICE_VERBS: Record<string, string> = {
  * Phrase shown while the model streams reasoning or prose rather than running a
  * tool. A tool call always names itself from its own name (see
  * `describeAssistantPhase`), so there is no in-between "preparing" state.
+ *
+ * `sideQuestion` is the BTW panel's FALLBACK phase, used only before the side
+ * child has reported anything: once it does, the panel shows the child's own
+ * per-phase verb (`Thinking`, `Writing response`, or the running tool's name).
+ * It is named for the feature rather than reusing `thinking`, which would claim
+ * a reasoning phase that has not been observed yet.
  */
 export const PHASE_VERBS = {
   thinking: 'Thinking',
   writing: 'Writing response',
+  sideQuestion: 'Answering side question',
 } as const;
 
 export function asString(value: unknown): string | undefined {

package/src/shared/lib/code/line-endings.test.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { detectLineEnding, toDiskText, toLf } from '@/shared/lib/code/line-endings';
+
+describe('line endings', () => {
+  test('the first terminator decides the style', () => {
+    expect(detectLineEnding('a\r\nb\n')).toBe('crlf');
+    expect(detectLineEnding('a\nb\r\n')).toBe('lf');
+  });
+
+  test('a file with no terminator, or one using lone CR, reads as lf', () => {
+    expect(detectLineEnding('single line')).toBe('lf');
+    expect(detectLineEnding('\rleading')).toBe('lf');
+    expect(detectLineEnding('a\rb\r')).toBe('lf');
+  });
+
+  test('the buffer form carries no CR', () => {
+    expect(toLf('a\r\nb\r\n')).toBe('a\nb\n');
+    expect(toLf('a\rb\r')).toBe('a\nb\n');
+    expect(toLf('a\nb\n')).toBe('a\nb\n');
+  });
+
+  test('writing back restores the detected ending', () => {
+    expect(toDiskText('a\nb\n', 'crlf')).toBe('a\r\nb\r\n');
+    expect(toDiskText('a\nb\n', 'lf')).toBe('a\nb\n');
+    // A mixed buffer still normalizes before it is re-encoded.
+    expect(toDiskText('a\r\nb\n', 'crlf')).toBe('a\r\nb\r\n');
+  });
+
+  test('an unedited CRLF round trip is byte-identical', () => {
+    const disk = 'const a = 1;\r\nconst b = 2;\r\n';
+    expect(toDiskText(toLf(disk), detectLineEnding(disk))).toBe(disk);
+  });
+});

package/src/shared/lib/code/line-endings.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Line-ending preservation for the file-editing surfaces.
+ *
+ * Two independent transports destroy the distinction, so the file's own ending
+ * has to be carried out of band rather than inferred from the buffer:
+ *
+ * - A `<textarea>` cannot hold a CRLF. The HTML spec defines its *API value* as
+ *   the raw value with every carriage return removed, so the instant a CRLF file
+ *   is placed in the editing surface the buffer is LF-only — verified in
+ *   Chromium: `textarea.value = 'a\r\nb'` reads back `'a\nb'`.
+ * - `multipart/form-data` normalizes the other way: every bare LF in a field
+ *   value becomes CRLF in transit (the HTML serializer on the way out, Bun's
+ *   parser agreeing on the way in). A save payload therefore cannot say "LF" no
+ *   matter what the buffer held.
+ *
+ * Saving the buffer as-is rewrote the whole file's line endings on a
+ * one-character edit — every line showed as changed in `git diff`. The ending is
+ * detected at read and travels as its own field; the server builds the bytes.
+ * An unedited save is then byte-identical and an edited save a one-line diff.
+ *
+ * Detection is by the FIRST terminator rather than a vote over all of them: a
+ * file is overwhelmingly uniform, and the first ending is the one the author's
+ * editor writes. A file with no terminator, or one using lone CR (classic Mac
+ * OS), reads as `lf`.
+ */
+
+export type LineEnding = 'lf' | 'crlf';
+
+/** The ending the file uses, judged by its first terminator. */
+export function detectLineEnding(text: string): LineEnding {
+  const index = text.indexOf('\n');
+  return index > 0 && text[index - 1] === '\r' ? 'crlf' : 'lf';
+}
+
+/**
+ * The buffer form: CRLF and lone CR collapsed to LF, matching what a textarea
+ * can actually hold. A string already free of CR is returned unchanged.
+ */
+export function toLf(text: string): string {
+  return text.includes('\r') ? text.replace(/\r\n?/g, '\n') : text;
+}
+
+/**
+ * The disk form: `text` normalized — whatever mix of endings it carries, and
+ * whether or not it came back through a transport that rewrote them — and then
+ * written with `ending`.
+ */
+export function toDiskText(text: string, ending: LineEnding): string {
+  const lf = toLf(text);
+  return ending === 'crlf' ? lf.replace(/\n/g, '\r\n') : lf;
+}

package/src/shared/lib/code/shiki-themes.ts

@@ -3,12 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * The two Shiki palettes every token carries.
+ *
+ * Shiki emits both palettes on every token span as `--shiki-light` /
+ * `--shiki-dark` custom properties with no inline color, so switching themes
+ * recolors code with zero JS and no re-highlight. `tailwind.css` selects which
+ * one paints, keyed off `<html data-theme-variant>` rather than a list of theme
+ * ids — that list is what a new theme used to fall through.
+ */
 export const SHIKI_LIGHT = 'one-light';
 export const SHIKI_DARK = 'one-dark-pro';
 
 export const SHIKI_THEMES = { light: SHIKI_LIGHT, dark: SHIKI_DARK } as const;
-
-/** Collapse any app theme id to the syntax theme key it uses. */
-export function resolveSyntaxThemeKey(theme?: string): 'light' | 'dark' {
-  return theme === 'noir' || theme === 'one-dark-pro-soft' ? 'dark' : 'light';
-}

package/src/shared/lib/fs/file-tree.ts

@@ -1,6 +1,9 @@
-export function setChildrenAt(nodes: any[], path: string, children: any[]): any[] {
+import type { FsNode } from '@/shared/types';
+
+/** Replace the children of the node at `path`, rebuilding only that branch. */
+export function setChildrenAt(nodes: FsNode[], path: string, children: FsNode[]): FsNode[] {
   return nodes.map(node => {
-    if (node.path === path) return { ...node, children, is_expanded: 1 };
+    if (node.path === path) return { ...node, children };
     if (Array.isArray(node.children)) {
       const nested = setChildrenAt(node.children, path, children);
       if (nested !== node.children) return { ...node, children: nested };
@@ -9,18 +12,20 @@ export function setChildrenAt(nodes: any[], path: string, children: any[]): any[
   });
 }
 
-export function rehydrateTree(nodes: any[], cache: Record<string, any[]>, expanded: Set<string>): any[] {
+/**
+ * Re-attach the children already loaded for a folder, so a re-listing of the
+ * same tree does not collapse what the user had open.
+ *
+ * Which folders are open is the caller's `expandedPaths` set, keyed by paths
+ * RELATIVE to the listed root — which is why the caller must drop both that set
+ * and the cache when the listed root changes: `src/` under one workspace would
+ * otherwise rehydrate into `src/` under the next.
+ */
+export function rehydrateTree(nodes: FsNode[], cache: Record<string, FsNode[]>): FsNode[] {
   return nodes.map(node => {
     if (node.type !== 'folder') return node;
     const cached = cache[node.path];
-    const wasExpanded = expanded.has(node.path);
-    if (cached) {
-      return {
-        ...node,
-        children: rehydrateTree(cached, cache, expanded),
-        is_expanded: wasExpanded ? 1 : 0,
-      };
-    }
-    return node;
+    if (!cached) return node;
+    return { ...node, children: rehydrateTree(cached, cache) };
   });
 }

package/src/shared/lib/markdown/autolink.test.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { renderMarkdown } from '@/shared/lib/markdown/marked';
+
+describe('autolink vs code span', () => {
+  test('a backticked email stays a code span, not a mailto link', () => {
+    const html = renderMarkdown('addresses (`NNN+login@users.noreply.github.com`) and more');
+    expect(html).toContain('<code class="inline-code">NNN+login@users.noreply.github.com</code>');
+    expect(html).not.toContain('mailto:');
+    expect(html).not.toContain('`');
+  });
+
+  test('a backticked URL stays a code span', () => {
+    const html = renderMarkdown('see `https://bun.sh/docs` for more');
+    expect(html).toContain('<code class="inline-code">https://bun.sh/docs</code>');
+  });
+
+  test('ordinary autolinks are untouched', () => {
+    expect(renderMarkdown('see https://bun.sh/docs for more')).toContain('<a href="https://bun.sh/docs">');
+    expect(renderMarkdown('write to a@b.com now')).toContain('<a href="mailto:a@b.com">');
+  });
+
+  test('a URL next to a code span keeps both', () => {
+    const html = renderMarkdown('https://bun.sh then `npm i`');
+    expect(html).toContain('<a href="https://bun.sh">');
+    expect(html).toContain('<code class="inline-code">npm i</code>');
+  });
+});