@orkestrel/scaffold 0.0.48 → 0.0.49

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

@@ -32,6 +32,10 @@ A round also needs something new to attack. When the previous round's claims all
 been added or repaired since, and the only motive is that an auditor could still imagine an attack,
 there is no subject — closing is the correct action and the next subject is the deliverable.
 
+When the same class has recurred along one seam to the budget in `.claude/rules/quality.md`
+§ Rounds and verdicts, the next move is that law's strategy switch — the breadth sweep of the
+stream, the ruling, or the dropped moving-target claim — rather than another successor round.
+
 ## Write the brief
 
 The brief is the instrument. A weak brief produces a confirming review no matter which auditor reads

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

@@ -83,7 +83,10 @@ A review that reads a diff finds what the diff shows. A review that tries to bre
 - A fix that adopts the auditor's prescription verbatim may close with a mutation probe in place of a fresh audit round: disable the load-bearing line, watch the adopted pin fail, restore it, and commit the pin as the regression guard. A fix that departs from the prescription gets the cross-engine round.
 - 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.
+- **Three rounds at one seam is the budget, and reaching it switches the search strategy rather than stopping the work.** Repeated rounds against one seam are evidence about the design, not evidence of diligence. At the third round, name what the audit is trying to accomplish, then pick the successor strategy from what the recurrence shows.
+- Recurrence with a direction — each fix relocates the class along one stream, or the evidence points up a dependency chain — ends the depth search. Run one breadth round that probes the stream's stations in parallel to locate the source, in the shape `.agents/orchestration.md` § Context and decomposition prescribes, then plan the downstream work from the source and size it by the sweep's map.
+- Recurrence with no direction makes the seam itself the question. 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.
+- A subject that reprices itself on every edit — a count, a census, a total over prose — has no closing condition and is not a seam. Drop the claim, or recast it as the property the tally stood in for.
 - Write the round count down in the capability/defect matrix row that owns the seam, 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.
 - State the ruling that ends a seam as the invariant the code will obey, the constraint bounding it against over-correction, and the interface where a consumer meets the obligation. A ruling that names only the defect it replaces produces the opposite defect next round.
 - 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.

package/dist/host/guides/scaffold.md

@@ -12,11 +12,11 @@ does not work. Scaffold makes the shared set data — a vendored data root shipp
 — and gives it verbs: create a workspace from it, report how a workspace differs from it, and
 write the difference back.
 
-Every code fence below is illustrative. [`tests/guides.test.ts`](../tests/guides.test.ts)
-transcribes the pure blueprint-default, compile-refusal, and error-narrowing fences and checks their
-literal verdicts. A trailing comment in another fence is this guide's claim rather than a measured
-answer; the driven examples are the ones the shipped declarations print. Limits states what that
-leaves unproven and what covers it instead.
+Every code fence below is illustrative. [`tests/guides.test.ts`](../tests/guides.test.ts) keeps the
+command reference aligned with the executable and transcribes the pure blueprint-default,
+compile-refusal, and error-narrowing fences. A trailing comment in another fence is this guide's
+claim rather than a measured answer; the driven examples are the ones the shipped declarations
+print. Limits states what that leaves unproven and what covers it instead.
 
 ```sh
 npm install --save-dev @orkestrel/scaffold
@@ -44,11 +44,12 @@ Exported from `@orkestrel/scaffold`, and reachable from
 | `CatalogEntry`      | type | One package row of the fleet catalog.                                                            |
 | `CompileStage`      | type | The compile phases, in the order they run.                                                       |
 | `CompilerEventMap`  | type | The compiler's observation channel.                                                              |
+| `HostFile`          | type | One vendored file read from the repository, beside the target bytes it answers for.              |
 | `Drift`             | type | How one target path compares to the artifact planned for it.                                     |
 | `Environment`       | type | One environment a generated workspace selects on its `src` or `app` axis.                        |
 | `Finding`           | type | One drift verdict against a target path.                                                         |
 | `Group`             | type | The artifact group a plan selects over.                                                          |
-| `Lookup`            | type | Whether an upstream lookup produced an answer.                                                   |
+| `Lookup`            | type | How an upstream lookup resolved: found, missing, unmatched, or failed.                           |
 | `Mirror`            | type | One dependency guide fetched from upstream, beside the local mirror it answers for.              |
 | `Origin`            | type | How an artifact's content is produced.                                                           |
 | `Ownership`         | type | What scaffold claims at an artifact's path.                                                      |
@@ -112,6 +113,7 @@ Exported from `@orkestrel/scaffold`, and reachable from
 | `GUIDES_TEST_PATH`                | const | The guide-parity proof whose presence selects the planned `guides` project.                      |
 | `HEX_PATTERN`                     | const | Exact lowercase hexadecimal bytes: two digits per byte, and empty content is valid.              |
 | `HOST_PATHS`                      | const | The paths byte-copied from the vendored data root, frozen.                                       |
+| `HOST_INVENTORY_PATH`             | const | The repository-relative path where the committed vendored-file inventory is served.              |
 | `INTEGRATION_TEST_PATH`           | const | The cross-environment composition proof whose presence makes a workspace `integration`.          |
 | `INVALID_PATH_CHARACTER_PATTERN`  | const | Visible characters a target-relative path and a Markdown path cell both forbid.                  |
 | `MAX_ARTIFACT_BYTES`              | const | Maximum bytes accepted for one artifact.                                                         |
@@ -195,6 +197,7 @@ Exported from `@orkestrel/scaffold`, and reachable from
 | `extractVersion`            | function | Extract the major, minor, and patch components of an exact version.           |
 | `inferDrift`                | function | Infer how one target path compares to the artifact planned for it.            |
 | `inferGroup`                | function | Infer the `Group` a path belongs to.                                          |
+| `isDeferredPath`            | function | Test whether another surface owns the vendored bytes at a path.               |
 | `manifestToDependencies`    | function | Project a package manifest's text to the `@orkestrel/*` packages it declares. |
 | `manifestToName`            | function | Project a package manifest's text to its own name.                            |
 | `matchesDriftReachability`  | function | Test whether `inferDrift` could have produced a finding for an ownership.     |
@@ -270,12 +273,13 @@ Exported from `@orkestrel/scaffold/server`, and reachable from
 
 | Name                    | Kind      | Summary                                                                              |
 | ----------------------- | --------- | ------------------------------------------------------------------------------------ |
+| `Host`                  | interface | A whole vendored host supplied as a value rather than read from a directory.         |
 | `HostManifest`          | interface | The complete vendored-host inventory.                                                |
-| `ManifestEntry`         | interface | One file record of the vendored host's manifest.                                     |
+| `ManifestEntry`         | interface | One file record of the vendored host's manifest, including its exact-byte digest.    |
 | `MaterializeResult`     | interface | The outcome of one mutation of a target.                                             |
 | `MaterializerInterface` | interface | The mutation contract: the package's only filesystem writer.                         |
 | `MaterializerOptions`   | interface | Options for the materializer.                                                        |
-| `Repository`            | interface | What git reports about a target's working tree.                                      |
+| `Worktree`              | interface | What git reports about a target's working tree.                                      |
 | `UpstreamInterface`     | interface | The upstream contract: the package's only network reader, and it never writes.       |
 | `UpstreamOptions`       | interface | Options for the upstream reader.                                                     |
 | `WriteAnchor`           | interface | One physical directory identity captured across a write transaction.                 |
@@ -287,12 +291,12 @@ Exported from `@orkestrel/scaffold/server`, and reachable from
 
 | Name                                | Kind  | Summary                                                                                  |
 | ----------------------------------- | ----- | ---------------------------------------------------------------------------------------- |
-| `BRANCH_PATTERN`                    | const | The Git branch syntax the guide endpoint accepts.                                        |
+| `BRANCH_PATTERN`                    | const | The Git branch syntax the repository endpoint accepts.                                   |
 | `DIGEST_PATTERN`                    | const | The exact SHA-256 syntax a digest is stated in: sixty-four lowercase hexadecimal digits. |
 | `DRIVE_PATTERN`                     | const | The drive prefix a Windows host path may open with.                                      |
 | `INVALID_SEGMENT_CHARACTER_PATTERN` | const | Visible characters no host path segment may carry.                                       |
 | `MANIFEST_NAME`                     | const | The reserved metadata name a staged vendored host writes at its own root.                |
-| `MAX_BRANCH_LENGTH`                 | const | Maximum characters one guide branch may carry.                                           |
+| `MAX_BRANCH_LENGTH`                 | const | Maximum characters one repository branch may carry.                                      |
 | `MAX_ENDPOINT_LENGTH`               | const | Maximum characters one caller-supplied upstream endpoint may carry.                      |
 | `MAX_INVENTORY_PATHS`               | const | Maximum paths one target's working-tree inventory may report.                            |
 | `MAX_PATH_DEPTH`                    | const | Maximum segments one host path may carry.                                                |
@@ -306,20 +310,22 @@ Exported from `@orkestrel/scaffold/server`, and reachable from
 
 | Name                    | Kind     | Summary                                                                            |
 | ----------------------- | -------- | ---------------------------------------------------------------------------------- |
-| `isBranch`              | const    | Narrow a value to a Git branch the guide endpoint accepts.                         |
+| `isBranch`              | const    | Narrow a value to a Git branch the repository endpoint accepts.                    |
 | `isCatalogEntries`      | const    | Narrow a value to a bounded list of fleet catalog rows.                            |
 | `isDependencies`        | const    | Narrow a value to a bounded list of declared runtime dependencies.                 |
 | `isDependencyNames`     | const    | Narrow a value to a bounded list of `@orkestrel` package names.                    |
 | `isDigest`              | const    | Narrow a value to one exact SHA-256 digest.                                        |
 | `isEndpoint`            | const    | Narrow a value to a bounded upstream endpoint.                                     |
 | `isFilesystemPath`      | function | Narrow a value to a path naming a location on this host.                           |
+| `isHost`                | const    | Narrow a value to one whole vendored host supplied as a value.                     |
 | `isHostManifest`        | const    | Narrow a value to one `HostManifest`.                                              |
 | `isInventory`           | function | Narrow a value to a working-tree inventory within the limit one target may report. |
 | `isManifestEntry`       | const    | Narrow a value to one `ManifestEntry`.                                             |
 | `isMaterializerHooks`   | const    | Narrow a value to the materializer's initial listener record.                      |
 | `isMaterializerOptions` | const    | Narrow a value to `MaterializerOptions`.                                           |
 | `isMirrors`             | const    | Narrow a value to a bounded list of fetched guide mirrors.                         |
-| `isRepository`          | const    | Narrow a value to a `Repository`.                                                  |
+| `isPaths`               | const    | Narrow a value to a bounded list of target-relative paths.                         |
+| `isWorktree`            | const    | Narrow a value to a `Worktree`.                                                    |
 | `isTimeout`             | const    | Narrow a value to a per-request timeout in milliseconds.                           |
 | `isUpstreamHooks`       | const    | Narrow a value to the upstream reader's initial listener record.                   |
 | `isUpstreamOptions`     | const    | Narrow a value to `UpstreamOptions`.                                               |
@@ -331,6 +337,8 @@ Exported from `@orkestrel/scaffold/server`, and reachable from
 | `computeDigest`         | function | Compute the SHA-256 digest of text.                                                   |
 | `computeFileDigest`     | function | Compute the SHA-256 digest of one file's exact bytes.                                 |
 | `computeManifestDigest` | function | Compute the digest of a vendored host's declared membership.                          |
+| `filesToHost`           | function | Overlay host-owned live files onto the installed vendored floor.                      |
+| `hexToDigest`           | function | Project exact bytes stated in hexadecimal to their SHA-256 digest.                    |
 | `isExactCaseFile`       | function | Test whether a physical file's path matches every on-disk segment exactly.            |
 | `isPhysicalDirectory`   | function | Test whether a path is a physical directory this package will read or write into.     |
 | `isPhysicalFile`        | function | Test whether a path is a physical file this package will read or replace.             |
@@ -350,12 +358,15 @@ Exported from `@orkestrel/scaffold/server`, and reachable from
 | `readExpectation`       | function | Capture what one destination holds before a write.                                    |
 | `readFileHex`           | function | Read one contained file as its exact bytes in lowercase hexadecimal.                  |
 | `readFileText`          | function | Read one contained file as bounded UTF-8 text.                                        |
+| `readHostFloor`         | function | Read the installed vendored host floor as a verified value.                           |
 | `readHostManifest`      | function | Read a vendored host's manifest, when it carries one.                                 |
 | `readManifestEntry`     | function | Derive one vendored-host manifest entry from a file in a checkout.                    |
 | `readSnapshot`          | function | Read a target's current bytes at the paths a plan claims.                             |
 | `resolveContainedPath`  | function | Resolve a root-relative path and refuse one that leaves its root.                     |
 | `resolveRealPath`       | function | Resolve a path through the real filesystem, keeping the part that does not exist yet. |
+| `stageBytes`            | function | Stage the named destinations of a value host into a private root.                     |
 | `stageHost`             | function | Stage a vendored host root from a real checkout.                                      |
+| `stageInventory`        | function | Stage the committed vendored-file inventory from a real checkout.                     |
 
 #### Classes
 
@@ -395,12 +406,13 @@ no interface and is documented directly.
 
 #### `UpstreamInterface`
 
-| Method    | Summary                                                                    |
-| --------- | -------------------------------------------------------------------------- |
-| `lookup`  | Look up the newest release each declared range admits.                     |
-| `fetch`   | Fetch each named package's guide, beside the local mirror it answers for.  |
-| `catalog` | Catalog the published fleet from the registry's organization package list. |
-| `destroy` | Tear the reader down, aborting every request in flight.                    |
+| Method    | Summary                                                                                    |
+| --------- | ------------------------------------------------------------------------------------------ |
+| `lookup`  | Look up the newest release each declared range admits.                                     |
+| `fetch`   | Fetch each named package's guide, beside the local mirror it answers for.                  |
+| `read`    | Read each named vendored file from the repository, beside the target bytes it answers for. |
+| `catalog` | Catalog the published fleet from the registry's organization package list.                 |
+| `destroy` | Tear the reader down, aborting every request in flight.                                    |
 
 #### `WriteTransaction`
 
@@ -426,34 +438,62 @@ option grants a write.
 | `catalog`   | The package table, the guide mirrors, and the ranges                            |
 | `overwrite` | Everything `repair` and `catalog` write, plus deletions                         |
 
+### Baselines
+
+Every remote surface reads its live source first and falls back, whole, to the copy the installed
+package distributes; each operation reports one baseline word per surface. A surface can select
+`floor` only where the package distributes a copy. The registry's organization membership ships
+nowhere, so `catalog` refuses when that read fails.
+
+For `new`, `repair`, `catalog`, and `overwrite`, authoritative absence never selects `floor`. A
+registry `404` or a packument with no admitted version stays a `FETCH` refusal, because writing a
+version the registry says is absent produces an uninstallable manifest. `audit` turns release
+absence into questions and returns its audit result. Transport faults, timeouts, rate refusals,
+byte-bound refusals, and integrity refusals can select the floor.
+
+The guide surface is the per-row exception to whole-surface fallback. A failed foreign guide keeps
+the target's existing mirror as its floor, while the other guide rows can still update. When at
+least one selected guide keeps its mirror, `provenance.guides` is `floor` for the result; it is
+`live` only when every selected guide resolved live.
+
+A value `Host` can carry live host-owned bytes beside installed floor bytes for deferred guide and
+catalog paths. Each surface still contributes one baseline. Deferred paths are presence-only, and
+repair never writes their floor bytes.
+
+Every verb's machine-readable result carries `provenance`. The record names only the remote
+surfaces that the verb read. A host supplied by the `--from` option is absent because it comes from
+a local path.
+
 `scaffold --help` prints the whole reference:
 
 ```text
 scaffold <verb> [options]
 
-  scaffold new <name> [--src <list>] [--app <list>] [--bin] [--deps <list>] [--from <path>] [--target <path>] [--json]
+  scaffold new <name> [--src <list>] [--app <list>] [--bin] [--deps <list>] [--offline] [--from <path>] [--target <path>] [--json]
       scaffold a workspace
-  scaffold audit [--groups <list>] [--from <path>] [--target <path>] [--json]
+  scaffold audit [--groups <list>] [--offline] [--from <path>] [--target <path>] [--json]
       report how the target compares to its plan, writing nothing
-  scaffold repair [--groups <list>] [--from <path>] [--target <path>] [--json]
+  scaffold repair [--groups <list>] [--offline] [--from <path>] [--target <path>] [--json]
       write each planned path the target is missing or has let drift
   scaffold catalog [--all] [--from <path>] [--target <path>] [--json]
       regenerate the package table and refresh the guide mirrors
-  scaffold overwrite [--groups <list>] [--dirty] [--from <path>] [--target <path>] [--json]
+  scaffold overwrite [--groups <list>] [--dirty] [--offline] [--from <path>] [--target <path>] [--json]
       do everything repair and catalog do, then delete what the plan does not own and re-declare the dependency ranges
 
 options
-  --src <list>     the published library environments to build: core, browser, server
-  --app <list>     the private application environments to build: core, browser, server
-  --bin            scaffold a command-line executable at src/bin/main.ts
-  --deps <list>    the @orkestrel/* packages the workspace depends on
-  --groups <list>  the artifact groups to cover; every group when absent
-  --all            fetch a guide for every package the organization publishes, not the declared ones alone
-  --dirty          delete from a tree carrying uncommitted changes
-  --from <path>    read the data root from a local path instead of the bundled one; catalog alone accepts it more than once
-  --target <path>  the directory the verb operates on; the working directory when absent
-  --json           emit one machine-readable value instead of a report
-  ORKESTREL_SCAFFOLD_REGISTRY  the registry base mapped to upstream.registry.base
+  --src <list>                   the published library environments to build: core, browser, server
+  --app <list>                   the private application environments to build: core, browser, server
+  --bin                          scaffold a command-line executable at src/bin/main.ts
+  --deps <list>                  the @orkestrel/* packages the workspace depends on
+  --groups <list>                the artifact groups to cover; every group when absent
+  --all                          fetch a guide for every package the organization publishes, not the declared ones alone
+  --dirty                        delete from a tree carrying uncommitted changes
+  --offline                      use the distributed dependency and vendored-host floors without reading upstream
+  --from <path>                  read the data root from a local path instead of the bundled one; catalog alone accepts it more than once
+  --target <path>                the directory the verb operates on; the working directory when absent
+  --json                         emit one machine-readable value instead of a report
+  ORKESTREL_SCAFFOLD_REGISTRY    the registry base mapped to upstream.registry.base
+  ORKESTREL_SCAFFOLD_REPOSITORY  the repository base mapped to upstream.repository.base
 
 exit codes
   0  clean
@@ -464,13 +504,16 @@ exit codes
 An option a verb does not list is refused by name rather than parsed and ignored. `--help` is the
 one exception, because it replaces the run rather than modifying it: a command line carrying
 `--help` anywhere prints the whole reference and exits `0` before the line is read as a command, so
-no verb has to list it. Every verb reaches the registry, and none of them invents a range when the
-read produces no answer. Dependency floors states what each verb reads and what it does then.
+no verb has to list it. Without the `--offline` option, every verb reaches the registry, and none of
+them invents a range when the read produces no answer. Dependency floors states what each verb reads
+and what it does then.
 
-Every read addresses the published registry. Set `ORKESTREL_SCAFFOLD_REGISTRY` to address a loopback
-or private one instead. The process entry maps it to `upstream.registry.base` and nothing else, so
-the seam changes which host answers a read and grants no verb any write authority it did not already
-have.
+At their defaults, online runs contact `registry.npmjs.org` for scoped package packuments and the
+`/-/org/orkestrel/package` membership path. They contact `raw.githubusercontent.com` for guide
+files on `main`, the scaffold repository's `host.json` file, and changed vendored paths.
+`ORKESTREL_SCAFFOLD_REGISTRY` replaces the registry base, and
+`ORKESTREL_SCAFFOLD_REPOSITORY` replaces the repository base. These settings change which host
+answers a read and grant no verb write authority that it did not already have.
 
 `new --bin` creates the executable entry, its test, and its scoped Vite and TypeScript wrappers. The
 other structural facts do not need creation flags. Add a root `tests/setup*.test.ts` proof for
@@ -565,13 +608,13 @@ unless `--dirty` waives that refusal. A target that is not a git repository is r
 `--json` replaces the report with one JSON value on standard output. Warnings and refusals go to
 standard error, so a piped value is never polluted.
 
-| Verb        | Value                                                                                      |
-| ----------- | ------------------------------------------------------------------------------------------ |
-| `new`       | `MaterializeResult` — `target`, `written`, `skipped`, `removed`                            |
-| `audit`     | `Audit` — `findings` and `questions` — plus `releases`; findings carry `ownership`         |
-| `repair`    | `MaterializeResult` plus `audit`, the terminal audit taken after the write, and `releases` |
-| `catalog`   | `MaterializeResult` plus `entries`, `mirrors`, `dropped`, and `releases`                   |
-| `overwrite` | The `catalog` value plus `audit` and `note` on a partial run                               |
+| Verb        | Value                                                                                                    |
+| ----------- | -------------------------------------------------------------------------------------------------------- |
+| `new`       | `MaterializeResult` — `target`, `written`, `skipped`, `removed` — plus `provenance`                      |
+| `audit`     | `Audit` — `findings` and `questions` — plus `releases` and `provenance`; findings carry `ownership`      |
+| `repair`    | `MaterializeResult` plus `audit`, the terminal audit taken after the write, `releases`, and `provenance` |
+| `catalog`   | `MaterializeResult` plus `entries`, `mirrors`, `dropped`, `releases`, and `provenance`                   |
+| `overwrite` | The `catalog` value plus `audit` and `note` on a partial run                                             |
 
 Every failure reports the same envelope instead: `{ "error": { "code": …, "message": … } }`. The
 code is a `ScaffoldErrorCode`, or `USAGE` for a command line that never became a command, or
@@ -925,18 +968,23 @@ alike.
 
 ### What each verb reads
 
-| Verb        | Reads                                                       | Writes on a complete answer                     | With no answer                                           |
-| ----------- | ----------------------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------- |
-| `new`       | Every `@orkestrel/*` row the compiled manifest declares     | The plan's ranges, before the target is opened  | `FETCH`, exit `1`, nothing written                       |
-| `audit`     | Every declared fleet row and planned foreign row            | Nothing                                         | Failed verdicts reported, exit `1`, nothing written      |
-| `repair`    | Every declared fleet row and planned foreign row            | The manifest's ranges, beside the repair        | `FETCH`, exit `1`, nothing written                       |
-| `catalog`   | The organization package list and every packument behind it | The manifest's ranges, beside the package table | `FETCH`, exit `1`, nothing written                       |
-| `overwrite` | Everything `repair` and `catalog` read                      | Everything `repair` and `catalog` write         | The offline half stands, `note` names the step, exit `1` |
+`new`, `audit`, and `repair` read declared versions and the vendored host. `catalog` reads
+organization membership, its packuments, and the selected guides. `overwrite` reads every surface
+that `repair` and `catalog` read. A network-forced floor is drift except for a successful `new` run;
+an explicit `--offline` floor is intentional, and the verb's result decides its exit. `catalog` has
+no offline form. `overwrite` commits repair and removal before it starts the catalog step.
+
+Each verb resolves a surface's complete answer before it opens that surface's write transaction, so
+a partial answer never becomes a partial pin set. `overwrite` keeps the repair and removal work it
+committed before a later catalog refusal and records that refusal in `note`.
 
-Each verb resolves the whole set before it opens a write transaction, so a partial answer never
-becomes a partial pin set. `overwrite` is the exception, and deliberately: its offline repair and
-deletion have already landed by the time the network half runs, so a step that produces no answer is
-collected into `note` and reported rather than discarding work that succeeded.
+| Verb        | Reads live                                                       | When the network forces a floor                                                                                             | With `--offline`                                                                                            |
+| ----------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `new`       | Declared versions and the vendored host                          | Writes the distributed version and host floors; exits `0` after creating the workspace                                      | Reads no upstream surface, writes the same floors, and exits `0` after creating the workspace               |
+| `audit`     | Declared versions and the vendored host                          | Compares through the distributed floors and exits `1`                                                                       | Compares through the floors; exits `0` for an aligned target or `1` for drift                               |
+| `repair`    | Declared versions and the vendored host                          | Repairs from the distributed floors and exits `1`, even when the terminal audit is aligned                                  | Repairs from the floors; the terminal audit decides exit `0` or `1`                                         |
+| `catalog`   | Organization membership, its packuments, and the selected guides | Refuses a membership or version failure with `FETCH` and exit `1`; preserves each failed guide's local mirror and exits `1` | Is a usage error; exits `2` and writes nothing                                                              |
+| `overwrite` | Everything `repair` and `catalog` read                           | Keeps completed repair and deletion work, names each floor or refused catalog step in `note`, and exits `1`                 | Repairs, deletes, and writes version floors; skips `catalog`, records that refusal in `note`, and exits `1` |
 
 A fleet row is compared exactly — `^0.1.0` is stale the moment the registry serves `0.1.2` — and
 that inequality alone raises `audit` to exit `1`. A foreign row is compared inside its declared
@@ -964,6 +1012,23 @@ directories, the bench scripts, the shared policy register, the byte-identical r
 the guide mirrors a generated workspace starts from. `HOST_PATHS` is the candidate list; a plan
 carries the subset its target selects, because a workspace never mirrors its own guide.
 
+The `host.json` file at the repository root is the committed live inventory. Each entry carries the
+SHA-256 digest of its file content, and the inventory carries a membership digest over its declared
+paths and file digests. Run `npm run build:inventory` whenever a vendored byte or path changes; the
+`config` project refuses a stale inventory. Run that gate against a quiescent checkout: its fresh and
+committed reads cannot distinguish stale data from a source edit made while the gate runs.
+
+The installed release fixes which paths a target owns. A live inventory can update bytes only for
+those paths; it can neither introduce a path nor delete one. A path added upstream is invisible
+until a release adds it to the installed manifest. Remove a vendored path in the same change that
+ships the release which removes it from that manifest.
+
+At the default `UpstreamOptions.retries` value, an aligned target spends one request on `host.json`,
+and each installed path whose live digest differs from the target adds one request for its bytes. A
+positive `retries` value can repeat a request after a transport fault. Raw-host propagation lag after
+a commit is a property of the content host. Scaffold neither creates that lag nor presents a stale
+response as fresher than the host served it.
+
 `.claude/settings.json` is in that set, and the artifact planned for it is content-owned. `repair`
 and `overwrite` restore its bytes, so an edit made to it inside a target is reverted at the next
 visit and reported as drift until then. Put an operator grant in `.claude/settings.local.json`
@@ -982,9 +1047,10 @@ stageHost(process.cwd(), 'dist/host') // one ManifestEntry per file staged
 Each vendored path is copied to a storage name, and every dot that opens a segment comes off,
 because npm's own ignore rules would drop a leading-dot entry from the tarball. A dotted file at the
 root moves under `dotfiles/` so it cannot collide with an undotted sibling. `manifest.json` is
-written last and declares the whole membership: one entry per file, the sorted directory inventory,
-and a SHA-256 digest over both. The digest is what detects a membership edit that did not update
-it, and the directory inventory is what makes a declared empty directory survive a file walk.
+written last and declares the whole membership: one entry per file with a digest computed from the
+staged destination after its copy, the sorted directory inventory, and a SHA-256 digest over both.
+The membership digest detects an edit that did not update the manifest, and the directory inventory
+makes a declared empty directory survive a file walk.
 
 A missing vendored path is refused rather than staged around, and the refusal names every missing
 path at once. That is why `guides/scaffold.md` — this file — must exist before `npm run build`
@@ -996,6 +1062,21 @@ module's own location rather than from the caller's working directory. `--from`
 else. A root carrying no manifest at all is read as a raw checkout, and artifact paths map onto it
 one to one.
 
+### Integrity
+
+HTTPS supplies Transport Layer Security (TLS) for each fetched response, and the reader applies its
+per-response and per-call byte budgets before it accepts content. It carries each fetched vendored
+response's decoded content as hexadecimal before any character decoding and verifies that content
+against the digest in `host.json`, then verifies the inventory against its membership digest.
+Transport encoding is transparent and does not enter the comparison. The path never character-
+decodes and re-encodes the content.
+
+This posture supplies integrity, not authenticity. An attacker who can serve the files can also
+serve a matching inventory. The residual is direct: fetched bytes govern agent behavior in a target
+that has no release gate. Run `audit` to preview the change, use the `--offline` option to pin the
+distributed floors, and keep operator grants in `.claude/settings.local.json`; scaffold does not
+read or write that file.
+
 ## Generated workspace
 
 A workspace's file set is a function of its axes plus its structural facts. Nothing is fixed
@@ -1082,6 +1163,10 @@ result.written // every path created
 materializer.destroy()
 ```
 
+When a `Materializer` uses a value `Host`, each mutating call stages the host under a private
+`#fill` root in the operating system's temporary directory and removes that root in a `finally`
+block. A process killed during the mutation can leave the temporary root behind.
+
 `resolveContainedPath` refuses a lexical escape, a physical link out of the root, and a dangling
 link whose raw target contains a `..` segment. It returns the lexical join of `root` and `path` — an
 absolute path under `root` — after checking the namespace, not an open filesystem handle. Its
@@ -1096,7 +1181,7 @@ in what survives that collapse. A `..` the caller wrote cancels the segment befo
 what `hop` points at. The collapse only ever shortens the path, so nothing reaches outside it this
 way; the answer is a lexical location resolved through links, not a physical one.
 
-Read the registry and the guide host:
+Read the registry and the repository host:
 
 ```ts
 import { Upstream } from '@orkestrel/scaffold/server'
@@ -1188,10 +1273,10 @@ What a reader will look for and not find.
 **Guide parity has a bounded reach.** [`tests/guides.test.ts`](../tests/guides.test.ts) proves that
 the Surface tables match the core and server barrels in each direction, the method tables match the
 behavioral declarations, relative links resolve, and named imports in TypeScript fences resolve. It
-does not resolve arbitrary backticked prose spans or typecheck a whole fence. The same suite
-executes the transcribed pure examples for blueprint defaults, compile refusal, and error-code
-narrowing. Other trailing comments remain guide claims rather than build answers. The verdicts that
-are measured are the ones a consumer hovers:
+does not resolve arbitrary backticked prose spans or typecheck a whole fence. The same suite keeps
+the command reference aligned with the executable and executes the transcribed pure examples for
+blueprint defaults, compile refusal, and error-code narrowing. Other trailing comments remain guide
+claims rather than build answers. The verdicts that are measured are the ones a consumer hovers:
 [`tests/distribution.test.ts`](../tests/distribution.test.ts) drives every `@example` the built
 declarations print against the installed package, scores each verdict it can read as a value, and
 names exactly the ones it cannot. Executing the remaining fences would require fixtures for each