@ttmg/cli 0.4.6-vibe-beta.7 → 0.4.6-vibe-beta.8

package/dist/scripts/dev-workflow-smoke.js

@@ -0,0 +1,260 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const entry = process.argv[2] ? path.resolve(process.argv[2]) : path.resolve(__dirname, '../dist/index.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-workflow-process-'));
+const game = path.join(root, 'game');
+fs.mkdirSync(game);
+fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round A");');
+fs.writeFileSync(path.join(game, 'game.json'), '{}');
+// Restarted projects contain previous evidence/builds; startup must exclude it.
+fs.mkdirSync(path.join(game, '.ttmg', 'previous-build'), { recursive: true });
+fs.writeFileSync(path.join(game, '.ttmg', 'previous-build', 'game.js'), 'throw new Error("old output must not be compiled");');
+const configPath = path.join(root, 'ttmgrc.json');
+const initialConfig = JSON.stringify({ clientKey: 'unchanged', lang: 'en-US' });
+fs.writeFileSync(configPath, initialConfig);
+const pause = ms => new Promise(resolve => setTimeout(resolve, ms));
+function run(args, directory = game) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...args], {
+      cwd: directory,
+      env: {
+        ...process.env,
+        NO_COLOR: '1',
+        FORCE_COLOR: '0',
+        TTMG_DEV_NO_OPEN: '1',
+        TTMGRC_PATH: configPath,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '',
+      stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error('CLI timeout'));
+    }, 75000);
+    child.stdout.on('data', data => {
+      stdout += data;
+    });
+    child.stderr.on('data', data => {
+      stderr += data;
+    });
+    child.once('error', reject);
+    child.once('close', code => {
+      clearTimeout(timer);
+      try {
+        const lines = stdout.trim().split(/\r?\n/);
+        assert.equal(
+          lines.length,
+          1,
+          'structured stdout must contain one object: ' + stderr,
+        );
+        resolve({ code, result: JSON.parse(lines[0]) });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+let owner;
+let secondOwner;
+async function main() {
+  try {
+    const start = [
+      'dev',
+      '--mode',
+      'client-preview',
+      '--update-mode',
+      'manual',
+      '--background',
+      '--client-key',
+      'smoke-client',
+      '--record-logs',
+      '--timeout',
+      '90',
+      '--format',
+      'json',
+    ];
+    const first = await run(start);
+    assert.equal(first.code, 0, JSON.stringify(first.result));
+    owner = first.result;
+    assert.equal(owner.updateMode, 'manual');
+    assert.equal(owner.reused, false);
+    assert.equal(fs.existsSync(owner.launch.qrPngPath), true);
+    assert.ok(owner.evidence.runtimeLogs);
+    assert.equal(fs.existsSync(path.join(owner.evidence.directory, 'build-output', '.ttmg')), false);
+    assert.equal(fs.existsSync(path.join(owner.evidence.directory, 'build-output', '__GAME__', '.ttmg')), false);
+    assert.ok(
+      fs.existsSync(path.join(owner.evidence.directory, 'build-output')),
+    );
+    const reused = await run(start);
+    assert.equal(reused.result.sessionId, owner.sessionId);
+    assert.equal(reused.result.reused, true);
+    const otherGame = path.join(root, 'other-game');
+    fs.mkdirSync(otherGame);
+    fs.writeFileSync(path.join(otherGame, 'game.js'), 'console.log("independent game");');
+    fs.writeFileSync(path.join(otherGame, 'game.json'), '{}');
+    const second = await run(start, otherGame);
+    assert.equal(second.code, 0, JSON.stringify(second.result));
+    secondOwner = second.result;
+    assert.notEqual(secondOwner.evidence.directory, owner.evidence.directory);
+    assert.ok(fs.existsSync(path.join(secondOwner.evidence.directory, 'build-output')));
+    fs.writeFileSync(configPath, JSON.stringify({ clientKey: 'different-global-key', lang: 'en-US' }));
+    for (const preview of [owner, secondOwner]) {
+      const response = await fetch(new URL('/game/config', preview.endpoints.page));
+      const config = await response.json();
+      assert.equal(config.data.clientKey, 'smoke-client');
+    }
+    fs.writeFileSync(configPath, initialConfig);
+    // Saving files alone must not start an intermediate build in manual mode.
+    const eventCount = fs
+      .readFileSync(owner.evidence.events, 'utf8')
+      .split('\n')
+      .filter(Boolean).length;
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round B");');
+    await pause(3500);
+    assert.equal(
+      fs.readFileSync(owner.evidence.events, 'utf8').split('\n').filter(Boolean)
+        .length,
+      eventCount,
+    );
+    const sync = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(sync.code, 0, JSON.stringify(sync.result));
+    assert.equal(sync.result.iterationId, 'round-1');
+    const observed = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-1',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      observed.result.status,
+      'needs_action',
+      JSON.stringify(observed.result),
+    );
+    assert.equal(observed.result.nextAction, 'connect_device');
+    assert.equal(observed.result.runtimeBuildVerified, false);
+    assert.equal(observed.result.launch.qrPngPath, owner.launch.qrPngPath);
+    assert.ok(observed.result.sourceDigest);
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round C");');
+    const retry = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(retry.result.buildId, sync.result.buildId);
+    const next = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-2',
+      '--format',
+      'json',
+    ]);
+    const nextResult = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-2',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      nextResult.result.status,
+      'needs_action',
+      JSON.stringify(nextResult.result),
+    );
+    assert.notEqual(next.result.buildId, sync.result.buildId);
+    assert.notEqual(
+      nextResult.result.sourceDigest,
+      observed.result.sourceDigest,
+    );
+    const stale = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(stale.result.errorCode, 'DEV_ITERATION_SUPERSEDED');
+    assert.equal(stale.code, 1);
+    fs.writeFileSync(path.join(game, 'game.js'), 'function {');
+    await run(['dev', 'sync', '--request-id', 'broken', '--format', 'json']);
+    const failed = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'broken',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(failed.result.status, 'failed', JSON.stringify(failed.result));
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("recovered");');
+    await run(['dev', 'sync', '--request-id', 'recovered', '--format', 'json']);
+    const recovery = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'recovered',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      recovery.result.status,
+      'needs_action',
+      JSON.stringify(recovery.result),
+    );
+    assert.equal(
+      fs.existsSync(path.join(game, '.ttmg', 'preview-start.lock')),
+      false,
+    );
+    assert.equal(fs.readFileSync(configPath, 'utf8'), initialConfig);
+    console.log(
+      'manual preview process smoke passed: start/reuse, two rounds, stale rejection, failure/recovery; no device connected',
+    );
+  } finally {
+    for (const preview of [owner, secondOwner].filter(Boolean)) {
+      const stopped = await run([
+        'dev',
+        'session',
+        'stop',
+        preview.sessionId,
+        '--sessions-dir',
+        preview.evidence.directory,
+        '--format',
+        'json',
+      ]);
+      assert.equal(stopped.code, 0, JSON.stringify(stopped.result));
+      assert.equal(fs.existsSync(preview.evidence.summary), true);
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+main().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/scripts/prepare-client-preview-acceptance.js

@@ -0,0 +1,65 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function prepareFixture(output) {
+  if (!output) throw new Error('Provide a new output directory.');
+  const root = path.resolve(output);
+  fs.mkdirSync(root, { recursive: false });
+  const runId = crypto.randomUUID();
+  try {
+    for (const round of ['A', 'B']) {
+      const directory = path.join(root, `round-${round.toLowerCase()}`);
+      fs.mkdirSync(directory);
+      const marker = `TTMG_ACCEPTANCE:${runId}:${round}`;
+      const code = `// Generated acceptance fixture. This is not a commercial game.
+const marker = ${JSON.stringify(marker)};
+const canvas = tt.createCanvas();
+const info = tt.getSystemInfoSync();
+canvas.width = info.windowWidth;
+canvas.height = info.windowHeight;
+const context = canvas.getContext('2d');
+function render() {
+  context.fillStyle = ${JSON.stringify(round === 'A' ? '#175cd3' : '#067647')};
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  context.fillStyle = '#ffffff';
+  context.font = 'bold 36px sans-serif';
+  context.fillText('ROUND ${round}', 20, 70);
+  context.font = '16px monospace';
+  context.fillText(${JSON.stringify(runId.slice(0, 18))}, 20, 110);
+  context.fillText(${JSON.stringify(runId.slice(18))}, 20, 138);
+  console.info(marker + ':info');
+  console.warn(marker + ':warn');
+  console.error(marker + ':error:EXPECTED_FIXTURE_LOG');
+}
+render();
+tt.onShow(render);
+`;
+      fs.writeFileSync(path.join(directory, 'game.js'), code);
+      fs.writeFileSync(path.join(directory, 'game.json'), '{}\n');
+    }
+    fs.cpSync(path.join(root, 'round-a'), path.join(root, 'project'), { recursive: true });
+    const result = {
+      schemaVersion: '1', status: 'prepared', runId, project: path.join(root, 'project'),
+      rounds: ['A', 'B'].map(round => ({ round, source: path.join(root, `round-${round.toLowerCase()}`),
+        marker: `TTMG_ACCEPTANCE:${runId}:${round}`, severities: ['info', 'warn', 'error'],
+        expectedScreen: `ROUND ${round} and the complete runId` })),
+      clientStarted: false, deviceVerified: false, commercialAcceptance: 'not_evaluated',
+    };
+    fs.writeFileSync(path.join(root, 'acceptance.json'), JSON.stringify(result, null, 2) + '\n');
+    return result;
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+module.exports = { prepareFixture };
+if (require.main === module) {
+  try {
+    if (process.argv.length !== 3) throw new Error('Usage: node prepare-client-preview-acceptance.js <new-directory>');
+    console.log(JSON.stringify(prepareFixture(process.argv[2])));
+  } catch (error) {
+    console.log(JSON.stringify({ status: 'failed', error: error.message, deviceVerified: false }));
+    process.exitCode = 1;
+  }
+}

package/dist/scripts/verify-agent-contract.js

@@ -10,7 +10,7 @@ const packageJson = JSON.parse(
   fs.readFileSync(path.join(cliRoot, 'package.json'), 'utf8'),
 );
 
-function runCli(args, environment = {}) {
+function runCli(args, environment = {}, cwd = cliRoot) {
   const env = {
     ...process.env,
     NO_COLOR: '1',
@@ -20,7 +20,7 @@ function runCli(args, environment = {}) {
   delete env.TTMG_LOGIN_EMAIL;
   delete env.TTMG_LOGIN_PASSWORD;
   return spawnSync(process.execPath, [cliEntry, ...args], {
-    cwd: cliRoot,
+    cwd,
     env,
     encoding: 'utf8',
   });
@@ -34,6 +34,30 @@ function assertExit(result, expected, label) {
   );
 }
 
+// Exercise the shipped bundle with an unavailable native binding, regardless
+// of the host OS. This catches bundler-hoisted imports as well as source imports.
+function runWithoutWasmBinding(args) {
+  const bootstrap = `
+    const Module = require('node:module');
+    const originalLoad = Module._load;
+    Module._load = function (request, ...rest) {
+      if (request === '@anrans001/ttmg-wasmtool') {
+        throw new Error('WASM_BINDING_MUST_NOT_LOAD_FOR_THIS_COMMAND');
+      }
+      return originalLoad.call(this, request, ...rest);
+    };
+    const [entry, ...args] = process.argv.slice(1);
+    process.argv = [process.execPath, entry, ...args];
+    require(entry);
+  `;
+  return spawnSync(process.execPath, ['-e', bootstrap, cliEntry, ...args], {
+    cwd: cliRoot,
+    env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+}
+
 function parseSingleJson(result, label) {
   const output = result.stdout.trim();
   assert.ok(output, `${label} did not write a JSON result to stdout`);
@@ -70,6 +94,23 @@ function assertNoSecretKeys(value, label) {
 }
 
 assert.ok(fs.existsSync(cliEntry), 'dist/index.js is missing; run build first');
+assertExit(runWithoutWasmBinding(['--help']), 0, 'help without Wasm binding');
+const withoutWasmCapabilities = runWithoutWasmBinding([
+  'capabilities', '--format', 'json',
+]);
+assertExit(withoutWasmCapabilities, 0, 'capabilities without Wasm binding');
+assert.equal(
+  parseSingleJson(withoutWasmCapabilities, 'capabilities without Wasm binding').command,
+  'capabilities',
+);
+const withoutWasmBuild = runWithoutWasmBinding([
+  'build', '--dir', __filename, '--format', 'json',
+]);
+assertExit(withoutWasmBuild, 1, 'build validation without Wasm binding');
+assert.equal(
+  parseSingleJson(withoutWasmBuild, 'build validation without Wasm binding').errorCode,
+  'BUILD_DIRECTORY_NOT_FOUND',
+);
 assert.match(
   packageJson.scripts.prepack,
   /verify:dist-version/,
@@ -104,6 +145,20 @@ assert.equal(
 );
 assert.equal(capabilities.commands.dev.outputModesMutuallyExclusive, true);
 assert.equal(capabilities.commands.dev.clientPreview.available, true);
+assert.equal(capabilities.commands.dev.clientPreview.textOutput, true);
+assert.equal(
+  capabilities.commands.dev.clientPreview.scanPage.urlField,
+  'launch.scanPageUrl',
+);
+assert.equal(
+  capabilities.commands.dev.clientPreview.scanPage.structuredModeAutoOpen,
+  false,
+);
+assert.equal(capabilities.commands.dev.sessionLogs.shortcut, 'ttmg dev logs');
+assert.equal(
+  capabilities.commands.dev.sessionScreenshot.shortcut,
+  'ttmg dev screenshot',
+);
 assert.equal(capabilities.commands.dev.clientPreview.protocolVersion, '1.0');
 assert.equal(capabilities.commands.dev.clientPreview.humanScanRequired, true);
 assert.equal(capabilities.commands.dev.clientPreview.deviceLaunch, false);
@@ -188,15 +243,133 @@ assert.match(
 const devHelp = runCli(['dev', '--help']);
 assertExit(devHelp, 0, 'dev help');
 assert.match(devHelp.stdout, /--mode <mode>/);
+assert.match(devHelp.stdout, /--record-logs\b/);
+for (const shortcut of ['logs', 'screenshot']) {
+  const help = runCli(['dev', shortcut, '--help']);
+  assertExit(help, 0, `${shortcut} shortcut help`);
+  assert.match(help.stdout, /--session <sessionId>/);
+  assert.match(help.stdout, /--sessions-dir <path>/);
+  assert.match(help.stdout, /--format <format>/);
+}
 
 const logsHelp = runCli(['dev', 'session', 'logs', '--help']);
+assert.equal(capabilities.commands.dev.iterationWorkflow.runtimeBuildVerified, false);
+assert.match(runCli(['dev', '--help']).stdout, /--background\b/);
+assert.match(runCli(['dev', '--help']).stdout, /--update-mode <mode>/);
+for (const action of ['sync', 'observe']) {
+  const help = runCli(['dev', action, '--help']);
+  assertExit(help, 0, `dev ${action} help`);
+  const missing = runCli(['dev', action, '--format', 'json']);
+  assertExit(missing, 1, `dev ${action} missing identifier`);
+  assert.equal(parseSingleJson(missing, action).errorCode, 'DEV_ITERATION_INVALID_ID');
+  assert.notEqual(runCli(['dev', action, '--unknown-option']).status, 0);
+}
+const invalidBackground = runCli(['dev', '--background', '--format', 'json']);
+assertExit(invalidBackground, 1, 'background mode validation');
+assert.equal(parseSingleJson(invalidBackground, 'background').errorCode, 'DEV_ITERATION_INVALID_OPTIONS');
+const invalidManual = runCli(['dev', '--update-mode', 'invalid', '--format', 'json']);
+assertExit(invalidManual, 1, 'update mode validation');
+assert.equal(parseSingleJson(invalidManual, 'manual').errorCode, 'DEV_ITERATION_INVALID_OPTIONS');
+// Validation must happen before writing evidence or starting local services.
+const unsafeEvidence = path.join(cliRoot, 'unsafe-evidence-' + process.pid);
+const invalidEvidence = runCli(['dev', '--client-key', 'fixture', '--mode', 'client-preview', '--no-open', '--format', 'json', '--evidence-dir', unsafeEvidence]);
+assertExit(invalidEvidence, 1, 'evidence directory isolation');
+assert.equal(parseSingleJson(invalidEvidence, 'evidence directory').errorCode, 'DEV_EVIDENCE_DIRECTORY_UNSAFE');
+assert.equal(fs.existsSync(unsafeEvidence), false);
+assert.deepEqual(capabilities.commands.dev.sessionLogs.evidenceDirectoryLocations, ['outside-project', 'project-root-.ttmg']);
+const packagingFixture = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-installed-pack-gate-'));
+try {
+  fs.writeFileSync(path.join(packagingFixture, 'game.js'), 'console.log("fixture");');
+  fs.writeFileSync(path.join(packagingFixture, 'game.json'), '{}');
+  fs.mkdirSync(path.join(packagingFixture, '.ttmg'));
+  fs.writeFileSync(path.join(packagingFixture, '.ttmg/logs.ndjson'), Buffer.alloc(5 * 1024 * 1024));
+  fs.writeFileSync(path.join(packagingFixture, '.ttmg/旧构建.js'), 'tt.login();');
+  const checked = runCli(['check', '--dir', packagingFixture, '--format', 'json']);
+  assertExit(checked, 0, 'installed packaging evidence exclusion');
+  const report = parseSingleJson(checked, 'installed packaging evidence exclusion');
+  assert.ok(!report.diagnostics.some(item => item.type === 'size' && !item.passed), 'installed ttmg-pack counted CLI evidence in package size');
+  assert.ok(report.diagnostics.some(item => item.name === 'login' && !item.passed), 'installed ttmg-pack scanned APIs from old debug builds');
+} finally {
+  fs.rmSync(packagingFixture, { recursive: true, force: true });
+}
+if (process.platform !== 'win32') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-evidence-symlink-'));
+  try {
+    fs.mkdirSync(path.join(root, 'assets'));
+    fs.writeFileSync(path.join(root, 'game.js'), 'console.log("fixture");');
+    fs.symlinkSync(path.join(root, 'assets'), path.join(root, '.ttmg'));
+    for (const extra of [[], ['--background']]) {
+      const result = runCli(['dev', '--mode', 'client-preview', '--update-mode', 'manual', '--client-key', 'fixture', '--no-open', '--format', 'json', ...extra], {}, root);
+      assertExit(result, 1, 'symlinked evidence isolation');
+      assert.equal(parseSingleJson(result, 'symlinked evidence').errorCode, 'DEV_EVIDENCE_DIRECTORY_UNSAFE');
+      assert.deepEqual(fs.readdirSync(path.join(root, 'assets')), [], 'validation wrote into game assets');
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+// Both formats perform the same local build validation; the former text placeholder is retired.
+const missingBuildDirectory = path.join(os.tmpdir(), 'ttmg-build-dir-that-does-not-exist-' + process.pid);
+for (const format of ['text', 'json']) {
+  const result = runCli(['build', '--dir', missingBuildDirectory, '--format', format]);
+  assertExit(result, 1, `build ${format} invalid directory`);
+  if (format === 'json') assert.equal(parseSingleJson(result, 'build').errorCode, 'BUILD_DIRECTORY_NOT_FOUND');
+}
 assertExit(logsHelp, 0, 'dev session logs help');
 assert.match(logsHelp.stdout, /--follow\b/);
 assert.match(logsHelp.stdout, /--until <cursor>/);
+assert.match(logsHelp.stdout, /--source <source>/);
+assert.match(logsHelp.stdout, /--runtime-session <id>/);
+assert.equal(
+  capabilities.commands.dev.sessionLogs.archive.defaultEnabled,
+  false,
+);
+assert.equal(capabilities.commands.dev.sessionLogs.nextQuery, true);
+const invalidRecording = runCli([
+  'dev',
+  '--record-logs',
+  '--format',
+  'json',
+  '--no-open',
+]);
+assertExit(invalidRecording, 1, 'log recording requires client-preview');
+assert.equal(
+  parseSingleJson(invalidRecording, 'invalid log recording').errorCode,
+  'DEV_LOG_INVALID_OPTIONS',
+);
+const invalidLogSource = runCli([
+  'dev',
+  'logs',
+  '--source',
+  'unknown',
+  '--format',
+  'json',
+]);
+assertExit(invalidLogSource, 1, 'invalid log source');
+assert.equal(
+  parseSingleJson(invalidLogSource, 'invalid log source').errorCode,
+  'DEV_LOG_INVALID_OPTIONS',
+);
 
 const screenshotHelp = runCli(['dev', 'session', 'screenshot', '--help']);
 assertExit(screenshotHelp, 0, 'dev session screenshot help');
 assert.match(screenshotHelp.stdout, /--image-format <format>/);
+assert.match(screenshotHelp.stdout, /--runtime-session <id>/);
+assert.match(
+  runCli(['dev', 'screenshot', '--help']).stdout,
+  /--runtime-session <id>/,
+);
+for (const command of [
+  ['dev', 'screenshot'],
+  ['dev', 'session', 'screenshot', 'missing-session'],
+]) {
+  const unknownOption = runCli([...command, '--runtime-sesion', 'unknown']);
+  assert.notEqual(
+    unknownOption.status,
+    0,
+    'unknown screenshot option must fail',
+  );
+}
 
 const checkHelp = runCli(['check', '--help']);
 assertExit(checkHelp, 0, 'check help');
@@ -248,4 +421,28 @@ try {
   fs.rmSync(tempDirectory, { recursive: true, force: true });
 }
 
+for (const operation of ['prepare', 'split']) {
+  assertExit(runWithoutWasmBinding(['wasm', operation, '--help']), 0, `wasm ${operation} help without binding`);
+  const invalid = runCli(['wasm', operation, '--format', 'json']);
+  assertExit(invalid, 1, `wasm ${operation} missing input`);
+  assert.equal(parseSingleJson(invalid, `wasm ${operation}`).errorCode, 'WASM_INVALID_OPTIONS');
+}
+const wasmSmoke = spawnSync(process.execPath, [path.join(cliRoot, 'scripts/wasm-smoke.js'), cliEntry], {
+  cwd: cliRoot, encoding: 'utf8', timeout: 60000,
+});
+assertExit(wasmSmoke, 0, 'Wasm built-artifact process smoke');
+console.log(wasmSmoke.stdout.trim());
+const captureHelp = runCli(['dev', 'capture', '--help']);
+assertExit(captureHelp, 0, 'capture help');
+assert.match(captureHelp.stdout, /--timeout/);
+const invalidCapture = runCli(['dev', 'capture', '--timeout', '0', '--format', 'json']);
+assertExit(invalidCapture, 1, 'capture invalid timeout');
+assert.equal(parseSingleJson(invalidCapture, 'capture invalid timeout').errorCode, 'DEV_CAPTURE_INVALID_OPTIONS');
+assertExit(runCli(['dev', 'capture', '--format', 'ndjson']), 1, 'capture invalid format inherited from dev');
+assertExit(runCli(['dev', 'capture', '--unknown-option']), 1, 'capture unknown option');
+const captureSmoke = spawnSync(process.execPath, [path.join(cliRoot, 'scripts/dev-capture-smoke.js'), cliEntry], {
+  cwd: cliRoot, encoding: 'utf8', timeout: 45000,
+});
+assertExit(captureSmoke, 0, 'capture built-artifact process smoke');
+console.log(captureSmoke.stdout.trim());
 console.log('built CLI agent contract verified');

package/dist/scripts/vibe-auth-open-test-preload.cjs

@@ -0,0 +1,11 @@
+// Test-only browser boundary: never launch a real browser from process smoke.
+const cp = require('node:child_process');
+const fs = require('node:fs');
+const original = cp.spawn;
+cp.spawn = function(command, args, options) {
+  if (command === 'open' || /(?:xdg-open|powershell\.exe)$/i.test(command)) {
+    fs.appendFileSync(process.env.TTMG_AUTH_OPEN_TEST_RECEIPT, JSON.stringify({command, args}) + '\n');
+    return original(process.execPath, ['-e', 'process.exit(0)'], {stdio: 'ignore'});
+  }
+  return original.call(this, command, args, options);
+};