axstack 0.9.0

package/skills/axstack-audit/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: axstack-audit
+description: When a substantive run needs evidence review, use axstack-audit to measure outcomes and propose bounded improvements.
+---
+
+# Audit
+
+Produce one evidence-bound audit record for the assigned substantive run or
+checkpoint. Separate what the run achieved, how it followed the workflow, and
+how completely the evidence supports either judgment. Improvement proposals
+are bounded follow-up candidates; this audit changes nothing itself.
+
+## 1. Establish the audit boundary
+
+Load [Standing contracts](../axstack/references/contracts.md) before inspecting
+the run, apply [PR shape](../axstack/references/pr-shape.md), then use the
+[audit record schema](references/record.md). Keep the
+shared load edge explicit: Standing contracts require
+[Shared lifecycle](../axstack/references/lifecycle.md) for independently called
+substantive phases, and lifecycle's audit hook loads this skill. This audit is
+the terminal exception: it writes its assigned record and does not audit itself.
+
+The dispatching driver reads [Orca runtime](../axstack/references/orca-runtime.md)
+immediately before an actual auditor profile or session dispatch. Ordinary
+audit reading and record writing do not load it, and the auditor never
+dispatches.
+
+Core owns the `axstack-auditor` profile (codex/gpt-5.6-luna max) and its
+invocation. This skill governs what that auditor reads, measures, and proposes.
+The user-chosen improvement mode is a tested, independently reviewed PR that a
+human merges.
+
+Act as a non-author, read-only reader of the run. The assigned audit artifact is
+the only writable output. Make no edits to product, skills, or config, and
+launch no child sessions.
+
+Proceed only when the record path, audit mode (`end-of-run` or `checkpoint`),
+accepted scope, and read-only authority are explicit. Record any gap without
+expanding authority to fill it.
+
+## 2. Build the evidence set
+
+Use actual records, never memory:
+
+- the approved spec, or the accepted peer, research, or maintenance scope;
+- the decision log and configured `axstack-advisor-astra` and
+  `axstack-advisor-fable` receipts;
+- exact git revisions;
+- test and review evidence; and
+- the run execution record at its recorded `progress.md` path.
+
+Auditing is enabled for every substantive run by default. A material deviation
+or repeated repair pattern can justify a checkpoint. Reuse still-valid prior
+audit evidence rather than repeating a whole-run rescan. A routine small lookup
+may end with a compact audit record; never force research through the full
+implementation pipeline. Cadence uses the core-owned invocation and creates no
+extra daemon, timer, or analytics service.
+
+The evidence set is ready when every claimed input has a source and revision
+where applicable, and every missing input is named as missing.
+
+## 3. Measure with denominators
+
+Follow the [audit record schema](references/record.md). Every metric carries
+counts with denominators plus the evidence behind the count:
+
+- Acceptance criteria passed, failed, and unverified, each traced to its tests plus SHA.
+- Planned steps completed and deviated, each deviation with why and approval.
+- Configured adviser coverage across Align, Spec creation, Spec revision,
+  solution design, and unresolved consequential decisions, including
+  independent same-question receipts, disagreement synthesis, and both plain AGREE receipts where high-stakes.
+- Debug evidence where `axstack-debug` ran: rung reached, loop command, fix
+  attempts with why each failed, adviser and investigator receipts, and
+  isolation evidence (pinned worktree, preserved probe artifacts).
+- Applicable test-first evidence: normal behavior changes have real red-green
+  proof; explicitly accepted structure-preserving work has the old revision
+  green before edits and the same checks green on the new revision, plus
+  applicable equivalence evidence. Record noncompliance when the applicable
+  evidence path is absent, or `UNKNOWN` with the reason when its records are
+  unavailable.
+- Independent exact-revision review status and unresolved findings.
+- Rework cycles with causes.
+- Avoidable user interventions where records support the call, and no call where they do not.
+- Parallelizable tasks identified versus dispatched, judged with dependency and writer isolation.
+- PRs within band / total PRs using the actual denominator. Apply the level
+  matching the measured total. For the rationale band, record cohesion
+  rationale presence; for the exception band, record the full driver exception
+  record. Record `UNKNOWN` when a receipt lacks the measurement.
+  This is evidence, not a score to game. Audit treats routine shape choices as
+  autonomous driver decisions; size alone never requires user approval.
+- Actual model, tool, time, token, and cost figures when provider receipts are available, unknown otherwise.
+
+Record `UNKNOWN` where evidence is absent. Never count missing evidence as a
+pass or collapse gaps into a vanity score. Prefer parallelism for genuinely
+independent decomposable work, while respecting dependencies and writer
+isolation; never game the measure by spawning needless agents.
+
+Accept the tally only when every count reconciles with its denominator, every
+item traces to evidence or an explicit unknown, and no inferred provider
+figures or retroactive TDD proof remain.
+
+## 4. State three judgments
+
+State execution outcome, procedural adherence, and measurement coverage as
+three separate judgments. Qualify causality and compare only compatible runs:
+report what the evidence supports, not what it merely suggests.
+
+Keep the judgments independent: evidence that changes one must not implicitly
+change either of the other two.
+
+## 5. Propose only bounded improvements
+
+Each proposal names:
+
+1. the observed failure or inefficiency;
+2. the hypothesized root cause, with evidence and counterevidence;
+3. one bounded hypothesized skill change;
+4. a regression scenario first, followed by an unchanged holdout evaluation;
+5. a cost and quality comparison when those values were measured; and
+6. the authorized delivery path: the auditor suggests, the driver arranges an
+   author and independent review, a reviewed PR is proposed, and a human merges.
+
+Keep evaluation data, candidate changes, and validation separate. This is an
+original Axstack workflow with no outside dependency or extra framework to
+install.
+
+Omit any proposal that is not testable, does not preserve unchanged
+expectations, or would grant the auditor implementation or activation
+authority.
+
+## 6. Write the record and stop
+
+Write the assigned artifact in the schema's field order. Preserve the accepted
+criteria and metrics after failures. Keep raw traces and run artifacts local
+and private by default; only an authorized sanitized summary may leave the run.
+Perform no self-edit, hidden per-user memory mutation, automatic merge, or
+activation. Stop after the record is complete.

package/skills/axstack-audit/references/record.md

@@ -0,0 +1,28 @@
+# Audit record schema
+
+Write one record per audited run or checkpoint in the field order below. Every
+count includes its denominator and evidence reference. Use `UNKNOWN` with the
+reason when evidence is missing; missing evidence is never a pass.
+
+```text
+Run: <run identity + scope/authority + audit mode (end-of-run | checkpoint)>
+Baseline: <approved spec rev | peer mode | research mode | maintenance scope>
+Acceptance: <passed / failed / unverified + test + SHA traces>
+Steps: <completed / deviated + why + approval per deviation>
+Advisers: <Astra/Fable coverage + same-question receipts + high-stakes AGREE status>
+Debug: <rung reached + loop command + fix attempts + adviser and investigator receipts + isolation evidence | n/a>
+TDD: <applicable evidence path: normal real red-green | accepted structure-preserving old revision green before edits + same checks new revision green; absent proof: noncompliance | unavailable records: UNKNOWN with reason>
+Review: <exact-rev independent review status + unresolved findings>
+Rework: <cycles + causes>
+Interventions: <avoidable user interventions, or unsupported by records>
+Parallelism: <identified vs dispatched + dependency/writer isolation>
+Shape: <PRs within band / total PRs + rationale-band cohesion rationale + exception-band full driver exception record; missing measurement: UNKNOWN>
+Cost: <model/tool/time/token/cost figures, or unknown otherwise>
+Judgment: <execution outcome vs procedural adherence vs measurement coverage>
+Proposals: <bounded hypothesized changes with regression-first plan, or none>
+Privacy: <local/private default; sanitized summary only when authorized>
+```
+
+The record is complete when its counts reconcile, its judgments remain
+separate, every proposal has a regression-first validation path, and all
+unknowns and evidence limitations are explicit.

package/skills/axstack-debug/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: axstack-debug
+description: When a bug, failing test, regression, or wrong behavior needs a root cause and a red loop is wanted, use axstack-debug to diagnose, escalate through adviser-directed investigators, and hand off a classified repair.
+---
+
+# Debug
+
+Produce a diagnosis record with a red-capable loop, a confirmed root cause or
+an honest UNKNOWN, and a classified hand-off. This skill never lands, commits,
+pushes, or publishes a product change; the repair goes to `axstack-implement`.
+`axstack-explain` answers how a system works; use this skill when something is
+wrong and a red loop is wanted.
+
+Before starting, load [Standing contracts](../axstack/references/contracts.md)
+and the lifecycle it requires. Shapes for the evidence packet, investigator
+brief, receipt, and diagnosis record are in [packet.md](references/packet.md);
+read it before phase 7 and before any fan-out.
+
+Redact secrets before showing any command, output, or artifact; build loops
+against environment variables so credentials never appear in what is shown.
+
+## Phases
+
+Each phase has an observable completion criterion. Skip one only with a
+recorded reason.
+
+1. **Loop.** Produce one agent-runnable command that goes red on the user's
+   exact symptom and is fast and deterministic. Prefer, in order: a failing
+   test at the nearest seam, an HTTP or CLI invocation diffed against a
+   known-good output, a headless browser script, a replayed captured trace, a
+   throwaway harness, a property loop, a bisection harness, a differential run.
+   For a flaky bug pin the sample count, observed failures, duration, seed and
+   environment, and the comparison criterion; a bare "high reproduction rate"
+   cannot support a later green claim. Narrow code reading needed to find the
+   entry point is allowed; forming a theory before the loop exists is not. If a
+   loop cannot be built, stop, list what was tried, and ask the user for an
+   environment, a redacted artifact, or instrumentation permission. Done when
+   the command has run once and its red output is recorded.
+2. **Reproduce and minimise.** Confirm the loop reproduces the user's failure
+   and not a neighbour. Remove inputs, callers, config, data, and steps one at
+   a time within a stated budget until the repro is the smallest practical;
+   keep the original loop as well. Done when each remaining element is
+   load-bearing or the budget is spent and recorded.
+3. **State and recent change.** Before reading code, inspect persistent
+   state, environment drift, caches, locks, config, and `git diff` and
+   `git log` since the last known-good revision. Record findings or none.
+4. **Hypothesise.** Rank the falsifiable hypotheses the evidence supports,
+   each with the prediction it makes. One strongly supported hypothesis is
+   enough; never invent alternatives to reach a quota. Show the ranking to the
+   user and proceed without blocking. If the user re-ranks mid-wave, finish
+   the wave and re-rank before the next.
+5. **Probe.** One probe per prediction, one variable at a time, every debug
+   log tagged with a unique prefix so cleanup is a single search. Use a
+   debugger or REPL before logs where available and bisection where history
+   exists. For a performance regression measure a baseline before any change.
+   A failed probe is not a failed fix.
+6. **Root cause and seam.** Trace the bad value backward to its origin. Name
+   the regression-test seam, or record NONE as a finding. Sweep the codebase
+   for the same pattern elsewhere and list the sites.
+7. **Record and hand off.** Emit the diagnosis record, classify the repair,
+   remove tagged instrumentation and throwaway harnesses or list them for the
+   implementer, and preserve the loop and minimal repro. Done when the record
+   is complete and the hand-off names its class.
+
+Anti-patterns to name and refuse: bypass flags, retry loops that mask
+diagnosis (bounded repeated trials for flaky reproduction are not this),
+shotgun changes, guards without a why, symptom fixes, theory before the loop,
+and "one more attempt" after the ladder says escalate.
+
+## Fix attempts
+
+A **fix attempt** is one coherent repair, predicted by the diagnosis record to
+turn the loop green, evaluated by the driver against the original symptom loop
+and the minimised repro. A change that failed because of an implementation
+slip (wrong file, bad test, setup failure) returns to the author under the
+existing repair contract and does not count. A diagnostic probe never counts.
+The per-bug ledger (revision, hypothesis, loop result, regression result, new
+failures introduced) carries across this skill, `axstack-implement`, and
+resume; a new invocation imports known attempts instead of resetting. On
+resume, the driver re-verifies the packet hash against the current revision and
+dirty patch; if either differs, refresh the packet and re-run the loop red
+before any further probe or attempt.
+
+## Ladder
+
+| Rung | Trigger | Who | Output |
+| --- | --- | --- | --- |
+| L0 | entry | driver alone | phases 1–7; at most one fix attempt through `axstack-implement` |
+| L1 | the L0 fix attempt failed; or phases 1–3 complete plus at least one discriminating probe (or a recorded reason no safe probe exists) and no hypothesis ranks | the preset's configured advisers, independently, same evidence packet | ranked hypotheses and one investigator brief per hypothesis |
+| L1 fan-out | driver merges the adviser plans | `axstack-debug-investigator-1..4`, identical packet, distinct briefs, no cross-reading | one receipt per brief |
+| L2 | the L1 fix attempt failed (second failure overall); or each fix reveals a new symptom elsewhere | the configured advisers on architecture, then the user | wrong-architecture finding, bounded refactor proposal, or one bounded next diagnostic action; the user decides before any third attempt |
+
+L1 is inadmissible without a red loop. Ordinary diagnosis is not a high-stakes
+decision: in `mixed` both advisers are consulted and both receipts are
+required; a single-provider preset consults its one configured adviser and
+records the other as an intentional absence. Whenever a run exposes a
+high-stakes architecture choice, serious security, downtime, or data-loss
+risk, the standing high-stakes and serious-risk contracts override this rule,
+including the single-provider high-stakes hold. An adviser configured but
+unavailable at launch holds L1 and L2 without substitution; L0 continues.
+Reuse an adviser receipt while the packet is unchanged; a changed packet needs
+a fresh receipt.
+
+**Plan merge.** The driver de-duplicates the advisers' hypotheses, ranks the
+union with reasons recorded in the run record, drops hypotheses both advisers
+refute, assigns the top N to the N live investigators (briefs ≤ seats per
+wave), and records the remainder as untested (queued). A second wave on the same roles is allowed on changed
+evidence. If every probe is refuted or inconclusive, one bounded adviser replan
+on the new evidence, then hold for the user; never unbounded.
+
+**Fan-out floor and completion.** At least two configured investigators must
+start with verified identity, or the fan-out is held with no substitution; a
+single available seat may run safe fact work but does not satisfy L1. L1 is
+complete only when at least two usable independent investigator receipts exist
+and every decisive conclusion has sufficient evidence. Account for every
+planned hypothesis as confirmed, refuted, inconclusive, blocked (probe could
+not run), or untested; accounting is reporting, not investigation, and two
+peripheral receipts do not clear a missing decisive probe. If a seat drops
+mid-wave, keep completed receipts and hold only dependent conclusions. Held
+briefs may be run serially by the driver at L0 authority, recorded as
+driver-run; driver-run probes supplement the evidence but never replace the
+two independent receipts or clear the hold. Reconcile contradictory receipts
+by evidence or one discriminating rerun, never by vote.
+
+Immediately before an actual adviser or investigator dispatch, load and follow
+[Orca runtime](../axstack/references/orca-runtime.md).
+
+## Isolation
+
+Each investigator gets its own disposable worktree at the pinned revision plus
+the recorded dirty patch and packet artifacts, materialised and hash-verified
+there, and re-runs the original loop red (for a flaky loop, meeting the phase 1
+pinned sample criterion) before probing. It may edit that worktree for probes
+and never commits, pushes, publishes, or creates children. Before
+driver-verified cleanup, the exact probe diff or script, command and output,
+and the receipt are preserved as redacted receipt artifacts under the run
+directory (the driver remains the sole `progress.md` writer); only then is the
+worktree discarded. The loop must be hermetic (worktree-local). A worktree
+isolates files, not shared or live systems: if the loop touches shared state
+(database, port, cache, lock), parameterise it per investigator, or serialise
+the wave against an explicitly authorised resource with recorded reset and
+restore steps between probes; if neither is possible, hold that probe. Record
+the outcome on the diagnosis record's `Hermetic:` line (`yes`, or `shared:`
+plus the resource and the chosen handling). The bundle's mode convention stays; record requested and effective settings
+separately, and hold on an unsupported requested mode.
+
+## Hand-off
+
+Classify the repair in the diagnosis record. A confirmed bounded repair
+supplies the small-change intent to `axstack-implement`; a substantial repair
+takes the approved-spec and ticket route; an unresolved diagnosis stays
+investigation. NONE seam is an explicit TDD gap that needs a scoped decision,
+not permission to fix without a meaningful red. The implementer verifies
+against both the original loop and the minimised repro. Returning to a phase
+transfers no PR ownership and grants no new mutation authority. Record one
+lesson line when the bug changed your understanding; it authorises no memory
+or skill edits.

package/skills/axstack-debug/references/packet.md

@@ -0,0 +1,80 @@
+# Debug shapes
+
+Read before phase 7 and before any fan-out. Every artifact below is redacted.
+
+## Evidence packet
+
+One snapshot file under the run record, hashed, referenced by path from every
+brief. Fields:
+
+- user symptom verbatim
+- base and candidate SHA plus dirty-patch or artifact hashes
+- cwd, runtime, dependency and config prerequisites
+- redacted fixture, setup and reset steps
+- the loop command, its exact assertion, and its original output
+- minimised repro and what remains load-bearing
+- state and recent-change findings
+- every prior attempt with diff summary, hypothesis, and why it was judged
+  failed
+- hypotheses already refuted
+- allowed reads, commands, scratch location, and excluded systems
+- probe budget
+
+## Investigator brief
+
+One per hypothesis, added to the shared packet:
+
+- hypothesis ID and statement
+- prediction it makes
+- discriminating probe
+- falsification criterion
+- stop criterion ("confirmed means", "inconclusive means", budget)
+
+An investigator may report one credible alternative hypothesis without
+cross-reading another investigator's output.
+
+## Investigator receipt
+
+```text
+Investigator: <role ID + provider/model/effort receipt> worktree <path> rev <sha> dirty <hash | clean>
+Hypothesis: <ID>
+Loop before probe: <red output excerpt>
+Probe: <diff or script pointer> -> <command> -> <output pointer>
+Verdict: confirmed | refuted | inconclusive | blocked
+Evidence: <pointers>
+Alternative: <one hypothesis or none>
+Limitations: <what could not be checked and why>
+```
+
+## Diagnosis record
+
+```text
+Bug: <user symptom, verbatim, redacted>
+Revision: <candidate SHA> base <SHA> dirty <patch hash | clean>
+Loop: <one command> -> <red output excerpt>  Hermetic: <yes | shared: ...>
+Minimised repro: <what remains load-bearing>
+State/recent change: <findings or none>
+Hypotheses: <ranked; each confirmed/refuted/inconclusive/blocked/untested + evidence>
+Root cause: <origin of the bad value> | UNKNOWN + what was tried
+Seam: <regression test location> | NONE (finding)
+Pattern sweep: <other sites or none>
+Rung reached: <L0 | L1 | L2>  Fixes tried: <n: change, why judged failed>
+Adviser receipts: <ids or n/a>  Investigator receipts: <ids or n/a>
+Cleanup: <tagged prefixes removed | listed for implementer>
+Repair class: <bounded -> small-change intent | substantial -> spec route | unresolved -> investigation continues>
+Lesson: <one line or none>
+```
+
+## Repair classes
+
+- `bounded` — a confirmed root cause with a named seam and a repair the
+  record predicts will turn the loop green; supplies the small-change intent
+  for `axstack-implement`.
+- `substantial` — the repair crosses a material design, security, or
+  infrastructure boundary; takes the approved-spec and ticket route.
+- `unresolved` — root cause UNKNOWN or no decisive evidence; investigation
+  continues at the recorded rung.
+
+A NONE seam is an explicit TDD gap requiring a scoped decision, not permission
+to fix without a meaningful red. The implementer verifies the repair against
+both the original loop and the minimised repro.

package/skills/axstack-explain/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: axstack-explain
+description: When understanding a system, change, or implementation gap, use axstack-explain to show how it works and what exists, is missing, or remains unverified.
+---
+
+# Explain
+
+Explain a system, change, current behavior, intended behavior, or implementation
+gap from inspected evidence. This direct route needs no spec ceremony. Use
+project documentation as evidence where relevant. It supersedes `axstack-docs`; if a stale install
+exposes both skills, route the request here only.
+
+Before acting, load [Standing contracts](../axstack/references/contracts.md),
+then follow its required lifecycle and audit pointers. Explanation work has no
+scope baseline. Ordinary work in the current chat needs no launch preflight;
+load the [Orca runtime boundary](../axstack/references/orca-runtime.md) only
+immediately before an actual profile dispatch.
+
+## 1. Bound the question and evidence
+
+1. Identify the audience, question, requested format, theme, and publication
+   boundary.
+2. Record the inspected paths. Use an exact revision for Git sources; for a
+   non-versioned file, screenshot, or exported snippet, use a stable source
+   identity or content hash. Record any live target and observation method.
+   Record the history window when available; unavailable history is a named
+   limitation, never an invented window. Trace the relevant flow, boundaries,
+   dependencies, and actual behavior before comparing current versus intended
+   behavior.
+3. Mark material claims independently as **source implemented**, **tested**,
+   **live observed**, **planned/proposed**, or **unknown**. These dimensions can
+   coexist; none implies another.
+4. For every gap, cite its inspected scope and applicable revision, stable
+   source identity, or content hash. “Not found” never means app-wide missing
+   without app-wide evidence; anything outside the inspected scope is unknown.
+
+## 2. Choose proportional output
+
+1. For a simple request, answer concisely in the current chat. Use a compact
+   diagram when useful. This needs no mandatory agent or intermediate artifact.
+2. For a complex visual, use the configured `axstack-explainer` role to create
+   self-contained HTML, or use the requested artifact format. An explicit user
+   theme wins; otherwise use the dark default.
+3. Profile IDs are presets, not availability proof. Before dispatch, follow the
+   launch sequence and preserve the configured model, mode, and effort. Report
+   an unavailable route; never substitute a model.
+
+## 3. Verify and deliver
+
+1. Any HTML explanation requires the full [visual QA
+   checklist](references/visual-qa.md): actual desktop and mobile rendering,
+   interaction, accessibility, and reduced-motion checks where relevant.
+2. Use the configured independent `axstack-explainer-review` role when
+   warranted, bound to the exact artifact identity. Any byte change invalidates
+   that review and requires a fresh check. In `claude-only`, separate Sonnet
+   author xhigh and reviewer high sessions are allowed for explanations as
+   session independence only. This exception never permits same-model code
+   review or a cross-provider-independence claim.
+3. Report source, tests, rendered observations, independent review, and
+   publication as separate evidence. Name every missing or unavailable check.
+4. For a public artifact, remove private paths, identifiers, prompts,
+   credentials, messages, and internal records. Local creation does not grant
+   authority to publish.
+5. Deliver the smallest useful explanation. Explanation causes no automatic
+   design and no automatic implementation; route later change work separately
+   only when the user requests it.

package/skills/axstack-explain/references/visual-qa.md

@@ -0,0 +1,15 @@
+# Visual QA checklist
+
+Use this checklist for every HTML explanation and other visual artifacts where
+rendering matters.
+
+1. Identify the final artifact bytes and theme. The explicit user theme wins;
+   otherwise use the dark default.
+2. Render the final artifact at desktop and mobile widths. Record actual
+   observations for both, or name the missing layout check.
+3. Exercise relevant interactions, keyboard and screen-reader accessibility,
+   and reduced-motion behavior. Report each unavailable check honestly.
+4. Keep source correctness, tests, rendered behavior, independent review, and
+   publication evidence separate.
+5. Bind review to the exact artifact identity. Any byte change invalidates the
+   affected approval and requires fresh QA and review.

package/skills/axstack-implement/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: axstack-implement
+description: When an approved task is ready to build or repair, use axstack-implement for strict TDD and owned delivery.
+---
+
+# 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.
+
+## 1. Admit the work
+
+Before consequential work, load the standing contracts, follow their required
+edge into the lifecycle (including its audit hook), then apply shared routing:
+
+- [Standing contracts](../axstack/references/contracts.md)
+- [Lifecycle and receipts](../axstack/references/lifecycle.md)
+- [Shared routing](../axstack/references/routing.md)
+- [PR-shape policy](../axstack/references/pr-shape.md)
+- [Candidate publication](../axstack/references/candidate-publication.md)
+
+Independently confirm the applicable
+[proportional scope identity](../axstack/references/routing.md#proportional-scope-identity):
+
+- Substantial new work has an approved spec identity and matching ticket map.
+- Small new work has one snapshotted **small-change intent**: the current
+  request or chosen issue, explicit acceptance checks, and exclusions. An
+  `axstack-debug` diagnosis record with repair class `bounded` is an accepted
+  small-change intent source; verify the repair against both its original loop
+  and its minimised repro. An implementation slip (wrong file, bad test, setup
+  failure) returns to the author and does not increment the bug's fix ledger.
+- An adopted own-PR repair has its accepted maintenance snapshot.
+
+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
+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.
+
+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
+through the shared lifecycle. Do not activate a task-owned automation outside
+the accepted automations contract.
+
+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.
+
+## 3. Establish test-first evidence
+
+Use the normal behavior path unless the accepted improvement scope is
+explicitly marked **structure-preserving**. The author never chooses that tag.
+
+### Normal behavior path
+
+Choose a behavior from the accepted scope, including its failure behavior or a
+real integration boundary. Test it through an observable interface rather than
+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.
+Corrective work begins with a new behavior slice that can go real red. This
+slice may turn green only after the intended failure is observed and recorded.
+
+### Structure-preserving path
+
+The accepted scope records the listed files, current and target shape,
+preserved behavior contract, and expected test evidence. Write or identify a
+behavioral baseline or characterization check. The old revision must run green
+before any structural edit. After the edit, run the same checks on the new
+revision green, plus appropriate actual artifact or equivalence checks.
+
+No behavioral red is expected here; never manufacture red. A mutation
+sensitivity check is optional evidence that the baseline detects meaningful
+change. If it detects nothing, record that sensitivity as an unverified
+boundary rather than changing acceptance tests to create a failure.
+
+Any bug or new behavior found during the refactor is separately accepted and
+returns to the normal strict real red -> green path. If work exceeds the listed
+files or crosses a new security or infrastructure boundary, stop and reassess
+scope through shared routing. Do not turn a bounded refactor into a sweeping
+campaign.
+
+## 4. Turn the slice green, then refactor
+
+For the normal behavior path, implement only what makes the red check pass.
+Run it and capture green evidence, then refactor while keeping it green. Repeat
+for each accepted behavior slice; every normal slice needs observed red and
+green evidence. For structure-preserving work, make only the accepted
+structural edits and keep the unchanged baseline and equivalence evidence
+green.
+
+## 5. Verify and return the candidate
+
+Run the acceptance checks and affected integration boundaries. Record commands,
+observed outputs, and verified states. UI work includes rendered interaction
+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:
+
+```text
+Record: <progress.md path or tiny-task brief>
+Candidate: <PR or branch> base <sha> revision <sha>
+Owner: <profile + session ID + worktree>
+Scope: <approved spec + capability | small-change intent | maintenance snapshot>
+Shape: <total> lines vs base <sha>; bulk: <buckets>; theme: <one line>
+TDD: <normal red/green | structure-preserving old-green/same-check-new-green evidence>
+Acceptance: <checks + observed results>
+Dependencies: <parent revisions or none>
+Unverified: <boundaries + reasons>
+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.