axstack 0.14.2 → 0.16.0

package/README.md

@@ -12,9 +12,9 @@ role choices, evidence, review policy, and one private derived run record.
 
 ## How a run works
 
-Invoke `axstack` or the needed phase directly: `axstack-align`,
-`axstack-spec`, `axstack-tickets`, `axstack-implement`, `axstack-review`, and
-`axstack-watch`. Direct `axstack-research`, `axstack-explain`,
+Invoke the needed phase directly: `axstack-align`, `axstack-spec`,
+`axstack-tickets`, `axstack-implement`, `axstack-review`, and `axstack-watch`.
+Direct `axstack-research`, `axstack-explain`,
 `axstack-improve`, and `axstack-debug` routes need no spec ceremony. `axstack-relay` remains an
 optional inline route for explicit messages and authorized notifications; an
 unavailable or legacy-runtime-only relay falls back to the current conversation
@@ -68,8 +68,8 @@ See [installation details](docs/installation.md).
 
 `--instructions` manages one versioned Axstack block in `AGENTS.md`,
 `CLAUDE.md`, or `GEMINI.md`. Harness defaults resolve those files automatically. The block
-points at the installed entry skill and requires every subagent, delegated worker,
-reviewer, and cross-harness dispatch to use visible Orca orchestration via the `orca` CLI
+requires direct matching phase-skill invocation and requires every subagent, delegated
+worker, reviewer, and cross-harness dispatch to use visible Orca orchestration via the `orca` CLI
 rather than a harness-native subagent tool (e.g. Claude/Codex native subagents). OpenCode
 and Antigravity subagents run as Orca-supervised workers. Text and file
 mode outside the markers are preserved; edited, malformed, unowned, or unsafe

package/docs/installation.md

@@ -147,7 +147,7 @@ to rewrite them.
 
 ## Role behavior after installation
 
-The runtime reads `roles.json` relative to the actually loaded `axstack` skill.
+The runtime reads `roles.json` from the installed shared root `skills/axstack/`.
 A new run records the selected preset plus all 23 role rows. An active run keeps
 that snapshot after a later preset install unless the user explicitly changes
 it and accepts the resulting evidence invalidation.

package/docs/workflows.md

@@ -10,9 +10,9 @@ Axstack implements that skill's specialist capability.
 
 ## Routing and scope identity
 
-`axstack` classifies the request and loads only the applicable phase plus shared
-references for routing, lifecycle, Orca runtime boundaries, role/model/risk
-contracts, the run record, and PR shape.
+The directly invoked phase loads the applicable shared references for routing,
+lifecycle, Orca runtime boundaries, role/model/risk contracts, the run record,
+and PR shape.
 
 Direct routes need no spec ceremony:
 
@@ -53,7 +53,7 @@ role.
 
 The installed `<skills-dir>/axstack/roles.json` adds the selected preset name:
 `{ "version": 1, "preset": "<name>", "roles": [...] }`. The runtime reads it
-relative to the actually loaded `axstack` skill and records the whole table for
+from the installed shared root `skills/axstack/` and records the whole table for
 a new run. Active runs retain their snapshot after later installation changes.
 
 Peer roles keep the stable IDs `axstack-reviewer-primary` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axstack",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "description": "Axstack installer and setup CLI: installs owned chat skills and role data, configures supported harness settings, and checks Orca capabilities.",
   "keywords": [
     "claude-code",

package/skills/axstack/references/automations.md

@@ -2,7 +2,7 @@
 
 Read this when the current session is the native Orca PR **driver** or its
 **watchdog**. The approved contract is
-`docs/specs/pr-automations.md` revision 5; this reference restates the parts an
+`docs/specs/pr-automations.md` revision 6; this reference restates the parts an
 automation session must execute and does not widen them.
 
 Pair A/B is retired for this contract; its artefacts remain untouched.
@@ -11,7 +11,7 @@ Pair A/B is retired for this contract; its artefacts remain untouched.
 
 - **driver** — every 15 minutes, fresh Opus session in the host's `root`
   folder workspace, which is not a git repository and belongs to no project. It discovers GitHub work, binds the persistent Orca
-  Run, checks each selected PR's head out into a free project-local slot, dispatches the
+  Run, creates one worktree per selected PR and checks its head out there, dispatches the
   matching Axstack agent, reconciles completions and decisions, then exits. The
   driver is the automation session itself, with no `axstack-monitor` or
   `axstack-owner` role row. It never performs review or repair in its own
@@ -97,7 +97,7 @@ The driver performs this order and exits:
    inbox. For a `worker_done` matching a live marker, verify the review id at
    the bound head, push range, or opened token. Release the worker; once its
    release receipt is settled and the process has exited, run the cleanup
-   under "Run directory" below, which proves the slot disposable before
+   under "Run directory" below, which proves the worktree disposable before
    resetting it; then clear the marker. Unverifiable delivery stays in
    `pending_settlement[]` and blocks only that PR.
 3. Consume decisions as their sole consumer under "Decision tokens" below.
@@ -126,34 +126,38 @@ The driver performs this order and exits:
 
 Claude Code trusts a folder per git toplevel and stops at its "Quick safety
 check" dialog otherwise, and the driver never answers that dialog for a
-worker. So workers run in a fixed pool: every allowlisted project has
-exactly five slot worktrees, `slot-1` through `slot-5`, its Orca child
-worktrees created once, parented to the project's primary worktree, and trusted once
-by the user through that dialog. The driver never creates or removes a
-worktree and never writes `~/.claude.json`. A slot is free when no live
-dispatch marker names it, it is not in `retained_slots[]`, no terminal is
-listed in it, and its tree is clean; no free slot in the project defers the
-PR to `deferred[]` like a budget, not a hold. Taking a slot fetches the head into the project clone,
-checks the slot out detached at the pinned head, and verifies HEAD equals
-it; the marker's worktree is the slot path. The worker is launched by Orca
-itself — `worker-start --agent claude --model claude-opus-5 --effort medium`
-on that slot — so the runtime owns the process: `worker-release` ends it and
-`worker-show` proves it exited, which is what returns the slot to the pool.
-Never pre-create the worker's terminal or hand a terminal handle to
+worker. Trust inherits from the project's primary clone, which the user
+trusted once (a fresh child worktree launched with no dialog — canary
+2026-09-18). There is no fixed pool: fetch the head into the project clone first (a
+failed fetch is a health line and no dispatch; no worktree exists yet), then
+create one Orca worktree per dispatch, `orca worktree create --repo id:<clone
+id> --name <repo short>-<num>-<head7> --base-branch <default branch>
+--parent-worktree id:<clone id>::<clone path> --setup skip` (a name collision
+with a retained worktree at the same head appends the tick's
+`tick_started_at` stamp); close the creation terminal Orca opens in it with
+`orca terminal close --worktree <selector> --all`; check the worktree out
+detached at the pinned head and verify HEAD equals it; the marker's worktree
+is that path. Never write
+`~/.claude.json`. The worker is launched by Orca itself — `worker-start
+--agent claude --model claude-opus-5 --effort medium` in that worktree — so
+the runtime owns the process: `worker-release` ends it and `worker-show`
+proves it exited, which is what allows the worktree to be removed. Never
+pre-create the worker's terminal or hand a terminal handle to
 `worker-start`: a reused handle is a resource Orca labels `external`, one it
-can neither stop nor prove exited, so every such slot ends retained. After
-`worker-start` run `worker-show` on the receipt's dispatch id and require
-`projection.resource.state == owned`; anything else is a launch Orca does not
-own: apply the runtime-refusal recovery rules under "Safety holds" (the
-`worker-list` row's `nextAction` argv verbatim; `none` means inspect and
-retain), append a `worker not owned` health line and a `retained_slots[]`
-entry for the slot, defer the PR, and record no marker. Orca's per-agent default arguments supply
-`--dangerously-skip-permissions`; the brief loads the skill files it needs by
-path. If `worker-start` reports a failed stage or a visible hold (the "Quick
-safety check" trust dialog) the slot is not trusted: name the slot in a health
-line, defer the PR, dispatch nothing, never answer the dialog. Project
-customizations load as they would for the user; the allowlist is defi-com
-only and the user accepted that surface on 2026-09-18.
+can neither stop nor prove exited, so every such worktree ends retained.
+After `worker-start` run `worker-show` on the receipt's dispatch id and
+require `projection.resource.state == owned`; anything else is a launch Orca
+does not own: apply the runtime-refusal recovery rules under "Safety holds"
+(the `worker-list` row's `nextAction` argv verbatim; `none` means inspect
+and retain), append a `worker not owned` health line and a `retained_slots[]`
+entry for the worktree, defer the PR, and record no marker. Orca's per-agent
+default arguments supply `--dangerously-skip-permissions`; the brief loads
+the skill files it needs by path. If `worker-start` reports a failed stage
+or a visible hold (the "Quick safety check" trust dialog) the worktree is not
+trusted: name it in a health line, defer the PR, dispatch nothing, never
+answer the dialog, and remove the worktree through the no-worker branch.
+Project customizations load as they would for the user; the allowlist is
+defi-com only and the user accepted that surface on 2026-09-18.
 
 Every selected PR receives one dispatch marker with task id, dispatch id,
 worktree, head, `started_at`, reservation (`verdict` or `repair`), and trigger:
@@ -175,16 +179,22 @@ An own PR needs repair when either trigger applies:
    digest not recorded for that PR and head. Both keys are required: the same
    finding under a new review id must not re-trigger repair. Record review id
    and body digest when dispatching. A superseded head with a new review
-   triggers again subject to the 24 h cap.
-
-Repair also requires no deploy-on-push head branch, no live repair cap, and
-selection of the lowest own PR in its stack that needs repair. Take a free
-slot of that project (its slots are parented to that project's primary
-worktree, so the work appears under the project it serves) at the exact
-head, and dispatch one `axstack-watch` agent in authored repair mode. Its
+   triggers again at the new head.
+
+Repair also requires no deploy-on-push head branch, a head not already in
+`repaired_heads[]`, and selection of the lowest own PR in its stack that
+needs repair. Create the
+dispatch worktree (parented to that project's primary worktree, so the work
+appears under the project it serves) at the exact head, and dispatch one
+`axstack-watch` agent in authored repair mode. Its
 brief contains only the triggering checks or review findings. Each open
 descendant records one user-owned `pending restack` hold until it stops needing
-repair. The 24 h cap starts at dispatch and an abandon does not refund it.
+repair. At dispatch record the head in `repaired_heads[]` (`pr`, `head`,
+`dispatched_at`): one repair per head, no time cap. A repair pushes a new
+head; a still-not-merge-ready new head shows a new failing check or review
+and is repaired again; a repair that pushes nothing is not retried at that
+head until a human or a new commit moves it. A confirmed abandon removes the
+record (retry once).
 
 A debounced peer PR is eligible when self has not reviewed its head. Read
 `gh pr view --json reviews` before dispatch. Whenever any self review with
@@ -196,14 +206,15 @@ human-placed block is never overwritten. A dismissed block and a self-approved
 PR are skipped. Dispatch one `axstack-review` agent in peer mode and link the
 prior review in its brief.
 
-Budgets are one `verdict` dispatch per tick, oldest first; at most six `repair`
-markers live across all repositories; and one repair per PR per 24 h. Put every
-eligible PR not dispatched because of a budget in `deferred[]` with repo, PR,
-and head. Budget exhaustion records the count and is not a hold.
+The only concurrency limit is the host-wide cap: at most eight live dispatch
+markers across all repositories and both reservations, oldest eligible
+first; plus one repair per head. Put every eligible PR not dispatched
+because the cap is reached in `deferred[]` with repo, PR, and head. Reaching
+the cap records the count and is not a hold.
 
 ## Agents and verdicts
 
-Every agent works in a project-local slot worktree checked out detached at
+Every agent works in its own project-local worktree checked out detached at
 the exact head and reports only through the Orca worker protocol.
 
 Peer review runs the two isolated configured reviewers on the identical brief,
@@ -343,12 +354,12 @@ is no gate for health findings.
 ## Run directory
 
 The driver and watchdog run from the host's `root` folder workspace, not a
-project worktree: no project owns the automation, and every slot worktree
-belongs to the project it serves. That workspace is not a git repository, so
+project worktree: no project owns the automation, and every dispatch
+worktree belongs to the project it serves. That workspace is not a git repository, so
 the run directory is private host state, one
 `~/.local/share/axstack/runs/<run id>/` directory. Settlement leaves nothing
 behind, but never destroys work. Before any destructive step the driver
-proves the slot is disposable: the worker is settled — on the release path
+proves the worktree is disposable: the worker is settled — on the release path
 a settled release receipt, on the abandon path an accepted abandon receipt,
 either with proven process exit; pending or unknown stops here — the
 worktree's HEAD is either the pinned head or a candidate that is durably
@@ -358,20 +369,21 @@ targeted fetch of that exact remote branch into a per-dispatch ref, never
 shared clone can fake durability, a failed fetch retaining the worktree — or held by a
 `refs/axstack/decisions/<token>` ref in the project clone; and, on the
 abandon path, the worktree has no uncommitted changes.
-Only then it closes any terminal tab still listed, resets the slot to the
-pinned head, clears untracked artefacts, and verifies the slot is clean, so
-it is back in the pool. On the settled path
-the worker has finished, so untracked files are artefacts by definition and
-are cleared; a candidate there is already pushed or token-held. A slot
-whose release is settled but whose HEAD cannot be proven disposable, and an
-abandoned slot that is dirty or holds an unproven candidate, are both
-**retained**: named in one `health[]` line with path and SHA, and blocking
-only that PR with the user as owner. Retention is mechanical on both paths:
-the driver appends `retained_slots[]` `{slot, pr, head, reason}`, which the
-free predicate excludes for every PR — a clean, terminal-less slot holding
-an unpushed candidate would otherwise look free — and an entry is cleared
-only by the user after reconciling the candidate. A dirty slot or a terminal that
-outlives its dispatch without such a retention record is a health finding. The run directory contains:
+Only then it closes any terminal tab still listed and removes the worktree
+with `orca worktree rm --worktree <selector> --force` (the proof is the
+gate; a finished worker's untracked artefacts are not), so the dispatch
+leaves nothing behind. On the settled path the worker has finished, so untracked
+files are artefacts by definition; a candidate there is already pushed or
+token-held. A worktree whose release is settled but whose HEAD cannot be
+proven disposable, and an abandoned worktree that is dirty or holds an
+unproven candidate, are both **retained** — retained in place: named in one `health[]`
+line with path and SHA, and blocking only that PR with the user as owner.
+Retention is mechanical on both paths: the driver appends `retained_slots[]`
+`{slot, pr, head, reason}` (`slot` is the worktree path); a retained worktree
+is never removed by the driver, and the entry is cleared only by the user
+after reconciling the candidate, who also removes the worktree. A leftover
+worktree or terminal that outlives its dispatch without such a retention
+record is a health finding. The run directory contains:
 
 - `cursor.json` — driver only, with these exact keys: `fingerprint`,
   `tick_started_at`, `tick_done_at`, `tick_outcome`, `prs{url: {head, base,
@@ -379,7 +391,10 @@ outlives its dispatch without such a retention record is a health finding. The r
   `task_id`, `dispatch_id`, `worktree`, `head`, `started_at`, `reservation`,
   `trigger`), `deferred[]`, `pending_settlement[]`,
   `retained_slots[]` (`slot`, `pr`, `head`, `reason`),
-  `repair_caps{url: {expires_at}}`, `abandon_count{head: n}`,
+  `repaired_heads[]` (`pr`, `head`, `dispatched_at`),
+  `repair_caps{url: {expires_at}}` (legacy: the first rev-6 tick clears it to
+  `{}` with one health line; never written again),
+  `abandon_count{head: n}`,
   `processed_reviews[]` (`review_id`, `pr`, `head`, `digest`),
   `deploy_on_push{repo: [branches]}`,
   `legacy_automation_reviews[]`, `health[]`,
@@ -420,12 +435,12 @@ delivery uses [axstack-relay](../../axstack-relay/SKILL.md).
   `runtime_refusal {code, first_seen, last_seen}`; the same code keeps the
   hold and updates `last_seen` without a new health line, a different code is
   a new finding. Prose is never the key. When `worker-start` itself is
-  refused after the slot was checked out, there is no worker, so the
+  refused after the worktree was created, there is no worker, so the
   settlement proof does not apply; the driver reads the receipt's `failedStage`
   and `residualResources` first. With no Dispatch and no residual resources
   the no-worker branch applies: the worktree's HEAD must equal the pinned
-  head and `git status --porcelain` must be empty, and then the slot is simply
-  free again in the same tick; there is nothing to remove.
+  head and `git status --porcelain` must be empty, and then the worktree is
+  simply removed in the same tick.
   With a Dispatch or any residual resource the failed start owns runtime
   state, and retaining alone is not recovery: the driver follows the
   runtime's recovery guide. With a Dispatch: `worker-list` for that run, and

package/skills/axstack/references/contracts.md

@@ -4,11 +4,11 @@ Apply these authority, scope, and model rules before consequential action.
 
 ## Required lifecycle load
 
-Except for `axstack-audit` itself, every independently called phase must load
-and follow [Shared lifecycle](lifecycle.md) before acting. When a substantive
-run ends or reaches a meaningful checkpoint, apply the lifecycle audit hook.
-The audit phase loads these contracts, writes its assigned record, and stops;
-it never audits itself.
+Except for `axstack-audit` and `axstack-relay`, every independently called phase
+must load and follow [Shared lifecycle](lifecycle.md) before acting. When a
+substantive run ends or reaches a meaningful checkpoint, apply the lifecycle
+audit hook. The audit phase loads these contracts, writes its assigned record,
+and stops; it never audits itself.
 
 ## Scope identity (conditional — see routing and lifecycle)
 

package/skills/axstack/references/lifecycle.md

@@ -1,25 +1,23 @@
 # Shared lifecycle and receipts
 
-Phases load through [Standing contracts](contracts.md)' mandatory edge.
-Substantive delegated or resumable work uses a driver-owned [Run record](run-record.md)
+Phases load through [Standing contracts](contracts.md).
+Delegated or resumable work uses a driver-owned [Run record](run-record.md)
 binding state and receipts to exact revisions.
 
 ## Roster (compact)
 
 - Driver: current chat; owns scope, decisions, cross-PR dependencies, Linear
   mutations, and integration.
-- Owner (`axstack-owner`): one persistent owner per PR; launches its author,
-  reviewers and watches; may perform authorized PR-scoped publication within user authority.
-  Human merge is default.
+- Owner: driver owns loop PRs; `axstack-owner` only for standalone watch/review
+  without live driver. It may perform PR-scoped publication within user authority. Human
+  merge is default.
 - Author: exactly one writer per candidate; accepted fixes return there.
   Workers launch no recursive teams.
 - Reviewers: peer = two independent `axstack-reviewer-primary` and
   `axstack-reviewer-secondary` sessions with identical brief and isolated first
   pass; authored = one eligible configured reviewer from actual author
   provenance. Owner and author never review.
-- Driver/monitor/watchdog: the driver every 15 minutes dispatches and exits as
-  a mutating owner; the watchdog is model-free and read-only, has no gate, and
-  records `watchdog.log`; there is no watch deadline for automations.
+- Automation driver/monitor/watchdog: see [Watch health](#watch-health).
 - Auditor (`axstack-auditor`): report-only; never edits, merges, activates, or
   audits itself.
 
@@ -78,10 +76,17 @@ Store concise receipt references, not raw worker output, in the [Run record](run
 ## Execution tracking
 
 The driver consumes native Orca completion and escalation deliveries for the
-active Run. Process each whole delivery before acknowledgment and validate its
-Task, Dispatch, sender, authority, revisions, and receipts before advancing the
-run record. Duplicate deliveries are deduplicated by runtime identity. Healthy
-unchanged observations produce no user-facing update.
+active Run. A driver turn does not end while a Dispatch is unsettled unless one
+completion wait from the orchestration guide is armed (background where the
+harness supports it, foreground otherwise) and re-armed on timeout; sleep or
+poll loops are forbidden. An explicitly invoked phase dispatches its configured
+roles through Orca and closes with the lifecycle close-out; in-chat execution
+covers only ordinary reading, writing, and local checks. Heartbeat deliveries
+are acknowledged with no user-facing text. Process each whole delivery before
+acknowledgment and validate its Task, Dispatch, sender, authority, revisions,
+and receipts before advancing the run record. Duplicate deliveries are
+deduplicated by runtime identity. Healthy unchanged observations produce no
+user-facing update.
 
 Detect completed-but-unadvanced work, failed sessions, unresolved launch
 receipts, and stalls through the version-matched orchestration guide. Never
@@ -98,7 +103,9 @@ Tracking grants no merge, release, model-substitution, or scope authority.
 
 The default 24-hour deadline covers standalone task-owned timers. Stop them at
 deadline and preserve remaining work; there is no watch deadline for
-automations. Merge-ready differs from merged; human merges.
+automations. A PR is merge-ready only with the applicable review receipt(s) at
+its exact head; green CI or tests alone never make it merge-ready. Merge-ready
+differs from merged; human merges.
 
 ## Watch health
 
@@ -110,24 +117,24 @@ no watch deadline for automations. Build no custom scheduler and use no legacy
 fallback. Details live in
 [Watch runtime](../../axstack-watch/references/watch-runtime.md).
 
-## Audit hook (end of run and meaningful checkpoints)
-
-Auditing defaults on for every substantive run at its end and meaningful
-checkpoints such as material deviation or repeated repair. Load the bundled [audit skill](../../axstack-audit/SKILL.md)
-and dispatch its auditor. An `axstack-audit` run is excluded: it writes its
-record and launches no children.
-
-The auditor reads the [Run record](run-record.md) for scope, outcomes, and
-metric counts/denominators; reports evidenced PASS/FAIL/UNKNOWN; and invents no
-numbers or cost. Proposals change nothing. Accepted proposals return as
-tested, independently reviewed work with a regression scenario and unchanged
-holdout checks. No automatic self-edit, merge, or activation. Records stay
-private; publication needs separate authority.
-
-## Idle-complete archive and retain
-
-After required PRs merge or hand off, timers stop, and receipts verify, mark
-the same [Run record](run-record.md) `Archived` in place. Preserve
-scope, revisions, evidence, receipts, and expiries. Archive only idle-complete
-records: never active/waiting workers, unrelated host state, or ownership merely
-because it is idle.
+## Audit hook (close-out and meaningful checkpoints)
+
+Audit measurement is enabled by default for every substantive run; dispatch
+follows [Close-out](#close-out) or a material-deviation/repeated-repair
+checkpoint. An `axstack-audit` run is excluded; it launches no children.
+Load [axstack-audit](../../axstack-audit/SKILL.md). Accepted proposals
+require a regression scenario and unchanged holdout checks; they change
+nothing without tested independent review.
+
+## Close-out
+
+After required PRs merge by forge state—not local branch ancestry—close out in
+order: (1) settle every worker terminal through the orchestration guide; (2)
+write a compact record with counts and denominators for
+user interventions, deviations from plan, and repairs; (3) dispatch
+`axstack-auditor` only when any count is non-zero or the user asks—an unavailable
+auditor leaves close-out pending, never skipped silently; (4)
+release merged run worktrees and branches and close Linear tickets
+(driver-owned); (5) mark the [Run record](run-record.md) `Archived`. The driver
+cannot report the run done before steps (1)-(5) have receipts. Small one-step
+lookups keep the run record's exemption.

package/skills/axstack/references/orca-runtime.md

@@ -22,7 +22,7 @@ daemon, scheduler, database, or escalation engine.
 
 ## Bind the configured role
 
-Read `roles.json` relative to the actually loaded `axstack` skill. The installed
+Read `roles.json` from the installed shared root `skills/axstack/`. The installed
 shape is `{ "version": 1, "preset": "<name>", "roles": [...] }`. Bundled
 profiles are setup inputs shaped as
 `{ "version": 1, "roles": [...] }`. A new run records the selected preset and

package/skills/axstack/references/routing.md

@@ -47,11 +47,12 @@ Role IDs:
   only gate-authorized health escalations.
 - `axstack-debug-investigator-1..4` each probe one L1 brief.
 
-Provenance is matched on provider/model ID; record effort but never use it to
-create a mapping. Provenance absent from the preset's table row is
-unsupported and `INCOMPLETE`; report the exact gap and ask the user. Never
-derive a reverse pairing from slot position, driver, owner, or provider.
-Author and owner never review their own work.
+Provenance is matched on provider/model ID; effort never maps. Missing table-row
+provenance is unsupported and `INCOMPLETE`; report it and ask the user. Never
+infer from slot, driver, owner, or provider. Author and owner never review.
+
+The `axstack-implement` loop requires `mixed`; single-provider presets hold at
+step (3) for user routing, with no substitution or same-provider review.
 
 ## Direct routes (no spec ceremony)
 
@@ -76,12 +77,11 @@ Author and owner never review their own work.
   handoff guide, and require explicit recipient acceptance before ownership
   changes. Missing capability is a setup gap; never invent one.
 - Colleague PR review -> `axstack-review`, peer mode.
-- Own PR maintenance or monitoring -> `axstack-review` in authored mode,
-  `axstack-watch` for adoption.
-
-Research, explanation, improvement discovery, debugging, handoff, peer review,
-and adopted maintenance need no alignment, spec, or ticket map; authority and
-intent boundaries still apply.
+- A status question about an own open PR or stack ("check now", "what's left",
+  "are we done", or "is it approved") -> `axstack-watch` in observation-only
+  mode. Explicit "address", "patch", or "fix" grants authorized maintenance.
+- Other own PR work -> `axstack-review` authored mode or `axstack-watch`
+  adoption.
 
 ## Proportional scope identity
 
@@ -126,5 +126,4 @@ not alone a formal spec trigger. Hold affected unsafe work while reassessing.
   author provenance — then use `axstack-review` and `axstack-watch` without
   repeated approval or new spec ceremony. Never infer the author from the
   orchestrator or assume an imported own PR's author.
-- Direct later phase: start there and pass that phase's identity check; entry
-  never admits work a deeper phase rejects.
+- Direct later phase: start there and pass that phase's identity check.

package/skills/axstack-align/SKILL.md

@@ -161,5 +161,5 @@ approval; record chosen document names and paths once per run.
    actual dispatch. Alignment completion never dispatches a recipient.
 
 Alignment stops for both sizes only when the handoff is usable, its next scope
-identity is explicit, and execution has not started. The user invokes `axstack`
-to execute.
+identity is explicit, and execution has not started. The user invokes
+`axstack-implement` to execute.

package/skills/axstack-implement/SKILL.md

@@ -5,11 +5,10 @@ description: When an approved task is ready to build or repair, use axstack-impl
 
 # Implement
 
-Deliver one reviewable candidate at an exact revision. Normal behavior changes
-have real red -> green -> refactor evidence; a narrowly accepted
-structure-preserving change has old-green characterization evidence. Name
-unverified boundaries and keep ownership unambiguous. Review and merge are
-later phases.
+From an accepted scope identity, drive its task/PR map through author -> review
+-> repair until every required PR is merge-ready or held. Keep exact revisions,
+strict TDD evidence, ownership, and unverified boundaries explicit. The human
+merges; the same run later reconciles those merges and closes out.
 
 ## 1. Admit the work
 
@@ -34,6 +33,9 @@ Independently confirm the applicable
   failure) returns to the author and does not increment the bug's fix ledger.
 - An adopted own-PR repair has its accepted maintenance snapshot.
 
+If substantial work lacks an approved spec or matching ticket map, report that
+exact gap, name `axstack-align` as the next route, and stop.
+
 Pin the exact base and current candidate revision. A missing, mismatched, or
 materially changed but unaccepted identity holds affected work; safe
 investigation may continue under the standing contracts. Proceed only with a
@@ -42,11 +44,9 @@ valid recorded identity and revisions; otherwise report the hold and exact gap.
 ## 2. Establish one owner and one writer
 
 For substantive delegated or resumable work, use the shared
-[run record](../axstack/references/run-record.md). On restart, reconcile it
-against actual Orca Tasks, Dispatches, sessions, Git revisions, GitHub state, the approved scope,
-Linear issue state, and watch registrations. Reuse the existing owner and
-author when valid. Ambiguous launch state is a hold on creating another writer,
-not evidence that the old writer disappeared.
+[run record](../axstack/references/run-record.md). Reconcile it on restart with
+the approved scope, Orca and forge state, exact revisions, tickets, and watches.
+Reuse valid owners and authors; ambiguity holds a replacement writer.
 
 At execution start, bind work to the driver-owned Orca Run and one authoritative
 Task/Dispatch attempt. Preserve the actual IDs and process completion deliveries
@@ -57,30 +57,22 @@ Immediately before an actual role dispatch, read and follow the
 [Orca runtime boundary](../axstack/references/orca-runtime.md). Ordinary local
 reading and writing does not require that launch reference.
 
-One persistent owner remains accountable for the PR, fixes, evidence, and
-monitoring. Exactly one author writes a candidate at a time; accepted review
-repairs return to that author when its evidence is still usable. When the owner
-delegates writing, the owner does not edit that candidate concurrently. An
-ownership transfer occurs only when explicitly requested; follow the shared
-lifecycle's native capability preflight for that transfer. An ordinary restart
-or resume reconciles the existing sessions and run record without creating a
-fresh recipient.
-
-There is no fixed active-PR count. Fanout is dependency- and capacity-driven
-within configured host resource and spending limits, while one host owns the
-run and one writer owns each candidate. The driver queues conflicting or
-dependent work and coordinates dependent PRs through `gh stack`. Routine shape,
-split, fanout, and exception choices are autonomous driver decisions within the
-approved spec; size alone never requires user approval. A dependent candidate
-starts from its reviewed parent. When a reviewed parent changes, hold reliance
-on stale child evidence and child merge readiness. Rebase the child onto the
-new parent revision, re-run affected checks, and remeasure shape against the new
-actual base. Re-record the shape and re-check its level-matching rationale; size
-growth alone is not an automatic hold. A green parent does not prove the
-combined stack, but the parent need not wait for an independently reviewed
-child. Dispatch only when ownership, worktree, dependency revisions, writer
-exclusivity, and configured capacity agree with live state. Escalation occurs
-only if a split exposes an existing shared-contract hold.
+One persistent owner remains accountable for each PR. Exactly one author writes
+it; accepted repairs return there while its evidence is usable, and the owner
+never edits concurrently. Only an explicit accepted transfer changes ownership;
+ordinary resume reconciles the same sessions and record.
+
+Fanout follows dependencies and capacity within configured limits. Queue
+conflicts and dependent work; use `gh stack`, starting each child from its
+reviewed parent. When the reviewed parent changes, hold reliance on
+stale child evidence and child merge readiness; rebase onto the new parent revision,
+re-run affected checks, and remeasure shape against it.
+Size growth alone is not an automatic hold.
+A parent need not wait for an
+independently reviewed child. Dispatch only when ownership, worktree, dependency
+revisions, writer exclusivity, and capacity agree with live state. Shape, split,
+fanout, and exceptions are autonomous driver decisions within the approved scope.
+Size alone never requires user approval.
 
 ## 3. Establish test-first evidence
 
@@ -95,11 +87,6 @@ restating source text or mirroring the intended implementation. Execute the
 check before changing production behavior and capture the expected behavioral
 failure. A missing-module error or unrelated setup failure is not red.
 
-For example, retry the same payment ID and observe one charge through the
-public interface. Counting internal helper calls alone would not prove that
-behavior. This illustrates the boundary test; it does not require a payment
-scenario in unrelated work.
-
 If no meaningful test-first check can be established, report why and hold
 dependent implementation for a scoped decision. Historical tests added after
 code remain noncompliant; they never become retroactive TDD evidence.
@@ -142,7 +129,7 @@ evidence when relevant. Name every unavailable OS, harness, credential, or
 other boundary instead of implying coverage.
 
 After the last change, pin the exact candidate revision and return this compact
-implementation receipt to the owner or driver:
+implementation receipt to the driver:
 
 ```text
 Record: <progress.md path or tiny-task brief>
@@ -158,7 +145,55 @@ Next: <owner reconciles receipt, uses gh stack to push exact revision, confirms
 remote readback, then routes it to axstack-review>
 ```
 
-The author stops at that receipt and does not push. The owner follows the
-candidate-publication boundary without editing the candidate, and review starts
-only after remote readback confirms the exact revision. This grants no merge
-authority; the human merges by default.
+The author stops at that receipt and does not push. The driver reconciles it,
+uses `gh stack` to publish, confirms remote readback, and continues the loop
+without editing the candidate. No step grants merge authority.
+
+## 6. Loop until merge-ready
+
+Inputs are one snapshotted small-change intent or an approved spec and ticket
+map. The unit is that accepted task/PR map: run independent PRs in parallel
+within the fanout rule; run a dependent `gh stack` bottom-up, each child from
+its reviewed parent. The driver is owner, sole record writer, dispatcher,
+publisher, and wait-holder for every loop PR it creates. Resume preserves an
+existing live owner absent an accepted transfer.
+
+For each PR:
+
+1. Dispatch `axstack-author` under §§3-5 and consume its strict-TDD receipt.
+2. Publish through candidate-publication and read back the exact SHA.
+3. Dispatch and consume the authored-mode `axstack-review` selected from actual
+   author provenance.
+4. Route the verdict. `APPROVE` at that head plus `axstack-watch` §5's full
+   predicate—required checks, all feedback, approvals, mergeability, and
+   exact-revision receipts—records `merge-ready`. With required checks pending,
+   use the forge-native blocking check wait, bounded and used once per revision, then
+   re-evaluate. Timeout, error, or missing wait capability records `held` at
+   that revision with reason and resume condition; it never triggers author
+   repair. Notify “checks pending, resume when green”, not “decision needed”.
+   `REQUEST_CHANGES`, a failed required check, or post-readiness feedback returns
+   findings to the same author for a new revision, increments `repairs`, and
+   returns to step 1. `INCOMPLETE`, a provenance gap, unavailable model, serious
+   risk, or the third `REQUEST_CHANGES` on one PR records `held`. A changed
+   parent sends its child back to step 1.
+
+One run-level completion wait covers every unsettled Dispatch; the bounded
+forge check wait is the only other wait. End a turn only when every required PR
+is `merge-ready` or `held`, after notification (b) or (a). Raise serious risk
+(c) immediately when found. Notifications use `axstack-relay` under the recorded
+Notification policy: (a) a user-decision hold, (b) the merge-ready set and the
+all-merged event—two per run—and (c) serious risk; never progress.
+
+Merge-ready is the human boundary: the user merges, bottom-up for a stack. The
+driver resumes on the user's next message or `/axstack-watch`; no Orca merge
+wake exists today. Re-read forge state: record forge-merged PRs as `merged`;
+changed heads or feedback return to step 1; release nothing before Close-out.
+Run Close-out once only after every required PR is forge-merged and acceptance
+passes. It settles workers, records counts, makes the auditor decision and
+settlement, releases worktrees, closes eligible tickets, and archives the run.
+
+The loop requires the `mixed` two-provider authored-review row. `codex-only` or
+`claude-only` holds at step (3) for an explicit user routing choice, with no
+substitution or same-provider review. Derived PR states are `authoring |
+published | in-review | repairing(n) | merge-ready | merged | held`. The run is
+done only when every required PR is forge-merged and Close-out has receipts.

package/skills/axstack-watch/SKILL.md

@@ -69,7 +69,8 @@ model-free and read-only, has no gate, and records `watchdog.log`; there is no
 watch deadline for automations. The driver is the automation session itself,
 with no `axstack-monitor` or `axstack-owner` role row; `axstack-monitor` stays
 an optional read-only observer that never sends. One read-only PR observation
-needs neither.
+needs neither. The publishing driver is the live owner for a status check;
+materialize no `axstack-owner` and start no automation for a read-only check.
 
 For standalone adoption, materialize `axstack-owner` only when no live owner
 exists. Once it exists, the current chat is not a competing coordinator. Only
@@ -157,3 +158,6 @@ Resume: <known commands or verified refs needed to reconcile from this revision>
 
 The watch ends only when registrations are stopped, receipts are recorded, and
 the PR is either merged or represented by this resumable state.
+When every required PR is merged, follow the lifecycle
+[Close-out](../axstack/references/lifecycle.md#close-out) before reporting the
+run as done.

package/src/installer.js

@@ -247,12 +247,14 @@ export async function validateBundle(bundleDir, selectedPreset = null) {
 
   const files = [];
   for (const dir of skillDirs) {
-    const skillMark = join(skillsRoot, dir.name, 'SKILL.md');
-    try {
-      const s = await stat(skillMark);
-      if (!s.isFile()) throw new Error();
-    } catch {
-      throw new Error(`skill ${dir.name} is missing SKILL.md`);
+    if (dir.name !== 'axstack') {
+      const skillMark = join(skillsRoot, dir.name, 'SKILL.md');
+      try {
+        const s = await stat(skillMark);
+        if (!s.isFile()) throw new Error();
+      } catch {
+        throw new Error(`skill ${dir.name} is missing SKILL.md`);
+      }
     }
     await walkSkills(join(skillsRoot, dir.name), skillsRoot, files);
   }
@@ -508,7 +510,7 @@ export async function installBundle({
     }
     instructionPlan = planInstruction({
       text: existingInstructionsRaw,
-      block: renderInstructionBlock(skillsRoot),
+      block: renderInstructionBlock(),
       ownership: boundInstructions.path === instructionsFile ? boundInstructions : null,
       force,
     });

package/src/instructions.js

@@ -1,14 +1,14 @@
 // Pure planning and byte-preserving edits for the Axstack-owned routing block.
 import { hashContent } from './manifest.js';
-import { join } from './posixpath.js';
 
 const BEGIN = '<!-- axstack:begin v1 -->';
 const END = '<!-- axstack:end -->';
 
-export function renderInstructionBlock(skillsDir) {
+export function renderInstructionBlock() {
   return [
     BEGIN,
-    `Use Axstack for engineering work. Load \`${join(skillsDir, 'axstack', 'SKILL.md')}\` to route the request.`,
+    'Use Axstack for engineering work: invoke the matching `axstack-*` skill directly.',
+    '`axstack-implement` loops author -> review -> repair until every PR is merge-ready.',
     'Route every subagent, delegated worker, reviewer, and cross-harness dispatch through Orca orchestration via the `orca` CLI and its `orca-cli` / `orchestration` skills so the work stays visible.',
     'Do not use a harness native subagent tool for delegated work.',
     END,

package/skills/axstack/SKILL.md

@@ -1,81 +0,0 @@
----
-name: axstack
-description: When routing an engineering run through Axstack, use axstack to select the applicable phase and scope identity.
----
-
-# Axstack entry
-
-Route the current request to one Axstack phase with the right scope identity.
-The current chat remains the driver; Orca owns runtime orchestration.
-
-For an explicit relay message or transport test, use
-[axstack-relay](../axstack-relay/SKILL.md) directly. No engineering scope
-identity or decision workflow is needed for that send. The same skill handles
-urgent or blocking notifications under an explicit standing instruction.
-
-## Route the request
-
-1. Classify the request with [Shared routing](references/routing.md). Direct
-   research, explanation, improvement discovery, peer-review, adopted-watch,
-   and handoff routes need no spec
-   ceremony. Only an explicit user-requested ownership transfer can use the
-   capability-gated native route in
-   [Lifecycle and receipts](references/lifecycle.md#native-handoff-and-resume),
-   not an Axstack handoff phase. Preparation completion, watch expiry, and
-   ordinary resume update or reconcile the run record without launching it.
-2. For new engineering work, validate scope identity before invoking any phase.
-   Record `small`, `substantial`, or `unclear` plus a brief reason, then apply the
-   [proportional scope identity](references/routing.md#proportional-scope-identity).
-   A small clear change proceeds from its snapshotted small-change intent.
-   Substantial work proceeds only from an approved spec and matching ticket
-   map. Clarify unclear size before dispatch.
-3. Only after validation passes, invoke exactly the selected phase. A directly
-   invoked later phase starts there and must pass its own identity check. When
-   substantial work lacks an approved spec or matching ticket map, return that
-   exact gap, name `axstack-align` as the next route, and stop the current
-   invocation; do not invoke align, spec, or tickets. Apply the same stop to a
-   mismatched or invalidated identity. Never admit work that a deeper phase
-   would reject.
-
-The route is settled when one applicable phase is named with its valid scope
-identity, or the exact preparation/setup gap is reported with affected work
-held.
-
-## Load at the action boundary
-
-- Every independently called phase loads [Standing contracts](references/contracts.md),
-  which requires lifecycle and audit loading before action.
-- Before an actual Axstack role dispatch, delivery, settlement, or handoff, load
-  [Orca runtime](references/orca-runtime.md). Ordinary reading, writing, and
-  local checks do not require launch discovery.
-- Substantive delegated or resumable work uses the
-  [Local run record](references/run-record.md).
-- When the current session is an Orca PR automation (driver or watchdog), load
-  [Automation sessions](references/automations.md) before any discovery,
-  review, gate, or mutation.
-- When review escalation or watch notification is eligible and the brief has a
-  `Notification policy`, use the optional
-  [axstack-relay](../axstack-relay/SKILL.md); otherwise keep notification in
-  the current Orca conversation.
-
-## Lifecycle
-
-This is a phase map, not an automatic dispatch sequence.
-
-1. `axstack-align` settles substantial scope and decisions.
-2. `axstack-spec` creates the single user-approved execution baseline.
-3. `axstack-tickets` maps capabilities, tasks, and dependencies, then
-   preparation stops with a resumable handoff.
-4. `axstack-implement` produces owned candidates with strict TDD.
-5. `axstack-review` gives peer PRs the two configured independent same-brief
-   reviewer roles; authored PRs get one complete eligible non-author/non-owner
-   review based on actual author provenance and the routing snapshot.
-6. `axstack-watch` monitors within the shared deadline and hands off remaining
-   work.
-7. The human merges by default, bottom-up for a stack. Review approval never
-   grants merge authority.
-
-Autonomous progress, model holds, serious-risk handling, mutation authority,
-and the one-host ownership contract live in
-[Standing contracts](references/contracts.md). Load only the selected phase
-and the references its action requires.