@homie-rocks/studio 0.37.2 → 0.39.0

package/CHANGELOG.md

@@ -17,6 +17,67 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.39.0] - 2026-10-09
+
+**Plugin 0.39.0** · [#78](https://github.com/homie-rocks/homie/pull/78)
+
+Your studio has its own MCP server. Connect your AI with one browser approval and add tools for the work your studio does.
+
+### Added
+
+- Connect Claude, ChatGPT or Grok to your studio's own `/mcp` address. Use your existing studio account; there is no key to find or copy. Client setup and workspace policies still apply.
+- Let your AI use the office, app records, shared parts and marked guide seats in rooms. Staff keep their own app permissions. Destructive office controls still wait for your confirmation.
+- Add a typed tool with `homie-studio tool new`, test it with `tool call` and share its code as a part. Tools can also supply prompts and signed inbound integrations; readable app records are resources.
+- Review AI connections and recent tool calls in the office. Revoke a connection there. Role checks, validated input and configurable call limits apply on the server.
+
+### Changed
+
+- Worker builds keep MCP libraries in separate modules, loaded when that surface is used. Ordinary page traffic performs no MCP storage work.
+
+### Fixed
+
+- Browser input checks wait for the final touch movement to reach the game before measuring its response, including when Chrome delays delivery. Successful browser calls clear their timeout timers.
+
+- Clean installs on Node 24 include the MCP SDK required by the payment library, so purchase tools and selling builds work alongside the studio MCP server.
+- MCP integration tests close clients after failures as well as successes. The desktop check clears request timers instead of waiting an extra minute after success. Package and plugin test files have a hard timeout.
+
+### Upgrade notes
+
+- Ask your AI to upgrade and build your studio. The build writes Worker modules and the normal deploy applies the new connection and audit tables. No separate Homie service or Cloudflare resource is needed.
+- Studio tools are trusted code in your Worker. Review tools received as parts before adding them. The tool context does not expose raw credentials.
+
+## [0.38.0] - 2026-10-09
+
+**Plugin 0.39.0**
+
+Your own character answers as soon as you press, even when the room runs on the server.
+
+### Added
+
+- Rules games predict your own movement with the same movement code the host runs. They ease corrections from the host and smoothly draw everyone else. Authors get this through the view library.
+- The build checks that browser movement agrees with the server and stays within its budget.
+
+### Changed
+
+- New Gem Rush games use rules plus view, with the server keeping movement, pickups and scores. The canvas, controls, waves and knockback keep their familiar look and play. Coin Dash also uses server movement with prediction.
+
+### Fixed
+
+- Rules prediction keeps movement continuous when snapshots replace its catch-up path or its input clock recalibrates, fixing backward steps on delayed, lossy connections.
+- A rules correction that catches up to the current fractional tick uses the next movement preview instead of holding still and jumping when the next whole tick arrives. Snapshots also preserve the drawn catch-up pose when they replace its history. Offset fading is bounded by normal movement speed, so it does not compound a fast knock's catch-up speed.
+- Gem Rush reports its downward Y axis to the rules probe, so control checks judge its actual on-screen direction. Rules views can supply their camera axes through `screenBasis`.
+- Playtest no longer attributes its default timeout duration to a rules game that declares no round duration in `game.json`.
+- Perf checks body presence in the last drawn frame without imposing a hidden 400 ms frame-rate requirement on software rendering.
+- Studio checks accept two replicas when the server hosts the rules. Perf reports and regression guards include both replicas, and choose a replica as the default goal for server rooms.
+- Shoot sends held keys to the game frame and reports a server-only preview without a running room as not playing. Its saved receipt now includes the final verdict.
+- The Game Lab exits after writing its completed report, even when Chrome leaves a pipe open. Coin Dash includes a reproducible Lab take.
+- Control timing starts at the game frame's receipt of a key or completed thumb gesture, judges the first changed frame, collects enough frames on a slow renderer, and measures the round clock between matching observations (including slow screenshots). The response and steering limits are unchanged.
+- The controls check exercises a browser disconnect and late joining in server rooms as well as host takeover in browser rooms. A hold with too little runway is repeated after moving away from the wall, with the same steering requirements.
+
+### Upgrade notes
+
+- Existing games keep their own source when you upgrade. Games written the old way keep working.
+
 ## [0.37.2] - 2026-10-09
 
 **Plugin 0.38.2** · [#70](https://github.com/homie-rocks/homie/pull/70)

package/bin/homie-studio.mjs

@@ -155,6 +155,8 @@
  *   homie-studio servers new <game> "<Name>" --policy open|humans-only|hybrid|beginner [--ai <n>] [--guides <n>]
  *                                        [--kids] [--door open|accounts|invite] [--level 1-5] [--level-max 1-5]
  *                                        [--speech game|lines|off] [--bots fill|off] [--rooms <n>] [--listed on|off]
+ *   homie-studio tool new <name> [--app <id>]
+ *   homie-studio tool call <name> --input <JSON> [--url <site>] [--public]
  *   homie-studio servers set <game> <server> [the same flags]
  *   homie-studio servers close <game> <server> [--reopen]
  *   homie-studio servers level <game> <room> <1-5>   (the AI's level in one room: Rookie, Steady, Fair, Strong, Maxed)
@@ -336,7 +338,7 @@ import { publish, publishBefore } from '../lib/directory.mjs';
 import { look } from '../lib/look.mjs';
 import { importPort, planPort } from '../lib/port.mjs';
 import { portCheck } from '../lib/port-check.mjs';
-import { DEFAULT_GOAL, perfCompare, perfRun, perfSizes } from '../lib/perf.mjs';
+import { perfCompare, perfRun, perfSizes } from '../lib/perf.mjs';
 import { LAB_PORT, labServe, labSet, labStop } from '../lib/lab.mjs';
 import { R2_COST, lineOf, mediaPlan, r2OverOf, recordUpload, resolveMedia, sizeOf, typeOf } from '../lib/media.mjs';
 import { newStudio } from '../lib/scaffold.mjs';
@@ -377,7 +379,7 @@ import { standaloneDeployNotes } from '../lib/standalone.mjs';
 
 const argv = process.argv.slice(2);
 const flags = new Map();
-const BOOL_FLAGS = ['lan', 'off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile', 'hands-on', 'automatic', 'unlock', 'confirm', 'no-library', 'no-validate', 'rigged', 'no-rig', 'supporter', 'managed', 'live', 'manual', 'renew', 'send', 'accept-tos', 'quiet', 'no-local-ai', 'timestamps', 'overwrite', 'own-route', 'before', 'release', 'device'];
+const BOOL_FLAGS = ['public', 'lan', 'off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile', 'hands-on', 'automatic', 'unlock', 'confirm', 'no-library', 'no-validate', 'rigged', 'no-rig', 'supporter', 'managed', 'live', 'manual', 'renew', 'send', 'accept-tos', 'quiet', 'no-local-ai', 'timestamps', 'overwrite', 'own-route', 'before', 'release', 'device'];
 const positional = [];
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
@@ -487,7 +489,15 @@ function print(result) {
       lines.push(`R2 holds about ${sizeOf(result.inR2)} of this studio's media. ${result.cost}`, ...(result.warning ? [`Warning: ${result.warning}`] : []));
       break;
     }
+    case 'tool new':
+      lines.push(result.file, result.next);
+      break;
+    case 'tool call':
+    case 'tool list':
+      lines.push(JSON.stringify(result.result, null, 2));
+      break;
     case 'deploy':
+      if (result.mcp) lines.push(`Connect your AI: ${result.mcp} (approve in your studio's browser page; no key)`);
       if (result.ci) {
         lines.push(`Live: ${result.url ?? '(Wrangler printed no address)'}${result.commit ? ` (commit ${result.commit.slice(0, 7)}${result.branch ? ` on ${result.branch}` : ''})` : ''}`, ...result.steps.map((x) => `  ${x.what}`), ...result.games.map((g) => `  ${g.id}: ${g.play}${g.hash ? `  [${deployWords(g)}]` : ''}`));
         break;
@@ -823,6 +833,7 @@ const OUTWARD_FLAGS = {
   'shop connect': ['url', 'managed', 'live', 'manual', 'renew', 'from-clipboard'], 'shop disconnect': ['url'], 'shop refund': ['url', 'reason', 'note', 'manual-transaction'], 'shop statements': ['url', 'period', 'send', 'cursor'],
   'agents pass': ['url', 'label', 'server', 'hands', 'role', 'days'], 'agents revoke': ['url'], 'agents brain': ['url', 'budget', 'remove'],
   'agents sit': ['url', 'server', 'pass', 'label', 'brain'],
+  'tool new': ['app'], 'tool call': ['url', 'input', 'public'], 'tool list': ['url', 'public'],
   // With --device it adds a phone to the person's Apple team and installs on it: a flag it does not know stops it.
   'standalone run': ['for', 'device', 'site'],
 };
@@ -878,11 +889,12 @@ async function main() {
   }
   if (cmd === 'perf' && sub === 'compare') {
     if (!positional[2] || !positional[3]) return { ok: false, command: 'perf compare', why: 'usage: homie-studio perf compare <before dir> <after dir> [--goal <metric>] [--min 3]' };
-    return perfCompare(positional[2], positional[3], { goal: String(flags.get('goal') ?? DEFAULT_GOAL), min: flags.has('min') ? Number(flags.get('min')) / 100 : 0.03, guards: flags.get('guards') ? String(flags.get('guards')).split(',').map((x) => x.trim()).filter(Boolean) : null, also: flags.get('also') ? String(flags.get('also')).split(',').map((x) => x.trim()).filter(Boolean) : [] });
+    return perfCompare(positional[2], positional[3], { goal: flags.has('goal') ? String(flags.get('goal')) : null, min: flags.has('min') ? Number(flags.get('min')) / 100 : 0.03, guards: flags.get('guards') ? String(flags.get('guards')).split(',').map((x) => x.trim()).filter(Boolean) : null, also: flags.get('also') ? String(flags.get('also')).split(',').map((x) => x.trim()).filter(Boolean) : [] });
   }
   // The starter library and the optimiser work anywhere; the rest of style and assets inside a studio (lib/art-cli.mjs).
   if (cmd === 'assets' && ['find', 'optimise', 'optimize'].includes(sub)) return assetsCommand(null, sub, positional, flags, { log });
   const root = requireStudio();
+  if (cmd === 'tool') return (await import('../lib/tools-cli.mjs')).toolCommand(root, sub, positional, flags, { log });
   // A trailer is the plugin's video skill; this hands the words after the id over to it (lib/trailer.mjs).
   if (cmd === 'trailer') return trailerCommand(root, sub, argv.slice(argv.indexOf(sub) + 1), { skills: flags.get('skills') ?? null, slug: flags.get('slug') ?? null });
   if (cmd === 'style') return styleCommand(root, sub, positional, flags, { log });
@@ -1327,7 +1339,7 @@ try {
   if (result && result.command !== 'help') print(result);
   if (result?.ok === false) process.exitCode = 1;
   // Chrome's pipes can outlive browser.close(); a finished check must not hang its caller.
-  if (['check', 'port check', 'look', 'perf', 'shoot'].includes(result?.command)) process.exit(process.exitCode ?? 0);
+  if (['check', 'port check', 'look', 'perf', 'shoot', 'lab check'].includes(result?.command)) process.exit(process.exitCode ?? 0);
 } catch (error) {
   await flushProgress().catch(() => {});
   print({ ok: false, why: error instanceof Error ? error.message : String(error) });

package/lib/build.mjs

@@ -491,6 +491,7 @@ export function orderGames(games, order, log = () => {}) {
 export async function build(root, { only = null, log = () => {}, deploy = process.env.WORKERS_CI === '1', maps = false, types = false, beforePublish = async () => {}, longCheck = false } = {}) {
   const esbuild = await studioEsbuild(root);
   const studio = readStudio(root);
+  await (await import('./tools-build.mjs')).buildTools(root, esbuild);
   // The shop first (shop/SHOP.md): invalid shop settings stop the build before anything is built.
   const shop = shopForBuild(root, { log });
   const live = join(root, 'site', 'dist');
@@ -689,6 +690,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
       ...(audienceOf(studio) !== 'general' ? { audience: audienceOf(studio) } : {}),
       ...(studio.referrals === false ? { referrals: false } : {}),
       ...(lounge ? { lounge } : {}),
+      ...(studio.mcp ? { mcp: studio.mcp } : {}),
       build: buildInfo(root),
     },
     games: rows,
@@ -723,6 +725,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   // site, never before: a game that did not build has left both as they were.
   await beforePublish();
   const hosted = (await rulesBuild()).writeRules(root, ruled, all.filter((g) => rulesOf.get(g.id)?.host === 'server').map((g) => g.id));
+  await (await import('./worker-build.mjs')).buildWorker(root, esbuild);
   // All of it is there: now, and only now, it becomes site/dist (lib/stage.mjs).
   const swapped = swapIn(dist, live);
   return {

package/lib/cloudflare.mjs

@@ -466,7 +466,7 @@ async function deployLocked(root, { log = () => {}, homie, fetchFn = null, ownRo
   const next = { ...kept, ...(cf.url && !isWorkersDev(cf.url) ? { url: cf.url } : {}), accountId, d1Id: db.uuid, r2: cf.r2 ?? null, created: [...created].sort() };
   writeStudio(root, { ...readStudio(root), cloudflare: next });
   return {
-    ok: true, command: 'deploy', url, ...(workersDev ? { workersDev, local: LOCAL_STATE } : {}), worker: cf.worker, d1: cf.d1, r2, account: accountId, announced, steps,
+    ok: true, command: 'deploy', url, mcp: url ? `${url}/mcp` : null, connectAI: url ? `${url}/_studio/office/connections` : null, ...(workersDev ? { workersDev, local: LOCAL_STATE } : {}), worker: cf.worker, d1: cf.d1, r2, account: accountId, announced, steps,
     ...(media ? { media: { moved: media.moved ?? [], failed: media.failed ?? [], inR2: media.inR2 ?? null } } : {}),
     games: b.catalogue.map((id) => { const g = delta.games.find((x) => x.id === id); return { id, page: url ? `${url}/${id}/` : null, play: url ? `${url}/${id}/play` : null, hash: g?.hash ?? null, change: delta.first ? 'first deploy from this computer' : g?.change ?? null }; }),
     ...(delta.removed.length ? { removed: delta.removed } : {}),
@@ -628,7 +628,7 @@ export async function ciDeploy(root, { log = () => {} } = {}) {
   const hashes = builtGames(root, games);
   for (const id of games) if (hashes[id]?.hash) step(`${id}: ${deployWords(hashes[id])}`);
   return {
-    ok: true, command: 'deploy', ci: true, url, worker: names.worker, d1: names.d1, r2: null, steps, announced: [],
+    ok: true, command: 'deploy', ci: true, url, mcp: url ? `${url}/mcp` : null, connectAI: url ? `${url}/_studio/office/connections` : null, worker: names.worker, d1: names.d1, r2: null, steps, announced: [],
     commit: process.env.WORKERS_CI_COMMIT_SHA ?? null, branch: process.env.WORKERS_CI_BRANCH ?? null,
     // A CI checkout has no earlier deploy to compare with: each game's content hash only (lib/deploy-state.mjs).
     games: games.map((id) => ({ id, page: url ? `${url}/${id}/` : null, play: url ? `${url}/${id}/play` : null, hash: hashes[id]?.hash ?? null })), songs: [], videos: [],

package/lib/dev.mjs

@@ -459,7 +459,18 @@ export async function dev(root, { lan = false, port: askedPort = 8787, remoteAi
       return;
     }
   };
-  const timer = setInterval(() => { look().catch(() => {}); rulesLook().catch(() => {}); }, watchMs);
+  const { toolFiles } = await import('./tools-build.mjs');
+  const toolsStamp = () => toolFiles(root).map(file => `${file}:${statSync(file).mtimeMs}:${statSync(file).size}`).join('|');
+  let lastTools = toolsStamp();
+  const toolsLook = async () => {
+    if (rebuilding || ending) return;
+    const stamp = toolsStamp(); if (stamp === lastTools) return;
+    lastTools = stamp; rebuilding = true;
+    try { log('Studio tools changed: type-checking and rebuilding…'); await build(root, { log }); }
+    catch (error) { log(`Studio tools did not build: ${error.message}`); }
+    finally { rebuilding = false; }
+  };
+  const timer = setInterval(() => { look().catch(() => {}); rulesLook().catch(() => {}); toolsLook().catch(() => {}); }, watchMs);
   timer.unref?.();
 
   /** Wait for the local site, then hold it to its own address (socketOriginProblem); a mismatch ends dev. */

package/lib/mcp-tools.mjs

@@ -782,6 +782,16 @@ export function toolDefs(ctx, avail = {}) {
         return r.ok ? ok('Node and npm are ready. AI: continue studio_scaffold.', r) : fail(r.next, r);
       },
     },
+    {
+      name: 'studio_connect_ai', title: 'Connect your AI to the studio',
+      description: 'Give the person this studio’s own remote MCP address and connection page. Their AI connects directly with browser approval and their existing studio account; no key or local server.',
+      inputSchema: { type: 'object', properties: { ...STUDIO_ARG } },
+      annotations: { title: 'Connect your AI', ...RO },
+      run: async (a) => {
+        const root = ctx.root(a.studio), site = siteUrl(root);
+        return site ? ok(`Connect your AI to ${site}/mcp. Approve with your studio account in the browser. Manage connections at ${site}/_studio/office/connections. Client setup varies; do not promise a one-click import a client does not support.`, { mcp: `${site}/mcp`, connections: `${site}/_studio/office/connections` }) : fail('This studio has no published address yet. Local tools can be tested with homie-studio dev.');
+      },
+    },
     {
       name: 'studio_domain', title: 'Set the studio domain',
       description: 'Prepare a requested custom hostname for deployment. Cloudflare creates DNS and TLS using its existing browser sign-in. The AI handles configuration; never ask for an account id, zone id or DNS value. Does not deploy or change the domain registrar.',

package/lib/perf.mjs

@@ -194,6 +194,17 @@ export function renderCostOf(samples) {
   return { samples: Math.max(calls.length, tris.length), drawCalls: sum(calls), triangles: sum(tris) };
 }
 
+/** Presence in the last drawn frame is independent of its frame rate. Runs measure frame timing separately. */
+export function gameReadiness() {
+  const p = window.__homiePort;
+  let self = null;
+  if (p && p.view !== 'board') {
+    const rows = p.rows(); const last = rows[rows.length - 1];
+    self = Boolean(last && Number.isFinite(last[1]) && Number.isFinite(last[2]));
+  }
+  return { first: window.__perf?.first?.() ?? null, port: Boolean(p), view: p?.view ?? null, self };
+}
+
 /** Open one browser of a run on the play page, instrumented, and wait until it is playable. */
 async function openPlayer(puppeteer, chrome, device, playUrl, label, log, cpu) {
   const dev = PERF_DEVICES[device];
@@ -243,12 +254,7 @@ async function openPlayer(puppeteer, chrome, device, playUrl, label, log, cpu) {
       shell = await T(page.evaluate(() => { const s = window.__shell; const a = s?.arrival; return s ? { room: s.room, seat: s.seat, role: s.stats?.role ?? null, arrival: a ? { phase: a.phase, lookMs: a.lookMs, liftedMs: a.liftedMs, by: a.by, mode: a.mode, explicitMs: a.explicitMs, lateMs: a.lateMs } : null } : null; }), 5000);
       const now = Date.now();
       if (seatedAt === null && shell?.room && Number.isInteger(shell.seat) && shell.role) seatedAt = now;
-      const g = await inGame(h, () => {
-        const p = window.__homiePort;
-        let self = null;
-        if (p && p.view !== 'board') { const r = p.rows(p.now() - 400); const last = r[r.length - 1]; self = last ? Number.isFinite(last[1]) : false; }
-        return { first: window.__perf?.first?.() ?? null, port: Boolean(p), view: p?.view ?? null, self };
-      });
+      const g = await inGame(h, gameReadiness);
       // The play page's arrival card (0.26.0) covers the game until the game says it is playable: not playable before.
       const lifted = !shell?.arrival || shell.arrival.phase === 'done';
       if (seatedAt !== null && g?.first !== null && g?.first !== undefined && lifted) {
@@ -651,7 +657,7 @@ function arrivalWords(summary, device, role, readyMs) {
 function headlineOf(summary) {
   const out = [];
   for (const device of summary.devices) {
-    for (const role of ['host', 'replica']) {
+    for (const role of ['host', 'replica', 'replica-2']) {
       const m = (k) => summary.metrics[`${device}.${role}.${k}`]?.median;
       if (m('frame.p50') === undefined) continue;
       out.push(`${device} ${role}: frames ${m('frame.p50')} ms median, ${m('frame.p95')} ms p95, ${m('frame.over50') ?? 0}% over 50 ms; game JS ${m('work.p50')} ms a frame (p95 ${m('work.p95')}); main thread ${m('busy')} ms a frame; first look at ${m('load.look') ?? '?'} ms, playable (control-ready) at ${m('load.playable') ?? '?'} ms${arrivalWords(summary, device, role, m('load.ready'))}; netplay ${m('net.msgsOut')} out / ${m('net.msgsIn')} in a second; heap ${m('heap')} MB; fetched before playable (measured) ${m('load.prePlayKb') ?? '?'} KB; renderer ${m('render.calls') !== undefined ? `${m('render.calls')} draw calls, ${m('render.triangles') ?? '?'} triangles (measured while playing)` : 'cost not exposed by the game (not measured)'}`);
@@ -749,8 +755,8 @@ export function readRuns(dir) {
 /** The metrics guarded by default: frame time and main-thread work of each role, time to playable and heap. */
 export function defaultGuards(devices, goal) {
   const g = [];
-  for (const d of devices) for (const role of ['host', 'replica']) g.push(`${d}.${role}.frame.p95`, `${d}.${role}.busy`, `${d}.${role}.load.playable`);
-  for (const d of devices) g.push(`${d}.host.heap`, `${d}.host.net.kbOut`);
+  for (const d of devices) for (const role of ['host', 'replica', 'replica-2']) g.push(`${d}.${role}.frame.p95`, `${d}.${role}.busy`, `${d}.${role}.load.playable`);
+  for (const d of devices) for (const role of ['host', 'replica', 'replica-2']) g.push(`${d}.${role}.heap`, `${d}.${role}.net.kbOut`);
   return g.filter((k) => k !== goal);
 }
 
@@ -758,10 +764,11 @@ export function defaultGuards(devices, goal) {
  * `homie-studio perf compare <before> <after>`: the goal metric and the guards, before against after, from the runs
  * in two folders. A run that was blocked, taken on a busy computer or profiled is left out (and counted).
  */
-export function perfCompare(beforeDir, afterDir, { goal = DEFAULT_GOAL, guards = null, also = [], min = 0.03, write = true } = {}) {
+export function perfCompare(beforeDir, afterDir, { goal = null, guards = null, also = [], min = 0.03, write = true } = {}) {
   const A = readRuns(beforeDir);
   const B = readRuns(afterDir);
   if (!A.runs.length || !B.runs.length) return { ok: false, command: 'perf compare', why: `no runs in ${!A.runs.length ? beforeDir : afterDir} (folders that homie-studio perf wrote)` };
+  goal ??= A.runs.every((r) => r.room?.hosted === 'server') ? DEFAULT_GOAL.replace('.host.', '.replica.') : DEFAULT_GOAL;
   const usable = (r) => !r.blocked && !r.loaded;
   const left = { before: A.runs.filter((r) => !usable(r)).length, after: B.runs.filter((r) => !usable(r)).length };
   const flat = (runs, sizes) => {

package/lib/port-check.mjs

@@ -44,7 +44,11 @@ const GPU = [
 const TAG = 'homie-studio-check';
 const ANDROID_UA = 'Mozilla/5.0 (Linux; Android 14; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36';
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const T = (p, ms, v = null) => Promise.race([Promise.resolve(p).catch(() => v), sleep(ms).then(() => v)]);
+const T = async (p, ms, v = null) => {
+  let timer;
+  try { return await Promise.race([Promise.resolve(p).catch(() => v), new Promise(resolve => { timer = setTimeout(() => resolve(v), ms); })]); }
+  finally { clearTimeout(timer); }
+};
 const DIRV = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
 const ALL = ['owner-desk', 'owner-phone', 'owner-iphone', 'round', 'life', 'tv'];
 
@@ -60,6 +64,25 @@ function yawDeg(a, b) {
   const d = a[5] * b[5] + a[6] * b[6]; const la = Math.hypot(a[5], a[6]) || 1; const lb = Math.hypot(b[5], b[6]) || 1;
   return (Math.acos(Math.max(-1, Math.min(1, d / (la * lb)))) * 180) / Math.PI;
 }
+/** A server room keeps its authority and advances; a browser room must promote a host. */
+export function roomContinued(before, after, serverHosted) {
+  return serverHosted
+    ? after?.hosted === 'server' && after?.role === 'replica' && Number.isFinite(before?.tick) && after?.tick > before.tick && after?.frames > before.frames
+    : after?.role === 'host';
+}
+
+/** Compare two observations on the same browser clock, including time spent taking screenshots. */
+export function roundClockContinued(before, after) {
+  return !before?.round || !after?.round || before.round.n !== after.round.n
+    || Math.abs((before.round.leftMs - after.round.leftMs) - (after.observedAt - before.observedAt)) < 6000;
+}
+
+/** A wall can leave too little runway; retry the same hold after moving away, never excuse steering faults. */
+export function needsRunway(res) {
+  return !res.ok && (res.why === 'barely moved' || res.why?.startsWith('blocked at once'))
+    && res.yawChangeDeg < 10 && (res.dirErrDeg === null || res.dirErrDeg < 15);
+}
+
 const finite = (r) => r && Number.isFinite(r[1]) && Number.isFinite(r[2]);
 /** A frame the player steers (the probe's `busy` says when a knockback, a stun or a respawn has the body). */
 const steerable = (r) => finite(r) && !r[8];
@@ -134,6 +157,9 @@ export function judgePresses(rows, presses, size, view) {
   const out = presses.map((p) => {
     const seg = rows.filter((r) => r[0] >= p.a && r[0] <= p.b + 60 && steerable(r));
     if (seg.length < 4) return rows.some((r) => r[0] >= p.a && r[0] <= p.b && finite(r) && r[8]) ? { dir: p.dir, ok: false, blocked: true, busy: true } : { dir: p.dir, ok: false, why: 'no samples' };
+    // The first post-input frame can already show the response. Keep its preceding drawn pose.
+    const before = rows.filter((r) => r[0] < p.a).at(-1);
+    if (before && steerable(before)) seg.unshift(before);
     const u = DIRV[p.dir]; const r0 = seg[0];
     let matchAt = null, after = 0, afterOk = 0, maxYaw = 0, peakAlong = 0, contact = false;
     for (let i = 1; i < seg.length; i++) {
@@ -258,7 +284,7 @@ async function webkit(pw) {
 const frameOf = (h) => h.page.frames().find((f) => f.url().includes('/__game/')) ?? null;
 async function inFrame(h, src, v = null) { const f = frameOf(h); return f ? T(f.evaluate(src), 10_000, v) : v; }
 const shell = (h) => T(h.page.evaluate(() => { const s = window.__shell; return s ? { room: s.room, seat: s.seat, role: s.stats?.role ?? null, results: s.results ?? [], facts: s.facts ? { counts: s.facts.counts } : null } : null; }), 8000, null);
-const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
+const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); i.observedAt = performance.now(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.hosted = n?.probe?.hosted?.() ?? null; i.tick = n?.probe?.tick?.() ?? null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
 const rowsSince = (h, t) => inFrame(h, `(window.__homiePort ? window.__homiePort.rows(${Number(t) || 0}) : [])`, []);
 const frameNow = (h) => inFrame(h, '(window.__homiePort ? window.__homiePort.now() : performance.now())', 0);
 
@@ -285,13 +311,14 @@ async function focusGame(h) {
 
 /* ------------------------------------------------------------------ input */
 
-async function holdKey(h, code, ms) { await h.page.keyboard.down(code); await sleep(ms); await h.page.keyboard.up(code); }
+async function holdKey(h, code, ms, ready) { await h.page.keyboard.down(code); if (ready) await ready(); await sleep(ms); await h.page.keyboard.up(code); }
 
 function thumbAt(h, i) { const t = i?.thumb ?? [0.24, 0.74]; return [Math.round(h.vp.width * t[0]), Math.round(h.vp.height * t[1])]; }
-async function touchDrag(h, from, dir, reach, holdMs) {
+async function touchDrag(h, from, dir, reach, holdMs, ready) {
   const [x0, y0] = from; const u = DIRV[dir];
   await h.touch('touchStart', [{ id: 1, x: x0, y: y0 }]);
   for (let k = 1; k <= 8; k++) { await h.touch('touchMove', [{ id: 1, x: Math.round(x0 + (u[0] * reach * k) / 8), y: Math.round(y0 + (u[1] * reach * k) / 8) }]); await sleep(12); }
+  if (ready) await ready();
   const end = Date.now() + holdMs;
   let w = 0;
   while (Date.now() < end) {
@@ -302,6 +329,50 @@ async function touchDrag(h, from, dir, reach, holdMs) {
   }
   await h.touch('touchEnd', h.touchAll ? [] : [{ id: 1, x: Math.round(x0 + u[0] * reach), y: Math.round(y0 + u[1] * reach) }]);
 }
+/** Timestamp real input delivery, then keep it held until four frames can judge its direction.
+ * The response limit stays 600 ms; slow automation delivery and the thumb's ramp are not game latency. */
+export async function measuredPress(h, how, code, from, dir) {
+  // CDP points use page coordinates; DOM touch receipts use frame coordinates.
+  let offset = { x: 0, y: 0 };
+  if (how !== 'keys') {
+    const element = await frameOf(h)?.frameElement();
+    if (element) {
+      try { offset = await element.boundingBox() ?? offset; }
+      finally { await element.dispose(); }
+    }
+  }
+  await inFrame(h, `(() => {
+    if (!window.__homieCheckInput) {
+      const state = window.__homieCheckInput = {};
+      addEventListener('keydown', e => { if (state.code === e.code && state.key === null) state.key = performance.now(); }, true);
+      addEventListener('touchmove', e => {
+        const touch = e.touches[0];
+        if (state.touch === null && touch && touch.clientX === state.touchX && touch.clientY === state.touchY) state.touch = performance.now();
+      }, { capture: true, passive: true });
+    }
+    Object.assign(window.__homieCheckInput, { code: ${JSON.stringify(code)}, key: null, touch: null, touchX: ${Math.round(from[0] + DIRV[dir][0] * 70) - offset.x}, touchY: ${Math.round(from[1] + DIRV[dir][1] * 70) - offset.y} });
+  })()`);
+  let a = null, b = null;
+  const ready = async () => {
+    // CDP acknowledgement is not DOM delivery. Wait for the final ramp point,
+    // then latch that receipt so later/coalesced moves cannot change it.
+    const deliveryDeadline = Date.now() + 3000;
+    do {
+      a = await inFrame(h, `window.__homieCheckInput.${how === 'keys' ? 'key' : 'touch'}`);
+      if (Number.isFinite(a)) break;
+      await sleep(20);
+    } while (Date.now() < deliveryDeadline);
+    if (!Number.isFinite(a)) throw new Error('the game frame did not receive the measured input');
+    await sleep(420);
+    const until = Date.now() + 3000;
+    while (Date.now() < until && (await rowsSince(h, a)).length < 4) await sleep(50);
+    b = await frameNow(h);
+  };
+  if (how === 'keys') await holdKey(h, code, 0, ready);
+  else await touchDrag(h, from, dir, 70, 0, ready);
+  return { dir, a, b };
+}
+
 async function swipe(h, dir) {
   const x0 = Math.round(h.vp.width * 0.5); const y0 = Math.round(h.vp.height * 0.55); const u = DIRV[dir]; const reach = Math.round(Math.min(h.vp.width, h.vp.height) * 0.3);
   await h.touch('touchStart', [{ id: 2, x: x0, y: y0 }]);
@@ -365,11 +436,22 @@ async function ownerTests(h, how, log) {
   const holds = view === 'side' ? ['right', 'left'] : ['down', 'left'];
   out.holds = [];
   for (const dir of holds) {
-    const a = await frameNow(h);
-    if (how === 'keys') await holdKey(h, keys[dir], 5000); else await touchDrag(h, thumbAt(h, i), dir, 70, 5000);
-    const b = await frameNow(h);
-    await sleep(250);
-    const res = judgeHold(await rowsSince(h, a - 50), dir, a, b, size, view);
+    const hold = async () => {
+      const a = await frameNow(h);
+      if (how === 'keys') await holdKey(h, keys[dir], 5000); else await touchDrag(h, thumbAt(h, i), dir, 70, 5000);
+      const b = await frameNow(h);
+      await sleep(250);
+      return judgeHold(await rowsSince(h, a - 50), dir, a, b, size, view);
+    };
+    let res = await hold();
+    if (needsRunway(res)) {
+      const first = res;
+      const away = { up: 'down', down: 'up', left: 'right', right: 'left' }[dir];
+      log(`  ${h.engine}-${h.kind} ${how} hold ${dir}: ${first.why}; move ${away} and retry the same hold`);
+      if (how === 'keys') await holdKey(h, keys[away], 1100); else await touchDrag(h, thumbAt(h, i), away, 70, 1100);
+      await sleep(400);
+      res = { ...await hold(), runwayRetry: first };
+    }
     out.holds.push(res);
     log(`  ${h.engine}-${h.kind} ${how} hold ${dir}: ${res.ok ? 'ok' : `FAIL (${res.why})`} travel ${res.travelBodies} bodies, yaw ${res.yawChangeDeg}°`);
     await sleep(400);
@@ -383,12 +465,9 @@ async function ownerTests(h, how, log) {
   const presses = [];
   const a0 = await frameNow(h);
   const until = Date.now() + 10_000;
-  for (let k = 0; Date.now() < until; k++) {
+  for (let k = 0; k < alt.length || Date.now() < until; k++) {
     const dir = alt[k % alt.length];
-    const a = await frameNow(h);
-    if (how === 'keys') await holdKey(h, keys[dir], 420); else await touchDrag(h, thumbAt(h, i), dir, 70, 380);
-    const b = await frameNow(h);
-    presses.push({ dir, a, b });
+    presses.push(await measuredPress(h, how, keys[dir], thumbAt(h, i), dir));
     await sleep(170);
   }
   await sleep(200);
@@ -595,10 +674,13 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
         if (!oa.ok || !ob.ok) { row('host-kill', false, { why: 'a browser was never seated' }); row('late-join', null, { why: 'skipped: no room' }); collect(A); collect(B); await close(A); await close(B); }
         else {
           await sleep(3000);
-          const ia = await info(A); const ib = await info(B);
-          if (ia?.role !== 'host') row('host-kill', null, { why: `the first browser was not the host (it was ${ia?.role}); skipped`, ia: ia?.role, ib: ib?.role });
+          const ia = await info(A); let ib = await info(B);
+          const serverHosted = ia?.hosted === 'server' && ib?.hosted === 'server';
+          if (ia?.role !== 'host' && !serverHosted) row('host-kill', null, { why: `the first browser was not the host (it was ${ia?.role}); skipped`, ia: ia?.role, ib: ib?.role });
           else {
             await shot(B, 'life-before');
+            // Screenshot encoding may span a round on a software renderer. Observe the room we actually leave.
+            ib = await info(B);
             const pids = A.pid ? [A.pid, ...descendants(A.pid)] : [];
             const killAt = Date.now();
             for (const p of pids) { try { process.kill(p, 'SIGKILL'); } catch { /* gone */ } }
@@ -606,14 +688,14 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
             collect(A);
             void A.close();
             let promoted = null; let ibAfter = null;
-            while (Date.now() - killAt < 15_000) { ibAfter = await info(B); if (ibAfter?.role === 'host') { promoted = Date.now() - killAt; break; } await sleep(100); }
+            while (Date.now() - killAt < 15_000) { ibAfter = await info(B); if (roomContinued(ib, ibAfter, serverHosted)) { promoted = Date.now() - killAt; break; } await sleep(100); }
             await sleep(1500);
             const ib2 = await info(B);
             const sameRound = ib?.round && ib2?.round && (ib2.round.n === ib.round.n || (ib.round.phase === 'over' || ib.round.leftMs < 3000));
-            const clockOk = ib?.round && ib2?.round && ib2.round.n === ib.round.n ? Math.abs((ib.round.leftMs - ib2.round.leftMs) - (Date.now() - killAt + 0)) < 6000 : true;
+            const clockOk = roundClockContinued(ib, ib2);
             const running = (ib2?.frames ?? 0) > (ibAfter?.frames ?? 0) && (ib2?.net?.snapHzOut ?? 0) >= 0;
             await shot(B, 'life-after-kill');
-            row('host-kill', Boolean(promoted !== null && promoted <= 5000 && sameRound && clockOk && running), { promotedMs: promoted, roundBefore: ib?.round ?? null, roundAfter: ib2?.round ?? null, why: promoted === null ? 'nobody took over as host within 15 s' : promoted > 5000 ? `the phone took over after ${promoted} ms (over 5 s)` : !sameRound ? 'the round did not continue (a new round started)' : !clockOk ? 'the round clock jumped at the takeover' : undefined });
+            row('host-kill', Boolean(promoted !== null && promoted <= 5000 && sameRound && clockOk && running), { hosted: serverHosted ? 'server' : 'browser', promotedMs: serverHosted ? null : promoted, continuedMs: serverHosted ? promoted : null, roundBefore: ib?.round ?? null, roundAfter: ib2?.round ?? null, why: promoted === null ? (serverHosted ? 'the server room stopped after a browser left' : 'nobody took over as host within 15 s') : promoted > 5000 ? `the phone took over after ${promoted} ms (over 5 s)` : !sameRound ? 'the round did not continue (a new round started)' : !clockOk ? 'the round clock jumped at the takeover' : undefined });
             // Late joiner into the same, running room.
             const C = await launch('desk');
             const joinAt = Date.now();

package/lib/rules-check-worker.mjs

@@ -183,12 +183,14 @@ function play(c, companions, allow) {
   const free = (seat) => { if (!seated.has(seat)) return; seated.delete(seat); did.push(`seat ${seat} left`); frames.push({ t: 'free', seat }); };
   const bots = (mode) => { policy = { ...(policy ?? {}), bots: mode }; frames.push({ t: 'policy', policy }); };
 
-  let A = open({ observe, noted, send });
+  const movesToCheck = [];
+  const moved = (...args) => movesToCheck.push(args);
+  let A = open({ observe, noted, moved, send });
   for (const m of told()) A.frame(m);
   /** The room stops and starts again as a deploy restarts it: a new epoch, everybody away until they are back. */
   const restart = () => {
     const bytes = A.save(); const epoch = A.epoch + 1; A.stop();
-    A = open({ observe, noted, send, restore: bytes, restoreEpoch: epoch });
+    A = open({ observe, noted, moved, send, restore: bytes, restoreEpoch: epoch });
     for (const m of told()) A.frame(m);
     // Everybody is back at once, but for the highest seat, which is a second late.
     const top = Math.max(...seated.keys());
@@ -342,6 +344,17 @@ function play(c, companions, allow) {
     const stats = A.core.stats; const cut = stats.ticksCut; const held = stats.held;
     A.tickNow();
     units += A.core.stats.tickUnits;
+    for (const [name, tick, input, before, after] of movesToCheck.splice(0)) {
+      const kind = c.kinds.find(k => k.name === name);
+      moveTick = tick;
+      const result = L.P.stepMove(kind.move, before, input, moveCtx.get(name), Math.max(1, Math.floor(budget / 4)), kind.motion, c.dims,
+        error => { fault ??= `${siteOf(name, 'move')} ${name}.move: prediction failed: ${error.message}.${when()}`; });
+      units += result.used;
+      const r = kind.body.radius, bounds = c.map.bounds;
+      result.pos = L.P.vec3({ x: Math.max(bounds.min.x + r, Math.min(bounds.max.x - r, result.pos.x)), y: Math.max(bounds.min.y + r, Math.min(bounds.max.y - r, result.pos.y)), z: result.pos.z }, c.dims);
+      delete result.used;
+      if (JSON.stringify(result) !== JSON.stringify(after)) fault ??= `${siteOf(name, 'move')} ${name}.move: prediction and the server produced different bodies from the same input.${when()}`;
+    }
     if (A.core.stats.tickUnits > peak) peak = A.core.stats.tickUnits;
     if (A.core.stats.maxUnits > most) { most = A.core.stats.maxUnits; worst = A.core.stats.worst; }
     const facts = A.facts();