spec-tree

ALWAYS invoke this skill when reviewing, auditing, or checking spec file conformance. NEVER check spec conformance without this skill.

ALWAYS invoke this skill before implementing any spec-tree work item. NEVER write code, tests, or architecture for a spec-tree node without this skill.

ADR audit methodology — judges one ADR against the ADR evidence model, covering section structure, atemporal voice, and per-rule tag validity.

Changeset-coherence audit methodology — judges whether an exact committed changeset forms one coherent review unit, covering semantic clustering, generated-source attribution, evidence completeness, and dependency-ordered review-unit sequencing.

Eval-evidence audit methodology — judges whether a spec node's eval suite provides evidence its `[eval]` assertions are fulfilled, covering case quality, verdict schema fit, and producer coupling.

Implementation audit methodology — judges a changeset's implementation against its governing decisions, specs, and language standards, covering per-language code, test, and architecture concerns, finding falsifiability, and completeness of the inspection.

PDR audit methodology — judges one PDR against the PDR evidence model, covering content classification, property quality, per-rule tag validity, atemporal voice, and consistency with ancestor decisions.

Spec-node audit methodology — judges one output or variant spec against the node-spec form, covering section structure, atemporal voice, and per-assertion tag fitness.

Test-evidence audit methodology — judges whether a spec node's tests provide behavior-coupled evidence its assertions are fulfilled, covering predicate ownership, source ownership, coupling, falsifiability, and full-chain coverage.

ALWAYS invoke this skill when adding, defining, or creating specs, decisions, or nodes. NEVER author spec tree artifacts without this skill.

ALWAYS invoke this skill when setting up a new spec tree or when /author detects an empty spx/ directory. NEVER create a spec tree from scratch without this skill.

ALWAYS invoke this skill when committing changes or when user says "commit". NEVER run git commit without this skill.

ALWAYS invoke this skill when asking about status, progress, or what exists in the spec tree. NEVER work on any part of the spec tree without loading context through this skill first.

ALWAYS invoke this skill when breaking down, splitting, scoping, composing, or structuring spec tree nodes. NEVER decompose specs without this skill.

ALWAYS invoke this skill when diagnosing the health of a spec-tree or spx environment, when checking whether the SessionStart hook fired for the current session, or when troubleshooting a missing session identity, worktree claim, or unreachable spx CLI. NEVER guess why session state is missing without running these checks first.

ALWAYS invoke to close active spec-tree work or a merge lifecycle closeout — archive claimed sessions, decide session-file creation, prepare continuation context, and produce operator-useful closeout — only once its goal is met with no continuation remaining, the user halted work, context is exhausted, or an external blocker prevents the next action. NEVER invoke while do-able in-scope work remains or for an explicit direct `spx session archive` or `spx session release` request against identified sessions. NEVER create a spec-tree session file without this skill.

ALWAYS invoke this skill when setting up a repository's git worktree layout — classifying a checkout as a single tree, a bare-repo worktree pool, or non-compliant, and provisioning the bare-repo pool while pushing every local ref to the remote and carrying a prior checkout's gitignored state across. NEVER run git clone --bare plus git worktree add to build the pool outside this skill.

ALWAYS invoke this skill when the user asks about CI failures, workflow logs, GitHub Actions status, pipeline issues, or troubleshooting failed builds. NEVER attempt CI workflow investigation through ad hoc gh CLI calls without this skill.

ALWAYS invoke before requirements interviews, draft approval, or unresolved scope/design questions while creating or modifying an artifact (spec, ADR, PDR, test, code, doc). NEVER invoke solely because a workflow uses {{! tool('ask_user') !}} for an operational choice.

ALWAYS invoke this skill when filing a follow-up into the owning repository's session queue — including the invoking repository, the spec-tree plugin repository, the spx CLI repository, or another spec-tree dependency. NEVER edit installed dependency source or run the current work through full handoff closure merely to record a needed follow-up.

ALWAYS invoke this skill when the user asks to open or manage a GitHub pull request, or runs /manage-github-pr. NEVER open or manage a GitHub pull request outside this skill.

ALWAYS invoke this skill when managing, waiting on, or continuing an open pull request lifecycle after a PR exists.

ALWAYS invoke this skill when the user asks to ship, integrate, or merge a changeset into the default branch on origin, or runs /merge. NEVER select a merge transport or drive a changeset to the default branch on origin without this skill.

Shared merge-lifecycle invariants and routing for detailed preflight, branch, review, authority-gate, transport, and closeout policy. Loaded by composing delivery workflows.

PR opening protocol for VERIFICATION_READINESS, branch push, ready PR creation, and the first management pass. Invoked by exact name as a composed lifecycle protocol.

ALWAYS invoke this skill when resuming prior spec-tree work, loading a handoff session, claiming queued session work, or continuing from another saved context. NEVER continue spec-tree handoff work directly without this skill.

Verification run-journal projection methodology loaded by audit and review skills when building spx journal events, computing rollups, or rendering verdict surfaces.

ALWAYS invoke this skill when moving nodes, re-scoping content, or extracting shared providers. NEVER restructure the spec tree without this skill.

ALWAYS invoke this skill when running ad hoc commands, writing debug scripts, or writing code without a spec. NEVER run ad hoc commands or write throwaway scripts without invoking this skill.

ALWAYS invoke this skill when reviewing working changes on a branch against a base ref. NEVER review changes by hand-formatting JSON or by reading persisted review artifacts directly.

Committed changeset endpoint identities and changed paths, resolved through the canonical Git scope capability.

ALWAYS invoke this skill when selecting the next executable slice to implement or deciding which spec-tree nodes /apply should build next from an implementation plan. NEVER choose the next nodes by ad hoc selection — this skill scopes an existing plan to demonstrable value before /apply runs.

ALWAYS invoke this skill to bring a branch behind its base current — before reading product truth, before verifying, and before every merge push. NEVER rebase a behind-base branch by hand or bring it current with git reset.

Runtime task-tracking standards for skills that schedule heartbeats or timers. Loaded by other skills, not invoked directly.

ALWAYS invoke this skill before writing or repairing deterministic tests for a spec assertion, selecting a decision Testing rule's assertion type, or when learning the testing approach.

Test-evidence seam, case-provenance, oracle-independence, execution-level, per-assertion-type artifact-permission, and pre-authoring assertion-design-record standards enforced across test authoring and auditing. Loaded by other skills, not invoked directly.

ALWAYS invoke this skill when the live SPEC_TREE_FOUNDATION marker is absent before direct filesystem access under spx/ or before reading, searching, listing, or changing source or test files. NEVER access that product content without loading this skill first.

ALWAYS invoke this skill when manually regenerating, refreshing, or scaffolding a product's root CLAUDE.md and AGENTS.md managed Spec Tree instruction surface from the installed spec-tree template, or reconciling a `shared` region that differs between the two files. NEVER hand-edit the router block to a new template version, or hand-merge a `shared` region to reconcile a cross-file difference, without this skill.

ALWAYS invoke this skill when selecting or establishing evidence for spec assertions, decision verification rules, or a spec-tree scope.

ALWAYS invoke this skill before starting a resource-intensive local command or when host load is high. NEVER calculate or schedule a host-load wait without this skill.