mixdog 0.9.43 → 0.9.45

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -0,0 +1,123 @@
+// Regression: OpenAI OAuth WS abnormal-close recovery before visible output.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
+import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+
+function close1006() {
+    const err = new Error('WebSocket closed abnormally');
+    err.wsCloseCode = 1006;
+    return err;
+}
+
+function entry() {
+    return { socket: { close() {} } };
+}
+
+function wsArgs(overrides = {}) {
+    return {
+        auth: { access_token: 'test-token' },
+        body: { model: 'gpt-5.5', input: [{ role: 'user', content: 'retry me' }] },
+        poolKey: 'openai-oauth-ws-1006-test',
+        cacheKey: 'openai-oauth-ws-1006-test',
+        useModel: 'gpt-5.5',
+        _sendFrameFn: async () => {},
+        _sleepFn: async () => {},
+        ...overrides,
+    };
+}
+
+test('pre-response 1006 opens a fresh WS and replays the same request', async () => {
+    const acquires = [];
+    const frames = [];
+    let streams = 0;
+    const result = await sendViaWebSocket(wsArgs({
+        _acquireWithRetryFn: async (opts) => {
+            acquires.push(opts.forceFresh);
+            return { entry: entry(), reused: false };
+        },
+        _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
+        _streamFn: async () => {
+            streams += 1;
+            if (streams === 1) throw close1006();
+            return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
+        },
+    }));
+
+    assert.equal(result.content, 'recovered');
+    assert.deepEqual(acquires, [false, true], 'retry must acquire a fresh socket');
+    assert.equal(frames.length, 2);
+    assert.deepEqual(frames[1].input, frames[0].input, 'retry must replay the same input');
+    assert.equal(result.__midstreamRetries, 1);
+});
+
+test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_WS_WARMUP',
+        'MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK',
+        'MIXDOG_AGENT_TRACE_DISABLE',
+    ].map((name) => [name, process.env[name]]));
+    Object.assign(process.env, {
+        MIXDOG_OAI_TRANSPORT: 'auto',
+        MIXDOG_OPENAI_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let streamAttempts = 0;
+        let httpCalls = 0;
+        const result = await provider.send([], 'gpt-5.5', [], {
+            sessionId: 'openai-oauth-ws-1006-fallback-test',
+            _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1006-fallback-test' },
+            _sendViaWebSocketFn: (args) => sendViaWebSocket({
+                ...args,
+                _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
+                _sendFrameFn: async () => {},
+                _streamFn: async () => {
+                    streamAttempts += 1;
+                    throw close1006();
+                },
+                _sleepFn: async () => {},
+            }),
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                return { content: 'http-recovered', toolCalls: [], usage: {} };
+            },
+        });
+
+        assert.equal(streamAttempts, 5, 'all bounded ws_1006 attempts must run before fallback');
+        assert.equal(httpCalls, 1);
+        assert.equal(result.content, 'http-recovered');
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('post-emission 1006 refuses replay after text or tool output', async () => {
+    for (const emitted of ['emittedText', 'emittedToolCall']) {
+        let acquires = 0;
+        await assert.rejects(
+            sendViaWebSocket(wsArgs({
+                poolKey: `openai-oauth-ws-1006-${emitted}-test`,
+                _acquireWithRetryFn: async () => {
+                    acquires += 1;
+                    return { entry: entry(), reused: false };
+                },
+                _streamFn: async ({ state }) => {
+                    state[emitted] = true;
+                    throw close1006();
+                },
+            })),
+            (err) => err.wsCloseCode === 1006 && err.unsafeToRetry === true,
+        );
+        assert.equal(acquires, 1, `${emitted} must prevent a replay`);
+    }
+});

package/scripts/routing-corpus.mjs

@@ -345,7 +345,7 @@ function buildCorpus(rows, { limit, sinceTs, agentFilter }) {
 }
 
 function scoreCorpus(cases) {
-  // A single健全 index: sum of flagged cases per KPI (lower is better).
+  // A single health index: sum of flagged cases per KPI (lower is better).
   const summary = {};
   let flaggedCases = 0;
   for (const k of FLAG_KEYS) summary[k] = cases.filter((c) => c.flags.includes(k)).length;

package/scripts/shell-jobs-windows-hide-test.mjs

@@ -0,0 +1,164 @@
+import assert from 'node:assert/strict';
+import { readFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+import {
+    killShellJob,
+    startBackgroundShellJob,
+    waitForShellJob,
+} from '../src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs';
+import { shellJobDetailPath } from '../src/runtime/agent/orchestrator/tools/builtin/shell-job-paths.mjs';
+
+function availablePowerShellHosts() {
+    return ['powershell.exe', 'pwsh.exe'].filter((host) => {
+        const result = spawnSync(host, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '$PSVersionTable.PSVersion.Major'], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        return !result.error && result.status === 0;
+    });
+}
+
+const windowProbe = String.raw`
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public delegate bool MixdogEnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+public static class MixdogWindowProbe {
+    [DllImport("user32.dll")] public static extern bool EnumWindows(MixdogEnumWindowsProc callback, IntPtr lParam);
+    [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetClassName(IntPtr hWnd, StringBuilder text, int maxCount);
+    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+}
+'@
+$consoleWindowPids = @{}
+$callback = [MixdogEnumWindowsProc] {
+    param([IntPtr] $hWnd, [IntPtr] $lParam)
+    $className = New-Object System.Text.StringBuilder 256
+    [void] [MixdogWindowProbe]::GetClassName($hWnd, $className, $className.Capacity)
+    if ($className.ToString() -eq 'ConsoleWindowClass') {
+        [uint32] $pid = 0
+        [void] [MixdogWindowProbe]::GetWindowThreadProcessId($hWnd, [ref] $pid)
+        $consoleWindowPids[[string] $pid] = $true
+    }
+    return $true
+}
+[void] [MixdogWindowProbe]::EnumWindows($callback, [IntPtr]::Zero)
+Get-CimInstance Win32_Process | ForEach-Object {
+    Write-Output "P|$($_.ProcessId)|$($_.ParentProcessId)|$($_.Name)"
+}
+$consoleWindowPids.Keys | ForEach-Object { Write-Output "W|$_" }
+`;
+
+function processConsoleSnapshot(probeHost) {
+    const result = spawnSync(probeHost, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', windowProbe], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 10_000,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error(`Console window probe failed: ${result.error?.message || result.stderr || result.status}`);
+    }
+    const processes = new Map();
+    const consoleWindowPids = new Set();
+    for (const row of result.stdout.split(/\r?\n/)) {
+        const [kind, pid, parentPid, name] = row.split('|');
+        if (kind === 'P') processes.set(Number(pid), { parentPid: Number(parentPid), name });
+        if (kind === 'W') consoleWindowPids.add(Number(pid));
+    }
+    return { processes, consoleWindowPids };
+}
+
+function processTreePids(processes, rootPid) {
+    const tree = new Set([rootPid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [pid, process] of processes) {
+            if (!tree.has(pid) && tree.has(process.parentPid)) {
+                tree.add(pid);
+                changed = true;
+            }
+        }
+    }
+    return tree;
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function removeJobArtifacts(detail) {
+    for (const file of [
+        shellJobDetailPath(detail.jobId),
+        detail.stdoutPath,
+        detail.stderrPath,
+        detail.exitPath,
+        detail.donePath,
+        `${detail.exitPath}.cmd.ps1`,
+        `${detail.exitPath}.user.ps1`,
+    ]) {
+        try { rmSync(file, { force: true }); } catch {}
+    }
+}
+
+test('Windows PowerShell shell jobs create no conhost or ConsoleWindowClass window', async (t) => {
+    if (process.platform !== 'win32') return t.skip('win32-only');
+    const hosts = availablePowerShellHosts();
+    if (hosts.length === 0) return t.skip('no PowerShell host installed');
+    const workDir = mkdtempSync(join(tmpdir(), 'mixdog-shell-job-window-'));
+    const probeHost = hosts[0];
+
+    try {
+        for (const shell of hosts) {
+            const before = processConsoleSnapshot(probeHost);
+            const job = startBackgroundShellJob({
+                command: "Start-Sleep -Milliseconds 5000; Write-Output 'mixdog-window-probe-out'; [Console]::Error.WriteLine('mixdog-window-probe-err')",
+                timeoutMs: 10_000,
+                workDir,
+                mergeStderr: false,
+                spawnEnv: process.env,
+                shell,
+                shellType: 'powershell',
+            });
+            try {
+                const newConsoleHosts = new Set();
+                for (let i = 0; i < 8; i += 1) {
+                    await sleep(100);
+                    const snapshot = processConsoleSnapshot(probeHost);
+                    const jobTree = processTreePids(snapshot.processes, job.pid);
+                    // windowsHide may give the outer wrapper one hidden console
+                    // (a direct child of job.pid). A second conhost belongs to
+                    // Start-Process only when it is nested below that wrapper.
+                    const isNestedJobConsole = (pid) => {
+                        const process = snapshot.processes.get(pid);
+                        return process && process.parentPid !== job.pid && jobTree.has(process.parentPid);
+                    };
+                    for (const [pid, process] of snapshot.processes) {
+                        if (process.name?.toLowerCase() === 'conhost.exe'
+                            && !before.processes.has(pid) && isNestedJobConsole(pid)) {
+                            newConsoleHosts.add(`${pid}|conhost.exe|parent=${process.parentPid}`);
+                        }
+                    }
+                    for (const pid of snapshot.consoleWindowPids) {
+                        if (!before.consoleWindowPids.has(pid) && isNestedJobConsole(pid)) {
+                            newConsoleHosts.add(`${pid}|ConsoleWindowClass`);
+                        }
+                    }
+                }
+                const detail = await waitForShellJob(job.jobId, { timeoutMs: 10_000, pollMs: 50 });
+                assert.equal(detail?.exitCode, 0, `${shell} preserves the child exit code`);
+                assert.equal(readFileSync(job.stdoutPath, 'utf8').trim(), 'mixdog-window-probe-out', `${shell} preserves stdout redirection`);
+                assert.equal(readFileSync(job.stderrPath, 'utf8').trim(), 'mixdog-window-probe-err', `${shell} preserves stderr redirection`);
+                assert.deepEqual([...newConsoleHosts], [], `${shell} created a console host/window in its process tree: ${[...newConsoleHosts].join(', ')}`);
+            } finally {
+                killShellJob(job.jobId);
+                removeJobArtifacts(job);
+            }
+        }
+    } finally {
+        rmSync(workDir, { recursive: true, force: true });
+    }
+});

package/scripts/tui-transcript-jitter-harness-entry.jsx

@@ -0,0 +1,302 @@
+import React from 'react';
+import { PassThrough } from 'node:stream';
+import { Box, measureElement, render } from 'ink';
+import { Item } from '../src/tui/components/TranscriptItem.jsx';
+import { useTranscriptWindow } from '../src/tui/app/use-transcript-window.mjs';
+import {
+  streamingMeasuredRowsById,
+} from '../src/tui/app/transcript-window.mjs';
+import {
+  resetAllStreamingMarkdownStablePrefixes,
+  resetStreamingMarkdownStablePrefix,
+  resolveStreamingMarkdownParts,
+} from '../src/tui/markdown/streaming-markdown.mjs';
+
+const COLUMNS = 42;
+const VIEW_ROWS = 8;
+const INITIAL_SCROLL = 8;
+const STREAM_ID = 'jitter-fence-tail';
+const HISTORY = Array.from({ length: 8 }, (_, index) => ({
+  id: `history-${index}`,
+  kind: 'notice',
+  tone: 'plain',
+  text: `H${index} stable history row`,
+}));
+const SCRIPT = [
+  'Here is the script:',
+  '',
+  '```js',
+  'const first = `',
+  'alpha',
+  '`;',
+  'const second = `',
+  'beta',
+  '`;',
+  'console.log(first, second);',
+  '```',
+  '',
+  'Done.',
+].join('\n');
+
+const frames = [];
+globalThis.__mixdogTailGrowthProbe = null;
+let commit = 0;
+const identity = (value) => value;
+const noop = () => {};
+
+function Harness({ text, step }) {
+  const [scrollOffset, setScrollOffset] = React.useState(INITIAL_SCROLL);
+  const [measuredRowsVersion, setMeasuredRowsVersion] = React.useState(0);
+  const transcriptAnchorRef = React.useRef(null);
+  const transcriptAnchorDirtyRef = React.useRef(true);
+  const scrollTargetRef = React.useRef(INITIAL_SCROLL);
+  const scrollPositionRef = React.useRef(INITIAL_SCROLL);
+  const maxScrollRowsRef = React.useRef(0);
+  const transcriptGeomRef = React.useRef({});
+  const followingRef = React.useRef(false);
+  const dragRef = React.useRef({ active: false, rect: null });
+  const transcriptViewportRef = React.useRef({ top: 0 });
+  const selectionLayoutRef = React.useRef(null);
+  const contentRef = React.useRef(null);
+  const tailRef = React.useRef(null);
+  const streamingTail = React.useMemo(() => ({
+    id: STREAM_ID,
+    kind: 'assistant',
+    text,
+    streaming: true,
+  }), [text]);
+  const transcriptItems = React.useMemo(() => [...HISTORY, streamingTail], [streamingTail]);
+
+  const preHookEntry = streamingMeasuredRowsById.get(STREAM_ID);
+  const preHookMeasuredRows = preHookEntry?.rows ?? null;
+  const preHookEstimateRows = preHookEntry?.estimateRows ?? null;
+
+  const {
+    transcriptWindow,
+    renderedTranscriptItems,
+    transcriptMeasureRef,
+  } = useTranscriptWindow({
+    items: HISTORY,
+    structureRevision: 1,
+    streamingTail,
+    themeEpoch: 0,
+    frameColumns: COLUMNS,
+    toolOutputExpanded: false,
+    transcriptContentHeight: VIEW_ROWS,
+    transcriptBottomSlackRows: 1,
+    transcriptGuardRows: 1,
+    floatingPanelRows: 0,
+    overlayHintRequested: false,
+    scrollOffset,
+    setScrollOffset,
+    transcriptAnchorRef,
+    transcriptAnchorDirtyRef,
+    scrollTargetRef,
+    scrollPositionRef,
+    maxScrollRowsRef,
+    transcriptGeomRef,
+    followingRef,
+    dragRef,
+    transcriptViewportRef,
+    selectionLayoutRef,
+    withSelectionClip: identity,
+    paintSelectionRect: noop,
+    stopSmoothScroll: noop,
+    measuredRowsVersion,
+    setMeasuredRowsVersion,
+  });
+
+  const growthProbe = globalThis.__mixdogTailGrowthProbe;
+  const tailHookRef = transcriptMeasureRef(streamingTail);
+  const combinedTailRef = React.useCallback((element) => {
+    tailHookRef?.(element);
+    tailRef.current = element;
+  }, [tailHookRef]);
+
+  React.useLayoutEffect(() => {
+    const geometry = transcriptGeomRef.current || {};
+    const prefix = geometry.prefixRows || [];
+    const physicalRows = measureElement(contentRef.current).height;
+    const tailYogaRows = measureElement(tailRef.current).height;
+    const renderScrollOffset = transcriptWindow.effectiveScrollOffset;
+    const visibleTopIndexed = transcriptWindow.totalRows - renderScrollOffset - VIEW_ROWS;
+    const visibleTopPhysical = physicalRows - renderScrollOffset - VIEW_ROWS;
+    frames.push({
+      commit: ++commit,
+      step,
+      char: text.at(-1) === '\n' ? '\\n' : (text.at(-1) || ''),
+      totalRows: transcriptWindow.totalRows,
+      renderScrollOffset,
+      visibleTopIndexed,
+      visibleTopPhysical,
+      physicalRows,
+      tailIndexedRows: prefix.length > 1 ? prefix.at(-1) - prefix.at(-2) : -1,
+      tailYogaRows,
+      mountedDelta: tailYogaRows - (prefix.length > 1 ? prefix.at(-1) - prefix.at(-2) : -1),
+      growthLive: growthProbe?.live ?? null,
+      growthBaseline: growthProbe?.baseline ?? null,
+      growthDelta: growthProbe?.delta ?? null,
+      suppressMeasured: geometry.suppressMeasuredRowHeights === true,
+      measuredRowsVersion,
+      preHookMeasuredRows,
+      preHookEstimateRows,
+      postHarvestMeasuredRows: streamingMeasuredRowsById.get(STREAM_ID)?.rows ?? null,
+      postHarvestEstimateRows: streamingMeasuredRowsById.get(STREAM_ID)?.estimateRows ?? null,
+      scrollTarget: scrollTargetRef.current,
+      following: followingRef.current,
+      anchor: transcriptAnchorRef.current?.id || '-',
+    });
+  }, [step, text, measuredRowsVersion, transcriptWindow.totalRows, transcriptWindow.effectiveScrollOffset,
+    transcriptAnchorRef, transcriptGeomRef]);
+
+  return (
+    <Box flexDirection="column" width={COLUMNS} height={VIEW_ROWS} overflow="hidden" justifyContent="flex-end">
+      <Box
+        ref={contentRef}
+        flexDirection="column"
+        width="100%"
+        flexShrink={0}
+        marginBottom={-transcriptWindow.effectiveScrollOffset}
+      >
+        {renderedTranscriptItems.map((item, index, all) => {
+          const hookRef = item.id === STREAM_ID ? combinedTailRef : transcriptMeasureRef(item);
+          return (
+            <Box key={item.id} ref={hookRef} flexDirection="column" flexShrink={0}>
+              <Item
+                item={item}
+                prevKind={index > 0 ? all[index - 1].kind : null}
+                columns={COLUMNS}
+                toolOutputExpanded={false}
+              />
+            </Box>
+          );
+        })}
+        {transcriptWindow.bottomSpacerRows > 0
+          ? <Box height={transcriptWindow.bottomSpacerRows} flexShrink={0} />
+          : null}
+      </Box>
+    </Box>
+  );
+}
+
+function fakeTty(columns, rows) {
+  const stream = new PassThrough();
+  stream.columns = columns;
+  stream.rows = rows;
+  stream.isTTY = true;
+  stream.getColorDepth = () => 1;
+  stream.hasColors = () => false;
+  stream.setRawMode = () => stream;
+  stream.on('data', () => {});
+  return stream;
+}
+
+async function settle(instance) {
+  await instance.waitUntilRenderFlush();
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  await instance.waitUntilRenderFlush();
+}
+
+function assertStreamingMarkdownPartsCache() {
+  const key = 'streaming-parts-cache-coverage';
+  const longText = 'Settled paragraph.\n\n```js\nconst value = 1;';
+  const initial = resolveStreamingMarkdownParts(longText, key);
+  const repeated = resolveStreamingMarkdownParts(`${longText}\n\n`, key);
+  if (repeated !== initial) {
+    throw new Error('normalized-equivalent stream text did not reuse its resolved parts');
+  }
+
+  const regressed = resolveStreamingMarkdownParts('plain text', key);
+  if (regressed === initial || regressed.stablePrefix || regressed.unstableSuffix !== 'plain text') {
+    throw new Error('text regression served a stale streaming-markdown split');
+  }
+
+  const recomputed = resolveStreamingMarkdownParts(longText, key);
+  if (recomputed === initial) {
+    throw new Error('text change did not evict the prior streaming-markdown snapshot');
+  }
+
+  const resetSeed = recomputed;
+  resetStreamingMarkdownStablePrefix(key);
+  if (resolveStreamingMarkdownParts(longText, key) === resetSeed) {
+    throw new Error('streaming-markdown reset did not clear its resolved-parts snapshot');
+  }
+}
+
+assertStreamingMarkdownPartsCache();
+resetAllStreamingMarkdownStablePrefixes();
+streamingMeasuredRowsById.delete(STREAM_ID);
+const stdout = fakeTty(COLUMNS, VIEW_ROWS);
+const stderr = fakeTty(COLUMNS, VIEW_ROWS);
+const stdin = fakeTty(COLUMNS, VIEW_ROWS);
+const instance = render(<Harness text={SCRIPT.slice(0, 1)} step={1} />, {
+  stdout,
+  stderr,
+  stdin,
+  interactive: true,
+  patchConsole: false,
+  exitOnCtrlC: false,
+  maxFps: 1000,
+});
+await settle(instance);
+for (let step = 2; step <= SCRIPT.length; step++) {
+  instance.rerender(<Harness text={SCRIPT.slice(0, step)} step={step} />);
+  await settle(instance);
+}
+instance.unmount();
+await instance.waitUntilExit();
+instance.cleanup();
+
+const byStep = new Map();
+for (const frame of frames) {
+  const list = byStep.get(frame.step) || [];
+  list.push(frame);
+  byStep.set(frame.step, list);
+}
+const dips = [];
+let previousSettled = null;
+for (const [step, list] of [...byStep.entries()].sort((a, b) => a[0] - b[0])) {
+  const first = list[0];
+  const settled = list.at(-1);
+  if (previousSettled
+    && first.visibleTopPhysical !== previousSettled.visibleTopPhysical
+    && settled.visibleTopPhysical === previousSettled.visibleTopPhysical) {
+    dips.push({ previous: previousSettled, transient: first, corrected: settled });
+  }
+  previousSettled = settled;
+}
+
+const print = (label, frame) => {
+  console.log(`${label} c${frame.commit} step=${frame.step} char=${JSON.stringify(frame.char)}`
+    + ` totalRows=${frame.totalRows} renderScrollOffset=${frame.renderScrollOffset}`
+    + ` visibleTop=${frame.visibleTopPhysical} indexedTop=${frame.visibleTopIndexed}`
+    + ` physicalRows=${frame.physicalRows} tail(index/yoga)=${frame.tailIndexedRows}/${frame.tailYogaRows}`
+    + ` mountedDelta=${frame.mountedDelta} helper(live/base/delta)=${frame.growthLive}/${frame.growthBaseline}/${frame.growthDelta}`
+    + ` suppressMeasured=${frame.suppressMeasured ? 1 : 0}`
+    + ` measuredVersion=${frame.measuredRowsVersion}`
+    + ` baseline(measured/estimate)=${frame.preHookMeasuredRows}/${frame.preHookEstimateRows}`
+    + ` harvest(measured/estimate)=${frame.postHarvestMeasuredRows}/${frame.postHarvestEstimateRows}`
+    + ` target=${frame.scrollTarget} following=${frame.following ? 1 : 0} anchor=${frame.anchor}`);
+};
+
+console.log(`# scrolled-up fenced-script frame repro columns=${COLUMNS} viewRows=${VIEW_ROWS} initialScroll=${INITIAL_SCROLL}`);
+console.log(`# append-only characters=${SCRIPT.length} commits=${frames.length} dip-snap events=${dips.length}`);
+for (const event of dips.slice(0, 4)) {
+  print('before   ', event.previous);
+  print('transient', event.transient);
+  print('harvest  ', event.corrected);
+  console.log('');
+}
+const suppressValues = new Set(frames.map((frame) => frame.suppressMeasured));
+console.log(`# suppressMeasuredRowHeights values during repro: ${[...suppressValues].map(Number).join(',')}`);
+if (dips.length > 0) {
+  throw new Error(`expected no visible-top dip/snap while fenced script streams; observed ${dips.length}`);
+}
+if (suppressValues.size !== 1 || !suppressValues.has(true)) {
+  throw new Error('repro unexpectedly toggled suppressMeasuredRowHeights');
+}
+console.log('tui-transcript-jitter-harness: ok');
+
+
+
+

package/scripts/tui-transcript-jitter-harness.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { build } from 'esbuild';
+import { readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const entry = join(ROOT, 'scripts', 'tui-transcript-jitter-harness-entry.jsx');
+const outfile = join(ROOT, 'scripts', '.tui-transcript-jitter-harness.tmp.mjs');
+
+const inkAlias = {
+  name: 'mixdog-ink-alias',
+  setup(ctx) {
+    ctx.onResolve({ filter: /^ink$/ }, () => ({
+      path: '../vendor/ink/build/index.js',
+      external: true,
+    }));
+  },
+};
+
+// Build-only probe: records the exact delta seen by the production helper
+// without adding another stateful estimator call from the harness.
+const growthProbe = {
+  name: 'streaming-tail-growth-probe',
+  setup(ctx) {
+    ctx.onLoad({ filter: /transcript-window\.mjs$/ }, async (args) => {
+      let source = (await readFile(args.path, 'utf8')).replace(/\r\n/g, '\n');
+      const target = '  return { tailRows: idEntry.rows, delta };';
+      const replacement = `  globalThis.__mixdogTailGrowthProbe = { live, baseline, delta, tailRows: idEntry.rows };\n${target}`;
+      if (!source.includes(target)) return null;
+      source = source.replace(target, replacement);
+      return { contents: source, loader: 'js' };
+    });
+  },
+};
+
+try {
+  await build({
+    entryPoints: [entry],
+    outfile,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node22',
+    jsx: 'automatic',
+    packages: 'external',
+    plugins: [inkAlias, growthProbe],
+    banner: {
+      js: "import { createRequire as __mixdogCreateRequire } from 'node:module';\nconst require = __mixdogCreateRequire(import.meta.url);",
+    },
+    logLevel: 'silent',
+  });
+  await import(`${pathToFileURL(outfile).href}?run=${Date.now()}`);
+} finally {
+  await rm(outfile, { force: true });
+}
+
+

package/src/agents/reviewer/AGENT.md

@@ -6,13 +6,11 @@ permission: read
 
 Independent regression/risk review agent.
 
-Review the approved intent, diff, and tests with independent judgment. Prioritize
-actionable correctness, regression, security, and verification risks; inspect
-affected boundaries. Do not reimplement the change or report non-risky nits.
-Treat implementer and Lead reports as claims to test rather than evidence;
-independently evaluate the final deliverable against the original request and
-available evidence with a critical lens, actively seeking errors, unsupported
-assumptions, and counterexamples before confirming.
+Review the diff and tests with independent judgment. Prioritize actionable
+correctness, regression, security, and verification risks; inspect affected
+boundaries. Do not reimplement the change or report non-risky nits. Independently
+evaluate the final deliverable with a critical lens, actively seeking errors,
+unsupported assumptions, and counterexamples before confirming.
 Report findings first, severity-ordered, with one line per `file:line`. If clean,
 say so in one line and include only material residual risk.