makersclaw 0.6.0 → 0.8.0

package/templates/next/files/check/run.mjs

@@ -3,18 +3,33 @@
 // exit 1 on the first thing that does not. No dependency: node's own fs,
 // crypto, fetch and child_process.
 //
-// Static rules read the source; the smoke test builds the app and loads
-// every surface. Every static rule exists because the failure it names
+// Source rules read the source; the smoke test builds the app and loads
+// every surface. Every source rule exists because the failure it names
 // was seen in a real build: a hex in a surface (the app stopped following
 // the workspace theme), a hand-rolled <select> that could not be used, an
 // example INSERTed into a shared table, a manifest entry whose file was
 // never written, an icon name that rendered nothing, a tweet card painted
 // in the workspace's tokens (unrecognisable as a tweet — the one thing
 // the app was for), a kit file "improved" per app, a button whose server
-// action the app's own agent had no way to know about.
+// action the app's own agent had no way to know about. Rules 9 and 11
+// came before their failures: 0.7.0 moves an app to its own schema, and
+// every example the Builder copied named public (tables); and the brain's
+// door refuses a kind the app did not declare only on the member's
+// screen, long after the build (brain). Number 10 is browser mode's rule
+// (claw's STATIC-SPEC §3): a browser app is files and a door, and the
+// build refuses its server code late and unclearly, or not at all.
+// Number 12 is the shell that grew with its content: a footer and the
+// buttons after a long article sat past the window's end (viewport).
+// Number 13 (llm, 0.8.0) keeps a model call on llm(): a screen that
+// fetched the model door by its path got none of what the function does.
 //
-//   npm run check               static rules, then smoke
-//   npm run check -- --static   static rules only
+//   npm run check               source rules, then smoke
+//   npm run check -- --no-build source rules only: no build, no smoke
+//                               (--static is its old name, still read)
+//   node check/run.mjs --actions
+//                               { "actions": [...], "tables": [...] }: the
+//                               actions the screens run and the tables they
+//                               write (rule 8), for the platform's ship
 //
 // The smoke test builds for itself, and only when a source file is newer
 // than its last build. Where: in place when the app folder is writable,
@@ -22,6 +37,7 @@
 // sandbox tree made `2755` before claw opened app trees to its `claw`
 // group, tree-access.ts), the sources are copied to a folder of its own
 // (`~/.claw-check/<app>`, node_modules symlinked back) and built there.
+// A browser app always takes the copy (below).
 //
 // Never into `.next`: it is not the check's. In a working copy it is the
 // preview dev server's; in a live app it holds the production build the
@@ -36,6 +52,17 @@
 // builder cannot write `.next` (`chmod 555` on it: EACCES on .next/trace),
 // which is where one Linux user per app, claw's planned walls, leads.
 //
+// A browser app ("mode": "browser") is exported, not started. Its smoke
+// always builds in the copy folder (`~/.claw-check/<app>`), with the
+// default distDir and the check's own environment, .env left out: under
+// export a custom distDir is the export's folder and the build itself
+// still goes to `.next`, so a build in place would empty the tree's
+// `.next`. It serves the copy's out/ from a file server of its own, by
+// the platform router's rules, and loads / and every surface: no `next
+// start`, no /claw-alive (browserSmoke, below). What that proves: every
+// page prerenders. Not that a surface renders with data: the export
+// holds each surface's loading line, and the rows come in the browser.
+//
 // A copy's node_modules is a symlink back to the app's, and Turbopack
 // reads nothing outside its root, so the copy's build is told a root
 // that holds both (CLAW_TURBOPACK_ROOT, commonRoot below).
@@ -46,15 +73,20 @@
 import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
+import { createServer as createHttpServer } from "node:http";
 import { createServer } from "node:net";
-import { basename, dirname, join, relative, sep } from "node:path";
+import { basename, dirname, join, posix, relative, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // The app dir: this file's parent, unless the platform runs a canonical
 // copy of it from elsewhere against an app (CLAW_APP_DIR).
 const ROOT = process.env.CLAW_APP_DIR || join(fileURLToPath(import.meta.url), "..", "..");
-const STATIC_ONLY = process.argv.includes("--static");
+// --no-build: the source rules alone. --static is the same flag's old
+// name (static as in reading the source, not a mode), kept because the
+// platform and scripts pass it.
+const NO_BUILD = process.argv.includes("--no-build") || process.argv.includes("--static");
+const ACTIONS_ONLY = process.argv.includes("--actions");
 
 // The kit, by exact file: what the template ships under components/ui and
 // components/parts. Anything else in those folders is the agent's, and the
@@ -66,7 +98,7 @@ const STATIC_ONLY = process.argv.includes("--static");
 // .jsx (a components/ui/depiction.js beside depiction.jsx won); Next 16's
 // Turbopack tries .jsx before .js (seen on 16.3.7), so the kit's own file
 // wins there, but the rule holds for every bundler.
-const KIT = /^components\/(?:ui\/(?:cx|index)\.js|ui\/(?:radio|toggle|button-group|avatar|breadcrumb|pagination|button|collapsible|item|table|depiction|feedback|stat|distribution|swatch|steps|separator|scroll-area|field|icon|menu|context-menu|popover|calendar|date-picker|tooltip|notice|sheet|tabs|slider|input-group|image|file-input|input-otp|command|combobox|rating|toast|carousel|resizable)\.jsx|parts\/(?:index|sample)\.js|parts\/(?:fixture|record-switcher|live-work)\.jsx)$/;
+const KIT = /^components\/(?:ui\/(?:cx|index)\.js|ui\/(?:radio|toggle|button-group|avatar|breadcrumb|pagination|button|collapsible|item|table|depiction|feedback|stat|distribution|swatch|steps|separator|scroll-area|layout|field|icon|menu|context-menu|popover|calendar|date-picker|tooltip|notice|sheet|tabs|slider|input-group|image|file-input|input-otp|command|combobox|rating|toast|carousel|resizable)\.jsx|parts\/(?:index|sample)\.js|parts\/(?:fixture|record-switcher|live-work)\.jsx)$/;
 
 // The pins: sha256 of every fixed file, written by `makersclaw init` and
 // `makersclaw add` (check/pins.json). Read first, because a BLOCK is
@@ -116,7 +148,7 @@ const SKIP = [
   /^check\//,
   KIT,
   /^app\/globals\.css$/,
-  /^lib\/(db|data|actions|claw|platform|hooks|sample)\.js$/,
+  /^lib\/(db|data|actions|claw|platform|hooks|sample|door|brain|brain-server)\.js$/,
   /^app\/(layout|page|error|global-error|not-found|error-relay|auto-refresh|escape-relay)\.jsx$/,
   /^app\/frame\.js$/,
   /^app\/claw-alive\/route\.js$/,
@@ -200,17 +232,478 @@ const COLOUR_PREFIXES = "bg|text|border(?:-[xytrbles])?|ring(?:-offset)?|inset-r
 
 /** Source without its comments, newlines kept so line numbers hold: a
  *  rule reads code, not the prose beside it (a header that says
- *  "window." or names <a> is not browser access or a link). */
-function stripComments(text) {
+ *  "window." or names <a> is not browser access or a link). A line comment
+ *  is a `//` that follows anything but a `:` or a backslash, which also
+ *  blanks a string that opens with two slashes ("//llm") or holds a
+ *  doubled one ("/_claw//llm") to the end of its line. `slashStrings`
+ *  reads those as strings: a `//` is a comment only at the start of a line
+ *  or after a space or one of ; , ( ) { } [ ]. For a rule that reads a
+ *  URL's slashes (12, llm). */
+function stripComments(text, { slashStrings = false } = {}) {
   const blank = (m) => m.replace(/[^\n]/g, " ");
+  const line = slashStrings ? /(^|[\s;,(){}[\]])\/\/[^\n]*/g : /(^|[^:\\])\/\/[^\n]*/g;
   return text
     .replace(/\{\/\*[\s\S]*?\*\/\}/g, blank)
     .replace(/\/\*[\s\S]*?\*\//g, blank)
-    .replace(/(^|[^:\\])\/\/[^\n]*/g, (m, lead) => lead + blank(m.slice(lead.length)));
+    .replace(line, (m, lead) => lead + blank(m.slice(lead.length)));
 }
 /** JSX attributes up to the tag's `>`: strings and balanced braces may hold a `>` or `=>`. */
 const ATTRS = String.raw`(?:"[^"]*"|'[^']*'|\{(?:[^{}]|\{[^{}]*\})*\}|[^>"'{])*`;
 
+// The app's makersclaw.json, read once for rules 8, 9 and 11. `broken` is
+// the parse error of a file that is not JSON.
+const MANIFEST = (() => {
+  const path = join(ROOT, "makersclaw.json");
+  if (!existsSync(path)) return { manifest: null, broken: null };
+  try {
+    return { manifest: JSON.parse(readFileSync(path, "utf8")), broken: null };
+  } catch (e) {
+    return { manifest: null, broken: e.message };
+  }
+})();
+
+/**
+ * The tables and views the app's own schema makes, for rule 9's last
+ * clause: { names, from }, or null where no list is here. The first
+ * found wins:
+ *   1. CLAW_APP_TABLES, a comma list the platform passes at ship, read on
+ *      the app lane. It comes first because after an app's first ship its
+ *      Builder makes tables with `sql`, and no file holds those. Set and
+ *      empty: the app makes none. A name given with its schema
+ *      (app_crm.deals) counts by its table.
+ *   2. ../install/schema.sql: a play folder's, what its install ran.
+ *   3. ../../schema.sql: a store package's (packages/<key>/files/app).
+ * From a file, every `create table` and `create view` (or replace,
+ * materialized, unlogged, temporary, if not exists), by the name's last
+ * part: a package from before 0.7.0 still writes `public.<t>` there.
+ */
+const APP_TABLES = (() => {
+  const env = process.env.CLAW_APP_TABLES;
+  if (env !== undefined) return { names: new Set(env.split(",").map((n) => n.trim().split(".").pop().trim()).filter(Boolean)), from: "CLAW_APP_TABLES" };
+  for (const rel of ["../install/schema.sql", "../../schema.sql"]) {
+    let sql;
+    try {
+      sql = readFileSync(join(ROOT, rel), "utf8");
+    } catch {
+      continue;
+    }
+    return { names: tablesMade(sql), from: rel };
+  }
+  return null;
+})();
+/** The tables and views a schema.sql creates. A quoted name keeps its
+ *  case; an unquoted one folds to lower case, as Postgres folds it. */
+function tablesMade(sql) {
+  const code = sql.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+  const PART = String.raw`(?:"(?:[^"]|"")+"|[A-Za-z_][\w$]*)`;
+  const CREATE = new RegExp(
+    String.raw`\bcreate\s+(?:or\s+replace\s+)?(?:(?:global\s+|local\s+)?(?:temp|temporary)\s+|unlogged\s+)?(?:materialized\s+|recursive\s+)?(?:table|view)\s+(?:if\s+not\s+exists\s+)?((?:${PART}\s*\.\s*)*${PART})`,
+    "gi",
+  );
+  const names = new Set();
+  for (const m of code.matchAll(CREATE)) {
+    const last = m[1].match(new RegExp(PART, "g")).pop();
+    names.add(last.startsWith('"') ? last.slice(1, -1).replace(/""/g, '"') : last.toLowerCase());
+  }
+  return names;
+}
+
+// Reading names out of the app's JavaScript, for rules 8, 9 and 11. The
+// check has no parser (it depends on nothing), so these read the shapes
+// an app writes: a string literal, a constant of the same file, an
+// object literal's properties.
+const ID = String.raw`[A-Za-z_][\w$]*`;
+// A string literal whose value can be read (no ${…} inside): lit(n) puts
+// its quote in group n and its value in group n + 1.
+const LIT = String.raw`(["'\`])((?:(?!\1)[^\\\n$]|\\.|\$(?!\{))*)\1`;
+const lit = (n) => LIT.replaceAll("\\1", `\\${n}`);
+/**
+ * A file's string constants (`const SOURCE = "deals"`), as a lookup:
+ * `constAt(name, at)` is the { value, index } of the one a use at `at`
+ * sees, the declaration in the innermost block that holds the use (the
+ * file's own, outside every block, holds every use). None: the name is
+ * something the code decides at run time (a prop, a parameter, another
+ * function's constant), and undefined. Until 0.7.0's review the first
+ * declaration anywhere was taken, so a `const kind = "error"` inside one
+ * component was read as the `{ kind }` prop of another.
+ */
+function stringConsts(code) {
+  // Every { … } of the code, strings skipped: [open, close].
+  const blocks = [];
+  const open = [];
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    if (c === '"' || c === "'" || c === "`") i = endOfString(code, i);
+    else if (c === "{") open.push(i);
+    else if (c === "}" && open.length) blocks.push([open.pop(), i]);
+  }
+  for (const o of open) blocks.push([o, code.length]);
+  const holds = (b, at) => b[0] < at && at < b[1];
+  const decls = new Map(); // name → [{ value, index, from, block }]: `from` opens its block (-1 and null: the file)
+  for (const m of code.matchAll(new RegExp(String.raw`\bconst\s+(${ID})\s*=\s*${lit(2)}`, "g"))) {
+    const from = blocks.filter((b) => holds(b, m.index)).reduce((a, b) => Math.max(a, b[0]), -1);
+    const block = from < 0 ? null : blocks.find((b) => b[0] === from);
+    if (!decls.has(m[1])) decls.set(m[1], []);
+    decls.get(m[1]).push({ value: m[3], index: m.index, from, block });
+  }
+  return (name, at) => {
+    let seen;
+    for (const d of decls.get(name) ?? []) {
+      if ((d.block === null || holds(d.block, at)) && (!seen || d.from > seen.from)) seen = d;
+    }
+    return seen && { value: seen.value, index: seen.index };
+  };
+}
+/** The index of the quote that closes the string opened at `i` (a
+ *  template's ${…} skipped whole). A quote left open ends at its line. */
+function endOfString(code, i) {
+  const q = code[i];
+  for (let j = i + 1; j < code.length; j++) {
+    const c = code[j];
+    if (c === "\\") j++;
+    else if (q === "`" && c === "$" && code[j + 1] === "{") j = closeOf(code, j + 1);
+    else if (c === q || (q !== "`" && c === "\n")) return j;
+  }
+  return code.length;
+}
+/** Every string and template literal of the code, outermost only (a
+ *  template's ${…} is read as part of it): [{ start, end }], the indexes
+ *  of its quotes. A ' or " right after a letter or a digit opens nothing:
+ *  it is JSX text's apostrophe ("Don't"), since code never puts a string
+ *  there. A quote inside a regular expression is read as one, as the
+ *  other walks here read it. */
+function literalsOf(code) {
+  const out = [];
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    if (c !== '"' && c !== "'" && c !== "`") continue;
+    if (c !== "`" && /[A-Za-z0-9]/.test(code[i - 1] ?? "")) continue;
+    const end = endOfString(code, i);
+    out.push({ start: i, end });
+    i = end;
+  }
+  return out;
+}
+/** The string literals of `code` that are SQL by where they go, for
+ *  rules 8 and 9: handed to query() (`query(…)`, `client.query(…)`),
+ *  directly or through a const of the file, or written as a sql`…`
+ *  template. A Set of their opening quote's index. */
+function handedToQuery(code) {
+  const handed = new Set();
+  const declaredAt = (name, before) => {
+    let at = null;
+    for (const m of code.matchAll(new RegExp(String.raw`\b(?:const|let|var)\s+${esc(name)}\s*=\s*(?=["'\`])`, "g"))) if (m.index < before) at = m.index + m[0].length;
+    return at;
+  };
+  for (const m of code.matchAll(new RegExp(String.raw`(?<![\w$])(?:${ID}\s*\??\.\s*)?query\s*(?:\?\.\s*)?\(\s*`, "g"))) {
+    const at = m.index + m[0].length;
+    if (/["'`]/.test(code[at] ?? "")) handed.add(at);
+    else {
+      const id = new RegExp(String.raw`^(${ID})\s*[,)]`).exec(code.slice(at));
+      const decl = id && declaredAt(id[1], m.index);
+      if (decl !== null && decl !== undefined) handed.add(decl);
+    }
+  }
+  for (const m of code.matchAll(/(?<![\w$.])sql\s*(?=`)/g)) handed.add(m.index + m[0].length);
+  return handed;
+}
+/**
+ * The code's strings as rule 9 reads SQL: each run of string literals
+ * joined with + is one text, as JavaScript joins it (`"select d.id " +
+ * "from deals d " + "join notes n …"`). Found in 0.7.0's review: each
+ * literal was read alone, so a table in any piece after the first
+ * passed. A name or a call between two pieces (`+ id +`) joins them
+ * through a character no name can hold. [{ text, at, handed }]: `handed`
+ * when a piece goes to query() (handedToQuery); `at(i)` is where the
+ * text's i-th character is in the code. The text is blanked where no
+ * table is named, every index kept: the SQL's own strings ('…'), its
+ * -- and block comments, and a \n, \r or \t written as an escape.
+ */
+function sqlTexts(code) {
+  const handed = handedToQuery(code);
+  const GLUE = new RegExp(String.raw`^\s*\+\s*${ID}(?:\s*\??\.\s*${ID})*(?:\s*\([^()"'\`]*\))?\s*\+\s*$`);
+  const runs = [];
+  let run = null;
+  for (const { start, end } of literalsOf(code)) {
+    const gap = run ? code.slice(run.end + 1, start) : "";
+    const joined = run !== null && /^\s*\+\s*$/.test(gap);
+    const glued = run !== null && !joined && GLUE.test(gap);
+    if (!joined && !glued) runs.push((run = { pieces: [], text: "", handed: false }));
+    if (glued) run.text += "\u0001";
+    run.pieces.push({ from: run.text.length, start });
+    run.text += code.slice(start + 1, end);
+    run.end = end;
+    if (handed.has(start)) run.handed = true;
+  }
+  return runs.map(({ pieces, text, handed }) => ({
+    handed,
+    // A string holding a backslash is left to the next quote, as before
+    // this reader: E'a\' from x' then blanks ' from x'.
+    text: text.replace(/'(?:[^'\\\n]|'')*'|--(?:[^\n\\]|\\(?![nr]))*|\/\*[\s\S]*?\*\/|\\[nrt]/g, (s) => " ".repeat(s.length)),
+    at: (i) => {
+      const p = pieces.findLast((q) => q.from <= i);
+      return p.start + 1 + (i - p.from);
+    },
+  }));
+}
+/** The index of the bracket that closes the one at `open`. */
+function closeOf(code, open) {
+  let depth = 0;
+  for (let i = open; i < code.length; i++) {
+    const c = code[i];
+    if (c === '"' || c === "'" || c === "`") i = endOfString(code, i);
+    else if (c === "(" || c === "[" || c === "{") depth++;
+    else if ((c === ")" || c === "]" || c === "}") && --depth === 0) return i;
+  }
+  return code.length;
+}
+/**
+ * Every property of every object literal in `text`: { key, value, at,
+ * depth, path }. `value` is its text (a shorthand's is its own name),
+ * `at` where its key starts, `depth` the braces around it (1: an object
+ * that is the text itself, a call's argument), `path` the keys of the
+ * properties whose values hold it, outermost first: in
+ * `{ writes: [{ kind: "deal", owner: { kind: "member" } }] }` the first
+ * kind's path is ["writes"], the second's ["writes", "owner"]. Anything
+ * that is not `key: value` or a shorthand (a spread, a method, a block's
+ * statements) is passed over.
+ */
+function objectProps(text) {
+  const out = [];
+  const frames = []; // one per open bracket: { brace, prop: { key, start, at } | null }
+  const KEY = new RegExp(String.raw`\s*(?:(${ID})|"([^"\\\n]*)"|'([^'\\\n]*)')\s*([:,}])`, "y");
+  const depth = () => frames.filter((fr) => fr.brace).length;
+  const path = () => frames.filter((fr) => fr.brace && fr.prop).map((fr) => fr.prop.key);
+  const end = (fr, i) => {
+    if (!fr.prop) return;
+    out.push({ key: fr.prop.key, value: text.slice(fr.prop.start, i).trim(), at: fr.prop.at, depth: depth(), path: path().slice(0, -1) });
+    fr.prop = null;
+  };
+  // At `i`, just after a { or a , of an object: a key, or not. Returns
+  // where the walk goes on.
+  const keyAt = (fr, i) => {
+    KEY.lastIndex = i;
+    const m = KEY.exec(text);
+    if (!m) return i;
+    const key = m[1] ?? m[2] ?? m[3];
+    const at = i + m[0].search(/\S/);
+    if (m[4] === ":") {
+      fr.prop = { key, start: KEY.lastIndex, at };
+      return KEY.lastIndex;
+    }
+    if (m[1]) out.push({ key, value: key, at, depth: depth(), path: path() });
+    return KEY.lastIndex - 1; // the , or } is the walk's
+  };
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const top = frames[frames.length - 1];
+    if (c === '"' || c === "'" || c === "`") i = endOfString(text, i);
+    else if (c === "{") {
+      const fr = { brace: true, prop: null };
+      frames.push(fr);
+      i = keyAt(fr, i + 1) - 1;
+    } else if (c === "(" || c === "[") frames.push({ brace: false, prop: null });
+    else if (c === "}" || c === ")" || c === "]") {
+      if (top?.brace) end(top, i);
+      frames.pop();
+    } else if (c === "," && top?.brace) {
+      end(top, i);
+      i = keyAt(top, i + 1) - 1;
+    }
+  }
+  return out;
+}
+
+// What the app's code hands to the write doors, for rule 8 and
+// `--actions` (0.7.0, claw's STATIC-SPEC §2): the name of every action
+// it runs (runAction) and the table of every one-row write (insertRow,
+// updateRow, moveRow, deleteRow, saveSetting). Each is read from the
+// call's first argument, `{ name }` or `{ source }`, where it is written:
+// a string literal, or a string constant of the same file that the call
+// sees, as rules 9 and 11 read theirs. A surface's own `source:
+// surface.source` is its manifest entry's (surfaces.js). The fixed lib/
+// files that define them are not read (SKIP).
+//
+// A call is found by the function's name however the file reaches it,
+// with `(` or `?.(`: bare; under an alias imported from lib/actions.js or
+// lib/door.js, or from an app file that re-exports them; through a
+// namespace (`import * as doors`, then `doors.runAction`,
+// `doors?.runAction?.(`, `doors["runAction"]`); or through an alias the
+// code makes of one (`const { runAction: go } = doors`, `const go =
+// doors.runAction`, `const go = runAction`). Until 0.7.0's review a
+// `?.(`, a `["…"]`, an alias the code made and a re-export each hid its
+// action or its table from the brief check and from the ship's --actions
+// list.
+const ROW_WRITES = ["insertRow", "updateRow", "moveRow", "deleteRow", "saveSetting"];
+const DOOR_MODULES = ["lib/actions", "lib/door"];
+/** The one bare, lower-case name the data door calls (ACTION_NAME in lib/actions.js). */
+const ACTION_NAME = /^[a-z_][a-z0-9_]{0,62}$/;
+/** A name, escaped for a RegExp (`$` is legal in one). */
+const esc = (name) => name.replace(/\$/g, "\\$");
+/** An app file's module, as an import names it: no extension, no /index. */
+const moduleOf = (path) => path.replace(/\.(?:jsx?|mjs)$/, "").replace(/\/index$/, "");
+/** The module a relative import in the file at `from` names. */
+const importOf = (from, spec) => moduleOf(posix.normalize(posix.join(posix.dirname(from), spec)));
+const jsFiles = files.filter((f) => /\.(?:jsx?|mjs)$/.test(f.path));
+/** The surface files the manifest mounts, each with the `source` of
+ *  every entry that mounts it: module → [source, or null for none]. */
+function surfaceSources() {
+  const out = new Map();
+  let text;
+  try {
+    text = stripComments(readFileSync(join(ROOT, "surfaces.js"), "utf8"));
+  } catch {
+    return out;
+  }
+  const imported = new Map();
+  for (const m of text.matchAll(/^\s*import\s+(\w+)\s+from\s*["'](\.\/[^"'\n]+)["']/gm)) imported.set(m[1], importOf("surfaces.js", m[2]));
+  for (const m of text.matchAll(/\{([^{}]*)\}/g)) {
+    const component = /\bcomponent\s*:\s*(\w+)/.exec(m[1])?.[1];
+    if (!component || !imported.has(component)) continue;
+    const source = new RegExp(String.raw`\bsource\s*:\s*${lit(1)}`).exec(m[1])?.[2]?.trim() || null;
+    const mod = imported.get(component);
+    if (!out.has(mod)) out.set(mod, []);
+    out.get(mod).push(source);
+  }
+  return out;
+}
+/**
+ * → { actions: [{ f, line, name, form }], tables: [{ f, line, fn, table }],
+ * unread: [{ f, line, fn }] }. An action's `form` is "object"
+ * (runAction({ name: "x" })), "string" (runAction("x"), which runs
+ * nothing: runAction takes one object) or "computed" (a name the code
+ * decides at run time; `name` is null). `unread` is every one-row write
+ * whose table the code decides at run time (a prop, a parameter): the
+ * check cannot say which table it writes.
+ */
+function writeCalls() {
+  const known = new Set([...ROW_WRITES, "runAction"]);
+  const all = () => new Map([...known].map((n) => [n, n]));
+  // Every module that hands out the doors, with what it exports under
+  // which name: lib/actions and lib/door, and an app file that re-exports
+  // them (`export { runAction as go } from "../lib/actions"`, `export *
+  // from`), until no file adds one.
+  const doors = new Map(DOOR_MODULES.map((m) => [m, all()]));
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const f of jsFiles) {
+      for (const m of f.code.matchAll(/^\s*export\s*(\*|\{[^}]*\})\s*from\s*["'](\.[^"'\n]+)["']/gm)) {
+        const names = doors.get(importOf(f.path, m[2]));
+        if (!names) continue;
+        const self = moduleOf(f.path);
+        const mine = doors.get(self) ?? new Map();
+        doors.set(self, mine);
+        const add = (as, fn) => {
+          if (mine.has(as)) return;
+          mine.set(as, fn);
+          grew = true;
+        };
+        if (m[1] === "*") for (const [n, fn] of names) add(n, fn);
+        else {
+          for (const part of m[1].slice(1, -1).split(",")) {
+            const [name, as] = part.trim().split(/\s+as\s+/);
+            if (name && names.has(name.trim())) add((as ?? name).trim(), names.get(name.trim()));
+          }
+        }
+      }
+    }
+  }
+  const mounted = surfaceSources();
+  const actions = [];
+  const tables = [];
+  const unread = [];
+  for (const f of jsFiles) {
+    const code = f.code;
+    const local = all(); // a name in this file → the function it calls
+    const spaces = new Map(); // a namespace in this file → its names
+    for (const m of code.matchAll(/^\s*import\s+([^;]*?)\s+from\s*["']([^"'\n]+)["']/gm)) {
+      if (!m[2].startsWith(".")) continue;
+      const names = doors.get(importOf(f.path, m[2]));
+      if (!names) continue;
+      for (const part of /\{([^}]*)\}/.exec(m[1])?.[1].split(",") ?? []) {
+        const [fn, as] = part.trim().split(/\s+as\s+/);
+        if (fn && names.has(fn.trim())) local.set((as ?? fn).trim(), names.get(fn.trim()));
+      }
+      const ns = new RegExp(String.raw`\*\s*as\s+(${ID})`).exec(m[1]);
+      if (ns) spaces.set(ns[1], names);
+    }
+    // The aliases the code makes, twice over so one of another counts.
+    for (let pass = 0; pass < 2; pass++) {
+      for (const m of code.matchAll(new RegExp(String.raw`\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*(${ID})\s*(?=[;\n])`, "g"))) {
+        const names = spaces.get(m[2]);
+        if (!names) continue;
+        for (const part of m[1].split(",")) {
+          const p = new RegExp(String.raw`^\s*(${ID})\s*(?::\s*(${ID}))?\s*(?:=[^,]*)?$`).exec(part);
+          if (p && names.has(p[1])) local.set(p[2] ?? p[1], names.get(p[1]));
+        }
+      }
+      for (const m of code.matchAll(new RegExp(String.raw`\b(?:const|let|var)\s+(${ID})\s*=\s*(${ID})(?:\s*(?:\?\.|\.)\s*(${ID}))?\s*(?=[;\n])`, "g"))) {
+        const [, as, base, member] = m;
+        if (member !== undefined) {
+          if (spaces.get(base)?.has(member)) local.set(as, spaces.get(base).get(member));
+        } else if (spaces.has(base)) spaces.set(as, spaces.get(base));
+        else if (local.has(base) && base !== as) local.set(as, local.get(base));
+      }
+    }
+    const found = []; // { fn, open }: `open` is the call's (
+    for (const [name, fn] of local) {
+      for (const m of code.matchAll(new RegExp(String.raw`(?<![\w$.])${esc(name)}\s*(?:\?\.\s*)?\(`, "g"))) {
+        // `function runAction(` is a definition of the app's own, not a call.
+        if (/\bfunction\s*\*?\s*$/.test(code.slice(Math.max(0, m.index - 16), m.index))) continue;
+        found.push({ fn, open: m.index + m[0].length - 1 });
+      }
+    }
+    for (const [ns, names] of spaces) {
+      for (const m of code.matchAll(new RegExp(String.raw`(?<![\w$.])${esc(ns)}\s*(?:(?:\?\.|\.)\s*(${ID})|(?:\?\.)?\s*\[\s*${lit(2)}\s*\])\s*(?:\?\.\s*)?\(`, "g"))) {
+        const member = m[1] ?? m[3];
+        if (names.has(member)) found.push({ fn: names.get(member), open: m.index + m[0].length - 1 });
+      }
+    }
+    const constAt = stringConsts(code);
+    // A literal, or a constant of this file that the use at `at` sees;
+    // null for anything the code decides at run time.
+    const valueAt = (text, at) => {
+      const v = text.trim();
+      const m = new RegExp(`^${lit(1)}$`).exec(v);
+      if (m) return m[2];
+      return new RegExp(`^${ID}$`).test(v) ? (constAt(v, at)?.value ?? null) : null;
+    };
+    const entries = mounted.get(moduleOf(f.path));
+    for (const { fn, open } of found.sort((a, b) => a.open - b.open)) {
+      const start = open + 1 + /^\s*/.exec(code.slice(open + 1))[0].length;
+      if (fn === "runAction" && /["'`]/.test(code[start] ?? "")) {
+        const m = new RegExp(`^${lit(1)}`).exec(code.slice(start));
+        actions.push({ f, line: lineOf(code, start), name: m ? m[2] : null, form: m ? "string" : "computed" });
+        continue;
+      }
+      const props = code[start] === "{" ? objectProps(code.slice(start, closeOf(code, start) + 1)).filter((p) => p.depth === 1) : [];
+      // The last of a key wins, as in JavaScript.
+      const p = props.findLast((q) => q.key === (fn === "runAction" ? "name" : "source"));
+      const value = p ? valueAt(p.value, start + p.at) : null;
+      const line = lineOf(code, p ? start + p.at : open);
+      if (fn === "runAction") actions.push({ f, line, name: value, form: value === null ? "computed" : "object" });
+      else if (value !== null && value.trim()) tables.push({ f, line, fn, table: value.trim() });
+      else if (p && /^(?:props\s*\??\.\s*)?surface\s*\??\.\s*source$/.test(p.value.trim()) && entries?.length && entries.every(Boolean)) {
+        for (const table of new Set(entries)) tables.push({ f, line, fn, table });
+      } else unread.push({ f, line, fn });
+    }
+  }
+  return { actions, tables, unread };
+}
+
+// `--actions`: what the screens run and write, as JSON, and nothing else,
+// always exit 0. The platform's ship reads it before it builds (claw's
+// STATIC-SPEC §2, "The platform checks at ship"): every action must be a
+// function in the app's schema, which a file cannot show. A check that
+// prints no JSON is one from before 0.7.0, and the ship says so.
+if (ACTIONS_ONLY) {
+  const { actions, tables } = writeCalls();
+  const names = (xs) => [...new Set(xs)].sort();
+  const listed = { actions: names(actions.filter((a) => a.name !== null).map((a) => a.name)), tables: names(tables.map((t) => t.table)) };
+  await new Promise((done) => process.stdout.write(`${JSON.stringify(listed)}\n`, done));
+  process.exit(0);
+}
+
 // 1. Colour lives in the workspace theme, nowhere in the app — except a
 //    depiction, which wears the colours of the place it depicts (rule 7).
 {
@@ -366,7 +859,8 @@ const surfaceKeys = [];
   // in the token check's place. `makersclaw update` removes the template's
   // own from 0.5.x.
   for (const e of existsSync(ROOT) ? readdirSync(ROOT) : []) {
-    if (/^(?:middleware|proxy)\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(e) && e !== "proxy.js") L.hit(e, "proxy", `Next 16 runs proxy.js, the template's fixed token check; delete ${e}`);
+    // A browser app has no proxy.js either; rule 10 (browser) names both files, and why.
+    if (MANIFEST.manifest?.mode !== "browser" && /^(?:middleware|proxy)\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(e) && e !== "proxy.js") L.hit(e, "proxy", `Next 16 runs proxy.js, the template's fixed token check; delete ${e}`);
   }
   // check/ is this script and its pins; a module hidden there is bundled
   // by Next and read by no rule.
@@ -481,17 +975,17 @@ const surfaceKeys = [];
     if ((m = /\bfetch\(|\bwindow\.|\bdocument\.(?![\w-]+["'\s])|localStorage|sessionStorage|getComputedStyle|matchMedia|\bref=\{|"use server"|revalidate/.exec(code))) L.hit(at(m), "io", "no reads, no writes, no browser: the surface does that beside the frame");
   }
 
-  // (b) where it is framed. The folder has one door: a static default
-  //     import under a Capitalised name. Any other string that names the
-  //     folder (import(), require(), a re-export, a split path) is a way
-  //     round the frame, wherever it sits.
+  // (b) where it is framed. The folder has one door: a default import at
+  //     the top of the file, under a Capitalised name. Any other string
+  //     that names the folder (import(), require(), a re-export, a split
+  //     path) is a way round the frame, wherever it sits.
   const DOOR = /(?<!^\s*import\s+[\w$]+\s+from\s*)["'`][^"'`\n]*\bdepictions\b[^"'`\n]*["'`]/m;
   scan(DOOR, (f, m, line) => {
     const slug = /depictions\/([a-z0-9-]+)/.exec(m[0])?.[1];
     if (slug) claimed.add(slug);
     L.hit(`${f.path}:${line}`, "door", `${m[0]}: a depiction is reached by one door — import XPost from "…/depictions/x-post" at the top of the file that frames it`);
   });
-  scan(/\bimport\s*\(|\brequire\s*\(/, (f, m, line) => L.hit(`${f.path}:${line}`, "dynamic", `${m[0].trim()} — the app is one static bundle; write import X from "…" at the top of the file`));
+  scan(/\bimport\s*\(|\brequire\s*\(/, (f, m, line) => L.hit(`${f.path}:${line}`, "dynamic", `${m[0].trim()} — the app is one bundle, every module imported at the top of a file; write import X from "…" at the top of the file`));
   const IMPORT = /^\s*import\s+([^;]*?)\s+from\s*["']([^"']*depictions\/([^"']+?))(?:\.jsx?)?["']/gm;
   const FRAME = new RegExp(String.raw`<Depiction\b(${ATTRS})>\s*<([A-Z]\w*)\b${ATTRS}\/>\s*<\/Depiction>`, "g");
   for (const f of appFiles) {
@@ -589,16 +1083,49 @@ const surfaceKeys = [];
 //    chat for a board, its agent asked the member to make one, since
 //    nothing told it how. An app with no brief beside it (a copy on its
 //    own) is not checked here.
+//
+//    0.7.0 grows it for an app on its own tables ("tables": "own"; claw's
+//    STATIC-SPEC §2). Its screens write through two doors only: a one-row
+//    write (insertRow, updateRow, moveRow, deleteRow, saveSetting), or an
+//    action, a function in the app's schema that runAction runs and the
+//    agent runs too (`select close_cycle($1::jsonb)`). So:
+//    1. No app file writes SQL: an insert into, update … set or delete
+//       from, in any case, in a string of a .js, .jsx or .mjs file (the
+//       fixed lib/ files are skipped, a .sql file is not read), where it
+//       reads as a statement. Both modes, brief or none.
+//    2. Every action the screens run is in the brief: `close_cycle` and
+//       its call, select close_cycle(. A name the code decides at run time
+//       fails, since no brief (and no ship) can name it; so does
+//       runAction("x"), which runs nothing (it takes one object), and a
+//       name no door calls (one bare, lower-case name). Those three need
+//       no brief.
+//    3. Every table the screens write through a one-row write is in the
+//       brief: `deals` for source: "deals". The agent's way is one
+//       statement on it.
+//    4. As before, every server action that writes is in the brief, a
+//       runAction in its body counted as a write.
+//    And no string names the door's path (_claw/data, data/actions/…):
+//    the screens reach it through its functions, which 2 and 3 read.
+//    An app with no tables key, or "public", keeps the rule as it was.
 {
   const home = dirname(ROOT);
-  if (!existsSync(join(home, "AGENTS.md"))) ok("agent", "no AGENTS.md beside the app: its actions are not checked here");
-  else {
-    const refs = join(home, "references");
-    const brief = [join(home, "AGENTS.md"), ...(existsSync(refs) ? readdirSync(refs).filter((n) => n.endsWith(".md")).map((n) => join(refs, n)) : [])]
-      .map((p) => readFileSync(p, "utf8"))
-      .join("\n");
-    const WRITES =
-      /\b(insertRow|updateRow|deleteRow|moveRow|saveSetting)\s*\(|\binsert\s+into\b|\bupdate\s+(?:only\s+)?(?:public\.)?[a-z_][a-z0-9_]*(?:\s+(?:as\s+)?[a-z_][a-z0-9_]*)?\s+set\b|\bdelete\s+from\b/i;
+  const own = MANIFEST.manifest?.tables === "own";
+  const hasBrief = existsSync(join(home, "AGENTS.md"));
+  const refs = join(home, "references");
+  const brief = hasBrief
+    ? [join(home, "AGENTS.md"), ...(existsSync(refs) ? readdirSync(refs).filter((n) => n.endsWith(".md")).map((n) => join(refs, n)) : [])].map((p) => readFileSync(p, "utf8")).join("\n")
+    : "";
+  /** Every exported server action that writes (the names in the brief
+   *  aside): { where, name }. `runAction` counts as a write for an own app. */
+  const serverWrites = (withRunAction) => {
+    // An UPDATE's table is read bare or under any schema. Up to 0.6.x
+    // only `public.` was known, the one schema apps had; an app of 0.7.0
+    // names its own tables bare, and one that still wrote `app_crm.deals`
+    // would have hidden the write from this rule while rule 9 refused it.
+    const WRITES = new RegExp(
+      String.raw`\b(insertRow|updateRow|deleteRow|moveRow|saveSetting${withRunAction ? "|runAction" : ""})\s*(?:\?\.\s*)?\(|\binsert\s+into\b|\bupdate\s+(?:only\s+)?(?:[a-z_][a-z0-9_]*\.)?[a-z_][a-z0-9_]*(?:\s+(?:as\s+)?[a-z_][a-z0-9_]*)?\s+set\b|\bdelete\s+from\b`,
+      "i",
+    );
     // Every top-level function of a server file, bare or wrapped in a call
     // (`export const save = safe(async (…) => …)`), exported by name or in
     // an `export { … }` list. One writes when its body writes, or when it
@@ -634,21 +1161,788 @@ const surfaceKeys = [];
         if ([...local, ...others].some((n) => mentions(f.body.slice(f.body.indexOf("(")), n))) f.writes = changed = true;
       }
     }
-    const writes = fns.filter((f) => f.writes && f.exported).map((f) => ({ where: f.where, name: f.exported }));
+    return fns.filter((f) => f.writes && f.exported).map((f) => ({ where: f.where, name: f.exported }));
+  };
+  /** Clause 4's line, when a server action that writes is not in the brief. */
+  const unnamed = (writes, missing) =>
+    fail(
+      "agent",
+      missing[0].where,
+      `${missing.length} of ${writes.length} server actions that write are not in the agent's brief: ` +
+        `${missing.slice(0, 6).map((w) => w.name).join(", ")}${missing.length > 6 ? ", …" : ""}. Name each in ` +
+        `../references/actions.md, in backticks, with the sql that does the same, so the app's agent can do what the screen does`,
+    );
+
+  if (!own) {
+    if (!hasBrief) ok("agent", "no AGENTS.md beside the app: its actions are not checked here");
+    else {
+      const writes = serverWrites(false);
+      const missing = writes.filter((w) => !brief.includes(`\`${w.name}\``));
+      if (!writes.length) ok("agent", "no server action writes");
+      else if (missing.length) unnamed(writes, missing);
+      else ok("agent", `all ${writes.length} server actions that write are in the agent's brief`);
+    }
+  } else {
+    const L = limiter("agent");
+    const hits = []; // { f, line, what, detail }
+    const DETAIL = "no app file writes SQL. A one-row write is insertRow, updateRow, moveRow, deleteRow or saveSetting; anything else is a function in the app's schema, called with runAction (README §5)";
+    // 1. SQL that writes, where it reads as a statement. Case decides
+    //    nothing: Postgres runs `Delete From deals where …` as it runs
+    //    `delete from deals where …`. Until 0.7.0's review the words had
+    //    to be in one case, which let mixed-case SQL through and refused
+    //    lower-case prose ("delete from your board" in JSX text). Now:
+    //    - Only inside a string or a template literal (literalsOf): JSX
+    //      text, a regular expression that names the words
+    //      (/(?:update|delete from|insert into)\s+/, the sql-console's)
+    //      and JavaScript's `delete from[key]` are not SQL.
+    //    - The words, then the table they write: bare, quoted, under a
+    //      schema, or a template's ${…}. A word starts after anything but
+    //      a letter, a digit, _ or $, or after a string's \n, \r or \t
+    //      ("select 1;\nDELETE FROM deals").
+    //    - Then what SQL puts next: `where`, `using` or `returning` after
+    //      a delete's table (an alias between); `(`, `values`, `select`,
+    //      `default values`, `overriding`, `on conflict` or `returning`
+    //      after an insert's; `<column> =` or `(` after an update's
+    //      `set`; `;` or a template's ${…} after any.
+    //    - Or the statement alone: an insert or a delete that starts the
+    //      string (or follows a ;, a newline) and whose table ends it,
+    //      `"delete from drafts"`. A JSX attribute's value is a label
+    //      then (title="Delete from board"); in code it is refused, with
+    //      a word for a label that reads so.
+    //    - Or handed to query(): `query(…)`, `client.query(…)`, directly or
+    //      through a const of the file, or a sql`…` template. Anything
+    //      that names the words and a table then counts.
+    //    It misses SQL glued together with + across the words.
+    const NAME = String.raw`(?:\\?"[^"\\\n]+\\?"|\$\{[^}\n]*\}|${ID})`;
+    const TABLE = String.raw`(?:only\s+)?(?:${NAME}\.)?${NAME}`;
+    const AT = String.raw`(?:(?<![\w$])|(?<=\\[nrt]))`;
+    const SQL_WRITE = new RegExp(String.raw`${AT}(?:(insert)\s+into\s+${TABLE}|(delete)\s+from\s+${TABLE}|(update)\s+${TABLE}(?:\s+(?:as\s+)?${ID})?\s+set\b)`, "gi");
+    const GOES_ON = {
+      insert: new RegExp(String.raw`^\s*(?:\(|values\b|select\b|default\s+values\b|overriding\b|on\s+conflict\b|returning\b|;|\$\{)`, "i"),
+      delete: new RegExp(String.raw`^\s*(?:(?:as\s+)?${ID}\s+)?(?:where|using|returning)\b|^\s*(?:;|\$\{)`, "i"),
+      update: new RegExp(String.raw`^\s*(?:\(|${NAME}\s*=(?!=)|;|\$\{)`, "i"),
+    };
+    // And (0.7.0's review) the door by its path: `claw("data/actions/x")`,
+    //    `fetch("_claw/data/tables/t/rows")`. A write made so is one no
+    //    clause above sees, and the ship's --actions never lists it; a
+    //    read made so skips rule 11. So in an own app no string names
+    //    `_claw/data`, `data/actions/` or `data/tables/`, and none that
+    //    starts `data/` goes to claw(), clawUrl() or clawStream().
+    const DOOR_PATH = /_claw\/data(?:\/|$)|(?:^|\/)data\/(?:actions|tables)\//;
+    for (const f of jsFiles) {
+      const code = f.code;
+      const handed = handedToQuery(code);
+      const toClaw = new Set();
+      for (const m of code.matchAll(/(?<![\w$.])claw(?:Url|Stream)?\s*(?:\?\.\s*)?\(\s*(?=["'`])/g)) toClaw.add(m.index + m[0].length);
+      // An attribute's value: <button title="…"> or title={"…"}.
+      const attribute = (at) => /\s[A-Za-z][\w-]*=\s*\{?\s*$/.test(code.slice(Math.max(0, at - 80), at));
+      for (const { start, end } of literalsOf(code)) {
+        const inner = code.slice(start + 1, end);
+        if (DOOR_PATH.test(inner) || (toClaw.has(start) && /^data\//.test(inner))) {
+          const path = inner.replace(/\s+/g, " ").slice(0, 60);
+          hits.push({ f, line: lineOf(code, start), what: "path", detail: `"${path}": the screens reach the data door through its functions, never by its path: runAction({ name }) for an action, insertRow, updateRow, moveRow, deleteRow or saveSetting for one row, lib/door.js and lib/brain.js for reads, so the brief and the ship see what the app does (README §5)` });
+        }
+        for (const m of inner.matchAll(SQL_WRITE)) {
+          const kind = (m[1] ?? m[2] ?? m[3]).toLowerCase();
+          const rest = inner.slice(m.index + m[0].length);
+          const statement = handed.has(start) || GOES_ON[kind].test(rest);
+          const alone = !statement && kind !== "update" && !m[0].endsWith("}") && /^\s*;?\s*$/.test(rest) && /(?:^|;|\\[nrt]|\n)\s*$/.test(inner.slice(0, m.index)) && !attribute(start);
+          if (!statement && !alone) continue;
+          const sql = m[0].trim().replace(/\s+/g, " ");
+          hits.push({ f, line: lineOf(code, start + 1 + m.index), what: "sql", detail: `\`${sql}\`: ${DETAIL}${alone ? `. If it is a label, word it otherwise ("Remove from board")` : ""}` });
+        }
+      }
+    }
+    // 2 and 3. What the screens hand to the write doors.
+    const calls = writeCalls();
+    const selects = (name) => new RegExp(String.raw`\bselect\s+${name}\s*\(`, "i").test(brief);
+    for (const a of calls.actions) {
+      let detail = null;
+      if (a.name === null) detail = 'runAction\'s name is decided at run time: name the action in the code, so the brief can (runAction({ name: "close_cycle", args }))';
+      else if (a.form === "string") detail = `runAction("${a.name}") runs nothing: it takes one object, runAction({ name: "${a.name}", args })`;
+      else if (!ACTION_NAME.test(a.name)) detail = `runAction runs "${a.name}": an action is one bare, lower-case name (close_cycle), a function of the app's own schema, the one the door calls`;
+      else if (!hasBrief) continue;
+      else if (!brief.includes(`\`${a.name}\``)) detail = `runAction runs ${a.name}, which the agent's brief does not name: add \`${a.name}\` to ../references/actions.md with its call, \`select ${a.name}($1::jsonb)\` and its params, so the app's agent runs the same function`;
+      else if (!selects(a.name)) detail = `the agent's brief names \`${a.name}\` but not its call: write \`select ${a.name}($1::jsonb)\` and its params there, so the app's agent runs the same function the screen does`;
+      if (detail) hits.push({ f: a.f, line: a.line, what: `${a.form} action ${a.name}`, detail });
+    }
+    if (hasBrief) {
+      for (const t of calls.tables) {
+        if (!brief.includes(`\`${t.table}\``)) hits.push({ f: t.f, line: t.line, what: `table ${t.table}`, detail: `${t.fn} writes ${t.table}, which the agent's brief does not name: add \`${t.table}\` to ../references/actions.md with the one statement that does the same on it` });
+      }
+    }
+    // Reported file by file, top to bottom, whichever clause found each.
+    const order = new Map(files.map((f, i) => [f, i]));
+    hits.sort((a, b) => order.get(a.f) - order.get(b.f) || a.line - b.line);
+    for (const h of hits) L.hit(`${h.f.path}:${h.line}`, h.what, h.detail);
+    if (L.count > 4) fail("agent", `${L.count - 4} more`, "writes the agent's brief does not name, SQL that writes in app code, or the door by its path");
+    // 4. Server actions, as before.
+    const writes = hasBrief ? serverWrites(true) : [];
     const missing = writes.filter((w) => !brief.includes(`\`${w.name}\``));
-    if (!writes.length) ok("agent", "no server action writes");
-    else if (missing.length)
-      fail(
+    if (missing.length) unnamed(writes, missing);
+    if (!L.count && !missing.length) {
+      const actions = new Set(calls.actions.map((a) => a.name)).size;
+      const tables = new Set(calls.tables.map((t) => t.table)).size;
+      // A write whose table the code decides at run time (a prop, a
+      // parameter) is not checked, and the line says so rather than
+      // claim every table.
+      const n = calls.unread.length;
+      const unread = n ? `; ${n} one-row write${n === 1 ? " names its" : "s name their"} table at run time (${calls.unread[0].f.path}:${calls.unread[0].line}), not checked here` : "";
+      ok(
         "agent",
-        missing[0].where,
-        `${missing.length} of ${writes.length} server actions that write are not in the agent's brief: ` +
-          `${missing.slice(0, 6).map((w) => w.name).join(", ")}${missing.length > 6 ? ", …" : ""}. Name each in ` +
-          `../references/actions.md, in backticks, with the sql that does the same, so the app's agent can do what the screen does`,
+        hasBrief
+          ? `no SQL write in app code; the agent's brief names every action with its call (${actions}), every table written (${tables}) and every server action that writes (${writes.length})${unread}`
+          : "no SQL write in app code; no AGENTS.md beside the app: its actions are not checked here",
       );
-    else ok("agent", `all ${writes.length} server actions that write are in the agent's brief`);
+    }
   }
 }
 
+/** Is the `from` at `at` one that SQL puts before a column, not a
+ *  table? `is [not] distinct from t.col`, and inside the parentheses of
+ *  extract(epoch from t.at), substring(… from …), trim(… from …) and
+ *  overlay(… from …). Read back to the parenthesis that holds it, within
+ *  the SQL's own string (a backtick, a double quote or a ; ends the
+ *  walk). Found in 0.7.0's review: an own app with a table named
+ *  app_events was refused `extract(epoch from app_events.created_at)`. */
+function columnFrom(code, at) {
+  if (!/^from\b/i.test(code.slice(at, at + 5))) return false;
+  if (/\bdistinct\s+$/i.test(code.slice(Math.max(0, at - 20), at))) return true;
+  let depth = 0;
+  for (let j = at - 1; j >= 0 && at - j < 400; j--) {
+    const c = code[j];
+    if (c === "`" || c === '"' || c === ";") return false;
+    if (c === ")") depth++;
+    else if (c === "(" && depth-- === 0) return /\b(?:extract|substring|trim|overlay)\s*$/i.test(code.slice(Math.max(0, j - 12), j));
+  }
+  return false;
+}
+
+// 9. The app's tables are its own (0.7.0, claw's APPS-SPEC 4.1). When
+//    makersclaw.json says "tables": "own", the app lives in its own
+//    schema (app_<name> in Makersclaw) and names every table of its own
+//    bare: its role's search_path finds them, and it holds nothing in
+//    public. So in the app's code a qualified name is refused when it is:
+//    - public.<t>: the schema every app shared up to 0.6.x. An own app's
+//      role cannot reach it, so the page would fail in the workspace;
+//    - app_<x>.<t>: a schema by name, even the app's own. A second copy of
+//      the app lives in another schema, and another app's tables are not
+//      this one's to reach;
+//    - brain.<t> or brain_api.<t>: the company brain. An app reaches it
+//      through lib/brain.js, where the door knows who asks and logs it;
+//      the brain's functions (`select brain_api.write(…)`) have no
+//      `from`, so any brain_api. name is refused.
+//    claw.<t> and claw_app.<t> (the activity view) are the platform's
+//    doors and pass. The names read, each bare or qualified: a surface's
+//    source, insertRow's and updateRow's first argument (its `source`,
+//    as for every call of lib/actions.js and lib/data.js), and the name
+//    after from, join, into and update in SQL (not a column's from:
+//    columnFrom). A string constant of the same file that the use sees
+//    counts as written in place (`const SOURCE = "…"`, then `source:
+//    SOURCE`). An app laid before 0.7.0 has no tables key and
+//    keeps its public names: this rule does not read them, and neither
+//    does "public". "moved" is refused: it is the platform's mode for a
+//    legacy app whose tables the workspace's move put in its schema
+//    (claw's MIGRATE-SPEC M17), never a manifest's.
+//    And a bare name is one the app's own schema makes (claw's
+//    MIGRATE-SPEC §10 and 7.2), so no bare name leans on something else:
+//    on a moved app's search_path a view in public answers a bare name,
+//    and a rebuild to own would ship code that reads it. The list is
+//    APP_TABLES (CLAW_APP_TABLES, then ../install/schema.sql, then
+//    ../../schema.sql); with none, the ok line says so. Bare names are
+//    read where they are surely tables, since a bare word is also what
+//    a column's value and prose look like:
+//    - a source: every `source` of surfaces.js (a literal or a const the
+//      entry sees, its key quoted or not), and the `source` of a call of
+//      lib/data.js, lib/door.js or lib/actions.js by its name (loadRows,
+//      useRows, insertRow, …), bare or through a namespace, either side
+//      of a ternary. Not `source: "web"` in a row's values, nor another
+//      function's `source`. Not read: an import alias, options held in a
+//      variable (`loadRows(opts)`);
+//    - SQL: strings joined with + read as one (sqlTexts), handed to
+//      query() or a sql`…` template, or starting as a statement (select,
+//      with, insert, update or delete, in one case). In it: the name
+//      after from (and each after its commas), join, insert into, merge
+//      into, update … set, a delete's or a merge's using, and a
+//      statement's table, truncate or copy. Not a function (`from
+//      unnest(…)`), a column's from, a CTE the same text names, a SQL
+//      string ('…') or comment, or pg_catalog's (pg_*). Not read: SQL a
+//      helper takes that does not start as a statement (`run("explain
+//      …")`), SQL built at run time (an array's join). A qualified name
+//      found there is judged as above, with spaces around its dot or
+//      not: forms only SQL's own text shows (a comma's, a using's).
+{
+  const { manifest, broken } = MANIFEST;
+  const tables = manifest && typeof manifest === "object" ? manifest.tables : undefined;
+  if (broken) fail("tables", "makersclaw.json", `is not JSON (${broken}), so where this app's tables live is unknown; \`makersclaw update\` reads it too`);
+  else if (tables === undefined || tables === "public")
+    ok("tables", tables === "public" ? 'on public (makersclaw.json "tables": "public"): names not checked here' : "no tables key in makersclaw.json (an app from before 0.7.0, on public): names not checked here");
+  else if (tables === "moved")
+    fail("tables", "makersclaw.json", `"tables": "moved" — moved is the platform's mode, never a manifest's: a moved app's makersclaw.json says "public" (or has no tables key) until its rebuild sets "own"`);
+  else if (tables !== "own") fail("tables", "makersclaw.json", `"tables": ${JSON.stringify(tables)} — an app's tables are "own" or "public"; set the one the platform holds for this app`);
+  else {
+    const L = limiter("tables");
+    const why = (schema, table) => {
+      const s = schema.toLowerCase();
+      if (s === "public") return `this app's tables are in its own schema ("tables": "own") and its role reaches nothing in public; write ${table}, bare`;
+      if (/^app_./.test(s)) return `name the app's own tables bare (${table}): a second copy of the app lives in another schema, and another app's tables are not this one's`;
+      if (s === "brain" || s === "brain_api") return "the company brain is reached through lib/brain.js (listRecords, getRecord, writeRecord…), never by its tables";
+      return null; // claw., claw_app., and schemas that are not apps' to keep out of
+    };
+    // A name two readers see (`from public.x`, over the whole code and in
+    // its SQL) is reported once: the limiter keeps one per file and name.
+    const hits = [];
+    const judge = (f, name, index) => {
+      const m = new RegExp(String.raw`^(?:"(${ID})"|(${ID}))\.(?:"(${ID})"|(${ID}))$`).exec(name.trim().replace(/\\"/g, '"'));
+      if (!m) return; // bare, or not a table name at all
+      const schema = m[1] ?? m[2];
+      const table = m[3] ?? m[4];
+      const reason = why(schema, table);
+      if (reason) hits.push({ f, line: lineOf(f.code, index), name: `${schema}.${table}`, reason });
+    };
+    for (const f of appFiles) {
+      if (!/\.(?:jsx?|mjs|cjs|tsx?|mts|cts)$/.test(f.path)) continue;
+      const code = f.code;
+      // The file's string constants, so a name held in one is read where
+      // it is written.
+      const constAt = stringConsts(code);
+      const named = (value, id, index) => {
+        if (value !== undefined) return judge(f, value, index);
+        const c = constAt(id, index);
+        if (c) judge(f, c.value, c.index);
+      };
+      // A source, wherever one is named: a surface's (surfaces.js), and
+      // the first argument of insertRow, updateRow and the rest of
+      // lib/actions.js and lib/data.js, which names its table in
+      // `source`. Written in place (`source: "deals"`, or its key quoted,
+      // `"source": "deals"`), through a constant (`source: SOURCE`), as a
+      // variable (`const source = "deals"`, then `{ source }`) or a prop
+      // (`source="deals"`).
+      for (const m of code.matchAll(new RegExp(String.raw`(?:\bsource|"source"|'source')\s*(?::\s*|=(?![=>])\s*\{?\s*)(?:${lit(1)}|(${ID})(?![\w$]|\s*[.(\[?]))`, "g"))) named(m[2], m[3], m.index);
+      // SQL, wherever it is written: a string, a template over several
+      // lines, pieces joined with +. A JavaScript statement never puts a
+      // name after these words (an import's path is quoted), so the whole
+      // code is read. A quoted identifier counts ("public"."deals"). SQL
+      // is written in one case, so a Capitalised word is prose, not a
+      // schema ("Imported from Public.com"); prose in lower case that
+      // reads like one is refused like SQL. A `from` that SQL puts before
+      // a column is passed over (columnFrom). What only SQL's own strings
+      // show (a comma's table, a using, spaces around the dot) is read
+      // below, in the strings that are SQL.
+      for (const m of code.matchAll(new RegExp(String.raw`\b(?:from|join|into|update)\s+(?:only\s+)?((?:\\?"${ID}\\?"|${ID})\.(?:\\?"${ID}\\?"|${ID}))`, "gi"))) {
+        if (!/^[A-Z][a-z]/.test(m[1]) && !columnFrom(code, m.index)) judge(f, m[1], m.index + m[0].length - m[1].length);
+      }
+      for (const m of code.matchAll(new RegExp(String.raw`\bbrain_api\.(?:"${ID}"|${ID})`, "g"))) judge(f, m[0], m.index);
+    }
+    // The last clause: a bare name is one the app's own schema makes.
+    // With no list here, bare names are not held to one.
+    let bare = () => {};
+    if (APP_TABLES) {
+      const { names, from } = APP_TABLES;
+      const sorted = [...names].sort();
+      const list = sorted.length ? `${sorted.slice(0, 6).join(", ")}${sorted.length > 6 ? ", …" : ""}` : "none";
+      const reason = (name) =>
+        `not a table or view this app's schema makes (${from}: ${list}). A bare name reaches only the app's own schema: in the workspace ` +
+        `${name} fails, or, on a moved app, reads a view in public. Name a table of its own, or reach a company thing through lib/brain.js` +
+        (from === "../install/schema.sql"
+          ? `; a table made since with sql is not in ${from}: the platform's ship checks the live list`
+          : from === "../../schema.sql"
+            ? `; a table the package makes belongs in ${from}`
+            : "");
+      // `fold`: SQL folds an unquoted name to lower case; a source is
+      // quoted as written (lib/db.js ident, the door).
+      bare = (f, raw, index, fold) => {
+        const m = new RegExp(String.raw`^\s*(?:\\?"(${ID})\\?"|(${ID}))\s*$`).exec(raw);
+        if (!m) return; // qualified, or not one name: judge reads it
+        const name = m[1] ?? (fold ? m[2].toLowerCase() : m[2]);
+        if (names.has(name) || /^pg_/.test(name)) return;
+        hits.push({ f, line: lineOf(f.code, index), name, reason: reason(name) });
+      };
+    }
+    // Sources: surfaces.js's entries, and the `source` of a call of the
+    // data layer, by its name (bare, or through a namespace).
+    const TAKES_SOURCE = ["loadRows", "loadRow", "countRows", "countBy", "useRows", "useRow", "useCount", "useCountBy", ...ROW_WRITES];
+    const CALL = new RegExp(String.raw`(?<![\w$])(?:${ID}\s*\??\.\s*)?(?:${TAKES_SOURCE.join("|")})\s*(?:\?\.\s*)?\(\s*(?=\{)`, "g");
+    const VALUE = String.raw`"[^"\\\n]*"|'[^'\\\n]*'|${ID}`;
+    // SQL: a run of strings (sqlTexts) that is SQL by where it goes
+    // (handedToQuery) or by how it starts, its verb in one case.
+    const STATEMENT = new RegExp(
+      String.raw`^\s*\(?\s*(?:(select)\s|(with)\s+(?:recursive\s+)?${ID}\s*(?:\([^()]*\)\s*)?as\s*(?:not\s+)?(?:materialized\s*)?\(|(insert)\s+into\s|(update)\s+(?:only\s+)?(?:\\?"${ID}\\?"|${ID})(?:\s+(?:as\s+)?${ID})?\s+set\s|(delete)\s+from\s)`,
+      "i",
+    );
+    // Where SQL names a table: the words, then one name, or (`list`) a
+    // comma's more (from a, b; using a, b; truncate a, b). A qualified
+    // name may have spaces around its dot (public . deals).
+    const PART = String.raw`\\?"${ID}\\?"|${ID}`;
+    const ONE = String.raw`(?:only\s+)?(?:${PART})(?:\s*\.\s*(?:${PART}))?`;
+    const PLACES = [
+      [/(?<![\w$])from\s+/gi, { list: true, fn: true, from: true }],
+      [/(?<![\w$])join\s+/gi, { fn: true }],
+      [/(?<![\w$])(?:insert|merge)\s+into\s+/gi, {}],
+      [/(?<![\w$])update\s+/gi, { set: true }],
+      [new RegExp(String.raw`(?<![\w$])(?:delete\s+from|merge\s+into)\s+${ONE}(?:\s*\*)?(?:\s+(?:as\s+)?(?!using\b)${ID})?\s+using\s+`, "gi"), { list: true, fn: true }],
+      [/(?:^|[;(]|(?<![\w$])(?:union|intersect|except)(?:\s+(?:all|distinct))?)\s*table\s+/gi, {}],
+      [/(?:^|;)\s*truncate\s+(?:table\s+)?/gi, { list: true }],
+      [/(?:^|;)\s*copy\s+/gi, {}],
+    ];
+    const ITEM = new RegExp(String.raw`(${PART})(?:\s*\.\s*(${PART}))?(?![\w$]|\s*\.)`, "y");
+    const MORE = new RegExp(String.raw`(?:\s*\*)?(?:\s+(?:as\s+)?${ID})?\s*,\s*`, "y");
+    const SET = new RegExp(String.raw`^(?:\s+(?:as\s+)?${ID})?\s+set\b`, "i");
+    const CTE = new RegExp(String.raw`(?:\bwith\s+(?:recursive\s+)?|,\s*)(${ID})\s*(?:\([^()]*\)\s*)?as\s*(?:not\s+)?(?:materialized\s*)?\(`, "gi");
+    const KEYWORDS = new Set(["lateral", "only", "select", "set", "values", "rows", "stdin", "program"]);
+    // The names a SQL text holds: { schema, table, index }, no schema for a
+    // bare one. Not a function (`from unnest(…)`), a column's from, a CTE
+    // the same text names, or a keyword.
+    const namesIn = (text) => {
+      const ctes = new Set([...text.matchAll(CTE)].map((m) => m[1].toLowerCase()));
+      const out = [];
+      for (const [re, how] of PLACES) {
+        for (const m of text.matchAll(re)) {
+          if (how.from && columnFrom(text, m.index)) continue;
+          let pos = m.index + m[0].length;
+          for (;;) {
+            pos += /^only\s+/i.exec(text.slice(pos))?.[0].length ?? 0;
+            ITEM.lastIndex = pos;
+            const it = ITEM.exec(text);
+            if (!it) break;
+            const rest = text.slice(ITEM.lastIndex);
+            if (how.fn && /^\s*\(/.test(rest)) break; // a function: from unnest($1)
+            if (how.set && !SET.test(rest)) break; // for update, on update cascade
+            const plain = (it[2] ?? it[1]).replace(/\\?"/g, "").toLowerCase();
+            if (it[2]) out.push({ schema: it[1], table: it[2], index: pos });
+            else if (KEYWORDS.has(plain)) break;
+            else if (!ctes.has(plain)) out.push({ table: it[1], index: pos });
+            if (!how.list) break;
+            MORE.lastIndex = ITEM.lastIndex;
+            if (!MORE.exec(text)) break;
+            pos = MORE.lastIndex;
+          }
+        }
+      }
+      return out;
+    };
+    for (const f of appFiles) {
+      if (!/\.(?:jsx?|mjs|cjs|tsx?|mts|cts)$/.test(f.path)) continue;
+      const code = f.code;
+      if (APP_TABLES) {
+        const constAt = stringConsts(code);
+        // A literal, or a const of the file the use sees.
+        const valueAt = (v, at) => {
+          const quoted = new RegExp(`^${lit(1)}$`).exec(v);
+          return quoted ? quoted[2] : new RegExp(`^${ID}$`).test(v) ? constAt(v, at)?.value : undefined;
+        };
+        if (f.path === "surfaces.js") {
+          for (const m of code.matchAll(new RegExp(String.raw`(?:\bsource|"source"|'source')\s*:\s*(?:${lit(1)}|(${ID})(?![\w$]|\s*[.(\[?]))`, "g"))) {
+            const value = m[2] ?? constAt(m[3], m.index)?.value;
+            if (value !== undefined) bare(f, value, m.index, false);
+          }
+        }
+        for (const m of code.matchAll(CALL)) {
+          const start = m.index + m[0].length;
+          const p = objectProps(code.slice(start, closeOf(code, start) + 1)).findLast((q) => q.depth === 1 && q.key === "source");
+          if (!p) continue;
+          const at = start + p.at;
+          // Either side of a ternary: source: open ? "deals" : "archive".
+          const either = new RegExp(String.raw`^[^?:"'\`]+\?\s*(${VALUE})\s*:\s*(${VALUE})$`).exec(p.value.trim());
+          for (const v of either ? [either[1], either[2]] : [p.value.trim()]) {
+            const value = valueAt(v, at);
+            if (value !== undefined) bare(f, value, at, false);
+          }
+        }
+      }
+      for (const { text, at, handed } of sqlTexts(code)) {
+        if (!handed) {
+          const s = STATEMENT.exec(text);
+          const verb = s && s.slice(1).find(Boolean);
+          if (!verb || (verb !== verb.toLowerCase() && verb !== verb.toUpperCase())) continue;
+        }
+        for (const n of namesIn(text)) {
+          if (n.schema) judge(f, `${n.schema}.${n.table}`, at(n.index));
+          else bare(f, n.table, at(n.index), true);
+        }
+      }
+    }
+    // Reported file by file, top to bottom, whichever scanner read each.
+    const order = new Map(appFiles.map((f, i) => [f, i]));
+    hits.sort((a, b) => order.get(a.f) - order.get(b.f) || a.line - b.line);
+    for (const h of hits) L.hit(`${h.f.path}:${h.line}`, h.name.toLowerCase(), `${h.name}: ${h.reason}`);
+    if (L.count > 4) fail("tables", `${L.count - 4} more`, "names outside this app's own tables; each is written bare, is one the app's schema makes, or goes through lib/brain.js");
+    if (!L.count) {
+      ok(
+        "tables",
+        APP_TABLES
+          ? `its own schema (makersclaw.json): every table named bare, and each bare name one of the ${APP_TABLES.names.size} its schema makes (${APP_TABLES.from}); claw. and claw_app. are the platform's`
+          : "its own schema (makersclaw.json): every table named bare; claw. and claw_app. are the platform's; no table list here (CLAW_APP_TABLES, ../install/schema.sql, ../../schema.sql), so bare names are not held to one",
+      );
+    }
+  }
+}
+
+// 10. A browser app is files and a door (0.7.0, claw's STATIC-SPEC §3).
+//     Only when makersclaw.json says "mode": "browser", exactly as
+//     next.config.mjs reads it. Its pages are built once into files the
+//     platform serves; nothing of it runs in the VM, and every read and
+//     write goes through the platform's data door (lib/door.js, which
+//     lib/data.js and lib/actions.js re-export). So the app holds:
+//     1. no "use server" module, and no function marked so: there is no
+//        server to run it;
+//     2. no import of next/headers, next/cache, next/server, pg or
+//        lib/db (nor lib/brain-server, which browser mode drops);
+//     3. no route.js or route.ts under app/;
+//     4. no proxy.js or middleware.js at the root. Under export Next
+//        warns and then ignores it, so its token check would be dead
+//        without a word;
+//     5. no export of dynamic, revalidate, fetchCache, runtime or
+//        dynamicParams (route segment config) in its code;
+//     6. every surface file surfaces.js mounts starts with "use client":
+//        the export holds its loading line, the browser renders it;
+//     7. no process.env.<X> but CLAW_BASE_PATH, CLAW_PRODUCT,
+//        NEXT_PUBLIC_* and NODE_ENV. A prerendered page prints what it
+//        reads into a file anyone who opens the app can fetch; NODE_ENV
+//        is "production" in every build and no secret.
+//     The build refuses 1, 2 and 5 itself, later and less clearly. 3 and
+//     4 read the folders, not the rules' file list: the template's own
+//     app/claw-alive/route.js and proxy.js are server mode's, and a
+//     browser app that still holds them is told to delete them.
+{
+  if (MANIFEST.manifest?.mode === "browser") {
+    const L = limiter("browser");
+    const code = files.filter((f) => /\.(?:[mc]?jsx?|[mc]?tsx?)$/.test(f.path));
+    const NO_SERVER = "a browser app has no server to run it: write with lib/actions.js (insertRow, updateRow, runAction…), which the platform's data door answers";
+
+    // 1. "use server", as a file's directive or a function's first line (after the
+    //    file's start, `{` or `;`: the last string of an array is not one).
+    scan(/(^|[{;])(\s*)(["'])use server\3\s*(?:;|(?=\n|\}|$))/, (f, m, line) =>
+      L.hit(`${f.path}:${lineOf(f.code, m.index + m[1].length + m[2].length)}`, "use-server", `"use server" — ${NO_SERVER}`), code);
+
+    // 2. Server modules, however the file reaches them.
+    const SERVER_MODULE = {
+      "next/headers": "a browser app's page is a file built once, with no request: who is asking is the door's to know (lib/door.js)",
+      "next/cache": "a browser app's page is a file built once: nothing to revalidate; the door's change stamp refreshes the rows (app/auto-refresh.jsx)",
+      "next/server": "a browser app has no request handlers: the platform's data door answers its reads and writes",
+      pg: "a browser app holds no database connection: read with lib/data.js (useRows…), write with lib/actions.js",
+      "lib/db": "a browser app holds no database connection: read with lib/data.js (useRows…), write with lib/actions.js",
+      "lib/brain-server": "browser mode has no lib/brain-server.js: read the brain with lib/brain.js, from a client component",
+    };
+    const IMPORT_SPEC = /\b(?:import|export)\b(?:(?!\b(?:import|export)\b)[^;"'`])*?\bfrom\s*(["'])([^"'\n]+)\1|\bimport\s*(["'])([^"'\n]+)\3|\b(?:require|import)\s*\(\s*(["'`])([^"'`\n]+)\5\s*\)/;
+    scan(IMPORT_SPEC, (f, m, line) => {
+      const spec = m[2] ?? m[4] ?? m[6];
+      const name = spec.startsWith(".") ? importOf(f.path, spec) : spec.replace(/^(pg)\/.*$/, "$1");
+      if (Object.prototype.hasOwnProperty.call(SERVER_MODULE, name)) L.hit(`${f.path}:${line}`, `import:${name}`, `imports ${spec} — ${SERVER_MODULE[name]}`);
+    }, code);
+
+    // 3. Route handlers under app/, on disk.
+    const appDir = join(ROOT, "app");
+    for (const full of existsSync(appDir) ? walk(appDir) : []) {
+      const rel = relative(ROOT, full).split(sep).join("/");
+      if (!/(?:^|\/)route\.(?:[mc]?jsx?|[mc]?tsx?)$/.test(rel)) continue;
+      if (rel === "app/claw-alive/route.js") L.hit(rel, "route", "server mode's liveness route; browser mode drops it (a browser app's auto-refresh asks the door what changed): delete it");
+      else L.hit(rel, "route", "a browser app has no request handlers: its pages are files, and the platform's data door answers its reads and writes (lib/door.js)");
+    }
+
+    // 4. A proxy or a middleware at the root, on disk.
+    for (const name of readdirSync(ROOT).filter((n) => /^(?:proxy|middleware)\.(?:[mc]?jsx?|[mc]?tsx?)$/.test(n)).sort()) {
+      L.hit(name, "proxy", 'under output: "export" Next warns and then ignores it, so its check would never run; the platform guards a browser app\'s files itself: delete it');
+    }
+
+    // 5. Route segment config, as a declaration or in an export list.
+    const SEGMENT = new Set(["dynamic", "revalidate", "fetchCache", "runtime", "dynamicParams"]);
+    const SEGMENT_DO = "a browser app's every page is a file built once, and route segment config only fails the export: take it out (a route of your own lists its values in generateStaticParams)";
+    scan(/\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/, (f, m, line) => {
+      if (SEGMENT.has(m[1])) L.hit(`${f.path}:${line}`, `segment:${m[1]}`, `export const ${m[1]} — ${SEGMENT_DO}`);
+    }, code);
+    scan(/\bexport\s*\{([^}]*)\}/, (f, m, line) => {
+      for (const part of m[1].split(",")) {
+        const name = part.trim().split(/\s+as\s+/).pop().trim();
+        if (SEGMENT.has(name)) L.hit(`${f.path}:${line}`, `segment:${name}`, `export { ${part.trim()} } — ${SEGMENT_DO}`);
+      }
+    }, code);
+
+    // 6. Every surface the manifest mounts is a client component.
+    let clientSurfaces = 0;
+    for (const mod of [...surfaceSources().keys()].sort()) {
+      const file = [".jsx", ".js", ".tsx", ".ts", "/index.jsx", "/index.js"].map((ext) => `${mod}${ext}`).find((p) => existsSync(join(ROOT, p)));
+      if (!file) continue; // rule 4 names a surface that is not there
+      if (/^\s*(["'])use client\1/.test(stripComments(readFileSync(join(ROOT, file), "utf8")))) clientSurfaces++;
+      else L.hit(`${file}:1`, "client", 'a browser app\'s surface renders in the browser: put "use client" on its first line (it reads its rows with lib/data.js\'s hooks, and ?row= with useSearchParams)');
+    }
+
+    // 7. The environment, by name only, and only the names a page may print.
+    const ENV_OK = (name) => name === "CLAW_BASE_PATH" || name === "CLAW_PRODUCT" || name === "NODE_ENV" || name.startsWith("NEXT_PUBLIC_");
+    const ENV_DO = "a prerendered page prints what it reads into a file anyone who opens the app can fetch; a browser app reads only CLAW_BASE_PATH, CLAW_PRODUCT and NEXT_PUBLIC_* (a secret stays with the platform)";
+    scan(/\bprocess\s*\??\.\s*env\b(?:\s*\??\.\s*([A-Za-z_$][\w$]*)|\s*(?:\?\.)?\s*\[\s*(?:(["'`])([^"'`\n]*)\2\s*\])?)?/, (f, m, line) => {
+      const where = `${f.path}:${line}`;
+      const named = m[1] ?? m[3];
+      if (named !== undefined) {
+        if (!ENV_OK(named)) L.hit(where, `env:${named}`, `process.env.${named} — ${ENV_DO}`);
+        return;
+      }
+      if (/\[\s*$/.test(m[0])) {
+        L.hit(where, "env:[]", `process.env[…] — a name the code decides at run time; ${ENV_DO}`);
+        return;
+      }
+      // The whole object: destructured by name, or handed on.
+      const before = f.code.slice(0, m.index);
+      const pattern = /\b(?:const|let|var)\s*\{([^{}]*)\}\s*=\s*$/.exec(before);
+      if (!pattern) {
+        L.hit(where, "env:*", `process.env, whole — ${ENV_DO}`);
+        return;
+      }
+      for (const part of pattern[1].split(",").map((p) => p.trim()).filter(Boolean)) {
+        const name = part.startsWith("...") ? "..." : part.split(/[:=]/)[0].trim();
+        if (name === "...") L.hit(where, "env:*", `{ ${part} } = process.env takes every variable — ${ENV_DO}`);
+        else if (!ENV_OK(name)) L.hit(where, `env:${name}`, `{ ${name} } = process.env — ${ENV_DO}`);
+      }
+    }, code);
+
+    if (L.count > 4) fail("browser", `${L.count - 4} more`, "more of the same: what a browser app cannot hold (server code, a route, a proxy, segment config, a server surface, an env name a page would print)");
+    if (!L.count) ok("browser", `files and a door: ${clientSurfaces} client surface${clientSurfaces === 1 ? "" : "s"}; no server code, route, proxy or segment config; env only by the names a page may print`);
+  }
+}
+
+// 11. The company brain: what the app touches is declared (0.7.0, claw's
+//     CONTRACTS §9). makersclaw.json's `brain` block names the kinds the
+//     app defines (`kinds`), reads and writes; the door hands the app
+//     only what `reads` and `writes` name (writes imply reads, "*" is
+//     every kind) and answers anything else `not_declared`, on the
+//     member's screen. So this rule checks the block's shape (kinds,
+//     reads, writes and links are arrays; each kind has kind, label,
+//     plural and fields), then reads every call of lib/brain.js and
+//     lib/brain-server.js whose kind is written in the code, in place or
+//     as a string constant of the same file that the call sees:
+//     - a read's (listRecords, countRecords, brainLists, and the hooks
+//       useRecords and useRecordCounts: `kind`; searchBrain,
+//       brainChanges and the hook useBrainSearch: `kinds`;
+//       brainRead("<one of them>", { … }), which they all run through) is
+//       in reads or writes;
+//     - a write's (writeRecord, createList: `kind`; writeRecords: each
+//       entry's) is in writes.
+//     A kind held in a variable is not read. The full rules (field types,
+//     keys, each link against the app's tables, "*" only in reviewed
+//     code) are claw's (shared/src/brain-declaration.ts) and run when the
+//     app ships or installs; this rule does not copy them.
+{
+  const L = limiter("brain");
+  const { manifest, broken } = MANIFEST;
+  const declared = !!manifest && typeof manifest === "object" && !Array.isArray(manifest) && Object.prototype.hasOwnProperty.call(manifest, "brain");
+  const brain = declared ? manifest.brain : undefined;
+  const what = (v) => (v === null ? "null" : Array.isArray(v) ? "an array" : v === "" ? "an empty string" : typeof v === "object" ? "an object" : `a ${typeof v}`);
+  const LISTS = {
+    kinds: '[{ "kind": "contact", "label": "Contact", "plural": "Contacts", "fields": [...] }]',
+    reads: '["company"]',
+    writes: '["contact"]',
+    links: '[{ "table": "tasks", "column": "contact_id", "kind": "contact", "on_erase": "null" }]',
+  };
+
+  // The shape.
+  const shape = [];
+  if (declared) {
+    if (!brain || typeof brain !== "object" || Array.isArray(brain)) shape.push(`"brain" is ${what(brain)}, not an object: "brain": { "kinds": [...], "reads": [...], "writes": [...], "links": [...] }`);
+    else {
+      for (const [key, example] of Object.entries(LISTS)) {
+        if (brain[key] !== undefined && !Array.isArray(brain[key])) shape.push(`brain.${key} is ${what(brain[key])}, not an array: "${key}": ${example}`);
+      }
+      (Array.isArray(brain.kinds) ? brain.kinds : []).forEach((def, i) => {
+        if (!def || typeof def !== "object" || Array.isArray(def)) {
+          shape.push(`brain.kinds[${i}] is ${what(def)}; each kind is an object with kind, label, plural and fields`);
+          return;
+        }
+        const wrong = [];
+        for (const k of ["kind", "label", "plural"]) {
+          if (def[k] === undefined) wrong.push(`no ${k}`);
+          else if (typeof def[k] !== "string" || !def[k].trim()) wrong.push(`its ${k} is ${what(def[k])}`);
+        }
+        if (def.fields === undefined) wrong.push("no fields");
+        else if (!Array.isArray(def.fields)) wrong.push(`its fields are ${what(def.fields)}`);
+        const name = typeof def.kind === "string" && def.kind.trim() ? ` ("${def.kind}")` : "";
+        if (wrong.length) shape.push(`brain.kinds[${i}]${name} has ${wrong.join(", ")}: each kind has kind, label and plural (words) and fields (an array)`);
+      });
+      for (const key of ["reads", "writes"]) {
+        (Array.isArray(brain[key]) ? brain[key] : []).forEach((k, i) => {
+          if (typeof k !== "string" || !k.trim()) shape.push(`brain.${key}[${i}] is ${what(k)}; ${key} names kinds: "${key}": ${LISTS[key]}`);
+        });
+      }
+    }
+  }
+
+  // The calls: every call of a function imported from lib/brain.js or
+  // lib/brain-server.js (by name, or `import * as brain`), and the kinds
+  // it names.
+  const ONE_READ = new Set(["listRecords", "countRecords", "brainLists", "useRecords", "useRecordCounts"]);
+  const MANY_READ = new Set(["searchBrain", "brainChanges", "useBrainSearch"]);
+  const ONE_WRITE = new Set(["writeRecord", "createList"]);
+  const calls = []; // { f, line, fn, kind, write }
+  for (const f of appFiles) {
+    if (!/\.(?:jsx?|mjs|cjs|tsx?|mts|cts)$/.test(f.path)) continue;
+    const code = f.code;
+    const named = new Map(); // local name → the function it is
+    const spaces = new Set();
+    for (const m of code.matchAll(/^\s*import\s+([^;]*?)\s+from\s*["']([^"'\n]+)["']/gm)) {
+      if (!m[2].startsWith(".")) continue;
+      const target = posix.normalize(posix.join(posix.dirname(f.path), m[2])).replace(/\.js$/, "");
+      if (target !== "lib/brain" && target !== "lib/brain-server") continue;
+      for (const part of /\{([^}]*)\}/.exec(m[1])?.[1].split(",") ?? []) {
+        const [fn, as] = part.trim().split(/\s+as\s+/);
+        if (fn) named.set((as ?? fn).trim(), fn.trim());
+      }
+      const ns = new RegExp(String.raw`\*\s*as\s+(${ID})`).exec(m[1]);
+      if (ns) spaces.add(ns[1]);
+    }
+    if (!named.size && !spaces.size) continue;
+    const esc = (name) => name.replace(/\$/g, "\\$");
+    const found = [];
+    for (const [local, fn] of named) {
+      for (const m of code.matchAll(new RegExp(String.raw`(?<![\w$.])${esc(local)}\s*\(`, "g"))) found.push({ fn, open: m.index + m[0].length - 1 });
+    }
+    for (const ns of spaces) {
+      for (const m of code.matchAll(new RegExp(String.raw`(?<![\w$.])${esc(ns)}\s*\??\.\s*(${ID})\s*\(`, "g"))) found.push({ fn: m[1], open: m.index + m[0].length - 1 });
+    }
+    const constAt = stringConsts(code);
+    // A property's value as kind names: a literal, or a constant of this
+    // file that the use at `at` sees; `many` reads a list ("a,b", or an
+    // array of either). Anything else the code decides at run time: no
+    // names.
+    const namesOf = (value, many, at) => {
+      const one = (v) => {
+        const m = new RegExp(`^${lit(1)}$`).exec(v.trim());
+        if (m) return m[2];
+        return new RegExp(`^${ID}$`).test(v.trim()) ? (constAt(v.trim(), at)?.value ?? null) : null;
+      };
+      if (many && /^\[[\s\S]*\]$/.test(value)) return value.slice(1, -1).split(",").map(one).filter((v) => v !== null).map((v) => v.trim()).filter(Boolean);
+      const v = one(value);
+      if (v === null) return [];
+      return many ? v.split(",").map((s) => s.trim()).filter(Boolean) : [v];
+    };
+    for (const { fn: called, open } of found) {
+      let fn = called;
+      let label = called;
+      let at = open + 1; // where `args` starts in the code
+      let args = code.slice(at, closeOf(code, open));
+      // brainRead("listRecords", { kind }, send): every read of
+      // lib/brain.js runs through it, and it is exported for
+      // lib/brain-server.js, so an app can call it too. It is read as the
+      // read it names, its second argument as that read's.
+      if (fn === "brainRead") {
+        const m = new RegExp(String.raw`^\s*${lit(1)}\s*,\s*`).exec(args);
+        if (!m || args[m[0].length] !== "{") continue;
+        fn = m[2];
+        label = `brainRead("${fn}")`;
+        at += m[0].length;
+        args = code.slice(at, closeOf(code, at) + 1);
+      }
+      const add = (p, write, many) => {
+        for (const kind of namesOf(p.value, many, at + p.at)) calls.push({ f, line: lineOf(code, at + p.at), fn: label, kind, write, call: open });
+      };
+      for (const p of objectProps(args)) {
+        if (p.depth === 1 && p.key === "kind" && (ONE_READ.has(fn) || ONE_WRITE.has(fn))) add(p, ONE_WRITE.has(fn), false);
+        else if (p.depth === 1 && p.key === "kinds" && MANY_READ.has(fn)) add(p, false, true);
+        // writeRecords: the kind of each entry of `writes`, wherever the
+        // entries are made (an array, a map's callback); never an
+        // entry's owner ({ kind: "member", id }).
+        else if (fn === "writeRecords" && p.key === "kind" && p.path[0] === "writes" && !p.path.some((k) => k === "owner" || k === "fields")) add(p, true, false);
+      }
+    }
+  }
+
+  const list = (xs) => (xs.length ? xs.map((k) => (k === "*" ? "every kind" : k)).join(", ") : "none");
+  if (broken) fail("brain", "makersclaw.json", "is not JSON, so what this app declares in the company brain is unknown");
+  else if (shape.length) {
+    for (const s of shape.slice(0, 4)) fail("brain", "makersclaw.json", s);
+    if (shape.length > 4) fail("brain", `${shape.length - 4} more`, "in makersclaw.json's brain block");
+  } else {
+    const reads = declared ? (brain.reads ?? []) : [];
+    const writes = declared ? (brain.writes ?? []) : [];
+    const defined = new Set(declared ? (brain.kinds ?? []).map((d) => d.kind) : []);
+    const readAll = reads.includes("*") || writes.includes("*");
+    const writeAll = writes.includes("*");
+    const hits = [];
+    for (const c of calls) {
+      const said = `${c.fn} ${c.write ? "writes" : "reads"} "${c.kind}"`;
+      // note is the brain's own kind: declared by name, with no def.
+      const def = c.kind === "note" || defined.has(c.kind) ? "" : ', with its def in "kinds"';
+      let why = null;
+      if (!declared) why = `${said}, and makersclaw.json has no brain block: the door hands an app only the kinds it declares. Add "brain": { "kinds": [its def], "${c.write ? "writes" : "reads"}": ["${c.kind}"] } (README §5)`;
+      else if (c.write && !writeAll && !writes.includes(c.kind))
+        why = readAll || reads.includes(c.kind) ? `${said}, which the brain block only reads: add it to "writes"` : `${said}, which the brain block does not declare: add it to "writes"${def}`;
+      else if (!c.write && !readAll && !reads.includes(c.kind) && !writes.includes(c.kind))
+        why = defined.has(c.kind)
+          ? `${said}: "kinds" defines it, but neither "reads" nor "writes" names it, and the door hands the app only what those name; add it to "reads"`
+          : `${said}, which the brain block does not declare (reads: ${list(reads)}; writes: ${list(writes)}): add it to "reads"${def}`;
+      if (why) hits.push({ ...c, why });
+    }
+    const order = new Map(appFiles.map((f, i) => [f, i]));
+    hits.sort((a, b) => order.get(a.f) - order.get(b.f) || a.line - b.line);
+    for (const h of hits) L.hit(`${h.f.path}:${h.line}`, `${h.fn} ${h.kind}`, h.why);
+    if (L.count > 4) fail("brain", `${L.count - 4} more`, "lib/brain.js calls whose kind makersclaw.json's brain block does not declare");
+    if (!L.count) {
+      const n = new Set(calls.map((c) => `${c.f.path} ${c.call}`)).size;
+      const names = n ? `${n} lib/brain.js call${n === 1 ? "" : "s"} name${n === 1 ? "s" : ""} only declared kinds` : "no lib/brain.js call names a kind";
+      ok("brain", declared ? `reads ${list(reads)} · writes ${list(writes)} (makersclaw.json); ${names}` : `no brain block in makersclaw.json; ${names}`);
+    }
+  }
+}
+
+// 12. One viewport owner: the kit's AppLayout. Every design-first build
+//     of 2026-10-07 shipped a shell of min-h-dvh that grew with its
+//     content: the page scrolled, no pane scrolled on its own, and a
+//     footer or a button after a 30-page article sat past the end of the
+//     window, where nothing could reach it. So the app's code never sizes
+//     anything by the window: no min-h-dvh, min-h-screen, h-screen, h-dvh
+//     (nor their svh, lvh and max-h- kin), and no vh unit at all
+//     (h-[80vh], max-h-[60vh], h-[calc(100vh-4rem)], style={{ height:
+//     "100vh" }}). The kit is skipped: AppLayout in components/ui is the
+//     one place the window's height is written. Depictions are read too:
+//     a picture is drawn in px, never by the window.
+{
+  const L = limiter("viewport");
+  const DO =
+    'the window has one owner, AppLayout from components/ui (the shell\'s frame: the content scrolls inside it, contentMode="fill" for a canvas, an inspector beside it), and a page for print is DocumentLayout; inside it bound a box by its parent (h-full, flex-1 min-h-0) or by a size (max-h-96)';
+  scan(/(?<![\w-])(?:min-|max-)?h-(?:screen|dvh|svh|lvh)(?![\w-])/, (f, m, line) => L.hit(`${f.path}:${line}`, m[0], `${m[0]} sizes by the window, so what follows a long page cannot be reached; ${DO}`), files);
+  scan(/(?<![\w.])\d+(?:\.\d+)?[dsl]?vh(?![A-Za-z0-9_])/, (f, m, line) => {
+    // The whole class or value it sits in: h-[calc(100vh-4rem)], "100vh".
+    const from = f.code.slice(0, m.index).search(/[^\s"'`{}]*$/);
+    const token = f.code.slice(from).match(/^[^\s"'`{}]*/)[0];
+    L.hit(`${f.path}:${line}`, token, `${token} is a fraction of the window, so what follows it cannot be reached; ${DO}`);
+  }, files);
+  if (L.count > 4) fail("viewport", `${L.count - 4} more`, "more of the same: sizes taken from the window");
+  if (!L.count) ok("viewport", "nothing in the app sizes itself by the window");
+}
+
+// 13. A model is called through llm() (0.8.0, the platform's _claw/llm
+//     door). A screen that wants one answer from a model (sort, draft,
+//     translate) calls llm() from lib/platform.js, or useLlm() from
+//     lib/hooks.js, and never reaches the door by its URL: the path is the
+//     platform's to move, the two functions are the contract, and an
+//     app that fetches its own copy skips what they do (nothing throws, a
+//     claw from before the door comes back `unavailable`, an abort
+//     answers `aborted`). So no string in the app's code names `_claw/llm`,
+//     and none handed to claw(), clawUrl() or clawStream() starts `llm`.
+//     "Names" is as the browser reads it: clawUrl() drops every leading
+//     slash, and a `./` or a doubled slash in a URL is dropped on the way
+//     (`claw("//llm")`, `claw("./llm")`, `/_claw/./llm` all reach the door;
+//     it reads the code with `slashStrings` so a `//` inside a string is
+//     not taken for a comment). It reads literals, so a path built from
+//     pieces is not seen, as in rule 8. Every mode and every tables
+//     setting: the door is the same for all.
+{
+  const L = limiter("llm");
+  const LLM_PATH = /_claw\/(?:\.?\/)*llm(?![\w-])/;
+  const LLM_NAME = /^(?:\.?\/)*llm(?![\w-])/;
+  for (const f of jsFiles) {
+    const code = stripComments(f.text, { slashStrings: true });
+    const toClaw = new Set();
+    for (const m of code.matchAll(/(?<![\w$.])claw(?:Url|Stream)?\s*(?:\?\.\s*)?\(\s*(?=["'`])/g)) toClaw.add(m.index + m[0].length);
+    for (const { start, end } of literalsOf(code)) {
+      const inner = code.slice(start + 1, end);
+      if (!(LLM_PATH.test(inner) || (toClaw.has(start) && LLM_NAME.test(inner)))) continue;
+      const path = inner.replace(/\s+/g, " ").slice(0, 60);
+      L.hit(`${f.path}:${lineOf(code, start)}`, "path", `"${path}": the model door is reached through llm(input, { system, schema }) in lib/platform.js, or useLlm() in lib/hooks.js, never by its path (README §5, Calling a model)`);
+    }
+  }
+  if (L.count > 4) fail("llm", `${L.count - 4} more`, "strings that name the model door's path instead of calling llm()");
+  if (!L.count) ok("llm", "no screen names _claw/llm: a model is called through llm() or useLlm() (README §5)");
+}
+
 // 6. Smoke: the app, built and started, answers every surface.
 
 /** Newest mtime among the app's own sources (what a build reads): walk
@@ -672,9 +1966,12 @@ function writable(dir) {
 }
 
 /** Where the build goes: { dir, dist } — in place when the app folder is
- *  ours to write, else a copy of the sources under a folder that is. */
-function buildSite() {
-  if (writable(ROOT)) return { dir: ROOT, dist: ".next-check", copied: false };
+ *  ours to write, else a copy of the sources under a folder that is. A
+ *  browser app (`exported`) always takes the copy, with the default
+ *  distDir: under export a custom distDir is the export's folder, and
+ *  the build goes to `.next` all the same. */
+function buildSite(exported = false) {
+  if (!exported && writable(ROOT)) return { dir: ROOT, dist: ".next-check", copied: false };
   const name = basename(dirname(ROOT)) || "app"; // plays/<name>/app
   const home = writable(homedir()) ? homedir() : tmpdir();
   return { dir: join(home, ".claw-check", name), dist: ".next", copied: true };
@@ -693,8 +1990,10 @@ function commonRoot(a, b) {
 }
 
 /** Copy the app's sources (never node_modules or a build) to `dir`, and
- *  point its node_modules back at the app's. */
-function copySources(dir) {
+ *  point its node_modules back at the app's. `dotenv: false` leaves the
+ *  app's .env files out too (a browser app's build takes no .env: claw
+ *  builds one under an allowlist, and Next would load any it found). */
+function copySources(dir, { dotenv = true } = {}) {
   for (const stale of readdirSync(dir, { withFileTypes: true }).filter((e) => e.name !== "node_modules" && e.name !== ".next")) {
     rmSync(join(dir, stale.name), { recursive: true, force: true });
   }
@@ -703,6 +2002,7 @@ function copySources(dir) {
     dereference: false,
     filter: (src) => {
       const rel = relative(ROOT, src);
+      if (!dotenv && /^\.env(?:\..*)?$/.test(rel)) return false;
       return !notSource(rel) && !/^check(\/|$)/.test(rel);
     },
   });
@@ -710,13 +2010,16 @@ function copySources(dir) {
   if (!existsSync(link)) symlinkSync(join(ROOT, "node_modules"), link, "dir");
 }
 
-function buildForCheck(site, env) {
+/** Build, unless the last build is newer than every source and `fresh`
+ *  (what else the reuse needs) holds. */
+function buildForCheck(site, env, { fresh = () => true, dotenv = true } = {}) {
   const stamp = join(site.dir, site.dist, "BUILD_ID");
-  if (existsSync(stamp) && statSync(stamp).mtimeMs >= newestSource()) return { ok: true, reused: true };
+  if (existsSync(stamp) && statSync(stamp).mtimeMs >= newestSource() && fresh()) return { ok: true, reused: true };
+  if (!existsSync(join(ROOT, "node_modules", ".bin", "next"))) return { ok: false, tail: "next is not installed (node_modules/.bin/next): run `makersclaw install`, then the check" };
   const started = Date.now();
   if (site.copied) {
     mkdirSync(site.dir, { recursive: true });
-    copySources(site.dir);
+    copySources(site.dir, { dotenv });
   }
   const r = spawnSync(join(site.dir, "node_modules", ".bin", "next"), ["build"], { cwd: site.dir, env, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
   if (r.status !== 0) {
@@ -727,6 +2030,9 @@ function buildForCheck(site, env) {
 }
 
 async function smoke() {
+  // A browser app (makersclaw.json "mode": "browser", exactly as
+  // next.config.mjs reads it) is exported, not started: its own smoke.
+  if (MANIFEST.manifest?.mode === "browser") return browserSmoke();
   const site = buildSite();
   const base = { ...process.env, ...dotenv(join(ROOT, ".env")), NODE_ENV: "production", HOSTNAME: "127.0.0.1", CLAW_DIST_DIR: site.dist };
   delete base.CLAW_TURBOPACK_ROOT;
@@ -784,6 +2090,169 @@ async function smoke() {
   }
 }
 
+// The browser smoke (claw's STATIC-SPEC §3). A build in the copy folder,
+// always, with the default distDir: the export in the copy's out/, the
+// build in the copy's .next, nothing in the tree. The build's env is the
+// check's own, .env left out: claw builds a browser app under an
+// allowlist and never sources .env, so a page that needs .env to
+// prerender would fail there, not here. Then the copy's out/ is served by
+// a file server of this check's own, on the router's rules (below), and
+// `/` must forward to a surface while every /s/<key> answers 200 with no
+// error-boundary text. No `next start` (an export has none) and no
+// /claw-alive (a browser app's auto-refresh asks the door).
+//
+// What it proves: every page prerenders. Not that a surface renders with
+// data: each browser surface sits in <Suspense> and reads
+// useSearchParams, so the export holds only its loading line, and its
+// hooks never run at build.
+async function browserSmoke() {
+  const site = buildSite(true);
+  const env = { ...process.env, NODE_ENV: "production" };
+  delete env.CLAW_DIST_DIR; // the default distDir: a custom one is where an export goes
+  mkdirSync(site.dir, { recursive: true });
+  env.CLAW_TURBOPACK_ROOT = commonRoot(site.dir, ROOT);
+  const wanted = env.CLAW_BASE_PATH || "";
+  const out = join(site.dir, "out");
+  // A build is reused only when it is newer than every source, its
+  // export is there, and it was made for the base path asked for now.
+  const builtFor = () => {
+    try {
+      return JSON.parse(readFileSync(join(site.dir, site.dist, "routes-manifest.json"), "utf8")).basePath ?? "";
+    } catch {
+      return null;
+    }
+  };
+  const built = buildForCheck(site, env, { fresh: () => existsSync(join(out, "index.html")) && builtFor() === wanted, dotenv: false });
+  if (!built.ok) {
+    fail("smoke", "build", `next build failed:\n${built.tail}`);
+    return;
+  }
+  if (!existsSync(join(out, "index.html"))) {
+    fail("smoke", "build", `next build left no out/index.html in ${site.dir}: the export did not run (next.config.mjs is the template's; \`makersclaw update\` restores it)`);
+    return;
+  }
+  const basePath = builtFor() ?? wanted;
+  const size = exportSize(out);
+  const buildNote = `${built.reused ? "build reused" : `built in ${built.seconds}s`} (copy at ${site.dir}) · export ${(size.bytes / 1e6).toFixed(1)} MB in ${size.files} files`;
+  const server = serveExport(out, basePath);
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const origin = `http://127.0.0.1:${server.address().port}${basePath}`;
+  const started = Date.now();
+  try {
+    const results = [];
+    const home = await fetch(`${origin}/`, { redirect: "manual" });
+    const body = await home.text();
+    const to = home.status >= 300 && home.status < 400 ? home.headers.get("location") : /<meta\b[^>]*\bhttp-equiv="refresh"[^>]*\bcontent="0;\s*url=([^"]*)"/i.exec(body)?.[1]?.replace(/&amp;/g, "&");
+    const key = to ? /\/s\/([^/?#]+)$/.exec(to.replace(/[?#].*$/, ""))?.[1] : undefined;
+    results.push(`/ → ${home.status}${to ? ` to ${to}` : ""}`);
+    if (!(home.status === 200 || (home.status >= 300 && home.status < 400))) fail("smoke", "/", `answered ${home.status}`);
+    else if (!to) fail("smoke", "/", "answered with no forward to a surface: app/page.jsx forwards to the home surface (`makersclaw update` restores it), and surfaces.js names one");
+    else if (!to.startsWith(`${basePath}/s/`) || key === undefined || !surfaceKeys.includes(decodeURIComponent(key))) fail("smoke", "/", `forwards to ${to}, which is not ${basePath}/s/<a key of surfaces.js>`);
+    for (const k of surfaceKeys) {
+      const res = await fetch(`${origin}/s/${encodeURIComponent(k)}`, { redirect: "manual" });
+      const page = await res.text();
+      const broke = /Something broke on this surface|The page could not render|Application error: a (client|server)-side exception|id="__next_error__"/.test(page);
+      results.push(`/s/${k} ${res.status}${broke ? " BROKE" : ""}`);
+      if (res.status !== 200) fail("smoke", `/s/${k}`, `answered ${res.status}: the export holds no s/${k}.html`);
+      else if (broke) fail("smoke", `/s/${k}`, "is the error boundary in the export: the page threw while it prerendered");
+    }
+    if (!failures.includes("smoke")) ok("smoke", `${buildNote} · ${results.join(" · ")} (${((Date.now() - started) / 1000).toFixed(1)}s)`);
+  } finally {
+    server.closeAllConnections(); // fetch keeps its sockets alive
+    server.close();
+  }
+}
+
+/** The export's size: every file under out/. */
+function exportSize(dir) {
+  let bytes = 0;
+  let count = 0;
+  for (const name of readdirSync(dir, { recursive: true })) {
+    const s = statSync(join(dir, String(name)));
+    if (s.isFile()) {
+      bytes += s.size;
+      count++;
+    }
+  }
+  return { bytes, files: count };
+}
+
+const TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+};
+
+/**
+ * A file server over `out`, on the platform router's rules (claw's
+ * STATIC-SPEC §4, "The router"), for this check alone: GET and HEAD; the
+ * base path cut (anything outside it is 404); each segment decoded once,
+ * and one that fails, is `.`/`..`, starts with a dot or holds a slash, a
+ * backslash or a NUL is 404; then the file, else `.html`, else
+ * `/index.html` (the empty path is index.html); else `404.html` with 404.
+ * It serves a local build to a local fetch, so it reads each file whole
+ * and holds none of the router's guards against a tree someone else can
+ * write.
+ */
+function serveExport(out, basePath) {
+  const find = (url) => {
+    let path = url.split(/[?#]/)[0];
+    if (basePath) {
+      if (path !== basePath && !path.startsWith(`${basePath}/`)) return null;
+      path = path.slice(basePath.length);
+    }
+    const segments = [];
+    for (const raw of path.split("/")) {
+      if (!raw) continue;
+      let seg;
+      try {
+        seg = decodeURIComponent(raw);
+      } catch {
+        return null;
+      }
+      if (seg.startsWith(".") || /[/\\\0]/.test(seg)) return null;
+      segments.push(seg);
+    }
+    const rel = segments.join("/");
+    for (const candidate of rel ? [rel, `${rel}.html`, `${rel}/index.html`] : ["index.html"]) {
+      const file = join(out, candidate);
+      try {
+        if (statSync(file).isFile()) return file;
+      } catch {}
+    }
+    return null;
+  };
+  return createHttpServer((req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { allow: "GET, HEAD" }).end();
+      return;
+    }
+    let file = find(req.url ?? "/");
+    let status = 200;
+    if (!file) {
+      status = 404;
+      file = existsSync(join(out, "404.html")) ? join(out, "404.html") : null;
+    }
+    if (!file) {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Not found");
+      return;
+    }
+    const ext = /\.[^./]+$/.exec(file)?.[0] ?? "";
+    const bytes = readFileSync(file);
+    res.writeHead(status, { "content-type": TYPES[ext] ?? "application/octet-stream", "content-length": bytes.length, "x-content-type-options": "nosniff" });
+    res.end(req.method === "HEAD" ? undefined : bytes);
+  });
+}
+
 function dotenv(path) {
   if (!existsSync(path)) return {};
   const out = {};
@@ -817,9 +2286,9 @@ async function waitFor(probe, ms) {
   return false;
 }
 
-if (!STATIC_ONLY) await smoke();
+if (!NO_BUILD) await smoke();
 
-console.log(`check: ${files.length} files · ${surfaceKeys.length} surface${surfaceKeys.length === 1 ? "" : "s"}${STATIC_ONLY ? " · static only" : ""}`);
+console.log(`check: ${files.length} files · ${surfaceKeys.length} surface${surfaceKeys.length === 1 ? "" : "s"}${NO_BUILD ? " · no build" : ""}`);
 for (const l of lines) console.log(l);
 const failed = new Set(failures).size;
 console.log(failed ? `${failed} rule${failed === 1 ? "" : "s"} failed` : "all clear");