ompchamber 3.1.1 → 3.2.0

package/src/shared/lib/fs/diff-parser.test.ts

@@ -61,7 +61,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds a whitespace-only rewrite into context when ignoring whitespace', () => {
-    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, true);
+    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, { ignoreWhitespace: true });
 
     // The counts the toolbar renders must match what is on screen.
     expect(additions).toBe(0);
@@ -81,7 +81,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('keeps a real change when ignoring whitespace', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, { ignoreWhitespace: true });
 
     expect(additions).toBe(1);
     expect(deletions).toBe(1);
@@ -90,7 +90,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds only the whitespace pair of a mixed hunk', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, { ignoreWhitespace: true });
 
     // Line 1 differs by indentation only; line 2 is a genuine edit.
     expect(additions).toBe(1);
@@ -110,7 +110,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('returns empty results for an empty diff', () => {
-    expect(parseUnifiedDiff('', true)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
-    expect(parseUnifiedDiff('   \n', false)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('', { ignoreWhitespace: true })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('   \n', { ignoreWhitespace: false })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
   });
 });

package/src/shared/lib/fs/diff-parser.ts

@@ -31,12 +31,29 @@ interface PendingChange {
  * which is what this used to do — left the row painted red/green and counted in
  * `+n/-n`, so the toggle changed the glyphs and nothing else.
  */
-export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = false): {
+export interface ParseDiffOptions {
+  /** Fold `-`/`+` pairs that differ only in whitespace back into context. */
+  ignoreWhitespace?: boolean;
+  /**
+   * Which view the caller renders. Both views are built from one flush so a
+   * decision cannot land in one and not the other, but building the one nobody
+   * shows doubled the allocations on a full-context diff — an 80k-line file
+   * produced ~60k discarded `SplitDiffRow` objects. `'both'` is the default so
+   * the counts and the shared flush stay exactly as they were.
+   */
+  views?: 'unified' | 'split' | 'both';
+}
+
+export function parseUnifiedDiff(rawDiff: string, options: ParseDiffOptions = {}): {
   lines: DiffLine[];
   splitRows: SplitDiffRow[];
   additions: number;
   deletions: number;
 } {
+  const ignoreWhitespace = options.ignoreWhitespace ?? false;
+  const views = options.views ?? 'both';
+  const wantUnified = views !== 'split';
+  const wantSplit = views !== 'unified';
   const lines: DiffLine[] = [];
   const splitRows: SplitDiffRow[] = [];
   let additions = 0;
@@ -73,43 +90,47 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
       }
     }
 
-    for (let i = 0; i < delBuffer.length; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && add) {
-        // Show it as unchanged on both sides: the change is still in the file,
-        // the reader asked not to be shown formatting noise.
-        lines.push({
-          type: 'context',
-          // The new form, so the row reads as the file's current state.
-          text: add.text,
-          oldLineNumber: del.lineNumber,
-          newLineNumber: add.lineNumber,
-        });
-        continue;
+    if (wantUnified) {
+      for (let i = 0; i < delBuffer.length; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && add) {
+          // Show it as unchanged on both sides: the change is still in the file,
+          // the reader asked not to be shown formatting noise.
+          lines.push({
+            type: 'context',
+            // The new form, so the row reads as the file's current state.
+            text: add.text,
+            oldLineNumber: del.lineNumber,
+            newLineNumber: add.lineNumber,
+          });
+          continue;
+        }
+        lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
+      }
+      for (let i = 0; i < addBuffer.length; i++) {
+        const add = addBuffer[i];
+        if (folded[i]) continue;
+        lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
       }
-      lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
-    }
-    for (let i = 0; i < addBuffer.length; i++) {
-      const add = addBuffer[i];
-      if (folded[i]) continue;
-      lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
     }
 
-    for (let i = 0; i < maxLen; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && del && add) {
+    if (wantSplit) {
+      for (let i = 0; i < maxLen; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && del && add) {
+          splitRows.push({
+            left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
+            right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          });
+          continue;
+        }
         splitRows.push({
-          left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
-          right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
+          right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
         });
-        continue;
       }
-      splitRows.push({
-        left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
-        right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
-      });
     }
     delBuffer = [];
     addBuffer = [];
@@ -156,16 +177,20 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
     } else {
       flushBuffers();
       const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
-      lines.push({
-        type: 'context',
-        text,
-        oldLineNumber: oldCounter,
-        newLineNumber: newCounter,
-      });
-      splitRows.push({
-        left: { type: 'context', text, lineNumber: oldCounter },
-        right: { type: 'context', text, lineNumber: newCounter },
-      });
+      if (wantUnified) {
+        lines.push({
+          type: 'context',
+          text,
+          oldLineNumber: oldCounter,
+          newLineNumber: newCounter,
+        });
+      }
+      if (wantSplit) {
+        splitRows.push({
+          left: { type: 'context', text, lineNumber: oldCounter },
+          right: { type: 'context', text, lineNumber: newCounter },
+        });
+      }
       oldCounter++;
       newCounter++;
     }

package/src/shared/lib/omp/subagent/parse.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers `readSubagentProgressFrame`, the one reader every subagent-progress
+ * consumer goes through (sidebar roster, transcript hook, server liveness).
+ *
+ * The wrapper shape is the whole point: omp's `subagent_progress` frame nests
+ * the child's `AgentProgress` under `payload.progress` and puts NO `id` on the
+ * wrapper, so a reader that parses the wrapper alone yields an id-less object
+ * with none of the reported fields — silently, because every field is
+ * optional. The payload below is a verbatim frame captured from omp 18.3.2.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseSubagentProgress, readSubagentProgressFrame } from '@/shared/lib/omp/subagent/parse';
+
+/** One `subagent_progress` frame as omp emits it (trimmed to the read fields). */
+const REAL_FRAME = {
+  index: 0,
+  agent: 'scout',
+  agentSource: 'user',
+  task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+  parentToolCallId: 'call_00_LsrwnITatwhVYX5NElPf2544',
+  detached: true,
+  assignment: '# Target\nCount files.',
+  sessionFile: '/tmp/sessions/parent/CountTsx.jsonl',
+  progress: {
+    index: 0,
+    id: 'CountTsx',
+    agent: 'scout',
+    agentSource: 'user',
+    status: 'running',
+    task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+    recentTools: [],
+    recentOutput: [],
+    toolCount: 3,
+    requests: 2,
+    tokens: 10400,
+    cost: 0.003,
+    durationMs: 8700,
+    modelRole: 'smol',
+    resolvedModelIdentity: 'kenari/deepseek-v4-flash',
+    resolvedThinkingLevel: 'low',
+    resolvedModel: 'kenari/deepseek-v4-flash:low',
+    resolvedModelIsFallback: false,
+  },
+};
+
+describe('readSubagentProgressFrame', () => {
+  test('unwraps the nested AgentProgress and keeps the fields it reports', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedModel).toBe('kenari/deepseek-v4-flash:low');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+    expect(progress?.status).toBe('running');
+    expect(progress?.tokens).toBe(10400);
+  });
+
+  test('reads a bare AgentProgress payload (snapshot field, not a frame)', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME.progress);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+  });
+
+  test('keeps the wrapper id when the nested snapshot omits it', () => {
+    const progress = readSubagentProgressFrame({ id: 'Wrapped', progress: { status: 'running' } });
+    expect(progress?.id).toBe('Wrapped');
+    expect(progress?.status).toBe('running');
+  });
+
+  test('returns undefined for a payload carrying no progress fields at all', () => {
+    expect(readSubagentProgressFrame({ event: { type: 'message_end' } })).toBeUndefined();
+    expect(readSubagentProgressFrame(null)).toBeUndefined();
+    expect(readSubagentProgressFrame('nonsense')).toBeUndefined();
+  });
+});
+
+describe('parseSubagentProgress', () => {
+  test('carries the resolved thinking level and drops a non-string one', () => {
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 'max' })?.resolvedThinkingLevel).toBe('max');
+    expect(parseSubagentProgress({ resolvedThinkingLevel: null })?.resolvedThinkingLevel).toBeUndefined();
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 3 })?.resolvedThinkingLevel).toBeUndefined();
+  });
+});

package/src/shared/lib/omp/subagent/parse.ts

@@ -81,6 +81,8 @@ export function parseSubagentProgress(value: unknown): SubagentProgress | undefi
   if (modelRole !== undefined) out.modelRole = modelRole;
   const resolvedModel = asString(value.resolvedModel);
   if (resolvedModel !== undefined) out.resolvedModel = resolvedModel;
+  const resolvedThinkingLevel = asString(value.resolvedThinkingLevel);
+  if (resolvedThinkingLevel !== undefined) out.resolvedThinkingLevel = resolvedThinkingLevel;
   if (typeof value.resolvedModelIsFallback === 'boolean') out.resolvedModelIsFallback = value.resolvedModelIsFallback;
   if (isRecord(value.retryState)) {
     const attempt = asNumber(value.retryState.attempt);
@@ -180,6 +182,21 @@ export function parseSubagentLifecycle(value: unknown): SubagentInfo | undefined
   return info;
 }
 
+/**
+ * Read a progress frame's payload: `SubagentProgressPayload` nests the
+ * AgentProgress it reports under `progress`, while a bare AgentProgress (and a
+ * `get_subagents` snapshot's own field) is the object itself. Both shapes reach
+ * the same listeners, so unwrap here rather than at each call site — the outer
+ * wrapper's `id`/`index` fill in what the nested snapshot omits.
+ */
+export function readSubagentProgressFrame(payload: unknown): SubagentProgress | undefined {
+  const direct = parseSubagentProgress(payload);
+  if (!isRecord(payload) || !isRecord(payload.progress)) return direct;
+  const nested = parseSubagentProgress(payload.progress);
+  if (!nested) return direct;
+  return { ...nested, id: nested.id ?? direct?.id, index: nested.index ?? direct?.index };
+}
+
 /** Extract a compact live-activity entry from a subagent_event payload. */
 export function parseSubagentActivityEvent(value: unknown): SubagentActivityEvent | null {
   if (!isRecord(value)) return null;

package/src/shared/lib/omp/subagent/transcript-client.test.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers the subagent transcript conversion's thinking-level stamping.
+ *
+ * A subagent transcript records its level as a separate `thinking_level_change`
+ * entry, never as a per-message field, so `convertMessages` has to walk the
+ * records and stamp the level in effect — otherwise the footer has no level to
+ * show and drops the segment entirely. The child's own level is the only
+ * correct one: a subagent routinely runs at a different level than the chat
+ * that spawned it, so borrowing the parent's would mislabel every row.
+ *
+ * Also pins the non-message entry handling the walk sits beside: a change
+ * record must be consumed, not converted into a row.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { convertMessages, mergeMessages } from '@/shared/lib/omp/subagent/transcript-client';
+import type { ChatMessageData } from '@/shared/types';
+
+/** An assistant message entry carrying text, as omp writes it to the JSONL. */
+function assistantEntry(id: string, text: string): Record<string, unknown> {
+  return {
+    type: 'message',
+    id,
+    timestamp: 1790403839189,
+    message: {
+      role: 'assistant',
+      model: 'deepseek-v4-flash',
+      provider: 'kenari',
+      content: [{ type: 'text', text }],
+    },
+  };
+}
+
+function changeEntry(level: unknown): Record<string, unknown> {
+  return { type: 'thinking_level_change', id: `chg-${String(level)}`, thinkingLevel: level, configured: null };
+}
+
+describe('convertMessages thinking-level stamping', () => {
+  test('stamps the level in effect onto assistant rows', () => {
+    const rows = convertMessages([changeEntry('low'), assistantEntry('a1', 'first'), assistantEntry('a2', 'second')], false);
+    expect(rows.map((row) => row.thinkingLevel)).toEqual(['low', 'low']);
+  });
+
+  test('follows a mid-transcript change, so each turn keeps the level that served it', () => {
+    const rows = convertMessages([
+      changeEntry('low'),
+      assistantEntry('a1', 'first'),
+      changeEntry('high'),
+      assistantEntry('a2', 'second'),
+    ], false);
+    expect(rows[0].thinkingLevel).toBe('low');
+    expect(rows[1].thinkingLevel).toBe('high');
+  });
+
+  test('normalizes a null level record to "off" rather than dropping the segment', () => {
+    const rows = convertMessages([changeEntry(null), assistantEntry('a1', 'first')], false);
+    expect(rows[0].thinkingLevel).toBe('off');
+  });
+
+  test('leaves user rows unstamped and the level absent before any record', () => {
+    const rows = convertMessages([
+      { type: 'message', id: 'u1', message: { role: 'user', content: 'hi' } },
+      assistantEntry('a1', 'answer'),
+      changeEntry('max'),
+      assistantEntry('a2', 'later'),
+    ], false);
+    expect(rows[0].role).toBe('user');
+    expect(rows[0].thinkingLevel).toBeUndefined();
+    expect(rows[1].thinkingLevel).toBeUndefined();
+    expect(rows[2].thinkingLevel).toBe('max');
+  });
+
+  test('consumes the change record instead of turning it into a row', () => {
+    const rows = convertMessages([changeEntry('low')], false);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe('mergeMessages', () => {
+  test('replaces a streamed row in place so its stamped level survives finalization', () => {
+    const streamed = convertMessages([changeEntry('low'), assistantEntry('a1', 'partial')], true);
+    const final = convertMessages([changeEntry('low'), assistantEntry('a1', 'complete answer')], false);
+    const merged = mergeMessages(streamed, final);
+    expect(merged).toHaveLength(1);
+    expect(merged[0].content).toBe('complete answer');
+    expect(merged[0].thinkingLevel).toBe('low');
+  });
+
+  test('appends a row whose id is new', () => {
+    const prev: ChatMessageData[] = convertMessages([changeEntry('low'), assistantEntry('a1', 'first')], false);
+    const merged = mergeMessages(prev, convertMessages([changeEntry('low'), assistantEntry('a2', 'second')], false));
+    expect(merged.map((row) => row.id)).toEqual(['a1', 'a2']);
+  });
+});

package/src/shared/lib/omp/subagent/transcript-client.ts

@@ -13,6 +13,7 @@
 import type { ChatMessageData, SubagentMessagesPage } from '@/shared/types';
 import { toChatMessage } from '@/shared/lib/omp/session/mapper';
 import { extractText } from '@/shared/lib/omp/session/parse-message-blocks';
+import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
 import { isRecord } from '@/shared/lib/util/guards';
 
 /** Normalize one wire message: the RPC may hand back bare omp AgentMessages
@@ -29,9 +30,20 @@ function normalizeRawMessage(value: unknown): Record<string, unknown> | null {
 
 export function convertMessages(raw: unknown[], streaming: boolean): ChatMessageData[] {
   const out: ChatMessageData[] = [];
+  // omp records the thinking level as its own `thinking_level_change` entry
+  // (session state), not as a per-message field. Walk the records in order and
+  // stamp the level in effect onto each non-user turn, so a subagent footer
+  // shows the level that served that turn — the child's own level, never the
+  // parent session's. Mirrors the server's main-session loader
+  // (`loadSessionMessages`).
+  let currentLevel: string | undefined;
   for (const item of raw) {
     if (isRecord(item)) {
       const entryType = typeof item.type === 'string' ? item.type : '';
+      if (entryType === 'thinking_level_change') {
+        currentLevel = normalizeThinkingLevel(item.thinkingLevel);
+        continue;
+      }
       if (entryType === 'custom' || entryType === 'custom_message') {
         const customType = typeof item.customType === 'string' ? item.customType : '';
         if (customType === 'session_exit') {
@@ -77,7 +89,11 @@ export function convertMessages(raw: unknown[], streaming: boolean): ChatMessage
     }
 
     const converted = toChatMessage(record, streaming);
-    if (converted) out.push(converted);
+    if (!converted) continue;
+    if (currentLevel !== undefined && converted.role !== 'user') {
+      converted.thinkingLevel = currentLevel;
+    }
+    out.push(converted);
   }
   return out;
 }

package/src/shared/types/omp/subagent.ts

@@ -49,6 +49,12 @@ export interface SubagentProgress {
   modelOverride?: string | string[];
   modelRole?: string;
   resolvedModel?: string;
+  /**
+   * Thinking level the child's own model resolved to. Never inferred from the
+   * parent session: the child may run at a different level than the chat that
+   * spawned it, so the footer must read this one or show nothing.
+   */
+  resolvedThinkingLevel?: string;
   resolvedModelIsFallback?: boolean;
   retryState?: SubagentRetryState;
   retryFailure?: { attempt: number; errorMessage: string };