@playcraft/cli 0.0.44 → 0.0.47

package/project-templates/phaser/skills/playable-record/scripts/verify-fusion.mjs

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * Gameplay fusion wiring probe — objective DoD for `fusion`.
+ *
+ * - <2 selected *.aigameplay atoms → PASS (no-op)
+ * - ≥2 atoms → DESIGN fusion type must be consistent + each mechanic wired in game/ source
+ *   + autoPlay path references both mechanics when publish contract is present
+ *
+ * Usage:
+ *   node skills/playable-record/scripts/verify-fusion.mjs --root=.
+ *   npm run verify:fusion
+ *
+ * Exit 0 = OK/pass
+ * Exit 2 = fusion contract broken
+ * Exit 1 = unexpected error
+ */
+
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve, basename } from 'node:path';
+import { writeValidatorArtifact } from '../../_shared/scripts/lib/validator-artifacts.mjs';
+
+// `[*_\s]*` tolerates markdown emphasis in the §6 template form `- **Fusion type**:`.
+const FUSION_TYPE_RE =
+  /Fusion\s+type[*_\s]*:\s*(Single|A-Visual|B1-Passive|B2-Active|C-Sequential|D-Parallel)/i;
+const REAL_FUSION_TYPES = new Set(['A-Visual', 'B1-Passive', 'B2-Active', 'C-Sequential', 'D-Parallel']);
+
+/** Signature tokens per gameplay atom — at least one must appear under game/. */
+export const GAMEPLAY_SIGNATURES = {
+  'match3_core.aigameplay': [
+    'trySwap',
+    'applyGravity',
+    'refillBoard',
+    'minMatchCount',
+    'match3',
+    'match-3',
+  ],
+  'memory_match.aigameplay': [
+    'flipCard',
+    'checkMatch',
+    'face_up',
+    'pairId',
+    'memory_match',
+    'flipBack',
+  ],
+  'screw_puzzle.aigameplay': [
+    'removeScrew',
+    'canRemoveScrew',
+    'bufferSlots',
+    'screw_puzzle',
+    'colorMatchRequired',
+  ],
+  'arrow_escape_core.aigameplay': [
+    'arrow_escape',
+    'direction_arrow',
+    'escape_core',
+    'canMoveArrow',
+  ],
+};
+
+function parseArgs(argv) {
+  const opts = { root: process.cwd(), json: false };
+  for (const arg of argv) {
+    if (arg === '--json') opts.json = true;
+    else if (arg.startsWith('--root=')) {
+      const v = arg.slice('--root='.length);
+      opts.root = v.startsWith('/') ? v : resolve(process.cwd(), v);
+    }
+  }
+  return opts;
+}
+
+/**
+ * @param {unknown} tree
+ * @returns {string[]}
+ */
+export function readSelectedGameplayAtoms(tree) {
+  const atoms = Array.isArray(tree?.meta?.selectedAtoms) ? tree.meta.selectedAtoms : [];
+  return atoms
+    .map((a) => (typeof a === 'string' ? a.trim() : ''))
+    .filter((a) => a.endsWith('.aigameplay'));
+}
+
+/**
+ * True only when a real pseudo-fusion / risk-accepted decision is documented.
+ *
+ * Judged by the *value* of the "Pseudo-fusion decision:" field — not the field
+ * label itself. The §6 template label always contains the word "pseudo-fusion"
+ * (and the placeholder hint contains "risk accepted: …"), so a naive substring
+ * match would make every fusion gate a no-op for any template-derived DESIGN.md.
+ *
+ * @param {string} content
+ * @returns {boolean}
+ */
+export function hasPseudoFusionDecision(content) {
+  // Drop unfilled {…} template placeholders so their hint text cannot satisfy the gate.
+  const filled = content.replace(/\{[^}]*\}/g, '');
+  // `[*_\s]*` tolerates markdown emphasis in `- **Pseudo-fusion decision**:`.
+  const field = filled.match(/Pseudo-?fusion decision[*_\s]*:\s*(.*)/i);
+  if (field) {
+    const value = field[1].trim();
+    const lower = value.toLowerCase();
+    const isEmpty = lower === '' || lower === 'n/a' || lower === 'na' || lower === 'none';
+    if (!isEmpty) return true;
+    // Field present but n/a → no decision documented; fall through to scan the rest.
+  }
+  // No structured field (or n/a): scan with the bare label stripped so it cannot self-satisfy.
+  const scrubbed = filled.replace(/Pseudo-?fusion decision[*_\s]*:/gi, '');
+  return /pseudo-?fusion/i.test(scrubbed) || /risk\s+accepted/i.test(scrubbed);
+}
+
+/**
+ * @param {string} designContent
+ * @returns {{ type: string | null, isPseudoFusion: boolean }}
+ */
+export function parseDesignFusionType(designContent) {
+  const match = designContent.match(FUSION_TYPE_RE);
+  if (!match) return { type: null, isPseudoFusion: false };
+  const raw = match[1];
+  const type =
+    raw.startsWith('B1') ? 'B1-Passive' : raw.startsWith('B2') ? 'B2-Active' : raw;
+  const isPseudoFusion = hasPseudoFusionDecision(designContent);
+  return { type, isPseudoFusion };
+}
+
+/**
+ * @param {string} content
+ * @param {string} atomId
+ * @returns {string[]}
+ */
+export function matchedSignatures(content, atomId) {
+  const signatures = GAMEPLAY_SIGNATURES[atomId] ?? [
+    atomId.replace('.aigameplay', ''),
+    atomId.split('.')[0],
+  ];
+  return signatures.filter((sig) => content.includes(sig));
+}
+
+async function collectGameSource(root) {
+  const gameDir = join(root, 'game');
+  if (!existsSync(gameDir)) return '';
+  const chunks = [];
+
+  async function walk(dir) {
+    let entries = [];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+        continue;
+      }
+      if (!/\.(ts|js|mjs|cjs)$/.test(entry.name)) continue;
+      try {
+        chunks.push(await readFile(abs, 'utf8'));
+      } catch {
+        // ignore unreadable files
+      }
+    }
+  }
+
+  await walk(gameDir);
+  return chunks.join('\n');
+}
+
+/**
+ * Extract the full `autoPlay(...) { ... }` body via brace balancing.
+ *
+ * A non-greedy regex stops at the first `\n}` and truncates the block whenever
+ * autoPlay contains nested `{}` (if/for blocks), which would drop later mechanic
+ * calls and cause false "missing mechanic" failures. This walks braces instead.
+ *
+ * @param {string} gameSource
+ * @returns {string}
+ */
+export function extractAutoPlayBlock(gameSource) {
+  const header = /autoPlay\s*\([^)]*\)\s*\{/g;
+  const m = header.exec(gameSource);
+  if (!m) return '';
+  const start = m.index;
+  let depth = 0;
+  for (let i = header.lastIndex - 1; i < gameSource.length; i += 1) {
+    const ch = gameSource[i];
+    if (ch === '{') depth += 1;
+    else if (ch === '}') {
+      depth -= 1;
+      if (depth === 0) return gameSource.slice(start, i + 1);
+    }
+  }
+  // Unbalanced source — best effort: return from the header onward.
+  return gameSource.slice(start);
+}
+
+/**
+ * @param {string} root
+ * @param {{ gameplayAtoms?: string[], designContent?: string, gameSource?: string }} [overrides]
+ */
+export async function verifyFusion(root, overrides = {}) {
+  const problems = [];
+
+  let gameplayAtoms = overrides.gameplayAtoms;
+  if (!gameplayAtoms) {
+    const atomTreePath = join(root, 'docs/atom-tree.json');
+    if (!existsSync(atomTreePath)) {
+      return { ok: true, skipped: true, reason: 'no atom-tree.json — fusion no-op' };
+    }
+    const tree = JSON.parse(await readFile(atomTreePath, 'utf8'));
+    gameplayAtoms = readSelectedGameplayAtoms(tree);
+  }
+
+  if (gameplayAtoms.length < 2) {
+    return { ok: true, skipped: true, reason: 'single gameplay atom — fusion no-op PASS' };
+  }
+
+  const designPath = join(root, 'docs/DESIGN.md');
+  const designContent =
+    overrides.designContent ??
+    (existsSync(designPath) ? await readFile(designPath, 'utf8') : '');
+  const { type, isPseudoFusion } = parseDesignFusionType(designContent);
+
+  if (!type) {
+    problems.push('DESIGN.md missing Fusion type: — classify fusion in ## 6. Gameplay Fusion');
+  } else if (type === 'Single' && !isPseudoFusion) {
+    problems.push(
+      `DESIGN.md Fusion type is Single but atom-tree selected ${gameplayAtoms.length} gameplay atoms — use a real fusion type or document pseudo-fusion`,
+    );
+  } else if (type !== 'Single' && !REAL_FUSION_TYPES.has(type) && !isPseudoFusion) {
+    problems.push(`DESIGN.md Fusion type "${type}" is not a recognized fusion classification`);
+  }
+
+  const gameSource = overrides.gameSource ?? (await collectGameSource(root));
+  if (!gameSource.trim()) {
+    problems.push('game/ source missing — cannot verify fusion wiring');
+    return { ok: false, problems, gameplayAtoms };
+  }
+
+  const wiring = {};
+  for (const atomId of gameplayAtoms) {
+    const hits = matchedSignatures(gameSource, atomId);
+    wiring[atomId] = hits;
+    if (hits.length === 0) {
+      problems.push(
+        `gameplay atom "${atomId}" has no wiring evidence in game/ (expected one of: ${(GAMEPLAY_SIGNATURES[atomId] ?? [atomId]).join(', ')})`,
+      );
+    }
+  }
+
+  const autoPlayBlock = extractAutoPlayBlock(gameSource);
+  if (autoPlayBlock) {
+    const autoPlayHits = gameplayAtoms.filter((atomId) =>
+      matchedSignatures(autoPlayBlock, atomId).length > 0,
+    );
+    if (autoPlayHits.length < gameplayAtoms.length) {
+      const missing = gameplayAtoms.filter((id) => !autoPlayHits.includes(id));
+      problems.push(
+        `autoPlay() does not reference all fused mechanics — missing evidence for: ${missing.join(', ')}`,
+      );
+    }
+  } else {
+    const referencedInSource = gameplayAtoms.filter((atomId) => gameSource.includes(atomId));
+    if (referencedInSource.length < gameplayAtoms.length) {
+      problems.push(
+        'autoPlay() block not found and not all selected gameplay atom ids appear in game/ source',
+      );
+    }
+  }
+
+  return {
+    ok: problems.length === 0,
+    problems,
+    gameplayAtoms,
+    wiring,
+    fusionType: type,
+  };
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  try {
+    const result = await verifyFusion(opts.root);
+    const artifactPayload = result.skipped
+      ? { ok: true, skipped: true, reason: result.reason }
+      : result;
+    await writeValidatorArtifact(opts.root, 'fusion', artifactPayload).catch(() => {});
+    if (result.skipped) {
+      const msg = `[verify:fusion] OK — ${result.reason}\n`;
+      process.stdout.write(msg);
+      if (opts.json) process.stdout.write(`${JSON.stringify({ ok: true, skipped: true, reason: result.reason })}\n`);
+      process.exit(0);
+    }
+
+    if (result.ok) {
+      const msg = `[verify:fusion] OK — ${result.gameplayAtoms.length} gameplay atoms wired (${result.gameplayAtoms.join(', ')})\n`;
+      process.stdout.write(msg);
+      if (opts.json) process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+      process.exit(0);
+    }
+
+    const detail = result.problems.join('\n  - ');
+    process.stderr.write(`[verify:fusion] FAIL\n  - ${detail}\n`);
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify({ ok: false, problems: result.problems, ...result })}\n`);
+    }
+    process.exit(2);
+  } catch (err) {
+    process.stderr.write(`[verify:fusion] error: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+const isMain =
+  process.argv[1] && basename(process.argv[1]) === 'verify-fusion.mjs';
+
+if (isMain) {
+  main();
+}

package/project-templates/phaser/skills/playable-record/scripts/verify-lifecycle.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Lightweight Ring 1 lifecycle probe.
+ *
+ * Boots the game, requires an initial HOOK phase, triggers autoPlay, and
+ * verifies that the phase path reaches ENDCARD without doing MP4 transcoding.
+ */
+
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runFirstWinProbe } from './verify-firstwin.mjs';
+import { writeValidatorArtifact } from '../../_shared/scripts/lib/validator-artifacts.mjs';
+
+function parseArgs(argv) {
+  const opts = {
+    root: process.cwd(),
+    url: null,
+    useDev: false,
+    port: 8080,
+    scene: 'MainScene',
+    timeout: 30_000,
+    headed: false,
+    json: false,
+  };
+  for (const arg of argv) {
+    if (arg === '--use-dev') opts.useDev = true;
+    else if (arg === '--headed') opts.headed = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg.startsWith('--root=')) {
+      const v = arg.slice('--root='.length);
+      opts.root = v.startsWith('/') ? v : resolve(process.cwd(), v);
+    } else if (arg.startsWith('--url=')) opts.url = arg.slice('--url='.length);
+    else if (arg.startsWith('--port=')) opts.port = Number(arg.slice('--port='.length));
+    else if (arg.startsWith('--scene=')) opts.scene = arg.slice('--scene='.length);
+    else if (arg.startsWith('--timeout=')) opts.timeout = Number(arg.slice('--timeout='.length));
+  }
+  return opts;
+}
+
+export function evaluateLifecycleResult(result) {
+  const problems = [...(result.problems || [])];
+  const path = result.phasePath || [];
+  if (result.ok) {
+    if (path[0] !== 'HOOK') problems.push('phase path must start at HOOK');
+    if (path[path.length - 1] !== 'ENDCARD') problems.push('phase path must reach ENDCARD');
+  }
+  return { ok: result.ok && problems.length === 0, problems, phasePath: path };
+}
+
+function printHuman(result) {
+  const evaluated = evaluateLifecycleResult(result);
+  console.log(`[verify:lifecycle] ${evaluated.ok ? 'OK' : 'FAIL'} — ${result.url}`);
+  if (result.phasePath) console.log(`  phase path: ${result.phasePath.join(' → ')}`);
+  if (result.elapsedMs != null) console.log(`  elapsed: ${result.elapsedMs}ms`);
+  for (const p of evaluated.problems) console.log(`  ✗ ${p}`);
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const result = await runFirstWinProbe(opts);
+  const evaluated = evaluateLifecycleResult(result);
+  const payload = { ...result, ...evaluated };
+  await writeValidatorArtifact(opts.root, 'lifecycle', payload).catch(() => {});
+  if (opts.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    printHuman(result);
+  }
+  process.exit(evaluated.ok ? 0 : 2);
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((err) => {
+    console.error(`[verify:lifecycle] ${err.message}`);
+    process.exit(1);
+  });
+}

package/project-templates/phaser/skills/playable-record/scripts/verify-slice-artist.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * slice-axis-v1 — Artist slice structure verifier (style / MC / ASR context).
+ * Checks validate/slice-artist/<sliceId>.json + artifactRefs exist — not asset quality.
+ *
+ * Usage: node skills/playable-record/scripts/verify-slice-artist.mjs --root=. [--json]
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  verifyArtistSliceStructure,
+  writeStructureReport,
+} from './lib/slice-structure-verify.mjs';
+
+function parseArgs(argv) {
+  const opts = { root: process.cwd(), json: false };
+  for (const arg of argv) {
+    if (arg === '--json') opts.json = true;
+    else if (arg.startsWith('--root=')) {
+      const v = arg.slice('--root='.length);
+      opts.root = v.startsWith('/') ? v : path.resolve(process.cwd(), v);
+    }
+  }
+  return opts;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const root = path.resolve(opts.root);
+  const result = verifyArtistSliceStructure(root);
+  writeStructureReport(root, result, 'slice-artist');
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`[verify:slice-artist] ${result.ok ? 'OK' : 'FAIL'} — slice ${result.sliceId || '(none)'}`);
+    for (const p of result.problems) console.log(`  ✗ ${p}`);
+    if (result.route) {
+      console.log(`  → routeTo: ${result.route.routeTo} (${result.route.failKey}): ${result.route.reason}`);
+    }
+  }
+  process.exit(result.ok ? 0 : 2);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((err) => {
+    console.error(`[verify:slice-artist] ${err.message}`);
+    process.exit(1);
+  });
+}
+
+export { verifyArtistSliceStructure };

package/project-templates/phaser/skills/playable-record/scripts/verify-slice-ta.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * slice-axis-v1 — TA slice structure verifier (production manifest / readiness / blockers).
+ * Checks validate/slice-ta/<sliceId>.json — not Ring 4 bulk production.
+ *
+ * Usage: node skills/playable-record/scripts/verify-slice-ta.mjs --root=. [--json]
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  verifyTaSliceStructure,
+  writeStructureReport,
+} from './lib/slice-structure-verify.mjs';
+
+function parseArgs(argv) {
+  const opts = { root: process.cwd(), json: false };
+  for (const arg of argv) {
+    if (arg === '--json') opts.json = true;
+    else if (arg.startsWith('--root=')) {
+      const v = arg.slice('--root='.length);
+      opts.root = v.startsWith('/') ? v : path.resolve(process.cwd(), v);
+    }
+  }
+  return opts;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const root = path.resolve(opts.root);
+  const result = verifyTaSliceStructure(root);
+  writeStructureReport(root, result, 'slice-ta');
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`[verify:slice-ta] ${result.ok ? 'OK' : 'FAIL'} — slice ${result.sliceId || '(none)'}`);
+    for (const p of result.problems) console.log(`  ✗ ${p}`);
+    if (result.route) {
+      console.log(`  → routeTo: ${result.route.routeTo} (${result.route.failKey}): ${result.route.reason}`);
+    }
+  }
+  process.exit(result.ok ? 0 : 2);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((err) => {
+    console.error(`[verify:slice-ta] ${err.message}`);
+    process.exit(1);
+  });
+}
+
+export { verifyTaSliceStructure };

package/project-templates/phaser/skills/playable-record/scripts/verify-slice.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * slice-axis-v1 — per-slice verifier (first-class). Judges ONLY the active
+ * slice's hypothesis from docs/project-state.json → sliceState, NOT the whole
+ * ring lifecycle (HOOK→ENDCARD). Ring gate still exists but cannot replace this.
+ *
+ * Ring 1 immediate-feedback probe (engine-neutral via window.__slice):
+ *   1. contract:  window.__playable + window.__slice exposed
+ *                 (__slice.getProgress / getFeedbackTicks / tapFirstTarget)
+ *   2. feedback:  one tapFirstTarget() increments getFeedbackTicks() (visible feedback fired)
+ *   3. progress:  one tapFirstTarget() increments getProgress() by exactly 1
+ *
+ * On failure emits the slice's declared fallbackRoute: { failKey, routeTo, reason }
+ * and writes validate/slice/<sliceId>.json. Exit 0 = pass, 2 = fail, 1 = error.
+ *
+ * NOTE: "slice" here = gameplay/implementation slice (≠ asset sprite slice used by
+ * mark:slices / verify:slice-plan). See docs/harness/slice-axis-design.md.
+ *
+ * Usage: node skills/playable-record/scripts/verify-slice.mjs --root=. --use-dev [--json]
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { detectDevUrl, startDevServer, startHttpServer, waitForHttp } from './lib/dev-server.mjs';
+import { getActiveSlice, readState } from '../../_shared/scripts/state-store.mjs';
+
+function parseArgs(argv) {
+  const opts = { root: process.cwd(), useDev: false, url: null, port: 8080, json: false };
+  for (const arg of argv) {
+    if (arg === '--use-dev') opts.useDev = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg.startsWith('--root=')) {
+      const v = arg.slice('--root='.length);
+      opts.root = v.startsWith('/') ? v : path.resolve(process.cwd(), v);
+    } else if (arg.startsWith('--url=')) opts.url = arg.slice('--url='.length);
+    else if (arg.startsWith('--port=')) opts.port = Number(arg.slice('--port='.length));
+  }
+  return opts;
+}
+
+function routeFor(slice, key) {
+  const fb = (slice && slice.fallbackRoute && slice.fallbackRoute[key]) || null;
+  if (fb) return { failKey: key, routeTo: fb.routeTo, reason: fb.reason };
+  return { failKey: key, routeTo: 'developer', reason: key };
+}
+
+export async function runSliceProbe(opts) {
+  const root = path.resolve(opts.root);
+  const slice = getActiveSlice(readState(root));
+  if (!slice) return { ok: false, problems: ['no active slice in docs/project-state.json (sliceState.activeSliceId is none)'], route: null };
+
+  const { chromium } = await import('playwright');
+  let server = null;
+  let browser = null;
+  let url = opts.url;
+  if (opts.url && !opts.useDev) {
+    /* external server */
+  } else if (opts.useDev) {
+    server = startDevServer(root);
+    url = await detectDevUrl(server, opts.url || 'http://127.0.0.1:3000/', 30000);
+  } else {
+    server = startHttpServer(opts.port, root);
+    url = `http://127.0.0.1:${opts.port}/game/index.html`;
+  }
+  const killServer = () => { if (server && !server.killed) server.kill('SIGTERM'); };
+
+  try {
+    await waitForHttp(url, 30000);
+    browser = await chromium.launch({ headless: true });
+    const context = await browser.newContext({ viewport: { width: 1080, height: 1920 } });
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: 'networkidle', timeout: 60000 });
+
+    const hasContract = await page
+      .waitForFunction(() => {
+        const s = window.__slice;
+        return !!(window.__playable
+          && s && typeof s.getProgress === 'function'
+          && typeof s.getFeedbackTicks === 'function'
+          && typeof s.tapFirstTarget === 'function');
+      }, null, { timeout: 15_000 })
+      .then(() => true)
+      .catch(() => false);
+    if (!hasContract) {
+      return { ok: false, sliceId: slice.sliceId, problems: ['window.__playable / window.__slice probe not exposed (need getProgress/getFeedbackTicks/tapFirstTarget)'], route: routeFor(slice, 'contractMissing'), url };
+    }
+
+    const before = await page.evaluate(() => ({ p: window.__slice.getProgress(), f: window.__slice.getFeedbackTicks() }));
+    await page.evaluate(() => window.__slice.tapFirstTarget());
+    await page.waitForTimeout(150);
+    const after = await page.evaluate(() => ({ p: window.__slice.getProgress(), f: window.__slice.getFeedbackTicks() }));
+
+    if (!(after.f > before.f)) {
+      return { ok: false, sliceId: slice.sliceId, problems: [`feedback ticks did not increase after tap (before=${before.f}, after=${after.f})`], route: routeFor(slice, 'feedbackMissing'), url, before, after };
+    }
+    if (after.p !== before.p + 1) {
+      return { ok: false, sliceId: slice.sliceId, problems: [`progress did not go +1 after tap (before=${before.p}, after=${after.p})`], route: routeFor(slice, 'progressMissing'), url, before, after };
+    }
+    return { ok: true, sliceId: slice.sliceId, problems: [], route: null, url, before, after };
+  } finally {
+    if (browser) await browser.close().catch(() => {});
+    killServer();
+  }
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const root = path.resolve(opts.root);
+  const activeSlice = getActiveSlice(readState(root));
+  const activeSliceId = activeSlice?.sliceId ?? null;
+  let result;
+  try {
+    result = await runSliceProbe(opts);
+  } catch (err) {
+    result = {
+      ok: false,
+      sliceId: activeSliceId,
+      problems: [`probe error: ${err.message}`],
+      route: null,
+    };
+  }
+  try {
+    const dir = path.join(root, 'validate/slice');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${result.sliceId || 'active'}.json`), `${JSON.stringify(result, null, 2)}\n`);
+  } catch { /* ignore */ }
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`[verify:slice] ${result.ok ? 'OK' : 'FAIL'} — slice ${result.sliceId || '(none)'}${result.url ? ` @ ${result.url}` : ''}`);
+    for (const p of result.problems) console.log(`  ✗ ${p}`);
+    if (result.route) console.log(`  → routeTo: ${result.route.routeTo} (${result.route.failKey}): ${result.route.reason}`);
+    if (result.before && result.after) console.log(`  progress ${result.before.p}->${result.after.p}, feedbackTicks ${result.before.f}->${result.after.f}`);
+  }
+  process.exit(result.ok ? 0 : 2);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((err) => { console.error(`[verify:slice] ${err.message}`); process.exit(1); });
+}