@cueloop/client 0.1.0-alpha.102 → 0.1.0-alpha.104

package/src/markdown/view-plan.ts

@@ -61,6 +61,7 @@ function singleRangeTextChanges(
   newText: string,
 ): ReturnType<typeof wordLevelChanges> | null {
   if (oldText === newText || oldText.length === newText.length) return null;
+
   let prefixLength = 0;
 
   while (
@@ -77,7 +78,9 @@ function singleRangeTextChanges(
     oldText[oldText.length - 1 - suffixLength] === newText[newText.length - 1 - suffixLength]
   )
     suffixLength++;
+
   if (prefixLength + suffixLength !== shorterLength) return null;
+
   const commonPrefix = oldText.slice(0, prefixLength);
   const commonSuffix = oldText.slice(oldText.length - suffixLength);
   const changed =
@@ -101,8 +104,11 @@ function singleRangeTextChanges(
 /** Word-overlap similarity gate: an unrelated cut + insert must not merge. */
 function similar(baseBlock: Block, workBlock: Block, expectedText?: string): boolean {
   if (baseBlock.kind !== workBlock.kind) return false;
+
   if (expectedText === workBlock.text) return true;
+
   if (singleRangeTextChanges(baseBlock.text, workBlock.text)) return true;
+
   const words = (text: string) => new Set(text.toLowerCase().split(/\s+/).filter(Boolean));
   const baseWords = words(baseBlock.text);
   const workWords = words(workBlock.text);
@@ -132,6 +138,7 @@ export function buildDisplay(
     const segments = sourceSegments[blockIndex];
 
     if (!segments?.length) return;
+
     const sourceStart = segments[0]!.sourceStart;
     const last = segments.at(-1)!;
     const sourceEnd = last.sourceStart + last.textEnd - last.textStart;
@@ -143,6 +150,7 @@ export function buildDisplay(
       const cut = exactCuts[index]!;
 
       if (cut.start >= sourceEnd) break;
+
       const start = blockTextBoundary(segments, block.text.length, cut.start);
       const end = blockTextBoundary(segments, block.text.length, cut.end);
 
@@ -153,6 +161,7 @@ export function buildDisplay(
     };
 
     if (ranges.length > 0) data.textCutRanges = ranges;
+
     cutData.set(block, data);
   });
   const blockCutData = (block: Block) => cutData.get(block) ?? {};
@@ -160,6 +169,7 @@ export function buildDisplay(
     const data = blockCutData(block);
 
     if (!data.textCutRanges) return undefined;
+
     let text = block.text;
 
     for (let index = data.textCutRanges.length - 1; index >= 0; index--) {
@@ -178,6 +188,7 @@ export function buildDisplay(
       if (!data.textCutRanges) {
         return { type: "same", kind: base.kind, base, work: base, ...data };
       }
+
       const text = expectedBlockText(base)!;
 
       return {
@@ -207,6 +218,7 @@ export function buildDisplay(
 
     return display;
   }
+
   const workBlocks = parseBlocks(workingContent);
   const signature = (block: Block) => block.kind + "\0" + block.text;
   const ops = lcsDiff(
@@ -225,6 +237,7 @@ export function buildDisplay(
       opIndex++;
       continue;
     }
+
     const deletedBlocks: Block[] = [];
     const addedBlocks: Block[] = [];
 
@@ -233,6 +246,7 @@ export function buildDisplay(
 
       if (changeOp.kind === "del") deletedBlocks.push(changeOp.oldValue!);
       else addedBlocks.push(changeOp.newValue!);
+
       opIndex++;
     }
     let deletedIndex = 0;
@@ -309,6 +323,7 @@ function blockTextBoundary(
     const sourceEnd = segment.sourceStart + segment.textEnd - segment.textStart;
 
     if (sourceOffset < segment.sourceStart) return segment.textStart;
+
     if (sourceOffset <= sourceEnd) return segment.textStart + sourceOffset - segment.sourceStart;
   }
 
@@ -377,13 +392,16 @@ export function marksByDisplay(
   for (const annotation of annotations) {
     // an addressed annotation keeps its record but paints no highlight
     if (isAddressed(annotation)) continue;
+
     const resolved = resolveAnchor(annotation.anchor, workBlocks);
 
     if (!resolved) continue;
+
     const startEntry = workEntries[resolved.blockIndex];
     const endEntry = workEntries[resolved.endBlockIndex];
 
     if (!startEntry || !endEntry) continue;
+
     // resolveAnchor works in the block's work text; the surface paints and hit-tests in rendered
     // text (markers concealed), so map the span onto the visible characters it covers
     const renderedStart = renderedOffsetAtOrAfter(
@@ -396,6 +414,7 @@ export function marksByDisplay(
     );
 
     if (renderedStart === null || renderedEndInclusive === null) continue;
+
     const span: TextSpan = {
       start: { blockIndex: startEntry.displayIndex, char: renderedStart },
       end: { blockIndex: endEntry.displayIndex, char: renderedEndInclusive + 1 },
@@ -407,6 +426,7 @@ export function marksByDisplay(
       const range = spanRangeInBlock(span, entry.displayIndex, renderedText(entry.block).length);
 
       if (!range) continue;
+
       const marks = marksByIndex.get(entry.displayIndex) ?? [];
 
       marks.push({
@@ -425,6 +445,7 @@ export function marksByDisplay(
 
 function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null {
   if (!block.base || !block.work || !block.textCutRanges) return null;
+
   const localCuts = block.textCutRanges;
   const expected = localCuts.reduceRight(
     (text, cut) => text.slice(0, cut.start) + text.slice(cut.end),
@@ -432,6 +453,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
   );
 
   if (expected !== block.work.text) return null;
+
   const sourceRuns = literal
     ? [{ text: block.base.text, role: "plain" as const, start: 0 }]
     : inlineStyleRuns(block.base.text, 0);
@@ -441,6 +463,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
 
   for (const sourceRun of sourceRuns) {
     if (sourceRun.start === null) continue;
+
     const runStart = sourceRun.start;
     const runEnd = runStart + sourceRun.text.length;
     let position = runStart;
@@ -461,6 +484,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         });
         break;
       }
+
       if (position < cut.start) {
         const commonEnd = Math.min(runEnd, cut.start);
 
@@ -473,6 +497,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         position = commonEnd;
         continue;
       }
+
       const removedEnd = Math.min(runEnd, cut.end);
 
       runs.push({
@@ -482,6 +507,7 @@ function exactCutRuns(block: DisplayBlock, literal: boolean): StyleRun[] | null
         baseStart: position,
       });
       position = removedEnd;
+
       if (position === cut.end) {
         deletedBefore += cut.end - cut.start;
         cutIndex++;
@@ -518,6 +544,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
         runs.push({ text: change.text, role: "del", start: null });
         continue;
       }
+
       // A code/rule block stays literal; prose segments inline-tokenize so their
       // markers conceal while their work offsets stay intact. Added text keeps
       // the green diff role (it wins over emphasis); context text shows emphasis.
@@ -533,6 +560,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
 
     return runs;
   }
+
   const text = displayText(block);
 
   // Prose carries inline markup; code fences and rules are literal. Concealed
@@ -550,6 +578,7 @@ export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
  *  document could otherwise splice into the terminal escape stream. */
 export function safeLinkHref(href: string | undefined): string | undefined {
   if (href === undefined) return undefined;
+
   if (!/^(https?:|mailto:)/i.test(href)) return undefined;
 
   return /^[\x21-\x7e]+$/.test(href) ? href : undefined;
@@ -565,6 +594,7 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
 
   for (const run of inlineRuns(text)) {
     if (run.role === "marker" || run.start === null) continue;
+
     const styleRun: StyleRun = {
       text: run.text,
       role: run.role === "text" ? "plain" : run.role,
@@ -572,6 +602,7 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
     };
 
     if (run.href !== undefined) styleRun.href = run.href;
+
     runs.push(styleRun);
   }
 
@@ -595,6 +626,7 @@ export function renderedStyleRuns(block: DisplayBlock): RenderedRun[] {
     const positioned: RenderedRun = { text: run.text, role: run.role, start: rendered };
 
     if (run.href !== undefined) positioned.href = run.href;
+
     runs.push(positioned);
     rendered += run.text.length;
   }
@@ -619,6 +651,7 @@ function addSyntaxBoundaries(
 ): void {
   for (const span of syntaxSpans) {
     if (span.start > line.start && span.start < line.end) cuts.add(span.start);
+
     if (span.end > line.start && span.end < line.end) cuts.add(span.end);
   }
 }
@@ -647,6 +680,7 @@ export function styledRunsFor(
 
   for (const run of roleRuns) {
     if (run.start > line.start && run.start < line.end) cuts.add(run.start);
+
     const runEnd = run.start + run.text.length;
 
     if (runEnd > line.start && runEnd < line.end) cuts.add(runEnd);
@@ -669,6 +703,7 @@ export function styledRunsFor(
     const end = edges[index + 1]!;
 
     if (end <= start) continue;
+
     const roleRun = roleRuns.find(
       (candidate) => candidate.start <= start && start < candidate.start + candidate.text.length,
     );
@@ -681,9 +716,11 @@ export function styledRunsFor(
     };
 
     if (roleRun?.href !== undefined) styled.href = roleRun.href;
+
     const syntaxGroup = syntaxGroupForRun(syntaxSpans, start, end);
 
     if (syntaxGroup) styled.syntaxGroup = syntaxGroup;
+
     runs.push(styled);
   }
 
@@ -693,6 +730,7 @@ export function styledRunsFor(
 /** Split runs at mark boundaries; marks only bind to runs with offsets. */
 export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
   if (!marks.length) return runs;
+
   const splitRuns: StyleRun[] = [];
 
   for (const run of runs) {
@@ -700,6 +738,7 @@ export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
       splitRuns.push(run);
       continue;
     }
+
     const bounds = new Set<number>([0, run.text.length]);
 
     for (const mark of marks) {
@@ -719,6 +758,7 @@ export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
       const sliceEnd = boundaries[boundaryIndex + 1]!;
 
       if (sliceStart >= sliceEnd) continue;
+
       const absoluteStart = runStart + sliceStart;
       const mark = marks.find(
         (candidate) => candidate.start <= absoluteStart && runStart + sliceEnd <= candidate.end,
@@ -751,6 +791,7 @@ export function renderedOffsetFor(runs: StyleRun[], workOffset: number): number
     if (run.start !== null && workOffset >= run.start && workOffset < run.start + run.text.length) {
       return rendered + (workOffset - run.start);
     }
+
     rendered += run.text.length;
   }
 
@@ -770,6 +811,7 @@ export function renderedOffsetAtOrAfter(runs: StyleRun[], workOffset: number): n
     if (run.start !== null && run.start + run.text.length > workOffset) {
       return rendered + Math.max(0, workOffset - run.start);
     }
+
     rendered += run.text.length;
   }
 
@@ -788,6 +830,7 @@ export function renderedOffsetAtOrBefore(runs: StyleRun[], workOffset: number):
     if (run.start !== null && run.start <= workOffset) {
       best = rendered + Math.min(workOffset - run.start, run.text.length - 1);
     }
+
     rendered += run.text.length;
   }
 
@@ -812,11 +855,14 @@ export function workRangeForRendered(
     const runRenderedEnd = rendered + run.text.length;
 
     rendered = runRenderedEnd;
+
     if (run.start === null) continue;
+
     const overlapStart = Math.max(renderedStart, runRenderedStart);
     const overlapEnd = Math.min(renderedEnd, runRenderedEnd);
 
     if (overlapEnd <= overlapStart) continue;
+
     const workStart = run.start + (overlapStart - runRenderedStart);
     const workEnd = run.start + (overlapEnd - runRenderedStart);
 
@@ -844,11 +890,14 @@ export function baseRangeForRendered(
     const runRenderedEnd = rendered + run.text.length;
 
     rendered = runRenderedEnd;
+
     if (run.baseStart === undefined) continue;
+
     const overlapStart = Math.max(renderedStart, runRenderedStart);
     const overlapEnd = Math.min(renderedEnd, runRenderedEnd);
 
     if (overlapEnd <= overlapStart) continue;
+
     const baseStart = run.baseStart + overlapStart - runRenderedStart;
     const baseEnd = run.baseStart + overlapEnd - runRenderedStart;
 
@@ -883,6 +932,7 @@ export function renderedSpanToWork(
 
     return range ?? { start: renderedStart, end: renderedEnd };
   }
+
   const startRuns = blockRuns(startBlock, true);
   const startRange = workRangeForRendered(
     startRuns,
@@ -952,6 +1002,7 @@ export function spanFromRange(
   const wordIndex = words.findIndex((word) => word[1] > start);
 
   if (wordIndex === -1) return null;
+
   let wordEnd = wordIndex;
 
   for (let index = wordIndex; index < words.length && words[index]![0] < end; index++) {
@@ -989,6 +1040,7 @@ export function spanKey(span: SpanState, key: string, text: string): SpanState {
     nextSpan.wordEnd = width;
     nextSpan.wordIndex = 0;
   } else return span;
+
   nextSpan.start = words[nextSpan.wordIndex]![0];
   nextSpan.end = words[nextSpan.wordEnd]![1];
 

package/src/performance/perf-report.ts

@@ -14,5 +14,6 @@ export function reportPerfMarks(scope: string): void {
   if (marks.length === 0) return;
 
   if (process.env.CUELOOP_PERF === "1") process.stderr.write(formatPerfBlock(scope, marks));
+
   void postOtlpTrace(PERF_SERVICE_NAME, phaseMarksToSpans(scope, marks));
 }

package/src/performance/perf-timings.ts

@@ -17,6 +17,7 @@ function perfInstrumentationEnabled(): boolean {
 /** Record the elapsed ms since the previous mark (or process start) under `label`. */
 export function perfMark(label: string): void {
   if (!perfInstrumentationEnabled()) return;
+
   const now = performance.now();
 
   phaseMarks.push({ label, elapsedMs: now - (lastMarkAt ?? 0) });

package/src/prototype/components/PrototypeContentView.tsx

@@ -126,6 +126,7 @@ function terminalColorScheme(textColor: string): "dark" | "light" {
   const hex = textColor.replace("#", "");
 
   if (hex.length < 6) return "dark";
+
   const r = parseInt(hex.slice(0, 2), 16);
   const g = parseInt(hex.slice(2, 4), 16);
   const b = parseInt(hex.slice(4, 6), 16);
@@ -181,12 +182,14 @@ function PrototypeContentViewImpl({
   // harness), but the launch trigger still runs.
   useEffect(() => {
     if (!renderer) return;
+
     const rendererOutput = v.safeParse(v.object({ writeOut: v.function() }), renderer);
     const rawWrite = rendererOutput.success ? rendererOutput.output.writeOut : null;
     const write = rawWrite ? (chunk: string) => rawWrite.call(renderer, chunk) : null;
     const medium = resolveTransmitMedium();
     const paint = (): void => {
       if (!write) return;
+
       // an app overlay is covering the sheet: pull the image so it does not show
       // through the overlay's cells, and re-transmit once the overlay closes
       if (hiddenRef.current) {
@@ -197,10 +200,12 @@ function PrototypeContentViewImpl({
 
         return;
       }
+
       const region = regionOf(regionRef.current);
       const png = pngRef.current;
 
       if (!region || !png) return;
+
       if (transmittedRef.current !== png) {
         transmitKittyImage(write, png, region, PROTOTYPE_IMAGE_ID, medium);
         transmittedRef.current = png;
@@ -219,6 +224,7 @@ function PrototypeContentViewImpl({
 
     return () => {
       renderer.off("frame", onFrame);
+
       if (write) deleteKittyImage(write, PROTOTYPE_IMAGE_ID);
     };
   }, [renderer]);
@@ -241,11 +247,13 @@ function PrototypeContentViewImpl({
     const caps = renderer?.capabilities;
 
     if (launchedRef.current || !region) return;
+
     if (caps && caps.kitty_graphics === false) {
       setStatus("unsupported");
 
       return;
     }
+
     launchedRef.current = true;
     const capture = captureConfig(region, renderer!);
 
@@ -266,6 +274,7 @@ function PrototypeContentViewImpl({
 
           return;
         }
+
         browserRef.current = browser;
         setPng(await browser.screenshot());
         setStatus("ready");
@@ -304,6 +313,7 @@ function PrototypeContentViewImpl({
     const region = regionOf(regionRef.current);
 
     if (status !== "ready" || !browser || !region) return;
+
     const geometry = {
       x: region.column,
       y: region.row,
@@ -313,10 +323,12 @@ function PrototypeContentViewImpl({
     const cssPoint = imageCellToCss(event, geometry, viewportRef.current);
 
     if (!cssPoint) return;
+
     void (async () => {
       const element = await browser.elementAt(cssPoint.x, cssPoint.y);
 
       if (!element) return;
+
       const cell = cssBoxToCell(element.box, geometry, viewportRef.current);
       const topRaw = cell.row - geometry.y;
 
@@ -326,6 +338,7 @@ function PrototypeContentViewImpl({
         top: Math.max(0, topRaw < OVERLAY_ROWS ? topRaw + 1 : topRaw - OVERLAY_ROWS),
         regionColumns: geometry.width,
       });
+
       // selecting an element opens the compose card directly, the same edit
       // primitive plan and diff use - there is no intermediate marker toolbar
       if (canComment) {
@@ -344,6 +357,7 @@ function PrototypeContentViewImpl({
     const browser = browserRef.current;
 
     if (status !== "ready" || !browser) return;
+
     const delta = event.scroll?.direction === "up" ? -SCROLL_STEP : SCROLL_STEP;
 
     // a selection would drift once the page scrolls under it, so drop it
@@ -356,7 +370,9 @@ function PrototypeContentViewImpl({
 
   const commit = (body: string): void => {
     if (!canComment) return;
+
     if (selected && body.trim()) onCommentElement(selected, body.trim());
+
     clearSelection();
   };
 
@@ -435,6 +451,7 @@ export const PrototypeContentView = React.memo(PrototypeContentViewImpl);
 
 function statusLine(status: SheetStatus, errorMessage: string): string {
   if (status === "loading") return "rendering prototype…";
+
   if (status === "unsupported")
     return "prototype preview needs a graphics terminal (kitty or ghostty)";
 

package/src/prototype/prototype-browser.ts

@@ -114,6 +114,7 @@ async function warmBrowser(executablePath: string | undefined): Promise<Puppetee
   const cached = sharedBrowser ? await sharedBrowser.catch(() => null) : null;
 
   if (cached && cached.connected) return cached;
+
   const puppeteer = (await import("puppeteer-core")).default;
   const launched = puppeteer.launch({
     executablePath: executablePath ?? chromeExecutable(),
@@ -124,6 +125,7 @@ async function warmBrowser(executablePath: string | undefined): Promise<Puppetee
   sharedBrowser = launched;
   const browser = await launched.catch((error) => {
     if (sharedBrowser === launched) sharedBrowser = null;
+
     throw error;
   });
 
@@ -143,7 +145,9 @@ export async function closePrototypeBrowser(): Promise<void> {
   const pending = sharedBrowser;
 
   sharedBrowser = null;
+
   if (!pending) return;
+
   const browser = await pending.catch(() => null);
 
   await browser?.close().catch(() => undefined);
@@ -233,8 +237,10 @@ function elementAtScript(x: number, y: number) {
     while (current && current !== document.body) {
       if (isNamed(current)) {
         if (current.childElementCount > 1) return current;
+
         namedFallback = namedFallback ?? current;
       }
+
       current = current.parentElement;
     }
 
@@ -251,6 +257,7 @@ function elementAtScript(x: number, y: number) {
         parts.unshift(part + "#" + CSS.escape(current.id));
         break;
       }
+
       const parent: Element | null = current.parentElement;
 
       if (parent) {
@@ -259,6 +266,7 @@ function elementAtScript(x: number, y: number) {
 
         if (twins.length > 1) part += ":nth-of-type(" + (twins.indexOf(current) + 1) + ")";
       }
+
       parts.unshift(part);
       current = current.parentElement;
     }
@@ -282,10 +290,12 @@ function elementAtScript(x: number, y: number) {
   const hit = document.elementFromPoint(x, y);
 
   if (!(hit instanceof Element)) return null;
+
   const node = focusableTarget(hit) ?? componentRoot(hit);
   const selector = selectorFor(node);
 
   if (!selector) return null;
+
   const text = (node.textContent || "").replace(/\s+/g, " ").trim();
   const tag = node.tagName.toLowerCase();
   const quote = text
@@ -313,6 +323,7 @@ function chromeExecutable(): string {
   if (process.platform === "darwin") {
     return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
   }
+
   if (process.platform === "win32") {
     return "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe";
   }

package/src/settings/components/SettingsDialog.tsx

@@ -92,10 +92,12 @@ export function SettingsDialog({
   const { width: terminalWidth, height: terminalHeight } = useTerminalDimensions();
 
   if (!isOpen) return null;
+
   const category =
     categories.find((candidate) => candidate.id === activeCategoryId) ?? categories[0];
 
   if (!category) return null;
+
   const onKeybinds = category.id === KEYBINDS_CATEGORY_ID;
 
   return (
@@ -143,6 +145,7 @@ export function SettingsDialog({
                     />
                   );
                 }
+
                 if (row.kind === "cycle") {
                   return (
                     <CycleRow

package/src/settings/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -12,6 +12,7 @@ import {
   persistLayout,
   persistPins,
   persistReviewSkill,
+  persistThreadModelDefault,
   persistReviewWorkspace,
   persistTheme,
   quickActionBody,
@@ -674,3 +675,80 @@ test("Thread agents default off and require a boolean experimental TOML flag", (
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("Thread harness preference persists without changing experimental or other settings", async () => {
+  const { persistThreadHarness } = await import("./config");
+  const dir = mkdtempSync(join(tmpdir(), "cueloop-thread-config-"));
+  const path = join(dir, "config.toml");
+
+  try {
+    writeFileSync(path, '[experimental]\nthread_agent = true\n[ui]\ntheme = "cueloop"\n');
+    persistThreadHarness("fx", path);
+    const config = loadConfig({ userConfigPath: path });
+
+    expect(config.thread.harness).toBe("fx");
+    expect(config.experimental.threadAgent).toBe(true);
+    expect(config.ui.theme).toBe("cueloop");
+    persistThreadHarness("pi", path);
+    expect(loadConfig({ userConfigPath: path }).thread.harness).toBe("pi");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("a malformed Thread section does not discard other preferences", () => {
+  const dir = mkdtempSync(join(tmpdir(), "cueloop-invalid-thread-config-"));
+  const path = join(dir, "config.toml");
+
+  try {
+    for (const section of ['thread = "fx"\n', '[thread]\nharness = "typo"\n']) {
+      writeFileSync(
+        path,
+        `${section}[experimental]\nthread_agent = true\n[ui]\ntheme = "cueloop"\n`,
+      );
+      const config = loadConfig({ userConfigPath: path });
+
+      expect(config.thread.harness).toBe("pi");
+      expect(config.experimental.threadAgent).toBe(true);
+      expect(config.ui.theme).toBe("cueloop");
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("Thread model defaults layer independently and persistence stays in the selected table", () => {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-model-defaults-"));
+  const user = join(directory, "user.toml");
+  const repository = join(directory, "repo");
+
+  try {
+    const defaults = loadConfig({ userConfigPath: user }).thread;
+
+    expect(defaults.pi).toEqual({ model: "openai-codex/gpt-6.1-sol", effort: "medium" });
+    expect(defaults.fx).toEqual({ model: "grok/grok-4.7", effort: "medium" });
+    writeFileSync(
+      user,
+      '[thread.pi]\nmodel = "openai-codex/custom"\neffort = "high"\n\n[thread.fx]\nmodel = "grok/custom"\neffort = "low"\n',
+    );
+    persistThreadModelDefault("pi", "effort", "medium", user);
+    persistThreadModelDefault("fx", "model", "grok/grok-4.7", user);
+
+    const config = loadConfig({ userConfigPath: user });
+
+    expect(config.thread.pi).toEqual({ model: "openai-codex/custom", effort: "medium" });
+    expect(config.thread.fx).toEqual({ model: "grok/grok-4.7", effort: "low" });
+    mkdirSync(join(repository, ".cueloop"), { recursive: true });
+    writeFileSync(
+      join(repository, ".cueloop/config.toml"),
+      '[thread.pi]\neffort = "high"\n[thread.fx]\nmodel = " "\neffort = "invalid"\n',
+    );
+
+    const layered = loadConfig({ userConfigPath: user, repoRoot: repository });
+
+    expect(layered.thread.pi).toEqual({ model: "openai-codex/custom", effort: "high" });
+    expect(layered.thread.fx).toEqual(config.thread.fx);
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});