devrites 5.5.0 → 5.6.0

package/pack/generated/pi/skills/rite-spec/reference/references-intake.md

@@ -0,0 +1,62 @@
+# Reference intake: design/style materials from the human
+
+During spec, the human may supply screenshots, Figma, video, sites, or docs showing how the
+feature should look or behave. When present, inspect them, save local copies, and classify
+each as a fidelity **target**, hard **constraint**, or **inspiration** so a mood reference
+cannot become a pixel-match contract. No references is valid; skip this intake.
+
+## Gather + understand each reference
+- **Images / screenshots / mockups:** open and **view** them (the Read tool renders
+  images). Describe what they show: layout, components, spacing, states, the target look.
+- **Figma link:** if a Figma integration is available, pull its design context (frames,
+  tokens, components); otherwise record the link and ask the human for an export/screenshot
+  so there's something concrete to match offline.
+- **Links / reference sites / docs:** fetch and read for the relevant intent (tone,
+  layout, interaction, quality bar). Capture *why* it's a reference, not just the URL.
+- **Video:** note what it demonstrates (the expected interaction/flow). Save it; later
+  phases can step through it as tooling allows.
+
+## Save local assets into the workspace
+Copy any local file (screenshot, mockup, video, export) into
+`.devrites/work/<slug>/references/` so it's durable and connectable later:
+```
+mkdir -p .devrites/work/<slug>/references
+cp "<the file the human gave>" .devrites/work/<slug>/references/<clear-name>.<ext>
+```
+Use clear names (`login-mockup.png`, `checkout-flow.mp4`). Don't move the user's
+original; copy it. For remote-only refs (a live Figma/URL), record the link in the index.
+Index source/owner/license and **reference-only** or **may ship** usage; external screenshots
+never grant rights to copy brand, copy, or assets.
+
+## Index in `references.md`
+```markdown
+# References: <slug>
+| Ref | Role | Usage / provenance | Type | Location | Shows / why it's a reference | Informs |
+|-----|------|--------------------|------|----------|------------------------------|---------|
+| R1 | target | project; may ship | screenshot | references/login-mockup.png | approved composition + spacing | spec UI, slice 2, proof |
+| R2 | constraint | project; may ship | figma | https://figma.com/… | required tokens + components | all UI |
+| R3 | target | user; reference-only | video | references/checkout-flow.mp4 | approved step order + transitions | build, proof |
+| R4 | inspiration | external; reference-only | link | https://example.com | tone + density, not identity/layout | shape |
+```
+
+Roles are normative: **target** means compare fidelity, **constraint** means satisfy the
+named rule, and **inspiration** means extract the cited principle without copying identity,
+composition, copy, or distinctive assets. Usage is normative too: only **may ship** assets
+enter product code.
+
+## Feed them into the spec + the design brief
+- Use references to sharpen `spec.md` (UI impact, success/acceptance: e.g. "matches R1").
+- When the feature touches UI, these references are the primary input to **`devrites-ux-shape`**
+  (spec step 3a): they anchor the design direction and can seed the visual-direction probe
+  (a Figma link → pulled design context; reference sites → screenshots). The resulting
+  `design-brief.md` cites them by R-id **and role**.
+- A reference can *resolve a gap* ("which layout?"): record that in the gaps table.
+- If a reference **conflicts** with the existing design system, that's an issue to raise
+  with the human (match the system, or adopt the reference: their call).
+
+## Later phases use them (wire-through)
+`devrites-frontend-craft` builds to the approved brief and its **target** references,
+honors **constraints**, and uses **inspiration** only for the named principle. `/rite-prove`
+records rendered comparisons in `browser-evidence.md`; `/rite-polish` and `/rite-seal`
+reuse that same contract. Save and classify once here so every downstream phase makes the
+same fidelity decision.

package/pack/generated/pi/skills/rite-spec/reference/spec-checklists.md

@@ -0,0 +1,89 @@
+# Spec-quality checklists
+
+Before `/rite-define`, test requirement prose for completeness, clarity, and
+measurability—not implementation. “Banner is prominent” lacks a threshold; ask
+whether export defines empty data, never whether `exportCsv()` handles `[]`.
+Function/file/library checks belong to `/rite-vet` and `/rite-prove`.
+
+## Output: one file per requirement domain
+
+Emit `.devrites/work/<slug>/checklists/<domain>.md` per covered domain; skip
+`none`. Each domain maps gaps to a `devrites-interview` dimension:
+
+| Domain file | Tests the prose of |
+| --- | --- |
+| `functional.md` | Functional requirements + scenarios: is each capability stated, bounded, testable? |
+| `data-model.md` | Key entities / data model: shapes, fields, lifecycle, relationships (skip if "none"). |
+| `interaction.md` | API / UI impact + UX states: every screen state and contract named (skip if no UI/API). |
+| `non-functional.md` | Invariants; security/privacy/accessibility, latency/scale, compatibility, operations, and human-only proof prerequisites. |
+| `edge-cases.md` | Empty/boundary/invalid/concurrent/failure/recovery paths plus the spec's applicability map. |
+
+## Each item: a question, a verdict, the line it interrogates
+
+```markdown
+# Spec checklist: <domain> — <slug>
+Scored: <iso>   Verdict: pass | gaps (<n CRITICAL / n minor>)
+
+| # | Question (tests the requirement prose) | Verdict | Spec line | Severity |
+|---|---|---|---|---|
+| 1 | Is every quantitative qualifier ("prominent", "fast", "large") given a number or reference? | fail | "banner is prominent" | **CRITICAL** |
+| 2 | Does each requirement name an observable outcome a test could check? | pass | REQ-001..004 | — |
+| 3 | Are all enumerations closed — no "etc." / "and so on" / open "…"? | pass | — | — |
+```
+
+Verdict: `pass | fail | n/a`. A fail is **CRITICAL** when ambiguity changes build
+or acceptance: unquantified success, open enumeration, ambiguous data shape,
+undefined stated-flow edge, or contradictory requirements. Other vague prose is
+**minor**: record it; do not block.
+
+## Question bank
+
+Each question checks one requirement-prose failure mode:
+
+- **Measurability:** every "good / fast / prominent / simple / secure" carries a number, a budget,
+  or a named reference. No adjective stands in for a threshold.
+- **Completeness:** every enumeration is closed (no "etc."); every requirement with a precondition
+  states the failure branch; every entity names its required fields + lifecycle; every stated flow
+  names its empty / error / boundary behaviour.
+- **Clarity:** one entity, one name (no `user`/`customer`/`account` drift); no requirement two
+  readers would implement differently; no "should" where "MUST" is meant.
+- **Assumptions:** no material behavior, scope, data, security, or proof fact survives as a
+  hidden assumption; verify it or record an owned/deadlined assumption or blocking question.
+- **Testability:** each acceptance criterion is binary and names (or clearly implies) its evidence.
+  A criterion only provable by reading code is a fail.
+- **Consistency:** no requirement contradicts another, the data model, or a non-goal.
+- **Stakeholders:** affected actors/operators are named; conflicting outcomes have an
+  explicit priority or decision owner rather than two simultaneously impossible promises.
+- **Applicability:** topology, data, integration, security, UI/i18n/time zone, and
+  compatibility/delivery rows are `applies` with IDs or specifically justified `not applicable`.
+- **Failure/recovery:** each partial, timeout, invalid, interrupted, or unavailable state
+  implied by an applicable row has a user outcome, system state, and safe retry/recovery rule.
+- **Data:** schema/backfill/concurrency/tenant/retention implications state invariants and
+  prohibited loss/leakage; implementation detail stays for Define.
+- **Integration:** timeout, invalid/partial response, auth/rate-limit/outage, duplicate,
+  ordering, and version-change behavior is specified when the boundary can produce it.
+- **Preservation:** each material brownfield outcome appears in `Existing behavior
+  to preserve` with preserving REQ/AC and current evidence. Missing/vague “no
+  regressions” or unjustified `none` is CRITICAL.
+  **Failing case:** brownfield login still works but the table has no evidence column
+  → CRITICAL until a test path, command, or observed contract is named.
+- **Backstops:** each row names an independent held-out, property/metamorphic, or
+  direct behavioral check and the failure it discriminates; confidence/presence/self-review fail.
+- **Non-functional:** each NFR names affected REQ/AC IDs or a bounded `global` scope;
+  human-only proof prerequisites name their owner.
+
+## Readiness gate
+
+The spec **Readiness gate** at the bottom of
+[`spec-template.md`](spec-template.md) requires every
+emitted `checklists/<domain>.md` to reach `Verdict: pass` (zero CRITICAL fails) before the gate
+passes. Minor fails are logged, not blocking. A single open CRITICAL keeps the spec `Status: Draft`.
+`/rite-define` reads the checklists at step 0 and **hard-blocks while any CRITICAL is
+unchecked**. A spec without checklists is not yet checked, so define stops and routes
+back here.
+
+## Discipline
+
+- Score honestly. Do not soften a checklist question to pass a weak spec.
+- Don't pad. Five real questions that find one CRITICAL beat thirty rubber-stamped rows.
+- If a question needs a function name, it belongs in `/rite-vet`'s `test-plan.md`.

package/pack/generated/pi/skills/rite-spec/reference/spec-template.md

@@ -0,0 +1,154 @@
+# `spec.md` template
+
+Contract WHAT users get, WHY, success, and scope. HOW belongs in `plan.md`,
+topology in `architecture.md`/`flows.md`, coverage in `traceability.md`.
+
+Use `[NEEDS CLARIFICATION: <question>]` (blocking stops `/rite-clarify`); before readiness
+every surviving marker converts to a gated `Q-###` open question (`spec-grammar.md` §
+Unresolved-question markers — fail closed). Stable `REQ-001`/`AC-001` IDs; link, never
+duplicate, source artifacts; over-budget requires `Budget override: <reason>`.
+
+```markdown
+# Spec: <Feature>
+Slug: <kebab-case>
+Status: Draft | Ready
+Created: <date>
+
+## Problem
+<What is broken, missing, or costly.>
+
+## Goal
+<User-visible outcome and why it matters.>
+
+Capability impact: <affected capability/ies and change | none — specific justification>
+
+## Non-goals
+- <Explicitly out of scope.>
+
+## Existing behavior to preserve
+List affected observable public/security/data/operational outcomes that MUST
+survive; map preserving REQ/AC plus current test/runtime/contract/source evidence.
+No implementation detail. True greenfield: `none — no existing behavior in the affected scope`.
+
+| Existing outcome | Preserved by | Current evidence |
+| --- | --- | --- |
+| <outcome that must not regress> | REQ-001 / AC-001 | <current evidence> |
+
+Each preservation row **must** cite current evidence (test, runtime, contract, or
+observed behavior). An empty or vague evidence cell blocks Spec readiness.
+
+**Failing case:** row lists REQ-001 with evidence "none" or "TBD" → readiness gate
+fails until evidence is named or the outcome is removed from scope.
+
+## Stakeholders and priorities
+| Actor/stakeholder | Observable outcome | Conflict / priority rule |
+| --- | --- | --- |
+| <actor or affected owner> | <goal, protection, or operational need> | <none or how competing goals resolve> |
+
+## Constraints and invariants
+- INV-001: <fact that MUST remain true across success, failure, retry, and recovery>.
+- <security/privacy/accessibility/performance/compatibility/data/operational constraint,
+  or `none — <specific reason>` for a materially relevant category>.
+
+## Requirements
+- REQ-001: The system MUST <observable product behavior>.
+- REQ-002: The system MUST NOT <prohibited behavior>.
+
+## Acceptance criteria
+Binary/evidence-backed; each maps to a requirement and later a traceability slice.
+
+- [ ] AC-001: Given <state>, when <action>, then <outcome>. (REQ-001)
+- [ ] AC-002: Given <state>, when <action>, then <outcome>. (REQ-002)
+
+Behavioral/high-risk work uses this grammar, with the AC ID inside the scenario:
+
+### Requirement: <name>
+The system SHALL <core observable behavior>.
+
+#### Scenario: <name>
+- [ ] AC-003: **WHEN** <trigger> **THEN** <observable outcome>. (REQ-001)
+
+## Edge Coverage
+Use `covered | backstop | dismissed | unresolved`; target an existing REQ/AC
+unless dismissed. `backstop` requires a named independent held-out,
+property/metamorphic, or direct behavioral check plus the wrong behavior it
+discriminates. If unavailable, use `unresolved`; presence/prose/self-judgment cannot pass.
+
+| Edge ID | Requirement/AC | Class | Status | Reason/backstop |
+| --- | --- | --- | --- | --- |
+| EDGE-001 | AC-001 | empty/error/permission/race/migration | covered | <evidence/rationale> |
+
+## Prohibitions (must-NOT)
+Bespoke only; generic security/privacy stays in standards. Status:
+`resolved/test | resolved/judgment | dismissed | unresolved`.
+
+| Prohibition ID | Requirement/AC | Status | Test/evidence |
+| --- | --- | --- | --- |
+| PROH-001 | REQ-002 | resolved/test | <test/evidence link> |
+
+## Failure and recovery behavior
+| Trigger / partial state | User-visible outcome | System state | Recovery / retry rule | Requirement/AC |
+| --- | --- | --- | --- | --- |
+| <timeout, invalid input, interruption, dependency loss> | <clear bounded outcome> | <unchanged/pending/reconciling> | <who/what can safely recover> | <REQ/AC> |
+
+## Applicability map
+Use `applies | not applicable`; a non-applicable row needs a specific reason. The
+status routes Define/Vet/Build/Prove to the named standard without copying it here.
+
+| Concern | Status and trigger | Affected REQ/AC/invariant |
+| --- | --- | --- |
+| Repository topology (nested/mono/multi-repo, languages, services, generated/vendor) | <status + reason> | <ids> |
+| Data integrity (writes, schema/migration, concurrency, tenant, retention/privacy) | <status + reason> | <ids> |
+| Integration reliability (API/webhook/queue/job/cache/cross-service) | <status + reason> | <ids> |
+| Security boundary (authn/authz, hostile input/files, secrets, privilege) | <status + reason> | <ids> |
+| UI/accessibility/i18n/time-zone behavior | <status + reason> | <ids> |
+| Compatibility/delivery (old/new versions, config, flag, rollout/rollback) | <status + reason> | <ids> |
+
+## Edge cases
+- <Boundary note not captured above.>
+
+## AI-SPEC annex
+- Model/RAG/agent/eval/LLM-output scope: `ai-spec.md` from `ai-spec-template.md`.
+- Otherwise: not applicable.
+
+## Success metrics
+- <Metric or observable proof.>
+
+## Scope boundaries
+- Owns: <surface/behavior>.
+- Does not own: <adjacent area>.
+- Placement summary: <module/layer>; full map in `architecture.md`.
+
+## Coverage seed
+- Actors/journeys/components: <material surfaces>.
+- States/data/contracts/integrations: <material boundaries>.
+- Operations/proof: <config, observability, rollout/rollback, evidence constraints>.
+
+## References
+- `brief.md`: request/outcome/scope; `architecture.md`: placement/integration;
+  `flows.md`: Mermaid-first diagrams (optional `visual/<flow>.html`+`.outline.md` companion
+  + link when richer presentation earns it — load playbooks via
+  `devrites-lib/reference/visual-playbooks/index.md`); `decisions.md`: decisions;
+  `decision-coverage.md`: Clarify topology/verdict; `traceability.md`: Define coverage;
+  `design-brief.md`: UI direction.
+
+## Open questions
+| Question ID | Gate | Question | Impact |
+| --- | --- | --- | --- |
+| Q-001 | blocking | [NEEDS CLARIFICATION: <question>] | AC-001 |
+
+## Readiness gate
+- [ ] No blocking clarification or open `blocking`/`escalating` question; REQ/AC IDs are valid and ACs independently provable.
+- [ ] Stakeholder conflicts/priority rules, constraints, and invariants are explicit;
+      implementation preferences are not disguised as requirements.
+- [ ] Existing affected behavior maps to preserving REQ/AC + current evidence, or uses the exact justified greenfield `none`.
+- [ ] Edge rows target REQ/AC or justify dismissal; every backstop names independent discriminating evidence, else `unresolved`.
+- [ ] Prohibitions resolve/dismiss; `resolved/test` links evidence.
+- [ ] Each material failure/partial state names user outcome, system state, recovery,
+      and REQ/AC; no silent success or blind retry remains.
+- [ ] Every applicability row is `applies` with affected IDs or has a specific
+      evidence-backed `not applicable` reason.
+- [ ] AI has `ai-spec.md` and UI has `design-brief.md`; out-of-scope work states not applicable.
+- [ ] Non-goals/scope are explicit; capability impact is singular/specific and matches ledger deltas.
+- [ ] Architecture/flows/decisions are linked, not duplicated; Coverage seed names Clarify surfaces.
+```

package/pack/generated/pi/skills/rite-spec/reference/state-workspace.md

@@ -0,0 +1,227 @@
+# `.devrites/` state workspace
+
+This is the writer-facing companion to the canonical schema in
+[`devrites-lib/reference/workspace-artifact-schema.md`](../../devrites-lib/reference/workspace-artifact-schema.md).
+Load that schema before creating or updating workspace artifacts.
+
+## Layout
+
+```text
+.devrites/
+  ACTIVE
+  work/
+    <feature-slug>/
+      README.md                  # compact workspace map
+      brief.md
+      spec.md
+      checklists/                # from /rite-spec step 5a
+      architecture.md            # from /rite-define
+      flows.md                   # optional Mermaid-first; only when useful
+      visual/                    # optional HTML+outline companions (never readiness)
+      decisions.md
+      assumptions.md
+      questions.md
+      decision-coverage.md       # from /rite-clarify
+      strategy.md                # from /rite-temper
+      plan.md                    # from /rite-define
+      tasks.md                   # from /rite-define
+      traceability.md            # from /rite-define
+      eng-review.md              # from /rite-vet
+      test-plan.md               # from /rite-vet
+      state.md
+      evidence.md                # from /rite-build or /rite-prove
+      browser-evidence.md        # UI only
+      drift.md                   # drift only
+      touched-files.md           # from /rite-build
+      design-brief.md            # UI only
+      handoff.md                 # from /rite-handoff
+      references.md
+      references/
+  archive/
+    <feature-slug>/
+```
+
+## `flows.md` (optional Mermaid-first)
+
+Write `flows.md` only when sequence/state/data/lifecycle diagrams clarify the feature.
+Keep **Mermaid in `flows.md`** when that is enough. When a richer reviewable presentation
+is needed, **also** emit `.devrites/work/<slug>/visual/<flow>.html` +
+`visual/<flow>.outline.md` and link the pair from `flows.md`.
+
+Before any HTML:
+
+1. Open matching playbooks via
+   [`../../devrites-lib/reference/visual-playbooks/index.md`](../../devrites-lib/reference/visual-playbooks/index.md)
+   (progressive; never preload all seven).
+2. Copy required outline headings from
+   [`outline-template.md`](../../devrites-lib/reference/visual-playbooks/outline-template.md).
+3. Dual-read: agents treat the outline as SSOT; **outline wins** on conflict. No Lavish
+   runtime; this is not a new lifecycle phase and never inflates readiness.
+
+`/rite-spec` may seed a thin `flows.md` when investigation already needs a diagram;
+`/rite-define` owns richer architecture/flow companions beside `architecture.md`.
+
+## Creation rules
+
+- Create or reuse the slug exactly under the canonical schema's
+  [Slug identity](../../devrites-lib/reference/workspace-artifact-schema.md#slug-identity)
+  contract.
+- `/rite-spec` creates the workspace map, `brief.md`, `spec.md`, `decisions.md`,
+  `assumptions.md`, `questions.md`, `state.md`, optional `references.md` /
+  `references/`, optional `flows.md` when a diagram already clarifies investigation,
+  and optional `design-brief.md` for UI.
+- `/rite-clarify` adds `decision-coverage.md`.
+- `/rite-define` adds `architecture.md`, `plan.md`, `tasks.md`, and
+  `traceability.md`; may add or enrich `flows.md` and optional `visual/` HTML+outline
+  companions when Mermaid alone is not enough.
+- `/rite-vet` adds `eng-review.md` and `test-plan.md`.
+- Later phases add only the artifact they own. Do not create optional files as
+  empty placeholders; absence means the phase has not produced that artifact.
+- Each artifact starts with a summary and links to deeper source files instead of
+  copying their content.
+- Use stable IDs: `REQ-001`, `AC-001`, `EDGE-001`, `PROH-001`, `SLICE-001`,
+  `DEC-001`, `ASM-001`, `DRIFT-001`, `EVID-001`; apply the canonical schema's
+  append-only ID contract. Queued questions use `q-YYYY-MM-DD-NNN` below.
+
+## README.md template
+
+```markdown
+# <Feature> Workspace
+phase: spec
+status: running
+next_action: /rite-clarify after spec readiness passes
+last_updated: <date>
+
+## Artifact map
+| File | Job |
+| --- | --- |
+| brief.md | Objective and bounds |
+| spec.md | Product contract |
+| decision-coverage.md | Clarification verdict; absent until /rite-clarify |
+| strategy.md | Temper record; absent until /rite-temper |
+| architecture.md | Technical map; absent until /rite-define |
+| plan.md | Technical approach; absent until /rite-define |
+| tasks.md | Vertical slices; absent until /rite-define |
+| traceability.md | Coverage dashboard; absent until /rite-define |
+| evidence.md | Proof log; absent until /rite-build or /rite-prove |
+
+## Read next
+| Phase / role | Read |
+| --- | --- |
+| Spec | brief.md, spec.md, questions.md |
+| Clarify | spec.md, decisions.md, assumptions.md, questions.md |
+| Build | state.md, decision-coverage.md, eng-review.md, test-plan.md, tasks.md, plan.md |
+| Review | traceability.md, evidence.md, decisions.md |
+
+## Blocking gates
+None.
+```
+
+## state.md template
+
+```markdown
+# State
+
+## Cursor
+| Key | Value |
+| --- | --- |
+| phase | spec |
+| status | running |
+| active_slice | none |
+| slice_mode | none |
+| risk | none |
+| next_action | <single command + reason, or terminal: none — technical recovery exhausted for an unchanged causal fingerprint> |
+| return_phase | <originating later phase; clarification or agent-owned technical backtracking only> |
+| return_next_action | <saved originating command> |
+
+## Awaiting human
+Only present when status is awaiting_human.
+| Key | Value |
+| --- | --- |
+| question_id | q-YYYY-MM-DD-NNN |
+| gate | blocking |
+| blocking_slices | SLICE-001 |
+```
+
+`state.md` is a compact cursor, not a history file. Put proof in `evidence.md`,
+decisions in `decisions.md`, assumptions in `assumptions.md`, and drift in
+`drift.md`. Omit both `return_*` rows outside a later-phase `/rite-clarify`
+retrofit or agent-owned technical backtracking chain.
+
+Before an active caller moves backward, it copies its current phase and
+non-empty action into the two return rows. Nested Plan, Vet, Build, and proof
+work preserves that valid cursor. Once the prerequisite chain is green, the
+controlling caller restores the saved phase/action and removes both rows in one
+rewrite. A real HITL or exhausted-recovery stop retains the cursor for cold
+resume. Never overwrite an existing valid return cursor, and preserve every
+unrelated Markdown byte. `/rite-clarify` applies its stricter native cursor protocol in `/rite-clarify`.
+
+On cold resume, a terminal `next_action` is a claim to verify, not a counter.
+Reconcile the exact fingerprint and its attempts in `drift.md` / `evidence.md`.
+If a consumptive action retained a distinct fingerprint below the no-progress
+cap, rewrite the cursor into caller-owned recovery and preserve or reconstruct
+the return rows only from the current phase and approved recorded action. The
+spent action authorization blocks another execution, not that rewrite.
+
+`afk_slices_remaining` is mutable runtime state, not `.devrites/AFK`
+configuration. Only the controlling root writes it under the shared
+[`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#the-sentinel-devritesafk)
+contract and Build's
+[`afk-discipline.md`](../../rite-build/reference/afk-discipline.md#iteration-cap).
+Ordinary workspace creation preserves the field without initializing,
+increasing, renaming, or deleting it. Released bullet workspaces spell it `AFK
+slices remaining`; preserve that presentation rather than migrating it.
+
+When the brief records a [sequence continuation](../../rite-plan/reference/slicing.md#continuation-workspaces),
+seed the `sequence_parent`, `sequence_position`, `sequence_workspaces_remaining`,
+and — for the release entry — `sequence_role` rows at creation per that contract.
+Without them `state merge-manifest` cannot walk the chain and the release-union
+gate never engages.
+
+## questions.md entry format
+
+```markdown
+## q-YYYY-MM-DD-NNN
+status: open | answered | dropped
+slice: spec | plan | SLICE-001
+gate: advisory | validating | blocking | escalating
+route: <specialist tag> (escalating only; omit otherwise)
+question: <one crisp sentence>
+options:
+  1. <recommended> (Recommended) - <trade-off>
+  2. <alternative> - <trade-off>
+proposed: <best current answer>
+raised_at: <iso>
+answered_at:
+answer:
+impact: <affected AC/REQ/slice IDs>
+```
+
+No open blocking/escalating question may remain before define/build/prove gates.
+For a new entry, scan every `## q-YYYY-MM-DD-NNN` header for the current date,
+choose one above the highest suffix (or `001` when none exist), advancing until
+it is unused, then re-read
+`questions.md` immediately before the append and recompute. If the candidate is
+no longer unused, retry the scan; never reserve or derive it with an engine
+command.
+
+## brief.md template
+
+```markdown
+# Brief: <Feature>
+
+## Objective
+<One sentence.>
+
+## Non-goals
+- <Explicitly out of scope.>
+
+## Success definition
+<One sentence that says what "done" means.>
+```
+
+## Compactness
+
+High-traffic files should stay within the budgets in
+`workspace-artifact-schema.md`. If a file truly must exceed its budget, add
+`Budget override: <reason>` near the top.

package/pack/generated/pi/skills/rite-status/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: rite-status
+description: User-invoked read-only active-feature report: phase, active slice, next action, evidence, open questions, drift, risks, and handoff readiness.
+argument-hint: "[feature-slug]"
+user-invocable: true
+disable-model-invocation: true
+---
+
+# /rite-status: active feature status
+
+Read-only. Report the active workspace; do not run a phase or write files.
+
+## Load
+
+Use the supplied slug or `.devrites/ACTIVE`; require its authoritative
+`state.md` and read the cursor directly. Read question, evidence, and risk
+artifacts only as needed. Never infer lifecycle state from `README.md` or chat.
+
+If no workspace exists: when archived workspaces record an unfinished
+[continuation sequence](../rite-plan/reference/slicing.md#continuation-workspaces),
+list each next command (`/rite-spec <parent>-<n> "<objective>"`); otherwise
+recommend `/rite-spec <feature>`. Then stop.
+
+If `state.md` is unreadable/malformed: report a gap with the defect and stop — never infer the phase from other files; `/rite-doctor`/`/rite-upgrade` own repair.
+
+## Report
+
+1. feature and one-line objective;
+2. phase, run mode, and active slice;
+3. status from `state.md`;
+4. the single `Next step` recorded in `state.md`;
+5. proven versus unproven evidence;
+6. open questions by gate, including the exact resolving command when awaiting
+   a human; list `gate: escalating` entries separately under **Escalating:**
+   with their `route:` specialist tag (do not mix with synchronous blockers);
+7. unresolved drift and material risks;
+8. handoff readiness.
+
+A workspace is handoff-ready when it records one next action, all unresolved
+questions, non-obvious decisions, load-bearing assumptions, current drift
+status, and evidence for its claims. If chat contains missing durable context,
+recommend `/rite-handoff` before the lifecycle command.
+
+Do not derive a command from host identity or invent one from phase names. Read
+the persisted `Next step`.
+
+## Output
+
+```text
+Feature: <slug> — <objective>
+Phase: <phase>; slice: <slice|n/a>; mode: <HITL|AFK>; status: <status>
+Evidence: <fresh/proven summary | gaps>
+Open: <questions/drift/blockers | none>
+Escalating: <qid route:tag … | none>
+Handoff: <ready | missing durable context>
+Next: <single persisted command>
+```