@hanzlaa/rcode 2.1.0

package/rihal/workflows/ship.md

@@ -0,0 +1,237 @@
+<purpose>
+Create a pull request from completed phase/milestone work, generate a rich PR body from planning artifacts, optionally run code review, and prepare for merge. Closes the plan → execute → verify → ship loop.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="initialize">
+Parse arguments and load project state:
+
+```bash
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse from init JSON: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `padded_phase`, `commit_docs`.
+
+Also load config for branching strategy:
+```bash
+CONFIG=$(node ".rihal/bin/rihal-tools.cjs" state load)
+```
+
+Extract: `branching_strategy`, `branch_name`.
+
+Detect base branch for PRs and merges:
+```bash
+BASE_BRANCH=$(node ".rihal/bin/rihal-tools.cjs" config-get git.base_branch 2>/dev/null || echo "")
+if [ -z "$BASE_BRANCH" ] || [ "$BASE_BRANCH" = "null" ]; then
+  BASE_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|^refs/remotes/origin/||')
+  BASE_BRANCH="${BASE_BRANCH:-main}"
+fi
+```
+</step>
+
+<step name="preflight_checks">
+Verify the work is ready to ship:
+
+1. **Verification passed?**
+   ```bash
+   VERIFICATION=$(cat ${PHASE_DIR}/*-VERIFICATION.md 2>/dev/null)
+   ```
+   Check for `status: passed` or `status: human_needed` (with human approval).
+   If no VERIFICATION.md or status is `gaps_found`: warn and ask user to confirm.
+
+2. **Clean working tree?**
+   ```bash
+   git status --short
+   ```
+   If uncommitted changes exist: ask user to commit or stash first.
+
+3. **On correct branch?**
+   ```bash
+   CURRENT_BRANCH=$(git branch --show-current)
+   ```
+   If on `${BASE_BRANCH}`: warn — should be on a feature branch.
+   If branching_strategy is `none`: offer to create a branch now.
+
+4. **Remote configured?**
+   ```bash
+   git remote -v | head -2
+   ```
+   Detect `origin` remote. If no remote: error — can't create PR.
+
+5. **`gh` CLI available?**
+   ```bash
+   which gh && gh auth status 2>&1
+   ```
+   If `gh` not found or not authenticated: provide setup instructions and exit.
+</step>
+
+<step name="push_branch">
+Push the current branch to remote:
+
+```bash
+git push origin ${CURRENT_BRANCH} 2>&1
+```
+
+If push fails (e.g., no upstream): set upstream:
+```bash
+git push --set-upstream origin ${CURRENT_BRANCH} 2>&1
+```
+
+Report: "Pushed `{branch}` to origin ({commit_count} commits ahead of ${BASE_BRANCH})"
+</step>
+
+<step name="generate_pr_body">
+Auto-generate a rich PR body from planning artifacts:
+
+**1. Title:**
+```
+Phase {phase_number}: {phase_name}
+```
+Or for milestone: `Milestone {version}: {name}`
+
+**2. Summary section:**
+Read ROADMAP.md for phase goal. Read VERIFICATION.md for verification status.
+
+```markdown
+## Summary
+
+**Phase {N}: {Name}**
+**Goal:** {goal from ROADMAP.md}
+**Status:** Verified ✓
+
+{One paragraph synthesized from SUMMARY.md files — what was built}
+```
+
+**3. Changes section:**
+For each SUMMARY.md in the phase directory:
+```markdown
+## Changes
+
+### Plan {plan_id}: {plan_name}
+{one_liner from SUMMARY.md frontmatter}
+
+**Key files:**
+{key-files.created and key-files.modified from SUMMARY.md frontmatter}
+```
+
+**4. Requirements section:**
+```markdown
+## Requirements Addressed
+
+{REQ-IDs from plan frontmatter, linked to REQUIREMENTS.md descriptions}
+```
+
+**5. Testing section:**
+```markdown
+## Verification
+
+- [x] Automated verification: {pass/fail from VERIFICATION.md}
+- {human verification items from VERIFICATION.md, if any}
+```
+
+**6. Decisions section:**
+```markdown
+## Key Decisions
+
+{Decisions from STATE.md accumulated context relevant to this phase}
+```
+</step>
+
+<step name="create_pr">
+Create the PR using the generated body:
+
+```bash
+gh pr create \
+  --title "Phase ${PHASE_NUMBER}: ${PHASE_NAME}" \
+  --body "${PR_BODY}" \
+  --base ${BASE_BRANCH}
+```
+
+If `--draft` flag was passed: add `--draft`.
+
+Report: "PR #{number} created: {url}"
+</step>
+
+<step name="optional_review">
+Ask if user wants to trigger a code review:
+
+```
+AskUserQuestion:
+  question: "PR created. Run a code review before merge?"
+  options:
+    - label: "Skip review"
+      description: "PR is ready — merge when CI passes"
+    - label: "Self-review"
+      description: "I'll review the diff in the PR myself"
+    - label: "Request review"
+      description: "Request review from a teammate"
+```
+
+**If "Request review":**
+```bash
+gh pr edit ${PR_NUMBER} --add-reviewer "${REVIEWER}"
+```
+
+**If "Self-review":**
+Report the PR URL and suggest: "Review the diff at {url}/files"
+</step>
+
+<step name="track_shipping">
+Update STATE.md to reflect the shipping action:
+
+```bash
+node ".rihal/bin/rihal-tools.cjs" state update "Last Activity" "$(date +%Y-%m-%d)"
+node ".rihal/bin/rihal-tools.cjs" state update "Status" "Phase ${PHASE_NUMBER} shipped — PR #${PR_NUMBER}"
+```
+
+If `commit_docs` is true:
+```bash
+node ".rihal/bin/rihal-tools.cjs" commit "docs(${padded_phase}): ship phase ${PHASE_NUMBER} — PR #${PR_NUMBER}" --files .planning/STATE.md
+```
+</step>
+
+<step name="report">
+```
+───────────────────────────────────────────────────────────────
+
+## ✓ Phase {X}: {Name} — Shipped
+
+PR: #{number} ({url})
+Branch: {branch} → ${BASE_BRANCH}
+Commits: {count}
+Verification: ✓ Passed
+Requirements: {N} REQ-IDs addressed
+
+Next steps:
+- Review/approve PR
+- Merge when CI passes
+- /rihal:complete-milestone (if last phase in milestone)
+- /rihal:progress (to see what's next)
+
+───────────────────────────────────────────────────────────────
+```
+</step>
+
+</process>
+
+<offer_next>
+After shipping:
+
+- /rihal:complete-milestone — if all phases in milestone are done
+- /rihal:progress — see overall project state
+- /rihal:execute-phase {next} — continue to next phase
+</offer_next>
+
+<success_criteria>
+- [ ] Preflight checks passed (verification, clean tree, branch, remote, gh)
+- [ ] Branch pushed to remote
+- [ ] PR created with rich auto-generated body
+- [ ] STATE.md updated with shipping status
+- [ ] User knows PR number and next steps
+</success_criteria>

package/rihal/workflows/show.md

@@ -0,0 +1,63 @@
+<purpose>
+Print a specific SPRINT.md file or all plans in a phase, with execution status from state.json.
+</purpose>
+
+## Step 0: Usage Check
+
+Verify argument was provided:
+- If empty: `Usage: /rihal:show <phase-id|plan-id> (e.g., /rihal:show 01 or /rihal:show 01-01)`
+- Proceed to Step 1
+
+## Step 1: Resolve ID
+
+Run: `node .rihal/bin/rihal-tools.cjs state resolve-id "$ARGUMENTS"`
+
+Expected output:
+```json
+{
+  "type": "phase" | "plan" | "unknown",
+  "id": "01" | "01-01",
+  "path": "/full/path/to/dir-or-file"
+}
+```
+
+If `type === "unknown"`: Return error `ID not found: $ARGUMENTS. Try /rihal:show 01 for phase, 01-01 for specific plan.`
+
+## Step 2: Phase or Plan?
+
+If `type === "phase"`:
+- Walk `.planning/phases/{phase-dir}/` for all `*.md` files matching `[0-9]{2}-[0-9]{2}-SPRINT.md`
+- Read each SPRINT.md frontmatter + body
+- Continue to Step 3
+
+If `type === "plan"`:
+- Read the single SPRINT.md at `{path}/SPRINT.md`
+- Continue to Step 3
+
+## Step 3: Display with Status
+
+For each SPRINT.md:
+
+1. Print frontmatter as YAML block (title, wave, description)
+2. Print body in full
+3. Read `.rihal/state.json` and extract `executions[].plan_id` matching this plan
+4. If found, append:
+   ```
+   Last execution: {timestamp}, {duration_ms}ms, commit {commit_sha}
+   ```
+   If not found: `Status: Not yet executed`
+
+Separate multiple plans with `---\n`
+
+## Success Criteria
+
+- [ ] ID resolves correctly
+- [ ] Full SPRINT.md content displayed (frontmatter + body)
+- [ ] Execution status appended
+- [ ] Multiple plans separated cleanly
+
+## On Error
+
+- ID unresolvable → Show resolve-id error message
+- SPRINT.md missing → "File not found: {path}"
+- state.json corrupt → Omit execution status, continue

package/rihal/workflows/sprint-planning.md

@@ -0,0 +1,166 @@
+# Workflow: rihal:sprint-planning
+
+<purpose>
+Plan the next sprint: compute capacity from velocity history, prioritize stories from phase scope, create SPRINT.md, register sprint + stories in state.json.
+
+Uses rihal-tools.cjs sprint/story state commands for tracking.
+</purpose>
+
+<output_format>
+Open with banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ RIHAL ► PLANNING SPRINT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+TaskCreate: "Load phase scope + velocity", "Curate stories with user", "Register sprint + stories in state", "Write SPRINT.md", "Start sprint".
+Closure: `RIHAL ► SPRINT {NN.S} READY ✓ ({N} stories, {M} points)`
+Next Up: `/rihal:execute .planning/phases/{phase}/SPRINT.md`
+</output_format>
+
+<required_reading>
+@.rihal/references/output-format.md
+</required_reading>
+
+<process>
+## Step 0 — Usage check
+
+If `$ARGUMENTS` contains `--help` or `-h`:
+
+```
+/rihal:sprint-planning [--phase <NN>] [--velocity <points>] [--goal "Sprint goal"]
+```
+
+**Examples:**
+```
+/rihal:sprint-planning
+/rihal:sprint-planning --phase 01 --goal "Auth system MVP"
+/rihal:sprint-planning --velocity 13
+```
+
+STOP — do not proceed.
+
+## Step 1 — Load context
+
+```bash
+STATE=$(node .rihal/bin/rihal-tools.cjs state read)
+VELOCITY=$(node .rihal/bin/rihal-tools.cjs state sprint velocity)
+```
+
+Extract:
+- Current phase from state
+- Velocity history + average from velocity output
+- Phase scope from `.planning/phases/{phase}/SCOPE.md` (if exists)
+
+If no phases in state:
+```
+No phases found. Run /rihal:new-project first to create a roadmap.
+```
+Exit.
+
+## Step 2 — Determine capacity
+
+**If velocity history exists:**
+- Use rolling 3-sprint average as capacity baseline
+- Commit max 80% of average (buffer for interrupts + unknowns)
+
+**If no velocity history (first sprint):**
+- Ask user: "This is your first sprint. How many story points can you commit to? (Typical: 8-13 for solo dev + AI)"
+- Or use `--velocity` flag
+
+Store as `velocity_target`.
+
+## Step 3 — Curate stories
+
+Read phase scope (SCOPE.md, REQUIREMENTS.md, or ROADMAP.md phase section).
+
+For each requirement/feature in scope:
+1. Break into stories: `As a [user], I want [action] so that [outcome]`
+2. Estimate: XS(1) / S(2) / M(3) / L(5) / XL(8)
+3. Stories > 8 points → split immediately
+4. Prioritize: must-have first, nice-to-have last
+
+Present story table to user:
+
+```markdown
+| # | Story | Points | Priority | Acceptance |
+|---|-------|--------|----------|------------|
+| 1 | Login endpoint | 5 | must | Returns JWT on valid creds |
+| 2 | Register endpoint | 3 | must | Creates user, hashes password |
+| 3 | Rate limiting | 2 | should | 429 after 10 req/min |
+```
+
+**Capacity check:** Total committed points <= velocity_target.
+If over: "We're at {N} points vs {target} capacity. Move story #{X} to next sprint?"
+
+Wait for user confirmation before proceeding.
+
+## Step 4 — Create sprint
+
+After user confirms stories:
+
+```bash
+# Register sprint in state
+node .rihal/bin/rihal-tools.cjs state sprint add \
+  --phase "{phase_name}" \
+  --goal "{sprint_goal}" \
+  --velocity {velocity_target}
+
+# Register each story
+node .rihal/bin/rihal-tools.cjs state story add \
+  --title "{story_title}" \
+  --points {points}
+```
+
+Write SPRINT.md to `.planning/phases/{phase_slug}/SPRINT.md` using the template at `rihal/templates/sprint.md`. Fill in:
+- Sprint goal
+- Stories table (from user-confirmed list)
+- Capacity section (velocity target, average, buffer)
+- Dependencies
+- Risks (if identified during estimation)
+
+## Step 5 — Start sprint
+
+```bash
+node .rihal/bin/rihal-tools.cjs state sprint start
+```
+
+## Step 6 — Summary
+
+```
+Sprint {sprint_id} created and started.
+
+Goal: {sprint_goal}
+Stories: {count} ({total_points} points)
+Capacity: {velocity_target} points ({buffer}% buffer)
+
+Next:
+  /rihal:execute .planning/phases/{phase}/SPRINT.md   ← execute the sprint
+  /rihal:sprint-status                                ← check progress anytime
+```
+
+## Output Format
+
+- SPRINT.md at `.planning/phases/{phase_slug}/SPRINT.md`
+- Sprint + stories registered in `.rihal/state.json`
+- Console summary with next-step commands
+
+## Examples
+
+### Happy Path
+**Input:** `/rihal:sprint-planning --phase 01 --goal "Auth MVP"`
+**Expected:** Load phase scope, estimate stories, present table, confirm, create SPRINT.md + register in state, start sprint.
+
+### Edge Case: Over capacity
+**Input:** 15 points of stories but velocity avg is 10
+**Expected:** Flag over-commitment, suggest deferring lowest-priority story.
+
+### Edge Case: No scope
+**Input:** Phase has no SCOPE.md or requirements
+**Expected:** "No scope found for this phase. Run /rihal:new-project or write a SCOPE.md first."
+
+### Negative Test
+**Input:** `/rihal:sprint-planning` with no phases in state
+**Expected:** Graceful exit suggesting /rihal:new-project.
+
+</process>

package/rihal/workflows/sprint-status.md

@@ -0,0 +1,124 @@
+# Workflow: rihal:sprint-status
+
+<purpose>
+Display current sprint progress: stories by status, points done vs remaining, velocity comparison, and burndown. Quick situational awareness without starting execution.
+</purpose>
+
+<output_format>
+Open with banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ RIHAL ► SPRINT {NN.S} STATUS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+Use status symbols (✓ done, ◆ in_progress, ○ todo) in story board.
+Show sprint progress bar: `Sprint 01.1: 8/13 points ████████░░░░░ 61%`.
+Show velocity line: `Velocity: avg 11 pts (last 3 sprints)`.
+End with Next Up routing based on sprint state.
+</output_format>
+
+<required_reading>
+@.rihal/references/output-format.md
+</required_reading>
+
+<process>
+## Step 0 — Usage check
+
+If `$ARGUMENTS` contains `--help` or `-h`:
+
+```
+/rihal:sprint-status [--sprint <NN.S>]
+```
+
+**Examples:**
+```
+/rihal:sprint-status              # current sprint
+/rihal:sprint-status --sprint 01.2
+```
+
+STOP — do not proceed.
+
+## Step 1 — Load sprint data
+
+```bash
+SPRINT_STATUS=$(node .rihal/bin/rihal-tools.cjs state sprint status)
+VELOCITY=$(node .rihal/bin/rihal-tools.cjs state sprint velocity)
+STORIES=$(node .rihal/bin/rihal-tools.cjs state story list)
+```
+
+If no current sprint:
+```
+No active sprint. Run /rihal:sprint-planning to create one.
+```
+Exit.
+
+## Step 2 — Display
+
+Print a compact status board:
+
+```
+Sprint {sprint_id} — {goal}
+Status: {active|planned|completed}
+
+Stories                         Points
+  todo:        {n}              done:      {done_pts}/{total_pts}
+  in_progress: {n}              remaining: {rem_pts}
+  review:      {n}              target:    {velocity_target}
+  done:        {n}
+  ────────────                  ────────────
+  total:       {total}          progress:  {pct}%
+
+Velocity
+  This sprint: {velocity_actual or "in progress"}
+  Average:     {avg_velocity} (last {sprint_count} sprints)
+  Trend:       {up/down/stable}
+```
+
+## Step 3 — Story board
+
+Show stories grouped by status:
+
+```
+IN PROGRESS
+  {id} {title} ({points}pts)
+
+TODO
+  {id} {title} ({points}pts)
+
+DONE
+  {id} {title} ({points}pts) ✓
+
+REVIEW
+  {id} {title} ({points}pts)
+```
+
+## Step 4 — Recommendations
+
+Based on data, suggest next action:
+
+- **All stories done:** "Sprint ready to close. Run `/rihal:sprint-planning` for next sprint."
+- **In progress stories exist:** "Continue executing. Run `/rihal:execute` to pick up next story."
+- **Over capacity (committed > velocity avg):** "Over-committed by {N} points. Consider deferring lowest-priority story."
+- **No stories moved today:** "No progress since last check. Blockers?"
+
+## Output Format
+
+- Compact terminal-friendly status board (no markdown tables, just aligned text)
+- Story board grouped by status
+- One-line recommendation with actionable command
+
+## Examples
+
+### Happy Path
+**Input:** `/rihal:sprint-status`
+**Expected:** Board showing 3 done / 1 in_progress / 2 todo, 8/13 points, velocity trend stable.
+
+### Edge Case: No sprint
+**Input:** `/rihal:sprint-status` (no active sprint)
+**Expected:** "No active sprint" + suggestion to run sprint-planning.
+
+### Negative Test
+**Input:** `/rihal:sprint-status --sprint 99.9`
+**Expected:** "Sprint 99.9 not found."
+
+</process>