ompchamber 1.2.1 → 2.0.1

package/src/client/hooks/chat/timeline/session-pagination.test.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The prepend anchor vs. a bottom jump. The anchor exists to hold a READING
+ * position when older history is paged in above the viewport, and it writes
+ * `scrollTop` directly (which CSS `scroll-behavior: smooth` then animates). A
+ * window that landed after the user asked for the tail therefore wrote
+ * `scrollTop` straight over the jump: reproduced live in the chamber against a
+ * session with older pages — the viewport stopped ~26k px short of the tail
+ * (the anchor's own target), and only the next click reached the bottom, once
+ * no window was left to page in.
+ *
+ * Runs against a real DOM (happy-dom) because the hook is a Preact hook;
+ * geometry and `fetch` are faked (happy-dom does no layout and no network).
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { Window } from 'happy-dom';
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { h as PreactH, render as PreactRender } from 'preact';
+import type { act as PreactAct } from 'preact/test-utils';
+import type { useSessionPagination as UsePagination, SessionPagination } from '@/client/hooks/chat/timeline/session-pagination';
+import type { ChatMessageData } from '@/shared/types';
+
+let useSessionPagination: typeof UsePagination;
+let h: typeof PreactH;
+let render: typeof PreactRender;
+let act: typeof PreactAct;
+
+let win: Window;
+let container: HTMLDivElement;
+let scrollEl: HTMLDivElement;
+/** Prepend this many pixels of older rows when the stubbed window resolves. */
+let prependHeightPx = 1000;
+let fetchCount = 0;
+
+const geometry = { top: 0, height: 5000, viewport: 500 };
+
+function installScroller(el: HTMLDivElement) {
+  Object.defineProperty(el, 'scrollHeight', { get: () => geometry.height, configurable: true });
+  Object.defineProperty(el, 'clientHeight', { get: () => geometry.viewport, configurable: true });
+  Object.defineProperty(el, 'scrollTop', {
+    get: () => geometry.top,
+    set: (value: number) => {
+      geometry.top = Math.max(0, Math.min(value, geometry.height - geometry.viewport));
+    },
+    configurable: true,
+  });
+  Object.defineProperty(el, 'scrollTo', { value: () => {}, configurable: true });
+}
+
+/** The two refs the scroll hook owns and the pagination hook reads. */
+const jumpActiveRef = { current: false };
+const jumpCountRef = { current: 0 };
+const sessionIdRef = { current: 's1' };
+const scrollRef: { current: HTMLDivElement | null } = { current: null };
+/** The hook prepends through this; the commit under test comes from its own
+ *  prepend tick, so recording the update is all this needs to do. */
+const setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>> = () => {};
+
+let pagination: SessionPagination;
+
+function Probe() {
+  pagination = useSessionPagination({
+    sessionId: 's1',
+    sessionIdRef,
+    setLocalMessages,
+    scrollRef,
+    jumpActiveRef,
+    jumpCountRef,
+  });
+  return null;
+}
+
+/** A window that prepends `prependHeightPx` of older rows when it lands. */
+function stubWindowFetch() {
+  (globalThis as Record<string, unknown>).fetch = async () => {
+    fetchCount += 1;
+    // The prepend commit is where the anchor reads the new scrollHeight.
+    geometry.height += prependHeightPx;
+    return {
+      ok: true,
+      json: async () => ({
+        session: { messages: [{ id: 'old-1', role: 'user', content: 'old' }] },
+        hasMore: false,
+        oldestIndex: 0,
+      }),
+    };
+  };
+}
+
+async function settle() {
+  for (let i = 0; i < 10; i++) await Promise.resolve();
+  await act(async () => { for (let i = 0; i < 10; i++) await Promise.resolve(); });
+}
+
+beforeAll(async () => {
+  win = new Window({ url: 'http://localhost' });
+  for (const key of ['window', 'document', 'navigator', 'Node', 'Element', 'HTMLElement', 'Event'] as const) {
+    (globalThis as Record<string, unknown>)[key] = (win as unknown as Record<string, unknown>)[key];
+  }
+  // Static imports cannot work here: Preact binds its environment at module
+  // evaluation time, so the modules below must load after those DOM globals.
+  ({ useSessionPagination } = await import('@/client/hooks/chat/timeline/session-pagination'));
+  ({ h, render } = await import('preact'));
+  ({ act } = await import('preact/test-utils'));
+});
+
+afterAll(() => {
+  delete (globalThis as Record<string, unknown>).fetch;
+  for (const key of ['window', 'document', 'navigator', 'Node', 'Element', 'HTMLElement', 'Event']) {
+    delete (globalThis as Record<string, unknown>)[key];
+  }
+});
+
+beforeEach(async () => {
+  geometry.top = 0;
+  geometry.height = 5000;
+  fetchCount = 0;
+  jumpActiveRef.current = false;
+  jumpCountRef.current = 0;
+  stubWindowFetch();
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  scrollEl = document.createElement('div');
+  installScroller(scrollEl);
+  scrollRef.current = scrollEl;
+  await act(async () => { render(h(Probe, {}), container); });
+  await act(async () => { pagination.applyWindow(true, 100); });
+});
+
+describe('prepend anchor vs bottom jump', () => {
+  test('holds the reading position when the user has not asked for the tail', async () => {
+    await act(async () => { pagination.loadOlder(); });
+    await settle();
+
+    expect(fetchCount).toBe(1);
+    expect(geometry.height).toBe(6000);
+    // prevTop (0) + the prepended height: the rows being read stay put.
+    expect(scrollEl.scrollTop).toBe(1000);
+  });
+
+  test('is dropped when the user asked for the tail after the request went out', async () => {
+    const requested = pagination.loadOlder();
+    // The user clicks scroll-to-bottom while the window is still in flight.
+    jumpCountRef.current += 1;
+    await requested;
+    await settle();
+
+    expect(fetchCount).toBe(1);
+    expect(geometry.height).toBe(6000);
+    // The jump owns the position; the anchor wrote nothing over it.
+    expect(scrollEl.scrollTop).toBe(0);
+  });
+
+  test('a jump in flight blocks the paging trigger', async () => {
+    jumpActiveRef.current = true;
+    await act(async () => { pagination.loadOlder(); });
+    await settle();
+
+    expect(fetchCount).toBe(0);
+    expect(geometry.height).toBe(5000);
+  });
+});

package/src/client/hooks/chat/timeline/session-pagination.ts

@@ -31,6 +31,15 @@ export interface UseSessionPaginationDeps {
   /** Scroll container of the timeline: lets loadOlder preserve the viewport
    *  position when older rows are prepended above it. */
   scrollRef?: RefObject<HTMLDivElement>;
+  /** Scroll hook's bottom-jump guard: history paging stands down while a jump
+   *  to the tail is settling, so the jump does not race a window it never
+   *  asked for (the jump starts at the top, where the trigger lives). */
+  jumpActiveRef?: RefObject<boolean>;
+  /** Scroll hook's bottom-jump counter: a page request stamps its viewport
+   *  anchor with the count it saw and drops the anchor when it has moved on.
+   *  The anchor exists to hold a READING position, and applying it over a jump
+   *  the user asked for parked the viewport back where they used to be. */
+  jumpCountRef?: RefObject<number>;
 }
 
 export interface SessionPagination {
@@ -67,7 +76,7 @@ interface WindowPayload {
 }
 
 export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPagination {
-  const { sessionId, sessionIdRef, setLocalMessages, scrollRef } = deps;
+  const { sessionId, sessionIdRef, setLocalMessages, scrollRef, jumpActiveRef: bottomJumpActiveRef, jumpCountRef } = deps;
 
   const [hasMore, setHasMore] = useState(false);
   const [oldestIndex, setOldestIndex] = useState(0);
@@ -83,14 +92,14 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
   // the scroll handler would read "the user reached the top" and page an extra
   // window nobody asked for — and that window's own scroll anchor would fight
   // the jump's.
-  const jumpActiveRef = useRef(false);
+  const railJumpActiveRef = useRef(false);
   // Live cursor: a jump walks it across several requests, and state does not
   // update between iterations of that loop.
   const oldestIndexRef = useRef(0);
   oldestIndexRef.current = oldestIndex;
   // Set while prepending older rows; the layout effect below re-anchors the
   // viewport to the content the user was reading instead of jumping.
-  const pendingScrollAnchorRef = useRef<{ prevHeight: number; prevTop: number } | null>(null);
+  const pendingScrollAnchorRef = useRef<{ prevHeight: number; prevTop: number; jumpCount: number } | null>(null);
 
   const resetPages = useCallback(() => {
     setHasMore(false);
@@ -101,6 +110,10 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
     loadingOlderRef.current = false;
     setLoadingOlder(false);
     setLoadOlderError(false);
+    // A recorded anchor belongs to the previous session's geometry, and its
+    // request was dropped on the switch — applying it would write THAT window's
+    // offset into this session's scrollTop.
+    pendingScrollAnchorRef.current = null;
   }, []);
 
   const applyWindow = useCallback((hasMoreFromLoad: unknown, oldestIndexFromLoad: unknown) => {
@@ -119,11 +132,15 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
     return { messages: data.session?.messages ?? [], hasMore: data.hasMore, oldestIndex: data.oldestIndex };
   }, [sessionId]);
 
-  /** Record the viewport geometry an older-window prepend is about to shift. */
+  /** Record the viewport geometry an older-window prepend is about to shift,
+   *  stamped with the bottom-jump count so the anchor can be dropped if the
+   *  user asked for the tail after this request went out. */
   const anchorViewport = useCallback(() => {
     const el = scrollRef?.current;
-    if (el) pendingScrollAnchorRef.current = { prevHeight: el.scrollHeight, prevTop: el.scrollTop };
-  }, [scrollRef]);
+    if (el) {
+      pendingScrollAnchorRef.current = { prevHeight: el.scrollHeight, prevTop: el.scrollTop, jumpCount: jumpCountRef?.current ?? 0 };
+    }
+  }, [scrollRef, jumpCountRef]);
 
   /** Drop the jump's scroll-handler guard once its target scroll has settled.
    *  Until then the viewport is still near the top of history (where the paging
@@ -132,7 +149,7 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
   const releaseJumpGuard = useCallback(() => {
     const el = scrollRef?.current;
     if (!el) {
-      jumpActiveRef.current = false;
+      railJumpActiveRef.current = false;
       return;
     }
     let lastTop = el.scrollTop;
@@ -145,7 +162,7 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
       }
       // A few still frames = the smooth scroll is done (or never started).
       if (settledFrames >= 5) {
-        jumpActiveRef.current = false;
+        railJumpActiveRef.current = false;
         return;
       }
       requestAnimationFrame(watch);
@@ -162,7 +179,11 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
    *  placeholder, and blocking it made the button feel dead mid-run. */
   const loadOlder = useCallback(() => {
     if (!sessionId || sessionId.startsWith('new-')) return;
-    if (!hasMore || loadingOlderRef.current || jumpActiveRef.current) return;
+    if (!hasMore || loadingOlderRef.current || railJumpActiveRef.current) return;
+    // A jump to the tail starts at the top, where this trigger lives: paging a
+    // window then is work the jump never asked for, and the window's own
+    // anchor would race the jump's landing.
+    if (bottomJumpActiveRef?.current) return;
     loadingOlderRef.current = true;
     setLoadingOlder(true);
     setLoadOlderError(false);
@@ -204,7 +225,7 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
         loadingOlderRef.current = false;
         setLoadingOlder(false);
       });
-  }, [sessionId, sessionIdRef, hasMore, oldestIndex, fetchWindow, anchorViewport, setLocalMessages, applyWindow]);
+  }, [sessionId, sessionIdRef, hasMore, oldestIndex, fetchWindow, anchorViewport, setLocalMessages, applyWindow, bottomJumpActiveRef]);
 
   /**
    * Walk the cursor down until the row with `id` is mounted, prepending every
@@ -226,7 +247,7 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
     if (loadingOlderRef.current) return false;
     const requestedSessionId = sessionId;
     loadingOlderRef.current = true;
-    jumpActiveRef.current = true;
+    railJumpActiveRef.current = true;
     setLoadingOlder(true);
     setLoadOlderError(false);
     // No viewport anchor here, deliberately: the anchor exists to hold the
@@ -283,6 +304,11 @@ export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPag
     const el = scrollRef?.current;
     if (!el) return;
     pendingScrollAnchorRef.current = null;
+    // The user asked for the tail after this window was requested: holding the
+    // old reading position would write scrollTop straight over that jump (a
+    // window landing mid-jump parked the viewport ~26k px short of the tail).
+    // The jump's own landing, plus the scroll hook's re-pin, owns the position.
+    if (anchor.jumpCount !== (jumpCountRef?.current ?? 0)) return;
     const delta = el.scrollHeight - anchor.prevHeight;
     if (delta > 0) el.scrollTop = anchor.prevTop + delta;
   }, [prependTick, scrollRef]);

package/src/client/hooks/editor/save-file.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The write half of the file-editing contract: POST one buffer to
+ * `/api/fs/action` and report whether the server took it.
+ *
+ * Kept out of `useFileEditor` because the multipart shape, the scope fields and
+ * the failure rule are one self-contained concern, and because the hook carries
+ * the read, cache and history concerns already.
+ */
+
+import type { LineEnding } from '@/shared/lib/code/line-endings';
+
+interface SavableFile {
+  path?: string;
+  root?: string;
+  repo?: string;
+}
+
+/**
+ * Writes `lfText` to `file.path` in the file's own `eol`. Returns false on any
+ * refusal — a non-2xx response, an `error` body, or a dropped connection —
+ * because the caller's only decision is whether to mark the buffer clean.
+ *
+ * The ending travels as its own field and the server rebuilds the bytes: a
+ * multipart body normalizes bare LF to CRLF, so the payload cannot carry the
+ * distinction itself.
+ */
+export async function saveEditorFile(file: SavableFile, lfText: string, eol: LineEnding): Promise<boolean> {
+  if (!file.path) return false;
+  const formData = new FormData();
+  formData.append('actionType', 'save');
+  formData.append('path', file.path);
+  formData.append('content', lfText);
+  formData.append('eol', eol);
+  if (file.root) formData.append('root', file.root);
+  if (file.repo && file.repo !== '.') formData.append('repo', file.repo);
+  try {
+    const res = await fetch('/api/fs/action', { method: 'POST', body: formData });
+    const data = await res.json().catch(() => null);
+    return Boolean(res.ok && data?.success);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Keeps only `keep`'s keys, returning the same object when nothing was
+ * dropped so a render whose tab set is unchanged does not re-key its children.
+ */
+export function retainKeys<T>(record: Record<string, T>, keep: Set<string>): Record<string, T> {
+  const keys = Object.keys(record);
+  if (keys.every((key) => keep.has(key))) return record;
+  const next: Record<string, T> = {};
+  for (const key of keys) {
+    if (keep.has(key)) next[key] = record[key];
+  }
+  return next;
+}

package/src/client/hooks/editor/use-file-editor.test.ts

@@ -19,7 +19,7 @@
  * bind their environment at evaluation time.
  */
 
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { Window } from 'happy-dom';
 import type { h as PreactH, render as PreactRender } from 'preact';
 import type { act as PreactAct } from 'preact/test-utils';
@@ -42,17 +42,21 @@ interface FsState {
   reads: number;
   writes: number;
   body: string;
+  /** The `eol` field of the last write — the ending the server is asked to use. */
+  sentEol: string | null;
 }
 
-/** Serves `state.body` for reads and counts writes, without touching the network. */
+/** Serves `state.body` for reads and records writes, without touching the network. */
 function stubFetch(state: FsState) {
   globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
     if (String(input).startsWith('/api/fs/read')) {
       state.reads += 1;
       return { ok: true, json: async () => ({ content: state.body }) };
     }
+    const form = init?.body as FormData;
     state.writes += 1;
-    state.body = String((init?.body as FormData).get('content'));
+    state.body = String(form.get('content'));
+    state.sentEol = form.get('eol') === null ? null : String(form.get('eol'));
     return { ok: true, json: async () => ({ success: true }) };
   }) as unknown as typeof fetch;
 }
@@ -123,9 +127,18 @@ beforeEach(() => {
   document.body.appendChild(container);
 });
 
+// Unmount while the DOM globals still exist, so the hook's effect cleanups run
+// here. A landed save arms a timer that returns the status to `idle`; an effect
+// timer that outlived this file would fire during the next file's test and, with
+// `window` already removed by `afterAll`, break its render.
+afterEach(() => {
+  render(null, container);
+  container.remove();
+});
+
 describe('useFileEditor revalidation', () => {
   test('reset re-reads from disk without blanking the open file', async () => {
-    const state: FsState = { reads: 0, writes: 0, body: DISK };
+    const state: FsState = { reads: 0, writes: 0, sentEol: null, body: DISK };
     stubFetch(state);
     await mountEditor();
     expect(mounted?.content).toBe(DISK);
@@ -142,7 +155,7 @@ describe('useFileEditor revalidation', () => {
   });
 
   test('a read that lands mid-typing does not replace the buffer', async () => {
-    const state: FsState = { reads: 0, writes: 0, body: DISK };
+    const state: FsState = { reads: 0, writes: 0, sentEol: null, body: DISK };
     stubFetch(state);
     await mountEditor();
 
@@ -155,4 +168,47 @@ describe('useFileEditor revalidation', () => {
     expect(state.reads).toBe(2);
     expect(mounted?.content).toBe('edited by hand');
   });
+
+  // A textarea's API value drops every CR, so a CRLF file reaches the buffer as
+  // LF — and multipart/form-data turns a bare LF back into CRLF, so the payload
+  // cannot carry the ending. The file's own ending therefore travels as its own
+  // field, and losing it rewrote every line of the file on a one-character edit.
+  test('a CRLF file is saved as CRLF after an edit', async () => {
+    const state: FsState = { reads: 0, writes: 0, sentEol: null, body: 'const a = 1;\r\nconst b = 2;\r\n' };
+    stubFetch(state);
+    await mountEditor();
+
+    expect(mounted?.content).toBe('const a = 1;\nconst b = 2;\n');
+
+    await act(async () => {
+      mounted?.onChange('const a = 1;\nconst c = 3;\n');
+    });
+    await settleEditor();
+    await act(async () => {
+      mounted?.saveNow();
+    });
+    await settleEditor();
+
+    expect(state.writes).toBe(1);
+    expect(state.body).toBe('const a = 1;\nconst c = 3;\n');
+    expect(state.sentEol).toBe('crlf');
+  });
+
+  test('an LF file is saved as LF', async () => {
+    const state: FsState = { reads: 0, writes: 0, sentEol: null, body: DISK };
+    stubFetch(state);
+    await mountEditor();
+
+    await act(async () => {
+      mounted?.onChange('const a = 1;\n');
+    });
+    await settleEditor();
+    await act(async () => {
+      mounted?.saveNow();
+    });
+    await settleEditor();
+
+    expect(state.body).toBe('const a = 1;\n');
+    expect(state.sentEol).toBe('lf');
+  });
 });

package/src/client/hooks/editor/use-file-editor.ts

@@ -2,6 +2,8 @@ import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import { getLanguageFromPath } from '@/shared/lib/code/syntax-highlight';
 import { getImageMimeType } from '@/shared/lib/fs/file-kind';
 import { buildFsRawUrl } from '@/shared/lib/fs/paths';
+import { detectLineEnding, toDiskText, toLf, type LineEnding } from '@/shared/lib/code/line-endings';
+import { retainKeys, saveEditorFile } from '@/client/hooks/editor/save-file';
 import { useFileTransfer } from '@/client/hooks/editor/use-file-transfer';
 
 export type FileEditorSaveStatus = 'idle' | 'saving' | 'saved' | 'error';
@@ -82,6 +84,12 @@ export function useFileEditor(
 
   const [contents, setContents] = useState<Record<string, string>>({});
   const [baselines, setBaselines] = useState<Record<string, string>>({});
+  /**
+   * The line ending each cached file arrived with. The buffer itself can only
+   * hold LF (a textarea strips CR), so the style has to live beside it or a
+   * CRLF file would be rewritten as LF by a one-character edit.
+   */
+  const [lineEndings, setLineEndings] = useState<Record<string, LineEnding>>({});
   const [isLoading, setIsLoading] = useState(false);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [saveStatus, setSaveStatus] = useState<FileEditorSaveStatus>('idle');
@@ -89,7 +97,9 @@ export function useFileEditor(
   const [revision, setRevision] = useState(0);
 
   const key = target ? targetKey(target) : '';
-  const content = target ? (contents[key] ?? target.content ?? '') : '';
+  // An inline `content` (attachment chip) can carry CRLF too, and the buffer it
+  // feeds is LF-only — normalizing here keeps `isDirty` comparing like with like.
+  const content = target ? (contents[key] ?? (target.content !== undefined ? toLf(target.content) : '')) : '';
   const isDirty = content !== (baselines[key] ?? content);
 
   // Extension-keyed, matching the server's own classification: an image tab
@@ -113,33 +123,34 @@ export function useFileEditor(
   contentsRef.current = contents;
   const baselinesRef = useRef(baselines);
   baselinesRef.current = baselines;
+  // `persist` is a stable callback, so the ending it writes back is read from a
+  // live mirror rather than captured in its closure.
+  const lineEndingsRef = useRef(lineEndings);
+  lineEndingsRef.current = lineEndings;
 
   const remember = useCallback((fileKey: string, text: string) => {
-    setContents((prev) => ({ ...prev, [fileKey]: text }));
-    setBaselines((prev) => ({ ...prev, [fileKey]: text }));
+    // The buffer holds LF only; the style the bytes arrived with is kept beside
+    // it so the write can put the file back the way it was found.
+    const ending = detectLineEnding(text);
+    const lf = toLf(text);
+    setContents((prev) => ({ ...prev, [fileKey]: lf }));
+    setBaselines((prev) => ({ ...prev, [fileKey]: lf }));
+    setLineEndings((prev) => ({ ...prev, [fileKey]: ending }));
   }, []);
 
   const persist = useCallback(
     async (file: FileEditorTarget, text: string) => {
       if (!file.path) return;
       setSaveStatus('saving');
-      const formData = new FormData();
-      formData.append('actionType', 'save');
-      formData.append('path', file.path);
-      formData.append('content', text);
-      if (file.root) formData.append('root', file.root);
-      if (file.repo && file.repo !== '.') formData.append('repo', file.repo);
-      try {
-        const res = await fetch('/api/fs/action', { method: 'POST', body: formData });
-        const data = await res.json().catch(() => null);
-        if (res.ok && data?.success) {
-          setSaveStatus('saved');
-          setBaselines((prev) => ({ ...prev, [targetKey(file)]: text }));
-          onFileSaved?.();
-        } else {
-          setSaveStatus(reportSaveError ? 'error' : 'idle');
-        }
-      } catch {
+      const fileKey = targetKey(file);
+      // The buffer is LF; the file's own ending is applied by the server, so an
+      // untouched CRLF file stays byte-identical and an LF file stays LF.
+      const written = await saveEditorFile(file, text, lineEndingsRef.current[fileKey] ?? 'lf');
+      if (written) {
+        setSaveStatus('saved');
+        setBaselines((prev) => ({ ...prev, [fileKey]: text }));
+        onFileSaved?.();
+      } else {
         setSaveStatus(reportSaveError ? 'error' : 'idle');
       }
     },
@@ -269,6 +280,11 @@ export function useFileEditor(
   const { copied, copy, download } = useFileTransfer({
     target,
     content,
+    // A download is the file leaving the app, so it carries the file's own line
+    // endings — the LF buffer is an artifact of the textarea, not of the file.
+    // Copy stays the buffer: it is a text selection, and CRLF in a pasted
+    // snippet is noise every destination editor would normalize anyway.
+    downloadContent: target ? toDiskText(content, lineEndings[key] ?? 'lf') : content,
     imageUrl,
     downloadMimeType,
   });
@@ -287,15 +303,8 @@ export function useFileEditor(
     for (const loaded of Array.from(loadedRef.current)) {
       if (!keep.has(loaded)) loadedRef.current.delete(loaded);
     }
-    setContents((prev) => {
-      const keys = Object.keys(prev);
-      if (keys.every((k) => keep.has(k))) return prev;
-      const next: Record<string, string> = {};
-      for (const k of keys) {
-        if (keep.has(k)) next[k] = prev[k];
-      }
-      return next;
-    });
+    setContents((prev) => retainKeys(prev, keep));
+    setLineEndings((prev) => retainKeys(prev, keep));
   }, []);
 
   useEffect(() => {

package/src/client/hooks/editor/use-file-transfer.ts

@@ -25,6 +25,8 @@ interface UseFileTransferOptions {
   target: FileTransferTarget | null;
   /** Current text buffer for `target`; ignored for images. */
   content: string;
+  /** Disk form of `content` (the file's own line endings), used by download. */
+  downloadContent: string;
   /** Raw-byte URL of the active image, else null. */
   imageUrl: string | null;
   /** MIME type used for the text Blob. */
@@ -41,6 +43,7 @@ export interface UseFileTransferResult {
 export function useFileTransfer({
   target,
   content,
+  downloadContent,
   imageUrl,
   downloadMimeType,
 }: UseFileTransferOptions): UseFileTransferResult {
@@ -71,8 +74,8 @@ export function useFileTransfer({
       void downloadUrl(imageUrl, target.name).catch(() => {});
       return;
     }
-    saveBlob(new Blob([content], { type: downloadMimeType }), target.name);
-  }, [target, content, downloadMimeType, imageUrl]);
+    saveBlob(new Blob([downloadContent], { type: downloadMimeType }), target.name);
+  }, [target, downloadContent, downloadMimeType, imageUrl]);
 
   return { copied, copy, download };
 }

package/src/client/hooks/settings/providers.ts

@@ -254,9 +254,40 @@ export function useProviderSettings({
     (models) => models.map((m) => (m.id === modelId ? { ...m, isVisible: !m.isVisible } : m)),
   );
 
-  const handleSaveModelConfig = (modelId: string, updates: Partial<ProviderModel>) => updateSelectedModels(
-    (models) => models.map((m) => (m.id === modelId ? { ...m, ...updates } : m)),
-  );
+  /**
+   * Save the per-model knobs omp honours (`models.yml` modelOverrides). The
+   * overlay still stores the display value so the dialog reopens where the user
+   * left it, but omp only reads the override — writing just the overlay was the
+   * bug that made these controls inert.
+   */
+  const handleSaveModelConfig = async (modelId: string, updates: Partial<ProviderModel>) => {
+    if (!selectedProvider) return;
+    const provider = selectedProvider;
+    updateSelectedModels((models) => models.map((m) => (m.id === modelId ? { ...m, ...updates } : m)));
+
+    const body: Record<string, unknown> = { provider: provider.slug, modelId };
+    if ('maxTokens' in updates) body.maxTokens = updates.maxTokens ?? null;
+    if ('reasoningEffort' in updates) body.reasoningEffort = updates.reasoningEffort ?? null;
+    if (Object.keys(body).length === 2) return;
+
+    try {
+      const response = await fetch('/api/settings/model-override', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const data = await response.json() as { success?: boolean; written?: boolean; reason?: string; error?: string };
+      if (!response.ok) {
+        pushToast(data.error || 'Failed to save the model configuration.', 'error');
+        return;
+      }
+      if (data.written) notifyModelsUpdated();
+      else if (data.reason) pushToast(data.reason, 'error');
+    } catch (error) {
+      console.error('Failed to save model override:', error);
+      pushToast('Failed to save the model configuration.', 'error');
+    }
+  };
 
   return {
     providers,