@orkestrel/scaffold 0.0.21 → 0.0.23

package/dist/host/claude/agents/scout.md

@@ -7,7 +7,7 @@ effort: low
 ---
 
 You are the **Scout** — the cheap native reconnaissance lane in this project's
-role set (see CLAUDE.md). You answer "where does X live, what shape is it, what
+role set (see .agents/orchestration.md). You answer "where does X live, what shape is it, what
 touches it" so the Orchestrator can write a precise dispatch. You are an
 Executor: spawn nothing.
 
@@ -15,10 +15,13 @@ Executor: spawn nothing.
 
 - Read **AGENTS.md** first; the repository model and rule map orient every
   answer. This charter restates nothing they own.
+- Reconnaissance belongs to Grok first. You are the last step of the tedious-work
+  ladder — Grok, then Luna on Codex, then you — so a dispatch reaching you should
+  already record why the benches above it were unavailable.
 - Locate, do not absorb: read excerpts sufficient to identify a seam, an owner,
-  or a shape — deep reading and synthesis belong to the `grok` bench, and
-  quality judgment belongs to the review roles. If the question needs either,
-  say so instead of drifting into it.
+  or a shape. Deep reading and synthesis belong to the `grok` bench, and quality
+  judgment belongs to the review roles. If the question needs either, say so
+  instead of drifting into it.
 - Return pointers, not prose: `file:line` for every claim, the minimal shape
   summary the question needs, and an explicit list of places searched that came
   up empty — an absence claim is only as good as its named search.

package/dist/host/claude/agents/verifier.md

@@ -8,7 +8,7 @@ permissionMode: default
 ---
 
 You are the **Verifier** — the independent gate runner in this project's role set
-(see CLAUDE.md). No builder's self-report counts as gate evidence. You are an
+(see .agents/orchestration.md). No builder's self-report counts as gate evidence. You are an
 Executor: run the gates yourself, spawn nothing.
 
 ## Job

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

@@ -25,15 +25,17 @@ 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/server integration crosses a contract/transport boundary. Neither
-  environment imports the other's implementation. `.oxlintrc.json`
-  `no-restricted-imports` enforces declared package, alias, and conventional
-  relative import direction. Scoped TypeScript configurations remove Node/DOM
-  globals from the wrong environment. Vite's actual browser and server builds
-  resolve Vue, assets, CSS, workers, and runtime module graphs. Generated
-  consumers must pass lint, scoped typechecking, production builds, and real
-  integration tests. Do not introduce a custom parser or source-language
-  analyzer to duplicate the project toolchain.
+- Browser and server integrate across a contract and transport boundary. Neither
+  environment imports the other's implementation.
+- Four tools enforce that boundary, and none of them is replaceable by a custom
+  parser or source-language analyzer: `.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 resolve Vue, assets, CSS,
+  workers, and runtime module graphs; and generated-consumer tests exercise all
+  three.
+- Generated consumers must pass lint, scoped typechecking, production builds, and
+  real integration tests.
 - Scoped checks include `.ts`, `.tsx`, `.mts`, and `.cts`. Vue SFCs and CSS
   belong to browser environments; SCSS requires an authorized compiler dependency.
 - Published `src` environments never import private `app` modules. Src core is
@@ -43,13 +45,12 @@ paths:
 - App-only manifests are unscoped and `private: true`, with no package export
   map or publish configuration. Mixed manifests publish only `dist/src`, and
   Vue remains development-only because app output is never published.
-- app/server process signals belong to a tested, explicitly stoppable,
-  generation-safe runner whose stale failures cannot release a newer run;
-  convenience startup returns the runner so normal cleanup cannot be hidden.
-  `ApplicationServerRunner` lives alone in `ApplicationServerRunner.ts`, and the
-  `startApplicationServer` convenience factory belongs in `factories.ts`.
-  `main.ts` invokes it and owns no reusable declarations or duplicated signal
-  handling.
+- 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`. The
+  `startApplicationServer` convenience factory belongs in `factories.ts`. `main.ts`
+  invokes it and owns no reusable declarations or duplicated signal handling.
 - Do not add showcase, auth, storage, proxy, CSS framework, or other product
   policy unless the request requires it.
 - Test repeated lifecycle, concurrent calls, malformed environment input,

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

@@ -13,26 +13,27 @@ paths:
 
 ## Centralized-file pattern
 
-| Content                   | Sole location                                |
-| ------------------------- | -------------------------------------------- |
-| Interfaces/types          | `*/types.ts`                                 |
-| Constants/data            | `*/constants.ts`                             |
-| Pure helpers              | `*/helpers.ts`                               |
-| Guards                    | `*/validators.ts`                            |
-| Guard combinators         | `*/combinators.ts`                           |
-| Owned snapshots           | `*/cloners.ts`                               |
-| Coercers                  | `*/parsers.ts`                               |
-| Shape values              | `*/shapers.ts`                               |
-| Value inferers            | `*/inferers.ts`                              |
-| Shape/algorithm compilers | `*/compilers.ts`                             |
-| Entity/value factories    | `*/factories.ts`                             |
-| Middleware factories      | `*/middlewares.ts`                           |
-| Seeders                   | `*/seeders.ts`                               |
-| Schemas                   | `*/schemas.ts`                               |
-| Relations                 | `*/relations.ts`                             |
-| Error classes/guards      | `*/errors.ts`                                |
-| Public exports            | `*/index.ts`                                 |
-| Implementations           | `*/[domain]/[Entity].ts`, one class per file |
+| Content                   | Sole location                                                |
+| ------------------------- | ------------------------------------------------------------ |
+| Interfaces/types          | `*/types.ts`                                                 |
+| Constants/data            | `*/constants.ts`                                             |
+| Pure helpers              | `*/helpers.ts`                                               |
+| Guards                    | `*/validators.ts`                                            |
+| Guard combinators         | `*/combinators.ts`                                           |
+| Owned snapshots           | `*/cloners.ts`                                               |
+| Coercers                  | `*/parsers.ts`                                               |
+| Shape values              | `*/shapers.ts`                                               |
+| Value inferers            | `*/inferers.ts`                                              |
+| Shape/algorithm compilers | `*/compilers.ts`                                             |
+| Entity/value factories    | `*/factories.ts`                                             |
+| Middleware factories      | `*/middlewares.ts`                                           |
+| Seeders                   | `*/seeders.ts`                                               |
+| Schemas                   | `*/schemas.ts`                                               |
+| Relations                 | `*/relations.ts`                                             |
+| Error classes/guards      | `*/errors.ts`                                                |
+| Public exports            | `*/index.ts`                                                 |
+| Implementations           | `*/[domain]/[Entity].ts`, one class per file                 |
+| Function modules          | a designated folder's `[function].ts`, one function per file |
 
 Use only the centralized files an environment needs.
 
@@ -40,6 +41,7 @@ Use only the centralized files an environment needs.
 
 - An implementation file contains imports and exactly one class implementation with `#` fields.
 - It contains no module-scope interface, type, constant, or free function—even when private to that file.
+- A function module contains imports and exactly one exported function named for its file. Everything else extracts by kind exactly as it does from a class module.
 - Extract local declarations by kind. “Only used here” and “not exported” are not exemptions.
 - Every declaration in a centralized file is exported. Fold away a trivial single-use declaration or export/test it; never leave it hidden.
 - The only permitted non-exported module-scope declarations are in a runtime entrypoint that must be self-contained and cannot import siblings, such as raw source loaded in a worker. Explain that necessity in a comment.
@@ -120,6 +122,15 @@ Store child managers in `#` fields and expose readonly getters typed as their in
 - Keep its interfaces in module-root `types.ts`, factories in module-root `factories.ts`, and exports in the module barrel.
 - Entity subfolders never grow their own centralized files.
 
+### Kind or folder
+
+- A word is either a centralized kind or a domain folder, never both.
+- A folder named for a centralized kind—`helpers/`, `validators/`, `handlers/`—is that kind's file, not a folder.
+- Read a function domain from the fleet-canon register (`tests/setupPolicy.ts`,
+  `FUNCTION_DOMAIN_FOLDERS`). Never infer one from a folder's name; a camelCase module inside an
+  undesignated folder is misplaced.
+- Request a new domain through a fleet-canon change. There is no workspace-local registration path.
+
 ### Extension categories
 
 - A designed extension point—drivers, stores, transports—gets its category folder even with one concrete class.
@@ -153,6 +164,12 @@ Both obey:
   barrel row.
 - 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 should 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.
 - When a symbol moves, update every import; never leave a compatibility re-export.
 
 ```ts
@@ -167,12 +184,14 @@ export * from './greeters/Greeter.js'
 
 ## System constraints
 
-- Build a capability with its first real consumer; do not speculate.
+- 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.
 - Centralize any pattern repeated twice.
 - Keep everything generic/reusable and free of unrelated-project logic.
-- Do not expand public API without concrete multi-site need.
+- Do not expand the capability set without concrete need. Once that capability exists intentionally,
+  its reusable top-level exports follow the barrel rule above without a second consumer gate.
 - Do not remove structural files because they are currently empty.
 - Prefer the smallest complete implementation that preserves architecture.
 - No deprecation aliases, compatibility shims, or backward-compatibility branches; update all consumers atomically.

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

@@ -14,7 +14,8 @@ paths:
 
 # Documentation and parity rules
 
-Documentation is an enforced contract, not explanatory decoration.
+Documentation is an enforced contract, not explanatory decoration. The Writing rules in
+`AGENTS.md` govern its prose and are not restated here.
 
 ## Authority and workflow
 

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

@@ -174,12 +174,13 @@ For `_` bindings:
 
 ## Files and folders
 
-| Kind           | Pattern                                      |
-| -------------- | -------------------------------------------- |
-| Domain folder  | lowercase plural entity: `agents/`, `tools/` |
-| Implementation | PascalCase entity: `Agent.ts`                |
-| Test           | PascalCase entity + `.test`: `Agent.test.ts` |
-| Guide          | lowercase domain: `agents.md`                |
+| Kind            | Pattern                                                                          |
+| --------------- | -------------------------------------------------------------------------------- |
+| Domain folder   | lowercase plural entity: `agents/`, `tools/`                                     |
+| Implementation  | PascalCase entity: `Agent.ts`                                                    |
+| Function module | camelCase function: `renderGrid.ts`                                              |
+| Test            | source filename without extension + `.test`: `Agent.test.ts`, `useTheme.test.ts` |
+| Guide           | lowercase domain: `agents.md`                                                    |
 
 ## Fixed lifecycle vocabulary
 

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

@@ -15,43 +15,90 @@ paths:
 
 ## Evidence before change
 
-- Research is mandatory when the user requests it, when comparing an upstream/protocol/legacy implementation, or when current external behavior materially affects design.
-- Use current primary sources for external capabilities and exact installed declarations/guides for dependencies. Separate verified fact from inference.
-- Read authoritative types and named decision-bearing implementation files first-hand. Delegate bulk supporting context, not the owning design decision.
-- Treat existing code, tests, `old/`, branches, and copied projects as evidence rather than authority.
+- Research when the user asks for it, when comparing an upstream, protocol, or legacy implementation, or when current external behavior materially affects design.
+- Use current primary sources for external capabilities, and the exact installed declarations and guides for dependencies. Separate verified fact from inference.
+- Read authoritative types and named decision-bearing implementation files first-hand. Delegate bulk supporting context, never the owning design decision.
+- Treat existing code, tests, `old/`, branches, and copied projects as evidence, not authority.
 - Build a capability/defect matrix before a broad API or production-readiness change. Every row ends as implement, repair, retain, or intentionally exclude with evidence.
+- Fix that matrix when the change starts. It is the definition of done, and the change closes when every row closes.
+- Never end a row as "hardened further." Replace any evaluative phrase with the concrete condition that closes the row.
+- Record a finding outside the matrix against the row that owns it, for the next matrix. Do not reopen this one.
+
+## Run it, don't argue it
+
+A question a probe can settle is settled by the probe, whether or not anyone has disputed it. Reasoning decides what to run and what the result means. It does not replace the run.
+
+This is a habit for your own work first, and a rule about disagreements second. Most unverified beliefs are never challenged by anyone — they are simply built on.
+
+- Test your own assumptions before you rely on them. You do not need a disagreement to justify a probe. If you are about to depend on what a function returns, what a config resolves to, what a flag does, or whether a path is even reached, run it and find out.
+- Treat a long deliberation about behaviour as the signal to stop and run something. Deliberation that a ten-line probe would have ended is the most expensive habit in this process, and it is invisible because it feels like rigour.
+- Verify a belief before stating it, or label it as unverified. An unverified assertion put into context becomes a fact for everything downstream, including other agents, and correcting it later costs more than the check would have.
+- Prefer the check over the chain of reasoning whenever the check is cheap. Reading the installed declaration, running one line, or counting the call sites beats three paragraphs inferring the same thing, and it produces evidence you can hand to someone else.
+- Write the probe before the argument gets long. The moment a claim about behaviour is disputed — between engines, between a report and a rule, or in your own head — stop and run it. Get the smallest real input through the real code and read the real output.
+- Bound the search before starting it, and put the bound in the brief. Name the benchmark, the population, or the row that ends it. An investigation with no stated stopping condition runs until attention runs out. This includes the case where the honest answer is that the limit is inherent and belongs in documentation rather than in code.
+- Treat a negative probe as evidence about the probe until its input is shown to reach the code under test. A pass proves nothing if the vector never arrived. Instrument the path, assert an observable side effect, or drive it through a door you can see.
+- When a report names a defect and your reproduction comes back clean, assume first that your vector was weaker than theirs, and go get their exact vector. Treating a failed reproduction as a disproof is the most common way a true finding is lost.
+- Do not read a result into a tool's failure to find your probe. "No tests found", an empty match, a skipped file, a runner that resolved nothing — these report on the harness, not the subject. Confirm the probe was collected and executed first.
+- Prefer an observation over a derivation, including your own. When a measurement and an argument disagree, the argument is wrong until the measurement is shown to be broken.
+- Diagnose from the artifact the work produces — the file, the count, the exit code, the timestamp on what changed — never from a wrapper or a proxy signal that merely correlates with progress.
+- Verify a comment or an agent's report against the call sites before relying on it. A code comment is not evidence. When two lanes disagree about whether a path is live, count the callers rather than weighing the prose.
+- What a round proves is what it ran. A conclusion carried from one door to another is a hypothesis at the second door. Re-run it there.
 
 ## Falsification
 
-A review that reads a diff finds what the diff shows; a review that tries to break named claims finds what the diff hides. Code that has already passed diff review several times can still carry a defect nobody has yet tried to trigger.
+A review that reads a diff finds what the diff shows. A review that tries to break named claims finds what the diff hides. Code that has passed diff review several times can still carry a defect nobody has tried to trigger.
+
+### Writing the claims
 
-- State an audit's subject as a numbered list of the claims the work makes, never as “review this diff”. Each claim is falsifiable: a property some concrete input, state, or interleaving could show false.
-- Instruct the auditor to attempt refutation rather than confirmation. A claim it cannot break is reported CONFIRMED with the evidence that convinced it; a claim it breaks is reported BROKEN with the exact failing input, state, or interleaving, plus the smallest correct fix.
+- State the subject as a numbered list of the claims the work makes, never as "review this diff." Each claim is falsifiable: a property some concrete input, state, or interleaving could show false.
+- Instruct the auditor to attempt refutation, not confirmation. A claim it cannot break is CONFIRMED with the evidence that convinced it. A claim it breaks is BROKEN with the exact failing input, state, or interleaving, plus the smallest correct fix.
 - Derive claims from what the change asserts under adverse conditions: cancellation, restart, concurrency, partial failure, hostile input, resource exhaustion, and the orderings a happy path never reaches.
 - Read the installed declaration or implementation of every substrate a claim depends on. A claim about `stop()` is unfalsifiable until you know what `stop()` does when the status is not the one the caller assumed.
-- An audit returning only confirmations has either audited trivial claims or has not tried. Name the claims you could not break, so the next round knows what has already been attacked.
+
+### Instruments
+
+- An instrument is not evidence until it has failed. Pair every probe, comparison, or matrix with a negative control that must report failure, run under the same conditions. An identity check whose control reports "same" has measured nothing.
+- Draw the negative control from outside the population the instrument covers. Name the instrument's membership rule first, then pick a control that rule excludes. A control sampled from constructs the instrument already handles proves only that it discriminates among those constructs, and says nothing about the class it silently cannot reach.
+- State what the controls established and what they did not. An instrument certified only from the inside is trusted exactly where it has never been tested.
+- Treat a gap between what an instrument says it checks and what it actually matches as a defect in the instrument, not as a documented limit. A recorded blind spot buys trust only when everything outside it is genuinely covered.
+- Measure the product, not the harness. A recorded baseline that counts something about its own fixture is not evidence about the shipped surface, however often a guide quotes it.
+- Adopt an instrument that settled a claim as a test before accepting the work it settled. The probe that proved a fix, carrying the control that proved the probe, is that fix's regression guard. A verification that runs once is a rehearsal, not a gate.
+
+### Rounds and verdicts
+
+- Treat an all-confirmed round as a legitimate result, and put the brief on trial rather than the subject. Re-read the claims and ask whether any could have been falsified by evidence the round actually had. If none could, the claims were descriptive and the round proved nothing — sharpen them and re-run. If they could have been and were not, the pass stands.
+- Name the claims you could not break either way, so the next round knows what has already been attacked.
+- Never tell an auditor that a clean round means it did not try. That instructs it to manufacture a finding, and a manufactured finding costs a fix unit, an argument, and the credibility of the true findings beside it.
+- Treat a repaired claim as a new claim, not a settled one. Re-ask it at every entry point that reaches the same rule, not only the door the defect arrived through. The engine that wrote the fix is least able to see this, because re-verifying where the fix is feels like verifying the fix.
+- Let reachability bound the fix. A defect reachable through the package's own shipped code or a documented extension seam falsifies its claim and is repaired now.
+- Document the obligation instead when a defect is reachable only through a hypothetical foreign implementation of a contract this package publishes. State it on the interface that owns it and prove the documentation. Do not build coordination machinery against a requirement nobody wrote down. Attacks are unlimited; reachable ones are not, and only the reachable set is a work list.
+- **Three rounds at one seam is the budget.** Repeated rounds against one seam are evidence about the design, not evidence of diligence. At the third round the next unit is a ruling — on the threat model, the mechanism, or the boundary — taken with the same adversarial pass a design gets, not a fourth repair.
+- Write the round count down when the seam opens, so it is a fact rather than a feeling. A seam that has consumed more rounds than the rest of the matrix combined has already answered the question.
+- Give every behavioural audit the means to run its attacks. An auditor that cannot execute cannot falsify a behavioural claim: it returns derivations, and a derivation reads exactly like a verdict while being a different thing — it will confirm a claim one probe would break. Treat a report with no executed evidence as a review of the source, and label it as such.
 
 ## Ecosystem reuse
 
-The root laws on inspecting declared `@orkestrel/*` capabilities, reusing a matching primitive, and updating every consumer without shims bind here without restatement. They leave this file the judgment calls:
+The root laws on inspecting declared `@orkestrel/*` capabilities, reusing a matching primitive, and updating every consumer without shims bind here without restatement. This file adds the judgment calls:
 
-- Prove the semantic difference before keeping a local variant; similar names are not evidence of different behavior.
-- Downstream friction is valid evidence of a reusable upstream defect, not automatic proof. Fix the lowest package that owns the general mechanism and keep product policy downstream.
+- Prove the semantic difference before keeping a local variant. Similar names are not evidence of different behavior.
+- Treat downstream friction as valid evidence of a reusable upstream defect, not as automatic proof. Fix the lowest package that owns the general mechanism and keep product policy downstream.
 - Never re-export a dependency's symbol to soften a consumer's import.
 
 ## Production hardening
 
-- Translate “enterprise-grade” or “production-ready” into an explicit risk/seam matrix covering applicable inputs, states, failures, cleanup, cancellation, concurrency, resource ownership, hostile boundaries, environment isolation, serialization/restore, and package consumption.
+- Translate "enterprise-grade" or "production-ready" into an explicit risk and seam matrix covering applicable inputs, states, failures, cleanup, cancellation, concurrency, resource ownership, hostile boundaries, environment isolation, serialization and restore, and package consumption.
+- Grade that matrix on coverage, not optimization: whether every applicable seam exists, works, and stays proven. Do not grade on how many further interleavings can be invented against the one seam already proven. A surface polished past its row buys less than the next uncovered seam would have.
 - Test observable invariants at each applicable seam with real implementations.
-- Use dedicated real-service projects for external model/service behavior. Require readiness and tune each request to the smallest robust proof.
-- Audit test discovery, counts, skipped/todo tests, cleanup, and assertion adequacy; passing discovered tests alone is insufficient.
+- Use dedicated real-service projects for external model or service behavior. Require readiness and tune each request to the smallest robust proof.
+- Audit test discovery, counts, skipped and todo tests, cleanup, and assertion adequacy. Passing discovered tests alone is insufficient.
 - Inspect public exports, declarations, supported runtime targets, and generated outputs.
-- A claim that a surface works with an external client stays unproven until one representative real client of that class has driven it end to end. Protocol tests prove the protocol, not the integration.
+- Treat a claim that a surface works with an external client as unproven until one representative real client of that class has driven it end to end. Protocol tests prove the protocol, not the integration.
 - Add an independent adversarial review for security, destructive paths, concurrency, protocols, or untrusted external input.
 
 ## Completion
 
-The root completion law — finish every in-scope capability now, leave no TODO, deferral, or hidden follow-up, and run the applicable repository skill for comprehensive work — binds here without restatement. It leaves this file two obligations:
+The root completion law — finish every in-scope capability now, leave no TODO, deferral, or hidden follow-up, and run the applicable repository skill for comprehensive work — binds here without restatement. This file adds three obligations:
 
-- Perform a final centralization/wrapper/test-helper/text-integrity sweep after implementation and before gates.
-- Local quality gates and relevant output inspection are required evidence.
+- Perform a final centralization, wrapper, test-helper, and text-integrity sweep after implementation and before gates.
+- Produce local quality gates and relevant output inspection as required evidence.
+- Stop once the enumerated scope is closed and those gates are green. Stopping there is correct, and the next scope is the deliverable. A further pass over the same surface requires a new instruction from the user, not an auditor's remaining appetite. Depth is owed to what the scope names, not to what an engine can still imagine about it.

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

@@ -35,7 +35,7 @@ SCSS mirrors TypeScript centralization. Concrete token prefixes are project-spec
 
 ## Prohibitions
 
-- Verify every treatment against the shipped resolved cascade — the compiled output plus the stylesheet of every dependency the consumer loads — before accepting it. A dependency's own default rules, not documentation or memory, decide what a bare element renders as.
+- Verify every treatment against the shipped resolved cascade before accepting it: the compiled output plus the stylesheet of every dependency the consumer loads. A dependency's own default rules decide what a bare element renders as — not documentation, and not memory.
 - Check `_tokens.scss` before inventing a token.
 - Put global tokens in `_tokens.scss`; put truly component-scoped custom properties on the component selector.
 - Never bury tokens in unrelated partials.

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

@@ -11,13 +11,14 @@ paths:
 ## Test contract
 
 - Mirror source/application structure:
-  `tests/{src,app}/[environment]/[domain]/[Entity].test.ts`.
+  `tests/{src,app}/[environment]/[domain]/[source].test.ts`.
 - Prefer test filenames matching entrypoints: `index.test.ts` for `index.ts`, `main.test.ts` for `main.ts`.
 - Tests are deterministic: identical inputs produce identical results.
 - Keep default suites fast: timers normally use 10–50 ms and tests make no network calls.
 - Use real implementations and small scenarios. Never use mocks, behavioral fakes, module replacement, or framework spies for project-owned or integrated behavior.
 - Use recorders for calls/events, temporary resources for stateful boundaries, protocol-faithful fixture servers for deterministic network peers, and the real external service when its behavior is the claim.
-- Prefer inert customizable data/input stubs. A scripted boundary stub is allowed only when it implements the real interface/protocol minimally to drive the system under test; it never reimplements project-owned behavior or stands in for the integration being claimed.
+- Prefer inert customizable data and input stubs.
+- Allow a scripted boundary stub only when it implements the real interface or protocol minimally, to drive the system under test. It never reimplements project-owned behavior and never stands in for the integration being claimed.
 - Cover happy paths, error paths, empty input, boundary values, `NaN`, positive/negative zero, cycles, and Map/Set order where relevant.
 - Test observable behavior, not implementation details.
 - A regression test records the exact command and its failing count before the fix, and the same command's passing count after.
@@ -115,11 +116,16 @@ Keep Vitest/provider configuration minimal:
 
 Before accepting that a behavior cannot be tested, look for the seam that would make it testable.
 
-- A collaborator reached through a hard-coded global — a stream, a clock source, a spawn, a fetch — is a missing injection point, not an untestable truth. An injected collaborator with a real minimal implementation is a sanctioned boundary stub, not a mock of project-owned behavior.
-- Prefer adding the seam over shipping the gap whenever the seam is one the design would welcome anyway, and whenever a sibling collaborator is already injected.
-- When a gap is genuinely irreducible, record it where a reader meets it: what is unproven, why it cannot be driven, and what would change that. A silent untested guard reads exactly like a tested one.
+- Treat a collaborator reached through a hard-coded global — a stream, a clock source, a spawn, a fetch — as a missing injection point, not an untestable truth.
+- An injected collaborator with a real minimal implementation is a sanctioned boundary stub, not a mock of project-owned behavior.
+- Add the seam rather than shipping the gap whenever the design would welcome it anyway, and whenever a sibling collaborator is already injected.
+- Record a genuinely irreducible gap where a reader meets it: what is unproven, why it cannot be driven, and what would change that. A silent untested guard reads exactly like a tested one.
 
-Coverage reporting is a discovery input, never evidence of proof. It answers one cheap mechanical question — which code no test even executed — and that question reliably finds forgotten branches and rules nothing calls. It cannot tell you whether an executed line is asserted, so a fully covered file can still be entirely unproven. Read a coverage report to find candidates for the adequacy audit; never cite it as the audit's result, and never let a percentage become the target.
+Coverage rules:
+
+- Read a coverage report as a discovery input, never as evidence of proof. It answers one cheap mechanical question — which code no test executed — and that reliably finds forgotten branches and rules nothing calls.
+- Never cite coverage as the adequacy audit's result. It cannot tell you whether an executed line is asserted, so a fully covered file can still be entirely unproven.
+- Never let a percentage become the target.
 
 ## Discovery and adequacy audit
 

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

@@ -63,7 +63,7 @@ type Result<T, E = Error> = Success<T> | Failure<E>
 
 ## Comments and API documentation
 
-- Comments explain why, never restate what self-explanatory code does.
+- Comments explain why, never restate what self-explanatory code does. The Writing rules in `AGENTS.md` govern their prose.
 - Every public export has complete TSDoc: description, `@param`, `@returns`, and `@example` where applicable.
 - Document an options object as one `@param`; describe its short fields under `@remarks`.
 - Private methods and overload-specific notes use single-line `//` comments, not public TSDoc.

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

@@ -30,8 +30,8 @@ Use only the environments a project needs, and keep the root dependency model in
 | `configs/`     | Thin target wrappers around root configs           |
 
 - Dependency direction is the root project model in `AGENTS.md` and is not restated here; this file governs where the environments live and how they are configured.
-- Typical browser-app domains: `components/`, `pages/`, `composables.ts`, `controllers/`, `services/`, `stores/`.
-- Typical server-app domains: `handlers/`, `middlewares.ts`, `routes.ts`.
+- Typical browser-app domains: `components/`, `pages/`, `composables/`, `controllers/`, `services/`, `stores/`.
+- Typical server-app domains: `handlers.ts`, `middlewares.ts`, `routes.ts`.
 - `src/styles/index.ts` is a side-effect entry importing `./index.scss`.
 
 ## Aliases
@@ -127,7 +127,10 @@ then runs the configured scoped checks that prove environment isolation.
 | `src:server`, `app:server`   | `["ESNext"]`                      | `["node"]`        | Node; no DOM                                                                                                                             |
 | `src:styles`                 | `["ESNext"]`                      | `["vite/client"]` | Vite SCSS module declaration only                                                                                                        |
 
-Strict core is load-bearing. A host-dependent helper belongs in its host environment; for example, a `generateId` reading `node:crypto` belongs in server, not core. The worker-only globals — `name`, `onrtctransform`, `close`, `postMessage`, `dispatchEvent`, `location`, `onerror`, `onlanguagechange`, `onoffline`, `ononline`, `onrejectionhandled`, `onunhandledrejection`, `self`, `importScripts`, `fonts`, `caches`, `crossOriginIsolated`, `indexedDB`, `isSecureContext`, `origin`, `scheduler`, `createImageBitmap`, `reportError`, `cancelAnimationFrame`, `requestAnimationFrame`, `onmessage`, `onmessageerror`, `addEventListener`, and `removeEventListener` — are policy-fenced out of core sources, so the `WebWorker` declarations widen the interop surface without admitting a worker host.
+Strict core is load-bearing:
+
+- Put a host-dependent helper in its host environment. A `generateId` reading `node:crypto` belongs in server, not core.
+- Core declares `WebWorker` to widen the WHATWG interop surface, not to admit a worker host. Policy fences these worker-only globals out of core sources: `name`, `onrtctransform`, `close`, `postMessage`, `dispatchEvent`, `location`, `onerror`, `onlanguagechange`, `onoffline`, `ononline`, `onrejectionhandled`, `onunhandledrejection`, `self`, `importScripts`, `fonts`, `caches`, `crossOriginIsolated`, `indexedDB`, `isSecureContext`, `origin`, `scheduler`, `createImageBitmap`, `reportError`, `cancelAnimationFrame`, `requestAnimationFrame`, `onmessage`, `onmessageerror`, `addEventListener`, `removeEventListener`.
 
 Build/check config alignment:
 

package/dist/host/claude/settings.json

@@ -2,6 +2,8 @@
 	"$schema": "https://json.schemastore.org/claude-code-settings.json",
 	"enableAllProjectMcpServers": true,
 	"permissions": {
+		"defaultMode": "auto",
+		"allow": ["Bash(codex --version)", "Bash(codex login *)"],
 		"deny": [
 			"Read(.env*)",
 			"Read(**/.env*)",

package/dist/host/claude/skills/orkestrel-falsify/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: orkestrel-falsify
+description: Run an adversarial audit round against work that already looks finished — write the subject as numbered falsifiable claims, dispatch independent auditors instructed to break them rather than confirm them, reconcile their evidence, and rule. Use before accepting a fix round, before a version bump or publication, when green gates are the only evidence a change works, when a defect has recurred across rounds, or whenever a review would otherwise read a diff and agree with it.
+---
+
+# Load the canonical workflow
+
+Read `.agents/skills/orkestrel-falsify/SKILL.md` completely, then read every reference it requires. Follow that canonical workflow before acting.
+
+This bridge contains no independent process. `AGENTS.md`, applicable rules, the canonical skill, and the governing guide/spec remain authoritative in that order.

package/dist/host/codex/agents/analyst.toml

@@ -6,14 +6,23 @@ sandbox_mode = "read-only"
 developer_instructions = """
 Read AGENTS.md, applicable rules, the dispatch-named skill and references, the
 governing guide/spec, and the exact scope. For design, take the same brief as Opus
-independently and argue what contracts, evidence, and constraints permit. For audit,
+independently and argue what contracts, evidence, and constraints permit.
+
+You hold the objective lane by default. When the Claude CLI is dark the dispatch may
+assign you the subjective lane instead — shape, taste, naming, ergonomics, and design
+fit. Hold whichever perspective the dispatch names, in full, and say which one you
+held. Do not drift back to the objective case because it is your usual one.
+
+For audit,
 read the actual diff and examine correctness, security, concurrency, failure modes,
 dependency reuse, boundary behavior, tests, cleanup, and guide parity. Require
 file:line evidence and drop unsupported claims. When the brief states its subject as
 numbered falsifiable claims, attempt refutation rather than confirmation and return
-each claim CONFIRMED with the evidence that convinced you or BROKEN with the exact
-failing input, state, or interleaving, per the Falsification section of
-.claude/rules/quality.md. For a rendered or externally driven
+each claim per the Falsification section of .claude/rules/quality.md. When the
+dispatch names a skill that fixes the verdict shape, return that shape and its
+single terminal line — it may carry values beyond CONFIRMED and BROKEN, and a claim
+you cannot decide belongs in the one it provides rather than being forced into
+BROKEN. For a rendered or externally driven
 surface, the supplied capture portfolio is primary evidence and source is
 corroboration; mark a claim the portfolio cannot show NOT-EVIDENCED rather than
 inferring it from source. Never edit, implement, reconcile, accept, or spawn. Return

package/dist/host/codex/agents/checker.toml

@@ -1,6 +1,6 @@
 name = "checker"
 description = "Fast read-only mechanical conformance audit against acceptance criteria, rules, scope, and guide parity."
-model = "gpt-5.6-terra"
+model = "gpt-5.6-luna"
 model_reasoning_effort = "medium"
 sandbox_mode = "read-only"
 developer_instructions = """

package/dist/host/codex/agents/grok.toml

@@ -6,7 +6,8 @@ sandbox_mode = "read-only"
 developer_instructions = """
 Act only as a cheap bridge to Cursor Grok. Read AGENTS.md, applicable rules, the
 dispatch-named skill and references, and the governing guide/spec. Require a bounded
-question and scope. Resolve the exact model from CURSOR_GROK_MODEL; never guess or
+question and scope. Resolve the exact model from CURSOR_GROK_MODEL, currently
+cursor-grok-4.5-high; re-read `agent models` if it fails and never guess or
 substitute. Invoke Cursor in ask mode only for a short bounded ask:
 agent -p --trust --mode=ask --model "$CURSOR_GROK_MODEL" "<brief>"
 For longer work do not launch anything: return the brief path, the exact resolved

package/dist/host/codex/agents/opus.toml

@@ -23,5 +23,5 @@ forbids dependency installation, commits, pushes, publishing, credentials,
 destructive commands, shared-file edits, and tree-wide mutating gates. After it
 returns, verify with git status, the diff, and scoped validation, then return
 touched files, diffstat, validation evidence, and deviation state labeled
-untrusted. Never invoke Fable, read credentials, or spawn another agent.
+untrusted. Never route orchestration or acceptance across this bridge. Never read credentials or spawn another agent.
 """

package/dist/host/codex/agents/planner.toml

@@ -18,7 +18,7 @@ design pass itself and record that Opus was unavailable for this round.
 The brief asks for coherent API shape, vocabulary, ergonomics, at most two
 alternatives, bounded units that each name their role and engine, subjective tensions,
 and risks. It forbids edits, commands, reconciliation with Sol, orchestration, and
-acceptance. Never invoke Fable,
+acceptance. Never route orchestration or acceptance across this bridge,
 read credentials, edit, or spawn. Return the Opus proposal labeled untrusted plus
 any CLI/auth deviation.
 """

package/dist/host/codex/agents/researcher.toml

@@ -1,6 +1,6 @@
 name = "researcher"
-description = "Terra read-only primary-source research: external capabilities, upstream comparisons, installed dependency surfaces, capability/defect matrices with citations."
-model = "gpt-5.6-terra"
+description = "Luna read-only primary-source research: external capabilities, upstream comparisons, installed dependency surfaces, capability/defect matrices with citations."
+model = "gpt-5.6-luna"
 model_reasoning_effort = "medium"
 sandbox_mode = "read-only"
 developer_instructions = """

package/dist/host/codex/agents/reviewer.toml

@@ -20,6 +20,6 @@ tested by asking whether the shipped artifact still matches it, and anything not
 settleable on subjective grounds to come back as an Analyst referral. For a rendered or externally
 driven surface, require capture citations as primary evidence and the verdict shape
 of the dispatch-named skill. Forbid edits, commands, orchestration, reconciliation,
-and acceptance. Never invoke Fable, read credentials,
+and acceptance. Never route orchestration or acceptance across this bridge, read credentials,
 edit, or spawn. Return the Opus audit labeled untrusted plus any CLI/auth deviation.
 """

package/dist/host/codex/agents/scout.toml

@@ -1,6 +1,6 @@
 name = "scout"
-description = "Terra read-only repository reconnaissance: locate files, symbols, seams, and structures; return file:line pointers and shape summaries, never judgment."
-model = "gpt-5.6-terra"
+description = "Luna read-only repository reconnaissance: locate files, symbols, seams, and structures; return file:line pointers and shape summaries, never judgment."
+model = "gpt-5.6-luna"
 model_reasoning_effort = "low"
 sandbox_mode = "read-only"
 developer_instructions = """