@orkestrel/scaffold 0.0.77 → 0.0.79

package/dist/host/agents/skills/{orkestrel-polish-surface → orkestrel-polish}/SKILL.md

@@ -1,25 +1,16 @@
 ---
-name: orkestrel-polish-surface
-description: Drive a rendered or externally driven surface to shipped quality through capture-evidence verdict rounds. Use when asked to polish an interface, bring a rendered surface to enterprise grade, judge what actually renders rather than what the source claims, reconcile design, state-truth, and inventory findings into fix units, or converge repeated review rounds on captured proof. Run one round for a narrow request; run the full campaign for a polish or production-readiness request.
+name: orkestrel-polish
+description: Drive a rendered or externally driven surface to shipped quality through one capture-evidence verdict round and its fix units. Use when asked to polish an interface, bring a rendered surface to enterprise grade, judge what actually renders rather than what the source claims, or reconcile design, state-truth, and inventory findings into fix units on captured proof. Run a verdict alone for a narrow request; run the round with its fix units for a polish or production-readiness request.
 ---
 
 # Polish a rendered surface
 
-## Load authority
+## Read
 
-Read the current files in this order:
-
-1. `AGENTS.md`.
-2. Every applicable `.claude/rules/*.md`. The style, browser, test, and documentation
-   laws bind every fix unit; this skill adds only the campaign.
-3. [capture-harness.md](references/capture-harness.md) before building, eyeballing, or
-   trusting a portfolio.
-4. `guides/README.md`, the governing guide for the surface, and `ROADMAP.md` when present.
-5. The authoritative `*/types.ts` for the surface, its components and partials, and the
-   shipped resolved cascade of every stylesheet the surface actually loads.
-
-Treat the current user instruction as authoritative. Treat repository rules as the coding
-contract and this skill as the workflow. Preserve dirty and user-owned work.
+`AGENTS.md` § Authority and loading names the files every unit reads. This skill adds
+[capture-harness.md](references/capture-harness.md) before building, eyeballing, or trusting a
+portfolio, the authoritative `*/types.ts` for the surface, its components and partials, and the
+shipped resolved cascade of every stylesheet the surface loads. Preserve dirty and user-owned work.
 
 ## Judge the rendering, not the source
 
@@ -41,14 +32,14 @@ supposed to produce it. Source-reading review passes a component that renders no
 Choose the smallest scope that satisfies the request:
 
 - **Verdict:** one portfolio, one lane, no fixes.
-- **Round:** portfolio → independent verdicts → reconciliation → fix units →
-  recapture.
-- **Campaign:** rounds repeated until one terminal converged line, then independent gates.
+- **Round:** portfolio → independent verdicts → reconciliation → fix units → recapture → one
+  re-verdict on the repaired items → independent gates.
 
 A narrow verdict request does not authorize fixes. A polish request authorizes fixing every
-confirmed finding in scope and rebuilding the harness gaps the verdicts expose.
+confirmed finding in scope and rebuilding the harness gaps the verdicts expose. A second round
+over the same surface needs an instruction from the user.
 
-## Execute the campaign
+## Execute the round
 
 1. **Build the portfolio.** Produce the full evidence set with the harness reference, then
    eyeball every artifact yourself before spending a verdict round on it. An unexamined
@@ -60,9 +51,10 @@ confirmed finding in scope and rebuilding the harness gaps the verdicts expose.
    § "Return the fixed verdict shape" fixes. The
    lanes are subjective design fit; objective state truth; and mechanical inventory of
    copy, classes, icons, and accessibility attributes. This is the surface variant of the
-   adversarial pass in `.agents/orchestration.md`, so its rules bind: each lane is a fresh
-   subagent with a clean context, run in parallel, blind to the others until all have
-   returned, and no lane is dropped because an engine is dark.
+   review in `.agents/orchestration.md` § Size gate, so its rules bind: each lane is a fresh
+   subagent with a clean context, blind to the others until reconciliation, run once, and no
+   lane is dropped because an engine is dark. A narrow verdict request runs the selected lane once
+   and stops.
 4. **Reconcile.** Confirmed findings get carriers; refuted findings die on the record with
    the evidence that killed them; conflicts get a dated ruling. Then walk the reconciled
    list once and name the fix-brief item carrying each finding — a finding with no carrier
@@ -71,14 +63,14 @@ confirmed finding in scope and rebuilding the harness gaps the verdicts expose.
    truth the subjective lane reads. Each unit records the failing proof before the
    repair — the exact command and its red count — and the same command's green count
    after. Commit each accepted unit before dispatching the next.
-6. **Cross-audit.** A fix unit's auditor is an engine that did not write it. Same-engine
-   re-review returns the author's own blind spot.
-7. **Recapture,** repairing every harness gap the verdicts exposed, and re-verdict against
-   the new portfolio, not the old one.
-8. **Iterate to the terminal line.** Repeat rounds until every lane returns converged. The item
-   inventory is fixed at the first judged portfolio; later rounds add only regressions of an item
-   already in it and gaps an earlier portfolio could not show. A fresh preference about an item
-   already converged is recorded for the next campaign, not made this one's blocker.
+6. **Defer each fix unit's review to the re-verdict.** No separate cross-audit runs; a fix that
+   adopted the verdict's prescription verbatim closes with the recapture alone.
+7. **Recapture,** repairing every harness gap the verdicts exposed. The re-verdict reads the
+   recaptured portfolio, never the old one.
+8. **Re-verdict the repaired items once.** Point the lanes at the recaptured portfolio and only at
+   the items the fix units repaired, plus regressions of an item already in the inventory. A
+   fresh preference about an item already converged is recorded for the user, not made this
+   round's blocker. An item still open after the re-verdict is reported open; the round ends.
 9. **Verify independently.** An independent runner executes the repository-prescribed
    gates; a fixer's own report never establishes green.
 
@@ -115,7 +107,7 @@ line, or a green claim from the engine that wrote the code. Completion requires:
 - every confirmed finding fixed or explicitly ruled out of scope on the record;
 - a final portfolio whose captures show the accepted state;
 - red-then-green evidence for every defect unit;
-- every lane converged in one round against that final portfolio;
+- every repaired item converged in the re-verdict against that final portfolio, and every open item named;
 - independent gate evidence.
 
 Report what changed, which capture proves each change, the exact test and gate results, and

package/dist/host/agents/skills/{orkestrel-polish-surface → orkestrel-polish}/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: 'Polish Rendered Surface'
   short_description: 'Drive a rendered surface to shipped quality on captured evidence'
-  default_prompt: 'Use $orkestrel-polish-surface to bring this rendered surface to shipped quality on captured evidence.'
+  default_prompt: 'Use $orkestrel-polish to bring this rendered surface to shipped quality on captured evidence.'

package/dist/host/agents/skills/{orkestrel-polish-surface → orkestrel-polish}/references/capture-harness.md

@@ -6,7 +6,7 @@ project can host — a served page, a foreign client, a process the runner canno
 Choose one source per surface, and never judge a round against a portfolio that is part
 journey-generated and part spawned.
 
-- Read the `orkestrel-prove-journey` skill for how the journey run generates a portfolio. This file
+- Read the `orkestrel-journey` skill for how the journey run generates a portfolio. This file
   adds only what the review requires of a portfolio and how a spawned harness produces one.
 - Own the spawned harness as the campaign owner. Never let a verdict lane write or edit it.
 - Treat the spawned harness as a throwaway instrument: written for this surface, rebuilt or deleted
@@ -31,7 +31,7 @@ Apply this section to a spawned harness only.
 ## Validate the seed before capturing
 
 Apply this section to a spawned harness only. In the journey run the acceptance journey is the seed,
-and `orkestrel-prove-journey` fixes how it enters and what it may reach past.
+and `orkestrel-journey` fixes how it enters and what it may reach past.
 
 - Build seed payloads from the surface's own published contract, never from memory of it; a
   near-miss field name renders an empty screen that reads as a product defect.
@@ -60,7 +60,7 @@ itself.
   row only where the surface declares none.
 - Read the journey run's per-variant written artifact for the accessibility snapshot and the logs,
   and cite the statechart harness by its deep link where a lane must watch the widget move rather
-  than read a still of it. `orkestrel-prove-journey` fixes what each holds and what each is named
+  than read a still of it. `orkestrel-journey` fixes what each holds and what each is named
   for.
 - Shoot the whole surface before selecting or focusing anything inside it. A capture taken after a
   selection reports a duplicate or highlighted artifact that does not exist.

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

@@ -5,26 +5,34 @@ description: Run an Orkestrel release from layer order to registry confirmation.
 
 # Publish an Orkestrel release
 
-## Load authority
+## Read
 
-Read the current files in this order:
+`AGENTS.md` § Authority and loading names the files every unit reads. This skill adds, in this order:
 
-1. `AGENTS.md` and every applicable `.claude/rules/*.md` file.
-2. `.agents/orchestration.md` § Publishing the fleet, § Long-running commands, § Orchestrator and
-   executor, § Writing concurrency, and § Dispatch anatomy. Each named section binds every step
+1. `references/release.md`, the `orkestrel-dispatch` skill and the launch reference it names, and `.agents/orchestration.md` § Routing,
+   § Parallelism, and § Dispatch. Each named section binds every step
    here.
-3. The reference the moment needs: [wave.md](references/wave.md) before visiting a repository,
+2. The reference the moment needs: [wave.md](references/wave.md) before visiting a repository,
    ruling on a bump, or preparing a layer; [window.md](references/window.md) before running
    `npm login` or any upload.
-4. The live evidence: the registry's packument for every package in the round, each target's
+3. The live evidence: the registry's packument for every package in the round, each target's
    manifest, and the catalog table the contract names as the layer order.
 
-The user's current instruction wins. The contract's § Publishing the fleet owns the credential
+## Scripts
+
+| Script               | Does                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `scripts/compare.ts` | `[--package NAME] [--version V] [--tarball PATH] [--dist dist] [--json]`, run from the package root after its build: fetches the published tarball and lists the material differences from the rebuilt `dist/` (sourcemaps excluded, whitespace-only differences ignored). Exit 0 when nothing differs, 3 when something does, 2 when the tarball cannot be read, 64 on usage (no package name, no `dist/`, or `--tarball` with no path).                                                                                                                                                                                                                                                                                                                                             |
+| `scripts/pins.ts`    | `--version PRIOR [--range PRIOR_RANGE ...] [--paths src,tests] [--json]`, run from the package root: lists every line under the paths carrying the prior version literal or a prior range literal, once per line, sweeping a one-comparator range such as `^8.3.0` for its bare version in any form. Exit 0 with no hits, 3 with hits, 64 on usage (no literal, or a flag with no value).                                                                                                                                                                                                                                                                                                                                                                                             |
+| `scripts/wave.ts`    | `--visit [--target DIR] [--offline] [--from STEP] [--to STEP] [--prior VERSION] [--dry-run] [--json] [--out FILE]` runs one repository's visit in the order [wave.md](references/wave.md) § Visit a repository fixes (pin, commit, overwrite, verify, install, pins, format, gates, compare), stops at the first failing step, and prints each step's exit, the bump ruling (the rebuilt dist against the published tarball, and the final runtime dependency set against the published manifest), and a row for `.orkestrel/release.md`; `--prior` names the version a pre-ruled bump replaced so the self-pin sweep finds it; `--plan` prints the packages by layer from the catalog table. Exit 0 when every step passed, 1 when one failed, 2 when a reading failed, 64 on usage. |
+| `scripts/window.ts`  | `--whoami [--wait SECONDS]` reads or polls `npm whoami`; `--login` prints the operator's login command and polls `whoami` until it answers; `--publish DIR... --otp CODE` uploads back to back with `npm publish --ignore-scripts --otp`, journals each upload under `tmp/units/`, stops at the first refusal naming where to resume, and confirms each accepted version against the registry; `--confirm NAME@VERSION...` re-reads the registry until it serves the version. Exit 0 on success, 3 when not.                                                                                                                                                                                                                                                                          |
+
+The user's current instruction wins. `references/release.md` owns the credential
 and authorization law; nothing here weakens it.
 
 ## The boundary with the contract
 
-`.agents/orchestration.md` § Publishing the fleet binds every release, and this skill does not
+`references/release.md` binds every release, and this skill does not
 repeat it. Read that section for the credential and approval law, the long-running-command
 binding, the serialization of uploads, the tarball swap that serves a consumer whose dependency
 has not published, what a bump obliges downstream, and where the layer order comes from.
@@ -37,20 +45,25 @@ following the skill.
 
 ## Run the release
 
-1. **Name the round.** List the packages the release covers, and group them into layers by the
-   contract's layer order.
+1. **Name the round.** List the packages the release covers, and group them into layers with
+   `node .agents/skills/orkestrel-publish/scripts/wave.ts --plan`, which reads the contract's
+   layer order from the catalog table.
 2. **Take the registry evidence.** Read what the registry serves for every package in the round.
    Derive each pin from that reading, never from a local manifest.
-3. **Visit each repository.** Run the visit in [wave.md](references/wave.md) in its stated order,
-   in parallel slices of disjoint repositories, each slice serial inside itself.
-4. **Rule on each package's bump.** Apply the triggers in [wave.md](references/wave.md) § Rule on
-   the bump; the contract's § What a bump obliges owns the blast radius.
+3. **Visit each repository.** Run `node .agents/skills/orkestrel-publish/scripts/wave.ts --visit --target <repository>`,
+   which runs the visit in [wave.md](references/wave.md) in its stated order and stops at the first
+   failing step; repair that step by hand and re-run from it with `--from`. Run visits in parallel
+   slices of disjoint repositories, each slice serial inside itself.
+4. **Rule on each package's bump.** Take the visit's comparison and range reading; repeat `compare.ts` only after the artifact changes or an unanswered result. Apply the triggers in [wave.md](references/wave.md) § Rule on
+   the bump; `references/release.md` § What a bump obliges owns the blast radius.
 5. **Prepare the whole layer before authenticating**, in the order [wave.md](references/wave.md)
    § Prepare a layer fixes. Every one of those steps happens outside the window.
-6. **Reach the approval.** Follow [window.md](references/window.md), and launch the login chain
-   only after the user signals they are at the keyboard.
+6. **Reach the approval.** Follow [window.md](references/window.md): run
+   `node .agents/skills/orkestrel-publish/scripts/window.ts --login` only after the user signals
+   they are at the keyboard, and read its `whoami` answer as the session.
 7. **Authorize and upload.** Follow [window.md](references/window.md). Take the account's one-time
-   code where it has one; § Authorize the upload there fixes that code's life and the layer it
+   code where it has one and run
+   `node .agents/skills/orkestrel-publish/scripts/window.ts --publish <layer directories> --otp <code>`; § Authorize the upload there fixes that code's life and the layer it
    carries. Where the account answers with no code, follow § Spend the window there.
 8. **Close the layer from the registry, then prepare the next**, per [wave.md](references/wave.md)
    § Prepare a layer.
@@ -64,9 +77,9 @@ Completion requires:
 
 - every package the round named has ended published at a registry-confirmed version, published on
   a later round with the reason recorded, or ruled as no bump with the evidence that ruled it;
-- every obligation § What a bump obliges places on a published package's dependents has closed as
+- every obligation `references/release.md` § What a bump obliges places on a published package's dependents has closed as
   that section requires;
-- every tarball swap is restored per § Fixing a dependency before it publishes, and no target
+- every tarball swap is restored per `references/release.md` § Fix a dependency before it publishes, and no target
   repository is left holding an uncommitted bump or an unpushed commit;
 - every gate that proved a package ran outside the window and against the artifact that shipped;
 - every gate red at a package's baseline for a cause `ROADMAP.md` already carries is recorded as a

package/dist/host/agents/skills/orkestrel-publish/references/release.md

@@ -0,0 +1,39 @@
+# Release laws
+
+`orkestrel-publish/SKILL.md` names this file. It carries the fleet release rules that bind an executor who is publishing or preparing a package to publish.
+
+## Publishing is the user's
+
+- Publishing is the user's decision and the user's credential. Prepare, surface the approval, and run the publishes the user asked for. Never substitute an API key, an access token, a copied auth file, or another login flow, and never ask the user to paste a token into the conversation.
+- A publish chain is a long-running command: write it as a TypeScript file and launch it through the `orkestrel-dispatch` skill's `scripts/launch.ts`; confirm the previous chain is dead by process id before starting another. Publish serially; concurrent publishes collide on the authentication handshake.
+- A wave over unpublished tips derives its order per run from the dependency graph and records only the round each package landed in.
+
+## Fix a dependency before it publishes
+
+When a consumer meets a defect that lives in a package it only has from the registry, build the dependency from source, pack it, and install the tarball into the consumer. Do not wait for the release and do not work around it in the consumer.
+
+- Install the tarball; never link it. A link skips packing, the `files` list, and the exports map.
+- Write the build, pack, and install to a script and run the file.
+- Record the range you replaced in the same step that replaces it.
+- Rebuild and repack whenever the dependency's source moves; a stale tarball is a stale `dist/`.
+- Delete the consumer's `node_modules/.vite` directory after every tarball install, or install into a fresh worktree; Vite keys its pre-bundle on the installed version.
+- Run one unit per checkout, at that checkout's catalog layer.
+- Fetch and merge the dependency's default branch before packing it.
+- Restore the registry copy before any gate that must prove the published artifact, and before publishing anything. The release still follows layer order: the dependency publishes first, then the consumer re-pins and re-runs its gates.
+- Keep tarballs under `tmp/`; sweep them at acceptance; never commit them.
+
+## What a bump obliges
+
+- A runtime `dependencies` bump reaches every consumer: each package downstream re-pins, re-runs its gates, bumps, and republishes in layer order.
+- A development `devDependencies` bump reaches nobody: re-pin, prove the gates green, commit to `main`; do not bump or publish.
+- A development bump that moves the published artifact is a runtime bump. Prove the direction with the build: rebuild after the re-pin and run `node .agents/skills/orkestrel-publish/scripts/compare.ts`, which compares `dist/` against the published tarball on material content only. Exit 3 bumps and publishes that package, and its dependents follow the runtime rule.
+- Every package is `0.0.x`, where a caret pins one exact release, so the fleet publishes in topological layer order derived from runtime `dependencies` and `peerDependencies` edges, never from a development edge.
+- Read the order from the catalog table in `.claude/agents/orkestrel.md`, regenerated with `scaffold catalog` before sequencing a cascade. Never write a second order elsewhere.
+
+## The scaffold surface
+
+- `scaffold` is a development dependency of every package, so it publishes on its own and propagates as files, never as a cascade. Each package builds against the published `scaffold`.
+- `scaffold` ships `dist/host`, the vendored file set every target receives through `repair`. Bump and publish `scaffold` when any vendored byte or the set of vendored paths changes.
+- After a vendored-only release, re-pin `@orkestrel/scaffold` in each target, run `repair` there, and prove that target's gates still green. A target bumps only when its own published surface moved.
+- Keep a target's own Claude permissions in `.claude/settings.local.json`; `repair` restores the vendored `.claude/settings.json`.
+- Never edit a vendored file inside a target; `repair` restores it and `scaffold audit` reports the drift. Change the vendored file in the scaffold repository and release.

package/dist/host/agents/skills/orkestrel-publish/references/wave.md

@@ -7,8 +7,9 @@ prepare the next.
 
 ## Visit a repository
 
-Run the visit in this order. A step that reads generated or installed state is invalid before the
-step that writes it.
+`scripts/wave.ts --visit` runs these steps in this order and stops at the first one that fails; a
+step that reads generated or installed state is invalid before the step that writes it. Run a step
+by hand only to repair it, then resume with `--from <step>`.
 
 1. Re-pin every `@orkestrel` range to the registry caret (peer ranges included) and install, so
    the overwrite runs the current vendored host.
@@ -39,18 +40,18 @@ step that writes it.
 6. Sweep the self-pins, per § Sweep the self-pins: the re-pin moves the snapshot class.
 7. Run the mutating `format` script to converge generated writes.
 8. Run the quality gates.
-9. Fetch the published tarball, then compare the rebuilt `dist/` against it for material content.
-   An absent baseline is an unanswered comparison, never a moved dist: fetch and re-run rather than
-   ruling a bump owed.
+9. Run `node .agents/skills/orkestrel-publish/scripts/compare.ts` to compare the rebuilt `dist/`
+   against the published tarball for material content. An exit of 2 is an unanswered comparison,
+   never a moved dist: fetch and re-run rather than ruling a bump owed.
 
 Restore any unpublished tarball the target is holding before the quality gates run, per
-`.agents/orchestration.md` § Fixing a dependency before it publishes. A distribution proof run
+`release.md` § Fix a dependency before it publishes. A distribution proof run
 against a local tarball proves the local tarball. Stage an unpublished tarball with
 `npm install --no-save`, because a `file:` pin refuses the blueprint and the manifest keeps a
 registry range.
 
-Where a visit runs before scaffold itself publishes, run `scaffold overwrite --offline` and prove
-the sweep with `scaffold audit --offline`. The online verbs read vendored bytes from the published
+Where a visit runs before scaffold itself publishes, run the visit with `--offline`; the runner
+performs the offline overwrite and proves the sweep with `scaffold audit --offline`. The online verbs read vendored bytes from the published
 package, so an unpublished scaffold's visit otherwise writes the registry's older floor, and an
 online audit reports the floor-restored files as stale until the release. The `--offline` overwrite
 skips the catalog step and exits `1` with a note naming that refusal, so run the full
@@ -61,15 +62,15 @@ reporting per target. Refuse a failed target, name it, repair it, and re-run it
 
 ## Rule on the bump
 
-Bump on either trigger: the rebuilt dist differs materially from the published tarball, or the
-final runtime dependency set differs from the published packument.
+Bump on either trigger: `scripts/compare.ts` exits 3 (the rebuilt dist differs materially from the
+published tarball), or the final runtime dependency set differs from the published packument.
 
 - Test the final dependency set against the packument, never "did my step move a pin". The
   `declare` step inside `scaffold overwrite` re-pins before any later check, so the step-local
   reading reports nothing moved while the manifest surface did.
 - Treat a re-pinned runtime range as published surface. Without the bump a consumer installs
   duplicate copies of the moved dependency.
-- Compare material content only, as `.agents/orchestration.md` § What a bump obliges defines it,
+- Compare material content only, as `release.md` § What a bump obliges defines it,
   and take the blast radius of a bump from that section rather than deciding it here.
 - Ship a dist built before the version bump wherever the bump edits no emitted byte. Check that
   per package rather than assuming it: a package that imports its own `package.json` version into
@@ -77,7 +78,7 @@ final runtime dependency set differs from the published packument.
   Rebuild after the bump there and pack from the rebuilt tree. The `npm publish --ignore-scripts`
   command skips `prepack`, so that rebuild is the operator's step rather than the publish's. The
   same holds for a package that writes its declared ranges into published output: its `dist/`
-  moves on a development re-pin, and `.agents/orchestration.md` § What a bump obliges rules that
+  moves on a development re-pin, and `release.md` § What a bump obliges rules that
   re-pin a release.
 
 One trigger orders rather than bumps. A package the fleet consumes as a development dependency,
@@ -105,8 +106,9 @@ Prepare a published package's layer in this order, after the visit has ruled the
 5. **Write the release commit and push before the window opens.** The preparation commit inside
    the visit is a different commit at a different moment.
 
-Where an inventory taken before the round already ruled every dist moved, the bump rides the
-visit's first step and these steps fold into the visit, whose comparison then confirms the ruling.
+Where an inventory taken before the round already ruled every dist moved, apply the bump before
+the visit, pass the replaced version through `--prior` so the self-pin sweep finds it, and complete
+the remaining steps of this section after the visit, whose comparison confirms the ruling.
 
 Prepare the next layer only after this one is on the registry. A dependent's new pin cannot
 install until the version it names exists, so preparation and publication interleave and cannot be
@@ -123,13 +125,12 @@ every one of them. A snapshot of generated output carries the ranges the package
 its own version, and any re-pin, a development one included, falsifies it. Run this sweep after the
 re-pin install, not after the manifest edit.
 
-- Search `tests/` and `src/` in the publishing package for the prior version literal, and rule on
-  every hit. A canned packument in a fixture and a looked-up version in a CLI suite carry the
-  version with no tripwire comment beside them, so they surface as a red gate after the bump
-  rather than as a planned edit before it.
-- Search `tests/` for the prior range of every re-pinned dependency, and move each snapshot the
-  search hits with the re-pin. A generated-manifest fixture never carries the package's own prior
-  version, so the version sweep cannot reach it.
+- Run `node .agents/skills/orkestrel-publish/scripts/pins.ts --version <prior> --range <prior range> ...`
+  with the prior version and the prior range of every re-pinned dependency, rule on every hit, and
+  move every generated-manifest snapshot hit with its re-pin.
+  A canned packument in a fixture and a looked-up version in a CLI suite carry the version with no
+  tripwire comment beside them, and a generated-manifest fixture carries the ranges and never the
+  package's own version, so one run names both classes.
 - Move a documented tripwire — a golden digest over generated output — in the same change as the
   version bump. That is what the tripwire is for.
 - Re-take a generated artifact's digest after the install, because the generated bytes can derive

package/dist/host/agents/skills/orkestrel-publish/references/window.md

@@ -9,8 +9,11 @@ rest of the layer either fits inside it or takes another approval.
 
 ## Arm the terminal
 
-- Run the login and every publish under `script -qfc '<command>' <log>`. npm offers the approval
-  only when it sees a TTY; without one it fails `EOTP` with no way to answer.
+- Read the session with `node .agents/skills/orkestrel-publish/scripts/window.ts --whoami`; `--login` prints the command the operator runs in a real terminal and polls `whoami` until it answers. No child of a script holds the TTY npm needs, so the login itself is the operator's.
+
+- Run the login and every browser-authorized publish under `script -qfc '<command>' <log>`. npm
+  offers the browser approval only when it sees a TTY; without one it fails `EOTP` with no way to
+  answer. The one-time-code path runs under captured pipes instead, per § Authorize the upload.
 - Pass `--browser=false` to `npm login` and to every `npm publish`. Without it npm prints
   `Press ENTER to open in the browser...` and blocks. Never answer that prompt with a newline: the
   web flow consumes the newline on a later read, drops to a legacy `Username:` prompt, and exits
@@ -27,13 +30,15 @@ rest of the layer either fits inside it or takes another approval.
   and an overnight gap expires it, so a session-start answer does not hold.
 - Read a login log that shows the spinner and then a legacy `Username:` prompt as a dead attempt
   rather than as a prompt to answer: expired, or refused on its first poll per § Read a `403` on the
-  poll. Kill it by the process id recorded at its launch, per `.agents/orchestration.md` § Confirm
-  dead before relaunching. Every publish here runs under the same `script -qfc` form, so a pattern
-  over the process list reaches a live upload as readily as the dead login.
-- On a Windows host, Git Bash ships no `script` binary, so the upload step is operator-driven:
-  prepare the layer, prove the gates, surface the exact `npm publish` command, and the operator
-  runs it in a real terminal. Everything before and after the upload — bumps, re-pins, gates,
-  registry reads — stays with the Orchestrator. The fifo stdin law still binds on that host.
+  poll. Kill it by the process id recorded at its launch, per the `orkestrel-dispatch` skill's launch
+  reference § Kill and relaunch. Every browser-authorized publish here runs under the same `script -qfc` form, so
+  a pattern over the process list reaches a live upload as readily as the dead login.
+- On a Windows host, Git Bash ships no `script` binary, so a browser-authorized upload is
+  operator-driven: prepare the layer, prove the gates, surface the exact `npm publish` command, and
+  the operator runs it in a real terminal. Everything before and after the upload — bumps, re-pins,
+  gates, registry reads — stays with the Orchestrator, and the one-time-code path in § Authorize the
+  upload runs through `window.ts` on every host. The fifo stdin law still binds a browser-authorized
+  upload on that host.
 
 ## Reach the approval
 
@@ -80,6 +85,8 @@ rest of the layer either fits inside it or takes another approval.
 
 ## Authorize the upload
 
+- Where the account answers with a one-time code, run `node .agents/skills/orkestrel-publish/scripts/window.ts --publish <layer directories> --otp <code>`: it uploads back to back, journals each upload under `tmp/units/`, stops at the first refusal naming the package to resume from on a fresh code, and confirms each accepted version against the registry. The browser path stays the operator's.
+
 - Take the account's one-time code where the account has one. The
   `npm publish --ignore-scripts --otp=<code>` command uploads with no browser authorization and no
   poll. The code has its own life: measured on 2026-09-04 against `registry.npmjs.org`, one code
@@ -93,12 +100,16 @@ rest of the layer either fits inside it or takes another approval.
   describes for the browser path: the chain stops at the refused package, and the layer resumes
   from that package on a fresh code. Never retry the refused upload on the same code.
 - Ask for the code and nothing else. Never ask for a password, an access token, or an auth file.
-  `.agents/orchestration.md` § Publishing the fleet owns that law.
-- Arm a one-time-code upload the way § Arm the terminal arms every other publish.
+  `release.md` § Publishing is the user's owns that law.
+- A one-time-code upload needs no terminal arming: `window.ts --publish` holds the upload under
+  captured pipes, where npm's non-TTY guard rethrows an authentication refusal instead of prompting,
+  so a spent code is refused `EOTP` with no prompt and no browser flow, which is the stop the runner
+  reads. The runner passes `--browser=false` and re-reads `whoami` immediately before the first
+  upload. Never run a one-time-code upload on a TTY: there npm answers a refused code with a prompt
+  the chain cannot see.
 - Fall back to the browser authorization where the account answers with no code. That path mints
   the `auth/cli/<id>` URL, needs the click inside the session's life, and opens the five-minute
-  window. In the `@orkestrel/scaffold` 0.0.56 run on 2026-08-27 that authorization failed on the
-  45-second abandon and the one-time code uploaded the package with no retry.
+  window.
 - Tell the user that approving an `auth/cli/<id>` URL opens a five-minute window covering the rest
   of the layer.
 
@@ -130,7 +141,7 @@ rest of the layer either fits inside it or takes another approval.
 - Expect a large layer to outlast one window. Size batches to what uploads in five minutes and
   name each planned approval point to the user, rather than discovering them mid-run.
 - The contract's serialization law binds every upload in the window, and
-  `.agents/orchestration.md` § Long-running commands binds the chain that runs them.
+  the `orkestrel-dispatch` skill binds the chain that runs them.
 
 ## Read a `403` on the poll
 
@@ -155,6 +166,8 @@ the same status. Rule from the evidence, never from which cause reads likelier.
 
 ## Read the verdict from the registry
 
+- Confirm a layer with `node .agents/skills/orkestrel-publish/scripts/window.ts --confirm <name@version>...`, which re-reads the registry until it serves each version or the wait ends.
+
 - Read `+ @orkestrel/<name>@<version>` in the upload's own journal as the accepted verdict, and
   advance the chain on it. The registry's read lags its processing by minutes, which the
   `Your package is being processed and may take a few minutes to become available.` notice beside