@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/constraint.ts

@@ -17,7 +17,7 @@ export function shown(proof: Proof): string {
 
 export interface Constraint extends Threaded {
   readonly version: number
-  readonly where: { readonly paths: readonly string[]; readonly except?: readonly string[] }
+  readonly where: { readonly paths: readonly string[] }
   readonly bans: string
   readonly because: string
   readonly instead: string
@@ -33,7 +33,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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`',
@@ -49,19 +49,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' },
-        ],
-      },
-    ],
   },
 
   {
@@ -69,14 +56,14 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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'] },
+    where: { paths: ['.'] },
     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',
+      '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, `undeclared-crossing` asks what a node reaches, and neither reads what a string contains. A vendor prefix is matched on its own because it is certain rather than probable: nothing else in a source file begins `sk_live_` or `AKIA` followed by twenty characters. A value that does not announce itself needs BOTH halves — a name that means credential AND something long and mixed enough to be one — because either alone is noise, a short assignment being a map key and a long opaque string being as likely a hash, a path or a fixture. Four things are deliberately not findings: a secret this app declares, which is a name and is the whole remedy this law recommends; an environment variable, whose contents this law cannot see and which `unvaulted-secret` refuses outright — a value arriving from the environment never passed the vault, which makes it a second defect rather than the remedy for this one; the obvious placeholders somebody writes while wiring something up; and the sealed store, which is base64 by construction, so the entropy half would find every value in it and recommend the thing the file already is — a law whose refusal has no honest remedy is one people learn to ignore. Measured 2026-09-17, against the rule that a check may hold no list of its own: this one holds twelve and they cannot come from the tree. A tree declares the NAMES of the secrets an app keeps, never the SHAPES of the keys other companies issue, so there is nothing here to read. Every scanner that exists spells the formats, and the one alternative — refusing whatever merely looks random — is the entropy half this row already rejects above. The list stands knowingly, and this is the one place in this framework where a check reaches exactly as far as somebody typed.',
     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 } }))",
+    right: "export const node = nd_action(async (opened) => await opened.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' },
@@ -91,42 +78,18 @@ export const CONSTRAINTS: readonly Constraint[] = [
     ],
   },
 
-  {
-    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/'] },
+    where: { paths: ['.'] },
     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'",
+    wrong: "import { 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: [
@@ -137,17 +100,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' },
-        ],
-      },
-    ],
   },
 
   {
@@ -155,7 +107,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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'] },
+    where: { paths: ['threads/'] },
     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',
@@ -172,14 +124,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -187,14 +131,22 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['threads/', '.'] },
     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}",
+    right: {
+      files: [
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_names_it.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_names_it.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const HELD: Threaded = {\n  declares: [\n    {\n      at: 'threads/core.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/core.ts', source: 'export const CORE = 1\n' },
+      ],
+      at: 'threads/_names_it.ts',
+    },
     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....' },
@@ -207,14 +159,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -222,7 +166,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
@@ -236,7 +180,16 @@ export const CONSTRAINTS: readonly Constraint[] = [
       ],
       at: 'threads/_probe_parented_row.ts',
     },
-    right: "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+    right: {
+      files: [
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_once.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_probe_once.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/core.ts',\n    },\n    {\n      at: 'threads/data.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/core.ts', source: 'export const CORE = 1\n' },
+        { at: 'threads/data.ts', source: 'export const DATA = 1\n' },
+      ],
+      at: 'threads/_probe_once.ts',
+    },
     cites: [{ on: '2026-08-14', said: 'Cause we need unthreaded, redthread, broken lineage, and the request/produce errors....' }],
     seeds: [
       {
@@ -246,14 +199,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -261,7 +206,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['threads/', '.'] },
     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',
@@ -281,14 +226,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -296,10 +233,10 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. Measured 2026-08-29 on a real install: this refused the glossary file on an app first gate run — a file the glossary command writes and had not written yet — with advice that would have deleted a correct declaration, so a path a row derives is now read off the tree and left alone until its command has run',
     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: {
@@ -309,7 +246,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
       ],
       at: 'probe.tsx',
     },
-    right: "const at = 'packages/core/integrity/src/constraint.ts'",
+    right: "const at = 'thread/integrity/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: [
       {
@@ -319,14 +256,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -334,10 +263,10 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. It reads those package files as TEXT and imports nothing but node builtins, because eight laws were once added whose walks imported a workspace package, plain Node could not resolve it, the loader swallowed the failure, and all eight then read from every caller exactly like laws finding nothing. What counts as a row was widened three times by measurement: a node may open its list inline or name a declares array beside it, and reading only the first made 107 of the 178 rows one package ships invisible, every one deletable in silence; a row may be an object literal or a call to a factory that takes the id first, which was the other half of the same blindness; and what a PACKAGE ships is only the ids inside a declares list, because reading every id in the file counted a row the package asks an app to append into another list as one it declares. What a TREE holds is the opposite — every id, whichever list it sits in — since gating that on declares made every row in the derivation sheet read as missing while it sat plainly on disk, and running the command this law recommends would not have cleared it. Only packages the tree ATTACHED are asked for: a package nothing points at is a dependency, and a dependency ships nothing this tree promised to hold',
     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}",
@@ -354,14 +283,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -391,14 +312,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -406,7 +319,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['threads/', 'thread/integrity/slopnators/'] },
     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',
@@ -431,14 +344,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -446,7 +351,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
@@ -474,14 +379,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -496,7 +393,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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}",
+    right: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'next.config.js',\n      by: 'thread routes',\n      runs: 'thread routes --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.' },
@@ -509,28 +406,20 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.',
+    describes: 'The refusal that makes an operation the only thing in this app that does anything. Work is not written where it happens to be wanted; it is declared as an operation, which states what it takes, what it hands back and what it has to reach, and the operation is what runs. Anything that acts outside one is work this app never said it would do, and nothing can replay it, retry it, price it or unwind it afterwards.',
     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',
+    where: { paths: ['.'] },
+    bans: 'acting outside an operation — anything that reaches past this process, whatever it is called',
     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',
+      'An operation is how this framework does anything at all: it states what it takes, what it hands back and what it has to reach, and the trial, the replay, the trace, the cost record and the compensation every one hang off that statement. Work written beside one has none of them: nothing recorded it, so it cannot be replayed; nothing owns it, so it cannot be retried; it left no record, so it cannot be priced; no compensation names it, so it cannot be unwound. 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 is not one of these. `Date.now()`, a timer and `new Date()` are each accepted here and have been for as long as this check has run — they sit in its own list of forms it stays silent on. A paragraph stood here saying the opposite, on the grounds that a run reading the clock cannot be replayed, and it described a refusal this check never made; an agent read it, reported the clock as a gap, and was told twice. Founder, 2026-09-17: date is environment, and environment is free. A duration or easing curve typed into an animate call is a separate matter, and nothing refuses it today — hardcoded-style reads a CSS declaration written inside a string, and an object argument is not one. Measured 2026-09-16: the check behind this carried ten ways of acting written out, so starting a process — which nobody had typed — was not a crossing at all, and 48 places that spawn one were green. The law was never about those ten. Measured 2026-09-17, against the rule that a check may hold no list of its own: the twenty-one spellings this reads cannot come from the tree either, and two ways out were tried. Reading the declared doors instead — the rows naming the files that open a disk, a process and a network — refuses every file that legitimately goes through one, which is most of this framework. Reading what those door files themselves import brings node:path in with them, and a path join is not a crossing. What is left is the spelling of the capability, which Node names and this tree never does. It stands, and it is the second place where a check reaches exactly as far as somebody typed.',
     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',
+      'Declare an operation and put the work in it. `thread create operation` asks what it takes, what it hands back and which targets it reaches, then writes it; `thread run trial <operation>` runs it against an input you supply, so you see it work before anything else does. An operation reaches outside only through a target it named — that is not a restriction on the work, it is where the work goes.',
     wrong: "const res = await fetch('https://api.stripe.com/v1/charges')",
-    right: "{ id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
+    right: "{ id: 'wf_charge_card', describes: 'Takes payment for an order through the stripe target this app declares.', requires: ['ht_stripe'] }",
     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.' },
@@ -544,14 +433,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -559,7 +440,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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.',
@@ -580,14 +461,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -596,13 +469,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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',
+    where: { paths: ['.'] },
+    bans: 'a destination reached without naming a declared screen — an `href`, or the address of a declared screen written out as a path',
     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',
+      '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. Measured 2026-09-17: what this read was a list of nine names — window, globalThis, self, top, parent, document, router, navigation, history — so a mover nobody had typed was not a mover at all, and the rule reached exactly as far as those nine. It reads the tree now: every screen an app declares has an address, and writing that address out rather than naming the screen is the finding, whatever does the writing. What is given up is a destination held in a variable, which was only ever caught when it passed through one of the nine.',
     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" />',
+    right: '<Link.linkInline 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.' },
@@ -617,14 +490,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -632,10 +497,10 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. Measured 2026-08-31 on a registry install: an operations-only app, everything made by the CLI, failed its own sweep on a file its own generator had just written, naming an operation the same tree declares — and a law that refuses a generated file is an app that cannot ship. So an identifier is accepted now, but only when it IS one of the declared operations; a variable holding a computed name is still refused, because it matches no declaration, and that is the hole this law was written for',
     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: {
@@ -669,14 +534,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -685,7 +542,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
@@ -721,14 +578,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -738,7 +587,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
@@ -760,21 +609,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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/'] },
+    where: { paths: ['threads/', 'operations/', 'entities/'] },
     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',
@@ -810,21 +651,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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'] },
+    where: { paths: ['.'] },
     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',
@@ -844,21 +677,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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/'] },
+    where: { paths: ['.'] },
     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',
@@ -885,14 +710,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -913,7 +730,9 @@ export const CONSTRAINTS: readonly Constraint[] = [
     },
     right: {
       files: [
-        { at: 'threads/_inert_probe.ts', source: "export const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly governs?: readonly string[]\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_inert_probe.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
         { at: 'packages/core/spec/src/islands/events.ts', source: 'export const EventsIslandSchema = {}\n' },
       ],
       at: 'threads/_inert_probe.ts',
@@ -931,21 +750,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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/'] },
+    where: { paths: ['.'] },
     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',
@@ -965,14 +776,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -1007,21 +810,13 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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/'] },
+    where: { paths: ['.'] },
     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',
@@ -1041,14 +836,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -1074,14 +861,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -1089,12 +868,20 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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',
+    bans: 'a slopnator importing the one place this framework starts a process',
     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'",
+    wrong: {
+      files: [
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_programs.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_probe_programs.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const INTEGRATIONS: Threaded = {\n  id: 'integrations',\n  declares: [\n    {\n      id: 'programs',\n      at: 'thread/integrations/cli.ts',\n    },\n  ],\n}\n" },
+        { at: 'thread/integrity/slopnators/sl_probe_law.ts', source: "import { starts } from '../../integrations/cli.ts'\n" },
+      ],
+      at: 'thread/integrity/slopnators/sl_probe_law.ts',
+    },
+    right: "import { readFileSync } from '../../integrations/disk.ts'",
     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.' },
@@ -1107,14 +894,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -1122,13 +901,21 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. Which files are bodies is asked of the tree through two clauses from two authorities, because each alone was measured wrong: reading the directory refused the woven body for importing its own steps, and asking the owning word called every byproduct of that meta a body — measured 2026-09-14, the four-line file that hands the seams on was refused for spreading a seam table, because this had decided the file it came from was an operation. So a body is a file some row derives with the compile command AND whose word wears an operation prefix, and neither clause is enough alone. Three things bind no operation and are passed: a type-only import, which names a shape nothing can dispatch; a type query or reference, which is erased before anything runs and whose refusal was a false positive that would have refused the probe written to test the reassignment form; and dispatch itself, which lives beside the operations because an app writes its own, so a file importing it from there had the handler added to the set and was then refused for mishandling the handler. The file is parsed here rather than taken from the visitor, because the sweep calls this once per file with no node at all, and what a file DOES with a binding is a question about the whole file rather than about one node in it',
     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)",
+    wrong: "import { operation } from './operations/wf_send_invoice.ts'\n\nawait operation.run(opened, held)",
+    right: {
+      files: [
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_operations.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_probe_operations.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      describes: 'sends an invoice',\n      derives: [\n        {\n          id: 'wf_send_invoice_body',\n          at: 'operations/wf_send_invoice.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+        { at: 'probe.tsx', source: "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nawait dispatch(operation, input, actor, opened)\n" },
+      ],
+      at: 'probe.tsx',
+    },
     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.' },
@@ -1143,14 +930,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -1158,7 +937,7 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['operations/'] },
     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',
@@ -1194,14 +973,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -1209,10 +980,10 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. What a row may wear is not written out here either — the prefixes come from the one list that `thread create` and this law both read, so a kind added there is never a kind this refuses. The braces are read off the code mask this package already ships rather than counted in the raw text, because counting them directly desynced on a describes holding a brace, and a second weaker walker beside the one that exists is the drift it exists to prevent',
     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: {
       files: [
@@ -1246,55 +1017,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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.' }],
-      },
-    ],
   },
 
   {
@@ -1302,10 +1024,10 @@ export const CONSTRAINTS: readonly Constraint[] = [
     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/'] },
+    where: { paths: ['.'] },
     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',
+      '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. It reads the files that are on disk and the markup that is actually there rather than calling the generator, because a check that runs the thing it is checking passes whenever that thing passes, which is no check at all. And which props carry a key is read off the declarations of the installed package itself: a list written into this law would go stale the first time an element gained a prop — silently, by finding fewer keys than there are, which is the failure this law exists to prevent',
     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',
@@ -1321,14 +1043,6 @@ export const CONSTRAINTS: readonly Constraint[] = [
         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',
@@ -1351,4 +1065,182 @@ export const CONSTRAINTS: readonly Constraint[] = [
       },
     ],
   },
+  {
+    id: 'unvaulted-secret',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a secret taken from the environment instead of the vault. The vault refuses a name no row declares and a value nothing sealed; the environment refuses nothing, so whoever reads it is handed whatever the machine happens to hold under that name.',
+    version: 1,
+    where: { paths: ['.'] },
+    bans: 'reading process.env under a name the file does not state, or under a name wearing a secret prefix',
+    because: 'measured 2026-09-15: this repository shipped a resolver that read process.env under the uppercased name of whatever was asked for, and installed it as the vault seam whenever the environment said production. Every gate the vault states — that the name is one a row declares, that a value was sealed for this environment, that the key opens it — was skipped for every secret, and a server credential and a browser value read identically. Nothing refused it, because secret-literal reads what a string contains and a member expression contains nothing, and because that law named an environment read among the things it deliberately does not find. The two halves are refused for different reasons: a name the file states can be compared against the secrets, while a name nobody reading the file can see can be any of them. Measured 2026-09-17, against the rule that a check may hold no list of its own: the two prefixes this read were a list typed into thread/integrations/secret.ts, and I first recorded here that they were where the tree coins them. That was wrong and the founder caught it: `sec_` and `pub_` are coined in the sentence on the secrets row and in the glossary, which is prose the descent cannot read. They come from the declared secrets now — every secret row wears one, and the prefixes are what those ids begin with — so a new kind of secret widens this without anybody typing it.',
+    instead: 'ask the vault. A declared secret is opened by the file `thread vault` writes, which refuses a name no row states and a value nothing sealed. Nothing inside an operation ever holds the value: the operation names a target on its `requires`, dispatch opens what that target is wired to send, and it goes straight into the call. If what you are reading is not a secret, give it a name wearing no secret prefix and write that name in the file rather than computing it',
+    wrong: 'const key = process.env[named.toUpperCase()]',
+    right: 'const mode = process.env[\'NODE_ENV\']',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_unvaulted_secret.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.',
+      },
+    ],
+  },
+  {
+    id: 'undeclared-list',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a check that decides from a list of words somebody typed. A rule reaches exactly as far as those words, so the first thing built under a name nobody typed walks straight past and the rule reports green over it. The list is followed wherever it was put — wrapped in as const, nested under a key, spread out of a helper, turned into a set of its own keys, or moved into another file and imported back.',
+    version: 1,
+    where: { paths: ['thread/integrity/slopnators/', 'threads/slopnators/'] },
+    bans: 'a check holding its own list of words — a name set to a written-out list, or to something built from one',
+    because: 'Measured 2026-09-16: `undeclared-crossing` says only a declared operation may act, and its check carried ten ways of acting written out. Starting a process was not one of them, so 48 places that start one reported green for as long as that list stood. Founder the same day: it must not be a hand written list. Measured 2026-09-17: this reading called every `!X.has(y)` a list the check only skips, so a catch list written as a negated guard that leaves the check — `if (!STARTS_A_PROCESS.has(from)) return false` — read as exempt, and `no-child-process` carried two spellings and reported green over every other way to start a process. What decides it is what the branch does: leaving the check on a membership test is the list deciding the refusal, while a `continue` in a loop is the list stepping over one candidate.',
+    instead: 'Ask the tree for the words. Every one this framework can refuse is coined by a row, so `thread inspect <word>` names where any of them is declared, and a check that reads those rows widens when the tree does rather than when somebody remembers to type.',
+    wrong: 'const CROSSINGS = [\'fetch\', \'setTimeout\', \'setInterval\']',
+    right: 'const CROSSINGS = declared()',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_undeclared_list.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.',
+      },
+    ],
+  },
+  {
+    id: 'screen-holds-only-declared',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of anything in a screen that is not one of the three things a screen is made of. A screen arranges declared elements and compositions and may hand an operation to dispatch; it reaches nothing and computes nothing itself, so a fetch or a clock written into one has nowhere to be rather than a rule standing against it.',
+    version: 1,
+    where: { paths: ['screens/', 'compositions/'] },
+    bans: 'a call in a screen that is not an element, a composition, or an operation handed to dispatch',
+    because: 'Measured 2026-09-17: undeclared-crossing carried twenty-one host spellings to catch exactly this, and reported nothing across all 320 files of this repository, because the framework itself always goes through a declared door. A screen is the one place those spellings were for: the screens command seeds an empty screen file and a person fills the body in, so a raw fetch can be typed straight into one. Founder the same day: Fetch just should not have a way to exist. Naming the ways to reach outside is a list that goes stale; naming the three things a screen may hold is not, because those three come from rows.',
+    instead: 'put the work in an operation and hand it to dispatch, and put what is drawn in an element or a composition. thread create operation declares the first, thread create element the second, and a screen then names them.',
+    wrong: 'export const Home = screen(\'home\', {}, () => fetch(address))',
+    right: {
+      files: [
+        { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+        { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_operations.ts',\n    },\n  ],\n}\n" },
+        { at: 'threads/_probe_operations.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_place_order',\n      describes: 'places an order',\n      derives: [\n        {\n          id: 'wf_place_order_body',\n          at: 'operations/wf_place_order.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+        { at: 'screens/probe.tsx', source: "import { dispatch } from '../operations/_dispatch.ts'\n\nimport { operation } from '../operations/wf_place_order.ts'\n\nexport const Home = screen('home', {}, () => dispatch(operation, input, actor, opened))\n" },
+      ],
+      at: 'screens/probe.tsx',
+    },
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_screen_holds_only_declared.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.',
+      },
+    ],
+  },
+  {
+    id: 'undeclared-webhook',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a webhook and an operation that do not agree. A webhook names the operation it invokes and that operation names the webhook back, so nothing outside this app reaches an operation that never said it would take it.',
+    version: 1,
+    where: { paths: ['threads/', 'app/inbound/'] },
+    bans: 'a webhook invoking an operation that does not name it back, and a webhook carrying no signature reaching an operation that takes only signed ones',
+    because: 'measured 2026-09-17: a webhook is a url anybody on the internet may post to, so whatever sits behind it is reachable by whoever finds the path. One row saying which operation it runs is half a decision, and the missing half is the one that matters: the operation never agreed to be reached that way, and nothing anywhere recorded that it had.',
+    instead: 'declare the webhook with `thread create webhook new <name>`, which asks the target it is `of`, the `path` it lands on, and the operation it `invokes`. Then name it back on that operation with `thread edit <operation> --webhooks <webhook>` — the same command with no field prints what that row says now, every field it takes with it, `webhooks` and `signed` among them. An operation whose row says `signed` needs the other half as well: `arrives` on the webhook, naming the header its signature comes in on, and a secret declared with `thread create secret new <name>` in what that webhook requires. The route is never written by hand — `thread capabilities` derives it from these rows.',
+    wrong: "const WH = { id: 'wh_stripe', invokes: 'wf_charge' }",
+    right: "const WH = { id: 'wh_stripe', describes: 'Where stripe posts what it has done.' }",
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_undeclared_webhook.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.',
+      },
+    ],
+  },
+  {
+    id: 'outside-an-operation',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a call on what this app hands an operation, made anywhere but inside one. An operation is opened with a store, a target or a program and is the only thing that may use them, so a file that gets hold of one and calls on it is doing an operation work where nothing declared it.',
+    version: 1,
+    where: { paths: ['.'] },
+    bans: 'a call on what this app hands an operation, made outside an operation',
+    because: 'Measured 2026-09-17: undeclared-crossing read two different things under one name. One is a reach past this process that goes through no declared integration; the other is a call on what an operation was opened with, made by something that is not an operation. They fire on different forms, they are fixed in different ways, and a single name meant neither could be stated on its own. Founder the same day: Then separate them. One is for things that reach or ways the repo is reached outside the repo and are not integrations, then there is things that reach outside or are reached by an outside thing and are not operations.',
+    instead: 'declare an operation and let dispatch open it. What an operation is handed is handed to it, and nothing else in this app is given a way to use it.',
+    wrong: {
+      files: [
+        { at: 'thread/operations/operations.ts', source: 'export interface Store {\n  insert(row: unknown): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Store }\n' },
+        { at: 'threads/_probe_target.ts', source: "import type { Opened } from '../thread/operations/operations.ts'\n\nexport const kept = async (opened: Opened<'pg_main'>): Promise<void> => {\n  await opened['pg_main']['insert']({})\n}\n" },
+      ],
+      at: 'threads/_probe_target.ts',
+    },
+    right: 'export const carried = (opened: Opened<\'pg_main\'>, run: (given: Opened<\'pg_main\'>) => Promise<void>): Promise<void> => run(opened)',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_outside_an_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.',
+      },
+    ],
+  },
+  {
+    id: 'underived-route',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a route nothing derives. A file that answers a request is written by a generator out of rows, never by hand, so the only shape allowed is a derives row naming it with the command that writes it and the command that catches it drifting.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a route file that is not a derives row carrying both by and runs',
+    because: 'measured 2026-09-17: a generator wrote app/inbound/wh_stripe/route.ts while no row anywhere named that address. Nothing refused it, because unthreaded only asks whether some row names a file and derived-drift only guards addresses a derives row already states. A route is the one file anybody on the internet can reach, so a route nobody declared is a door nobody agreed to.',
+    instead: 'declare the generator with `thread create generator`, which writes its row into GENERATORS with the `by` command it answers, then give the thing that owns the route a `derives` row naming the route file, with `by` set to that command and `runs` set to that command and --check. Both rows or neither: the generator makes the bytes, and the derives row is what says the address was agreed to.',
+    wrong: 'const M = { declares: [{ at: \'app/inbound/wh_stripe/route.ts\' }] }',
+    right: {
+      files: [
+        { at: 'threads/thread.ts', source: "export const THREAD = {\n  declares: [\n    { at: 'threads/_probe_route.ts' },\n  ],\n}\n" },
+        { at: 'threads/_probe_route.ts', source: "export const M = {\n  derives: [\n    { at: 'app/inbound/wh_stripe/route.ts', by: 'thread capabilities', runs: 'thread capabilities --check' },\n  ],\n}\n" },
+      ],
+      at: 'threads/_probe_route.ts',
+    },
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_underived_route.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.',
+      },
+    ],
+  },
+  {
+    id: 'door-in-a-node',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a node that reaches outside by importing the framework\'s own way out — the file that starts programs, reads the disk or sends over https — so what it does out there goes through no declared target and nothing prices it, replays it in a trial or refuses it.',
+    version: 1,
+    where: { paths: ['operations/'] },
+    bans: 'a node importing a file that reaches past this process — by a Node builtin, a global like fetch, or a driver — or importing anything that imports one',
+    because: 'measured 2026-09-22: `undeclared-crossing` refuses the spellings that reach past this process — `node:child_process`, `node:fs`, `fetch` and the rest — and lets a file declared under `integrations` use them, because those files are the doors this framework opens on an operation\'s behalf. A node that imports one of them writes no such spelling, so that check read it as clean, and it required no target, so no target check had anything to read. Nothing read what the imported file opens, and a node could run git or write the disk with every check green',
+    instead: 'require the target on the operation and call what the node is handed. `thread create target` declares the place and `thread create target call` each thing it is asked; the operation\'s `requires` names the target, and the node receives one function per call. A type may be imported from anywhere, because a type opens nothing',
+    wrong: {
+      files: [
+        { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
+        { at: 'operations/_probe_node.ts', source: "import { starts } from '../thread/integrations/cli.ts'\n\nexport const node = (): void => {\n  starts('git')\n}\n" },
+      ],
+      at: 'operations/_probe_node.ts',
+    },
+    right: 'import { z } from \'zod\'',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_door_in_a_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.',
+      },
+    ],
+  },
+  {
+    id: 'unlisted-program',
+    at: 'thread/integrity/constraint.ts',
+    describes: 'The refusal of a cli target naming a program this tree did not install — a program found on the machine instead of under node_modules/.bin is whatever that machine has, so a target on it bounds nothing and a declared call on it can run any line.',
+    version: 1,
+    where: { paths: ['threads/'] },
+    bans: 'a `cli_` target whose program is neither one this tree installed under node_modules/.bin, nor git, node or thread, nor the package manager the lockfile picks',
+    because: 'measured 2026-09-22: the program a cli target starts fell back to the bare name when nothing under node_modules/.bin carried it, so a target `cli_bash` with a call at `-c` would have started a shell with whatever line an operation handed it, and every check stayed green — the prefix was right, the call was declared, the operation required it. Measured the same day: `cli_typescript` was declared naming a program that does not exist, since the installed executable is `tsc`, and nothing said so until a build tried to start it',
+    instead: 'name the target after a program this tree installs, so `cli_` and the file under node_modules/.bin agree — `cli_tsc`, not `cli_typescript` — or after git, node, thread or `packager`, the word for whichever package manager the lockfile picks. A program the tree does not install yet is added as a dependency first, so an install brings it and the lockfile records it',
+    wrong: 'export const TARGETS: readonly Target[] = [{ id: \'cli_typescript\', of: \'in_typescript\', describes: \'The compiler this tree is checked and built with.\', version: 1, takes: [], requires: [] }]',
+    right: 'export const TARGETS: readonly Target[] = [{ id: \'cli_git\', of: \'in_git\', describes: \'The git on the machine a command runs on.\', version: 1, takes: [], requires: [] }]',
+    seeds: [
+      {
+        id: 'slopnator',
+        at: 'thread/integrity/slopnators/sl_unlisted_program.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.',
+      },
+    ],
+  },
 ]