@1aboveio/skills 1.0.7 → 1.0.9

package/skills/engineering/ensure-coverage/SKILL.md

@@ -2,7 +2,7 @@
 name: ensure-coverage
 description: "Define or audit behavior-first test criteria — ACs, required test levels, mock/integration/E2E policy — across three axes: breadth (Coverage Ledger), depth (over-mocking), presentation (perceivability of browser surfaces). NOT judging whether a single test is any good (test-quality), authoring browser tests (e2e-test), reviewing a PR (better-review), or delivering issues (resolve-issues)."
 disable-model-invocation: true
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Ensure Coverage

package/skills/engineering/ensure-coverage/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/golden-path/SKILL.md

@@ -3,7 +3,7 @@ name: golden-path
 description: "Golden-path E2E: the short list of user journeys whose failure blocks a release, kept in a repo as one contract (golden-paths.json) with a generated GOLDEN_PATHS.md and a generated GitHub Actions workflow, and run against a local build or a deployed URL for an ALIVE/DEAD verdict. Use to set golden paths up in a repo ('init golden paths', 'add golden-path CI'), to migrate an older smoke.manifest.json or a hand-built smoke setup ('audit', 'migrate smoke'), to add, change, or remove a golden path, to ask 'is the build alive?' or run them before a PR or release, or when a change touches a flow listed in GOLDEN_PATHS.md. NOT for writing the Playwright specs themselves (e2e-test), deciding what a change must prove (ensure-coverage), or general workflow YAML (github-actions)."
 dependencies:
   - e2e-test
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Golden path

package/skills/engineering/golden-path/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/harness-runtime/SKILL.md

@@ -3,7 +3,7 @@ name: harness-runtime
 description: Internal import-only library shared by first-party engineering packages. Not a workflow skill; never select or invoke it as a user capability.
 disable-model-invocation: true
 user-invocable: false
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Harness Runtime

package/skills/engineering/harness-runtime/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/resolve-issues/SKILL.md

@@ -8,7 +8,7 @@ dependencies:
   - better-review
   - golden-path
   - harness-runtime
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Resolve issues
@@ -78,7 +78,7 @@ ships sooner at the same bar.
 `/rush-issues` runs this workflow with every answer defaulted ([shortcut mode](references/preflight.md#shortcut-mode)).
 
 **Bounds:** the harness times and stops workers · retry while cycles reach new lows; 2 without one,
-then [expire.md](references/expire.md) (a fix cycle progresses only on a new low; a resume, when it adds work the PR needs; diagnostics and records never) · workers within [live host capacity](references/implementation.md#live-capacity), one local emulator, queued for device-only work
+then [expire.md](references/expire.md) (fixes and resumes progress through verified checkpoint advances or fewer established failures; added work, diagnostics and records alone do not reset counts) · workers within [live host capacity](references/implementation.md#live-capacity), one local emulator, queued for device-only work
 and non-CI emulator proof ([scheduling](references/implementation.md#scheduling); CI confirms, never debugs) · one PR per issue · every runnable unit in one run, in dependency order · blocking review hands back
 after 2 fix rounds without a new low of open P0/P1 path rows; no fixed round cap.
 
@@ -150,26 +150,17 @@ Read each procedure right before its stage; never substitute your own.
   steps are only the read-only warehouse canary (never blocks) and the isolated, run-owned resources
   [preflight.md](references/preflight.md#never-block-on-the-human) allows.
 
+## Delivery progress
+
+Before briefing or continuing a unit, read [delivery-progress.md](references/delivery-progress.md).
+Keep one existing acceptance checkpoint per unit, preserve failure history, justify new
+infrastructure, and report verified behavior. Full acceptance and required CI still apply.
+
 ## Every brief contains
 
-- the source and criteria, as a file already in the run directory
-- the plan's `standingOrders`, verbatim, and the decisions that answer this unit's questions
-- absolute run, workspace, and findings paths; for implementers, the unit's
-  findings entry and its parents' `contracts`
-- model id, effort, and a required read-back
-- an absolute skill path when the stage invokes a leaf skill; for validating, the unit's `proof.suite` `skill` (read it first) and `local`, when set
-- the outcome and validation, with no prescribed method or evidence format
-- the [Goal](#goal) and [Principles](#principles), verbatim (a reviewer gets review.md's two rules instead)
-- the result path, `<run>/results/<unit>-<label>.json` (`<label>`: kind and attempt, e.g. `fix-2`), with `unit` and `decisionNeeded` (null or a choice)
-- at the deadline: stop starting work, commit, and report
-- environment rules: write only inside the workspace (and the findings directory for the explorer),
-  with tool caches and temp files there (`TMPDIR`, `npm_config_cache`, `UV_CACHE_DIR`); use the machine's
-  installed JDK, Android SDK, system images, and browsers (`JAVA_HOME`, `ANDROID_HOME`) where they fit,
-  or the repo's pinned Playwright image where the runner has no browser (`github-actions` runners.md);
-  edit with the harness's tools, never a shell `apply_patch`
-
-Treat a missing or unreadable result as an incomplete stage: resume a dead
-spawn once in the same workspace, never with a success claim.
+Use the full [brief checklist](references/delivery-progress.md#every-brief-contains),
+including the Goal and Principles verbatim, checkpoint history and result contract.
+Treat a missing or unreadable result as incomplete; resume a dead spawn once in its workspace.
 
 ## Workflow
 

package/skills/engineering/resolve-issues/references/delivery-progress.md

@@ -0,0 +1,63 @@
+# Delivery progress
+
+For each active unit, name **one immediate acceptance checkpoint** from its existing
+criteria: the next observable behavior or contract to prove. A narrow checkpoint guides
+the next action; it does not replace the unit's full acceptance or required CI. Independent
+units keep their own checkpoints and continue in parallel within actual resource limits.
+
+- **Preserve an existing working baseline.** Keep its source/artifact identity, relevant
+  environment and passing result as a comparison. Reuse it while those inputs remain
+  valid; do not create a new baseline campaign when none exists or treat an old artifact
+  as acceptance of the candidate. Keep only what the repo's ownership/retention rules allow.
+- **Debug the smallest failing behavior first.** Name the failing command and the
+  observation that would distinguish the remaining causes. Run the relevant host,
+  integration or device check before another broad acceptance cycle. After a correction,
+  run affected checks and the required delivery checks, not extra assurance work.
+- **Justify infrastructure before adding it.** State which existing criterion requires
+  it, why the current path cannot provide that proof, and the smallest alternative.
+  Record the choice in the existing decision/note, within current authorization. Routine
+  choices need no new approval; shared-resource changes and changes to the acceptance
+  bar retain their existing authorization rules. A failed screen alone does not justify
+  a new service, transport layer or test platform.
+- **Continue on evidence, not activity.** A handoff identifies what changed at the
+  checkpoint: a reproduction, a discriminating observation, a verified correction or
+  a concrete blocker, and the next test. A new worker, commit, diagnostic helper, test
+  count or green unrelated check is not delivery progress. Useful diagnostic evidence
+  can justify a bounded experiment; it does not reset acceptance/non-convergence counts.
+- **Reassess repeated failure at the same checkpoint.** Carry prior evidence and
+  no-progress history across worker/model changes and new infrastructure. Follow
+  [expiry](expire.md); do not restart the same approach with a fresh brief or
+  count newly invented setup milestones as progress. Replan around a smaller case or a
+  different distinguishing test, keeping the original criteria and truthful blockers.
+- **Report delivered behavior first.** Use existing plan notes/results to state criteria
+  completed and the current checkpoint. When available, include time to reproduction,
+  time to verified correction and full CI runs spent on this change. Do not invent
+  missing timings or create a separate reporting system to collect them.
+
+These rules apply to briefs and coordinator decisions; they add no plan schema, check,
+issue or automatic scheduler gate. They do not waive required validation.
+
+## Every brief contains
+
+- the source and criteria, as a file already in the run directory
+- the plan's `standingOrders`, verbatim, and the decisions that answer this unit's questions
+- absolute run, workspace, and findings paths; for implementers, the unit's
+  findings entry and its parents' `contracts`
+- model id, effort, and a required read-back
+- an absolute skill path when the stage invokes a leaf skill; for validating, the unit's `proof.suite` `skill` (read it first) and `local`, when set
+- the outcome and validation, with no prescribed method or evidence format
+- the [immediate acceptance checkpoint](#delivery-progress), existing baseline (or none),
+  and, for a continuation, the last result, remaining uncertainty and next distinguishing
+  test; retain the same checkpoint/history when changing workers
+- the [Goal](../SKILL.md#goal) and [Principles](../SKILL.md#principles), verbatim (a reviewer gets review.md's two rules instead)
+- the result path, `<run>/results/<unit>-<label>.json` (`<label>`: kind and attempt, e.g. `fix-2`), with `unit` and `decisionNeeded` (null or a choice)
+- at the deadline: stop starting work, commit, and report
+- environment rules: write only inside the workspace (and the findings directory for the explorer),
+  with tool caches and temp files there (`TMPDIR`, `npm_config_cache`, `UV_CACHE_DIR`); use the machine's
+  installed JDK, Android SDK, system images, and browsers (`JAVA_HOME`, `ANDROID_HOME`) where they fit,
+  or the repo's pinned Playwright image where the runner has no browser (`github-actions` runners.md);
+  edit with the harness's tools, never a shell `apply_patch`
+
+Treat a missing or unreadable result as an incomplete stage: resume a dead
+spawn once in the same workspace, never with a success claim.
+

package/skills/engineering/resolve-issues/references/expire.md

@@ -9,10 +9,12 @@ commit alone is not progress. Lows only fall, so the loop always ends.
 Example: CI fails 5 tests, then 3, then 3, then 3: expire after the fourth
 cycle. 3, 2, 3, 2 expires too: the second 2 is no new low. 5, 4, 3, 2, 1
 never expires. A failing journey run, local or dispatched, counts as one
-failing check, so count its furthest checkpoint instead (the last step its
-log reports passing): login, store, charge, charge, charge expires;
-login, store, charge, receipt keeps going. Checkpoints are finite, so this
-loop ends too.
+failing check, so count its furthest **existing acceptance checkpoint** instead
+(the last relevant step its log reports passing): login, store, charge, charge,
+charge expires; login, store, charge, receipt keeps going. Extra instrumentation,
+new infrastructure milestones or renaming a checkpoint do not extend this sequence.
+Carry the comparison history across worker/model changes and retries; a genuinely
+changed requirement needs an explicit scope decision, not an implicit reset.
 
 | Scope | Count that must reach a new low | Expire after |
 |---|---|---|
@@ -21,9 +23,17 @@ loop ends too.
 | Warehouse canary | distinct errors | 2 attempts without progress; record a follow-up, never block |
 | Review | open P0/P1 path rows | `review-verdict.mjs` verdict `handback` ([review.md](review.md#fix-loop)) |
 | CI and merge | failing checks and tests; a failing journey run (local or `gh workflow run`) is one check, so it progresses when it passes a checkpoint no earlier run of the attempt passed | 2 fix-and-watch cycles without progress |
-| Any worker the harness reports stuck, late, or at its ceiling | none: a resume [progresses](#retry-by-failure-mode) when it adds work the unit's PR needs (product code, tests, CI config, a fix of what blocks it) or meets another acceptance criterion; diagnostics and records alone are not progress | 2 resumes in a row that add neither |
+| Any worker the harness reports stuck, late, or at its ceiling | a resume progresses when its verified result advances the existing checkpoint or reduces the established failure count; added product/test/CI code without that result is not progress, and diagnostics alone do not reset the count | 2 resumes in a row without such progress |
 
-Leave timing to the harness; never stop a worker still making progress.
+Use [Delivery progress](../SKILL.md#delivery-progress) to choose the next bounded
+experiment before applying this ladder. Reproducing a failure or collecting a missing
+observation can be useful without advancing acceptance. Record that distinction; do
+not count logs, helper code or a changed worker as a new low. On repeated non-convergence,
+reassess the approach and preserve unpassed criteria rather than creating another setup
+chain. Existing retry/block/replan rules below still apply.
+
+Leave timing to the harness for worker lifetimes. Bound individual test/subprocess waits
+explicitly with cleanup time; an outstanding tool call or heartbeat is not progress.
 
 ### Retry by failure mode
 
@@ -102,8 +112,9 @@ hours.
   wakes the run at the printed time.
 - `check-worker` means the worker changed no workspace file for
   `--quiet-minutes` (45 by default): read its latest output. Stuck: stop it
-  and take the `timeout-task` response. Still working (a long test run with
-  live output): let it run.
+  and take the `timeout-task` response. A long test with advancing test/phase results
+  inside its declared command deadline may continue. Repeated heartbeats, unchanged
+  logs or an unbounded child wait are not that evidence.
 - A watcher that ends with nothing new (a queue `STALLED` with no failing
   check) is a wait: restart it and report it in one line, or not at all.
 
@@ -202,14 +213,14 @@ logs, and record one line, with the reason code, in the unit's plan row.
 
 | Failure | Response |
 |---|---|
-| `timeout-task` or `spawn-death` | Resume in the kept workspace: commit what is there, then finish or report. Keep resuming while each resume makes [progress](#retry-by-failure-mode); after 2 in a row that add nothing, mark the unit `blocked` (`blockedReason: timeout-task` or `spawn-death`) and hand it back. A result with `decisionNeeded` is decided first ([Decide before you defer](#decide-before-you-defer)), and the resume that carries the decision always runs. Example: a fix worker loses its model stream twice but committed a fixture each time; start a third continuation. |
+| `timeout-task` or `spawn-death` | Resume in the kept workspace: commit what is there, then finish or report. Keep resuming while each resume makes [progress](#retry-by-failure-mode); after 2 in a row without verified checkpoint/failure-count progress, mark the unit `blocked` (`blockedReason: timeout-task` or `spawn-death`) and hand it back. A result with `decisionNeeded` is decided first ([Decide before you defer](#decide-before-you-defer)), and the resume that carries the decision always runs. Example: a fix worker loses its model stream after its focused regression passes; resume the remaining work with that result. Two resumes that only add fixtures without advancing the existing checkpoint trigger reassessment. |
 | Environment or infrastructure (a check cannot run: cache, emulator, runner, network, credentials) | See [Infrastructure failures](#infrastructure-failures). |
 | Implement: a fix cycle without progress | Resume with the failing command and its output as the only target, using the escalation model. 2 cycles in a row without progress: `blocked` (`blockedReason: retry-implement`), deferred on its issue. |
 | Review: `review-verdict.mjs` verdict `fix` | Follow its `action` ([review.md](review.md#fix-loop)). |
 | Review: `review-verdict.mjs` verdict `handback` (`not-converging`) | Stop fixing; mark the unit `blocked` (`blockedReason: review-handback`) and defer the PR with its open findings on its issue. |
 | Review: `review-verdict.mjs` verdict `decide`, or a worker's `decisionNeeded` | [Decide before you defer](#decide-before-you-defer). |
 | CI: a fix cycle without progress | Treat the failing check as the failing test: the next fix worker runs on the escalation model with that check as its only target. 2 cycles in a row without progress: `blocked` (`blockedReason: retry-ci`), deferred on its issue. |
-| Too big for one attempt | Resume in the kept workspace while each resume makes [progress](#retry-by-failure-mode); after 2 in a row that make none, draft a split in `<run>/splits/`, file it into the spec's tree, and run the slices the sync adds ([preflight.md](preflight.md#put-every-filed-issue-in-the-tree)). |
+| Too big for one attempt | Resume in the kept workspace while each resume makes [progress](#retry-by-failure-mode); after 2 in a row without verified checkpoint/failure-count progress, draft a split in `<run>/splits/`, file it into the spec's tree, and run the slices the sync adds ([preflight.md](preflight.md#put-every-filed-issue-in-the-tree)). |
 | A required proof the unit has no environment for yet | The unit builds it; see [Proof stays with its unit](#proof-stays-with-its-unit). |
 | Dependency | Fix the edge; resume when runnable. |
 | A capability the unit needs is missing and no unit builds it (a shared driver, fixture, or hook) | Build it inside the first unit that needs it; units that need it later get `dependsOn` on that unit. Only when that puts the unit past the size check's line limit, file it as its own issue beside them, with `blocked_by` on the units that use it, never on their parent issue. Example: three proof units each need a device-state reader: the first builds it, the other two depend on the first. |
@@ -229,7 +240,9 @@ dependents start while the parent still proves itself; only the unit's own
 merge waits for its proof.
 
 - **No working suite or environment yet? The unit builds what its proof
-  needs**, with access the run already has (the run's local emulator, when
+  needs**, after recording why the existing path cannot prove that criterion and why
+  the proposed addition is the smallest suitable option ([Delivery progress](../SKILL.md#delivery-progress)),
+  with access the run already has (the run's local emulator, when
   [its queue](implementation.md#scheduling) hands it over, a
   disposable database, a container, a tunnel hostname), counted in its
   lines like a missing prerequisite. When two or more units need the same

package/skills/engineering/resolve-issues/references/implementation.md

@@ -59,6 +59,12 @@ boundary, workspace, outcome, validation, and return contract; prescribe no
 method or evidence format. Name a leaf skill only as the findings record it
 (`proof.suite.skill`, with `local`).
 
+A continuation inherits the immediate acceptance checkpoint and history from
+[Delivery progress](../SKILL.md#delivery-progress). In its existing result, state what
+new evidence changes the next action; if nothing changed, say so instead of relaunching
+the same work. A passing setup check is not a substitute for the blocked behavior.
+No additional report or result schema is required.
+
 Have the implementer treat findings as leads, find its own code, and report
 any `product`, `scope`, `design`, or `approval` question the explorer missed and any
 human-only proof. Report each question in the result's `decisionNeeded`
@@ -87,7 +93,9 @@ implementer in its kept workspace with the brief and its findings entry.
    options, recommendation; options are ways to proceed, and staying
    blocked is never one). Fix workers write the same file. Return
    nothing else: no artifact hashes, version inventories, screenshots,
-   copied logs, or earlier attempts.
+   copied logs, or earlier attempts. For a continuation, include the current checkpoint,
+   outcome and relevant prior-result links in the existing integration notes; do not
+   duplicate the full attempt history.
 
 After 2 fix cycles without progress, or a stuck or late worker, follow
 [expire.md](expire.md). Start the next worker in the same workspace with the

package/skills/engineering/resolve-issues/references/preflight.md

@@ -45,6 +45,13 @@ sub-issues, never a checklist.
 
 ### Compaction hook
 
+For a native Codex bundle, first follow [Native Codex selection](shared-modules.md#native-codex-selection).
+The hook command returns `plugin-no-global-hooks` and writes nothing, even without
+`--check`. Do not offer a machine-wide cached-path hook. Preserve the installation
+descriptor in the plan and use the selected copy's recovery command after resume.
+Native host compaction/resume still requires separate client certification.
+The remaining hook instructions apply to standalone installations.
+
 **A compaction summary keeps the run's state and drops the skill's rules, so
 a hook makes you read the skills again after every compaction.** Check it:
 

package/skills/engineering/resolve-issues/references/shared-modules.md

@@ -4,6 +4,33 @@ Use the owning skill for models, review, golden paths, and the merge queue; neve
 copy its doctrine here. Resolve a leaf skill from the active skills root only
 for a stage that invokes it, and pass its absolute path.
 
+## Native Codex selection
+
+For a native bundle invocation, run the invoked copy's
+`scripts/active-installation.mjs capture` before spawning workers. Save its JSON as
+`installation` in this run's task plan and as a run-local `installation.json`.
+Capture reads only the executing bundle's fixed ancestor, never another cache.
+A certifier passes independently verified pins as `capture <expected-pins.json>`;
+ordinary capture starts from the artifact selected by Codex. Neither operation is
+a signature or published-artifact certification.
+
+Use `scripts/active-installation.mjs worker <installation.json> <canonical-name>...`
+to obtain verified absolute instruction paths. Resolve other resources through
+`engineering-runtime/scripts/installation-resolver.mjs resolve <installation.json>
+<canonical-name> <member-relative-resource>`. Pass those paths and the unchanged
+installation descriptor in worker briefs. Keep the host's observed namespaced
+identity separate from the canonical catalog name; never strip arbitrary prefixes
+to resolve dependencies. Missing, changed or ambiguous resources stop the affected
+workflow; do not search caches, use a shared namesake, or install dependencies.
+Model slots and reviewer independence still follow the policy below.
+
+After compaction or resume, run the selected copy's `scripts/rehydrate.mjs --cwd
+<project>` and read the returned instruction paths in full. It verifies the saved
+installation before returning paths and reports blocked recovery on drift. Native
+bundle invocations do not install global hooks. Scripted recovery alone is not
+proof that a Codex surface triggers it; native host compaction/resume certification
+must pass before that surface is advertised as supported.
+
 ## Model catalog
 
 Owner: [`harness-runtime`](../../harness-runtime/) (catalog doctrine and seed

package/skills/engineering/resolve-issues/references/task-plan.md

@@ -85,7 +85,7 @@ Fleet `status`: `pending`, `in-flight`, `succeeded`, `failed`,
 | `workerKind` | `implement`, `fix`, or `review`, set with `worker`; the [live-capacity scheduler](implementation.md#live-capacity) (`next-actions.mjs`) prints `worker-kind` for any other kind or none. An infrastructure diagnosis or a test-first worker is a `fix` worker. The explorer is the `explore` fleet row's worker, never a unit's; a merge-queue watcher is not a worker |
 | `estimatedLines` | Explorer estimate |
 | `sizeCheck` | Measures, `verdict` (the size check's per-unit verdict; `stop` means held), scope and proof verdicts, split or verification path; `runWhole: true` once a recommendation to run a held unit whole is accepted |
-| `note` | SHA, expiry reason code, failure and the response taken, or blocker |
+| `note` | SHA, expiry reason code, failure and response, or blocker; for active debugging, the immediate acceptance checkpoint, baseline/result link and next distinguishing test ([delivery progress](../SKILL.md#delivery-progress)) |
 | `pr`, `headSha`, `reviewedHead` | PR URL, current HEAD (recorded from the implementer's first pushed commit on, so the draft PR opens early), last HEAD whose verdict was `pass` (reviewed or carried) |
 | `delivery` | `building`, `opening`, `review`, `ci`, `merged`, `blocked` |
 | `reviewRound`, `fixRound` | Review-attempt/file number, and the count of blocking-fix cycles (a record, not a cap); record both from the review/verdict, never charge skips, or reviews that follow a passing one, as fixes |
@@ -102,7 +102,11 @@ Example: #1201's code is done and its PR is in review, so it is
 merge-ready PR handed back stays `in-flight` with the note "merge-ready,
 handed back"; it is never `succeeded` until the human merges it.
 
-Run fields: `skill` (`resolve-issues` or `rush-issues`; the scheduler and
+Run fields: optional `installation` holds the explicit native installation descriptor
+(one absolute root, layout, resource metadata path/digest, release identity, and
+pinned external root mappings). Capture from the selected bundle and preserve it
+through workers and recovery; never replace it with a newer cache or shared copy.
+Other run fields: `skill` (`resolve-issues` or `rush-issues`; the scheduler and
 rehydrate read it, and `next-actions.mjs` exits 2 without it), `planRevision`, models and efforts, `targetBranch`,
 `deliveryMode` and its check, `mergeMode`, run directory, `specLocator`
 (`owner/name#N` or an issue URL; any other name turns off the issue-tree sync),
@@ -259,6 +263,9 @@ changes, unit outcomes, validation turning red or green, canary events,
 retries and escalations, newly runnable dependencies, PR open, HEAD change, or
 merge, and about every 5 minutes; skip when nothing changed.
 
-Final board: each unit's outcome with its scope and proof verdicts, every PR URL, SHA,
-and merge state, retry and escalation totals, each blocker, and the exploration
-path.
+Final board: lead with behavior delivered and criteria still unproved, then each unit's
+scope and proof verdicts, PR URL, SHA, merge state, retries, blocker and exploration path.
+Use existing result timestamps and CI records, when available, for time to reproduction,
+time to verified correction and full CI runs per delivered change. Mark missing data as
+unknown. Worker/test counts describe activity, not acceptance; do not add a reporting
+pipeline or duplicate the plan to produce these summaries.

package/skills/engineering/resolve-issues/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/resolve-issues/scripts/active-installation.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { executingBundleRoot, selectInstallation, workerResources } from '../../engineering-runtime/scripts/installation-resolver.mjs';
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs';
+
+// Initial capture trusts the explicitly invoked native artifact's package metadata. A release
+// certifier supplies independent pins; subsequent workers/recovery always reuse the captured pins.
+export function captureBundleInstallation(skillDirectory, expected = null, externalRoots = {}) {
+  const root = executingBundleRoot(skillDirectory);
+  if (!root) throw new Error('The invoked skill is not in a native bundle');
+  const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+  const pins = expected ?? pkg.nativeCodex;
+  if (!pins || Object.keys(pins).some((key) => !['schemaVersion', 'metadataPath', 'metadataDigest', 'releaseIdentity'].includes(key))) {
+    throw new Error('Expected resource pins cannot override installation selection');
+  }
+  const { metadataPath, metadataDigest, releaseIdentity } = pins;
+  return selectInstallation({ layout: 'bundle', root, metadataPath, metadataDigest, releaseIdentity, externalRoots });
+}
+
+if (isMainModule(import.meta.url)) {
+  try {
+    const [command, descriptor, ...names] = process.argv.slice(2);
+    const result = command === 'capture' ? captureBundleInstallation(dirname(dirname(fileURLToPath(import.meta.url))),
+      descriptor ? JSON.parse(readFileSync(descriptor, 'utf8')) : null)
+      : command === 'worker' ? workerResources(JSON.parse(readFileSync(descriptor, 'utf8')),
+        names.map((canonicalName) => ({ canonicalName }))) : null;
+    if (!result) throw new Error('Usage: active-installation.mjs capture [expected-pins.json] | worker <installation.json> <canonical-name>...');
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }
+}

package/skills/engineering/resolve-issues/scripts/install-hooks.mjs

@@ -25,6 +25,7 @@ import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
+import { executingBundleRoot } from '../../engineering-runtime/scripts/installation-resolver.mjs'
 import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
 
 export const REHYDRATE = join(dirname(fileURLToPath(import.meta.url)), 'rehydrate.mjs')
@@ -85,10 +86,12 @@ function readJson(file) {
 export function run({ home = homedir(), check = false, harness } = {}) {
   const names = harness ? [harness] : Object.keys(HARNESSES)
   const out = []
+  const nativeBundle = executingBundleRoot(dirname(dirname(REHYDRATE)))
   for (const name of names) {
     const h = HARNESSES[name]
     if (!h) throw new InstallHooksError(`unknown harness ${name}: use claude or codex`)
     const file = join(home, h.dir, h.file)
+    if (nativeBundle) { out.push({ harness: name, file, status: 'plugin-no-global-hooks' }); continue }
     if (!existsSync(join(home, h.dir))) { out.push({ harness: name, file, status: 'absent' }); continue }
     const settings = readJson(file)
     if (pluginEnabled(settings, name)) { out.push({ harness: name, file, status: 'plugin' }); continue }

package/skills/engineering/resolve-issues/scripts/rehydrate.mjs

@@ -20,6 +20,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
+import { workerResources } from '../../engineering-runtime/scripts/installation-resolver.mjs'
 import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
 import { RULES, SKILL_PATH } from './next-actions.mjs'
 
@@ -54,13 +55,28 @@ export function activeRuns(cwd, now = Date.now(), hours = ACTIVE_HOURS) {
     const units = (Array.isArray(plan?.units) ? plan.units : plan?.issues) ?? []
     const open = units.filter((u) => !DONE.has(u?.status)).length
     if (!open) continue
-    runs.push({ dir: join(root, name), skill: plan.skill ?? 'resolve-issues', revision: plan.planRevision ?? null, open, mtime })
+    runs.push({ dir: join(root, name), skill: plan.skill ?? 'resolve-issues', revision: plan.planRevision ?? null, open, mtime,
+      ...(plan.installation ? { installation: plan.installation } : {}) })
   }
   return runs.sort((a, b) => b.mtime - a.mtime).map(({ mtime, ...r }) => r)
 }
 
 export function message(runs, { skillPath = SKILL_PATH, rushSkillPath = RUSH_SKILL_PATH } = {}) {
   if (!runs.length) return ''
+  if (runs.some((run) => run.installation)) {
+    return runs.map((run) => {
+      if (!run.installation) return message([run], { skillPath, rushSkillPath })
+      try {
+        const names = ['resolve-issues', ...(run.skill === 'rush-issues' ? ['rush-issues'] : [])]
+        const resources = workerResources(run.installation, names.map((canonicalName) => ({ canonicalName })))
+        return message([{ ...run, installation: undefined }], { skillPath: resources[0].path,
+          rushSkillPath: resources.find((entry) => entry.canonicalName === 'rush-issues')?.path ?? rushSkillPath })
+          + `\nSelected installation: ${JSON.stringify(run.installation)}\nReuse this exact root and identity for worker resources; never select another cache or a shared copy.`
+      } catch (error) {
+        return `Recovery blocked for ${run.dir}: ${error.message}. Do not use another installation or emit shared-store repair commands.`
+      }
+    }).join('\n\n')
+  }
   const skills = [skillPath]
   if (runs.some((r) => r.skill === 'rush-issues') && existsSync(rushSkillPath)) skills.push(rushSkillPath)
   const nextActions = join(dirname(skillPath), 'scripts', 'next-actions.mjs')

package/skills/engineering/resolve-release/SKILL.md

@@ -4,7 +4,7 @@ description: "Slash/explicit-only (/resolve-release). Full GitHub Flow release f
 disable-model-invocation: true
 metadata:
   workflow-role: coordinator
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Resolve release

package/skills/engineering/resolve-release/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/rush-issues/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   workflow-role: coordinator
 dependencies:
   - resolve-issues
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Rush issues (shortcut of resolve-issues)
@@ -50,7 +50,10 @@ question.
      and complete the goal
      ([done.md](../resolve-issues/references/done.md#close-the-run)).
 3. Everything else — run rules, stages, scripts, review, CI and merge, and the
-   done criteria — applies exactly as `resolve-issues` states it.
+   done criteria — applies exactly as `resolve-issues` states it. In particular,
+   [Delivery progress](../resolve-issues/SKILL.md#delivery-progress) applies in shortcut
+   mode too: keep one immediate checkpoint per active unit, justify infrastructure and
+   reassess repeated non-convergence. More worker activity is not a reason to reset it.
    The shared [task-plan checkpoints](../resolve-issues/references/task-plan.md#checkpoints)
    apply too: on Pi, bind or reload through `update_plan` with the absolute
    workflow path and persisted revision (no event means read-only), then

package/skills/engineering/rush-issues/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/rush-release/SKILL.md

@@ -6,7 +6,7 @@ metadata:
   workflow-role: coordinator
 dependencies:
   - resolve-release
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Rush release (shortcut of resolve-release)

package/skills/engineering/rush-release/release-check.mjs

@@ -2,7 +2,7 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -46,6 +46,8 @@ function writeCache(path, value) {
 
 function main(now = Date.now()) {
   if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const bundle = readJson(join(resolve(here, '../../..'), 'package.json'));
+  if (bundle.name === '@1aboveio/skills' && bundle.nativeCodex?.schemaVersion === 1) return;
   const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
   const name = frontmatterValue(skill, 'name');
   const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));

package/skills/engineering/test-quality/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: test-quality
 description: "Seven principles for tests that catch real bugs, and an audit that reports weak, redundant, and not-coverage tests without fixing them. Use when writing, changing, or reviewing tests, or when asked whether tests are useful, redundant, over-mocked, flaky, only assert static text, or test config files, or asked to make a slow test suite faster without losing coverage, or when the user asks to write the testing conventions into a repo's CONTRIBUTING.md. NOT defining what a spec must prove (ensure-coverage) or authoring browser tests (e2e-test)."
-release-version: 0.43.0
+release-version: 0.44.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Test Quality