@orkestrel/scaffold 0.0.108 → 0.0.109

package/dist/host/claude/rules/application.md

@@ -11,19 +11,17 @@ paths:
 
 # Application composition
 
+These rules govern how an application composes its environments: selections, entries, manifests, and the server runner. `AGENTS.md` § Project model owns the environment boundaries.
+
 - Select only needed app environments; app-only, src-only, and mixed workspaces
   are first-class.
-- The CLI names the independent selections `--src` and `--app`.
-  `--surfaces` is not an alias and must fail as an unknown option.
-- `new` selects the styles surface with `--styles`, its themes target with `--themes` (requires
-  `--styles`), the showcase with `--showcase` (requires `--app browser`), and extensions with
-  `--extend <surface:name,…>`. Each `--extend` entry is `browser:vue`, applied to every selected
-  browser axis, or `styles:<name>`, which requires `--styles`. `--app browser` implies the journey.
+- `guides/scaffold.md` § Select at creation owns the `scaffold new` selections and the
+  combinations it refuses.
 - Core-only, browser-only, and server-only applications are valid. A combined
   browser+server application includes app/core for shared contracts.
 - Every selected environment has an `index.ts` barrel. `main.ts` is an executable
   entry and never owns reusable declarations.
-- app/core is host-independent and check/test-only.
+- app/core is check/test-only.
 - app/browser is framework-independent: it uses app/core contracts, an
   `index.html` entry, a `main.ts` that renders through the DOM, `check:app:browser`
   through `tsc`, and real Chromium tests.
@@ -37,10 +35,10 @@ paths:
 - app/server uses app/core contracts, parses environment values before binding,
   defaults to loopback, emits `dist/app/server/main.cjs`, and keeps only
   `node:*` external.
-- Browser and server integrate across a contract and transport boundary. Neither
-  environment imports the other's implementation.
-- The project toolchain enforces that boundary, and none of its tools is
-  replaceable by a custom parser or source-language analyzer: `.oxlintrc.json`
+- Parse the server's options container and its host and port before any mutation. Reject a
+  wrong-shaped container, an empty host, and a non-integer, negative, or out-of-range port with a
+  coded error and its guard.
+- The project toolchain enforces the environment boundary: `.oxlintrc.json`
   `no-restricted-imports` enforces declared package, alias, and conventional
   relative import direction; scoped TypeScript configurations remove Node and
   DOM globals from the wrong environment; Vite's real browser and server builds
@@ -48,14 +46,10 @@ paths:
   generated-consumer tests exercise those real configurations.
 - Generated consumers must pass lint, scoped typechecking, production builds, and
   real integration tests.
-- Include `.ts`, `.tsx`, `.mts`, and `.cts` in scoped checks. Publish only TypeScript from
-  `src/vue`, and put Vue SFCs in `app/vue`. Put CSS in browser code; compile SCSS through the
-  `sass` dependency the styles surface declares.
-- Published `src` environments never import private `app` modules. Src core is
-  host-independent; src browser/server may import src core but never one
-  another's implementation. Apply the same environment law to
-  `@orkestrel/<package>/browser` and `/server` exports; a package's bare export
-  is its core API.
+- Include `.ts`, `.tsx`, `.mts`, and `.cts` in scoped checks. Put CSS in browser code; compile
+  SCSS through the `sass` dependency the styles surface declares.
+- Apply the environment law to `@orkestrel/<package>/browser` and `/server` exports; a package's
+  bare export is its core API.
 - App-only manifests are unscoped and `private: true`, with no `main`,
   `module`, `types`, export map, or publish configuration. Mixed manifests
   publish only `dist/src` and the SCSS sources a stylesheet export names, and
@@ -64,8 +58,7 @@ paths:
 - Give app/server process signals to a tested, explicitly stoppable,
   generation-safe runner whose stale failures cannot release a newer run.
 - Return the runner from convenience startup, so normal cleanup cannot be hidden.
-- `ApplicationServerRunner` lives alone in `ApplicationServerRunner.ts`.
-  `startApplicationServer` belongs in `handlers.ts` beside the other process-lifecycle
+- Place `startApplicationServer` in `handlers.ts` beside the other process-lifecycle
   functions, because `factories.ts` admits only `create`-prefixed construction and this
   one starts a signal-owning resource. `main.ts` invokes it and owns no reusable
   declarations or duplicated signal handling.

package/dist/host/claude/rules/architecture.md

@@ -4,13 +4,12 @@ paths:
   - 'app/**/*.{ts,vue}'
   - 'tests/**/*.ts'
   - 'configs/**/*.ts'
-  - 'vite.config.ts'
-  - 'tsconfig.json'
-  - 'package.json'
 ---
 
 # Architecture and placement rules
 
+These rules govern where each declaration lives and how classes, functions, plugins, stores, and barrels are shaped. `.claude/rules/workspace.md` places the environments themselves.
+
 ## Centralized-file pattern
 
 | Content                   | Sole location                                                |
@@ -71,7 +70,7 @@ Use only the centralized files an environment needs.
   so both stay in `helpers.ts`. Placement follows what the function is; the name form follows
   placement.
 - Repair a violation of those forms by deciding what the function **is** first, then moving or
-  renaming to match. Both repairs exist and picking the wrong one does real damage.
+  renaming to match.
   - Wrong file, right name → **move it**. A `scan*` in `parsers.ts` is a pure lexical leaf that
     belongs in `helpers.ts`. The barrel star-exports both, so the move leaves the published surface
     identical.
@@ -79,12 +78,9 @@ Use only the centralized files an environment needs.
     drive its own state, as opposed to a plain value that carries data and no behaviour. A function
     returning a live entity is an entity factory and belongs in `factories.ts` whatever it is
     called, so `restoreThing` there is misnamed, not misplaced. Renaming moves the published
-    surface and earns a version bump; that cost is the correct one to pay, and it is smaller than
-    the alternative.
-  - Never let the name choose. Relocating a correctly-placed function to escape a rename drags its
-    dependencies with it — an entity factory moved into `helpers.ts` makes that file import an
-    implementation class, and a leaf file that imports a class stops being a leaf for every module
-    beneath it.
+    surface and earns a version bump.
+  - Never let the name choose. Never relocate a correctly placed function to escape a rename: an
+    entity factory moved into `helpers.ts` makes that file import an implementation class.
 - Keep the leaf pair class-free. `helpers.ts` and `validators.ts` sit at the bottom of a module's
   graph: they import types, constants, errors, and each other, and they import no implementation
   class. Every file that constructs or drives a class — `cloners.ts`, `compilers.ts`, `factories.ts`,
@@ -100,29 +96,37 @@ Use only the centralized files an environment needs.
 
 ### What the policy instruments prove
 
-The `policy` Oxlint plugin (`configs/policy.ts`) enforces syntactic placement: a declaration of a
-given syntactic kind appears only in a file permitted to hold that kind. The fleet policy sweep
-(`tests/policy.test.ts`, `tests/setupPolicy.ts`) enforces what a path or a text reading decides.
-The plugin reads declaration syntax and file name; the sweep reads paths and workspace text;
+`.claude/rules/workspace.md` § Policy instruments fixes which instrument takes which rule. The
+`policy` Oxlint plugin (`configs/policy.ts`) reads declaration syntax and file name; the fleet
+policy sweep (`tests/policy.test.ts`, `tests/setupPolicy.ts`) reads paths and workspace text;
 neither reads meaning.
 
 - The plugin proves that a module function sits in a function-kind file, that module data sits in a
   data-kind file, that every centralized declaration is exported, that a class sits in its matching
-  implementation or errors file, and that `constants.ts` declares only UPPER_SNAKE_CASE consts with
-  no bare collection literal.
+  implementation or errors file, that `constants.ts` declares only UPPER_SNAKE_CASE consts with
+  no bare collection literal, and that every interface or type-alias property is `readonly`.
+- The plugin proves that no file declares a `let` that `prefer-const` leaves, and, over
+  `POLICY_NESTED_GLOBS` and `POLICY_SCRIPT_GLOBS`, that no function sits inside another outside the
+  callback positions.
+- The plugin proves that a skill script exports every top-level declaration with a doc block and
+  runs nothing but its entry guard, over `POLICY_SCRIPT_GLOBS`.
 - The sweep proves that no source, test, config, script, or sheet file carries an `eslint-disable`,
   `oxlint-disable`, or `prettier-ignore` directive.
 - The sweep proves that every `.claude/rules/*.md` file has a rule-map row in `AGENTS.md` and that
   every row resolves to a file.
 - The sweep proves the host portability rules that are path- or text-shaped over the population
   `POLICY_PORTABILITY_GLOB` names: no path segment carries a Windows reserved device name, a
-  character Windows refuses, a trailing dot or space, or a sibling differing only by case; and no
-  `package.json` script names a `.sh` file.
+  character Windows refuses, a trailing dot or space, or a sibling differing only by case; no
+  `package.json` script names a `.sh` file; and no shell, PowerShell, Python, or batch file sits
+  outside `scripts/`.
+- The sweep proves that the authored and source text decodes as UTF-8 with no replacement,
+  byte-order, or control character beyond tab, line feed, and carriage return.
+- The sweep proves that a skill proof imports no skill file but its own script.
 - The plugin proves, over the population `POLICY_ENDING_GLOBS` names, that no source trims a
   payload before splitting it on `'\n'`, reads `os.EOL`, or imports `EOL` from `node:os`.
-- The sweep cannot write a filename the host refuses. A Windows host rejects `<`, folds a case
-  collision into one file, and turns `:` into an alternate data stream, so those boundaries are
-  proven from a path population rather than from written files.
+- Prove a filename the host refuses from a path population, never from written files: a Windows
+  host rejects `<`, folds a case collision into one file, and turns `:` into an alternate data
+  stream.
 - The plugin does not prove a collection is frozen. It reads the declaration, never the value a
   call returns, so `Object.freeze([…])` and any other call initializer are one syntax to it. The
   freeze obligation in the earlier kind-purity rules binds regardless; only the bare literal is
@@ -131,8 +135,7 @@ neither reads meaning.
   functions reads the same to it apart from the `parse*`, `create*`, `create*Plugin`, and `create*Plugins` name
   forms: `cloners.ts`, `combinators.ts`, `compilers.ts`, `errors.ts`, `factories.ts`, `handlers.ts`,
   `helpers.ts`, `inferers.ts`, `middlewares.ts`, `parsers.ts`, `plugins.ts`, `relations.ts`,
-  `schemas.ts`, `seeders.ts`, `shapers.ts`, and `validators.ts`. That list is exhaustive, a new function kind joins it, and no
-  later version of the plugin claims more.
+  `schemas.ts`, `seeders.ts`, `shapers.ts`, and `validators.ts`.
 - The name forms read names only: a function, an export specifier, an exported import alias, and a
   star re-export in the kind file. They never read a return type, so a `create{Name}Plugins` that
   returns one plugin passes; review owns arity. A value binding in a kind file is the data rule's
@@ -152,20 +155,17 @@ neither reads meaning.
 - The cleanup pass and independent review prove kind purity across those files. A helper misfiled
   as a parser, a coercer misfiled as a guard, a compiler misfiled as a factory, and a shaper
   misfiled as a cloner are review findings, not instrument diagnostics.
-- The plugin does not decide barrel membership. It parses each file alone and resolves no module,
-  so it cannot tell whether a declaration is reachable from its barrel. That question belongs to
-  each package's `tests/guides.test.ts`, which imports the barrel and gets real resolution. Do not
-  add module resolution here to duplicate it.
+- The plugin does not decide barrel membership: it parses each file alone and resolves no module.
+  Each package's `tests/guides.test.ts` imports the barrel and decides reachability. Add no module
+  resolution to the plugin.
 - The kind table is mandatory whether or not an instrument can see the violation.
 
 ## Wrapper test
 
-A wrapper survives only when it adds a real boundary, invariant, composition, translation, lifecycle, or materially narrower contract.
+`AGENTS.md` § Design laws states the wrapper test. Apply it:
 
 - Delete one-line delegates, pass-through factories, rename-only helpers/getters, compatibility aliases, and wrappers around semantically identical platform or declared-dependency primitives.
 - Rename or import the real symbol and update every consumer atomically. Do not preserve a wrapper to avoid downstream edits.
-- Do not re-export a dependency's symbol from this package.
-- A public class method composes real entity behavior; it never exists only to forward 1:1 to a helper.
 - Audit callers and callees after every extraction so the old path and duplicate implementation do not remain.
 
 ## Functions and orchestration
@@ -276,8 +276,6 @@ Every shape obeys:
 - Never re-export a symbol originating in another package; fix consumer imports to the originating package.
 - Implementation files export their own classes directly.
 - Expose every intentional top-level source export through its correct environment barrel.
-- Never let current consumer count gate later exposure. Developers receive the same supported
-  mechanisms the package uses, so they retain full control and customization.
 - If a declaration must not be public, make it a true local or runtime-private detail, or remove
   the capability for a substantive reason. Never leave an intentional reusable export stranded
   outside the barrel.
@@ -290,7 +288,6 @@ Every shape obeys:
 - Delete a barrel row whose class no consumer can construct, and delete its `@example` with it. A
   row obliges a documented, runnable example, so a class kept public without one is drift that
   parity cannot see.
-- When a symbol moves, update every import; never leave a compatibility re-export.
 
 ```ts
 export * from './types.js'
@@ -304,16 +301,9 @@ export * from './greeters/Greeter.js'
 
 ## System constraints
 
-- Build or substantively expand a capability with its first real consumer; do not speculate. This
-  gate applies only when creating or expanding the capability, not to its later barrel exposure.
-- Keep interfaces to the smallest primitives the capability requires.
-- For multiple backends, implement shared querying/paging/aggregation in one engine over those primitives. A backend may override an operation only with a genuine native fast path and otherwise falls back to the engine.
+`AGENTS.md` § Design laws owns the minimal-API, shim, polling, and product-policy laws. This section adds:
+
+- For multiple backends, implement shared querying/paging/aggregation in one engine over the smallest primitives. A backend may override an operation only with a genuine native fast path and otherwise falls back to the engine.
 - Centralize any pattern repeated twice.
 - Keep everything generic/reusable and free of unrelated-project logic.
-- Do not expand the capability set without concrete need. Once that capability exists intentionally,
-  its reusable top-level exports follow the earlier barrel rule without a second consumer gate.
-- Do not remove structural files because they are empty.
-- Prefer the smallest complete implementation that preserves architecture.
-- No deprecation aliases, compatibility shims, or backward-compatibility branches; update all consumers atomically.
-- No polling/busy loops or recursive microtasks as architecture. Park idle work on an event/abort wakeup and yield long work in cooperative quanta.
-- Framework/server utilities provide mechanism—HMAC, CORS, parsing, sessions, cookies, CSRF, static serving—not product policy such as user models, login flow, or authorization.
+- Mechanism in a framework or server utility means HMAC, CORS, parsing, sessions, cookies, CSRF, and static serving; product policy means user models, login flow, and authorization.

package/dist/host/claude/rules/browser.md

@@ -11,9 +11,10 @@ paths:
 
 # Vue and browser rules
 
+These rules govern Vue and browser code: where Vue lives, reactivity, composables, styling classes, and platform APIs. `AGENTS.md` § Project model owns the import boundaries of each face.
+
 - Publish only TypeScript composables and contracts from `src/vue`; put Vue single-file components
   in `app/vue`. Keep `.vue` files and `vue` imports out of `src/browser` and `app/browser`.
-  Apply `AGENTS.md` § Project model to imports from each Vue face.
 - Declare `vue` in the manifest as an optional peer only for the `./vue` export. Until that
   declaration exists, the `./vue` build refuses `vue`, `vue/*`, and `@vue/*`; after it, the build
   externalizes `vue` and its subpaths and still refuses `@vue/*`.
@@ -31,7 +32,5 @@ function useTheme(): {
 - Use utility classes for layout: flex, gap, spacing, sizing.
 - Use the framework's token-backed semantic classes for color/chrome: `.surface`, `.button`, `.muted`, `.accent`.
 - A `[data-theme]` change must retheme the whole interface through tokens.
-- Add custom SCSS only when no utility provides the behavior.
-- Integrate through the framework's Sass variables/functions instead of hand-rolled values.
-- Never write literal colors.
+- Add custom SCSS only when no utility provides the behavior, and write it per `.claude/rules/styles.md`, which owns literal colors and the pinned-recreation exception.
 - Prefer native platform APIs—Popover, `<dialog>`, `hashchange` routing, native events/storage/observers—over custom replacements or added dependencies.

package/dist/host/claude/rules/campaign.md

@@ -43,13 +43,13 @@ A package directory holds:
 ## Start a session
 
 1. Read the package folder's `README.md` when present, then `plan.md` § State, then the first open chunk of § Sequence.
-2. Run `git status --porcelain -b`, `git log @{upstream}..`, and `node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --report`. Reconcile each difference with § State before you act.
+2. Run `git status --porcelain -b`, `git log @{upstream}..`, and `node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --report`. Reconcile each difference with `plan.md` § State before you act.
 3. Act only on what the folder, the tree, and git hold. Agent memory from another machine or harness is absent.
 
 ## Hand off and close
 
 - Keep `plan.md` § State current at every commit, and make its last line the next action.
 - Before a session ends or its context compacts, write each ruling, decision, and next action into the folder; `.agents/orchestration.md` § Memory owns what memory can hold.
-- When a chunk closes, remove it from § Sequence. Its closing commit carries its evidence, and § State names the commit.
+- When a chunk closes, remove it from `plan.md` § Sequence. Its closing commit carries its evidence, and `plan.md` § State names the commit.
 - Delete a verdict file when its seam closes.
 - At acceptance, move each file that outlives the campaign to its root home, retarget its citations in the same change, and delete the package directory per `.agents/skills/orkestrel-debrief/references/retention.md`. Delete a top-level file when the wave or fleet campaign it records closes.

package/dist/host/claude/rules/documentation.md

@@ -14,8 +14,7 @@ paths:
 
 # Documentation and parity rules
 
-Documentation is an enforced contract, not explanatory decoration. The Writing rules in
-`AGENTS.md` govern its prose and are not restated here.
+Documentation is an enforced contract. These rules govern guides, parity, examples, agent-facing surfaces, and skill files; `AGENTS.md` § Writing and `.claude/rules/writing.md` govern their prose.
 
 ## Authority and workflow
 
@@ -44,18 +43,15 @@ Documentation is an enforced contract, not explanatory decoration. The Writing r
   rewriting, and remaining-drift reporting. Run `npm run test:guides` for read-only parity
   assertions. Use
   `npm run test:guides -- --to guide` or `npm run test:guides -- --to source` only when choosing
-  an explicit rewrite direction. Before adopting the generated command, implement its direct
-  entry and rewrite directions in the package-owned `tests/guides.test.ts`. Scaffold must not
-  synthesize or overwrite that authored proof. Update each fleet package's authored file before
-  its release. Never weaken the gate.
+  an explicit rewrite direction. The package authors `tests/guides.test.ts`.
 - The TSDoc voice rule governs a doc block, and a `Summary` cell carries that block's description
   paragraph, so the same voice governs the cell. A guide tagline and a README pitch are noun
   phrases, and each is the blockquote under its file's H1.
 - A vendored dependency guide is a mirror. Its relative links address the upstream tree and resolve to nothing here, so they are outside local-link parity. Refresh a mirror rather than rewriting it: a rewritten copy is a translation, and no comparison against the fetched bytes can check it.
 - Place a fence whose code is tab-indented outside a list item: inside one, `oxfmt` writes the item's continuation spaces before each tab, which `git diff --check` refuses.
-- Falsify a prose claim the way you falsify a code claim. The parity test proves a name exists, never that a sentence about behavior is true, so run the example and read what it returns. A `// false` beside a call that returns `true` is a defect of the same kind as a wrong return value, and it reaches every consumer who installs the package. That proof has a home: `tests/guides.test.ts` executes the flagship fences, per `.claude/rules/tests.md`. An ordered behaviour with no gate is not a gate.
-  Asserting that the sentence appears is not asserting that it is true. `expect(text).toContain('a spawn fault reports null')` passes unchanged when the code starts returning something else, so it guards the documentation's presence and nothing about the behaviour. Where a prose claim about behaviour sits under no fence, add the executed assertion that would break if the claim went false, and keep the substring check only as a presence guard beside it. A row whose close condition names a behaviour does not close on a substring.
-- Re-read the prose last, against what actually shipped. Where a change chose to document a limit rather than close it, the sentence was often drafted for the option that lost, or written more confidently than the code earns. Code rulings survive review because a test can falsify them; prose rulings survive because nothing tries.
+- Falsify a prose claim the way you falsify a code claim. The parity test proves a name exists, never that a sentence about behavior is true, so run the example and read what it returns. A `// false` beside a call that returns `true` is a defect. `tests/guides.test.ts` executes the flagship fences, per `.claude/rules/tests.md`.
+- Assert a prose claim about behaviour with an executed assertion that breaks if the claim goes false: `expect(text).toContain('a spawn fault reports null')` passes unchanged when the code starts returning something else. Keep a substring check only as a presence guard beside the executed assertion, and never close a row whose close condition names a behaviour on a substring.
+- Re-read the prose last, against what shipped. Where a change documents a limit rather than closing it, check that the sentence states the limit and neither describes the option that lost nor claims more than the code earns.
 
 For behavioral interfaces/classes:
 
@@ -80,6 +76,15 @@ Code fences import through the package's published specifier:
 
 Never use in-repository `@src/*` aliases in public guide examples; reserve them for source/tests.
 
+## Agent-facing surfaces
+
+A skill, a tool description, and a refusal message each teach an agent mid-task. When you write one:
+
+- Put the critical path in the tool description, most important first: a worked example, the key nesting, and the reply shape. A harness abbreviates a nested schema and delivers the description intact; never leave the teaching to the schema.
+- Make every refusal orient, name, or correct: state the subject, the exact key path, the expected shape, the valid candidates, and every missing and every unexpected item, in one refusal.
+- Refuse with the correction in the message. Never coerce a malformed input and never silently drop it. Encode an untrusted identifier in a diagnostic, JSON-encoded and length-capped, so malformed input cannot fake or balloon the message.
+- Acknowledge or state, never both: a mutation returns an acknowledgement and a read returns state. Say the split in both tools' descriptions so neither is polled for the other's job.
+
 ## Workflow skills
 
 - Skills prescribe reusable process; they do not copy naming, placement, syntax, lifecycle, or test laws from `AGENTS.md` and rules.
@@ -87,7 +92,7 @@ Never use in-repository `@src/*` aliases in public guide examples; reserve them
 - For a portable skill that teaches an external framework, takes the host project's own `AGENTS.md` file as its code law, and binds none of this repository's rule files, drop the `orkestrel-` prefix and name the skill for the framework a reader searches for. Add no other exception. The `enterprise-bootstrap` skill meets that test and keeps its name: it carries Bootstrap 5.3 craft, assumes no stack, and names the `.agents/orchestration.md` and `.claude/rules/quality.md` files only where they are present. Do not rename it into the namespace.
 - Keep `SKILL.md` concise and route conditional detail to one-level `references/`.
 - In a `SKILL.md`, name another skill's reference by that skill and the reference's title, never as a `references/<name>.md` path; the policy sweep attributes that token to the citing skill.
-- When you add a canonical skill, register it in `TARGET_SKILL_NAMES` in `src/core/constants.ts`, in the skill lists of `tests/distribution.test.ts`, `tests/src/core/Compiler.test.ts`, and `tests/src/core/compilers.test.ts`, and in the pointer-file count of `tests/src/bin/CLI.test.ts`, then regenerate `host.json` with a build.
+- In the `@orkestrel/scaffold` checkout, when you add a canonical skill, register it in `TARGET_SKILL_NAMES` in `src/core/constants.ts`, in the skill lists of `tests/distribution.test.ts`, `tests/src/core/Compiler.test.ts`, and `tests/src/core/compilers.test.ts`, and in the pointer-file count of `tests/src/bin/CLI.test.ts`, then regenerate `host.json` with a build.
 - Name every Markdown file in a skill's `references/` from its `SKILL.md`, and delete a reference nothing names.
 - Frontmatter contains only `name` and a trigger-focused `description`.
 - Set `name` to the skill's own directory name.
@@ -95,10 +100,18 @@ Never use in-repository `@src/*` aliases in public guide examples; reserve them
 - Do not put model routing or package version catalogs in a skill.
 - Validate every referenced resource, leave no template TODOs, and limit each skill directory to `SKILL.md`, `agents/openai.yaml`, the `references/*.md` files its `SKILL.md` names, and the `scripts/*.ts` files its `SKILL.md` names; add no other file or directory.
 - Put a repeatable or idempotent step of a skill in `scripts/<name>.ts`, run with `node .agents/skills/<skill>/scripts/<name>.ts` from the checkout root under Node's type stripping, and name the script, its arguments, and its exit codes from `SKILL.md` so an executor runs it instead of re-deriving the step. Name another skill's script by its full path under `.agents/skills/<skill>/scripts/`; the policy sweep attributes a bare `scripts/<name>.ts` token to the skill whose `SKILL.md` carries it and requires a qualified path to exist.
-- A skill script obeys `AGENTS.md`, `.claude/rules/typescript.md`, `.claude/rules/names.md`, and `.claude/rules/portability.md` as written, plus the no-nested-function and wrapper laws in `.claude/rules/architecture.md`, with these adaptations: an executable script exports nothing, runs `main` at the bottom, and carries the usage line and the exit codes in its opening comment; the types, constants, and helpers it alone needs live in the file, because the kind-file placement law stops at a self-contained script; what two scripts share lives in `.agents/skills/orkestrel-dispatch/scripts/helpers.ts`, the one shared module, which exports declarations with TSDoc, runs no entry point, and carries no usage line; a script imports `node:` modules and that module and nothing else, so the `@orkestrel/process` spawn rule yields to `child_process` there (a target may not declare that package), and imports it with the `.ts` extension, because the checkout runs a script unbuilt; and it spawns `process.execPath` or an executable by name with an argument array and never a shell, except the npm shim where no `npm-cli.js` sits beside the binary. Every script has a mirrored proof at `tests/agents/skills/<skill>/scripts/<name>.test.ts`: an executable script's proof drives it as a child process against a scratch fixture, and the shared module's proof imports it and tests each export. The policy sweep refuses a script without a proof, and a proof grows a case for every defect found.
+- Keep a skill script simple: one repeatable step its skill needs. It obeys `AGENTS.md`, `.claude/rules/typescript.md`, `.claude/rules/names.md`, and `.claude/rules/portability.md` as written, plus the no-nested-function and wrapper laws in `.claude/rules/architecture.md`, with these adaptations:
+  - It is self-contained: it declares every type, constant, and helper it needs even when another script declares the same one, and no file but its own proof imports it. The kind-file placement law stops at it, and the `@orkestrel/process` spawn rule yields to `child_process` there, because a target may not declare that package.
+  - It exports every top-level declaration, each with a doc block, so its proof can test each function.
+  - It runs `main` only when Node runs the file itself: `if (process.argv[1] !== undefined && realpathSync(process.argv[1]) === import.meta.filename)`. An import runs nothing. The `policy/no-malformed-script` lint rule refuses an unexported declaration, an export with no doc block directly above it, and any top-level statement other than an import, an exported declaration, or that one guard.
+  - Its opening comment carries the usage line and the exit codes.
+  - It spawns `process.execPath` or an executable by name with an argument array and never a shell, except the npm shim where no `npm-cli.js` sits beside the binary.
+
+  Every script has a mirrored proof at `tests/agents/skills/<skill>/scripts/<name>.test.ts`. The proof imports the script to test its functions, and drives it as a child process against a scratch fixture to test its command line. The policy sweep refuses a script without a proof and a proof that imports a file under `.agents/skills/` other than its own script, lint refuses a script import other than a `node:` module, and a proof grows a case for every defect found.
+
 - Run a script in a target through its built twin, `node node_modules/@orkestrel/scaffold/dist/agents/skills/<skill>/scripts/<name>.js`, because Node refuses to strip types for a file under `node_modules`; `.claude/rules/workspace.md` names the `build:skills` script that emits the twins. When a script spawns a sibling script, take the extension from the running file (`extname(fileURLToPath(import.meta.url))`), so the twin spawns `.js` and the checkout spawns `.ts`. When a script resolves a file under `.agents/templates/`, add that file to the copy in `build:skills`.
 - Resolve a sibling canon file (a template, another script) from the script's own location with `import.meta.url`, and the manifest, `tmp/`, and the test tree from the working directory, because a target runs the script from `node_modules/@orkestrel/scaffold/dist/agents/` against its own checkout.
-- Read arguments as `--flag value` pairs through the shared helpers: the first occurrence of a flag wins, a value that opens with `--` is a missing value, and `--flag=value` is not read. Where flags select different work (`--visit` or `--plan`), the script names one operation mode per run and refuses two; where each flag adds a section to one report (`--tree` with `--headings`), the script combines them and its usage line says so. Read a flag that repeats (`--range`) through `readOptions` and say in the usage line that it repeats. Exit 64 on every usage refusal and say on stderr what was refused: the usage line when no mode or two modes were given, and the flag with the value it takes when a flag was malformed or given with no value.
+- Read arguments as `--flag value` pairs: the first occurrence of a flag wins, a value that opens with `--` is a missing value, and `--flag=value` is not read. Refuse every argument before a bare `--` that opens with `--` and names no flag the script reads, the `--flag=value` form included, so a mistyped flag never runs the default; a bare `--` opens a command the script passes on. Where flags select different work (`--visit` or `--plan`), the script names one operation mode per run and refuses two; where each flag adds a section to one report (`--tree` with `--headings`), the script combines them and its usage line says so. Read every value of a flag that repeats (`--range`) and say in the usage line that it repeats. Exit 64 on every usage refusal and say on stderr what was refused: the usage line when no mode or two modes were given, and the flag with the value it takes when a flag was unknown, malformed, or given with no value.
 - Print to the terminal by default. Offer `--json` for a reader that parses, and `--out FILE` (`.txt` for a list, `.json` for a structure) where a lane reads the result later or the output would crowd a context; a written file saves the tokens a terminal dump spends. Choose per script; state each form in its usage line.
 - Verify each API a skill instructs an executor to call against the installed package's public entry before landing the instruction, and name the entry you read. A skill that names a symbol its package does not export teaches an executor to write a dangling import.
 - Put every symbol a skill teaches in a named import inside a Markdown fence in `SKILL.md` or a named reference. The policy sweep reads fenced value and type imports from `@orkestrel/*` declaration entries; it does not read identifiers in prose or table cells, or validate call signatures and runtime behavior.

package/dist/host/claude/rules/names.md

@@ -113,10 +113,15 @@ The root design laws in `AGENTS.md` — one term per concept, boolean behavior s
 - Prefer short common English; avoid jargon, abbreviations, and non-universal acronyms.
 - Properties are nouns; methods are verbs.
 - Booleans read as assertions: `aborted`, `exhausted`, `expired`.
+- Name an option, a field, a result, a record, a constant, or an action for the thing or the outcome, never with an -ing word, which reads as work in progress: `final`, not `closing`; `uniform`, not `framing`; `FrameResult`, not `FrameReading`; `CAPTURE_STAGE_LIMIT`, not `CAPTURE_STAGINGS`. Four kinds of -ing word remain:
+  - a noun that carries no tense (`string`, `binding`, `finding`, `heading`, `warning`);
+  - a name that mirrors an external field under the rule below (`encoding`, `CONNECTING`);
+  - a lifecycle state that is in progress when it is read (`pending`, `running`, `stopping`);
+  - an adjective naming a condition that holds when it is read (`blocking`, `missing`, `remaining`).
 - Accessors use bare nouns, never `get*`/`set*`.
 - Do not alternate `count`/`length`/`size`/`total` or `abort`/`cancel`.
-- Name the axis a discriminant varies: `relationship`, `command`, `category`, `operation`, `via`.
-- A binary switch is a boolean such as `bail`, never `'continue' | 'halt'`; genuine discriminants, multi-state lifecycles, conventional value pairs (`ascending`/`descending`, `and`/`or`), and external-spec literals remain unions.
+- Name the axis a discriminant varies; `operation` and `via` are axis names beside those `AGENTS.md` lists.
+- A binary switch such as `bail` is never `'continue' | 'halt'`; genuine discriminants, multi-state lifecycles, conventional value pairs (`ascending`/`descending`, `and`/`or`), and external-spec literals remain unions.
 - An option key, constant, or member that transliterates an external protocol field, format field, or engine pragma keeps the external wording in this project's casing, and its TSDoc names the source it mirrors: the `foreignKeys` key mirrors the `PRAGMA foreign_keys` statement, and the `keepAlive` key mirrors the Ollama `keep_alive` field.
 - Outside a declared wire body, a mirrored name never uses `kind` or `type` as a member name, and never uses a word § Rejected naming lists. A Compound File Binary (CFB) directory entry's object-type byte takes a named discriminant.
 - A declared wire body — a type whose members transliterate an external wire format field for field — keeps the external field names, `type` and `kind` included, and its TSDoc names the format it transliterates. The package's own domain type carries neither word, and the package owns the projection between the wire body and the domain type.
@@ -127,14 +132,14 @@ Give every bare exported name one owning package across the `@orkestrel` fleet.
 
 Check a public name against the fleet's published guides before adding it. The `surface` policy rule reports a name another package's guide already claims, and `.claude/rules/workspace.md` § Policy instruments fixes the instrument that reports it.
 
-The rule grandfathers a source name the target's own hosted guide claims, because that guide is the target's own claim to it. It grandfathers no root `tests/setup*.ts` export, so clear a colliding setup export before adopting the scaffold release that carries the rule. A vendored `tests/setup*.ts` module a scaffold release stages sits outside the inspected population.
+The rule grandfathers a source name the target's own hosted guide claims, because that guide is the target's own claim to it. It grandfathers no root `tests/setup*.ts` export. A vendored `tests/setup*.ts` module a scaffold release stages sits outside the inspected population.
 
 Resolve a reported collision with these rules, in order.
 
 1. **Reuse before renaming.** Where the colliding declarations carry the same contract, delete this one and import the owner's export. Declare the dependency that import needs, or stop and report that the dependency is not authorized.
 2. **The subject keeps the name.** Where the contracts differ, leave the name with the package whose domain the name describes, and rename the other declaration for the thing it is. Refuse a rename that makes the renamed declaration vaguer; name its own contract instead.
 3. **Qualify rather than extract.** Extract a shared package only where a proof shows the colliding declarations interchangeable and the dependency change is authorized. Otherwise qualify the name in place for the domain it serves, and route the extraction through a design round rather than renaming by fiat.
-4. **Close the collision in the code.** Change a declaration; the rule reads no allowlist a target can add a name to, and it carries no suppression. The committed `host.json` inventory in the `@orkestrel/scaffold` checkout records the collisions that predate this rule, and a release build refuses a staged collision that record does not already hold. Shrink that record by closing a collision, and never widen it to admit one. Never suppress the violation, and never edit a vendored policy instrument to clear it.
+4. **Close the collision in the code.** Change a declaration; the rule reads no allowlist a target can add a name to, and it carries no suppression. Never suppress the violation, and never edit a vendored policy instrument to clear it. In the `@orkestrel/scaffold` checkout, shrink the committed `host.json` collision record by closing a collision, and never widen it to admit one.
 
 ## Acronyms
 

package/dist/host/claude/rules/patterns.md

@@ -7,17 +7,16 @@ paths:
 
 # API pattern rules
 
+These rules govern the shape of options, managers, emitters, and contracts, and the reuse check that precedes a new primitive. `.claude/rules/architecture.md` places the files; `.claude/rules/names.md` names the members.
+
 ## Declared ecosystem capabilities
 
-Before writing a guard, parser, combinator, outcome, safe exception boundary, contract shape/compiler, schema utility, error narrower, emitter helper, or other general primitive:
+`AGENTS.md` § Non-negotiable rules owns the reuse law. Before writing a guard, parser, combinator, outcome, safe exception boundary, contract shape/compiler, schema utility, error narrower, emitter helper, or other general primitive:
 
 1. Inspect `package.json`, the lockfile, vendored dependency guides, and exact installed declarations/exports.
 2. Build a semantic overlap map between the proposed/local behavior and declared `@orkestrel/*` capabilities.
-3. Reuse the originating package directly when semantics match.
-4. Keep local behavior only when it adds a real domain invariant, composition, projection, translation, or intentionally different contract.
-5. Test the difference. Similar names are not proof of equivalent semantics.
-
-Never reimplement or rename-wrap a declared package primitive. Do not add an ecosystem dependency unless the user explicitly authorizes it.
+3. Keep local behavior only when it adds a real domain invariant, composition, projection, translation, or intentionally different contract.
+4. Test the difference. Similar names are not proof of equivalent semantics.
 
 ## Options
 
@@ -120,7 +119,7 @@ Use these orthogonal contract mechanisms:
 
 - Use plain guards/parsers for small contracts.
 - Use the shape DSL only when validation, serialization, and generation parity earns its complexity.
-- When `@orkestrel/contract` is declared, use its exact installed guards, parsers, combinators, outcomes, `attempt` boundary, and shape DSL wherever their semantics match. Do not maintain a local copy of those primitives.
+- When `@orkestrel/contract` is declared, use its exact installed guards, parsers, combinators, outcomes, `attempt` boundary, and shape DSL wherever their semantics match.
 - A guard never throws for any input, including cycles, deep nesting, revoked proxies, throwing accessors, or exotic prototypes; return false.
 - Recursive guards track ancestors and cap depth.
 - Recursion enters only through an explicit lazy gate.

package/dist/host/claude/rules/portability.md

@@ -93,7 +93,7 @@ and the form of a conditional skip.
 - Write every `package.json` script as a portable command: a Node invocation or an installed binary.
   Never name a `.sh` file there.
 - Keep `#!/usr/bin/env node` on an npm bin. npm writes the Windows shim from it.
-- Keep `scripts/` for the Claude Code Cloud session hooks alone, in bash, with `.gitattributes` `eol=lf`. Every other script is TypeScript run by Node per `AGENTS.md`; a skill's scripts live in its `scripts/` directory.
+- Give the Claude Code Cloud session hooks in `scripts/`, the one bash exception `AGENTS.md` admits, `.gitattributes` `eol=lf`. The policy sweep refuses a shell, PowerShell, Python, or batch file outside `scripts/` and any file but a `.sh` file inside it.
 - Spawn a command from a script with an argument array and no shell, so quoting is the same on every host; resolve a `.cmd` shim to the JavaScript entry it wraps rather than spawning the shim.
 
 ## Claims

package/dist/host/claude/rules/quality.md

@@ -8,6 +8,8 @@ paths:
 
 # Evidence, probes, and completion rules
 
+These rules govern how a claim is established: the evidence read before a change, the probes and instruments that settle a question, performance measurement, and the completion check.
+
 ## Evidence before change
 
 - Read the authoritative `types.ts` and the decision-bearing implementation first-hand. Delegate bulk reading, never the owning decision.
@@ -34,7 +36,7 @@ paths:
 - When the question supplies no project, no case, or no control, write a probe per `.claude/rules/tests.md` § Probes and report the probe's control and coverage.
 - When no `probe` server is registered, register one outside the repository in the harness's user or local MCP scope, pointing at `node_modules/@orkestrel/probe/dist/bin/main.js`, and start it in the repository whose projects the question names. A scaffold target holds no `.mcp.json`.
 - When a question concerns what a rendered page shows or does, drive the page through the tools the `browse` MCP server registers and read what they return before arguing from source. Accept a surface through journey tests, never through a `browse` session; `.agents/skills/orkestrel-journey/references/recorded.md` rules how a recorded journey counts.
-- When no `browse` server is registered and the workspace declares `@orkestrel/browser`, register one outside the repository in the harness's user or local MCP scope, running `node` with the argument `node_modules/@orkestrel/browser/dist/bin/main.js`, and start it in the repository root. Leave `BROWSE_ROOT` unset so the server writes under `tmp/browsers/`. Set `BROWSE_HEADLESS=false` only while a person watches the window, `BROWSE_READONLY=true` to refuse `record`, `save`, `edit`, and `forget`, and `BROWSE_EXECUTABLE` to a Chromium executable when the server finds none.
+- When no `browse` server is registered and the workspace declares `@orkestrel/browser`, register one outside the repository in the harness's user or local MCP scope, running `node` with the argument `node_modules/@orkestrel/browser/dist/bin/main.js`, and start it in the repository root. Leave `BROWSE_ROOT` unset so the server writes under `tmp/browsers/`, and set `BROWSE_HEADLESS=false` only while a person watches the window. `guides/browser.md` § Register the browse binary with Claude Code lists every `BROWSE_*` variable.
 - When the workspace builds the surface into a `showcase/<application>.html` page, serve that page before navigating: run the `build:showcase` script, or the `build:showcase:<framework>` script for a framework mode, then serve the `showcase/` directory with `npx vite preview --config configs/app/vite.showcase.config.ts` and navigate to the page by its file name. Never navigate to a `file:` URL; `browse` refuses every scheme but `http:` and `https:`.
 - When the workspace builds no showcase page for the surface, or the question needs what one HTML file does not carry (a second route, a separately requested asset, or a source edit shown without a rebuild), start the `dev` script, or the `dev:<framework>` script for a framework face, and navigate to the address the script prints.
 - When the surface calls an API, start every server it calls before navigating, each on a port apart from the page's server: a third-party backend by its own start command, and the project's `src/server` or `app/server` surface by the script that starts it, which is the `serve:build` script for `app/server`.
@@ -57,9 +59,8 @@ paths:
 
 ## Ecosystem reuse
 
-- Prove a semantic difference before keeping a local variant of an installed primitive.
+- Prove a semantic difference before keeping a local variant of an installed primitive, per `.claude/rules/patterns.md` § Declared ecosystem capabilities.
 - Fix a reusable defect in the lowest package that owns the mechanism; keep product policy downstream.
-- Never re-export a dependency's symbol.
 
 ## Production hardening
 
@@ -68,9 +69,7 @@ paths:
 - Test observable invariants at each seam with real implementations; use a dedicated real-service project for external behavior.
 - Treat "works with an external client" as unproven until one representative real client has driven it end to end.
 - Audit test discovery, counts, skipped and todo tests, cleanup, and assertion adequacy before acceptance. Coverage is not adequacy.
-- Add an independent review for security, destructive paths, concurrency, protocols, or untrusted input, per the size gate in `.agents/orchestration.md`.
 
 ## Completion
 
 - Sweep centralization, wrappers, test helpers, and text integrity after implementation and before gates.
-- Stop when the enumerated scope is closed and the gates the size gate names are green. The next scope is the deliverable; a further pass needs a further instruction from the user.

package/dist/host/claude/rules/styles.md

@@ -59,8 +59,8 @@ SCSS mirrors TypeScript centralization. Concrete token prefixes are project-spec
   custom-property value is the one text Sass emits verbatim, so write every custom-property
   declaration in a literal partial as a Sass string interpolation (`--name: #{'VALUE'};`), which the
   formatter reads as a string and Sass emits byte for byte. Keep a pinned expected output in a JSON
-  fixture, never in a CSS file the formatter would canonicalise. The face's byte proofs (link 1, the
-  per-module region cases, the sample cases) hold under `npm run format`.
+  fixture, never in a CSS file the formatter would canonicalise. The face's byte proofs hold under
+  `npm run format`.
 - Never repeat per-color/per-variant blocks; drive shared structure with one `@each` over a shared list.
 - If a pattern appears in at least two partials, move it to `_mixins.scss`.
 - Treat a declaration block two partials share because each records an external value as a