@prestack/thread 0.0.1 → 0.0.3

package/dist/integrity/constraint.ts

@@ -0,0 +1,1202 @@
+import type { Threaded } from '../core/thread.ts'
+import { named } from '../core/scope.ts'
+
+export interface Constraint extends Threaded {
+  readonly version: number
+  readonly where: { readonly paths: readonly string[]; readonly except?: readonly string[] }
+  readonly bans: string
+  readonly because: string
+  readonly instead: string
+  readonly wrong: string
+  readonly right: string
+  readonly governs?: string
+  readonly severity?: 'forbidden' | 'warning'
+}
+
+export const CONSTRAINTS: readonly Constraint[] = [
+  {
+    id: 'no-comment',
+    at: './constraint.ts',
+    describes: 'The refusal that keeps meaning in one place — an agent reads prose beside the code, believes it over the code, and writes more of it, so explanation accumulates where nothing checks it while the glossary declared to hold it stays empty.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'slopnators/'] },
+    bans: 'a comment of any kind — block, line or JSDoc',
+    because:
+      'measured 2026-08-13: 52,187 of this repository\'s 124,964 lines are comment, and the five thread files carry 739 of them against a glossary holding 27 words with 27 empty meanings — so meaning lives in prose that nothing checks while the one place declared to hold it is empty. A single read of those five files found 17 statements contradicting the code beside them: three teach the `parent:` field `no-child-parent` refuses, one reports a 61-row book that holds 18, and one names `pnpm ci` as the gate when the script is `pnpm gate`',
+    instead: 'write the meaning in `threads/glossary.ts`, and whatever a file must say about itself in the row that parents it — its `describes` and its `cites`',
+    wrong: '/** THREAD — the root. The only node that exists without being declared. */',
+    right: "{ id: 'thread', means: 'The root. The only node that exists without being declared.' }",
+    cites: [{ on: '2026-08-13', said: 'I want a law, that no comment is allowed. There is a glossary, and meaning goes in the glossary. The code tells what the app does, not comments. AIs read comments, ignore code, and write more comments, and the comments are all slop or lie.' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_comment.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'A law is written, names a slopnator. Slopnator is seeded magically. Someone write the function. An enforcer picks it up and it just works.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        by: 'thread trials',
+        runs: 'thread trials',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [
+          { on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' },
+          { on: '2026-08-14', said: 'maybe laws + slopnators produce a trial through law instead? That also works for me.' },
+        ],
+      },
+    ],
+  },
+
+  {
+    id: 'secret-literal',
+    at: './constraint.ts',
+    describes: 'The refusal of a credential written into a file — the one leak this framework can actually prevent, because a value in a tree is in every copy of it, in its history for ever, and in whatever bundle reaches it.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/', 'dist/', 'slopnators/', 'thread/integrity/constraint.ts'] },
+    bans: 'a credential written as a literal — a vendor key by its own prefix, a private key block, a password inside a connection string, or a long opaque value assigned to something called a secret, a password, a token or a key',
+    because:
+      'a secret is the one thing here that cannot be taken back. A wrong schema is regenerated and a wrong row is edited, but a credential committed once is in the history of every clone of that repository and has to be rotated at the vendor — and the framework itself never ships, so the only place a value can leak from is an app somebody built with it. Nothing else refuses this: the descent asks who declared a file, `unseamed-reach` asks what a node imports, and neither reads what a string contains',
+    instead:
+      'declare it with `thread create secret`, which asks a person for the value at a terminal with the echo off and seals it into the store beside the tree. The row holds the name and the sentence and has no field for a value at all; a target requires the row by name, and dispatch resolves it at the moment of the call',
+    wrong: "export const stripe = { apiKey: 'sk_live_51H8xQvL2eZvKYlo2C0Nx9K4mQwErTyUiOp' }",
+    right: "export const node = nd_action(async (hands) => await hands.ht_stripe.charge({ json: { amount: 100 } }))",
+    cites: [
+      { on: '2026-08-29', said: 'some of the secrets are server and extremely important, others are public....so we need a way to make this extremely robust to attacks or leaks. Mostly leaks since the framework doesn\'t ship' },
+      { on: '2026-08-29', said: 'we need constraints.ts to have ways to protect us' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_secret_literal.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'A law is written, names a slopnator. Slopnator is seeded magically. Someone write the function. An enforcer picks it up and it just works.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'unseamed-reach',
+    at: './constraint.ts',
+    describes: 'The refusal of a node taking a capability from the runtime instead of from the seams it is handed — everything through the seams is recorded under the node\'s own id, counted against the run\'s quota and permitted by its grants, and everything around them is none of those things.',
+    version: 1,
+    where: { paths: ['operations/', 'nodes/'], except: ['thread/operations/', '_generated/', 'node_modules/'] },
+    bans: 'a file under an operation or a node type importing a runtime built-in — anything `node:`, by that name or the bare one',
+    because:
+      'measured 2026-08-27 in an app installed from a packed build: a node whose row says `nd_read` was given `import { readFileSync } from \'node:fs\'` and a body that read /etc/hosts, and `thread gate` passed 5 of 5 — the compiler, the descent, the sweep, the build and the seed check all agreed, and the run\'s record said the node ran and read nothing. Nothing else refuses this, because every other rule reads what a file declares rather than what it reaches: the descent asks who named the file, `no-dispatch-bypass` asks who called the operation, and neither asks what the body touches. An operation whose nodes can reach the disk directly is an operation whose log describes a different program, and the log is the whole reason a node has an id',
+    instead:
+      'take it from the seams the node is handed — `store` and `search` on a read node, the whole of `seams` on an action node. If what you need is not there, it is a seam the framework has not declared yet, and that is a question for the founder rather than an import',
+    wrong: "import { readFileSync } from 'node:fs'",
+    right: 'export const node = nd_read<In>(async (hands) => await hands.store.get(\'customer\', held.input.id))',
+    cites: [{ on: '2026-08-27', said: 'node:fs law' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unseamed_reach.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'A law is written, names a slopnator. Slopnator is seeded magically. Someone write the function. An enforcer picks it up and it just works.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'no-import-cycle',
+    at: './constraint.ts',
+    describes: 'The refusal that keeps the tree readable from the top — a ring of files has no first one, so there is no order to descend in, and it loads at all only while every back edge happens to be type-only.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a file importing a file that imports it back',
+    because:
+      'measured 2026-08-14: threads/ holds six files and three of them — thread.ts, types.ts and meta.ts — import each other in a ring. It compiled only because every back edge happened to be type-only; make one of them a value import and the package stops loading. A ring has no first file, so there is no order to read the tree in, and reading it top down is the whole premise. Measured 2026-08-15, after the shapes became one interface: the ring is gone and every import points down — thread.ts imports nothing, meta.ts and ci.ts take from it, law.ts and glossary.ts take from meta.ts. A guard that has not fired since is a guard doing its job, and the ring took one refactor to reappear once already',
+    instead:
+      'move the thing that is depended upon into the file that is depended upon, so every import points one way. Where that fights the parent that declares it, the depended-upon thing wins — the alternative is code that does not compile',
+    wrong: "import type { Threaded } from './probe.tsx'",
+    right: "import type { Threaded } from '../core/thread.ts'",
+    cites: [{ on: '2026-08-14', said: 'does any file import a file that imports it back? Three do right now. That is the whole check, and it is the kind of thing a law could hold. Do this as a law first.' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_import_cycle.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'A law is written, names a slopnator. Slopnator is seeded magically. Someone write the function. An enforcer picks it up and it just works.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [
+          { on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' },
+          { on: '2026-08-14', said: 'maybe laws + slopnators produce a trial through law instead? That also works for me.' },
+        ],
+      },
+    ],
+  },
+
+  {
+    id: 'undescribed',
+    at: './constraint.ts',
+    describes: 'The one refusal a type cannot make — a required string is satisfied by an empty one and by a restatement of the name beside it, so presence is all a compiler ever proves and content has to be checked by something else.',
+    version: 1,
+    where: { paths: ['threads/'], except: ['threads/glossary.ts'] },
+    bans: 'a `describes` or `means` that is empty, or whose every word beyond the common ones already appears in the id beside it',
+    because:
+      'measured 2026-08-14: threads/glossary.ts holds 27 words and 27 empty meanings, and every other check passed them because presence was all anything asked for — so the tree read as described and said nothing. Measured 2026-08-15: 35 words, 35 empty meanings, and this is the only rule that sees them, because a type can require a field and never require it to say anything. A description that restates its own name is the same hole with prose in it: it adds nothing a reader could not already read off the id, and it is what a machine writes when a person was supposed to. Measured 2026-08-15, once the glossary became derived: every `means` in threads/glossary.ts is a copy of the `describes` this rule already reads on the row that coins the word, so scanning the derived file read the same 52 strings a second time and could not report anything the first pass had missed. That file is excepted — a rule reading a copy of what it already read is a second opinion from the same source',
+    instead:
+      'say what the thing is and what it solves, in a sentence somebody who has not seen the code can act on. If the honest answer is the id again, the thing does not need a description — it needs a reason to exist',
+    wrong: "const M = { id: 'rule', describes: 'The rule.' }",
+    right: "const M = { id: 'rule', describes: 'A rule that must be guaranteed to be enforced, declared once as a row from which its lint rule, its message and the trial that proves it are all derived.' }",
+    cites: [{ on: '2026-08-12', said: 'And you know, I don\'t see the "undescribed" error in your lists.' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undescribed.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I for sure need all errors to be defined, easy to understand, well explained, with fix suggestions.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'unthreaded',
+    at: './constraint.ts',
+    describes: 'The refusal of a file no parent names through the interface, which is how this repository decides what is wired: whatever the descent never reaches is not part of the declared surface, and a reach count printed beside the gap is not a refusal of it.',
+    version: 1,
+    where: { paths: ['threads/', '.'], except: ['_generated/', '.claude/'] },
+    bans: 'a file that no `at:` names from inside a node annotated `Threaded`, `threads/thread.ts` excepted because the root exists by fiat',
+    because:
+      'measured 2026-08-14: the descent from threads/thread.ts names 28 of 641 tracked files, and nothing refused the gap — check-threads printed it as a reach number and exited 0, so twelve files in the mechanism\'s own directories read as wired while nothing declared them. Whatever the descent never reaches is not wired, and a count is not a refusal. This rule reads the mentions and `broken-lineage` reads the roots, deliberately: a file in `threads/` that nothing names still threads what it points at here, and it is that file — not the subtree under it — that gets reported, which is one finding at the cause instead of a cascade at the symptoms. Measured 2026-08-15: an `at:` was a mention, not a thread. Eight lines appended to scripts/finding.ts — a bare object with no id, no at, no describes, no cites and no type — threaded packages/core/engine/src/cache.ts on the next run, and nothing refused it. A file must have a parent; a parent must use the `Threaded` interface to parent it; if it does not, the file is unthreaded. So an `at:` counts only inside a node annotated `Threaded` or an interface extending it, and the bare object threads nothing',
+    instead:
+      'declare it from the row that owns it, or delete it. A file that nothing names is either somebody\'s child nobody wrote down, or it is nobody\'s',
+    wrong: 'export const ORPHAN = 1',
+    right: "export const HELD: Threaded = {\n  declares: [\n    {\n      at: 'threads/probe.tsx',\n    },\n  ],\n}",
+    cites: [
+      { on: '2026-08-12', said: 'Not untraced, unthreaded. Let\'s enforce the naming.' },
+      { on: '2026-08-14', said: 'Cause we need unthreaded, redthread, broken lineage, and the request/produce errors....' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unthreaded.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I want you to transform every single thing that currently is a check into a law.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'twice-parented',
+    at: './constraint.ts',
+    describes: 'The refusal of one address claimed by two owners, because a child declared twice has two answers for who owns it and where it came from, and the tree can give neither — the two rows may sit in different files, so only a slopnator that compares them all can see it.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/'] },
+    bans: 'one `at` claimed by two `declares` rows, wherever the two rows live',
+    because:
+      '`declares` is exactly one parent ever, and with two the child\'s owner, its shape and its origin each have two answers while the tree gives none. Measured 2026-08-14: the two rows may sit in different files, so no slopnator that sees one file can find this — check-threads found it only by comparing parents across the whole descent, which is why it was a check rather than a rule. Measured 2026-08-15: this rule read `threads/` and nothing else, so a file outside the tree that declared a child the tree already declares was invisible to it — and a file outside the tree may name children, which is the whole premise `broken-lineage` rests on. It now counts parents from every file the tree reaches, not from one directory',
+    instead:
+      'keep the row that owns it and delete the other. If both are true, one of them is a `derives` or a `seeds`, which may have many parents because neither of them owns the child',
+    wrong: "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/one.ts',\n    },\n  ],\n}",
+    right: "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+    cites: [{ on: '2026-08-14', said: 'Cause we need unthreaded, redthread, broken lineage, and the request/produce errors....' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_twice_parented.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I want you to transform every single thing that currently is a check into a law.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'broken-lineage',
+    at: './constraint.ts',
+    describes: 'The refusal of a file that names children while nothing names it — the break is above them, so every child reads as merely unnamed and repairing them one by one fixes nothing, which is the difference between one finding and a subtree of them.',
+    version: 1,
+    where: { paths: ['threads/', '.'], except: ['_generated/', '.claude/'] },
+    bans: 'a file that names children while its own origin does not trace back to `threads/`',
+    because:
+      'a file outside `threads/` may name children — that is how `guard.mjs`, once threaded, parents `try-guard.ts` — but the chain has to start somewhere, and the only somewhere is `threads/`. A file that parents while nothing parents IT strands every child it names, and each of those reads as merely unthreaded rather than as the consequence of one break higher up. Measured 2026-08-14: the descent from threads/thread.ts reaches 33 of 646 tracked files, and a single unrooted parent is the difference between one finding and a subtree of them',
+    instead:
+      'thread the file itself — name it from whatever already traces back to `threads/` — or delete it and the children it threaded. Fixing the children first repairs nothing, because the break is above them',
+    wrong: "export const M: Threaded = {\n  declares: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
+    right: 'export const PLAIN = 1',
+    cites: [
+      { on: '2026-08-14', said: 'Red thread is broken lineage.' },
+      { on: '2026-08-14', said: 'if we have files outside threads naming themselves, they must have their origin threaded to threads, otherwise it\'s a broken-lineage error. It\'s different from unthreaded which is nothing parents it.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_broken_lineage.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'Red thread is broken lineage.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'stale-path',
+    at: './constraint.ts',
+    describes: 'The refusal of a written address that is not on disk — a file moves and every sentence naming it becomes a confident lie that still reads as correct, and counting those without judging them is worse than never scanning, because the number reads as a result.',
+    version: 1,
+    where: { paths: ['.'], except: ['slopnators/', '_generated/', 'thread/integrity/sealed.ts'] },
+    bans: 'a string naming a path in this repository that is not on disk',
+    because:
+      'measured 2026-08-10: 91 distinct paths across 240 mentions named files that had moved under `packages/core/`, and every one of them read as correct. Measured 2026-08-14: paths:check scanned 505 files, found 59 more and judged none of them, printing "no findings" while holding the count — a class counted and unjudged is worse than one never scanned, because the number reads as a result',
+    instead:
+      'fix the path, or delete the sentence naming it. A path that carries a `{variable}` states the directory it writes into, and that directory must exist',
+    wrong: "const at = 'threads/nope.ts'",
+    right: "const at = 'packages/core/integrity/src/constraint.ts'",
+    cites: [{ on: '2026-08-14', said: 'I want you to transform every single thing that currently is a check into a law, so we can retire checks and we can have SSOT for laws, and slopnators only for execution.' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_stale_path.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I want you to transform every single thing that currently is a check into a law.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'missing-row',
+    at: './constraint.ts',
+    describes: 'The refusal of a tree that has dropped a row the package it attached from still ships — what a framework offers is not an app\'s to withdraw, and until this existed an app could delete any shipped row and every check still passed.',
+    version: 1,
+    where: { paths: ['.'], except: ['slopnators/', '_generated/'] },
+    bans: 'a tree holding fewer rows than the package it attached from declares',
+    because:
+      'measured 2026-08-22: the `ease` row was deleted from an app\'s `_threads/tokens.ts` and check-threads reported NOTHING — not one finding, and the exit was unchanged. The descent sweeps an app for files nothing declares; it never asks the opposite question, is anything the PACKAGE declares missing from this list, and a shipped file lives under `node_modules/` where nothing sweeps for orphans. So 84 shipped rows could be deleted one at a time in silence, and every check would report success having measured nothing',
+    instead:
+      'run `thread attach <package>` — it appends any row that has gone and skips every row already there, so one command restores the list without touching what the app added',
+    wrong: "const M: Threaded = {\n  declares: [],\n}",
+    right: `const M: Threaded = {\n  declares: [\n    {\n      at: 'node_modules/${named('ui')}/dist/tokens/colour.js',\n    },\n  ],\n}`,
+    cites: [
+      { on: '2026-08-21', said: 'users can create new elements freely, but they can\'t delete the ones that exist (build error) and they can\'t just add them in place or create a file, first they must declare in the SSOT' },
+      { on: '2026-08-22', said: 'KISS and make sure this is not a dead beat law. Make sure we have a way to fix with one command.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_missing_row.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I want you to transform every single thing that currently is a check into a law.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'no-such-command',
+    at: './constraint.ts',
+    describes: 'The refusal of a row promising a script this repository does not have — otherwise the promise breaks only when somebody runs the gate, only at the step that names it, and only after every step before it has already passed.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a `runs` or `by` naming a script this repository does not have',
+    because:
+      'the gate is the commands these name, so one that package.json lacks fails as `Command "nope:check" not found` at the moment it is reached — after every step before it has already run, and only when somebody runs the gate. Measured 2026-08-14: sixteen rows name sixteen commands and nothing has ever compared them against package.json; they are correct today by nobody having mistyped one',
+    instead: 'add the script to package.json, or fix the name. A row naming a command is a promise that the command exists',
+    wrong: "const M = {\n  runs: 'pnpm nope:check',\n}",
+    right: "const M = {\n  runs: 'pnpm typecheck',\n}",
+    cites: [{ on: '2026-08-14', said: 'I think you need to study how a file gets parented and make proper error handling for everything. No at is just one.' }],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_such_command.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-14', said: 'I think you need to study how a file gets parented and make proper error handling for everything.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'unpaired-slopnator',
+    at: './constraint.ts',
+    describes: 'The refusal of half a rule — a row without the function that enforces it, or a function no row threaded — because nothing but their names holds the two together, so either half can go missing while the other reads as working.',
+    version: 1,
+    where: { paths: ['threads/', 'thread/integrity/slopnators/'], except: ['_generated/'] },
+    bans: 'a rule naming a slopnator that is not on disk, and a slopnator in the slopnators directory that no rule names',
+    because:
+      'a rule is a row and a slopnator is a function, and nothing but their names holds the two together — so either half can go missing and the other reads as working. A rule whose slopnator is absent registers, loads, reports nothing, and is indistinguishable from a rule being obeyed. A slopnator no rule names is code that runs in no gate and governs nothing, while looking like enforcement to anybody reading the directory. Measured 2026-08-15: this rule was real and enforced, but it lived as a gate step in ci.ts rather than as a rule — one more place where a guarantee could be turned off by editing a list, which is the thing the rules exist to stop. Moving it here deletes the step rather than adding a check',
+    instead: 'write the rule that needs the slopnator, or delete the slopnator. `pnpm slopnator:seed` writes the scaffold for a rule that has none, and a rename is a `git mv` rather than a second file',
+    wrong: "const CONSTRAINTS = [\n  {\n    id: 'nothing-names-this-slopnator',\n  },\n]",
+    right: "const CONSTRAINTS = [\n  {\n    id: 'no-comment',\n  },\n]",
+    cites: [
+      { on: '2026-08-14', said: 'A law is written, names a slopnator. Slopnator is seeded magically. Someone write the function. An enforcer picks it up and it just works.' },
+      { on: '2026-08-15', said: 'Does a slopnator without a law or a law without a slopnator exist? This should be an error....' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unpaired_slopnator.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-15', said: 'Does a slopnator without a law or a law without a slopnator exist? This should be an error....' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'twice-meant',
+    at: './constraint.ts',
+    describes: 'The refusal of one word carrying two meanings — the glossary holds a single row per word and takes it from the `describes` beside the id, so rows that disagree leave the meaning decided by whichever the slopnator reached first.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/'] },
+    bans: 'two rows coining the same id while stating different `describes`',
+    because:
+      'the glossary is derived: a word\'s meaning is the `describes` on the row that coins it, so a word coined twice with two descriptions has two meanings and the file can hold one. Repetition is not the defect — measured 2026-08-15, the tree coins `slopnator` on twelve rows and `trial` on twelve, deliberately, because the founder asked for the category in the glossary rather than each instance under its own name. Disagreement is the defect: those same twelve rows each stated a different sentence, so the tree asserted twelve meanings for one word and nothing looked. Five words were split this way — `slopnator`, `trial`, `ci`, `build` and `glossary` — and three of them were the same sentence written twice, which is the SSOT failure wearing a second coat',
+    instead:
+      'state the category meaning on every row that coins the word, because the word is what the row names. Where two rows describe the same file from different heights, the row that declares it wins and the node repeats it. Where a row needs to say something only true of its own instance, it needs its own id — and if you do not want that word in the glossary, the sentence does not belong on the row',
+    wrong: "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'A different thing entirely.',\n    },\n  ],\n}",
+    right: "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n  ],\n}",
+    cites: [
+      { on: '2026-08-15', said: 'the ids thing. We can\'t have that, the id\'s being the same.' },
+      { on: '2026-08-15', said: 'Each row IS it\'s category. So, doesn\'t the describe in the law declaration in integrity it\'s own means? cause the word is the id in it\'s declaration no? In the threader interface.' },
+      { on: '2026-08-15', said: 'Yes, rows carry category meaning. No individual ids.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_twice_meant.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-15', said: 'Yes, rows carry category meaning. No individual ids.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'derived-drift',
+    at: './constraint.ts',
+    describes: 'The refusal of a generated file that is no longer the bytes its generator writes, and of a byproduct naming no command to write it — either way the file is a hand edit wearing a generated name, and every reader downstream believes the wrong one.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a derived file that is not the bytes its generator writes, and a `derives` row naming a file no row states both a `by` and a `runs` for',
+    because:
+      'a derivation is only worth the name while running it again produces what is on disk — the moment the two differ, the file is a hand edit wearing a generated file\'s name, and every reader downstream believes the wrong one. Measured 2026-08-15: five derivations each carried their own `:check` command as a separate gate step, so the rule was stated five times and nowhere. Measured again 2026-08-15, after this rule existed: the tree holds twenty `derives` rows and this slopnator read five — a row missing `by` or `runs` was dropped at the `if` that collected it, so fifteen declared derivations were never compared to anything and the rule reported zero findings over them. The file they all name survived only because a sixteenth row elsewhere happened to carry the command; delete that one row and fifteen go dark with nothing saying so. `permissions.deny` stops an agent editing a derived file; nothing stopped a shell, a merge, or a row that never named a generator at all',
+    instead:
+      'run the generator the row names in `by` and commit what it writes. Never edit the file — a derived file has no author, and an edit to one is a change to the generator that somebody skipped. Where many rows name one derived file, at least one of them must state the `by` that writes it and the `runs` that proves it',
+    wrong: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm nope:check',\n    },\n  ],\n}",
+    right: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm gate:check',\n    },\n  ],\n}",
+    cites: [
+      { on: '2026-08-15', said: 'You\'ll take the checks that exist, make them into laws that derive the exact same checks. The laws create ALL things that check stuff. I do not want multiple sources of truth for anything.' },
+      { on: '2026-08-15', said: 'So slopnators should have kinds. walk, check, whatever else it needs so it works.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_derived_drift.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-15', said: 'make them into laws that derive the exact same checks' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'undeclared-crossing',
+    at: './constraint.ts',
+    describes: 'The refusal that makes a declared operation the only thing that can act — the network, the clock, randomness, the queue and files are reachable from a workflow node or a view and from nowhere else, so everything an app does is something it declared it would do.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/', '_threads/', 'thread/'] },
+    bans: 'a boundary crossing written outside a declared node — the network, the clock and its timers and its animations, randomness, the queue or files',
+    because:
+      'the trial, the replay, the trace, the cost record and the compensation all hang off a declared node, and a crossing written beside one has none of them: it cannot be replayed because nothing recorded it, cannot be retried because nothing owns it, cannot be priced because it left no record, and cannot be unwound because no compensation names it. A `fetch` in a screen is not a smaller operation than a workflow — it is an operation the app cannot see, and the page renders fine either way, which is why nothing catches it without a rule. The clock and randomness belong here for the same reason a network call does: a run that reads `Date.now()` cannot be replayed, so a trial over it proves nothing and passes. A timer is the clock scheduled rather than read, and it is refused by the same row rather than a second one: it re-renders on a schedule nothing declared, and a rule naming only `setInterval` leaves the self-rescheduling `setTimeout` behind, which is an interval wearing a different name. `element.animate()` is the same clock again, and the worst of them, because it takes its own duration and its own easing curve as arguments: every other crossing borrows a value from somewhere, and this one invents a whole motion vocabulary in place, past every `motion` and `ease` row the style guide holds. Measured 2026-09-02: three compositions in one app each hard-coded `cubic-bezier(0.2, 0, 0, 1)` and 180 or 200 milliseconds, while the same app declared 25 animations and named one of them anywhere',
+    instead:
+      'declare the node, name the seam it needs, and write the crossing in its body — or read through a declared view, which is the other half of what may act',
+    wrong: "const res = await fetch('https://api.stripe.com/v1/charges')",
+    right: "{ id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
+    cites: [
+      { on: '2026-08-16', said: 'The ones most important are the ones that enforce UI through elements and screens, and the ones that enforce that the only things that can operate are workflows and views.' },
+      { on: '2026-08-16', said: 'No operation without a workflow or view.' },
+      { on: '2026-08-16', said: 'And make it ubiquitous.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_crossing.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-16', said: 'No operation without a workflow or view.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'hardcoded-style',
+    at: './constraint.ts',
+    describes:
+      'The refusal that keeps the compiler a translator. The style guide, the fonts, the animations and the icons hold the values; CSS is what one of those means said in another language, and a generator is the sentence that carries it across. So a generator may know that a thing becomes `background` and may not know what colour that is. Nothing else in this repository looks here — a row is checked, a variant is checked, an element is checked, and the strings a generator itself emits are checked by nobody. This reads them, and answers on any value typed in rather than taken from the sheet that owns it.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/', 'dist/', '_threads/', 'slopnators/'] },
+    bans: 'a value typed into the compiler where a sheet should have supplied it — a CSS declaration whose value is neither the name of a row nor derived from one',
+    because:
+      'a value lives in exactly one sheet and everything reads it from there, so a value typed into the compiler is outside that system while sitting at its centre: it survives a rebrand, ignores every mode and theme, answers to no command, and no sheet knows it exists. It is also the one hardcoding no other law can see — the raw-value refusal reads what a ROW states, and this is written where nothing states anything.',
+    instead:
+      'take it from the sheet that owns it: name the row, `var(--colour-page)` rather than `#f8fbfa`, or derive it the way `color-scheme` is derived from the modes an app declares. The property and the selector are the translation and are the compiler\'s; the value never is.',
+    wrong: "lines.push('  body {', '    background: #f8fbfa;', '  }')",
+    right: "lines.push('  body {', '    background: var(--colour-page);', '  }')",
+    cites: [
+      { on: '2026-09-03', said: 'You are probably trying to fucking game my system. Trying to bring css to the elements, to the fucking framework. Unacceptable.' },
+      { on: '2026-09-03', said: 'Then the first thing we must do is make sure that nothing in the compiler can EVER hardcode a value. You are breaking the compiler so it can NEVER FUCKING DO THIS.' },
+      { on: '2026-09-02', said: 'It shouldn\'t match any CSS rule because it should never speak CSS.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_hardcoded_style.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-09-03', said: 'nothing in the compiler can EVER hardcode a value' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'undeclared-destination',
+    at: './constraint.ts',
+    governs: 'navigation',
+    describes: 'The refusal that makes the map the whole of where an app can go — a screen is reached by naming it, so every destination is one the map declares and a link nobody declared cannot exist.',
+    version: 1,
+
+    where: { paths: ['.'], except: ['app/_generated/', 'thread/ui/elements/'] },
+    bans: 'a destination reached without naming a declared screen — an `href`, a `window.location`, or a push, replace or prefetch on a router, a navigation or a history',
+    because:
+      'the map island holds the screens and the links between them, and everything that reasons about where an app can go reads `island.links`: `checkMapIsland` refuses a link naming a screen nothing declares, two screens answering one path, a link from a screen to itself and an app with no `entry`, and `orphanScreens` finds every screen no link reaches. Five checks, all of them blind to a destination reached another way — an `href` is not a link the island holds, so the screen it points at reads as unreachable, the app reads as having no path to it, and the page renders and navigates correctly. That is the whole failure: the map is not what the app does, it is what the app declared it does, and the two only stay the same thing if there is no second way to move',
+    instead: 'name the screen — `navigateTo="Order"` — and let the map carry the destination, so a link exists in the island that reasons about links',
+    wrong: '<a href="/orders/42">{label}</a>',
+    right: '<Link.label navigateTo="Order" labelKey="order.title" />',
+    cites: [
+      { on: '2026-08-16', said: 'The ones most important are the ones that enforce UI through elements and screens, and the ones that enforce that the only things that can operate are workflows and views.' },
+      { on: '2026-08-16', said: 'But they must be app wide.' },
+      { on: '2026-08-16', said: 'And make it ubiquitous.' },
+      { on: '2026-08-16', said: 'Here\'s a new law I need you to add: No island without law.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_destination.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-16', said: 'The ones most important are the ones that enforce UI through elements and screens' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'undeclared-operation',
+    at: './constraint.ts',
+    describes: 'The refusal that keeps a dispatched name answerable to a declaration — a name handed to dispatch is a string like any other, so one that names nothing, or one assembled while the program runs, reaches for an operation that does not exist and fails in front of a person rather than where it was written.',
+    version: 1,
+
+    where: { paths: ['.'], except: ['app/_generated/', 'thread/operations/', 'thread/ui/'] },
+    bans: 'dispatch handed a name nothing declares, or a name this file does not write down',
+    because:
+      'measured 2026-08-25: nothing anywhere holds a dispatched name against a declaration. `packages/ui/src/bindings.tsx` exposes `run(workflow: string, input?)`, and that workflow is a bare string passed to a context the UI package never sees — so a name that matches no operation reaches the browser and fails at whatever the host does with an unknown id. The second half is measured from the other side: `dispatch` in packages/core/operations/src/dispatch.ts takes an Operation object rather than a name, so no shipped call site names an operation as a string at all, and the only place a name was written down was that `run`. Measured again the same day, after `packages/ui/src/bindings.tsx` was deleted: `dispatch` is now a seam on the UI config, named once, handed a name — so from here on a dispatched name is always written where it can be read, and this rule is what holds it to a declaration. A name assembled at runtime is the same hole with a lid on it — it reads from every check exactly like a name that was checked and found',
+    instead:
+      'write the name where it can be read, and declare the operation it names — `dispatch(\'wf_send_invoice\')` against a row whose `at` is `operations/wf_send_invoice.ts`. Where the name genuinely varies, the choosing belongs in the declaration, not in a template string',
+    wrong: "dispatch('wf_not_declared')",
+    right: "dispatch('wf_send_invoice')",
+    cites: [
+      { on: '2026-08-25', said: 'And make sure the composition can only dispatch existing operations.' },
+      { on: '2026-08-25', said: 'Yes — reading a view is dispatching too' },
+      { on: '2026-08-25', said: 'Let\'s pretend dispatch is a magic thing like I say it is, and remove bindings cause that\'s just a way to avoid using dispatch.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_operation.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-25', said: 'And make sure the composition can only dispatch existing operations.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'undeclared-variant',
+    at: './constraint.ts',
+    describes: 'The refusal that leaves a variant row as the only thing deciding what an element may wear — a member written on an element is a name nothing checks against anything, so one that was never declared, or one declared for a different element, renders carrying a class the stylesheet never writes and reads on screen as lost styling rather than a missing declaration.',
+    version: 1,
+
+    where: { paths: ['.'], except: ['app/_generated/'] },
+    bans: 'an element wearing a member that no variant row declares, or that a variant row declares for a different element',
+    because:
+      'measured 2026-08-25: the founder wrote `<Button.primary text="translation.key" />` as the shape a composition takes, and the fourteen variants in packages/ui/src/variants.ts hold no row `primary` — the one that fits is `button-primary`. `element()` in packages/ui/src/wrappers.tsx resolves any member through a proxy, so that call renders a button carrying the class `thread-primary`, which the stylesheet generator never writes because no variant of that name exists to write it from. It renders, it is unstyled, and nothing in the repository says a word. The pairing half is the same hole from the other side: `card` declares fifteen elements that wear it and `Button` is not among them, and nothing stops `<Button.card />` either. Both are the silent-pass shape — a check reporting success because it measured nothing',
+    instead:
+      'declare the variant, and name the element in that row\'s `wears` — the row is what makes the pairing legal, which is why `<Button.buttonPrimary />` holds and `<Button.primary />` does not',
+    wrong: '<Button.primary />',
+    right: '<Button.buttonPrimary />',
+    cites: [
+      { on: '2026-08-25', said: 'Variants themselves declare what elements they relate to, in their declarations. Then the composition says button.primary and if that matches the combination of variant and element it\'s acceptable.' },
+      { on: '2026-08-25', said: 'If there\'s no primary variant.....that\' an error moron. Didn\'t I said that it can\'t name a variant that doesn\'t exist?' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_variant.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-25', said: 'Variants themselves declare what elements they relate to, in their declarations.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'undeclared-element',
+    at: './constraint.ts',
+    governs: 'elements',
+    describes: 'The refusal that makes the element catalogue the only thing an interface is built from — a lowercase tag is HTML written in place: it wears no declared style, sits in no catalogue, and is the one shape that renders like an element while being invisible to everything that reads what an app is made of.',
+    version: 1,
+
+    where: { paths: ['.'], except: ['app/_generated/', 'thread/ui/'] },
+    bans: 'a host element — any lowercase-initial tag, not only `<div>` — written anywhere in an app',
+    because:
+      'a host element carries neither `category` nor `style`, which are the two fields `ElementSchema` offers and the only places a look is declared, so the style guide cannot show it, a rebrand cannot move it and an overlay cannot vary it — it renders correctly and is absent from every derivation that reads the catalogue, which is why nothing catches it without a rule. Measured 2026-08-16: the rule that refused this was already written, 113 rows naming every HTML tag down to `<wbr>`, held in a book of app rules that nothing in this repository imported — its only mention anywhere was a tree row stating its address, and the book was deleted on 2026-08-17. Enumerated to the last tag, consumed by nothing, refusing nothing: the same shape a check takes when it measured zero files. This one governs the whole app rather than the screens directory, because a host element written in a composition ships to a screen either way',
+    instead:
+      'declare the element in the elements island and write the member that wears its look — `<Box.card>` — using the declared groupings `Column`, `Stack` and `Box` wherever a host element would have gone',
+    wrong: '<div><Box.card /></div>',
+    right: '<Column><Box.card /></Column>',
+    cites: [
+      { on: '2026-08-16', said: 'The ones most important are the ones that enforce UI through elements and screens, and the ones that enforce that the only things that can operate are workflows and views.' },
+      { on: '2026-08-16', said: 'But they must be app wide.' },
+      { on: '2026-08-16', said: 'And make it ubiquitous.' },
+      { on: '2026-08-16', said: 'Here\'s a new law I need you to add: No island without law.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_element.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-16', said: 'The ones most important are the ones that enforce UI through elements and screens' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'unpaired-member',
+    at: './constraint.ts',
+    describes: 'The refusal of half a member — a row that seeded no file, or a file no row brought into existence, so nothing an island governs can exist that was not declared first.',
+    version: 1,
+    where: { paths: ['threads/', 'operations/', 'entities/'], except: ['_generated/'] },
+    bans: 'a member declared in an island\'s tree file whose file is not on disk, and a file in an island\'s folder that no row declares',
+    because:
+      'a member is added by declaring it and then written, never the other way round — the same order a rule follows to its slopnator, and for the same reason: the row is what everything downstream reads, so a file that arrived without one is a thing the runtime, the API, the agent tools and the trials have all never heard of, while it sits there able to act. The two halves are held together by nothing but a name, so either can go missing and the other reads as working. Absence is the finding in both directions because there is no third place to look: the rows are what exists, the folder is what was written, and any gap between them is one somebody has to close on purpose. The rule reaches by shape and not by name — it reads every island that seeds its members from the tree, so an island added tomorrow is governed without editing this row',
+    instead:
+      'add the row to the island\'s tree file first and run `pnpm member:seed`, which writes the file that row brings into existence — then write the member into the template it left',
+    wrong: "export const OPERATIONS: readonly Member[] = [\n  {\n    id: 'wf_nothing_seeded_this',\n  },\n]",
+    right: "export const OPERATIONS: readonly Member[] = []",
+    cites: [
+      { on: '2026-08-17', said: 'FIRST we add the new row in workflows.ts, which seeds a new wf_{id} file in a workflows folder.' },
+      { on: '2026-08-17', said: 'The file is not authored but seeded. We can write the operation after, but it must have a template with instructions maybe of how to build. Like slopnators.' },
+      { on: '2026-08-17', said: 'No wf_ without a row in workflows.ts' },
+      { on: '2026-08-17', said: 'Apply the EXACT SAME MODEL as workflow to entities. Should literally be mirrors in how they operate, with laws and all that shit.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unpaired_member.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-17', said: 'No wf_ without a row in workflows.ts' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'unversioned',
+    at: './constraint.ts',
+    describes: 'The refusal that makes a governing declaration say which one it is — anything other things must conform to states a version, so a change to it is a diff a consumer can see and a gap something can be carried across.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'slopnators/', 'docs/', 'AGENTS.md'] },
+    bans: 'a declaration that governs and states no version — a node annotated `Threaded` or an interface extending it, and an island schema pinning no `specVersion`',
+    because:
+      'a version is not bookkeeping, it is the only thing that makes an update mechanical rather than archaeological: without it a consumer built against an older shape is indistinguishable from one built against this shape, so nothing can decide whether to migrate and nothing can tell what changed. The mechanism to carry a declaration forward already exists and has never been usable — `packages/core/spec/src/codemods.ts` holds the chain from one grammar version to the next and its own row says the chain is empty, because there was never a second version to carry anything to. Measured 2026-08-17: twelve of the thirteen island schemas pin a `specVersion` and `RegistryIslandSchema` pins none, so one kind of declaration was already unversioned and nothing said so; and the whole of `threads/` — the root, four metas, and every rule that governs a path — stated no version at all. This is the one rule that governs the governors, which is why it reaches by annotation rather than by naming them: a meta added tomorrow is covered without editing this row',
+    instead: 'state a `version` on the node, and a `specVersion` on the island schema — one integer, raised when what it governs changes shape',
+    wrong: "export const M: Threaded = { id: 'a-meta', at: 'threads/integrity.ts', describes: 'What it is and what it solves.' }",
+    right: "export const M: Threaded = { id: 'a-meta', at: 'threads/integrity.ts', describes: 'What it is and what it solves.', version: 1 }",
+    cites: [
+      { on: '2026-08-17', said: 'We should add a law that everything must be versioned right? So we can properly update things and do diffs.' },
+      { on: '2026-08-17', said: 'The things that govern other things, we need those to be versioned. Islands, laws, thread.ts, metas....everything that governs other things.' },
+      { on: '2026-08-17', said: 'make it universal for thread related stuff' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unversioned.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-17', said: 'The things that govern other things, we need those to be versioned.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'declared-elsewhere',
+    at: './constraint.ts',
+    describes: 'The refusal that makes an island the only place its kind is declared — one rule for every island, reading what each one governs, so a kind added tomorrow is enforced the moment its row exists.',
+    version: 1,
+    where: { paths: ['.'], except: ['AGENTS.md', '_generated/', 'slopnators/', 'threads/', 'docs/'] },
+    bans: 'a declaration of a kind an island governs, written anywhere but where that island governs',
+    because:
+      'the loader opens the paths an island governs and nothing else, so a declaration written beside the code that needs it is not a smaller declaration — it is no declaration, and every surface downstream reports success over it: it typechecks, the editor completes it, and the generator emits nothing. This is one rule rather than one per island because the rule never differed — measured 2026-08-17: the same sentence was written eleven times, and the island-to-path fact it depends on appeared 130 times across 56 authored files, so eleven copies of a rule drifted against a fact stated everywhere. Here the island states what it governs once, and the slopnator reads it. The call it looks for is read out of the island itself rather than derived from its name, because no convention survives contact with the real set: `sql` exposes `defineSqlFunctions` and `navigation` exposes `defineMap`. An island that governs only folders is one whose kind is derived and authored nowhere, so the call is refused everywhere — which is what `AUTHORED_MAP` did for the map at build.ts:150, now stated on the island instead of in the CLI',
+    instead: 'declare it in the file the island governs, and import it where it is needed',
+    wrong: "export default definePermissions({ specVersion: 1, entities: [{ entity: 'ent_order' }] })",
+    right: "import permissions from 'app/_declare/permissions'",
+    cites: [
+      { on: '2026-08-17', said: 'If there\'s something that is govern by an island but it\'s propelry done through island, error.' },
+      { on: '2026-08-17', said: 'Each island governs it\'s thing. Laws make sure that this is true and no island is inert.' },
+      { on: '2026-08-16', said: 'EVERYTHING must be SSOT. Why? Because AIs are lazy and they want to create things in place.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_declared_elsewhere.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-17', said: 'Each island governs it\'s thing.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'inert-island',
+    at: './constraint.ts',
+    describes: 'The refusal that makes an island state its own authority — an island that governs nothing is a shape nothing is held to, and the rule about where its kind may be declared cannot be written at all.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'an island that states nothing it governs',
+    because:
+      'what an island governs is the one fact about it that nothing else can supply. It is not derivable from the island\'s name — measured 2026-08-17: `navigation` governs `app/screens/` and its schema lives in `map.ts`, and `sql` exposes `defineSqlFunctions`, so two of thirteen break any convention a generator could apply. Stated as nothing, the rule that refuses a declaration elsewhere has no elsewhere to refuse: no file is the place its kind belongs, which makes every file the place. The island still parses, still typechecks, still appears in the tree, and governs nobody — inert rather than absent, which is the harder kind to notice',
+    instead: 'state what the island governs — a file where its kind is declared, or a folder whose implementation it governs',
+    wrong: "const M: Islanding = { declares: [{ id: 'events', at: 'packages/core/spec/src/islands/events.ts' }] }",
+    right: "const M: Islanding = { declares: [{ id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['app/_declare/events.ts'] }] }",
+    cites: [
+      { on: '2026-08-17', said: 'An island extends threader. It declares what it governs.' },
+      { on: '2026-08-17', said: 'If there\'s an island that doesn\'t state what it governs, error.' },
+      { on: '2026-08-17', said: 'An island governs either folders or file types or implementation.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_inert_island.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-17', said: 'no island is inert' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'unnamed-island',
+    at: './constraint.ts',
+    describes: 'The refusal that stops an island arriving as a file — a schema the tree does not name states what an app may say while nothing states where it may say it, so the kind is declarable and every rule about it is absent.',
+    version: 1,
+    where: { paths: ['.'], except: ['AGENTS.md', '_generated/', 'slopnators/', 'threads/', 'docs/'] },
+    bans: 'a module exporting an island schema that no row in the tree names',
+    because:
+      'an island is a kind an app may declare, and adding one by writing a file is how a kind arrives with no rule attached — the schema parses, the loader can be pointed at it, and nothing anywhere says which file its declarations belong in. This is the guarantee that has to hold when a package contributes an island rather than the framework: a file alone cannot create a kind, because the row is what carries what it governs, and what it governs is what every rule about it reads. Absence is the finding here for the same reason it is in `unthreaded` — whatever the descent never reaches is not wired, and a schema nobody named is a kind nobody governs',
+    instead: 'name it from the row that owns it, stating what it governs — or delete the schema, because a kind with no rule is not a kind',
+    wrong: 'export const ThingIslandSchema = z.strictObject({ specVersion: z.literal(1) })',
+    right: 'export const ThingSchema = z.strictObject({ name: z.string() })',
+    cites: [
+      { on: '2026-08-17', said: 'If there\'s an island that doesn\'t extends threader, error.' },
+      { on: '2026-08-17', said: 'An island extends threader. It declares what it governs.' },
+      { on: '2026-08-16', said: 'other packages must be able to contribute both islands AND laws that governs their islands' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unnamed_island.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-17', said: 'If there\'s an island that doesn\'t extends threader, error.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'ungoverned-island',
+    at: './constraint.ts',
+    describes: 'The refusal that keeps a rule about a kind that exists — a rule naming an island the tree does not declare is a rule about nothing, and it reads as coverage of a kind nobody can declare.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a rule whose `governs` names an island the tree does not declare',
+    because:
+      'a rule that names a kind nobody declares is the most convincing kind of gap: somebody can point at the rule, the plugin registers it, the trial passes, and the thing it governs does not exist. It is the mirror of the silent pass — enforcement over an empty set. This rule used to refuse the other direction too, an island no rule named, and that direction retired on 2026-08-17 when the eleven per-island placement rules collapsed into `declared-elsewhere`: one rule reading what each island governs, so a kind added tomorrow is enforced the moment its row exists. What was checked became structural, and a check that can no longer fail is a check worth deleting rather than keeping for the shape of it',
+    instead:
+      'name an island the tree declares, or drop the `governs` — a rule about a kind nobody can declare is a rule about nothing',
+    wrong: "export const L: Constraint = {\n  id: 'a-rule',\n  governs: 'no-island-by-this-name',\n}",
+    right: "export const L: Constraint = {\n  id: 'a-rule',\n  governs: 'entities',\n}",
+    cites: [
+      { on: '2026-08-16', said: 'Here\'s a new law I need you to add: No island without law.' },
+      { on: '2026-08-16', said: 'So also we need a "law doesn\'t match island" if this is to be done entirely by hand so we catch drifts.' },
+      { on: '2026-08-16', said: 'NOTHING can exist that has no island for the things island govern.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_ungoverned_island.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-16', said: 'Here\'s a new law I need you to add: No island without law.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'no-barrel',
+    at: './constraint.ts',
+    version: 1,
+    describes: 'The refusal that stops a file existing to list what exists — a barrel says a name is there while the tree already says what it is, so the two drift apart and no import names the file anything came from.',
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/'] },
+    bans: 'a barrel — a file named index.ts, and any file whose whole content is re-exports',
+    because:
+      'the tree already answers what exists and what each thing is for, so a barrel is a second answer that goes stale on its own. Measured 2026-08-18: packages/core/spec/src/islands/index.ts held seventeen `export *` lines and was hand-edited four times in one session to drop islands that had been deleted, and derived-drift caught it only once the glossary stopped masking it. That same file made `islands.X` the import at 454 sites across 11 packages, so not one file said which islands it used and the dependency graph could not be read from the imports at all. every package here already ships with no barrel: one line of package.json exports maps every file to its own path, measured 2026-08-27 across all eight',
+    instead: 'export from the file that holds the thing, and let package.json carry a wildcard exports map so every file is importable at its own path. The tree is where you look to see what exists',
+    wrong: "export * from './one'\nexport * from './two'\nexport * from './three'\n",
+    right: 'export function coined(word: string): string {\n  return word.trim()\n}\n',
+    cites: [
+      { on: '2026-08-18', said: 'another barrel. You love barrels huh. You love files that hold lists. why?' },
+      { on: '2026-08-18', said: 'We do not need a file that holds a list. This is slop. Makes no sense to have a file that exists only to list what exists....what the fuck is this? Remove. Delete.' },
+      { on: '2026-08-18', said: 'Add a new law: no barrels allowed. Block any file named index.ts at write time and compile and every sort of error' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_barrel.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-18', said: 'no barrels allowed' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'inert-slopnator',
+    at: './constraint.ts',
+    version: 1,
+    describes: 'The refusal of a slopnator that was seeded and never written — the file exists, the pair looks complete, and the rule it belongs to enforces nothing.',
+    where: { paths: ['threads/slopnators/', 'thread/integrity/slopnators/'] },
+    bans: 'a slopnator still returning `NOT_WRITTEN`, or one whose `proves` states nothing it refuses',
+    because:
+      'seeding creates exactly this state on purpose: the row exists, the file exists, and `unpaired-slopnator` is satisfied because it asks only whether the file is there. Between the seed and the slopnator being written, the pair reads as complete from every direction. Measured 2026-08-19 in a fresh app with one rule declared and its slopnator seeded: the only thing that refused was a hand-written `throw` inside `defineLaw`, which reaches only the surfaces that call it, is counted by no report, and named `packages/core/integrity/src/slopnators/` and `pnpm slopnator:seed` — a directory and a command that do not exist in an app. A refusal that lives in one function instead of a row is the second enforcement mechanism this system exists to not have',
+    instead: 'write the slopnator — replace the `NOT_WRITTEN` return with what it looks for, and fill `proves` with at least one form it refuses and one it accepts. If the rule was a mistake, delete the row and the file together',
+    wrong: "export const slopnator: Slopnator = {\n  on: [],\n  holds: () => NOT_WRITTEN,\n  proves: { wrong: [], right: [] },\n}",
+    right: "export const slopnator: Slopnator = {\n  holds: (_node, at) => at.text.includes('console.log') && 'a console.log',\n  proves: { wrong: ['console.log(1)'], right: ['const held = 1'] },\n}",
+    cites: [
+      { on: '2026-08-19', said: 'No inert slopnator. So when someone adds a rule or law, it immediately shows when a slopnator is inert, or without anything written, any body or code.' },
+      { on: '2026-08-19', said: 'Then on seed, we have this other state which is a blank slopnator, also not acceptable.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_inert_slopnator.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-19', said: 'No inert slopnator.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'no-child-process',
+    at: './constraint.ts',
+    version: 1,
+    describes: 'The refusal of a slopnator that can start a process — enforcement is one process reading files, and a slopnator that shells out can be re-entered by whatever it starts.',
+    where: { paths: ['threads/slopnators/', 'thread/integrity/slopnators/'] },
+    bans: 'a slopnator importing `node:child_process`, by any spelling',
+    because:
+      'measured 2026-08-19, twice, on the founder\'s machine: `derived-drift` spawned every command a `derives` row named, one of which was `pnpm trial:try`, which runs the trial for `derived-drift`, which spawned `pnpm trial:try` again. Six-way branching, unbounded depth, each level a fresh process holding the whole engine. Killing the parent did nothing because the children were already orphaned to launchd, and the machine ran out of memory and had to be restarted — twice, an hour apart, from one inverted filter. No comparable tool does this: eslint, semgrep, clippy and ruff are each a single process. The recursion was possible only because a slopnator was allowed to start something, so the rule is about the capability rather than about any one slopnator that misused it',
+    instead: 'read what you need in this process. If a slopnator cannot see something without running a command, that command is a gate step, declared once and run once in the chain — not a slopnator that fires on every sweep and every file written',
+    wrong: "import { spawnSync } from 'node:child_process'",
+    right: "import { readFileSync } from 'node:fs'",
+    cites: [
+      { on: '2026-08-19', said: 'this last thing you did killed my mac. It spawned infinite number of processes called node which each took around 75mb, and they killed my memory, my ram, my disk. DO NOT DO THIS AGAIN.' },
+      { on: '2026-08-19', said: 'You can put a the no node child thing in place already. Make it real.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_child_process.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-19', said: 'You can put a the no node child thing in place already.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'no-dispatch-bypass',
+    at: './constraint.ts',
+    describes: 'The refusal of a second way in — anything done with an imported operation other than handing it to `dispatch`, so identity, rate, replay, input, quota and rules end up decided by whoever happened to hold the object.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'thread/operations/'] },
+    bans: 'reaching into an imported operation, calling it, or passing it anywhere but `dispatch`',
+    because:
+      'measured 2026-08-22: nothing stopped it, and the tree said otherwise. The `dispatch` row this framework writes into every app states "a way to run that did not come through here does not exist", and the glossary publishes that sentence as the meaning of the word — while any file could `import { operation }` from a body and call `run` directly, skipping six gates in one line. A promise a tree makes about itself and cannot keep is worse than one it never made, because everything downstream reads the promise. Measured again 2026-08-24: the refusal read one form only, `… from \'<relative path>\'`, so three ways in were invisible — `await import(...)`, `createRequire(...)(...)`, and a path written from the tree root rather than from the file. Each was tried against a real tree and each passed unremarked. Measured a third time 2026-08-25: reading the BODY\'S ADDRESS still left a way in, because a body\'s address does not have to appear anywhere — `await import(\'../operations/\' + name + \'.ts\')` writes only a fragment, and a sweep over a real tree reported that file once, for being unthreaded, and not at all for this. So what is read is the DIRECTORY, not the file in it: an operation is seeded under `operations/`, dispatch reaches it by building the path at run time from the row and never writes it down, and everything else that gets there has to write a path pointing in — whole, or in pieces. Two things are not reached, and neither is an exception to the rule: dispatch, because it writes no such path, and the `at` of a row, read off the syntax tree rather than off the text, because naming a child is what an `at` is for and it is the one place the address belongs. The directory has to be read with its separator. Reading a bare `operations` as well fired on `id: \'operations\'` — the word this whole system is named after, sitting in the row that declares it — in both tree files at once, and the first reading of that misfire blamed the `at` exclusion and replaced it with a weaker one that matched `at:` as text. Nothing was wrong with the `at` exclusion; a word is not a path until it has a slash in it. Measured 2026-08-25, after dispatch was changed to take the operation itself instead of its name: this reading is now behind the rule it states. A caller has to import the body to hand it over, so the one sanctioned call site writes a path into `operations/` and is refused, while the deliberate bypass beside it writes the identical string — the reading cannot tell them apart, and a check that refuses the right answer and the wrong one alike is deciding nothing. What has to be read is what a file DOES with the operation, not whether it named the file: handing it to dispatch is the whole of a caller, and touching what it holds is the finding. Rewritten the same day: the reading is now over USE, not over paths. A file may import an operation — there is no other way to hand one over in this language — and the only thing it may then do with the binding is pass it to `dispatch`. Reaching into it, calling it, or passing it anywhere else is the finding, read off the syntax tree: a member access on the binding, a call whose callee is the binding, or the binding as an argument to anything that is not dispatch. Type-only imports bind nothing that can run and are skipped. Measured against a real tree the same day: the sanctioned caller, which imports the body and hands it to dispatch, is quiet, and the probe beside it, which imports the identical body and reaches into it, fires — the same two files the path reading refused alike. Measured 2026-08-28, after the founder said "I have no interest in shipping the framework. This is just scaffolding": dispatch moved, and its name did not. It was a value imported from `@thread/operations`, which is how ~900 lines of this framework ended up inside every artifact an app shipped; it is now the app\'s own `operations/_dispatch.ts`, written by `thread compile` — the same nine checks in the same order, emitted rather than imported. The first attempt at this renamed it to `gate`, and a real app refused that in two ways within one run of `thread gate`: `gate` was already coined by the command of that name, so the glossary held one word with two meanings, and the emitted file carried explanatory comments, which `no-comment` refuses in an app. Both were the same mistake — changing more than the ask needed. What this rule refuses did not change, the reading did not change, and the word a caller writes did not change. Only the import specifier did',
+    instead: 'hand `dispatch` the operation and let it run. Handing it over is the whole of what a caller does; reaching into what it holds — calling the function it compiled to, reading what it requires — is reaching past every gate the operation sits behind',
+    wrong: "import { operation } from './operations/wf_send_invoice.ts'\n\nawait operation.run(hands, held)",
+    right: "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nawait dispatch(operation, input, actor, seams)",
+    cites: [
+      { on: '2026-08-17', said: 'That way we can enforce how things run, and they can only run through dispatch.' },
+      { on: '2026-08-17', said: 'when something wants to run an operation (meaning an invoke), it\'s a simple, direct, dispatch(wf_) or dispatch(agt_) and it just works, it just runs, and everything is as is.' },
+      { on: '2026-08-22', said: 'I guess you should do both then.' },
+      { on: '2026-08-24', said: 'dispatch is the only way to run an operation' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_no_dispatch_bypass.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-22', said: 'I guess you should do both then.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'undeclared-node',
+    at: './constraint.ts',
+    describes: 'The refusal of a step nobody declared — an operation built from a node the descent never reaches, so the flow reads as agreed while one of its spans is a step this app never said it could take.',
+    version: 1,
+    where: { paths: ['operations/'], except: ['_generated/'] },
+    bans: 'an operation reaching a node under `nodes/` that the tree does not declare',
+    because:
+      'measured 2026-08-22: `OperationNode` stated `node` as a bare string, so a body naming `nd_teleport` compiled, loaded and dispatched, and nothing anywhere compared that name against a declared node. The first reading of this rule matched that string. Measured again 2026-08-26, after a node began building its own span: an operation writes no such string any more — it imports a node and calls it — so the reading matched nothing on any real file, and its own proofs were written in the same retired shape, so it passed its trial while measuring nothing. Both halves drifted together, which is the only way a rule goes quiet without anybody noticing. Proved by planting a node body no row declares and running a real app: it ran, answered `ok`, and the sweep named the file for being unthreaded and said nothing about the operation built from it. What an operation says today is the import it reaches its node through, so that is what is read — resolved to a path and checked against the descent, which also catches an import that resolves to nothing at all, where the only other answer was a module-not-found at run time. Measured a third time the same day, an hour after that reading shipped: it matched `import … from` and nothing else, so `await import(...)`, `require(...)` and `export … from` each walked through it, each tried against a real tree and each unremarked. Twice now this rule has enumerated a form instead of stating its rule, which is how a refusal ends up being a list of whatever somebody happened to try. The rule is about the PATH: a string that resolves under `nodes/` names a node, and a node the descent never reaches is a step nobody agreed to — whether it arrives by import, by require, by re-export, or sitting in a const waiting to be used',
+    instead: 'declare the node in the tree and then build from it. What an app can be asked to do grows by declaring a node, never by importing a file nothing brought into existence',
+    wrong: "import { node as ghost } from '../nodes/nd_ghost.ts'",
+    right: "import { node as read } from '../nodes/nd_read.ts'",
+    cites: [
+      { on: '2026-08-22', said: 'Operations are bilt of nodes, only nodes that are declared.' },
+      { on: '2026-08-22', said: 'That\'s why it grows. We declare, operations can do more.' },
+      { on: '2026-08-26', said: '1-this is a clear BUG' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_undeclared_node.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-22', said: 'Operations are bilt of nodes, only nodes that are declared.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'unprefixed-member',
+    at: './constraint.ts',
+    describes: 'The refusal of a row wearing the wrong prefix — an operation declared among the nodes or a node among the operations, so what a row IS stops being readable from its name and everything downstream believes the list it happens to sit in.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/'] },
+    bans: 'a row in a tree file\'s `MEMBERS` whose id does not carry a prefix that list takes — `wf_`, `vw_` or `agt_` in the operations tree, `nd_` in the nodes tree',
+    because:
+      'measured 2026-08-24: a prefix is not bound to a file. Both tree files export a list called `MEMBERS`, both are arrays of rows carrying a string id, and nothing in TypeScript or in any check separated them — a node id placed in the operations list typechecked, attached, seeded a body and read as agreed, and an operation id placed in the nodes list did the same. The prefix is the only thing that says which of the two a row is, and it was decoration. Measured again 2026-08-25, after the first reading of this was deleted for a different reason: the same gap was still open, and the founder named it as one of five mismatches against their stated requirements. Depth is what the reading turns on — a member row states its own id, and the `seeds` and `derives` rows beneath it state theirs, which are bodies rather than operations or nodes, so `wf_send_invoice_body` carries no prefix and must not be refused for it. Only rows sitting directly in the list are read',
+    instead: 'name the row for what it is. An operation is `wf_`, `vw_` or `agt_` and belongs in the operations tree; a node is `nd_` and belongs in the nodes tree. A row in the wrong list is not a naming slip, it is a declaration of the wrong thing',
+    wrong: "export const MEMBERS: readonly Member[] = [\n  {\n    id: 'nd_teleport',\n    at: '_threads/operations.ts',\n    describes: 'a node wearing an operation list',\n    version: 1,\n  },\n]",
+    right: "export const MEMBERS: readonly Member[] = [\n  {\n    id: 'wf_send_invoice',\n    at: '_threads/operations.ts',\n    describes: 'sends an invoice',\n    version: 1,\n  },\n]",
+    cites: [
+      { on: '2026-08-24', said: 'operations.ts, where it declares nodes.ts and dispatch.ts, and member rows in operations are wf_,vw_ and agt_ files.' },
+      { on: '2026-08-25', said: '3 fix it please.' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unprefixed_member.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-22', said: 'I guess you should do both then.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'unkept-rows',
+    at: './constraint.ts',
+    describes:
+      'The refusal of an app that declares somewhere to keep its rows and then keeps them somewhere else. A target that holds entities derives a store of its own; if what says where rows go names none of them, the tables are written, the migrations are written, the gate is green, and the database is never opened.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/'] },
+    bans: 'a store derived for a declared target while what says where rows go names none of them',
+    because:
+      'until 2026-09-01 there was exactly one implementation of the store this framework ships, and it held rows in a Map. A target derived a schema and its migrations and nothing that could talk to the database those describe — so an app declared postgres, had its tables written, passed every one of its checks, and then kept every row in memory, losing them all on restart with nothing anywhere saying so. The store exists now; this is what stops the same silence coming back, because every surface that could have noticed the old state reported success',
+    instead:
+      'run `thread capabilities`, which writes where rows go from what this app declares it keeps. If what it wrote is the in-memory stand-in, then this app declares no target that keeps entities — declare one with `thread create target` and put an entity in it with `thread create entity`',
+    wrong: 'a store is derived for a declared target   and   where rows go still names the in-memory stand-in',
+    right: 'a store is derived for a declared target   and   where rows go names that store',
+    cites: [
+      {
+        on: '2026-09-01',
+        said: 'What the fuck does that mean? Cause this seems to be the thing that NEVER IS READY. WHY IS THIS NOT READY? WHAT NEEDS TO CHANGE???????',
+      },
+      { on: '2026-09-01', said: 'Yes — all three' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_unkept_rows.ts',
+        describes:
+          'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-22', said: 'I guess you should do both then.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes:
+          'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+
+  {
+    id: 'untranslated-key',
+    at: './constraint.ts',
+    describes: 'The refusal of wording an app asks for and cannot say — a key named in the interface that a declared language answers with nothing, which renders as a blank where a sentence belongs and looks, to whoever sees it, like a broken component rather than an unfinished translation.',
+    version: 1,
+    where: { paths: ['.'], except: ['_generated/', 'node_modules/'] },
+    bans: 'a message key named by an element and left empty, or absent, in any language the app declares',
+    because:
+      'until 2026-08-29 an app could not declare a single word of its own: the translator was built over the catalogue compiled into `@thread/ui`, and a key that catalogue did not hold threw at render. So every app showed the framework\'s English and nothing else, and there was no file anywhere for a second language to go in. With the wording generated, the remaining hole is the one that cannot be generated — nobody can invent the sentence, so a key arrives holding an empty string, and an empty string is indistinguishable at every other surface from a translated one. The compiler catches a key a language has no LINE for; only this catches a line with nothing in it',
+    instead: 'write it with `thread create message`, which asks for every declared language at the moment the key is made and refuses a blank answer, or fill the line `thread i18n` added to each `i18n/<language>.json`',
+    wrong: '<Button label="checkout.confirm" />   with   { "checkout.confirm": "" }   in i18n/pt-BR.json',
+    right: '<Button label="checkout.confirm" />   with   { "checkout.confirm": "Confirmar" }   in i18n/pt-BR.json',
+    cites: [
+      { on: '2026-08-29', said: 'i18n keys must be translated OR ITS AN ERROR. This should be done 2 ways, CLI requires the keys in i18n in all translations needed AT THE MOMENT OF CREATION, not bypassable + a new constraint.ts row and slopnator that checks i18n entries against the keys in the UI and if there\'s anything missing in whatever file, it\'s a build error, compile error, gate error, everything. Cannot be allowed.' },
+      { on: '2026-08-29', said: 'i18n ships by default, nothing hardcoded in the UI at all' },
+    ],
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_untranslated_key.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+        cites: [{ on: '2026-08-22', said: 'I guess you should do both then.' }],
+      },
+    ],
+    derives: [
+      {
+        id: 'trial',
+        at: '_threads/_generated/trials.ts',
+        describes: 'The proof that a rule does what its row claims — the rule fired at the form it says it refuses and at the fix it recommends, derived from the row and the slopnator it names rather than written by hand.',
+        cites: [{ on: '2026-08-14', said: 'Slopnators though also need to run. So they derive their own tests.' }],
+      },
+    ],
+  },
+  {
+    id: 'only-takes-a-literal',
+    at: './constraint.ts',
+    describes: 'The refusal of a key list typed at the check — the keys a command accepts and the questions its receipt prints are one set, so a command that spells them out at `only` has stated that set twice and nothing holds the two together.',
+    version: 1,
+    where: { paths: ['.'] },
+    bans: 'an array literal as the second argument of `only`',
+    because:
+      'measured 2026-09-03 across eight receipts: six printed labels that were not the keys their own `only` took. `target new` had two of seven wrong; `target call` printed four labels for five keys and never showed `of` at all, so a piped answer could name a field the receipt had never mentioned; `capability` validated `live` and named it nowhere. Every one of them was a list typed at the check beside a second list typed in the guide, and every correct one already built both from the same rows. The defect is not that somebody mistyped a key, it is that the shape allowed two answers to one question — the same session that fixed three of these shipped a seventh while doing it',
+    instead:
+      'state the questions once, as rows carrying the key and what it says, and derive both from them — `const TAKES = ASKS.map((one) => one.key)` for what the command accepts, and the printed lines from the same array. A key that is not asked for cannot then be taken, and a label that is printed cannot then be refused',
+    wrong: "only(piped, ['name', 'describes', 'address'], 'a target')",
+    right: 'only(piped, TAKES, \'a target\')',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: './slopnators/sl_only_takes_a_literal.ts',
+        describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\'s text, or a command whose output is read.',
+      },
+    ],
+  },
+]