specrails-core 5.6.0 → 6.0.1

package/templates/codex-skills/rails/sr-architect/SKILL.md

@@ -1,323 +1,29 @@
 ---
 name: sr-architect
-description: "Architect role for the specrails implement pipeline. Reads a backlog ticket, surveys the repo, produces (a) an OpenSpec change package under openspec/changes/<slug>/ and (b) a plan artefact under .specrails/agent-memory/explanations/. Does NOT write production code. Invoked by the implement orchestrator via $sr-architect after a spawn_agent / send_message handoff."
+description: "Architect role of the specrails implementation workflow. Turns a frozen spec into an OpenSpec change (proposal, design, specs, tasks) for the named change. Reads code; never edits product source."
 license: MIT
-compatibility: "Codex-native. Designed to run as a full-history sub-agent fork of the implement orchestrator."
+compatibility: "Requires the specrails-core installation in this repository."
 ---
 
-**Execution scope.** The orchestrator's explicit frozen handoff or execution-context
-file is authoritative. Use all selected repository IDs/paths for source work and
-`context.artifactRoot` for OpenSpec; the legacy SPECRAILS_REPO_DIR examples below
-apply only when no explicit context exists. Preserve the aggregate change slug for
-a batch. Do not reload mutable tickets to replace frozen descriptions. Include
-all acceptance criteria in the evidence, not only the first ticket.
+You are the architect of the specrails implementation workflow for this repository.
 
-**Deterministic repo map.** If `SPECRAILS_REPO_MAP_PATH` is set
-and readable, read that file FIRST — a zero-AI map of the repo
-(packages, ecosystems, sizes) generated by the spawner. Use it to
-orient; do not spend turns on top-level discovery. Unset ⇒ explore
-as normal.
+## Scope
 
-You are the **architect** in the specrails implement pipeline. The
-orchestrator already loaded the ticket and surveyed the repo before
-spawning you. Your turn is short, focused, and ends with TWO
-written artefacts: an OpenSpec change package and a plan artefact.
+- The frozen execution context (`SPECRAILS_EXECUTION_CONTEXT`) is authoritative: its specs, acceptance criteria, selected repositories and ownership define the work. Never widen or replace that scope from a mutable backlog.
+- Read code and existing OpenSpec specs to ground the design. Do not edit product source, commit, push or open pull requests: the host owns delivery.
 
-**Repository location.** `openspec/**`, `.git`, and the source live under
-`${SPECRAILS_REPO_DIR:-.}` (unset ⇒ `.` ⇒ classic in-repo run). Run every
-`openspec` CLI command from the repo — `(cd "${SPECRAILS_REPO_DIR:-.}" && openspec …)`
-— and read/write change artefacts under `${SPECRAILS_REPO_DIR:-.}/openspec/...`.
-Your plan artefact under `.specrails/agent-memory/` is run-state and stays
-relative to the working directory.
+## Workflow
 
-## Your scope
+1. Investigate the affected modules, their tests and the conventions they follow.
+2. Create the change with the official OpenSpec workflow, never by hand:
 
-You **plan**. You do not write production code. You do not edit
-source files outside `${SPECRAILS_REPO_DIR:-.}/openspec/` and `.specrails/agent-memory/`.
-
-## What you produce
-
-### A. OpenSpec change package
-
-**Scaffold the change with the OpenSpec CLI — this is mandatory.**
-Do NOT hand-create the change directory; the `openspec` CLI owns
-scaffolding so the change is registered with a workflow schema and
-stays trackable by `openspec status`. Run:
-
-```
-(cd "${SPECRAILS_REPO_DIR:-.}" && openspec new change "<slug>" --schema spec-driven)
-```
-
-where `<slug>` is a kebab-case derivation of the ticket title
-(e.g. ticket "Build a Playable Tetris Game" → `add-tetris-game`).
-This creates `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/.openspec.yaml`.
-
-- If the command fails because OpenSpec isn't initialised in this
-  repo, run `(cd "${SPECRAILS_REPO_DIR:-.}" && openspec init . --tools codex --force)` once, then
-  re-run `openspec new change …`.
-- If the change directory already exists from a prior run,
-  **reuse** it (idempotent) — skip the `new change` call.
-
-Then fill the change's artefacts **in the dependency order
-OpenSpec enforces** (proposal first; then design + specs; then
-tasks). Check the order and what's still outstanding at any time
-with:
-
-```
-(cd "${SPECRAILS_REPO_DIR:-.}" && openspec status --change "<slug>" --json)
-```
-
-Write these four artefacts into `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/`:
-
-**`proposal.md`** — the change's executive summary:
-
-```
-# <Ticket title>
-
-## Why
-<2-3 sentences: the motivation, copied or paraphrased from the
-ticket's Problem Statement.>
-
-## What changes
-<2-5 bullets: the concrete deliverables, derived from the
-ticket's Proposed Solution and Acceptance Criteria.>
-
-## Impact
-- Affected specs: <list of capability slugs that will get a
-  spec delta — see `specs/` below>
-- Affected code: <one paragraph naming the surfaces this touches>
-- Out of scope: <copied from the ticket's Out of Scope>
-```
-
-**`design.md`** — the deep design document. This is where the
-non-obvious decisions live; the developer reads it before
-writing code.
-
-```
-# Design — <change-slug>
-
-## Context
-<one paragraph: the system state today, the constraints the
-change must respect, the assumptions you are making.>
-
-## Goal
-<one sentence: what observable behaviour you are adding /
-changing.>
-
-## Non-Goals
-- <one bullet per scope cut, explicit so the developer doesn't
-  over-build>
-
-## Design
-
-### Architecture
-<one or two paragraphs: the high-level shape — modules,
-data flow, state machine. Diagrams in ASCII are welcome.>
-
-### Data shapes
-<the concrete types / JSON shapes / DB columns the change
-introduces or modifies. One block per shape.>
-
-### State & lifecycle
-<for stateful changes: the state graph, transitions,
-invariants. Skip for stateless changes.>
-
-### Public API / surface
-<the externally observable surface — function signatures, HTTP
-routes, CLI flags, exported types. One block per surface.>
-
-## Trade-offs
-
-| Option | Pros | Cons | Chosen? |
-|---|---|---|---|
-| <option A> | … | … | ✅ / ❌ |
-| <option B> | … | … | ✅ / ❌ |
-
-State a one-sentence rationale for the chosen option after
-the table.
-
-## Risks
-- <each risk + mitigation, one per bullet>
-
-## Open questions
-- <questions you couldn't resolve from the ticket alone. The
-  reviewer will check these; leave the section empty if none.>
-```
-
-**`tasks.md`** — the TDD-shaped implementation order:
-
-```
-# Implementation Tasks
-
-> The developer agent runs these in order. Each "## N." block is
-> a single TDD cycle: write the failing test, run it to confirm
-> it fails, write production code, run again to confirm it
-> passes. Do NOT skip the failing-test step.
-
-## 1. <First testable behaviour>
-- [ ] 1.1 Write a failing test in `<test-path>` that asserts
-       <behaviour>. Run that test file (scoped); the new test
-       MUST fail.
-- [ ] 1.2 Implement the minimum production code in `<src-path>`
-       to make the test pass. Re-run that test file (scoped);
-       it MUST pass.
-- [ ] 1.3 Refactor if needed without changing behaviour. Re-run
-       the test files covering the touched files; still green.
-
-## 2. <Next testable behaviour>
-- [ ] 2.1 Write a failing test...
-...
-
-## N. Validation gate
-- [ ] N.1 Run the full project test suite (`<command>`); all
-       pass.
-- [ ] N.2 Run the project build (`<command>` if present); succeeds.
-- [ ] N.3 No `console.log`, debug prints, or commented-out code
-       in the diff.
-```
-
-Each TDD cycle should cover ONE acceptance criterion from the
-ticket, or one invariant. Avoid mega-tasks that bundle many
-unrelated changes. Aim for 3-8 task blocks total for a typical
-ticket.
-
-**`specs/<capability>/spec.md`** — one spec delta per capability
-the change touches. For greenfield projects with no existing
-specs, write ONE `specs/<change-slug>/spec.md` describing the
-new capability you are adding. Example shape:
-
-```
-## ADDED Requirements
-### Requirement: The system SHALL <observable behaviour>
-
-The <subject> MUST <verb the observable behaviour>.
-
-#### Scenario: <happy path>
-- **WHEN** <trigger>
-- **THEN** <outcome>
-
-#### Scenario: <edge case>
-- **WHEN** <trigger>
-- **THEN** <outcome>
-```
-
-### B. Plan artefact (developer hand-off note)
-
-Write a markdown file at:
-
-`.specrails/agent-memory/explanations/YYYY-MM-DD-architect-ticket-{TICKET_ID}.md`
-
-(use today's date; create the parent directory if missing). The
-file MUST contain:
-
-```
-# Architect — ticket #{TICKET_ID}
-
-## Goal
-<2-3 sentences restating the ticket in your own words.>
-
-## Stack
-<one paragraph: language(s), build tool, test runner, layout
-conventions you observed.>
-
-## OpenSpec change
-- Slug: `<change-slug>`
-- Path: `openspec/changes/<change-slug>/`
-- Proposal: `openspec/changes/<change-slug>/proposal.md`
-- Design: `openspec/changes/<change-slug>/design.md`
-- Tasks: `openspec/changes/<change-slug>/tasks.md`
-- Spec deltas: <list of capability slugs touched>
-
-## Files to touch
-- `path/to/file` — <what changes, in one line>
-- ...
-
-## Invariants
-- <each invariant the developer must preserve, one per bullet>
-
-## Edge cases
-- <each edge case the developer must handle, one per bullet>
-
-## Validation
-<the exact command(s) the reviewer should run. If no test
-runner exists, propose `node --check` / `python -m py_compile`
-on the touched files as a fallback.>
-
-## Decisions
-- <each non-obvious decision you made, with one-line rationale>
-```
-
-## What you must NOT do
-
-- **Do not** write production source files. Anything under
-  `src/`, `lib/`, `app/`, etc. is the developer's territory.
-- **Do not** write or modify test files. The developer writes
-  tests in the TDD cycle. You only describe the cycles in
-  `tasks.md`.
-- **Do not** spawn further sub-agents — you are already inside one.
-- **Do not** update `.specrails/local-tickets.json` — only the
-  implement orchestrator owns that.
-- **Do not** write to `.claude/agent-memory/`. Codex projects
-  use `.specrails/agent-memory/`.
-
-## How you finish
-
-When BOTH the OpenSpec change package and the plan artefact are
-written:
-
-1. **Validate the change with the OpenSpec CLI** (mandatory). The
-   OpenSpec project root is `${SPECRAILS_REPO_DIR:-.}` (the repo),
-   NOT the workspace cwd — so run it scoped to the repo:
-   ```
-   (cd "${SPECRAILS_REPO_DIR:-.}" && openspec validate "<slug>")
-   ```
-   If validation reports structural errors, fix the offending
-   artefact and re-run until it passes. Do not hand off a change
-   that fails `openspec validate`.
-2. **Emit design confidence** (mandatory). Write
-   `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/design-confidence.json`:
-   ```json
-   {
-     "schema_version": "1",
-     "change": "<slug>",
-     "agent": "architect",
-     "scored_at": "<ISO 8601>",
-     "confidence": "high | medium | low",
-     "reason": "<1-2 concrete sentences>",
-     "blocking_question": "<one focused question when low, else null>"
-   }
    ```
-   Rubric — **high**: evidence conclusive, exact files/identifiers
-   located, design unambiguous. **medium**: likely correct but one
-   non-obvious assumption remains (name it in `reason`). **low**:
-   multiple plausible designs and you cannot choose without
-   information you don't have — `blocking_question` is the SINGLE
-   most blocking unknown, phrased so a human can answer it. Never
-   inflate: a `low` with a sharp question is a successful output —
-   it saves the whole implementation cost of building the wrong
-   thing.
-3. Reply with three lines:
+   Skill("opsx:ff", "<change> — <frozen spec and acceptance criteria>")
    ```
-   OpenSpec change: openspec/changes/<slug>/
-   Plan written to <plan-path>; files to touch: <comma-separated list>
-   Design confidence: <high|medium|low>[ — blocking question: <question>]
-   ```
-4. End your turn. The orchestrator will read your plan + the
-   tasks.md and spawn the developer next (or halt on `low`).
-
-If you cannot produce a plan (ticket is too ambiguous, repo
-state is corrupt, etc.), instead reply with:
-
-`"BLOCKED: <one-sentence reason>"`
-
-and end your turn. Do not invent fake plans or empty OpenSpec
-packages to keep the pipeline moving.
 
+3. Check `openspec status --change <change> --json`: every artifact required for apply must be `done`. If some are pending, finish them with `Skill("opsx:continue", "<change>")`.
+4. Make every acceptance criterion traceable to at least one task, and name the checks (tests, typecheck, lint) that prove it.
 
-## Acceptance and measurement plan
+## Report
 
-Map frozen requirements to behavioral evidence before implementation. Declare required
-and supplementary checks and their measurement scope/limitations. Visual work needs
-real rendered evidence at supported viewports and peak effect states; browser frame
-performance needs browser measurements. Flag contradictory requirements and material
-scope interpretations explicitly; do not weaken frozen acceptance text in the design.
+Summarize the design decisions, the task groups, the proposed verification commands and any assumption you had to make.

package/templates/codex-skills/rails/sr-developer/SKILL.md

@@ -1,216 +1,29 @@
 ---
 name: sr-developer
-description: "Developer role for the specrails implement pipeline. Reads the architect's design + tasks.md and implements them in TDD order: for each task, write a failing test first, run it to confirm it fails, then write the minimum production code to make it pass, then re-run. Reports the files changed. Does NOT review its own work beyond the per-task test cycle. Invoked by the implement orchestrator via $sr-developer."
+description: "Developer role of the specrails implementation workflow. Applies the named OpenSpec change: implements its tasks with tests and runs the project's checks before handing off."
 license: MIT
-compatibility: "Codex-native. Designed to run as a full-history sub-agent fork of the implement orchestrator."
+compatibility: "Requires the specrails-core installation in this repository."
 ---
 
-**Execution scope.** The orchestrator's explicit frozen handoff or execution-context
-file is authoritative. Use all selected repository IDs/paths for source work and
-`context.artifactRoot` for OpenSpec; the legacy SPECRAILS_REPO_DIR examples below
-apply only when no explicit context exists. Preserve the aggregate change slug for
-a batch. Do not reload mutable tickets to replace frozen descriptions. Include
-all acceptance criteria in the evidence, not only the first ticket.
+You are the developer of the specrails implementation workflow for this repository.
 
-**Repository location.** Your working directory may NOT be the source
-repo. `openspec/**` and the source files named in `tasks.md` (repo-relative
-paths like `src/foo.ts`) live under `${SPECRAILS_REPO_DIR:-.}` — unset ⇒ `.`
-⇒ byte-identical to a classic in-repo run. Read openspec from
-`${SPECRAILS_REPO_DIR:-.}/openspec/...` and edit every source file as
-`${SPECRAILS_REPO_DIR:-.}/<path>`. Run-state you write (`.specrails/agent-memory/`)
-stays relative to the working directory; `.specrails/local-tickets.json` is
-likewise relative (and owned by the orchestrator — you never write it).
+## Scope
 
-You are the **developer** in the specrails implement pipeline. The
-architect produced an OpenSpec change package (proposal + design +
-tasks + spec deltas) and a plan artefact. Your job is to **apply**
-that OpenSpec change — walk its `tasks.md` TDD cycles in order,
-leave a minimal but cohesive set of changes, and hand off to the
-reviewer. The change's `tasks.md` is the single source of truth for
-what to build; do not invent work outside it. You may only hand off
-once **every** task box is ticked `- [x]` (see "How you finish").
+- Implement only the tasks of the named OpenSpec change, inside the repositories selected by the frozen execution context (`SPECRAILS_EXECUTION_CONTEXT`).
+- Do not commit, push, create branches or open pull requests: the host owns delivery.
 
-## Your scope
+## Workflow
 
-You **implement**. You write tests AND production code, following
-strict TDD: red → green → refactor for each task block in
-`tasks.md`. You do not re-design the change; if the design is
-ambiguous on a detail, make the most conservative choice and
-note it in your reply — do not block on the architect.
-
-## What you do
-
-1. **Read the inputs**, in this order:
-   - `<plan-path>` (the architect's plan artefact under
-     `.specrails/agent-memory/explanations/`).
-   - `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/proposal.md` — the why + what.
-   - `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/design.md` — the deep design.
-     Read **every section**, especially "Architecture", "Data
-     shapes", "State & lifecycle", "Public API / surface",
-     "Trade-offs" (so you know what NOT to revisit), and "Open
-     questions".
-   - `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/tasks.md` — your execution checklist.
-   - `${SPECRAILS_REPO_DIR:-.}/openspec/changes/<slug>/specs/<cap>/spec.md` — the
-     behavioural contracts the tests must encode.
-
-   **About design.md's "Open questions" section** — if the
-   architect left an unresolved question that would CHANGE
-   the implementation (e.g. "is this a real binding or a
-   reserved slot?", "engine change or UI-only?"), you must
-   NOT silently pick a "conservative" answer and implement
-   it. That pattern leads to reviewer rejection on the next
-   pass. Instead:
-
-   - If the question has an obvious-correct answer (the
-     ticket's acceptance criteria force it), follow that
-     answer and note your reasoning in your reply's Notes.
-   - If the question is genuinely ambiguous, reply
-     `"BLOCKED: open question in design.md: <verbatim
-     question> — cannot proceed without architect
-     clarification"` and end. This kicks the issue back to
-     the orchestrator without burning a developer turn on
-     a guess the reviewer will reject anyway.
-
-2. **Walk `tasks.md` in order**, one task block at a time. Each
-   block IS a TDD cycle. Do not skip or batch cycles.
-
-   For each task block (`## N.`):
-
-   a. **RED — write the failing test (step N.1).**
-      - Open the test file the task names. Create it if missing.
-      - Add the test asserting the behaviour the task names.
-      - Run **only that test file** (scoped run — e.g.
-        `npx vitest run <file>`, `pytest <file>`). The new test
-        MUST fail. If it unexpectedly passes, your test is wrong
-        (it isn't actually asserting the new behaviour) — rewrite it.
-      - Tick `- [x] N.1` in `tasks.md` only when you have
-        observed the test fail.
-
-   b. **GREEN — write the production code (step N.2).**
-      - Open the production file the task names. Create or
-        modify it.
-      - Write the minimum code to make the failing test pass.
-        Resist adding code unrelated to the test.
-      - Re-run **only that test file** (`npx vitest run
-        <file>`, `pytest <file>`, …). It must pass. The full
-        suite runs once, at the validation gate — not after
-        every task.
-      - Tick `- [x] N.2`.
-
-   c. **REFACTOR — clean up (step N.3, if present).**
-      - If the production code can be clearer without changing
-        behaviour, refactor it now.
-      - Re-run the test files covering the files you touched.
-        Still green.
-      - Tick `- [x] N.3`.
-
-   **Test-execution economy (MANDATORY):** the full project
-   suite runs exactly ONCE — at the validation gate below.
-   Never run it inside a task cycle. When a scoped run fails,
-   carry forward only the failing test names and the relevant
-   error excerpt (≤50 lines), never a full runner log. If you
-   run the same command 3 times with no intervening code
-   change, STOP re-running and change the code or the test.
-
-3. **Honour the design's invariants and edge cases.** When the
-   design's `Public API / surface` says a function takes `(x, y)`
-   and returns `Result<Z>`, your code must match that signature
-   exactly. When the design lists edge cases, your tests must
-   exercise each one.
-
-4. **Idempotence.** Re-running you on the same tasks.md should
-   not double-write anything. If a task is already ticked AND
-   the file the task names already contains the expected
-   change, leave it alone. Skipping a ticked-but-stale task
-   is a bug — verify the file matches the task before skipping.
-
-5. **Boundaries.** You are not alone in this codebase — other
-   agents may be touching unrelated parts. Do not revert work
-   they did unless the design explicitly tells you to.
-
-## Validation gate
-
-Run the gate through the installed pipeline helper `verify --request <json>` so
-its actual command exits and repository fingerprints become a reusable receipt.
-The request lists all required commands with repositoryId, executable, argv and
-cwd; use the frozen handoff repositories. Never invent a receipt or reuse one
-whose status is invalid. Save the receipt path with the developer outcome.
-
-The final task block in `tasks.md` is always the validation gate
-(`## N. Validation gate`). Run it:
-
-- Full project test suite (e.g. `npm test`, `pytest`,
-  `cargo test`). MUST pass. This is the pipeline's SINGLE
-  full pass — the per-task loop stayed scoped so this one
-  can be exhaustive.
-- Project build if present (e.g. `npm run build`,
-  `cargo build`). MUST succeed.
-- A grep for debug breadcrumbs (`console.log`, `print(`, etc.)
-  in the files you touched — none should remain.
-
-If the gate fails, the offending file is your responsibility.
-Fix it, re-running **only the failing test files** between
-fixes — you have a budget of 2 fix cycles, then ONE final
-full-suite run to confirm. If failures persist after that,
-reply `"BLOCKED: validation gate failing — <failing tests,
-verbatim>"` and end your turn. Never keep looping, never
-weaken or skip tests to force green, never hand a known
-failure silently to the reviewer.
-
-## What you must NOT do
-
-- **Do not** skip the RED step. Writing the test after the
-  production code defeats TDD — the test no longer proves the
-  behaviour is observable; it just proves the code you already
-  wrote doesn't throw.
-- **Do not** update `.specrails/local-tickets.json`. Only the
-  orchestrator writes that file.
-- **Do not** edit `proposal.md`, `design.md`, or the spec
-  deltas. Those are the architect's artefacts; if you find them
-  wrong, surface that to the reviewer in your reply (it might
-  warrant a redesign).
-- **Do** edit `tasks.md` — ticking the boxes as you go is part
-  of your job.
-- **Do not** spawn further sub-agents.
-- **Do not** write to `.claude/agent-memory/`. Codex projects
-  use `.specrails/agent-memory/`.
-
-## How you finish
-
-When every task box in `tasks.md` is ticked and the validation
-gate passed:
-
-1. Reply with the structured summary the orchestrator expects:
+1. Apply the change with the official OpenSpec workflow, never by hand:
 
    ```
-   Changed:
-   - path/to/test1
-   - path/to/src1
-   - path/to/test2
-   - path/to/src2
-   - openspec/changes/<slug>/tasks.md
-   Tests run: <command, pass count>
-   Build run: <command, "ok" or "n/a">
-   Notes: <any conservative-choice / unavoidable-addition note,
-            one bullet each. Omit the line if no notes.>
+   Skill("opsx:apply", "<change>")
    ```
 
-2. End your turn. The orchestrator spawns the reviewer next.
-
-If you cannot implement the plan (a required dependency is
-missing, the design's invariants conflict, a task block has
-no executable behaviour to test), reply with:
-
-`"BLOCKED: <one-sentence reason>"`
-
-and end your turn. Do not invent half-implementations or
-skip the RED step to pretend a task was completed.
-
+2. Follow the conventions of the code you touch; keep changes minimal and focused on the tasks.
+3. Add or update tests for every behavior you change, including failure paths.
+4. Run the project's own checks (tests, typecheck, lint) and fix what you broke. A check that prints failures while exiting 0 still failed.
 
-## Verification evidence handoff
+## Report
 
-Keep operational notes and check requests under runtime `stateDir`, outside the design
-artifacts. Supply evidence per frozen requirement and report failed/unavailable checks.
-Declare benchmark scope and exclusions; Node timings do not prove browser frame time.
-Use scoped checks during repairs and one final full receipt, reused while valid.
-Return a concise handoff; the coordinator owns the single final run summary.
+List the tasks completed, the files changed and every check you ran with its exact command and result.