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

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.7",
+  "version": "0.4.6-vibe-beta.8",
   "description": "TikTok Mini Game Command Line Tool",
   "license": "ISC",
   "bin": {
@@ -31,11 +31,12 @@
     "test:auth": "node scripts/run-ts-test.js src/commands/common/auth.test.ts",
     "test:capabilities": "node scripts/run-ts-test.js src/commands/common/capabilities.test.ts",
     "test:test-account": "node scripts/run-ts-test.js src/commands/common/testAccount.test.ts",
-    "test:dev-session": "node scripts/run-ts-test.js src/commands/native/dev/agentSession.test.ts",
-    "test:dev-session-command": "node scripts/run-ts-test.js src/commands/native/dev/session.test.ts",
+    "test:dev-session": "node scripts/run-ts-test.js src/commands/native/dev/agentSession.test.ts && npm run test:packaging-compatibility",
+    "test:packaging-compatibility": "node scripts/run-ts-test.js src/commands/native/dev/packagingCompatibility.test.ts",
+    "test:dev-session-command": "node scripts/run-ts-test.js src/commands/native/dev/session.test.ts && node scripts/run-ts-test.js src/commands/native/dev/projectSession.test.ts && node scripts/run-ts-test.js src/commands/native/dev/scanPage.test.ts && node scripts/run-ts-test.js src/commands/native/dev/runtime/logArchive.test.ts && node scripts/run-ts-test.js src/commands/native/dev/capture.test.ts",
     "test:dev-runtime-event": "node scripts/run-ts-test.js src/commands/native/dev/utils/scoket.test.ts",
     "test:dev-runtime-client": "node scripts/run-ts-test.js src/commands/native/dev/runtime/runtime.test.ts",
-    "test:dev-session-control": "node scripts/run-ts-test.js src/commands/native/dev/runtime/sessionControl.test.ts",
+    "test:dev-session-control": "node scripts/run-ts-test.js src/commands/native/dev/runtime/sessionControl.test.ts && node scripts/run-ts-test.js src/commands/native/dev/runtime/previewWorkflow.test.ts",
     "test:dev-runtime-session-follow": "node scripts/run-ts-test.js src/commands/native/dev/runtime/runtimeSessionFollow.test.ts",
     "test:dev-client-preview-orchestrator": "node scripts/run-ts-test.js src/commands/native/dev/runtime/clientPreviewOrchestrator.test.ts",
     "test:dev-watch-change": "node scripts/run-ts-test.js src/commands/native/dev/utils/watchChange.test.ts",
@@ -46,9 +47,10 @@
     "test:check-ai": "node scripts/run-ts-test.js src/commands/native/check/ai.test.ts",
     "test:build-structured": "node scripts/run-ts-test.js src/commands/native/build/build.test.ts",
     "test:doctor": "node scripts/run-ts-test.js src/commands/native/doctor/doctor.test.ts",
-    "test:agent-contract": "npm run test:login && npm run test:auth && npm run test:capabilities && npm run test:test-account && npm run test:upload-preview && npm run test:preview-page && npm run test:check && npm run test:check-ai && npm run test:build-structured && npm run test:doctor && npm run test:dev-session && npm run test:dev-session-command && npm run test:dev-runtime-event && npm run test:dev-runtime-client && npm run test:dev-session-control && npm run test:dev-runtime-session-follow && npm run test:dev-client-preview-orchestrator && npm run test:dev-watch-change && npm run test:network && npm run test:vibe && npx tsc --noEmit && npm run build && npm run test:vibe-process && npm run test:preview-page-process && npm run test:preview-page-detached && npm run verify:dist-version && npm run verify:agent-contract",
-    "test:agent-contract:full": "npm run test:agent-contract && npm run test:dev-default-process && npm run test:dev-game-ready-process && npm run test:dev-client-preview-control-process",
-    "publish:beta": "npm publish --registry=https://registry.npmjs.org/ --access public --tag beta",
+    "test:wasm": "node scripts/run-ts-test.js src/commands/native/wasm/wasm.test.ts && node scripts/acceptance-fixture.test.js",
+    "test:agent-contract": "npm run test:login && npm run test:auth && npm run test:capabilities && npm run test:test-account && npm run test:upload-preview && npm run test:preview-page && npm run test:check && npm run test:check-ai && npm run test:build-structured && npm run test:doctor && npm run test:wasm && npm run test:dev-session && npm run test:dev-session-command && npm run test:dev-runtime-event && npm run test:dev-runtime-client && npm run test:dev-session-control && npm run test:dev-runtime-session-follow && npm run test:dev-client-preview-orchestrator && npm run test:dev-watch-change && npm run test:network && npm run test:vibe && npx tsc --noEmit && npm run build && npm run test:vibe-process && npm run test:preview-page-process && npm run test:preview-page-detached && npm run verify:dist-version && npm run verify:agent-contract",
+    "test:agent-contract:full": "npm run test:agent-contract && npm run test:dev-default-process && npm run test:dev-game-ready-process && npm run test:dev-client-preview-control-process && node scripts/dev-workflow-smoke.js",
+    "publish:beta": "npm publish --registry=https://registry.npmjs.org/ --access public --tag vibe-beta",
     "setup": "node scripts/setup.js",
     "reset:local-state": "node scripts/resetLocalState.js",
     "dev:link": "npm run build && npm link",
@@ -60,7 +62,7 @@
   ],
   "author": "zhanghongyang.mocha",
   "dependencies": {
-    "@anrans001/ttmg-wasmtool": "^0.3.2",
+    "@anrans001/ttmg-wasmtool": "^0.3.3",
     "acorn": "^8.15.0",
     "archiver": "^7.0.1",
     "axios": "^1.11.0",
@@ -93,7 +95,7 @@
     "qs": "6.12.1",
     "semver": "^7.7.2",
     "socks-proxy-agent": "^9.0.0",
-    "ttmg-pack": "0.4.13-beta.2",
+    "ttmg-pack": "0.4.13",
     "ws": "^8.18.3"
   },
   "devDependencies": {

package/dist/scripts/acceptance-fixture.test.js

@@ -0,0 +1,33 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const vm = require('node:vm');
+const { test } = require('node:test');
+const { prepareFixture } = require('./prepare-client-preview-acceptance');
+
+test('two fixture rounds have unique correlated logs/screens and never start a client', t => {
+  const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-acceptance-test-'));
+  t.after(() => fs.rmSync(temporary, { recursive: true, force: true }));
+  const root = path.join(temporary, 'run');
+  const result = prepareFixture(root);
+  assert.equal(result.deviceVerified, false);
+  assert.equal(result.clientStarted, false);
+  assert.throws(() => prepareFixture(root), /EEXIST/);
+  assert.notEqual(prepareFixture(path.join(temporary, 'other')).runId, result.runId);
+  for (const round of result.rounds) {
+    const logs = [], text = [];
+    const context = { fillRect() {}, fillText(value) { text.push(value); } };
+    vm.runInNewContext(fs.readFileSync(path.join(round.source, 'game.js'), 'utf8'), {
+      tt: { createCanvas: () => ({ getContext: () => context }),
+        getSystemInfoSync: () => ({ windowWidth: 360, windowHeight: 640 }), onShow() {} },
+      console: Object.fromEntries(['info', 'warn', 'error'].map(level => [level, value => logs.push([level, value])])),
+    });
+    assert.deepEqual(logs.map(x => x[0]), round.severities);
+    assert.ok(logs.every(x => x[1].startsWith(round.marker)));
+    assert.equal(text[0], 'ROUND ' + round.round);
+    assert.equal(text.slice(1).join(''), result.runId);
+  }
+  assert.equal(fs.readFileSync(path.join(result.project, 'game.js'), 'utf8'),
+    fs.readFileSync(path.join(root, 'round-a', 'game.js'), 'utf8'));
+});

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

@@ -0,0 +1,76 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const net = require('node:net');
+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.realpathSync(fs.mkdtempSync(path.join(process.platform === 'win32' ? os.tmpdir() : '/tmp', 'ttmg-cap-')));
+const id = 'dev_capture_test';
+const directory = path.join(root, '.ttmg', 'sessions', id);
+fs.mkdirSync(directory, { recursive: true });
+fs.writeFileSync(path.join(root, 'game.json'), '{}');
+const address = process.platform === 'win32'
+  ? { transport: 'named-pipe', path: `\\\\.\\pipe\\ttmg-${id}` }
+  : { transport: 'unix', path: path.join(directory, 'ipc') };
+fs.writeFileSync(path.join(directory, 'manifest.json'), JSON.stringify({
+  schemaVersion: '1', sessionId: id, mode: 'client-preview', status: 'ready',
+  project: { directory: root, clientKey: 'fixture' }, process: { pid: process.pid },
+  control: address, runtime: { runtimeSessionId: 'runtime_fixture', sessionStartCursor: '0' },
+}));
+const rows = Array.from({ length: 1201 }, (_, i) => ({ sequence: String(i + 1), severity: 'info', message: `fixture ${i}` }));
+const server = net.createServer(socket => {
+  let buffer = '';
+  socket.on('data', data => {
+    buffer += data;
+    if (!buffer.includes('\n')) return;
+    const request = JSON.parse(buffer.trim());
+    const params = request.params || {};
+    let result = { runtimeSessionId: 'runtime_fixture' };
+    if (request.operation === 'logs.snapshot') {
+      const until = params.until || '1201';
+      const eligible = rows.filter(x => BigInt(x.sequence) > BigInt(params.after || '0') && BigInt(x.sequence) <= BigInt(until));
+      const records = eligible.slice(0, params.limit);
+      result = { ...result, records, snapshotCursor: until, oldestCursor: '1',
+        nextCursor: records.length ? records[records.length - 1].sequence : until,
+        cursorExpired: false, hasMore: eligible.length > records.length };
+    } else if (request.operation === 'screenshot.capture') {
+      fs.writeFileSync(params.output, 'fixture screenshot');
+      result = { ...result, path: params.output, mime: 'image/jpeg', width: 10, height: 20, captureTime: '123' };
+    }
+    socket.end(JSON.stringify({ requestId: request.requestId, type: 'result', result }) + '\n');
+  });
+});
+function run(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...args, '--format', 'json'], {
+      cwd: root, env: { ...process.env, TTMGRC_PATH: path.join(root, 'rc.json') }, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => child.kill('SIGKILL'), 15000);
+    child.stdout.on('data', x => { stdout += x; });child.stderr.on('data', x => { stderr += x; });
+    child.on('error', reject);
+    child.on('close', code => {
+      clearTimeout(timer);
+      try { assert.equal(code, 0, stderr + stdout);assert.equal(stdout.trim().split('\n').length, 1);resolve(JSON.parse(stdout)); }
+      catch (error) { reject(error); }
+    });
+  });
+}
+(async () => {
+  try {
+    await new Promise((resolve, reject) => { server.once('error', reject);server.listen(address.path, resolve); });
+    const legacy = await run(['dev', 'logs']);
+    assert.equal(legacy.records.length, 200);
+    assert.equal(legacy.cursor.hasMore, true);
+    const capture = await run(['dev', 'capture']);
+    assert.equal(capture.logs.records, 1201);assert.equal(capture.logs.complete, true);
+    assert.deepEqual(fs.readFileSync(capture.logs.path, 'utf8').trim().split('\n').map(JSON.parse), rows);
+    assert.equal(fs.existsSync(capture.screenshot.path), true);
+    assert.equal(capture.runtimeSessionId, 'runtime_fixture');
+    assert.equal(capture.platformWrite, false);
+    console.log('capture process passed: 1201 logs, screenshot path, session discovery, unchanged paged logs; local IPC fixture only');
+  } finally {
+    await new Promise(resolve => server.close(resolve));fs.rmSync(root, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error);process.exitCode = 1; });

package/dist/scripts/dev-client-preview-control-smoke.js

@@ -5,27 +5,67 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 
-function runCli(args, cwd) {
+function runCli(args, cwd, inspectScanPage) {
   return new Promise((resolve, reject) => {
     const child = spawn(
       process.execPath,
       [path.resolve(__dirname, '../dist/index.js'), ...args],
       {
         cwd,
-        env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+        env: {
+          ...process.env,
+          NO_COLOR: '1',
+          FORCE_COLOR: '0',
+          TTMG_DEV_NO_OPEN: '1',
+        },
         stdio: ['ignore', 'pipe', 'pipe'],
       },
     );
     let stdout = '';
     let stderr = '';
+    let inspection = Promise.resolve();
+    let inspectionStarted = false;
+    let inspectionError;
+    const timer = setTimeout(() => child.kill('SIGKILL'), 20000);
     child.stdout.on('data', chunk => {
       stdout += chunk;
+      if (inspectScanPage && !inspectionStarted) {
+        for (const line of stdout.split(/\r?\n/)) {
+          let event;
+          try {
+            event = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (event.payload?.state !== 'READY_FOR_SCAN') continue;
+          inspectionStarted = true;
+          inspection = inspectScanPage(event.payload).catch(error => {
+            inspectionError = error;
+          });
+          break;
+        }
+      }
     });
     child.stderr.on('data', chunk => {
       stderr += chunk;
     });
-    child.once('error', reject);
-    child.once('close', status => resolve({ status, stdout, stderr }));
+    child.once('error', error => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once('close', async status => {
+      clearTimeout(timer);
+      await inspection;
+      if (inspectionError) {
+        reject(inspectionError);
+        return;
+      }
+      if (inspectScanPage && !inspectionStarted) {
+        reject(new Error(`No live scan page: ${stderr || stdout}`));
+        return;
+      }
+      resolve({ status, stdout, stderr });
+    });
   });
 }
 
@@ -92,6 +132,15 @@ async function run() {
       buffer += chunk.toString();
       if (!buffer.includes('\n')) return;
       const request = JSON.parse(buffer.slice(0, buffer.indexOf('\n')));
+      if (request.operation === 'session.status') {
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: { status: 'ready' },
+        });
+        socket.end();
+        return;
+      }
       if (request.operation === 'logs.snapshot') {
         write(socket, {
           requestId: request.requestId,
@@ -157,15 +206,31 @@ async function run() {
         return;
       }
       if (request.operation === 'screenshot.capture') {
+        if (
+          request.params.runtimeSessionId &&
+          request.params.runtimeSessionId !== 'runtime-control-smoke'
+        ) {
+          write(socket, {
+            requestId: request.requestId,
+            type: 'error',
+            errorCode: 'RUNTIME_SESSION_MISMATCH',
+            error: 'Runtime session changed.',
+          });
+          socket.end();
+          return;
+        }
         assert.equal(request.params.format, 'jpeg');
         assert.equal(request.params.quality, 0.8);
-        const output = request.params.output;
+        const output =
+          request.params.output ||
+          path.join(screenshotsDirectory, 'default.jpeg');
         fs.writeFileSync(output, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
         write(socket, {
           requestId: request.requestId,
           type: 'result',
           result: {
             path: output,
+            runtimeSessionId: 'runtime-control-smoke',
             mime: 'image/jpeg',
             size: 4,
             width: 1,
@@ -190,10 +255,53 @@ async function run() {
         '--events',
         'ndjson',
         '--no-open',
+        '--record-logs',
         '--timeout',
-        '1',
+        '3',
       ],
       previewGameDirectory,
+      async ready => {
+        const pageResponse = await fetch(ready.scanPageUrl, {
+          signal: AbortSignal.timeout(1500),
+        });
+        assert.equal(pageResponse.status, 200);
+        assert.match(
+          pageResponse.headers.get('content-security-policy'),
+          /frame-ancestors 'none'/,
+        );
+        assert.equal(
+          pageResponse.headers.get('access-control-allow-origin'),
+          null,
+          'scan page must bypass game CORS middleware',
+        );
+        const html = await pageResponse.text();
+        assert.match(html, /id="status-title"/);
+        const status = await (
+          await fetch(`${ready.scanPageUrl}/status`)
+        ).json();
+        assert.equal(status.state, 'waiting');
+        assert.equal(status.compile, 'succeeded');
+        assert.equal(status.developerOptions.values.enableDomainCheck, true);
+        const editToken = html.match(/editToken="([a-f0-9]+)"/)[1];
+        const saved = await fetch(`${ready.scanPageUrl}/settings`, {
+          method: 'POST', headers: { 'Content-Type': 'application/json',
+            Origin: new URL(ready.scanPageUrl).origin, 'X-TTMG-Scan-Token': editToken },
+          body: JSON.stringify({ ...status.developerOptions.values, enableAdMock: true }),
+        });
+        assert.equal(saved.status, 200);
+        const savedOptions = (await saved.json()).developerOptions;
+        assert.equal(savedOptions.values.enableAdMock, true);
+        assert.equal(savedOptions.delivery, 'pending');
+        assert.deepEqual((await (await fetch(`${ready.scanPageUrl}/status`)).json()).developerOptions, savedOptions);
+        const png = Buffer.from(
+          await (await fetch(`${ready.scanPageUrl}/qr.png`)).arrayBuffer(),
+        );
+        assert.deepEqual(
+          png,
+          fs.readFileSync(ready.qrPngPath),
+          'page and terminal PNG must use the same launch payload',
+        );
+      },
     );
     assert.equal(previewRun.status, 2, previewRun.stderr || previewRun.stdout);
     const previewEvents = previewRun.stdout
@@ -203,16 +311,49 @@ async function run() {
       .map(JSON.parse);
     const readyForScan = previewEvents.find(
       event =>
-        event.type === 'lifecycle' &&
-        event.payload?.state === 'READY_FOR_SCAN',
+        event.type === 'lifecycle' && event.payload?.state === 'READY_FOR_SCAN',
     );
     assert.ok(readyForScan, previewRun.stderr || previewRun.stdout);
     assert.equal(fs.existsSync(readyForScan.payload.qrPngPath), true);
+    await assert.rejects(
+      fetch(readyForScan.payload.scanPageUrl, {
+        signal: AbortSignal.timeout(1000),
+      }),
+      'scan page stops with the CLI',
+    );
+    assert.match(
+      readyForScan.payload.scanPageUrl,
+      /^http:\/\/127\.0\.0\.1:\d+\/__ttmg\/client-preview\/[a-f0-9]+$/,
+    );
     const previewManifest = JSON.parse(
       fs.readFileSync(readyForScan.payload.manifest, 'utf8'),
     );
+    assert.ok(previewManifest.evidence.runtimeLogs);
+    const savedRead = await runCli(
+      [
+        'dev',
+        'logs',
+        '--source',
+        'archive',
+        '--session',
+        previewManifest.sessionId,
+        '--format',
+        'json',
+      ],
+      previewGameDirectory,
+    );
+    assert.equal(savedRead.status, 0, savedRead.stderr || savedRead.stdout);
+    const saved = JSON.parse(savedRead.stdout);
+    assert.equal(saved.source, 'archive');
+    assert.equal(saved.archive.state, 'closed');
+    assert.deepEqual(saved.records, []);
+    assert.equal(saved.runtimeSessionId, null);
+    assert.equal(saved.platformWrite, false);
     if (previewManifest.control?.transport === 'unix') {
-      assert.equal(Buffer.byteLength(previewManifest.control.path) <= 100, true);
+      assert.equal(
+        Buffer.byteLength(previewManifest.control.path) <= 100,
+        true,
+      );
     }
     assert.match(previewRun.stderr, /QR image:/);
     assert.equal(
@@ -224,6 +365,39 @@ async function run() {
       'session evidence must not trigger an endless recompilation loop',
     );
 
+    const humanPreview = await runCli(
+      [
+        'dev',
+        '--mode',
+        'client-preview',
+        '--client-key',
+        'smoke-client',
+        '--timeout',
+        '1',
+      ],
+      previewGameDirectory,
+    );
+    assert.equal(
+      humanPreview.status,
+      2,
+      humanPreview.stderr || humanPreview.stdout,
+    );
+    assert.match(humanPreview.stdout, /Scan with TikTok|使用 TikTok 扫码/);
+    assert.match(humanPreview.stdout, /QR image:|二维码图片：/);
+    assert.match(humanPreview.stdout, /ttmg dev screenshot/);
+    assert.ok(!humanPreview.stdout.includes('"schemaVersion"'));
+    for (const id of fs.readdirSync(
+      path.join(previewGameDirectory, '.ttmg', 'sessions'),
+    )) {
+      if (id === previewManifest.sessionId) continue;
+      const base = path.join(previewGameDirectory, '.ttmg', 'sessions', id);
+      const unrecorded = JSON.parse(
+        fs.readFileSync(path.join(base, 'manifest.json'), 'utf8'),
+      );
+      assert.equal(unrecorded.evidence.runtimeLogs, undefined);
+      assert.equal(fs.existsSync(path.join(base, 'runtime-logs')), false);
+    }
+
     await new Promise((resolve, reject) => {
       server.once('error', reject);
       server.listen(control.path, resolve);
@@ -305,9 +479,119 @@ async function run() {
     assert.equal(screenshotLines.length, 1);
     const screenshot = JSON.parse(screenshotLines[0]);
     assert.equal(screenshot.path, screenshotOutput);
+    assert.equal(screenshot.runtimeSessionId, 'runtime-control-smoke');
     assert.equal(screenshot.mime, 'image/jpeg');
     assert.equal('data' in screenshot, false);
     assert.equal(fs.readFileSync(screenshotOutput).toString('hex'), 'ffd8ffd9');
+    for (const command of [
+      ['dev', 'screenshot', '--session', sessionId],
+      ['dev', 'session', 'screenshot', sessionId],
+    ]) {
+      const pinnedRun = await runCli(
+        [
+          ...command,
+          '--runtime-session',
+          'runtime-control-smoke',
+          '--output',
+          path.join(root, `pinned-${command[1]}.jpeg`),
+          '--format',
+          'json',
+        ],
+        gameDirectory,
+      );
+      assert.equal(pinnedRun.status, 0, pinnedRun.stderr || pinnedRun.stdout);
+      const lines = pinnedRun.stdout.trim().split(/\r?\n/);
+      assert.equal(lines.length, 1);
+      assert.equal(
+        JSON.parse(lines[0]).runtimeSessionId,
+        'runtime-control-smoke',
+      );
+      const invalidOutput = path.join(root, `stale-${command[1]}.jpeg`);
+      const staleRun = await runCli(
+        [
+          ...command,
+          '--runtime-session',
+          'old-runtime',
+          '--output',
+          invalidOutput,
+          '--format',
+          'json',
+        ],
+        gameDirectory,
+      );
+      assert.equal(staleRun.status, 1);
+      assert.equal(
+        JSON.parse(staleRun.stdout).errorCode,
+        'RUNTIME_SESSION_MISMATCH',
+      );
+      assert.equal(fs.existsSync(invalidOutput), false);
+    }
+
+    // Professional-developer shortcuts use the same IPC, without a session ID.
+    const subdirectory = path.join(gameDirectory, 'src');
+    fs.mkdirSync(subdirectory);
+    const humanLogs = await runCli(['dev', 'logs'], subdirectory);
+    assert.equal(humanLogs.status, 0, humanLogs.stderr || humanLogs.stdout);
+    assert.match(humanLogs.stdout, /\[INFO\] \[native_runtime\] snapshot/);
+    const jsonLogs = await runCli(
+      ['dev', 'logs', '--format', 'json'],
+      gameDirectory,
+    );
+    assert.equal(jsonLogs.status, 0, jsonLogs.stderr || jsonLogs.stdout);
+    assert.equal(
+      JSON.parse(jsonLogs.stdout).records[0].sequence,
+      '90071992547409930002',
+    );
+    const humanFollow = await runCli(
+      ['dev', 'logs', '--follow', '--timeout', '1'],
+      gameDirectory,
+    );
+    assert.equal(
+      humanFollow.status,
+      0,
+      humanFollow.stderr || humanFollow.stdout,
+    );
+    assert.match(humanFollow.stdout, /\[ERROR\] \[structured_trace\] live/);
+    const aliasFollow = await runCli(
+      ['dev', 'logs', '--follow', '--timeout', '1', '--format', 'ndjson'],
+      gameDirectory,
+    );
+    assert.equal(
+      aliasFollow.status,
+      0,
+      aliasFollow.stderr || aliasFollow.stdout,
+    );
+    assert.deepEqual(
+      aliasFollow.stdout
+        .trim()
+        .split(/\r?\n/)
+        .map(JSON.parse)
+        .map(frame => frame.type),
+      ['log_snapshot', 'log_batch', 'follow_end'],
+    );
+    const humanShot = await runCli(['dev', 'screenshot'], gameDirectory);
+    assert.equal(humanShot.status, 0, humanShot.stderr || humanShot.stdout);
+    assert.match(humanShot.stdout, /default\.jpeg/);
+    assert.ok(fs.existsSync(path.join(screenshotsDirectory, 'default.jpeg')));
+    const jsonShot = await runCli(
+      [
+        'dev',
+        'screenshot',
+        '--output',
+        path.join(root, 'alias.jpeg'),
+        '--format',
+        'json',
+      ],
+      gameDirectory,
+    );
+    assert.equal(jsonShot.status, 0, jsonShot.stderr || jsonShot.stdout);
+    assert.equal(JSON.parse(jsonShot.stdout).mime, 'image/jpeg');
+    const noSession = await runCli(['dev', 'logs', '--format', 'json'], root);
+    assert.equal(noSession.status, 1);
+    assert.equal(
+      JSON.parse(noSession.stdout).errorCode,
+      'DEV_SESSION_NOT_RUNNING',
+    );
   } finally {
     await new Promise(resolve => server.close(resolve));
     fs.rmSync(root, { recursive: true, force: true });

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

@@ -13,6 +13,10 @@ async function run() {
   fs.mkdirSync(gameDirectory);
   fs.writeFileSync(path.join(gameDirectory, 'game.js'), 'console.log("game");\n');
   fs.writeFileSync(path.join(gameDirectory, 'game.json'), '{}\n');
+  for (const directory of ['.ttmg', '.ttmg-assets', 'assets/.ttmg']) {
+    fs.mkdirSync(path.join(gameDirectory, directory), { recursive: true });
+    fs.writeFileSync(path.join(gameDirectory, directory, 'data.txt'), 'before');
+  }
 
   let output = '';
   const child = spawn(
@@ -49,7 +53,24 @@ async function run() {
       await delay(100);
     }
     assert.match(output, /Game resources compiled successfully|游戏资源编译成功/);
-    assert.equal(fs.existsSync(path.join(gameDirectory, '.ttmg')), false);
+    // Ordinary dev must not create an Agent session. Existing evidence must
+    // not trigger reloads, while similarly named runtime assets still do.
+    assert.equal(fs.existsSync(path.join(gameDirectory, '.ttmg/sessions')), false);
+    const compileCount = () => (output.match(/Game resources compiled successfully|游戏资源编译成功/g) || []).length;
+    const initialCount = compileCount();
+    fs.writeFileSync(path.join(gameDirectory, '.ttmg/data.txt'), 'new log');
+    await delay(4500);
+    assert.equal(compileCount(), initialCount, 'session writes triggered a rebuild');
+    for (const file of ['.ttmg-assets/data.txt', 'assets/.ttmg/data.txt']) {
+      const before = compileCount();
+      fs.writeFileSync(path.join(gameDirectory, file), 'updated runtime asset');
+      const deadline = Date.now() + 15000;
+      while (compileCount() === before && Date.now() < deadline) {
+        if (child.exitCode !== null) throw new Error(`Default dev exited while watching ${file}:\n${output}`);
+        await delay(100);
+      }
+      assert.ok(compileCount() > before, `${file} did not trigger a rebuild`);
+    }
   } finally {
     if (child.exitCode === null) {
       child.kill('SIGTERM');