mixdog 0.9.159 → 0.9.161

package/scripts/pdf-rotation-stress.mjs

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { PDFDocument, degrees } from 'pdf-lib';
+import { applyPdfBatch } from '../src/runtime/office/pdf/pdf-adapter.mjs';
+import { extractPdfTextLayout, findPdfText } from '../src/runtime/office/pdf/pdf-analysis.mjs';
+
+// Deterministic differential stress: compare search-derived PDF marks with
+// the coordinates used to draw the source, varying page rotation and boxes.
+// This is opt-in and never runs as part of the default unit suite.
+const until = Date.parse(process.argv[2] || '');
+assert.ok(Number.isFinite(until), 'Pass an ISO end time');
+const directory = await mkdtemp(join(tmpdir(), 'pdf-rotation-stress-'));
+const path = join(directory, 'latest.pdf');
+let state = 0x5eed2026;
+const random = () => {
+  state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+  return state / 0x100000000;
+};
+const between = (min, max) => min + random() * (max - min);
+let rounds = 0;
+let pagesChecked = 0;
+let nextReport = Date.now();
+do {
+  const pdf = await PDFDocument.create();
+  const font = await pdf.embedFont('Helvetica');
+  const expected = [];
+  for (let index = 0; index < 16; index += 1) {
+    const width = between(400, 700);
+    const height = between(350, 800);
+    const originX = between(-100, 150);
+    const originY = between(-100, 150);
+    const page = pdf.addPage([width, height]);
+    page.setMediaBox(originX, originY, width, height);
+    page.setCropBox(originX + 10, originY + 10, width - 20, height - 20);
+    page.setRotation(degrees([0, 90, 180, 270][index % 4]));
+    const size = between(9, 30);
+    const x = originX + 40;
+    const y = originY + height - 80;
+    const prefix = font.widthOfTextAtSize('Al', size);
+    // Separate text runs exercise joining in reversed as well as upright text.
+    page.drawText('Alpha', { x, y, size, font });
+    page.drawText('beta', { x: x + font.widthOfTextAtSize('Alpha ', size), y, size, font });
+    expected.push({ x: x + prefix, y, width: font.widthOfTextAtSize('pha beta', size), height: size });
+  }
+  await writeFile(path, await pdf.save());
+  const results = await applyPdfBatch(path, [
+    { op: 'highlight', find: 'pha beta' },
+    { op: 'add_link', find: 'pha beta', toPage: 1 },
+    { op: 'add_text', text: 'After measurement', page: 1, x: 40, y: 40, size: 10 },
+  ]);
+  for (const result of results.slice(0, 2)) {
+    assert.equal(result.boxes.length, expected.length);
+    for (const box of result.boxes) {
+      for (const key of ['x', 'y', 'width', 'height']) {
+        assert.ok(Math.abs(box[key] - expected[box.page - 1][key]) < 0.08,
+          JSON.stringify({ round: rounds, state, key, box, expected: expected[box.page - 1], path }));
+      }
+    }
+  }
+  const layout = await extractPdfTextLayout(path, { shapes: false });
+  assert.equal(findPdfText(layout, 'pha beta').matchCount, expected.length);
+  const saved = await PDFDocument.load(await readFile(path));
+  assert.deepEqual(saved.getPages().map((page) => page.getRotation().angle),
+    expected.map((_, index) => [0, 90, 180, 270][index % 4]));
+  rounds += 1;
+  pagesChecked += expected.length;
+  if (Date.now() >= nextReport) {
+    console.log(JSON.stringify({ rounds, pagesChecked, rssMB: Math.round(process.memoryUsage().rss / 1024 / 1024) }));
+    nextReport = Date.now() + 60_000;
+  }
+} while (Date.now() < until);
+console.log(JSON.stringify({ ok: true, rounds, pagesChecked, directory }));

package/scripts/perf/cold-reconnect-probe.mjs

@@ -0,0 +1,109 @@
+// Exercise production orchestration with injected, non-network dependencies.
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { setImmediate as immediate } from 'node:timers/promises';
+
+const directory = mkdtempSync(join(tmpdir(), 'mixdog-cold-reconnect-'));
+process.env.MIXDOG_RUNTIME_ROOT = directory;
+process.env.MIXDOG_DATA_DIR = directory;
+process.env.MIXDOG_DISABLE_MCP = '0';
+const started = performance.now();
+const { createProviderModels } = await import('../../src/session-runtime/provider-models.mjs');
+const { createProviderAuthApi } = await import('../../src/session-runtime/provider-auth-api.mjs');
+const { createMcpGlue } = await import('../../src/session-runtime/mcp-glue.mjs');
+const importMs = performance.now() - started;
+let catalogCalls = 0, revision = 987654;
+const registry = {
+    providerCatalogRevision: () => revision,
+    getAllProviders: () => new Map([['openai', {
+        listModels: async () => {
+            catalogCalls++;
+            await immediate();
+            return [{ id: 'synthetic-model', name: 'Synthetic model', contextWindow: 128000 }];
+        },
+    }]]),
+};
+const createModels = () => createProviderModels({
+    caches: { providerModelsCache: { models: null }, providerModelsLoadSeq: 0,
+        webSearchProviderModelsCache: { models: null } },
+    modelMetaByRoute: new Map(), getRoute: () => ({ provider: 'openai' }),
+    getConfig: () => ({}), getReg: () => registry, webSearchCapableFor: () => false,
+    sortProviderModelsRaw: rows => rows,
+    providerModelCacheRowRaw: (provider, row) => ({ ...row, provider }),
+    normalizeWebSearchProviderId: value => value, isWebSearchCapableProvider: () => false,
+    ensureFullConfig() {}, awaitKeychainPrewarm: async () => {},
+    ensureProvidersReady: async () => {}, bootProfile() {}, scheduleProviderModelWarmup() {},
+    quickHelpers: { quickProviderModelRows: () => [{ id: 'quick' }] },
+});
+const sessions = Array.from({ length: 8 }, createModels);
+let start = performance.now();
+const cold = await Promise.all(sessions.map(api => api.collectProviderModels()));
+const catalogColdMs = performance.now() - start;
+assert.ok(cold.every(rows => rows.length === 1));
+assert.equal(catalogCalls, 1);
+start = performance.now();
+await Promise.all(sessions.map(api => api.collectProviderModels()));
+const catalogWarmMs = performance.now() - start;
+assert.equal(catalogCalls, 1);
+revision++;
+await Promise.all(sessions.map(api => api.collectProviderModels()));
+assert.equal(catalogCalls, 2);
+
+let releaseSecrets, ready = false;
+const secrets = new Promise(resolve => { releaseSecrets = resolve; });
+const auth = createProviderAuthApi({
+    awaitKeychainPrewarm: () => secrets,
+    isKeychainPrewarmReady: () => ready,
+    hasProviderSetupCached: () => ready,
+    cachedProviderSetup: async options => ({ source: options.quick ? 'quick' : 'authoritative' }),
+});
+start = performance.now();
+const quickAuth = await auth.getProviderSetup();
+const pendingAuthMs = performance.now() - start;
+assert.equal(quickAuth.pendingSecrets, true);
+assert.equal(quickAuth.source, 'quick');
+ready = true;
+releaseSecrets();
+await immediate();
+assert.equal((await auth.getProviderSetup()).source, 'authoritative');
+
+let releaseConnect;
+let active = 0, maxActive = 0, config = { mcpServers: { first: { command: 'synthetic' } } };
+const connected = [];
+const gate = new Promise(resolve => { releaseConnect = resolve; });
+const state = { mcpConnectGeneration: 0, mcpConnectInFlight: null, mcpFailures: [] };
+const mcp = createMcpGlue({
+    state, getConfig: () => config, getCurrentCwd: () => directory,
+    mcpClient: {
+        resolveMcpTransportKind: () => 'stdio', getMcpServerStatus: () => [],
+        resolveMcpStartupTimeoutMs: () => 10000, disconnectAll: async () => {},
+        connectMcpServers: async servers => {
+            maxActive = Math.max(maxActive, ++active);
+            await gate;
+            connected.push(Object.keys(servers));
+            active--;
+        },
+    },
+});
+const initial = mcp.connectConfiguredMcp();
+start = performance.now();
+await mcp.awaitInitialMcpConnect(15);
+const mcpBoundedWaitMs = performance.now() - start;
+assert.equal(active, 1);
+const obsolete = mcp.connectConfiguredMcp({ reset: true });
+config = { mcpServers: { latest: { command: 'synthetic' } } };
+const latest = mcp.connectConfiguredMcp({ reset: true });
+releaseConnect();
+await Promise.all([initial, obsolete, latest]);
+assert.equal(maxActive, 1);
+assert.deepEqual(connected, [['first'], ['latest']]);
+assert.equal(state.mcpConnectInFlight, null);
+const report = { directory, importMs, catalogColdMs, catalogWarmMs, pendingAuthMs,
+    catalogCallsForEightSessionsBeforeAndAfterInvalidation: catalogCalls, mcpBoundedWaitMs,
+    maxConcurrentMcpConnections: maxActive, connected,
+    limits: 'Injected model lists, keychain and MCP: validates orchestration, not external network/keychain latency.' };
+writeFileSync(join(directory, 'report.json'), JSON.stringify(report, null, 2));
+console.log(JSON.stringify(report, null, 2));

package/scripts/perf/transcript-baseline.mjs

@@ -0,0 +1,56 @@
+// Frozen pre-optimization reference for differential tests and local probes.
+// This is deliberately not imported by product code.
+export function legacyTokenFloors(s) {
+    let floor = 0;
+    for (const match of s.matchAll(/[\x21-\x7e]{16,}/g)) {
+        floor += match[0].length * (match[0].length >= 64 ? 0.65 : 0.5);
+    }
+    const words = s.match(/\b(?=[A-Za-z0-9]{8,}\b)(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*\d)[A-Za-z0-9]+\b/g) || [];
+    if (words.length >= 3) {
+        const chars = words.reduce((sum, word) => sum + word.length, 0);
+        floor = Math.max(floor, chars * 0.5 + (s.length - chars) * 0.25);
+    }
+    const lines = s.split(/\r?\n/).filter(line => line.trim());
+    const nonWhitespace = s.match(/\S/g)?.length || 0;
+    const structural = s.match(/[\[\]{}":,=<>|\\]/g)?.length || 0;
+    const jsonLines = lines.filter(line => /^\s*[\[{].*[\]}],?\s*$/.test(line)).length;
+    if (lines.length >= 3 && nonWhitespace > 0
+        && (jsonLines >= Math.ceil(lines.length / 2) || structural / nonWhitespace >= 0.12)) {
+        floor = Math.max(floor, nonWhitespace * 0.5 + (s.length - nonWhitespace) * 0.25);
+    }
+    return floor;
+}
+
+const text = item => typeof item.text === 'string' ? item.text : item.text == null ? '' : String(item.text);
+const ownsId = item => item.id !== undefined && item.id !== null;
+const signature = item => [item.kind, item.status, item.label, item.tone, item.verb,
+    item.count, item.completedCount, item.detail].map(value => String(value ?? '')).join('\u0001');
+
+export function legacyAlignment(previous, incoming) {
+    let best = null;
+    for (let offset = 0; offset < previous.length; offset++) {
+        const span = Math.min(previous.length - offset, incoming.length);
+        let overlap = 0, idMatches = 0, strongMatches = 0;
+        for (; overlap < span; overlap++) {
+            const a = previous[offset + overlap], b = incoming[overlap];
+            const at = text(a), bt = text(b);
+            const compatible = a.kind === b.kind && (a.kind === 'tool'
+                ? String(a.name ?? '') === String(b.name ?? '')
+                : a.kind === 'user' || a.kind === 'assistant'
+                    ? at === bt || (at.length > 0 && bt.length > 0 && (at.startsWith(bt) || bt.startsWith(at)))
+                    : true);
+            if (a !== b && !compatible) break;
+            if (ownsId(a) && ownsId(b) && String(a.id) === String(b.id)) idMatches++;
+            if (a === b || (a.kind === b.kind && at === bt
+                && String(a.name ?? '') === String(b.name ?? '') && signature(a) === signature(b))) strongMatches++;
+        }
+        if (!overlap || overlap !== span) continue;
+        const candidate = { offset, overlap, idMatches, strongMatches, endsAtBaselineTail: offset + overlap === previous.length };
+        const rank = item => [item.overlap, item.idMatches, item.strongMatches,
+            Number(item.endsAtBaselineTail), incoming.length < previous.length ? item.offset : -item.offset];
+        const a = rank(candidate), b = best && rank(best);
+        const different = b ? a.findIndex((value, index) => value !== b[index]) : -1;
+        if (!best || (different >= 0 && a[different] > b[different])) best = candidate;
+    }
+    return best;
+}

package/scripts/perf/transcript-runtime-probe.mjs

@@ -0,0 +1,62 @@
+// Isolated synthetic histories only: no live daemon, credentials or model calls.
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { setImmediate as immediate } from 'node:timers/promises';
+import { legacyTokenFloors } from './transcript-baseline.mjs';
+import { denseTokenFloor, structuredTokenFloor } from '../../src/runtime/agent/orchestrator/session/token-estimate-floors.mjs';
+import { estimateMessagesTokens, summarizeContextMessages } from '../../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import { readTopLevelLifecycleRecord } from '../../src/runtime/agent/orchestrator/session/lifecycle-scan.mjs';
+import { createCanonicalSessionReader } from '../../src/runtime/agent/orchestrator/session/store/canonical-reader.mjs';
+import { yieldToRenderer } from '../../src/tui/session/render-timing.mjs';
+
+const directory = mkdtempSync(join(tmpdir(), 'mixdog-transcript-perf-'));
+const messages = Array.from({ length: 1000 }, (_, i) => ({
+    role: i % 2 ? 'assistant' : 'user', content: `message ${i}\n${'ordinary content with spaces '.repeat(280)}`,
+}));
+const raw = JSON.stringify({ id: 'synthetic', closed: false, generation: 1, messages });
+const target = join(directory, 'synthetic.json');
+writeFileSync(target, raw);
+const currentReader = createCanonicalSessionReader();
+const oldReader = () => readTopLevelLifecycleRecord(readFileSync(target, 'utf8'));
+const currentFloors = value => Math.max(denseTokenFloor(value), structuredTokenFloor(value));
+const median = values => [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
+const timed = async (name, action, repetitions = 5) => {
+    const samples = [];
+    for (let i = 0; i < repetitions; i++) {
+        globalThis.gc?.();
+        const start = performance.now();
+        await action();
+        samples.push(performance.now() - start);
+    }
+    return { name, medianMs: +median(samples).toFixed(3), samplesMs: samples.map(n => +n.toFixed(3)) };
+};
+const results = [];
+results.push(await timed('token-floors-before', () => messages.forEach(m => legacyTokenFloors(m.content))));
+results.push(await timed('token-floors-after', () => messages.forEach(m => currentFloors(m.content))));
+results.push(await timed('full-token-meter-after', () => estimateMessagesTokens(messages)));
+results.push(await timed('context-summary-cold-after', () => summarizeContextMessages(structuredClone(messages))));
+summarizeContextMessages(messages);
+results.push(await timed('context-summary-warm-after', () => summarizeContextMessages(messages)));
+results.push(await timed('canonical-before', oldReader));
+currentReader(target, true);
+results.push(await timed('canonical-warm-after', () => currentReader(target, true)));
+results.push(await timed('headless-render-yield-after', () => yieldToRenderer()));
+// An independent queued session callback shares the SAME event loop with the
+// heavy operation. Its delay attributes interference directly to this batch,
+// unlike a live daemon's unrelated maximum event-loop observation.
+for (const [name, action] of [
+    ['shared-loop-before', () => { messages.forEach(m => legacyTokenFloors(m.content)); oldReader(); }],
+    ['shared-loop-after', () => { messages.forEach(m => currentFloors(m.content)); currentReader(target, true); }],
+]) {
+    results.push(await timed(name, async () => {
+        const otherSession = immediate();
+        action();
+        await otherSession;
+    }));
+}
+const report = { bytes: Buffer.byteLength(raw), messageCount: messages.length, directory, results,
+    limits: 'Synthetic same-event-loop contention, not attribution of the prior live 502ms event.' };
+writeFileSync(join(directory, 'report.json'), JSON.stringify(report, null, 2));
+console.log(JSON.stringify(report, null, 2));

package/scripts/release-paths.mjs

@@ -28,48 +28,22 @@ export const DESKTOP_GATE_SCRIPT_BASES = [
   'scripts/runtime-dependency-cache-key',
 ];
 
-// Prefixes whose changes require the runtime gate (the release-critical lane
-// plus the tool-contract suites the gate also executes).
+// Prefixes whose changes require the runtime gate. The gate runs the
+// discovered default lane (scripts/test.mjs: every test file under src/ and
+// scripts/), so any change under those roots is a candidate.
 export const RUNTIME_GATE_PREFIXES = [
   '.github/workflows/',
   'native/',
-  'scripts/tool-contracts/',
-  'src/runtime/agent/orchestrator/',
-  'src/runtime/shared/',
+  'scripts/',
+  'src/',
 ];
 
-// Everything `npm run test:release-critical` executes
-// (test:release-assets + smoke:patch + test:providers).
-export const RELEASE_CRITICAL_SCRIPTS = [
-  'scripts/verify-release-assets.mjs',
-  'scripts/release-gate-test.mjs',
-  'scripts/prepare-native-assets.mjs',
-  'scripts/prepare-native-assets-test.mjs',
-  'scripts/generate-voice-runtime-manifest.mjs',
-  'scripts/generate-voice-runtime-manifest.test.mjs',
-  'scripts/apply-patch-edit-smoke.mjs',
-  'scripts/provider-contract-test.mjs',
-  'scripts/provider-stream-outcome-test.mjs',
-  'scripts/cursor-provider-test.mjs',
-];
-
-// Directory-shaped suites the critical lane executes (test:providers runs
-// scripts/provider-toolcall/*.test.mjs): deploy consumes these as git
-// pathspecs, the gate regex as path prefixes.
-export const RELEASE_CRITICAL_SUITE_DIRS = ['scripts/provider-toolcall'];
-
-// Gate-only suite files the runtime job executes beyond the critical lane
-// (test:compact); editing one must re-run the gate that executes it.
-export const RUNTIME_GATE_SUITE_FILES = ['scripts/suite-compact-test.mjs'];
-
 // deploy.yml plan: paths whose change since the published release tag marks
-// the critical lane as unverified.
+// the default lane as unverified.
 export const RELEASE_CRITICAL_PATHS = [
   'native',
-  'src/runtime/agent/orchestrator',
-  'src/runtime/shared',
-  ...RELEASE_CRITICAL_SCRIPTS,
-  ...RELEASE_CRITICAL_SUITE_DIRS,
+  'scripts',
+  'src',
   ...PACKAGE_MANIFESTS,
 ];
 
@@ -87,10 +61,6 @@ export function desktopGateRegex() {
 export function runtimeGateRegex() {
   return `^(${[
     ...RUNTIME_GATE_PREFIXES.map(escapeRegex),
-    ...RELEASE_CRITICAL_SCRIPTS.map((file) => `${escapeRegex(file)}$`),
-    ...RELEASE_CRITICAL_SUITE_DIRS.map((dir) => `${escapeRegex(dir)}/`),
-    ...RUNTIME_GATE_SUITE_FILES.map((file) => `${escapeRegex(file)}$`),
-    ...DESKTOP_GATE_SCRIPT_BASES.map((base) => `${escapeRegex(base)}(\\.test)?\\.mjs$`),
     ...PACKAGE_MANIFESTS.map((file) => `${escapeRegex(file)}$`),
     ...GATE_SELECTION_SOURCES.map((file) => `${escapeRegex(file)}$`),
   ].join('|')})`;

package/scripts/run-advisory-spec.mjs

@@ -0,0 +1,6 @@
+// Mutable product and workflow specifications are reviewed explicitly and do
+// not participate in blocking invariant gates.
+process.env.MIXDOG_TEST_ADVISORY = '1';
+
+await import('./release-gate-test.mjs');
+await import('./runtime-turn-contract-test.mjs');

package/scripts/run-office-live-tests.mjs

@@ -1,28 +1,61 @@
-import { spawnSync } from 'node:child_process';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { buildLiveTestPlan, liveTestHelp } from './office-live-test-plan.mjs';
 
-const defaultTestPath = fileURLToPath(new URL('../src/runtime/office/office-live-runtime.test.mjs', import.meta.url));
-const testPath = process.argv[2] ? resolve(process.argv[2]) : defaultTestPath;
-const child = spawnSync(process.execPath, ['--test', testPath], {
+let plan;
+try {
+  plan = buildLiveTestPlan(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(`${error.message}\n${liveTestHelp}`);
+  process.exit(1);
+}
+if (!plan) {
+  process.stdout.write(liveTestHelp);
+  process.exit(0);
+}
+process.stdout.write(`Office 라이브 검증 시작 — ${plan.label}\n`);
+const child = spawn(process.execPath, plan.args, {
   cwd: process.cwd(),
   env: {
     ...process.env,
     MIXDOG_TEST_LIVE_OFFICE: '1',
   },
   stdio: ['inherit', 'pipe', 'pipe'],
-  encoding: 'utf8',
-  maxBuffer: 16 * 1024 * 1024,
   windowsHide: true,
 });
-const tapFailurePattern = /(?:^|[\r\n])not ok \d+ -|(?:^|[\r\n])# fail [1-9]\d*(?:[\r\n]|$)/m;
-const stdout = child.stdout || '';
-const stderr = child.stderr || '';
-process.stdout.write(stdout);
-process.stderr.write(stderr);
-if (child.error) {
-  process.stderr.write(`${child.error?.stack || child.error}\n`);
-  process.exit(1);
+let tapFailed = false;
+let emptySelection = false;
+// Forward chunks immediately; retain only a bounded line prefix for TAP status,
+// not the potentially large Office snapshots printed in assertion failures.
+for (const [source, destination] of [[child.stdout, process.stdout], [child.stderr, process.stderr]]) {
+  source.setEncoding('utf8');
+  let prefix = '';
+  const inspect = () => {
+    if (/^(?:not ok \d+ -|# fail [1-9]\d*)/u.test(prefix)) tapFailed = true;
+    // Node can wrap a filtered-out file as one passing file test after a
+    // top-level empty TAP plan, so "# tests" alone is not sufficient.
+    if (/^(?:# tests 0\s*$|1\.\.0(?:\s|$))/u.test(prefix)) emptySelection = true;
+  };
+  source.on('data', (chunk) => {
+    if (!destination.write(chunk)) {
+      source.pause();
+      destination.once('drain', () => source.resume());
+    }
+    const lines = chunk.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+      prefix = (prefix + lines[i]).slice(0, 1024);
+      if (i < lines.length - 1) {
+        inspect();
+        prefix = '';
+      }
+    }
+  });
+  source.on('end', inspect);
 }
-const tapFailed = tapFailurePattern.test(`${stdout}\n${stderr}`);
-process.exit(tapFailed ? 1 : Number.isInteger(child.status) ? child.status : 1);
+child.on('error', (error) => {
+  process.stderr.write(`${error.stack || error}\n`);
+  process.exitCode = 1;
+});
+child.on('close', (code) => {
+  if (emptySelection) process.stderr.write('선택한 범위에 실행할 테스트가 없습니다.\n');
+  process.exitCode = tapFailed || emptySelection ? 1 : Number.isInteger(code) ? code : 1;
+});

package/scripts/suite-health.mjs

@@ -16,8 +16,6 @@ export const WORKSPACES = [
       'smoke:loop': 'long-running local endurance harness',
       'smoke:loop:final': 'endurance-harness gate, needs hours of loop data',
       'smoke:loop:report': 'report reader, not a suite',
-      'test:release-critical': 'aggregate; the release gate owns it',
-      'test:quick': 'aggregate; its components run individually',
       'test:office:live': 'drives real Office COM on a desktop machine',
       'test:embedding-runtime:warmup': 'downloads the embedding runtime',
       'test:spec-advisory': 'advisory by design (MIXDOG_TEST_ADVISORY)',
@@ -26,9 +24,9 @@ export const WORKSPACES = [
   {
     dir: 'apps/desktop',
     exclusions: {
-      'test:renderer:full': 'aggregate; its components run individually',
-      'test:fast-direct': 'dev-only deploy tool; real deploys are its verification',
-      'test:office-approval': 'runs through the root test:office chain',
+      'test:all': 'aggregate of the fast, slow, and live lanes',
+      'test:live': 'needs built artifacts; the packaging workflow owns it',
+      'test:daemon:e2e': 'needs the built daemon; the release gate desktop job owns it',
       'test:spec-advisory': 'advisory by design (MIXDOG_TEST_ADVISORY)',
       'test:browser-host:integration': 'live desktop integration harness',
       'test:browser-profile-import:integration': 'live desktop integration harness',

package/scripts/test.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// Discovery-based test entry (docs/testing.md). A test file joins the suite
+// by existing; its lane comes from its name, never from a hand-kept list:
+//
+//   *.test.mjs        fast   the default lane; every push, every local run
+//   *.slow.test.mjs   slow   files over ~10s; their own CI job
+//   *.live.test.mjs   live   need a built artifact or a live system
+//
+// Usage: node scripts/test.mjs [--lane fast|slow|live|all] [--list]
+//                              [--import <spec>]... [--test-*]... [filter...]
+//   filter   substring of a file path; only matching files run.
+//   --import forwarded to node (desktop passes its test-env and tsx loaders).
+//   --test-* forwarded to node --test (e.g. --test-name-pattern, --test-only).
+//
+// Runs from the package that invokes it: `src/` and `scripts/` under cwd are
+// the roots, so the root package and apps/desktop share this one entry.
+import { spawn } from 'node:child_process';
+import { glob } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOTS = ['src', 'scripts'];
+const PATTERNS = ['**/*.test.mjs', '**/*-test.mjs'];
+const EXCLUDED_DIRS = new Set(['node_modules', '.runtime', 'out', 'dist', 'target']);
+// A file URL: node resolves reporter specifiers through the ESM loader, which
+// rejects a bare Windows drive path as an unknown "c:" scheme.
+const REPORTER = pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), 'lib', 'test-timing-reporter.mjs')).href;
+
+export function laneOf(file) {
+  if (/\.live\.test\.mjs$/.test(file)) return 'live';
+  if (/\.slow\.test\.mjs$/.test(file)) return 'slow';
+  return 'fast';
+}
+
+export function parseArgs(argv) {
+  const options = { lane: 'fast', list: false, nodeArgs: [], filters: [] };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === '--lane') options.lane = argv[++index];
+    else if (arg.startsWith('--lane=')) options.lane = arg.slice('--lane='.length);
+    else if (arg === '--list') options.list = true;
+    else if (arg === '--import') options.nodeArgs.push(arg, argv[++index]);
+    else if (arg.startsWith('--import=') || arg.startsWith('--test-')) options.nodeArgs.push(arg);
+    else options.filters.push(arg.replaceAll('\\', '/'));
+  }
+  if (!['fast', 'slow', 'live', 'all'].includes(options.lane)) {
+    throw new Error(`unknown lane "${options.lane}" (fast|slow|live|all)`);
+  }
+  return options;
+}
+
+export async function discoverTestFiles(cwd = process.cwd()) {
+  const files = new Set();
+  for (const root of ROOTS) {
+    for (const pattern of PATTERNS) {
+      for await (const entry of glob(`${root}/${pattern}`, {
+        cwd,
+        exclude: (path) => String(path).split(/[\\/]/).some((segment) => EXCLUDED_DIRS.has(segment)),
+      })) files.add(entry.replaceAll('\\', '/'));
+    }
+  }
+  return [...files].sort();
+}
+
+export function selectTestFiles(files, { lane, filters }) {
+  return files
+    .filter((file) => lane === 'all' || laneOf(file) === lane)
+    .filter((file) => filters.length === 0 || filters.some((filter) => file.includes(filter)));
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const files = selectTestFiles(await discoverTestFiles(), options);
+  if (options.list) {
+    for (const file of files) console.log(`${laneOf(file).padEnd(5)} ${file}`);
+    return;
+  }
+  if (files.length === 0) {
+    console.error(`no ${options.lane} test files match ${options.filters.join(' ') || '(everything)'}`);
+    process.exitCode = 1;
+    return;
+  }
+  const args = [
+    ...options.nodeArgs,
+    '--test',
+    // A suite that leaves a handle open (a session runtime closed without
+    // waiting for its children) must not hang the whole run.
+    '--test-force-exit',
+    '--test-reporter=spec', '--test-reporter-destination=stdout',
+    `--test-reporter=${REPORTER}`, '--test-reporter-destination=stderr',
+    ...files,
+  ];
+  const child = spawn(process.execPath, args, { stdio: 'inherit' });
+  child.on('exit', (code, signal) => {
+    process.exitCode = code ?? (signal ? 1 : 0);
+  });
+}
+
+const invoked = process.argv[1] ? resolve(process.argv[1]) : '';
+if (invoked === fileURLToPath(import.meta.url)) await main();

package/scripts/tui-frame-harness-shim.mjs

@@ -1,4 +1,4 @@
-// Mirror of vendor/ink/build/ink.js shouldClearTerminalForFrame, with the
+// Mirror of patched Ink's shouldClearTerminalForFrame, with the
 // Windows branch parameterized so the harness can probe both platforms without
 // relying on process.platform. Kept byte-faithful to the source predicate so
 // the harness reflects real clear decisions.

package/scripts/tui-frame-harness.mjs

@@ -2,7 +2,7 @@
 /**
  * scripts/tui-frame-harness.mjs — renderer-level frame-grid evidence harness.
  *
- * Drives vendor/ink log-update createIncremental(fakeStream) through the SAME
+ * Drives patched Ink log-update createIncremental(fakeStream) through the SAME
  * wrapper logic ink.js renderInteractiveFrame() applies (fullscreen detect +
  * trailing-newline normalization + shouldClearTerminalForFrame), replays the
  * emitted ANSI into a minimal VT grid interpreter, and asserts the absolute row
@@ -13,12 +13,17 @@
  *
  * Run: node scripts/tui-frame-harness.mjs
  */
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
 // [harness] log-update reads process.platform/WT_SESSION AT IMPORT to pick its
 // Windows-safe absolute-cursor branch. Force WT_SESSION on BEFORE importing it
 // so POSIX/CI runs exercise the same branch WT users hit. Must precede the
 // dynamic import below.
 process.env.WT_SESSION = process.env.WT_SESSION || '1';
-const { default: logUpdate } = await import('../vendor/ink/build/log-update.js');
+const inkBuildDir = dirname(fileURLToPath(import.meta.resolve('ink')));
+const logUpdateUrl = pathToFileURL(join(inkBuildDir, 'log-update.js')).href;
+const { default: logUpdate } = await import(logUpdateUrl);
 const { shouldClearTerminalForFrameProbe } = await import('./tui-frame-harness-shim.mjs');
 const { default: ansiEscapes } = await import('ansi-escapes');
 

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

@@ -8,16 +8,6 @@ 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,
-    }));
-  },
-};
-
 try {
   await build({
     entryPoints: [entry],
@@ -28,7 +18,6 @@ try {
     target: 'node22',
     jsx: 'automatic',
     packages: 'external',
-    plugins: [inkAlias],
     banner: {
       js: "import { createRequire as __mixdogCreateRequire } from 'node:module';\nconst require = __mixdogCreateRequire(import.meta.url);",
     },