@looop-games/cli 0.1.36 → 0.1.37

package/CHANGELOG.md

@@ -14,6 +14,14 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.37] - 2026-09-06
+
+- Windows: stopping a development or smoke stack terminates its worker descendants, releasing their ports and temporary folders.
+
+- Windows: selective test runs recognize short and long names for the same project folder, and replay export accepts destinations inside the game folder.
+
+- Test submissions with `looop test --since <base>`: ordinary checks plus explicitly triggered extended tests in `looop.tests.json`; `--list` explains selection and `--all` runs an explicit audit. Smoke stacks disable reload watchers, and module serving avoids repeated filesystem lookups within each dependency walk.
+
 ## [0.1.36] - 2026-09-04
 
 ### Added

package/bin/looop.mjs

@@ -8,6 +8,7 @@ import { lane } from '../lib/lane.mjs';
 import { login, whoami } from '../lib/login.mjs';
 import { publish } from '../lib/publish.mjs';
 import { create } from '../lib/create.mjs';
+import { parseTestArgs } from '../lib/test-policy.mjs';
 import { testCmd } from '../lib/test-cmd.mjs';
 import { lintCmd } from '../lib/lint.mjs';
 import { update } from '../lib/update.mjs';
@@ -30,7 +31,9 @@ Usage:
   looop dev [--port <n>]     Run the full dev stack (game + multiplayer + services)
   looop assets [<id>]       Browse and drive your models, sounds and assets on their own
   looop lane <name>          Open an isolated copy of the game to experiment in, safely
-  looop test                 Run the game's tests (*.test.mjs) and smokes (*.smoke.mjs)
+  looop test [aspect]        Run targeted checks (no aspect: conservative full run)
+  looop test --since <base>  Submission: ordinary + triggered extended checks
+  looop test --all           Explicit full audit; add --list to preview selection
   looop lint [--fix]         Check the game against the Looop rules (runs inside 'looop test')
   looop changelog [<v>]      What changed in the engine (default: everything newer than your pin)
   looop update [--rc <v>]    Move this game to the latest engine release (--rc <v> takes a specific pre-release)
@@ -90,9 +93,7 @@ try {
       await create({ name: rest.find((a) => !a.startsWith('--')) });
       break;
     case 'test': {
-      // Positional args scope the run: `looop test charge` runs only files whose
-      // path contains "charge". Flags are left for future options (e.g. --changed).
-      const { ok } = await testCmd({ patterns: rest.filter((a) => !a.startsWith('--')) });
+      const { ok } = await testCmd(parseTestArgs(rest));
       process.exit(ok ? 0 : 1);
     }
     case 'lint': {

package/lib/dev.mjs

@@ -8,6 +8,7 @@
 // Multiplayer runs from minute one — the platform is not optional (the Next
 // analogy deliberately breaks there). NO_MP=1 opts out for purely-SP work.
 import { spawn } from 'node:child_process';
+import { terminateChildTree } from './process-tree.mjs';
 import { existsSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname, basename } from 'node:path';
@@ -50,7 +51,7 @@ export function partykitBin() {
 // and publish disagreed and a creator's primitive ran in production but not on
 // their own machine. One question, one answer, both commands.
 
-export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP === '1', log = console.log } = {}) {
+export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP === '1', watch = true, log = console.log } = {}) {
   const project = findProject(cwd);
   // Q4 revision: the engine is not an npm dependency — install/refresh it from
   // the platform's login-gated registry (no-op when the pinned version is in).
@@ -112,19 +113,8 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   const ownServer = roomServerCwd !== engine.roomServerDir;
 
   const stop = () => {
-    for (const c of children) {
-      // partykit is npx-style: node wrapper forks workerd. Kill the tree.
-      try {
-        process.kill(-c.pid, 'SIGTERM');
-      } catch {
-        try {
-          c.kill('SIGTERM');
-        } catch {
-          /* gone */
-        }
-      }
-    }
     for (const s of servers) s.close();
+    for (const c of children) terminateChildTree(c);
   };
 
   // ─── static ───
@@ -159,14 +149,15 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
       { url: '/shared/', dir: overridesDir },
       { url: '/shared/', dir: engine.sharedDir },
     ],
-    watchDirs: [project.dir, engine.sharedDir],
+    watchDirs: watch ? [project.dir, engine.sharedDir] : [],
+    injectReload: watch,
     // Present only for a framework-v2 game — injects the looop import map + the
     // lowered skeleton into the entry HTML so startGame() boots in the browser.
     skeleton: roomSkeleton,
   });
   await staticServer.listen(ports.static);
   servers.push(staticServer);
-  log(`→ static      :${ports.static}  (serving ${project.dir}, engine ${engine.version}, auto-reload on)`);
+  log(`→ static      :${ports.static}  (serving ${project.dir}, engine ${engine.version}, auto-reload ${watch ? 'on' : 'off'})`);
 
   // ─── multiplayer (partykit on the bundle's room code) ───
   // A single-player framework-v2 game (no config({ multiplayer: true })) runs its
@@ -187,7 +178,7 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
     // partykit reloader below does this as a side effect; single-player needs a
     // stripped-down version with no child to respawn. (NO_MP on a real multiplayer
     // game has no client to serve a skeleton to, so it needs none.)
-    if (singlePlayer) {
+    if (singlePlayer && watch) {
       const skelWatcher = createFileWatcher({
         files: roomInputs,
         dirs: ['entities', 'components', 'overrides/shared/ui/room'].map((d) => join(project.dir, d)),
@@ -226,28 +217,27 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
       return pk;
     };
     const killMp = async (pk) => {
+      if (pk.pid == null) return;
+      // Keep ownership when termination fails so stop() can retry the tree.
+      // Child exit callbacks cannot run between these synchronous statements.
+      terminateChildTree(pk);
       const idx = children.indexOf(pk);
       if (idx !== -1) children.splice(idx, 1);
-      if (pk.pid == null) return; // never started — nothing to reap, and 'exit' will never fire
       const exited = new Promise((resolveExit) => {
         if (pk.exitCode !== null || pk.signalCode !== null) return resolveExit();
-        pk.once('exit', resolveExit);
-        pk.once('error', resolveExit);
+        const onExit = () => {
+          pk.removeListener('exit', onExit);
+          pk.removeListener('error', onExit);
+          resolveExit();
+        };
+        pk.once('exit', onExit);
+        pk.once('error', onExit);
       });
-      try {
-        process.kill(-pk.pid, 'SIGTERM');
-      } catch {
-        try {
-          pk.kill('SIGTERM');
-        } catch {
-          /* gone */
-        }
-      }
       // partykit is a node wrapper forking workerd; if the tree ignores TERM,
       // escalate — the port must be free before the replacement binds it.
       const hardKill = setTimeout(() => {
         try {
-          process.kill(-pk.pid, 'SIGKILL');
+          terminateChildTree(pk, 'SIGKILL');
         } catch {
           /* gone */
         }
@@ -315,18 +305,18 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
       },
     });
     reloader.attach(roomServerCwd, pk);
-    roomWatcher = createFileWatcher({
+    roomWatcher = watch ? createFileWatcher({
       files: roomInputs,
       dirs: ['entities', 'components', 'overrides/shared/ui/room'].map((d) => join(project.dir, d)),
       onChange: reloader.onChange,
-    });
+    }) : null;
     // stop() (e.g. `looop test` tearing down its stack) must also stop the
     // reloader: a rebuild in flight would otherwise spawn a replacement room
     // child AFTER the children list was killed — a leaked detached process.
     servers.push({
       close: () => {
         reloader.stop();
-        roomWatcher.close();
+        roomWatcher?.close();
       },
     });
   }

package/lib/inject.mjs

@@ -137,7 +137,7 @@ function fileInfo(path) {
     return null;
   }
   const hit = parseCache.get(path);
-  if (hit && hit.mtimeMs === st.mtimeMs) return hit;
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.ctimeMs === st.ctimeMs && hit.size === st.size) return hit;
   const specs = [];
   if (/\.(js|mjs)$/.test(path)) {
     let text = null;
@@ -152,35 +152,48 @@ function fileInfo(path) {
       }
     }
   }
-  const info = { mtimeMs: st.mtimeMs, specs };
+  const info = { mtimeMs: st.mtimeMs, ctimeMs: st.ctimeMs, size: st.size, specs };
   parseCache.set(path, info);
   return info;
 }
 
-// Walk in URL space: each node is a URL path, mapped to bytes through the
-// server's mount table. `memo` (shared across one rewrite pass) short-circuits
-// only entry nodes — a spec repeated in one body — not intermediates.
-function closureStampUrl(urlPath, resolveUrl, memo) {
-  if (memo?.has(urlPath)) return memo.get(urlPath);
+// A rewrite shares resolved nodes across all import closures. Each URL is
+// resolved/stat'ed once even when several roots reach it. The cache belongs to
+// this synchronous rewrite only: the next request observes edits, deletions and
+// newly-created overrides immediately, without waiting for the reload watcher.
+function rewriteContext(resolveUrl) {
+  const nodes = new Map();
+  return {
+    stamps: new Map(),
+    node(url) {
+      if (!nodes.has(url)) {
+        const path = resolveUrl(url);
+        nodes.set(url, path ? fileInfo(path) : null);
+      }
+      return nodes.get(url);
+    },
+  };
+}
+
+function closureStampUrl(urlPath, context) {
+  if (context.stamps.has(urlPath)) return context.stamps.get(urlPath);
   let max = 0;
   const seen = new Set();
   const stack = [urlPath];
   while (stack.length) {
-    const u = stack.pop();
-    if (seen.has(u)) continue;
-    seen.add(u);
-    const fs = resolveUrl(u);
-    if (!fs) continue;
-    const info = fileInfo(fs);
+    const url = stack.pop();
+    if (seen.has(url)) continue;
+    seen.add(url);
+    const info = context.node(url);
     if (!info) continue;
-    if (info.mtimeMs > max) max = info.mtimeMs;
+    max = Math.max(max, info.mtimeMs);
     for (const spec of info.specs) {
-      const child = resolveSpecToUrl(spec, u);
+      const child = resolveSpecToUrl(spec, url);
       if (child) stack.push(child);
     }
   }
   const stamp = max ? Math.floor(max) : null;
-  memo?.set(urlPath, stamp);
+  context.stamps.set(urlPath, stamp);
   return stamp;
 }
 
@@ -192,28 +205,28 @@ function closureStampUrl(urlPath, resolveUrl, memo) {
 // disk-space fallback. Resolving a relative spec beside the importer on disk
 // stamps the wrong file whenever a mount shadows it (the overrides mechanism),
 // which silently re-opens the staleness hole. No serving context → no stamp.
-function versionedPath(relPath, { baseUrl, resolveUrl, allowBareRelative = false, memo }) {
+function versionedPath(relPath, { baseUrl, resolveUrl, allowBareRelative = false, context }) {
   if (!/\.(js|mjs|json)$/.test(relPath)) return null;
   if (baseUrl == null || !resolveUrl) return null;
   const urlTarget = resolveSpecToUrl(relPath, baseUrl, { allowBareRelative });
   if (!urlTarget) return null;
-  if (!resolveUrl(urlTarget)) return null; // nothing serves it — leave the spec alone
-  const stamp = closureStampUrl(urlTarget, resolveUrl, memo);
+  if (!context.node(urlTarget)) return null;
+  const stamp = closureStampUrl(urlTarget, context);
   return stamp === null ? null : `${relPath}?v=${stamp}`;
 }
 
 export function rewriteJsImports(text, { baseUrl, resolveUrl }) {
-  const memo = new Map();
+  const context = rewriteContext(resolveUrl);
   return text.replace(JS_IMPORT_RE, (whole, prefix, quote, path) => {
-    const v = versionedPath(path, { baseUrl, resolveUrl, memo });
+    const v = versionedPath(path, { baseUrl, resolveUrl, context });
     return `${prefix}${quote}${v ?? path}${quote}`;
   });
 }
 
 export function rewriteHtmlScripts(html, { baseUrl, resolveUrl }) {
-  const memo = new Map();
+  const context = rewriteContext(resolveUrl);
   return html.replace(HTML_SCRIPT_RE, (whole, prefix, path, suffix) => {
-    const v = versionedPath(path, { baseUrl, resolveUrl, allowBareRelative: true, memo });
+    const v = versionedPath(path, { baseUrl, resolveUrl, allowBareRelative: true, context });
     return `${prefix}${v ?? path}${suffix}`;
   });
 }

package/lib/process-tree.mjs

@@ -0,0 +1,30 @@
+import { execFileSync } from 'node:child_process';
+import { win32 } from 'node:path';
+
+// PartyKit owns worker descendants. Windows has no Unix process groups, so
+// killing its wrapper alone can leave a worker holding ports and directories.
+export function terminateChildTree(child, signal = 'SIGTERM', {
+  platform = process.platform, exec = execFileSync, kill = process.kill,
+} = {}) {
+  if (child.pid == null) return;
+  if (platform === 'win32') {
+    if (child.exitCode != null || child.signalCode != null) return;
+    const taskkill = win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'taskkill.exe');
+    try {
+      exec(taskkill, ['/PID', String(child.pid), '/T', '/F'], {
+        stdio: 'pipe', timeout: 5000, windowsHide: true,
+      });
+    } catch (error) {
+      // An already-exited child is harmless; a live tree that could not be
+      // terminated must fail shutdown rather than silently leak workers.
+      try { kill(child.pid, 0); } catch (probe) {
+        if (probe.code === 'ESRCH') return;
+      }
+      throw error;
+    }
+    return;
+  }
+  try { kill(-child.pid, signal); } catch {
+    child.kill(signal);
+  }
+}

package/lib/replay-cmd.mjs

@@ -4,7 +4,7 @@
 // hand both to the exporter, and then say enough about what came out that the
 // next step is obvious. The table's shape and every decision about it live in
 // replay-export.mjs; nothing here knows what a column is.
-import { join, relative, resolve } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
 import { statSync } from 'node:fs';
 import { findProject } from './project.mjs';
 import { streamDir } from './replay-store.mjs';
@@ -82,7 +82,7 @@ export async function replayExport({
   const outDir = out ? resolve(project.dir, out) : join(project.dir, ...EXPORTS_DIR);
   // The tables are tens of megabytes and this creates directories to hold them.
   // A path that climbs out of the game folder is a typo, not an intention.
-  if (outDir !== project.dir && !outDir.startsWith(`${resolve(project.dir)}/`)) {
+  if (outDir !== project.dir && !outDir.startsWith(`${resolve(project.dir)}${sep}`)) {
     throw new Error(`--out must be inside the game folder, and ${out} is not`);
   }
   const engine = await ensureEngineImpl(project.dir, { log });

package/lib/test-cmd.mjs

@@ -2,11 +2,12 @@
 //
 // Discovers the game's test files — `*.test.mjs` (unit, run under
 // `node --test`) and `*.smoke.mjs` (integration, run against a REAL dev
-// stack) — and runs them all. The files ARE the executable QA list: `/qa`
+// stack) — and selects ordinary plus triggered extended checks. The files ARE the executable QA list: `/qa`
 // merges this gate with handbook/qa.md and the engine's master qa.md.
 //
 // The smoke stack boots on a free shifted port triple so it never seizes a
 // dev server the creator has running on :8000.
+import { selectTests, readTestPolicy, changedTestPaths } from './test-policy.mjs';
 import { spawn } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
@@ -93,29 +94,36 @@ function looopTestPreload(projectDir) {
   }
 }
 
-export async function testCmd({ cwd = process.cwd(), log = console.log, devFn = dev, lintFn = lintCmd, runFn = run, patterns = [] } = {}) {
+export async function testCmd({ cwd = process.cwd(), log = console.log, devFn = dev, lintFn = lintCmd, runFn = run, patterns = [], since, all: runAll = false, list = false } = {}) {
   const project = findProject(cwd);
 
-  // Freshness gate: referenced 3D models re-bake if their GLB or bake config
-  // changed, BEFORE anything runs — a stale artifact means every hit test in
-  // the suite exercises a surface the player no longer sees. A bake failure
-  // fails the gate with the model named.
-  const { ensureBaked } = await import('./model-bake.mjs');
-  await ensureBaked({ dir: project.dir, log });
-
+  if ((since && runAll) || (patterns.length && (since || runAll))) throw new Error('Choose patterns, --since, or --all');
   const all = discoverTestFiles(project.dir);
-
-  // Scoped run (`looop test <pattern>…`): keep only files whose path contains a
-  // pattern. The file-naming convention already encodes the aspect
-  // (`charge.smoke.mjs`, `riven-charge.test.mjs`), so a substring on the path
-  // reaches both a unit test and its smoke without any source→test mapping.
-  // This is a PER-STEP speed lever, not the gate — the full suite still runs at
-  // milestone close and before publish (qa.md T3). With no pattern, everything
-  // runs, exactly as before.
+  const files = [...all.unit, ...all.smokes];
+  const policy = readTestPolicy(project.dir, files);
   const scoped = patterns.length > 0;
-  const matches = (f) => patterns.some((p) => posixRelative(project.dir, f).includes(p));
-  const unit = scoped ? all.unit.filter(matches) : all.unit;
-  const smokes = scoped ? all.smokes.filter(matches) : all.smokes;
+  let changed;
+  if (since) {
+    try { changed = changedTestPaths(project.dir, since); }
+    catch (error) { log(`⚠ Cannot compare with ${since}: ${error.message}. Including every extended test.`); }
+  }
+  const selection = scoped
+    ? { files: files.filter((f) => patterns.some((p) => posixRelative(project.dir, f).includes(p))), skipped: [], reason: 'targeted step checks' }
+    : selectTests({ dir: project.dir, files, policy, changed, all: runAll });
+  const selected = new Set(selection.files);
+  const unit = all.unit.filter((f) => selected.has(f));
+  const smokes = all.smokes.filter((f) => selected.has(f));
+  log(`▶ ${selection.reason}: ${selected.size} of ${files.length} test files`);
+  for (const entry of policy?.extended ?? []) {
+    const included = selection.files.some((f) => posixRelative(project.dir, f) === entry.test);
+    log(`  ${included ? 'include' : 'defer'} extended ${entry.test} — ${entry.reason}`);
+  }
+  if (list) {
+    for (const file of selection.files) log(`  ${posixRelative(project.dir, file)}`);
+    return { ok: !scoped || selected.size > 0, ran: 0, selection };
+  }
+  const { ensureBaked } = await import('./model-bake.mjs');
+  await ensureBaked({ dir: project.dir, log });
 
   // Lint FIRST — it needs no servers and no browser, and the defects it catches
   // (a hardcoded multiplayer host, a smoke pointed at the wrong port) are
@@ -123,8 +131,7 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
   // Failing here does not skip the tests: the creator should see everything
   // that is wrong in one run, not peel it one gate at a time.
   //
-  // A SCOPED run skips it: lint is the full gate's job and runs at milestone
-  // close with the whole suite — a `looop test <pattern>` is a focused per-step
+  // A SCOPED run skips it: lint runs at the submission gate — a `looop test <pattern>` is a focused per-step
   // re-run, not the gate.
   const lint = scoped ? { ok: true, skipped: true } : await lintFn({ cwd: project.dir, log });
 
@@ -145,7 +152,7 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
   }
 
   if (patterns.length) {
-    log(`▶ scoped to ${patterns.map((p) => `"${p}"`).join(', ')}: ${unit.length + smokes.length} of ${all.unit.length + all.smokes.length} file(s) — full suite still runs at milestone close.`);
+    log(`▶ scoped to ${patterns.map((p) => `"${p}"`).join(', ')}: ${unit.length + smokes.length} of ${all.unit.length + all.smokes.length} file(s) — broader coverage runs at submission.`);
   }
 
   let ok = lint.ok;
@@ -190,11 +197,13 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
       }
     }
 
-    const handle = await devFn({ cwd: project.dir, port: await freeTestPort(), log: () => {} });
+    const handle = await devFn({ cwd: project.dir, port: await freeTestPort(), watch: false, log: () => {} });
     log(`▶ smokes against ${handle.url}`);
     try {
       for (const file of smokes) {
         const rel = relative(project.dir, file);
+        const started = performance.now();
+        log(`  ▶ ${rel}`);
         const code = await runFn(['--import', SMOKE_PRELOAD, ...looopImport, file], {
           cwd: project.dir,
           env: {
@@ -206,7 +215,7 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
             URL: handle.url,
           },
         });
-        log(`  ${code === 0 ? '✅' : '❌'} ${rel}`);
+        log(`  ${code === 0 ? '✅' : '❌'} ${rel} (${((performance.now() - started) / 1000).toFixed(2)}s)`);
         if (code !== 0) ok = false;
       }
     } finally {
@@ -216,5 +225,5 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
 
   log('');
   log(ok ? `✅ looop test: all green (${unit.length} unit file(s), ${smokes.length} smoke(s))` : '❌ looop test: failures above');
-  return { ok, ran: unit.length + smokes.length, lint };
+  return { ok, ran: unit.length + smokes.length, lint, selection };
 }

package/lib/test-policy.mjs

@@ -0,0 +1,100 @@
+// Extended tests are opt-in declarations; every undeclared test stays ordinary.
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, relative, resolve } from 'node:path';
+
+const POLICY = 'looop.tests.json';
+const posix = (s) => s.replaceAll('\\', '/');
+
+function matcher(pattern) {
+  if (typeof pattern !== 'string' || !pattern || pattern.startsWith('/') || pattern.includes('\\') || pattern.split('/').includes('..') || /[\[\]{}]/.test(pattern)) {
+    throw new Error(`${POLICY}: patterns must be relative paths using /, *, ** or ?`);
+  }
+  let source = '^';
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === '*' && pattern[i + 1] === '*') {
+      i++;
+      if (pattern[i + 1] === '/') { i++; source += '(?:.*/)?'; }
+      else source += '.*';
+    } else if (c === '*') source += '[^/]*';
+    else if (c === '?') source += '[^/]';
+    else source += c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+  return new RegExp(source + '$');
+}
+
+function patterns(value, label, { nonempty = false } = {}) {
+  if (!Array.isArray(value) || (nonempty && !value.length)) throw new Error(`${POLICY}: ${label} must be ${nonempty ? 'a nonempty' : 'an'} array`);
+  return value.map(matcher);
+}
+const matches = (path, rules) => rules.some((rule) => rule.test(path));
+
+export function readTestPolicy(dir, files) {
+  const path = join(dir, POLICY);
+  if (!existsSync(path)) return null;
+  const raw = JSON.parse(readFileSync(path, 'utf8'));
+  if (raw.version !== 1 || !Array.isArray(raw.extended)) throw new Error(`${POLICY}: expected version 1 and an extended array`);
+  const allowed = ['version', 'extended', 'ordinaryChanges', 'always'];
+  if (Object.keys(raw).some((k) => !allowed.includes(k))) throw new Error(`${POLICY}: unknown top-level field`);
+  const known = new Set(files.map((f) => posix(relative(dir, f))));
+  const seen = new Set();
+  const extended = raw.extended.map((entry) => {
+    if (!entry || typeof entry.test !== 'string' || !known.has(entry.test) || seen.has(entry.test)) throw new Error(`${POLICY}: extended test is missing or duplicated: ${entry?.test}`);
+    if (Object.keys(entry).some((k) => !['test', 'when', 'reason'].includes(k))) throw new Error(`${POLICY}: unknown field for ${entry.test}`);
+    if (typeof entry.reason !== 'string' || !entry.reason.trim()) throw new Error(`${POLICY}: ${entry.test} needs a reason`);
+    seen.add(entry.test);
+    return { ...entry, rules: patterns(entry.when, `${entry.test}.when`, { nonempty: true }) };
+  });
+  return {
+    extended,
+    ordinary: patterns(raw.ordinaryChanges ?? [], 'ordinaryChanges'),
+    always: patterns(raw.always ?? [], 'always'),
+  };
+}
+
+// Name-only without rename detection returns both sides of moves. NUL delimiters
+// preserve spaces/newlines, and -- separates paths from command-line options.
+export function changedTestPaths(dir, since) {
+  const git = (args) => execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (!since || since.startsWith('-')) throw new Error('test --since needs an integration base, not an option');
+  const root = realpathSync.native(git(['rev-parse', '--show-toplevel']).trim());
+  const projectDir = realpathSync.native(dir);
+  const base = git(['merge-base', 'HEAD', since]).trim();
+  const changed = git(['-C', root, 'diff', '--no-relative', '--name-only', '--no-renames', '-z', base, '--']);
+  const untracked = git(['-C', root, 'ls-files', '--others', '--exclude-standard', '-z']);
+  return [...new Set((changed + untracked).split('\0').filter(Boolean).map((p) => posix(relative(projectDir, resolve(root, p)))))];
+}
+
+export function selectTests({ dir, files, policy, changed, all = false }) {
+  if (!policy || all) return { files, skipped: [], reason: all ? 'explicit --all audit' : 'all tests are ordinary (no policy)' };
+  if (!changed) return { files, skipped: [], reason: 'no integration base; including all extended tests (use --since <base> at submission)' };
+  const extended = new Map(policy.extended.map((entry) => [entry.test, entry]));
+  const testPaths = new Set(files.map((f) => posix(relative(dir, f))));
+  const broad = changed.find((p) => p === POLICY || matches(p, policy.always) || (!testPaths.has(p) && !matches(p, policy.ordinary) && !policy.extended.some((e) => matches(p, e.rules))));
+  if (broad) return { files, skipped: [], reason: `broad coverage: ${broad} is a foundation, policy, or unmapped change` };
+  const selected = files.filter((file) => {
+    const path = posix(relative(dir, file));
+    const entry = extended.get(path);
+    return !entry || changed.some((p) => p === path || matches(p, entry.rules));
+  });
+  const selectedSet = new Set(selected);
+  return { files: selected, skipped: files.filter((f) => !selectedSet.has(f)), reason: 'ordinary regressions plus extended tests triggered by changes' };
+}
+
+export function parseTestArgs(args) {
+  const options = { patterns: [], all: false, list: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--all') options.all = true;
+    else if (arg === '--list') options.list = true;
+    else if (arg === '--since') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) throw new Error('test --since requires a git integration base');
+      options.since = value;
+    } else if (arg.startsWith('-')) throw new Error(`Unknown test option: ${arg}`);
+    else options.patterns.push(arg);
+  }
+  if ((options.all && options.since) || (options.patterns.length && (options.all || options.since))) throw new Error('Choose test <pattern>, test --since <base>, or test --all');
+  return options;
+}

package/lib/test-selection-cli.mjs

@@ -0,0 +1,18 @@
+// Adapter for runners with their own discovery rules. Stdout is NUL-delimited
+// selected paths; explanations go to stderr so filenames remain lossless.
+import { readTestPolicy, changedTestPaths, selectTests } from './test-policy.mjs';
+const [dir, since, ...files] = process.argv.slice(2);
+try {
+  const policy = readTestPolicy(dir, files);
+  let changed;
+  if (since !== '--all') {
+    try { changed = changedTestPaths(dir, since); }
+    catch (error) { console.error(`Cannot compare with ${since}: ${error.message}. Including all tests.`); }
+  }
+  const selection = selectTests({ dir, files, policy, changed, all: since === '--all' });
+  console.error(`Test selection: ${selection.reason}; ${selection.files.length} selected, ${selection.skipped.length} deferred.`);
+  process.stdout.write(selection.files.map((file) => file + '\0').join(''));
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,7 +17,7 @@
     "node": ">=20.11"
   },
   "scripts": {
-    "test": "node --test 'lib/*.test.mjs'"
+    "test": "node scripts/run-tests.mjs"
   },
   "dependencies": {
     "cross-spawn": "^7.0.6",