mixdog 0.9.160 → 0.9.161

package/README.md

@@ -259,7 +259,9 @@ npm start
 
 npm run smoke
 npm run smoke:all
-npm run test:tool-contracts
+npm test                      # every *.test.mjs under src/ and scripts/
+npm test -- src/runtime/memory  # one directory
+npm run test:slow             # *.slow.test.mjs
 npm run build:tui
 npm run audit:models
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.160",
+  "version": "0.9.161",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -53,6 +53,9 @@
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
+    "test": "node scripts/test.mjs",
+    "test:slow": "node scripts/test.mjs --lane slow",
+    "test:live": "node scripts/test.mjs --lane live",
     "smoke": "node scripts/smoke.mjs",
     "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:patch && npm run smoke:compact",
     "smoke:boot": "node scripts/boot-smoke.mjs",
@@ -75,8 +78,15 @@
     "test:session-transport": "node --test \"scripts/session-transport/*.test.mjs\" scripts/daemon-bootstrap-test.mjs src/runtime/shared/child-spawn-remote.test.mjs src/standalone/session-runtime-agent-control-client.test.mjs src/standalone/session-runtime-dispatch-cancel.test.mjs src/standalone/session-runtime-host-factory.test.mjs src/standalone/session-runtime-inline-host.test.mjs src/standalone/session-runtime-provider-cooldown.test.mjs src/standalone/session-runtime-shard-host.test.mjs src/standalone/session-runtime-shard-router.test.mjs",
     "test:session": "node --test scripts/runtime-turn-contract-test.mjs scripts/session-save-fault-store-test.mjs scripts/turn-review-revert-test.mjs src/runtime/shared/tool-surface.test.mjs src/runtime/bridge-clients.test.mjs src/runtime/computer-bridge/client-semantic-error.test.mjs src/runtime/agent/orchestrator/session/tool-envelope.test.mjs src/runtime/agent/orchestrator/session/eager-dispatch.test.mjs",
     "test:quick": "npm run test:session && npm run test:session-transport && npm run test:desktop-main --prefix apps/desktop",
-    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime-contract.test.mjs src/runtime/office/office-runtime-com.test.mjs src/runtime/office/office-runtime-portable.test.mjs src/runtime/office/office-runtime-pdf.test.mjs src/runtime/office/office-runtime-design.test.mjs src/runtime/office/office-freeform-pipeline.test.mjs src/runtime/office/office-assurance.test.mjs src/runtime/office/office-design-aesthetics.test.mjs src/runtime/office/portable-authoring.test.mjs src/runtime/office/slide-quality.test.mjs && npm run test:office-approval --prefix apps/desktop",
+    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime-contract.test.mjs src/runtime/office/office-runtime-com.test.mjs src/runtime/office/office-runtime-portable.test.mjs src/runtime/office/xlsx-formula-audit.test.mjs src/runtime/office/xlsx-portable-snapshot.test.mjs src/runtime/office/office-runtime-pdf.test.mjs src/runtime/office/office-runtime-design.test.mjs src/runtime/office/office-assurance.test.mjs src/runtime/office/office-design-aesthetics.test.mjs src/runtime/office/portable-authoring.test.mjs src/runtime/office/slide-quality.test.mjs src/runtime/office/authoring/pptx-brief.test.mjs src/runtime/office/authoring/pptx-receipt.test.mjs src/runtime/office/quality/render-air.test.mjs src/runtime/office/quality/pptx-deck-rubric.test.mjs && npm run test:office-approval --prefix apps/desktop",
     "test:office:live": "node scripts/run-office-live-tests.mjs",
+    "test:office:preview": "node --test src/runtime/office/office-render-preview.test.mjs",
+    "test:office:review": "node --test src/runtime/office/pptx-independent-review.test.mjs src/runtime/office/pptx-chart-styling.test.mjs",
+    "test:office:cleanup": "node --test src/runtime/office/com/office-cleanup.test.mjs src/runtime/office/office-runtime-com.test.mjs",
+    "test:office:compat": "node scripts/run-office-live-tests.mjs compat",
+    "test:office:live:all": "node scripts/run-office-live-tests.mjs all",
+    "test:office:render": "node --test src/runtime/office/pptx-skill-kit.slow.test.mjs",
+    "office:icons": "node scripts/office/build-pptx-icons.mjs",
     "test:media": "node --test src/runtime/media/store.test.mjs src/runtime/media/renditions.test.mjs src/runtime/media/adapters/codex-image.test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
@@ -84,8 +94,8 @@
     "bench:office:contract": "node src/runtime/office/bench/contract-benchmark.mjs",
     "bench:office:assurance": "node src/runtime/office/bench/assurance-benchmark.mjs",
     "bench:office:polish": "node src/runtime/office/bench/polish-benchmark.mjs",
+    "bench:office:deck": "node src/runtime/office/bench/deck-bench.mjs",
     "bench:office:quality:live": "node src/runtime/office/bench/quality-live-benchmark.mjs",
-    "bench:office:freeform:live": "node src/runtime/office/bench/freeform-live-benchmark.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",
     "diag:tools": "node scripts/tool-efficiency-diag.mjs",
     "diag:sweep": "node scripts/session-sweep.mjs",
@@ -149,6 +159,7 @@
     "pdf-lib": "^1.17.1",
     "pdfjs-dist": "^6.2.108",
     "pg": "^8.22.0",
+    "pptxgenjs": "^4.0.1",
     "puppeteer-core": "^25.2.0",
     "react": "^19.2.7",
     "sharp": "^0.35.3",
@@ -172,10 +183,8 @@
   "devDependencies": {
     "acorn": "^8.17.0",
     "esbuild": "^0.28.1",
-    "eslint-scope": "^9.1.2"
-  },
-  "optionalDependencies": {
-    "@vscode/ripgrep": "^1.18.0"
+    "eslint-scope": "^9.1.2",
+    "lucide-static": "^1.41.0"
   },
   "main": "index.js",
   "directories": {

package/scripts/lib/local-provider-live-scenarios.mjs

@@ -0,0 +1,22 @@
+export async function completeToolConversation({ send, messages, tools, executeTool, maxSteps = 8 }) {
+  const transcript = [...messages];
+  for (let step = 0; step < maxSteps; step++) {
+    const result = await send(transcript, tools);
+    if (result.truncated) throw new Error(`Tool conversation was truncated: ${JSON.stringify(result).slice(0, 2000)}`);
+    if (!result.toolCalls?.length) return { result, toolSteps: step };
+    transcript.push({ role: 'assistant', content: result.content,
+      toolCalls: result.toolCalls, reasoningContent: result.reasoningContent });
+    for (const tool of result.toolCalls) {
+      transcript.push({ role: 'tool', toolCallId: tool.id, content: await executeTool(tool) });
+    }
+  }
+  throw new Error(`Tool conversation exceeded its ${maxSteps}-step bound`);
+}
+
+export function assertResponseContains(result, expected) {
+  if (typeof result?.content !== 'string' || !result.content.includes(expected)) {
+    throw new Error(`Model response did not include ${JSON.stringify(expected)}: ${JSON.stringify({
+      content: result?.content, toolCalls: result?.toolCalls, stopReason: result?.stopReason, truncated: result?.truncated,
+    }).slice(0, 3000)}`);
+  }
+}

package/scripts/lib/test-timing-reporter.mjs

@@ -0,0 +1,38 @@
+// Secondary node:test reporter: per-file wall time, slowest files first.
+// Runs beside the spec reporter (scripts/test.mjs) so a slow default lane
+// always names its cause instead of hiding it inside one total. A file over
+// SLOW_HINT_MS belongs in the slow lane (rename to *.slow.test.mjs).
+import { relative } from 'node:path';
+
+const SLOW_HINT_MS = 10_000;
+const TOP = 8;
+
+// Each test file runs in its own process; its top-level tests arrive as
+// nesting-0 events tagged with the file, so a file's time is the sum of its
+// top-level test durations (module load excluded).
+export default async function* timingReporter(source) {
+  const byFile = new Map();
+  for await (const event of source) {
+    if (event.type !== 'test:pass' && event.type !== 'test:fail') continue;
+    if (event.data.nesting !== 0 || !event.data.file) continue;
+    const file = relative(process.cwd(), String(event.data.file)).replaceAll('\\', '/');
+    const entry = byFile.get(file) ?? { file, ms: 0, failed: false };
+    entry.ms += Number(event.data.details?.duration_ms) || 0;
+    entry.failed ||= event.type === 'test:fail';
+    byFile.set(file, entry);
+  }
+  const files = [...byFile.values()];
+  if (files.length === 0) return;
+  files.sort((a, b) => b.ms - a.ms);
+  const total = files.reduce((sum, entry) => sum + entry.ms, 0);
+  const lines = [
+    '',
+    `slowest files (${files.length} files, ${(total / 1000).toFixed(1)}s file-time):`,
+    ...files.slice(0, TOP).map((entry) => `  ${String(Math.round(entry.ms)).padStart(7)}ms  ${entry.file}${entry.failed ? '  (failed)' : ''}`),
+  ];
+  const slow = files.filter((entry) => entry.ms >= SLOW_HINT_MS && !/\.(?:slow|live)\.test\.mjs$/.test(entry.file));
+  if (slow.length) {
+    lines.push(`  ${slow.length} file(s) over ${SLOW_HINT_MS / 1000}s in the default lane; rename to *.slow.test.mjs to move them out.`);
+  }
+  yield `${lines.join('\n')}\n`;
+}

package/scripts/local-provider-live-check.mjs

@@ -0,0 +1,141 @@
+// Explicit live acceptance runner. It uses an existing owner process only:
+// no server launch, unload, app restart, download, or real tool side effects.
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { MixdogLocalProvider } from '../src/runtime/agent/orchestrator/providers/mixdog-local.mjs';
+import { recordLocalModelLoad, localModelState } from '../src/runtime/local-provider/model-state.mjs';
+import { completeToolConversation, assertResponseContains } from './lib/local-provider-live-scenarios.mjs';
+
+const flags = Object.fromEntries(process.argv.slice(2).map((arg) => {
+  const [key, ...rest] = arg.replace(/^--/, '').split('=');
+  return [key, rest.join('=')];
+}));
+const pid = Number(flags.pid);
+const durationSeconds = Number(flags.seconds || 600);
+const targetCycles = flags.cycles ? Number(flags.cycles) : null;
+const selectedCase = flags.case || null;
+const cases = ['long-context', 'multi-turn', 'tool-roundtrip', 'concurrent-queue', 'cancel-and-recover'];
+if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(durationSeconds) || durationSeconds < 600
+    || (targetCycles !== null && (!Number.isInteger(targetCycles) || targetCycles < 1 || targetCycles > 100))
+    || (selectedCase && !cases.includes(selectedCase))) {
+  throw new Error('Explicit --pid and --seconds>=600 are required; optional --cycles=1..100 and --case select a bounded follow-up.');
+}
+const reportPath = resolve(flags.report || '.runtime/local-provider-live/report.json');
+const exec = promisify(execFile);
+const { stdout } = await exec('powershell', ['-NoProfile', '-NonInteractive', '-Command',
+  `(Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}').CommandLine`], { windowsHide: true, maxBuffer: 128 * 1024 });
+const line = stdout.trim();
+if (!/llama-server\.exe/i.test(line)) throw new Error('The supplied process is not llama-server.');
+const argument = (name) => {
+  const match = new RegExp(`--${name}\\s+(?:"([^"]+)"|(\\S+))`).exec(line);
+  return match?.[1] || match?.[2] || '';
+};
+const port = Number(argument('port')), apiKey = argument('api-key'), model = argument('alias');
+if (!Number.isInteger(port) || !apiKey || !model) throw new Error('Required local server arguments are unavailable.');
+const baseURL = `http://127.0.0.1:${port}/v1`;
+const headers = { Authorization: `Bearer ${apiKey}` };
+const propsResponse = await fetch(`http://127.0.0.1:${port}/props`, { headers, signal: AbortSignal.timeout(10_000) });
+if (!propsResponse.ok) throw new Error(`Local props HTTP ${propsResponse.status}`);
+recordLocalModelLoad(model, await propsResponse.json(), null);
+const provider = new MixdogLocalProvider({}, { ensureServer: async () => ({ baseURL, apiKey }) });
+const report = { startedAt: new Date().toISOString(), pid, model, durationSeconds, targetCycles, selectedCase, busySkips: 0, cases: [], failures: [] };
+const started = Date.now();
+const persist = () => {
+  mkdirSync(dirname(reportPath), { recursive: true });
+  writeFileSync(reportPath, JSON.stringify(report, null, 2) + '\n');
+};
+const send = (messages, tools = [], options = {}) => provider.send(messages, model, tools, {
+  maxOutputTokens: 2048, ...options,
+  signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(120_000)]) : AbortSignal.timeout(120_000),
+});
+async function check(name, action) {
+  if (selectedCase && name.replace(/-\d+$/, '') !== selectedCase) return;
+  const at = Date.now();
+  try {
+    const detail = await action();
+    report.cases.push({ name, ok: true, elapsedMs: Date.now() - at, metrics: localModelState(model).inference, detail });
+    console.log(`PASS ${name} ${Date.now() - at}ms`);
+  } catch (error) {
+    const failure = { name, elapsedMs: Date.now() - at, error: String(error?.message || error) };
+    report.failures.push(failure);
+    console.log(`FAIL ${name}: ${failure.error}`);
+  }
+  persist();
+}
+let cycle = 0;
+try {
+while (targetCycles !== null ? cycle < targetCycles : Date.now() - started < durationSeconds * 1000 || cycle < 2) {
+  if (Date.now() - started > (durationSeconds + 600) * 1000) throw new Error('Live acceptance exceeded its bounded completion window.');
+  const slotsResponse = await fetch(`http://127.0.0.1:${port}/slots`, { headers, signal: AbortSignal.timeout(10_000) });
+  if (!slotsResponse.ok) throw new Error(`Cannot establish server idleness: HTTP ${slotsResponse.status}`);
+  const slots = await slotsResponse.json();
+  if (!Array.isArray(slots)) throw new Error('Invalid server slots response');
+  if (slots.some((slot) => slot.is_processing)) { report.busySkips++; await delay(2000); continue; }
+  cycle++;
+  await check(`long-context-${cycle}`, async () => {
+    const records = Array.from({ length: 768 }, (_, index) => `Record ${index}: stored value is entry-${index}-copper.`);
+    const result = await send([{ role: 'user', content: `${records.join('\n')}\nWhat is the exact stored value of Record 731? Reply with that value only.` }]);
+    assert.ok(result.content.includes('entry-731-copper'));
+  });
+  await check(`multi-turn-${cycle}`, async () => {
+    const marker = `marker-${cycle}-amber`;
+    const messages = [{ role: 'system', content: 'Answer concisely and accurately.' },
+      { role: 'system', content: 'This conversation uses short factual answers.' },
+      { role: 'user', content: `Remember this marker for the next question: ${marker}. Briefly acknowledge it.` }];
+    const first = await send(messages);
+    assert.ok(first.content);
+    messages.push({ role: 'assistant', content: first.content, reasoningContent: first.reasoningContent });
+    messages.push({ role: 'user', content: 'What was the exact marker? Reply with the marker only.' });
+    assert.ok((await send(messages)).content.includes(marker));
+  });
+  await check(`tool-roundtrip-${cycle}`, async () => {
+    const tools = [{ name: 'read_probe_value', description: 'Read the current test value for a named field.',
+      inputSchema: { type: 'object', properties: { field: { type: 'string', enum: ['marker'] } }, required: ['field'], additionalProperties: false } }];
+    const messages = [{ role: 'user', content: 'Use read_probe_value to read the marker field. Then tell me its returned value.' }];
+    const completed = await completeToolConversation({ send, messages, tools, executeTool: async (tool) => {
+      assert.equal(tool.name, 'read_probe_value');
+      assert.equal(tool.arguments.field, 'marker');
+      return `probe-value-${cycle}`;
+    } });
+    assert.ok(completed.toolSteps > 0, `Model did not use the offered tool: ${JSON.stringify(completed.result).slice(0, 2000)}`);
+    assertResponseContains(completed.result, `probe-value-${cycle}`);
+    return { toolSteps: completed.toolSteps };
+  });
+  await check(`concurrent-queue-${cycle}`, async () => {
+    const results = await Promise.all([
+      send([{ role: 'user', content: 'What is 7 plus 8? Reply with just the result.' }]),
+      send([{ role: 'user', content: 'What is 12 minus 5? Reply with just the result.' }]),
+    ]);
+    assert.match(results[0].content, /15/);
+    assert.match(results[1].content, /7/);
+  });
+  await check(`cancel-and-recover-${cycle}`, async () => {
+    const controller = new AbortController();
+    let emitted = false;
+    await assert.rejects(send([{ role: 'user', content: 'Explain the tradeoffs between caching, memory consumption, and request scheduling in a local inference server.' }], [], {
+      signal: controller.signal,
+      onStreamDelta(kind) {
+        if (kind !== 'transport' && !emitted) { emitted = true; controller.abort(new Error('live check cancellation')); }
+      },
+    }));
+    assert.equal(emitted, true);
+    const recovered = await send([{ role: 'user', content: 'Reply with exactly RECOVERED.' }]);
+    assert.match(recovered.content, /RECOVERED/);
+  });
+}
+} catch (error) {
+  report.failures.push({ name: 'runner', error: String(error?.message || error) });
+}
+report.finishedAt = new Date().toISOString();
+report.elapsedMs = Date.now() - started;
+report.cycles = cycle;
+report.passed = report.failures.length === 0 && cycle >= (targetCycles || 2);
+report.scope = 'Existing model process; long-running multi-turn/tool/queue/cancel recovery. No OS sleep, app restart, model reload or new model installation.';
+persist();
+console.log(JSON.stringify({ reportPath, passed: report.passed, cycles: cycle, elapsedMs: report.elapsedMs,
+  failures: report.failures.length, maxToolSteps: Math.max(0, ...report.cases.map((entry) => entry.detail?.toolSteps || 0)) }));
+if (!report.passed) process.exitCode = 1;

package/scripts/office/aesthetics-probe.mjs

@@ -0,0 +1,59 @@
+// Stage a rendered deck for SlidesGen-Bench's aesthetics metrics (refs/slidesgen-bench/eval/aesthetics_metrics.py):
+//   node scripts/office/aesthetics-probe.mjs <deck.pptx> <page-image-prefix> <out-dir>
+// Copies <prefix>-page-N.png into <out-dir>/slide_images/slide_000N.png and writes the deck's own text-box geometry
+// into <out-dir>/detection/slide_000N.json in the benchmark's layout-detection format ({ boxes: [{ label, coordinate }] }),
+// so the figure-ground contrast (Usability) metric reads text regions from the file the way the benchmark reads its
+// PaddleOCR output — the geometry comes from the saved deck, not from a detector. Then:
+//   python eval/aesthetics_metrics.py <out-dir>/slide_images --compute-score --config eval/aesthetics_config.json --no-parallel -o <result.json>
+import { copyFile, mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import sharp from 'sharp';
+import { snapshotPortableOoxml } from '../../src/runtime/office/portable/portable-snapshot.mjs';
+import { measureTextBlock } from '../../src/runtime/office/portable/text-metrics.mjs';
+
+// A detector's box hugs the glyphs; a kit box is often wider than its text (a kicker in a 6 in box, a source line,
+// a hero label). Width is tightened to the measured text so the contrast reads the type, not the empty paper beside
+// it; height is kept, since the snapshot does not say where in the box the text is anchored.
+function tightWidth(shape) {
+  if (shape.table) return shape.width;
+  const size = Number(shape.font?.size) || 18;
+  const measured = measureTextBlock([{ text: String(shape.text), fontName: shape.font?.name || 'Noto Sans KR', fontSize: size, bold: Boolean(shape.font?.bold) }], { width: shape.width });
+  return Math.min(shape.width, Math.max(size, measured.width + 4));
+}
+
+const [deck, prefix, out] = process.argv.slice(2);
+if (!deck || !prefix || !out) {
+  console.error('usage: node scripts/office/aesthetics-probe.mjs <deck.pptx> <page-image-prefix> <out-dir>');
+  process.exit(1);
+}
+const CANVAS = { width: 960, height: 540 };   // 13.33 × 7.5 in, in points — the snapshot's unit
+const snapshot = await snapshotPortableOoxml(resolve(deck), 'pptx', {});
+const slides = snapshot?.slides || snapshot?.document?.slides || [];
+if (!slides.length) throw new Error(`no slides read from ${deck}`);
+await mkdir(join(out, 'slide_images'), { recursive: true });
+await mkdir(join(out, 'detection'), { recursive: true });
+let total = 0;
+for (const slide of slides) {
+  const stem = `slide_${String(slide.index).padStart(4, '0')}`;
+  const source = `${prefix}-page-${slide.index}.png`;
+  const target = join(out, 'slide_images', `${stem}.png`);
+  await copyFile(source, target);
+  const { width, height } = await sharp(target).metadata();
+  const sx = width / CANVAS.width, sy = height / CANVAS.height;
+  // Text carriers only: text boxes and native tables. Charts draw their own labels; pictures and fields carry none.
+  const boxes = (slide.shapes || [])
+    .filter((shape) => String(shape.text || '').trim() && !shape.chart && [shape.left, shape.top, shape.width, shape.height].every(Number.isFinite))
+    .map((shape) => ({
+      label: 'text',
+      score: 1,
+      coordinate: [
+        Math.max(0, Math.round(shape.left * sx)), Math.max(0, Math.round(shape.top * sy)),
+        Math.min(width, Math.round((shape.left + tightWidth(shape)) * sx)), Math.min(height, Math.round((shape.top + shape.height) * sy)),
+      ],
+    }))
+    .filter((box) => box.coordinate[2] - box.coordinate[0] > 2 && box.coordinate[3] - box.coordinate[1] > 2);
+  await writeFile(join(out, 'detection', `${stem}.json`), JSON.stringify({ source: 'pptx-snapshot', image: `${stem}.png`, boxes }, null, 2));
+  total += boxes.length;
+  console.log(`${stem}: ${boxes.length} text regions (${width}×${height})`);
+}
+console.log(`${slides.length} pages staged under ${out} with ${total} text regions`);

package/scripts/office/author-deck.mjs

@@ -0,0 +1,56 @@
+// Author a deck from the working tree's office runtime (the installed app runs its own copy):
+//   node scripts/office/author-deck.mjs <script.js> <deck.pptx> [--mode portable|auto] [--render] [--critique critique.json] [--out result.json]
+// author (measured, no render) → qa → measured issues; --render adds the page images, contact sheet, receipt,
+// and reviewToken; --critique finalizes with the critique file (its reviewToken is filled from the render).
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { executeOfficeTool } from '../../src/runtime/office/index.mjs';
+import { isAdvisoryOfficeIssue } from '../../src/runtime/office/quality/quality-pipeline.mjs';
+
+const value = (result) => JSON.parse(result.content[0].text);
+const argv = process.argv.slice(2);
+const flag = (name) => { const at = argv.indexOf(name); return at >= 0 ? argv[at + 1] : null; };
+const positional = argv.filter((arg, index) => !arg.startsWith('--') && !(index > 0 && argv[index - 1].startsWith('--') && !['--render'].includes(argv[index - 1])));
+const [scriptPath, deckPath] = positional;
+if (!scriptPath || !deckPath) {
+  console.error('usage: node scripts/office/author-deck.mjs <script.js> <deck.pptx> [--mode portable|auto] [--render] [--critique critique.json] [--out result.json]');
+  process.exit(1);
+}
+const cwd = resolve('.');
+const script = await readFile(scriptPath, 'utf8');
+const mode = flag('--mode') || 'portable';
+const authored = value(await executeOfficeTool({ action: 'author', path: deckPath, script, mode, overwrite: true, render: false }, { cwd }));
+if (!authored.ok) {
+  console.error(`author failed: ${authored.error?.message}\n  line ${authored.error?.line}\n${authored.error?.excerpt || ''}`);
+  process.exit(2);
+}
+const session = authored.session;
+console.log(`authored ${deckPath} (${authored.backend}, kit ${authored.kit}, gradients ${authored.nativeGradients || 0}, ${authored.elapsedMs} ms)`);
+const qa = value(await executeOfficeTool({ action: 'qa', session, render: false }, { cwd }));
+const issues = (qa.issuesAfter || qa.issues || []);
+const measured = issues.filter((issue) => !isAdvisoryOfficeIssue(issue));
+console.log(`qa: ${measured.length} measured, ${issues.length - measured.length} advisory`);
+for (const issue of issues) console.log(`  ${measured.includes(issue) ? '!' : '·'} ${issue.code} ${issue.path || ''} ${issue.message || ''}`);
+const result = { deck: deckPath, session, authored: { kit: authored.kit, nativeGradients: authored.nativeGradients || 0, bytes: authored.bytes }, issues };
+if (argv.includes('--render') || flag('--critique')) {
+  const rendered = value(await executeOfficeTool({ action: 'render', session }, { cwd }));
+  result.render = { output: rendered.output, pageCount: rendered.pageCount, reviewToken: rendered.reviewToken, images: (rendered.images || []).map((image) => image.path), contactSheet: rendered.contactSheet?.path || rendered.contactSheet };
+  result.receipt = rendered.receipt;
+  console.log(`rendered ${rendered.pageCount} pages → ${rendered.output}`);
+  for (const image of rendered.images || []) console.log(`  page ${image.page}: ${image.path}`);
+  if (rendered.contactSheet?.path) console.log(`  contact sheet: ${rendered.contactSheet.path}`);
+  if (rendered.receipt?.deck?.rhythm) console.log(`  rhythm: ${JSON.stringify(rendered.receipt.deck.rhythm)}`);
+}
+const critiquePath = flag('--critique');
+if (critiquePath) {
+  const critique = JSON.parse(await readFile(critiquePath, 'utf8'));
+  const finalized = value(await executeOfficeTool({ action: 'finalize', session, design: { reviewed: true, reviewToken: result.render.reviewToken, critique } }, { cwd }));
+  result.finalize = finalized;
+  console.log(`finalize: ${finalized.ok ? 'ok' : 'blocked'} ${JSON.stringify(finalized.summary || finalized.reason || finalized.issues?.slice(0, 5) || '')}`);
+  if (!finalized.ok) for (const issue of finalized.issues || []) console.log(`  ! ${issue.code} ${issue.path || ''} ${issue.message || ''}`);
+} else {
+  await executeOfficeTool({ action: 'close', session, save: false }, { cwd }).catch(() => {});
+}
+const out = flag('--out');
+if (out) await writeFile(out, JSON.stringify(result, null, 2));
+process.exit(critiquePath && !result.finalize?.ok ? 3 : measured.length ? 4 : 0);

package/scripts/office/build-pptx-icons.mjs

@@ -0,0 +1,48 @@
+// Builds the offline icon set the pptx authoring runtime injects as ICON(name):
+// a curated subset of Lucide (ISC) read from the lucide-static dev dependency,
+// stored as the icons' inner SVG markup so the kit can render them at any color.
+//   node scripts/office/build-pptx-icons.mjs
+import { readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const root = dirname(require.resolve('lucide-static/package.json'));
+const { version, license } = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+const out = join(dirname(fileURLToPath(import.meta.url)), '../../src/runtime/office/authoring/pptx-icons.json');
+
+// One line per family so a reader can see what the deck can reach for. Names are Lucide's.
+export const ICON_NAMES = [
+  // direction and process
+  'arrow-right', 'arrow-left', 'arrow-up', 'arrow-down', 'arrow-up-right', 'arrow-down-right', 'move-right', 'chevron-right', 'chevrons-right', 'corner-down-right', 'repeat', 'refresh-cw', 'rotate-cw', 'route', 'workflow', 'git-branch', 'git-merge', 'git-fork', 'milestone', 'flag', 'goal', 'target', 'crosshair', 'compass', 'map', 'map-pin', 'navigation', 'footprints', 'play', 'pause', 'square', 'circle', 'timer', 'hourglass', 'clock', 'calendar', 'calendar-check', 'history',
+  // data and evidence
+  'bar-chart-3', 'bar-chart-4', 'chart-bar', 'chart-column', 'chart-line', 'chart-pie', 'chart-area', 'chart-scatter', 'chart-no-axes-combined', 'trending-up', 'trending-down', 'activity', 'gauge', 'percent', 'hash', 'sigma', 'table', 'table-2', 'database', 'server', 'hard-drive', 'file-text', 'file-check', 'file-search', 'file-bar-chart', 'clipboard-list', 'clipboard-check', 'list-checks', 'list-ordered', 'scale', 'ruler', 'binary', 'calculator',
+  // people and organisation
+  'user', 'users', 'user-check', 'user-plus', 'user-round', 'users-round', 'contact', 'building', 'building-2', 'factory', 'landmark', 'store', 'briefcase', 'handshake', 'crown', 'award', 'medal', 'trophy', 'graduation-cap', 'presentation', 'megaphone', 'speech', 'message-circle', 'message-square', 'messages-square', 'mail', 'phone', 'headphones', 'mic', 'vote', 'heart-handshake',
+  // money and value
+  'coins', 'banknote', 'wallet', 'credit-card', 'piggy-bank', 'receipt', 'shopping-cart', 'shopping-bag', 'tag', 'tags', 'ticket', 'badge-dollar-sign', 'circle-dollar-sign', 'dollar-sign', 'euro', 'landmark',
+  // technology and product
+  'cpu', 'microchip', 'circuit-board', 'bot', 'brain', 'brain-circuit', 'sparkles', 'wand-2', 'code', 'code-2', 'terminal', 'braces', 'bug', 'cloud', 'cloud-upload', 'cloud-download', 'wifi', 'radio', 'satellite', 'smartphone', 'tablet', 'laptop', 'monitor', 'tv', 'camera', 'image', 'video', 'layers', 'layout-grid', 'layout-dashboard', 'component', 'boxes', 'box', 'package', 'container', 'plug', 'zap', 'battery-charging', 'settings', 'settings-2', 'sliders-horizontal', 'wrench', 'hammer', 'cog', 'puzzle', 'blocks', 'link', 'unlink', 'globe', 'network', 'share-2',
+  // safety, status, judgement
+  'check', 'check-check', 'circle-check', 'circle-x', 'x', 'circle-alert', 'triangle-alert', 'octagon-alert', 'info', 'circle-help', 'shield', 'shield-check', 'shield-alert', 'lock', 'lock-open', 'key', 'key-round', 'eye', 'eye-off', 'fingerprint', 'scan', 'search', 'filter', 'thumbs-up', 'thumbs-down', 'star', 'heart', 'bookmark', 'bell', 'siren', 'life-buoy', 'ban', 'minus', 'plus', 'equal', 'lightbulb', 'flame', 'rocket', 'anchor', 'scale-3d',
+  // nature, place, matter
+  'sun', 'moon', 'cloud-rain', 'snowflake', 'wind', 'droplet', 'leaf', 'sprout', 'trees', 'mountain', 'waves', 'earth', 'recycle', 'thermometer', 'home', 'warehouse', 'truck', 'ship', 'plane', 'train-front', 'car', 'bike', 'fuel', 'utensils', 'coffee', 'pill', 'stethoscope', 'heart-pulse', 'syringe', 'dna', 'atom', 'flask-conical', 'microscope', 'book-open', 'library', 'pen-line', 'pencil', 'paintbrush', 'palette', 'scissors', 'shapes', 'type', 'quote', 'gem', 'gift', 'umbrella', 'infinity', 'orbit',
+];
+
+const icons = {};
+const missing = [];
+for (const name of [...new Set(ICON_NAMES)]) {
+  let svg;
+  try { svg = await readFile(join(root, 'icons', `${name}.svg`), 'utf8'); } catch { missing.push(name); continue; }
+  const inner = svg.replace(/<!--[\s\S]*?-->/g, '').replace(/^[\s\S]*?<svg\b[^>]*>/, '').replace(/<\/svg>\s*$/, '')
+    .replace(/\s+/g, ' ').replace(/> </g, '><').trim();
+  if (!inner) { missing.push(name); continue; }
+  icons[name] = inner;
+}
+if (missing.length) {
+  console.error(`missing in lucide-static ${version}: ${missing.join(', ')}`);
+  process.exit(1);
+}
+await writeFile(out, `${JSON.stringify({ source: 'lucide-static', version, license, viewBox: '0 0 24 24', stroke: true, icons }, null, 0)}\n`);
+console.log(`${Object.keys(icons).length} icons → ${out}`);

package/scripts/office-live-test-plan.mjs

@@ -0,0 +1,34 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const defaultTestPath = fileURLToPath(new URL('../src/runtime/office/office-live-runtime.test.mjs', import.meta.url));
+export const liveProfiles = Object.freeze(['excel', 'word', 'powerpoint', 'author', 'attach', 'contract', 'compat', 'all']);
+
+export const liveTestHelp = `실제 Office 검증은 실행 범위를 지정해 주세요.
+  npm run test:office:live -- <excel|word|powerpoint|author|attach|contract>
+  npm run test:office:compat     매크로·서식 9종 호환성 검증
+  npm run test:office:live:all   모든 라이브 검증
+  npm run test:office           Office를 실행하지 않는 일반 검증
+  npm run test:office:render    별도 렌더 검증
+기존 호출도 지원합니다: <테스트 파일> [테스트 이름 정규식]
+`;
+
+export function buildLiveTestPlan(argv, testPath = defaultTestPath) {
+  const [selector, namePattern, ...extra] = argv;
+  if (!selector || selector === '--help' || selector === '-h') return null;
+  if (extra.length) throw new Error('인자가 너무 많습니다.');
+  let pattern;
+  if (liveProfiles.includes(selector)) {
+    if (namePattern) throw new Error('기능 이름 뒤에는 추가 인자를 받지 않습니다.');
+    pattern = selector === 'all' ? null : `^\\[${selector}\\]`;
+  } else {
+    if (!/\.(?:mjs|cjs|js)$/u.test(selector)) throw new Error(`알 수 없는 검증 범위: ${selector}`);
+    testPath = resolve(selector);
+    pattern = namePattern || null;
+  }
+  if (pattern) new RegExp(pattern); // Reject malformed filters before starting a child.
+  return {
+    label: selector,
+    args: ['--test', '--test-reporter=tap', ...(pattern ? ['--test-name-pattern', pattern] : []), testPath],
+  };
+}

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 }));