makersclaw 0.7.0 → 0.8.1

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

@@ -18,6 +18,33 @@
 // 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.
+// Number 14 (library, 0.8.1) does the same for the Library's door.
+// Number 15 (actions, 0.8.1) keeps every write a screen makes a declared
+// action, the one its agent calls too: the CRM's agent saved fifty people
+// as one note, because it had no other way to make them.
+// Number 16 (squeeze, 0.8.1) refuses a wrapping flex row that holds a
+// growing text cell (min-w-0 flex-1): it squeezed to a word a line in the
+// CRM's list header and its connect card.
+// Number 17 (resize, 0.8.1) keeps a ResizeObserver from changing what it
+// watches inside its own delivery: the CRM's People screen reported "loop
+// completed with undelivered notifications" and every report began a repair.
+// Number 18 (automations, 0.8.1) asks the platform's own validator about the
+// automations an app ships (makersclaw.json `automations`), so a flow the
+// platform would refuse at install is refused here, at build.
+// Number 19 (stretch, 0.8.1) keeps a row of ActionCards one height, their
+// buttons on one line (UI review X6). Number 20 (meter, 0.8.1) wants
+// `compact` on a labelled Meter in a box under 8rem (X1). Number 21
+// (landed, 0.8.1) wants a page that opens a row it just made to wait for
+// the write (X11). Number 25 (agentfirst, 0.8.1) keeps a "have the agent do it"
+// button opening the agent with its line, never a form first (X9). Number 26
+// (barlabel, 0.8.1) wants an icon on a top-bar action whose words are a
+// BarText: under 32rem the words give way, and an icon-less button is empty.
+// Number 27 (sidelong, 0.8.1) keeps a side column short: a PageLayout `side`
+// or an <aside> that holds a form or a long list is refused (X13).
 //
 //   npm run check               source rules, then smoke
 //   npm run check -- --no-build source rules only: no build, no smoke
@@ -73,7 +100,7 @@ import { createServer as createHttpServer } from "node:http";
 import { createServer } from "node:net";
 import { basename, dirname, join, posix, relative, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } 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).
@@ -94,7 +121,7 @@ const ACTIONS_ONLY = process.argv.includes("--actions");
 // .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|page|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
@@ -228,13 +255,20 @@ 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`(?:"[^"]*"|'[^']*'|\{(?:[^{}]|\{[^{}]*\})*\}|[^>"'{])*`;
@@ -251,6 +285,204 @@ const MANIFEST = (() => {
   }
 })();
 
+// The app's declared actions (makersclaw.json `actions`, 0.8.1; claw's
+// docs/APP-TOOLS-PLAN.md D2): the writes its screens make, which its agent
+// calls as tools through the platform's one runner. Read once for
+// `--actions`, rule 8 and rule 15. Once an app declares any, its agent can
+// write no other way, so every write a screen makes must be one (rule 15).
+const DECLARED = (() => {
+  const list = MANIFEST.manifest?.actions;
+  return Array.isArray(list) ? list.filter((a) => a && typeof a === "object" && !Array.isArray(a) && typeof a.name === "string") : [];
+})();
+const DECLARED_NAMES = new Set(DECLARED.map((a) => a.name));
+
+/**
+ * The refusals of a declaration, each naming its place: [] when it holds.
+ * The same rules as claw's shared/src/app-actions.ts validateActions, so
+ * what passes here passes the platform at ship (keep the two together).
+ */
+function actionRefusals(actions, brainDecl, mode) {
+  if (actions === undefined || actions === null) return [];
+  if (!Array.isArray(actions)) return ["actions must be a list"];
+  const NAME = /^[a-z][a-z0-9_]{0,39}$/;
+  const FN = /^[a-z_][a-z0-9_]{0,62}$/;
+  const PROP = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;
+  const KEYWORDS = new Set(["type", "description", "title", "properties", "required", "items", "enum", "minItems", "maxItems", "minLength", "maxLength", "minimum", "maximum", "additionalProperties", "format", "default", "examples"]);
+  const TYPES = new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
+  const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+  const out = [];
+  if (actions.length > 60) out.push(`actions: at most 60; this app declares ${actions.length}`);
+  const b = isObj(brainDecl) ? brainDecl : {};
+  const writes = new Set(Array.isArray(b.writes) ? b.writes.filter((w) => typeof w === "string") : []);
+  const defs = new Map([["note", { fields: ["title", "body", "imported_from"], link_types: [] }]]);
+  for (const d of Array.isArray(b.kinds) ? b.kinds : [])
+    if (isObj(d) && typeof d.kind === "string" && Array.isArray(d.fields))
+      defs.set(d.kind, { fields: d.fields.filter((f) => isObj(f) && typeof f.name === "string" && f.retired !== true).map((f) => f.name), link_types: Array.isArray(d.link_types) ? d.link_types.filter(isObj) : [] });
+  const schema = (sch, at, depth = 0) => {
+    if (!isObj(sch)) return [`${at}: a schema is an object`];
+    if (depth > 6) return [`${at}: nested deeper than six levels`];
+    const r = [];
+    for (const k of Object.keys(sch)) if (!KEYWORDS.has(k)) r.push(`${at}: "${k}" is not a schema keyword the platform checks`);
+    if (!TYPES.has(sch.type)) return [...r, `${at}: type must be one of ${[...TYPES].join(", ")}`];
+    if (sch.type === "object" && sch.properties !== undefined) {
+      if (!isObj(sch.properties)) r.push(`${at}: properties must be an object`);
+      else for (const [n, sub] of Object.entries(sch.properties)) {
+        if (!PROP.test(n)) r.push(`${at}.${n}: a property is a plain name`);
+        r.push(...schema(sub, `${at}.${n}`, depth + 1));
+      }
+    }
+    if (sch.type === "object" && sch.required !== undefined)
+      for (const q of Array.isArray(sch.required) ? sch.required : [null])
+        if (typeof q !== "string" || !isObj(sch.properties) || !(q in sch.properties)) r.push(`${at}: required ${q} is not one of its properties`);
+    if (sch.type === "array") r.push(...(sch.items === undefined ? [`${at}: an array says its items`] : schema(sch.items, `${at}[]`, depth + 1)));
+    return r;
+  };
+  const prop = (sch, n) => (isObj(sch) && isObj(sch.properties) && isObj(sch.properties[n]) ? sch.properties[n] : null);
+  const WORDS = `a source is "key", "$.key", { "value": … } or { "now": true }`;
+  // `edit`: the write names its record (id), so { "value": null } clears.
+  const source = (src, at, item, input, edit = false) => {
+    if (isObj(src)) {
+      const keys = Object.keys(src);
+      if (keys.length === 1 && keys[0] === "now") return src.now === true ? null : `${at}: { "now": true } is the time of the call`;
+      if (keys.length !== 1 || keys[0] !== "value") return `${at}: ${WORDS}`;
+      if (src.value === null) return edit ? null : `${at}: { "value": null } clears a field, only in a write that names its record (id)`;
+      return ["string", "number", "boolean"].includes(typeof src.value) ? null : `${at}: a constant is text, a number, true/false, or null to clear`;
+    }
+    if (typeof src !== "string" || !src) return `${at}: ${WORDS}`;
+    const top = src.startsWith("$.");
+    return prop(top ? input : item, top ? src.slice(2) : src) ? null : `${at}: ${src} is not a property of the ${top || item === input ? "input" : "item"}`;
+  };
+  // An arg a write reads by name (id, if_version, clear): its schema and whether it is required.
+  const arg = (src, at, item, input) => {
+    if (typeof src !== "string" || !src) return `${at}: names an arg, "key" or "$.key"`;
+    const top = src.startsWith("$.");
+    const from = top ? input : item;
+    const key = top ? src.slice(2) : src;
+    const sch = prop(from, key);
+    if (!sch) return `${at}: ${src} is not a property of the ${top || item === input ? "input" : "item"}`;
+    return { sch, required: isObj(from) && Array.isArray(from.required) && from.required.includes(key) };
+  };
+  const seen = new Set();
+  actions.forEach((a, i) => {
+    const at = `actions[${i}]${isObj(a) && typeof a.name === "string" ? ` (${a.name})` : ""}`;
+    if (!isObj(a)) return out.push(`${at}: an action is an object`);
+    for (const k of Object.keys(a)) if (!["name", "description", "input", "brain", "sql", "agent"].includes(k)) out.push(`${at}: unknown key "${k}"`);
+    if (!NAME.test(a.name ?? "")) out.push(`${at}: name is lower case, a-z, 0-9 and _, starting with a letter, at most 40`);
+    else if (seen.has(a.name)) out.push(`${at}: ${a.name} is declared twice`);
+    seen.add(a.name);
+    if (typeof a.description !== "string" || !a.description.trim()) out.push(`${at}: needs a description, one line of what it does`);
+    else if (a.description.length > 300 || a.description.includes("\n")) out.push(`${at}: the description is one line of at most 300 characters`);
+    if (a.agent !== undefined && typeof a.agent !== "boolean") out.push(`${at}: agent is true or false`);
+    const input = a.input;
+    if (!isObj(input) || input.type !== "object") out.push(`${at}: input is a JSON Schema of type object`);
+    else {
+      out.push(...schema(input, `${at}.input`));
+      if (JSON.stringify(input).length > 12000) out.push(`${at}: input is over 12000 characters of JSON; shorten its descriptions`);
+    }
+    if (a.brain === undefined && a.sql === undefined) out.push(`${at}: needs brain, sql, or both: an action does something`);
+    if (a.sql !== undefined && (typeof a.sql !== "string" || !FN.test(a.sql))) out.push(`${at}: sql names one function of the app's schema, lower case`);
+    if (a.brain === undefined) return;
+    const br = a.brain;
+    if (!isObj(br)) return out.push(`${at}.brain: an object with writes, and each and links when needed`);
+    if (mode === "server") out.push(`${at}.brain: company brain writes run only in a browser app ("mode": "browser"), through the platform's door`);
+    for (const k of Object.keys(br)) if (!["each", "writes", "links"].includes(k)) out.push(`${at}.brain: unknown key "${k}"`);
+    if (prop(input, "records")) out.push(`${at}.input: records is the platform's: it hands the written records to the sql function under that name`);
+    let item = input;
+    let per = 1;
+    if (br.each !== undefined) {
+      const each = typeof br.each === "string" ? prop(input, br.each) : null;
+      if (!each || each.type !== "array" || !isObj(each.items) || each.items.type !== "object") out.push(`${at}.brain.each: names an input property that is an array of objects`);
+      else {
+        item = each.items;
+        if (typeof each.maxItems !== "number" || each.maxItems > 100) out.push(`${at}.brain.each: ${br.each} needs a maxItems of at most 100`);
+        else per = each.maxItems;
+        if (!(Array.isArray(input.required) && input.required.includes(br.each))) out.push(`${at}.brain.each: ${br.each} must be required`);
+      }
+    }
+    const steps = br.writes === undefined ? [] : br.writes;
+    if (!Array.isArray(steps) || steps.length > 10 || (steps.length === 0 && !(Array.isArray(br.links) && br.links.length)))
+      return out.push(`${at}.brain.writes: a list of 1 to 10 writes (none only when the action has links)`);
+    if (steps.length * per > 500) out.push(`${at}.brain: up to ${steps.length * per} writes a call; at most 500`);
+    const kindOf = new Map();
+    steps.forEach((w, j) => {
+      const wat = `${at}.brain.writes[${j}]`;
+      if (!isObj(w)) return out.push(`${wat}: a write is an object with as, kind and fields`);
+      for (const k of Object.keys(w)) if (!["as", "kind", "fields", "when", "id", "if_version", "clear"].includes(k)) out.push(`${wat}: unknown key "${k}"`);
+      if (typeof w.as !== "string" || !NAME.test(w.as)) out.push(`${wat}: as is a lower-case name the links and records use`);
+      else if (kindOf.has(w.as)) out.push(`${wat}: as ${w.as} is used twice`);
+      if (typeof w.kind !== "string" || !w.kind) return out.push(`${wat}: kind names a company brain kind`);
+      if (typeof w.as === "string") kindOf.set(w.as, w.kind);
+      if (!writes.has("*") && !writes.has(w.kind)) out.push(`${wat}: the app does not declare ${w.kind} in brain.writes`);
+      const def = defs.get(w.kind);
+      if (!def) out.push(`${wat}: ${w.kind} has no def in brain.kinds`);
+      const edit = w.id !== undefined;
+      if (!isObj(w.fields) || !Object.keys(w.fields).length) out.push(`${wat}: fields maps the kind's fields to their sources`);
+      else for (const [f, src] of Object.entries(w.fields)) {
+        if (def && !def.fields.includes(f)) out.push(`${wat}.fields.${f}: not a field of ${w.kind}`);
+        const bad = source(src, `${wat}.fields.${f}`, item, input, edit);
+        if (bad) out.push(bad);
+      }
+      if (w.when !== undefined) {
+        const bad = source(w.when, `${wat}.when`, item, input);
+        if (bad) out.push(bad);
+      }
+      if (edit) {
+        const id = arg(w.id, `${wat}.id`, item, input);
+        if (typeof id === "string") out.push(id);
+        else {
+          if (id.sch.type !== "string") out.push(`${wat}.id: ${w.id} is a string, the record's id`);
+          if (!id.required && w.when !== w.id) out.push(`${wat}.id: ${w.id} must be required, or the write's when`);
+        }
+      }
+      if (w.if_version !== undefined) {
+        if (!edit) out.push(`${wat}.if_version: only in a write that names its record (id)`);
+        const v = arg(w.if_version, `${wat}.if_version`, item, input);
+        if (typeof v === "string") out.push(v);
+        else if (v.sch.type !== "integer" && v.sch.type !== "number") out.push(`${wat}.if_version: ${w.if_version} is a whole number, the version read`);
+      }
+      if (w.clear !== undefined) {
+        if (!edit) out.push(`${wat}.clear: only in a write that names its record (id)`);
+        const c = arg(w.clear, `${wat}.clear`, item, input);
+        if (typeof c === "string") out.push(c);
+        else {
+          const its = isObj(c.sch.items) ? c.sch.items : null;
+          const names = its && Array.isArray(its.enum) ? its.enum : null;
+          const mapped = isObj(w.fields) ? Object.keys(w.fields) : [];
+          if (c.sch.type !== "array" || !its || its.type !== "string" || !names) out.push(`${wat}.clear: ${w.clear} is an array of strings with an enum of the fields it may clear`);
+          else for (const n of names) if (typeof n !== "string" || !mapped.includes(n)) out.push(`${wat}.clear: ${JSON.stringify(n)} is not one of this write's fields`);
+        }
+      }
+    });
+    if (br.links === undefined) return;
+    if (!Array.isArray(br.links)) return out.push(`${at}.brain.links: a list`);
+    br.links.forEach((l, j) => {
+      const lat = `${at}.brain.links[${j}]`;
+      if (!isObj(l)) return out.push(`${lat}: a link is { from, to, type }`);
+      const end = (e, which) => {
+        if (typeof e === "string") {
+          if (!kindOf.has(e)) out.push(`${lat}.${which}: ${e} is no write's as`);
+          return kindOf.get(e) ?? null;
+        }
+        if (isObj(e) && Object.keys(e).length === 1 && "id" in e) {
+          const bad = source(e.id, `${lat}.${which}.id`, item, input);
+          if (bad) out.push(bad);
+          return null;
+        }
+        out.push(`${lat}.${which}: a write's as, or { "id": <source> }`);
+        return null;
+      };
+      for (const k of Object.keys(l)) if (!["from", "to", "type", "op"].includes(k)) out.push(`${lat}: unknown key "${k}"`);
+      const from = end(l.from, "from");
+      const to = end(l.to, "to");
+      if (l.op !== undefined && l.op !== "add" && l.op !== "remove") out.push(`${lat}: op is "add" or "remove"`);
+      if (typeof l.type !== "string" || !NAME.test(l.type)) out.push(`${lat}: type is a link type's name`);
+      else if (l.type !== "related" && from && !(defs.get(from)?.link_types ?? []).some((t) => t.type === l.type && t.from === from && (to === null || t.to === to)))
+        out.push(`${lat}: ${from} declares no link type ${l.type}${to ? ` to ${to}` : ""}`);
+    });
+  });
+  return out;
+}
+
 /**
  * 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
@@ -525,6 +757,10 @@ function objectProps(text) {
 // list.
 const ROW_WRITES = ["insertRow", "updateRow", "moveRow", "deleteRow", "saveSetting"];
 const DOOR_MODULES = ["lib/actions", "lib/door"];
+/** The company brain's writes a screen can make (lib/brain.js), for rule
+ *  15: once an app declares actions, each is one of them. Erase, confirm
+ *  and merge stay a person's press, and are not listed. */
+const BRAIN_WRITES = ["writeRecord", "writeRecords", "linkRecords", "unlinkRecords", "createList", "changeList"];
 /** 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). */
@@ -573,6 +809,7 @@ function writeCalls() {
   // 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()]));
+  doors.set("lib/brain", new Map(BRAIN_WRITES.map((n) => [n, n])));
   for (let grew = true; grew; ) {
     grew = false;
     for (const f of jsFiles) {
@@ -601,6 +838,7 @@ function writeCalls() {
   const actions = [];
   const tables = [];
   const unread = [];
+  const brainWrites = [];
   for (const f of jsFiles) {
     const code = f.code;
     const local = all(); // a name in this file → the function it calls
@@ -659,6 +897,10 @@ function writeCalls() {
     };
     const entries = mounted.get(moduleOf(f.path));
     for (const { fn, open } of found.sort((a, b) => a.open - b.open)) {
+      if (BRAIN_WRITES.includes(fn)) {
+        brainWrites.push({ f, line: lineOf(code, open), fn });
+        continue;
+      }
       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));
@@ -677,7 +919,7 @@ function writeCalls() {
       } else unread.push({ f, line, fn });
     }
   }
-  return { actions, tables, unread };
+  return { actions, tables, unread, brainWrites };
 }
 
 // `--actions`: what the screens run and write, as JSON, and nothing else,
@@ -688,7 +930,20 @@ function writeCalls() {
 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)) };
+  // A declared action's name runs its `sql` function (none for one that
+  // only writes the company brain), and every declared function is listed,
+  // a screen's or the agent's alone: the ship checks each exists and keeps
+  // the live app's from a change build (0.8.1).
+  const fnsOf = (name) => {
+    const a = DECLARED.find((x) => x.name === name);
+    return a ? (typeof a.sql === "string" ? [a.sql] : []) : [name];
+  };
+  const declaredFns = DECLARED.map((a) => a.sql).filter((x) => typeof x === "string");
+  const listed = {
+    actions: names([...actions.filter((a) => a.name !== null).flatMap((a) => fnsOf(a.name)), ...declaredFns]),
+    tables: names(tables.map((t) => t.table)),
+    ...(DECLARED.length ? { declared: names([...DECLARED_NAMES]) } : {}),
+  };
   await new Promise((done) => process.stdout.write(`${JSON.stringify(listed)}\n`, done));
   process.exit(0);
 }
@@ -851,11 +1106,13 @@ const surfaceKeys = [];
     // 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.
+  // check/ is this script, its pins and the two copies of the automation
+  // format rule 18 runs (pinned like any fixed file); a module hidden there
+  // is bundled by Next and read by no rule.
   if (existsSync(join(ROOT, "check"))) {
     for (const e of readdirSync(join(ROOT, "check"))) {
-      if (e !== "run.mjs" && e !== "pins.json") L.hit(`check/${e}`, "extra", "check/ holds run.mjs and pins.json only; a module goes in components/ or lib/");
+      const copy = (e === "automation-format.ts" || e === "automation-package.ts") && PINS !== null && Object.prototype.hasOwnProperty.call(PINS, `check/${e}`);
+      if (e !== "run.mjs" && e !== "pins.json" && !copy) L.hit(`check/${e}`, "extra", "check/ holds run.mjs, pins.json and the automation format's two pinned copies only; a module goes in components/ or lib/");
     }
   }
   for (const f of files) {
@@ -1250,12 +1507,17 @@ const surfaceKeys = [];
       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`;
+      // A declared action is the agent's own tool (rule 15): its brief
+      // says when, never the SQL.
+      else if (DECLARED_NAMES.has(a.name)) continue;
       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) {
+    // An app that declares actions has no one-row writes left to name:
+    // rule 15 makes each an action.
+    if (hasBrief && !DECLARED.length) {
       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` });
       }
@@ -1871,6 +2133,770 @@ function columnFrom(code, at) {
   }
 }
 
+// 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)");
+}
+
+// 14. The Library is read through library() (0.8.1, the platform's
+//     _claw/library door). A screen that shows what Makersclaw keeps
+//     (decks, templates, a dataset) calls library.collections(),
+//     library.items() and the rest from lib/platform.js, or the hooks
+//     useLibraryItems() and kin from lib/hooks.js, and never reaches the
+//     door by its URL: the path is the platform's to move, the 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 id that names nothing asks nothing, an abort
+//     answers `aborted`). So no string in the app's code names
+//     `_claw/library`, and none handed to claw(), clawUrl() or clawStream()
+//     starts `library`, however the browser would read it (rule 13 says
+//     how: `claw("//library")`, `claw("./library/items")` and
+//     `/_claw/./library` are all the door). It reads literals, so a path
+//     built from pieces is not seen, as in rules 8 and 13. Every mode and
+//     every tables setting: the door is the same for all.
+{
+  const L = limiter("library");
+  const LIBRARY_PATH = /_claw\/(?:\.?\/)*library(?![\w-])/;
+  const LIBRARY_NAME = /^(?:\.?\/)*library(?![\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 (!(LIBRARY_PATH.test(inner) || (toClaw.has(start) && LIBRARY_NAME.test(inner)))) continue;
+      const path = inner.replace(/\s+/g, " ").slice(0, 60);
+      L.hit(`${f.path}:${lineOf(code, start)}`, "path", `"${path}": the Library door is reached through library.collections(), library.items(id) and kin in lib/platform.js, or useLibraryItems() and kin in lib/hooks.js, never by its path (README §5, Showing the Library)`);
+    }
+  }
+  if (L.count > 4) fail("library", `${L.count - 4} more`, "strings that name the Library door's path instead of calling library()");
+  if (!L.count) ok("library", "no screen names _claw/library: the Library is read through library() or its hooks (README §5)");
+}
+
+// 15. Every write a screen makes is a declared action (0.8.1; claw's
+//     docs/APP-TOOLS-PLAN.md D2, D6). makersclaw.json `actions` names
+//     them: `name`, a one-line `description`, `input` (a JSON Schema
+//     object), then `sql` (its function) and `brain` (the company brain's
+//     writes the platform runs). The screens call each by its name with
+//     runAction, and the app's agent calls the same name as a tool. Once
+//     an app declares any, its agent can write no other way, so a write a
+//     screen makes that is not one would be a thing only a person can do:
+//     an undeclared runAction name, a one-row write (insertRow, updateRow,
+//     moveRow, deleteRow, saveSetting) and a company brain write from
+//     lib/brain.js (writeRecord(s), linkRecords, unlinkRecords, createList,
+//     changeList) each fail. Erase, confirm and merge stay a person's
+//     press. An app that declares none keeps rule 8 as it was.
+{
+  const L = limiter("actions");
+  const { manifest } = MANIFEST;
+  const has = manifest && Object.prototype.hasOwnProperty.call(manifest, "actions");
+  if (!has) ok("actions", "no actions declared in makersclaw.json: the app's agent writes as references/actions.md says");
+  else {
+    const refusals = actionRefusals(manifest.actions, manifest.brain, manifest.mode);
+    for (const r of refusals.slice(0, 4)) fail("actions", "makersclaw.json", r);
+    if (refusals.length > 4) fail("actions", "makersclaw.json", `${refusals.length - 4} more`);
+    if (DECLARED.length) {
+      const calls = writeCalls();
+      const DECLARE = "declare it in makersclaw.json actions (its name, description, input, then sql or brain) and call it with runAction({ name, args }): once an app declares actions its agent writes no other way (README §5)";
+      for (const a of calls.actions)
+        if (a.name !== null && !DECLARED_NAMES.has(a.name)) L.hit(`${a.f.path}:${a.line}`, `action ${a.name}`, `runAction runs ${a.name}, which makersclaw.json does not declare: ${DECLARE}`);
+      for (const t of [...calls.tables, ...calls.unread])
+        L.hit(`${t.f.path}:${t.line}`, `${t.fn} ${t.table ?? ""}`, `${t.fn}${t.table ? ` writes ${t.table}` : ""}, a write the app's agent cannot make: make it a function of the app's schema and ${DECLARE}`);
+      for (const b of calls.brainWrites)
+        L.hit(`${b.f.path}:${b.line}`, b.fn, `${b.fn} writes the company brain from the screen, which the app's agent cannot do: give an action brain steps (writes, each, links) and ${DECLARE}`);
+      if (L.count > 4) fail("actions", `${L.count - 4} more`, "writes the screens make that are not declared actions");
+    }
+    if (!refusals.length && !L.count)
+      ok("actions", `${DECLARED.length} declared${DECLARED.length ? "; every write the screens make is one of them" : ""}`);
+  }
+}
+
+// 16. A row that wraps does not hold a text cell that grows (0.8.1; the
+//     CRM's list header and its "Connect your mailbox" card, 2026-10-11).
+//     `flex flex-wrap` with a child of `min-w-0 flex-1` looks right at a
+//     wide window and is wrong at the width a real window has: flex-1 has
+//     a basis of zero, so the text never wraps to a line of its own, it
+//     squeezes to what the fixed pieces beside it leave, a word or two a
+//     line, and the row grows tall around it. The founder saw it twice in
+//     one app. So no direct child of a wrapping flex row both grows
+//     (flex-1, grow) and may shrink to nothing (min-w-0) without a basis
+//     of its own (basis-*, min-w-[…], w-full, w-N): stack the pieces
+//     (grid gap-2, flex-col), or give the text a basis so it takes its own
+//     line when it does not fit. It reads the JSX the way prettier lays it
+//     out (a child is a line one indent in from its parent's opening tag,
+//     className a string on that line), so a tag split across lines is not
+//     seen; a cell that truncates (one line, cut short) is fine; the kit
+//     and the blocks are skipped (pinned).
+{
+  const L = limiter("squeeze");
+  const classesOf = (line) => [...line.matchAll(/"([^"]*)"|`([^`$]*)`|'([^']*)'/g)].map((m) => m[1] ?? m[2] ?? m[3]).join(" ");
+  const has = (cls, re) => new RegExp(`(?:^|\\s)(?:[\\w@\\[\\]/-]+:)*${re}(?![\\w-])`).test(cls);
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    const rows = f.code.split("\n");
+    for (let i = 0; i < rows.length; i++) {
+      const open = rows[i].match(/^(\s*)<(\w[\w.]*)\b[^>]*\bclassName=/);
+      if (!open || /\/>\s*$/.test(rows[i])) continue;
+      const cls = classesOf(rows[i]);
+      if (!has(cls, "flex-wrap") || !(has(cls, "flex") || has(cls, "inline-flex")) || has(cls, "flex-col")) continue;
+      const ind = open[1].length;
+      for (let j = i + 1; j < rows.length; j++) {
+        const lead = rows[j].match(/^(\s*)\S/);
+        if (!lead) continue;
+        if (lead[1].length <= ind) break;
+        if (lead[1].length !== ind + 2 || !/^\s*<\w/.test(rows[j])) continue;
+        const kid = classesOf(rows[j].slice(0, rows[j].indexOf(">") > 0 ? rows[j].indexOf(">") : undefined));
+        if (!(has(kid, "flex-1") || has(kid, "grow")) || !has(kid, "min-w-0")) continue;
+        if (has(kid, "truncate") || has(kid, "line-clamp-\\d")) continue; // one line, cut short: it never squeezes to a word a line
+        if (has(kid, "basis-[^\\s]+") || has(kid, "min-w-\\[[^\\s]+") || has(kid, "w-full") || has(kid, "w-\\d[^\\s]*")) continue;
+        L.hit(`${f.path}:${j + 1}`, "squeeze", `a text cell that grows (min-w-0 flex-1) sits in a flex-wrap row (line ${i + 1}) beside fixed pieces: flex-1 never wraps to a line of its own, it squeezes to a word or two a line. Stack them (grid gap-2, or flex-col), or give the text a basis so it wraps below (basis-64, min-w-[16rem])`);
+      }
+    }
+  }
+  if (L.count > 4) fail("squeeze", `${L.count - 4} more`, "wrapping rows with a growing text cell");
+  if (!L.count) ok("squeeze", "no wrapping flex row holds a text cell that grows (min-w-0 flex-1)");
+}
+
+// 17. A ResizeObserver hands its work to the next frame (0.8.1; the CRM's
+//     People screen, 2026-10-11). A browser says "ResizeObserver loop
+//     completed with undelivered notifications" when a callback changes the
+//     size of something an observer watches before the frame is over:
+//     setting a height, a width, or state that a synchronous render turns
+//     into one. The page still works, and nobody can say which line did it,
+//     which is why a repair of the app found nothing to change every time.
+//     So in the app's own files a `new ResizeObserver(cb)` takes its
+//     measurements in the callback and acts on them in a
+//     requestAnimationFrame: the callback (or the function it names, in the
+//     same file) must contain one. The kit and the blocks are pinned and
+//     are not read; the template reports no such notice any more
+//     (lib/claw.js drops it), so this rule is what keeps the cause out.
+{
+  const L = limiter("resize");
+  scan(/new\s+ResizeObserver\s*\(/, (file, m, at) => {
+    // The argument: from the opening bracket to its match.
+    const open = m.index + m[0].length;
+    let depth = 1;
+    let end = open;
+    while (end < file.code.length && depth > 0) {
+      const ch = file.code[end++];
+      if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+    }
+    const arg = file.code.slice(open, end - 1);
+    if (/requestAnimationFrame/.test(arg)) return;
+    // A function named in the same file: read its body.
+    const named = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(arg);
+    if (named) {
+      const def = new RegExp(`(?:const|let|function)\\s+${named[1].replace(/\$/g, "\\$")}\\b`).exec(file.code);
+      if (def && /requestAnimationFrame/.test(file.code.slice(def.index, def.index + 900))) return;
+    }
+    L.hit(`${file.path}:${at}`, "resize", "a ResizeObserver whose callback acts at once: whatever it sets (a height, a width, state) can change what it watches inside its own delivery, and the browser reports a loop. Measure in the callback and act in requestAnimationFrame: `let raf = 0; new ResizeObserver(() => { cancelAnimationFrame(raf); raf = requestAnimationFrame(apply); })`");
+  });
+  if (L.count > 4) fail("resize", `${L.count - 4} more`, "ResizeObservers that act inside their own delivery");
+  if (!L.count) ok("resize", "every ResizeObserver acts in the next frame");
+}
+
+// 18. The automations an app ships hold to the platform's format (0.8.1;
+//     claw's docs/AUTOMATIONS-PLAN.md phase 9). makersclaw.json `automations`
+//     is a list of definitions (format 1), each with an optional
+//     `replaces_wake`; the store ships the same list as seeds.automations.
+//     The one validator is claw's validatePackageAutomations, which calls
+//     validateAutomation: both are copied beside this file
+//     (check/automation-format.ts, check/automation-package.ts; never
+//     edited, refreshed by scripts/sync-automation-format.mjs in the
+//     template repo) and run here as they are, so what passes here passes
+//     the platform. An action step must name a declared action. They are
+//     TypeScript with no runtime import, so node loads them as they are
+//     from 22.18; on an older node the rule says so and is skipped, never
+//     failed (the platform's own door still refuses the flow at install).
+//     Wakes and kinds of account are not known to an app's own check: they
+//     are the store's to check (it knows seeds.wakes and the connections).
+{
+  const { manifest } = MANIFEST;
+  const has = manifest && Object.prototype.hasOwnProperty.call(manifest, "automations") && manifest.automations !== undefined && manifest.automations !== null;
+  if (!has) ok("automations", "no automations declared in makersclaw.json");
+  else {
+    const here = join(ROOT, "check");
+    // Node says a .ts file with no "type" in package.json is reparsed as a
+    // module, and (before 22.18) that type stripping is experimental. The
+    // copies are ours and fixed: say nothing about how they are read.
+    const emit = process.emitWarning;
+    process.emitWarning = function (warning, ...rest) {
+      const said = [warning, ...rest].map((x) => (typeof x === "string" ? x : (x?.code ?? x?.message ?? ""))).join(" ");
+      if (/MODULE_TYPELESS_PACKAGE_JSON|Module type of file|Type Stripping/i.test(said)) return;
+      return emit.call(this, warning, ...rest);
+    };
+    let loaded = null;
+    let why = null;
+    try {
+      const fmt = await import(pathToFileURL(join(here, "automation-format.ts")).href);
+      const pack = await import(pathToFileURL(join(here, "automation-package.ts")).href);
+      if (typeof pack.validatePackageAutomations !== "function") throw new Error("check/automation-package.ts has no validatePackageAutomations");
+      loaded = { fmt, pack };
+    } catch (e) {
+      why = String(e?.code ?? e?.message ?? e).split("\n")[0];
+    }
+    await new Promise((done) => setImmediate(done));
+    process.emitWarning = emit;
+    if (!loaded) {
+      lines.push(`skip  ${"automations".padEnd(10)} not checked: this node (${process.versions.node}) cannot read the format's TypeScript files (it needs 22.18 or newer): ${why}`);
+    } else {
+      const list = manifest.automations;
+      const result = Array.isArray(list)
+        ? loaded.pack.validatePackageAutomations(list, { actionNames: new Set(DECLARED_NAMES), wakes: null, categories: null }, loaded.fmt)
+        : { ok: false, problems: [{ path: "automations", message: "automations is a list" }] };
+      if (result.ok) {
+        const from = /@ (\w+)\./.exec(readFileSync(join(here, "automation-format.ts"), "utf8").split("\n", 1)[0])?.[1];
+        ok("automations", `${result.entries.length} shipped; each holds to the platform's format${from ? ` (claw ${from})` : ""}`);
+      } else {
+        const said = loaded.pack.packageProblemLines(result.problems, 8);
+        for (const line of said) fail("automations", "makersclaw.json", line);
+      }
+    }
+  }
+}
+
+// 19. Cards in a row are not set to their own height (0.8.1; UI review X6,
+//     Project Roadmap's four start cards, 2026-10-12). ActionCard stretches
+//     to the height of its row and pins its status and its button to the
+//     bottom, so a row of them ends on one line and the buttons line up.
+//     `self-start` (or self-center, self-end, h-fit, h-auto) on a card, or
+//     `items-start` (items-center, items-end) on the grid or flex row that
+//     holds two or more of them, takes the stretch away again: each card is
+//     then only as tall as its own words, the cards end at different
+//     heights and their buttons sit at different heights. The CRM's fix of
+//     2026-10-11 had put `self-start` into the kit to stop an empty block
+//     under a card; that block came from a squeezed row (rule 16), not from
+//     the stretch. A card on its own beside something unrelated takes the
+//     `fit` prop instead (`fit` beside other ActionCards is refused too). It
+//     reads the JSX the way rule 16 does (a child is a line one indent in
+//     from its parent's opening tag).
+{
+  const L = limiter("stretch");
+  const classesOf = (text) => [...text.matchAll(/"([^"]*)"|`([^`$]*)`|'([^']*)'/g)].map((m) => m[1] ?? m[2] ?? m[3]).join(" ");
+  const has = (cls, re) => new RegExp(`(?:^|\\s)(?:[\\w@\\[\\]/-]+:)*!?${re}(?![\\w-])`).test(cls);
+  const card = new RegExp(`<ActionCard\\b(${ATTRS})`, "g");
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    if (!/<ActionCard\b/.test(f.code)) continue;
+    for (const m of f.code.matchAll(card)) {
+      const own = classesOf(m[1]);
+      if (has(own, "self-(?:start|center|end)") || has(own, "h-(?:fit|auto|min)"))
+        L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "self", "an ActionCard sized to its own words (self-start, h-fit…): in a row it ends shorter than its neighbours and its button sits higher. A card stretches to its row and pins its button to the bottom; take the class off. One card alone beside something unrelated takes the `fit` prop");
+    }
+    const rows = f.code.split("\n");
+    for (let i = 0; i < rows.length; i++) {
+      const open = rows[i].match(/^(\s*)<(\w[\w.]*)\b[^>]*\bclassName=/);
+      if (!open || /\/>\s*$/.test(rows[i]) || /^\s*<ActionCard\b/.test(rows[i])) continue;
+      const cls = classesOf(rows[i]);
+      if (!(has(cls, "grid") || has(cls, "flex") || has(cls, "inline-flex")) || !has(cls, "items-(?:start|center|end)")) continue;
+      const ind = open[1].length;
+      let cards = 0;
+      let mapped = false;
+      for (let j = i + 1; j < rows.length; j++) {
+        const lead = rows[j].match(/^(\s*)\S/);
+        if (!lead) continue;
+        if (lead[1].length <= ind) break;
+        if (/\.map\(/.test(rows[j])) mapped = true;
+        if (/<ActionCard\b/.test(rows[j])) cards += 1;
+      }
+      if (cards >= 2 || (mapped && cards >= 1)) {
+        L.hit(`${f.path}:${i + 1}`, "items", "a row of ActionCards whose row sets items-start (items-center, items-end): the cards then end at different heights and their buttons do not line up. Leave the row's alignment alone: the cards stretch to the row and pin the button to the bottom");
+      }
+    }
+    // `fit` on a card that has neighbours in the same parent.
+    for (let i = 0; i < rows.length; i++) {
+      if (!/<ActionCard\b[^>]*\sfit(?:[\s/>=]|$)/.test(rows[i])) continue;
+      const ind = rows[i].match(/^(\s*)/)[1].length;
+      let siblings = 0;
+      for (const dir of [-1, 1]) {
+        for (let j = i + dir; j >= 0 && j < rows.length; j += dir) {
+          const lead = rows[j].match(/^(\s*)\S/);
+          if (!lead) continue;
+          if (lead[1].length < ind) break;
+          if (lead[1].length === ind && /^\s*<ActionCard\b/.test(rows[j])) siblings += 1;
+        }
+      }
+      if (siblings) L.hit(`${f.path}:${i + 1}`, "fit", "`fit` on an ActionCard that has ActionCard neighbours: in a row the cards stretch to one height. `fit` is for a card on its own");
+    }
+  }
+  if (L.count > 4) fail("stretch", `${L.count - 4} more`, "ActionCards sized to their own words");
+  if (!L.count) ok("stretch", "no ActionCard is sized to its own words, and no row of them sets items-start");
+}
+
+// 20. A Meter in a narrow box is a compact Meter (0.8.1; UI review X1,
+//     Newsletter Engine's top bar, 2026-10-12). A Meter draws its label and
+//     its numbers as visible text above the bar. In a box under about 8rem
+//     (`w-14`, `w-24`…) the label wraps to a second line and runs into the
+//     button beside it ("15,000 cr left" over Find). `compact` draws the bar
+//     alone; the label stays for a screen reader and as the tooltip. So a
+//     `<Meter` with a `label` and a width of 8rem or less in its className
+//     (w-N, w-[Nrem|Npx], max-w-N, size-N) and no `compact` is refused.
+{
+  const L = limiter("meter");
+  const meter = new RegExp(`<Meter\\b(${ATTRS})`, "g");
+  const narrow = (cls) => {
+    for (const m of cls.matchAll(/(?:^|\s)(?:[\w@[\]/-]+:)*!?(?:max-w|w|size)-(?:(\d+(?:\.\d+)?)|\[(\d+(?:\.\d+)?)(rem|px|em)\])(?![\w%/-])/g)) {
+      const px = m[1] !== undefined ? Number(m[1]) * 4 : Number(m[2]) * (m[3] === "px" ? 1 : 16);
+      if (px <= 128) return m[0].trim();
+    }
+    return null;
+  };
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    for (const m of f.code.matchAll(meter)) {
+      const attrs = m[1];
+      if (!/(?:^|\s)label\s*=/.test(attrs) || /(?:^|\s)compact(?:[\s=/]|$)/.test(attrs)) continue;
+      const cls = [...attrs.matchAll(/className\s*=\s*(?:"([^"]*)"|\{\s*(?:"([^"]*)"|`([^`$]*)`)\s*\})/g)].map((c) => c[1] ?? c[2] ?? c[3]).join(" ");
+      const w = narrow(cls);
+      if (w)
+        L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "meter", `a Meter with a label in a box ${w} wide: the label draws as visible text and spills into what is beside it. Add \`compact\` (the bar alone; the label stays as the tooltip and for a screen reader)`);
+    }
+  }
+  if (L.count > 4) fail("meter", `${L.count - 4} more`, "labelled Meters in narrow boxes");
+  if (!L.count) ok("meter", "no labelled Meter sits in a box under 8rem without compact");
+}
+
+// 21. A page that opens what it just made waits for the write (0.8.1; UI
+//     review X11, Project Health's "That project isn't here", 2026-10-12).
+//     Apps read their whole world once and share it. A write answers, THEN
+//     the world is read again; `router.push(?row=<new id>)` straight after
+//     the write opens a record the world does not hold yet, and the page
+//     says "not found" until the re-read lands. So a router.push/replace
+//     whose address is built from the answer of an awaited call
+//     (`const out = await addProject(…)` … `${out.id}`) needs the write
+//     wrapped in afterWrite() (lib/data), or an `await whenLanded()` between
+//     them. A read (loadRow, fetch…) is not a write and is not asked. The
+//     other half is the record page's: it says "not found" through
+//     useNotFound() (lib/data), which stays false while a write or a
+//     re-read is out; the template's tests hold that half.
+{
+  const L = limiter("landed");
+  const READS = /\b(?:loadRows?|countRows|countBy|loadActivity|fetch|claw|loadOne|read[A-Z]\w*)\s*\(/;
+  for (const f of appFiles.filter((x) => /\.(?:jsx?|tsx?)$/.test(x.path))) {
+    const rows = f.code.split("\n");
+    for (let i = 0; i < rows.length; i++) {
+      const m = /\b(?:router|history)\.(?:push|replace)\s*\(|\bnavigate\s*\(/.exec(rows[i]);
+      if (!m) continue;
+      // The address: this line to the call's closing bracket (or 4 lines).
+      const arg = rows.slice(i, i + 4).join(" ").slice(m.index);
+      const vars = new Set([...arg.matchAll(/\b([A-Za-z_$][\w$]*)\??\.[A-Za-z_$]/g)].map((x) => x[1]));
+      for (const v of vars) {
+        if (/^(?:window|location|document|Math|JSON|Object|Number|String|Array|process|props|this)$/.test(v)) continue;
+        const name = v.replace(/\$/g, "\\$");
+        const decl = new RegExp(`(?:\\b(?:const|let|var)\\s+${name}\\s*=|^\\s*${name}\\s*=)\\s*await\\b`);
+        for (let k = i; k >= Math.max(0, i - 40); k--) {
+          if (!decl.test(rows[k])) continue;
+          const between = rows.slice(k, i + 1).join("\n");
+          if (/\bafterWrite\s*\(|\bwhenLanded\s*\(/.test(between) || READS.test(rows[k])) break;
+          L.hit(`${f.path}:${i + 1}`, v, `${m[0].replace(/\s*\($/, "")}() builds its address from \`${v}\`, the answer of a write awaited on line ${k + 1}, before the page holds what was written: the record page then says "not found" until the re-read lands. Wait for it: \`const ${v} = await afterWrite(<the write>)\` (lib/data), or \`await whenLanded()\` first`);
+          break;
+        }
+      }
+    }
+  }
+  if (L.count > 4) fail("landed", `${L.count - 4} more`, "navigations built from a write that has not landed");
+  if (!L.count) ok("landed", "no page opens a row from a write it did not wait for");
+}
+
+// 22. A mounted agent can be opened (0.8.1; UI review X8, Gantt Planner,
+//     2026-10-12). Gantt mounted the agent's dock and defined a function to
+//     toggle it, and no button anywhere called it: the agent could not be
+//     opened unless a screen happened to ask it something. So an app that
+//     mounts an AgentDock needs a way to open it: the TopBar block (which
+//     always draws Ask when it is given the dock, or sits under an
+//     AskProvider), its AskButton, a button of the app's own whose
+//     onClick/onAsk calls the dock's toggle() or setOpen(), or a window event
+//     the shell hears (and opens the dock from) that a bar dispatches. A
+//     toggle that is defined and never wired to a control is what this
+//     refuses.
+{
+  const L = limiter("ask");
+  const mounts = [];
+  const names = new Set();
+  scan(/<AgentDock\b/, (f, m, at) => {
+    mounts.push(`${f.path}:${at}`);
+    const tag = new RegExp(`^<AgentDock\\b${ATTRS}`).exec(f.code.slice(m.index))?.[0] ?? "";
+    const named = /\bdock=\{\s*([A-Za-z_$][\w$]*)\s*\}/.exec(tag);
+    if (named) names.add(named[1].replace(/\$/g, "\\$"));
+  });
+  if (mounts.length) {
+    const BAR = /from\s*["'][^"']*\bblocks\/top-bar["']/;
+    const bars = appFiles.filter((f) => BAR.test(f.code));
+    const drawn = bars.some((f) => /<(?:TopBar|AskButton)\b/.test(f.code));
+    const fed = bars.some((f) => /<AskProvider\b/.test(f.code) || new RegExp(`<(?:TopBar|AskButton)\\b${ATTRS}\\b(?:dock|onAsk)=`).test(f.code));
+    const who = names.size ? [...names].join("|") : "[A-Za-z_$][\\w$]*";
+    const own = appFiles.some((f) => new RegExp(`\\bon(?:Click|Ask)=\\{[^}]*\\b(?:${who})\\.(?:toggle|setOpen)\\b`).test(f.code));
+    // The older way: a window event the shell listens for (and calls the
+    // dock's toggle/setOpen from) that some bar dispatches by name.
+    const opens = new RegExp(`\\b(?:${who})\\.(?:toggle|setOpen)\\b`);
+    const heard = new Set();
+    scan(/addEventListener\(\s*["']([^"']+)["']/, (f, m) => {
+      if (opens.test(f.code.slice(Math.max(0, m.index - 400), m.index + 400))) heard.add(m[1]);
+    });
+    const sent = [...heard].some((name) => appFiles.some((f) => new RegExp(`new\\s+(?:Custom)?Event\\(\\s*["']${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`).test(f.code)));
+    if (!(drawn && fed) && !own && !sent) {
+      L.hit(mounts[0], "ask", "an AgentDock is mounted and nothing opens it: no button calls the dock's toggle() or setOpen(), so the agent cannot be reached unless a screen asks it something. Draw the top bar with the TopBar block (blocks/top-bar) and give it the dock (`<TopBar dock={dock} …/>`, or wrap the shell in `<AskProvider dock={dock}>`): it always draws Ask and Ask opens the dock. In a bar that cannot be a TopBar, use `<AskButton dock={dock}/>`");
+    }
+  }
+  if (!mounts.length) ok("ask", "no agent dock is mounted");
+  else if (!L.count) ok("ask", "the agent dock is mounted and Ask opens it");
+}
+
+// 23. A page with a side column uses PageLayout (0.8.1; UI review X12, Project
+//     Roadmap's Today, 2026-10-12). A screen that draws its own main + side
+//     (`grid-cols-[minmax(0,1fr)_19rem]` and an `<aside>` with `border-l`) is
+//     as tall as its words: in a tall window the divider stops halfway, the
+//     bottom half is empty, and the side cannot scroll on its own. PageLayout
+//     (components/ui) takes the full height of the window's content, runs the
+//     divider top to bottom and scrolls each column by itself.
+{
+  const L = limiter("page");
+  const SIDE = /(?:^|[\s"'`{])(?:[\w@[\]/-]+:)*grid-cols-\[(?:minmax\(0,\s*1fr\)|1fr)_(?:\d+(?:\.\d+)?(?:rem|px)|var\([^)]*\))\]/;
+  const RULED = /(?:^|[\s"'`{])(?:[\w@[\]/-]+:)*border-l(?![\w-])/;
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    const grid = SIDE.exec(f.code);
+    if (!grid) continue;
+    const ruled = [...f.code.matchAll(new RegExp(`<aside\\b(${ATTRS})`, "g"))].some((a) => RULED.test(a[1]));
+    if (!ruled) continue;
+    L.hit(`${f.path}:${lineOf(f.code, grid.index)}`, "page", "a page drawn as a main column and a side column of its own (a fixed-width grid column and an <aside> with a left border) is only as tall as its words: in a tall window the divider stops halfway and the side cannot scroll by itself. Use PageLayout from components/ui: `<PageLayout side={<Side/>}>{main}</PageLayout>` in an AppLayout with contentMode=\"fill\"; it fills the height, runs the divider top to bottom and scrolls each column on its own");
+  }
+  if (L.count > 4) fail("page", `${L.count - 4} more`, "pages with a hand-drawn side column");
+  if (!L.count) ok("page", "no screen draws its own main + side columns: PageLayout does");
+}
+
+// 24. A screen's heading is a tool's, not a landing page's (0.8.1; UI review
+//     X10, Gantt Planner's home, 2026-10-12: "Plan a project that lands on its
+//     date." at 52px with four stacked cards and a big chart under it). An
+//     <h1> at text-4xl (36px) or more, or a pixel size from 36 up, is a hero.
+//     The first run of an app is the FirstRun block: one plain heading line
+//     at the kit's size, what the app does in a line, and the real first
+//     steps. A picture of someone else's page (components/depictions) is
+//     skipped.
+{
+  const L = limiter("hero");
+  const BIG = /(?:^|[\s"'`{])(?:[\w@[\]/-]+:)*text-(?:[4-9]xl|\[(?:3[6-9]|[4-9]\d|\d{3,})(?:\.\d+)?px\]|\[(?:2\.(?:2[5-9]|[3-9])\d*|[3-9](?:\.\d+)?)rem\])(?![\w-])/;
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    const g = new RegExp(`<h1\\b(${ATTRS})`, "g");
+    let m;
+    while ((m = g.exec(f.code))) {
+      if (!BIG.test(m[1])) continue;
+      L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "hero", "an <h1> at 36px or more reads as a website's hero, not an app's page. Use the kit's heading sizes (text-xl to text-2xl), and for a first run the FirstRun block (blocks/first-run): one heading line, what the app does in a line, then the real first steps");
+    }
+  }
+  if (L.count > 4) fail("hero", `${L.count - 4} more`, "oversized page headings");
+  if (!L.count) ok("hero", "no page heading is set at a landing page's size");
+}
+
+// 25. "Have the agent do it" opens the agent, not a form (0.8.1; UI review
+//     X9, Gantt Planner, 2026-10-12: "Have the agent draft it" still made
+//     the member fill in a name, a code and two dates first; the founder:
+//     "the agent should be able to create these"). A button whose words say
+//     the agent will do the work ("Have the agent draft it", "Let the agent
+//     plan it", "Draft it with the agent") calls openAgent("…")
+//     (blocks/agent-dock) or sends to the agent (ask, chat.send): the dock
+//     opens with the line already in hand and the agent asks only for what
+//     it is missing, in the chat. A button that submits a form, follows a
+//     link or only changes a step is what this refuses. A form stays only
+//     for "type it yourself". It reads the buttons' own words (the handler
+//     may be named in the same file), and a short quoted label ("Have the
+//     agent draft it" as a choice's label): that file must call openAgent,
+//     or send to the agent and draw no form of its own. The kit and the
+//     blocks are pinned and are not read.
+{
+  const L = limiter("agentfirst");
+  const WHO = String.raw`(?:the\s+|your\s+)?(?:agent|ai|assistant)`;
+  const LABEL = String.raw`(?:(?:have|let|get|ask)\s+${WHO}\s+(?:to\s+)?(?:draft|do|create|build|plan|write|make|set\s*up|fill|prepare|handle|generate)\b|(?:draft|plan|create|build|write|generate)\s+(?:it\s+|this\s+|them\s+)?with\s+${WHO}\b)`;
+  const OPENS = /\bopenAgent\s*\(/;
+  const SENDS = /\b(?:openAgent|askAgent|askTheAgent|ask|send)\s*\(/;
+  const FORM = /<(?:form|Field|Input|Textarea|Select|DateInput|DatePicker)\b/;
+  const NOT_FORMS = String.raw`openAgent("Draft a project plan for me") (blocks/agent-dock) opens the agent with that line already sent in a new chat, and the agent asks only for what it is missing, in the chat; a form stays only for "type it yourself"`;
+  /** Does the handler an onClick names (in the same file) open the agent? */
+  const sends = (code, click) => {
+    if (SENDS.test(click)) return true;
+    for (const id of new Set(click.match(/[A-Za-z_$][\w$]*/g) ?? [])) {
+      const def = new RegExp(`(?:const|let|function)\\s+${id.replace(/\$/g, "\\$")}\\b`).exec(code);
+      if (def && SENDS.test(code.slice(def.index, def.index + 900))) return true;
+    }
+    return false;
+  };
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    const el = new RegExp(`<(Button|button|Link|a|MenuItem)\\b(${ATTRS})>\\s*(?:<Icon\\b[^>]*/>\\s*)?(${LABEL}[^<{]{0,40})`, "gi");
+    let m;
+    while ((m = el.exec(f.code))) {
+      const click = /\bon(?:Click|Press|Select)=\{((?:[^{}]|\{[^{}]*\})*)\}/.exec(m[2])?.[1] ?? "";
+      if (sends(f.code, click)) continue;
+      L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "agentfirst", `"${m[3].trim()}" opens ${click ? "something other than the agent" : "a form or a route"}: a button that says the agent will do the work must open the agent. ${NOT_FORMS}`);
+    }
+    if (OPENS.test(f.code)) continue;
+    const drawsForm = FORM.test(f.code);
+    if (SENDS.test(f.code) && !drawsForm) continue;
+    const quoted = new RegExp(`(["'\`])\\s*${LABEL}[^"'\`\\n]{0,40}\\1`, "gi");
+    while ((m = quoted.exec(f.code))) {
+      L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "agentfirst", `${m[0]} is a choice that says the agent will do the work, and ${SENDS.test(f.code) ? "this file draws a form around it" : "nothing in this file asks the agent"}: ${NOT_FORMS}`);
+    }
+  }
+  if (L.count > 4) fail("agentfirst", `${L.count - 4} more`, 'buttons that say "have the agent do it" and open a form');
+  if (!L.count) ok("agentfirst", 'every "have the agent do it" button opens the agent');
+}
+
+// 26. A bar action with words has an icon (0.8.1; the Newsletter Engine pilot,
+//     2026-10-12). The top bar's `BarText` hides its words under 32rem so the
+//     action is its icon, and leaves them to a screen reader. A button whose
+//     only content is `<BarText>` and which has no `icon` is, under 32rem,
+//     an empty button: nothing to see, nothing to press. Give the Button an
+//     `icon` (or an <Icon/> beside the BarText).
+{
+  const L = limiter("barlabel");
+  for (const f of appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path))) {
+    if (!/<BarText\b/.test(f.code)) continue;
+    const g = new RegExp(`<(Button|button|IconButton)\\b(${ATTRS})>`, "g");
+    let m;
+    while ((m = g.exec(f.code))) {
+      if (/\/\s*$/.test(m[2])) continue;
+      const end = f.code.indexOf(`</${m[1]}>`, m.index);
+      if (end < 0) continue;
+      const inner = f.code.slice(m.index + m[0].length, end);
+      if (!/<BarText\b/.test(inner)) continue;
+      if (/(?:^|\s)icon=/.test(m[2]) || /<(?:Icon|svg)\b/.test(inner)) continue;
+      L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "barlabel", "a button whose words are a <BarText> and that has no icon is an empty button under 32rem of bar (BarText gives its words up there, to a screen reader only). Give the Button an icon: `<Button icon=\"plus\"><BarText>New issue</BarText></Button>`");
+    }
+  }
+  if (L.count > 4) fail("barlabel", `${L.count - 4} more`, "bar actions with no icon");
+  if (!L.count) ok("barlabel", "every bar action with words has an icon");
+}
+
+// 27. A side column is the fixed one, so it is short (0.8.1; UI review X13,
+//     Newsletter Engine's first run, 2026-10-12: a short intro on the left
+//     and a long "Name it" form in the right column, "one small column and
+//     then all the card long scrolling in other column"). In a main + side
+//     page the main scrolls and the side holds its place; a form, a paste
+//     box or a list that grows with the data does not belong there. Reads a
+//     PageLayout `side` and an <aside>: their markup, and the components the
+//     app defines that they draw (a name resolved in any app file, three
+//     levels; a called function only when it returns JSX). Refused: a <form>, a <Textarea>, three or more of Field ·
+//     Input · Textarea · Select, and a `.map(` of data with no `.slice(` in
+//     the same piece of code (a constant in CAPITALS, an array literal and
+//     Object.entries(CAPITALS) are fixed lists). It cannot see inside a block
+//     or a kit component, content that comes in by props or context, or how
+//     long a list is at run time.
+{
+  const L = limiter("sidelong");
+  const jsxFiles = appFiles.filter((x) => /\.(?:jsx|tsx)$/.test(x.path));
+  const OPEN = { "{": "}", "(": ")", "[": "]" };
+  /** The index just past the bracket that closes the one at `i`. Double-quoted
+   *  and template strings are skipped; single quotes are not (JSX text has
+   *  apostrophes). */
+  const closeAt = (code, i) => {
+    let depth = 0;
+    for (let k = i; k < code.length; k++) {
+      const c = code[k];
+      if (c === '"' || c === "`") {
+        const e = code.indexOf(c, k + 1);
+        if (e < 0) return code.length;
+        k = e;
+      } else if (OPEN[c]) depth++;
+      else if (c === "}" || c === ")" || c === "]") {
+        depth--;
+        if (depth === 0) return k + 1;
+        if (depth < 0) return k;
+      }
+    }
+    return code.length;
+  };
+  /** From `i` to the `;` that ends the statement (brackets balanced). */
+  const untilSemi = (code, i) => {
+    let k = i;
+    while (k < code.length) {
+      const c = code[k];
+      if (c === '"' || c === "`") {
+        const e = code.indexOf(c, k + 1);
+        k = e < 0 ? code.length : e + 1;
+      } else if (OPEN[c]) k = closeAt(code, k);
+      else if (c === ";" || c === "}" || c === ")" || c === "]") break;
+      else k++;
+    }
+    return code.slice(i, k);
+  };
+  /** The body of the component or function `name` an app file defines. */
+  const defined = (name) => {
+    const out = [];
+    for (const f of jsxFiles.concat(appFiles.filter((x) => /\.(?:js|ts)$/.test(x.path)))) {
+      const fn = new RegExp(`\\bfunction\\s+${name}\\s*\\(`).exec(f.code);
+      if (fn) {
+        const p0 = fn.index + fn[0].length - 1;
+        const b = f.code.indexOf("{", closeAt(f.code, p0));
+        if (b >= 0) out.push(f.code.slice(b, closeAt(f.code, b)));
+        continue;
+      }
+      const cn = new RegExp(`\\b(?:const|let)\\s+${name}\\s*=`).exec(f.code);
+      if (cn) out.push(untilSemi(f.code, cn.index + cn[0].length));
+    }
+    return out;
+  };
+  /** What a piece of side code holds: a reason, or null. */
+  const holds = (code) => {
+    if (/<form\b/.test(code)) return "a <form>";
+    if (/<Textarea\b/.test(code)) return "a <Textarea> (a paste or text box)";
+    const fields = new Set([...code.matchAll(/<(Field|Input|Select)\b/g)].map((m) => m[1]));
+    const n = [...code.matchAll(/<(?:Field|Input|Select)\b/g)].length;
+    if (n >= 3) return `${n} fields (${[...fields].join(", ")})`;
+    if (!/\.slice\(/.test(code)) {
+      for (const m of code.matchAll(/([A-Za-z_$][\w$.]*|\)|\])\s*\.map\(/g)) {
+        const recv = m[1];
+        if (recv === "]") continue;
+        if (recv === ")") {
+          if (/Object\.(?:entries|keys|values)\(\s*[A-Z][A-Z0-9_]*\s*\)\s*$/.test(code.slice(Math.max(0, m.index - 60), m.index + 1))) continue;
+          if (/\bArray\.from\(/.test(code.slice(Math.max(0, m.index - 60), m.index + 1))) continue;
+        } else if (/^(?:[A-Za-z_$][\w$]*\.)*[A-Z][A-Z0-9_]*$/.test(recv)) continue;
+        return `a list from data (${recv === ")" ? "…)" : recv}.map) with no .slice(...) to bound it`;
+      }
+    }
+    return null;
+  };
+  /** The code without what opens over the page (a Sheet, a Popover, a
+   *  Dialog, a menu): its form is not in the column until someone opens it. */
+  const withoutOverlays = (code) => {
+    let out = code;
+    for (const tag of ["Sheet", "Popover", "Dialog", "Modal", "Drawer", "Menu", "DropdownMenu", "Tooltip", "AlertDialog"]) {
+      for (;;) {
+        const open = new RegExp(`<${tag}\\b`).exec(out);
+        if (!open) break;
+        const close = out.indexOf(`</${tag}>`, open.index);
+        out = out.slice(0, open.index) + (close < 0 ? "" : out.slice(close + tag.length + 3));
+        if (close < 0) break;
+      }
+    }
+    return out;
+  };
+  /** The first reason in `code`, or in a component or function it draws. */
+  const reason = (whole, seen = new Set(), depth = 0, via = []) => {
+    const code = withoutOverlays(whole);
+    const own = holds(code);
+    if (own) return { why: own, via };
+    if (depth >= 3) return null;
+    const names = new Set([...code.matchAll(/<([A-Z][\w$]*)\b/g)].map((m) => m[1]));
+    for (const m of code.matchAll(/(?<![\w$.])([a-z][\w$]*)\(/g)) names.add(m[1]);
+    for (const name of names) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      for (const body of defined(name)) {
+        // A function the side calls draws something only if it returns JSX
+        // (a formatter that maps a list of strings draws nothing).
+        if (/^[a-z]/.test(name) && !/<[A-Za-z]/.test(body)) continue;
+        const r = reason(body, seen, depth + 1, [...via, name]);
+        if (r) return r;
+      }
+    }
+    return null;
+  };
+  /** The value of the `side` attribute of the <PageLayout> that opens at `at`:
+   *  JSX or an expression, or a name that stands for one in the same file. */
+  const sideOf = (code, at) => {
+    let k = at + "<PageLayout".length;
+    while (k < code.length) {
+      const c = code[k];
+      if (c === ">") return null;
+      if (c === '"' || c === "'") {
+        const e = code.indexOf(c, k + 1);
+        k = e < 0 ? code.length : e + 1;
+      } else if (c === "{") k = closeAt(code, k);
+      else if (/\s/.test(c) && /^\s+side=\{/.test(code.slice(k, k + 12))) {
+        const b = code.indexOf("{", k);
+        const expr = code.slice(b + 1, closeAt(code, b) - 1);
+        const id = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(expr);
+        if (!id) return expr;
+        const decl = new RegExp(`\\b(?:const|let)\\s+${id[1]}\\s*=`).exec(code);
+        return decl ? untilSemi(code, decl.index + decl[0].length) : expr;
+      } else k++;
+    }
+    return null;
+  };
+  const SAY = "a side column is the fixed one: it stays put while the main scrolls, so it is short and needs no scroll of its own. Put the form or the long list in the main (a step that opens reveals its own card there) and keep the side to a summary, the next step or a small panel; bound a short list with .slice(0, 5)";
+  for (const f of jsxFiles) {
+    for (const m of f.code.matchAll(/<PageLayout\b/g)) {
+      const side = sideOf(f.code, m.index);
+      const r = side ? reason(side) : null;
+      if (r) L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "side", `a PageLayout side holds ${r.why}${r.via.length ? ` (through ${r.via.join(" → ")})` : ""}: ${SAY}`);
+    }
+    const beside = /(?:^|[\s"'`{])(?:[\w@[\]/-]+:)*grid-cols-\[(?:minmax\(0,\s*1fr\)|1fr)_(?:\d+(?:\.\d+)?(?:rem|px)|var\([^)]*\))\]/.test(f.code);
+    for (const m of f.code.matchAll(new RegExp(`<aside\\b(${ATTRS})>`, "g"))) {
+      if (/\/\s*$/.test(m[1])) continue;
+      // An <aside> is a side column when it is ruled (border-l or border-r) or
+      // sits in a file that draws a fixed-width column beside a main: a note
+      // or a callout that happens to be an <aside> is not.
+      if (!beside && !/(?:^|[\s"'`{])(?:[\w@[\]/-]+:)*border-[lr](?![\w-])/.test(m[1])) continue;
+      const from = m.index + m[0].length;
+      let depth = 1;
+      let end = f.code.length;
+      for (const t of f.code.slice(from).matchAll(/<(\/?)aside\b/g)) {
+        depth += t[1] ? -1 : 1;
+        if (!depth) {
+          end = from + t.index;
+          break;
+        }
+      }
+      const r = reason(f.code.slice(from, end));
+      if (r) L.hit(`${f.path}:${lineOf(f.code, m.index)}`, "aside", `an <aside> holds ${r.why}${r.via.length ? ` (through ${r.via.join(" → ")})` : ""}: ${SAY}`);
+    }
+  }
+  if (L.count > 4) fail("sidelong", `${L.count - 4} more`, "side columns that hold a form or a long list");
+  if (!L.count) ok("sidelong", "no side column holds a form or a long list");
+}
+
 // 6. Smoke: the app, built and started, answers every surface.
 
 /** Newest mtime among the app's own sources (what a build reads): walk
@@ -1900,7 +2926,12 @@ function writable(dir) {
  *  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
+  // plays/<name>/app names the copy <name>; the store's packages/<key>/files/app
+  // would all be "files", one folder shared by every package's check, so the
+  // package's key names it there (2026-10-12, every builder of the wave).
+  const parent = dirname(ROOT);
+  let name = basename(parent) || "app";
+  if (name === "files") name = basename(dirname(parent)) || name;
   const home = writable(homedir()) ? homedir() : tmpdir();
   return { dir: join(home, ".claw-check", name), dist: ".next", copied: true };
 }