@hanzlaa/rcode 2.1.0

package/rihal/workflows/quick.md

@@ -0,0 +1,105 @@
+<purpose>
+Execute a trivial task inline without subagent overhead. No SPRINT.md, no Task spawning,
+no research, no plan checking. Just: understand → do → commit → log.
+
+For tasks like: fix a typo, update a config value, add a missing import, rename a
+variable, commit uncommitted work, add a .gitignore entry, bump a version number.
+
+Use /rihal:quick for anything that needs multi-step planning or research.
+</purpose>
+
+<process>
+
+<step name="parse_task">
+Parse `$ARGUMENTS` for the task description.
+
+If empty, ask:
+```
+What's the quick fix? (one sentence)
+```
+
+Store as `$TASK`.
+</step>
+
+<step name="scope_check">
+**Before doing anything, verify this is actually trivial.**
+
+A task is trivial if it can be completed in:
+- ≤ 3 file edits
+- ≤ 1 minute of work
+- No new dependencies or architecture changes
+- No research needed
+
+If the task seems non-trivial (multi-file refactor, new feature, needs research),
+say:
+
+```
+This looks like it needs planning. Use /rihal:quick instead:
+  /rihal:quick "{task description}"
+```
+
+And stop.
+</step>
+
+<step name="execute_inline">
+Do the work directly:
+
+1. Read the relevant file(s)
+2. Make the change(s)
+3. Verify the change works (run existing tests if applicable, or do a quick sanity check)
+
+**No SPRINT.md.** Just do it.
+</step>
+
+<step name="commit">
+Commit the change atomically:
+
+```bash
+git add -A
+git commit -m "fix: {concise description of what changed}"
+```
+
+Use conventional commit format: `fix:`, `feat:`, `docs:`, `chore:`, `refactor:` as appropriate.
+</step>
+
+<step name="log_to_state">
+If `.planning/STATE.md` exists, append to the "Quick Tasks Completed" table.
+If the table doesn't exist, skip this step silently.
+
+```bash
+# Check if STATE.md has quick tasks table
+if grep -q "Quick Tasks Completed" .planning/STATE.md 2>/dev/null; then
+  # Append entry — workflow handles the format
+  echo "| $(date +%Y-%m-%d) | fast | $TASK | ✅ |" >> .planning/STATE.md
+fi
+```
+</step>
+
+<step name="done">
+Report completion:
+
+```
+✅ Done: {what was changed}
+   Commit: {short hash}
+   Files: {list of changed files}
+```
+
+No next-step suggestions. No workflow routing. Just done.
+</step>
+
+</process>
+
+<guardrails>
+- NEVER spawn a Task/subagent — this runs inline
+- NEVER create SPRINT.md or SUMMARY.md files
+- NEVER run research or plan-checking
+- If the task takes more than 3 file edits, STOP and redirect to /rihal:quick
+- If you're unsure how to implement it, STOP and redirect to /rihal:quick
+</guardrails>
+
+<success_criteria>
+- [ ] Task completed in current context (no subagents)
+- [ ] Atomic git commit with conventional message
+- [ ] STATE.md updated if it exists
+- [ ] Total operation under 2 minutes wall time
+</success_criteria>

package/rihal/workflows/remove-phase.md

@@ -0,0 +1,155 @@
+<purpose>
+Remove an unstarted future phase from the project roadmap, delete its directory, renumber all subsequent phases to maintain a clean linear sequence, and commit the change. The git commit serves as the historical record of removal.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="parse_arguments">
+Parse the command arguments:
+- Argument is the phase number to remove (integer or decimal)
+- Example: `/rihal:remove-phase 17` → phase = 17
+- Example: `/rihal:remove-phase 16.1` → phase = 16.1
+
+If no argument provided:
+
+```
+ERROR: Phase number required
+Usage: /rihal:remove-phase <phase-number>
+Example: /rihal:remove-phase 17
+```
+
+Exit.
+</step>
+
+<step name="init_context">
+Load phase operation context:
+
+```bash
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${target}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Extract: `phase_found`, `phase_dir`, `phase_number`, `commit_docs`, `roadmap_exists`.
+
+Also read STATE.md and ROADMAP.md content for parsing current position.
+</step>
+
+<step name="validate_future_phase">
+Verify the phase is a future phase (not started):
+
+1. Compare target phase to current phase from STATE.md
+2. Target must be > current phase number
+
+If target <= current phase:
+
+```
+ERROR: Cannot remove Phase {target}
+
+Only future phases can be removed:
+- Current phase: {current}
+- Phase {target} is current or completed
+
+To abandon current work, use /rihal:pause-work instead.
+```
+
+Exit.
+</step>
+
+<step name="confirm_removal">
+Present removal summary and confirm:
+
+```
+Removing Phase {target}: {Name}
+
+This will:
+- Delete: .planning/phases/{target}-{slug}/
+- Renumber all subsequent phases
+- Update: ROADMAP.md, STATE.md
+
+Proceed? (y/n)
+```
+
+Wait for confirmation.
+</step>
+
+<step name="execute_removal">
+**Delegate the entire removal operation to rihal-tools:**
+
+```bash
+RESULT=$(node ".rihal/bin/rihal-tools.cjs" phase remove "${target}")
+```
+
+If the phase has executed plans (SUMMARY.md files), rihal-tools will error. Use `--force` only if the user confirms:
+
+```bash
+RESULT=$(node ".rihal/bin/rihal-tools.cjs" phase remove "${target}" --force)
+```
+
+The CLI handles:
+- Deleting the phase directory
+- Renumbering all subsequent directories (in reverse order to avoid conflicts)
+- Renaming all files inside renumbered directories (SPRINT.md, SUMMARY.md, etc.)
+- Updating ROADMAP.md (removing section, renumbering all phase references, updating dependencies)
+- Updating STATE.md (decrementing phase count)
+
+Extract from result: `removed`, `directory_deleted`, `renamed_directories`, `renamed_files`, `roadmap_updated`, `state_updated`.
+</step>
+
+<step name="commit">
+Stage and commit the removal:
+
+```bash
+node ".rihal/bin/rihal-tools.cjs" commit "chore: remove phase {target} ({original-phase-name})" --files .planning/
+```
+
+The commit message preserves the historical record of what was removed.
+</step>
+
+<step name="completion">
+Present completion summary:
+
+```
+Phase {target} ({original-name}) removed.
+
+Changes:
+- Deleted: .planning/phases/{target}-{slug}/
+- Renumbered: {N} directories and {M} files
+- Updated: ROADMAP.md, STATE.md
+- Committed: chore: remove phase {target} ({original-name})
+
+---
+
+## What's Next
+
+Would you like to:
+- `/rihal:progress` — see updated roadmap status
+- Continue with current phase
+- Review roadmap
+
+---
+```
+</step>
+
+</process>
+
+<anti_patterns>
+
+- Don't remove completed phases (have SUMMARY.md files) without --force
+- Don't remove current or past phases
+- Don't manually renumber — use `rihal-tools phase remove` which handles all renumbering
+- Don't add "removed phase" notes to STATE.md — git commit is the record
+- Don't modify completed phase directories
+</anti_patterns>
+
+<success_criteria>
+Phase removal is complete when:
+
+- [ ] Target phase validated as future/unstarted
+- [ ] `rihal-tools phase remove` executed successfully
+- [ ] Changes committed with descriptive message
+- [ ] User informed of changes
+</success_criteria>

package/rihal/workflows/remove-workspace.md

@@ -0,0 +1,158 @@
+# Workflow: rihal:remove-workspace
+
+<purpose>
+Remove a workspace and clean up all its artifacts. This is destructive — deleted workspaces cannot be recovered unless `--archive` flag is used. Use when a parallel work stream is complete or abandoned.
+</purpose>
+
+## Step 0 — Usage check
+
+If `$ARGUMENTS` is empty or only `--help` or `-h`:
+
+```
+/rihal:remove-workspace <workspace-name> [--archive] [--force]
+```
+
+**Examples:**
+```
+/rihal:remove-workspace Bug Fix Sprint
+/rihal:remove-workspace Emergency --force
+/rihal:remove-workspace Old Work --archive
+```
+
+STOP — do not proceed.
+
+## Step 1 — Parse arguments
+
+Extract from `$ARGUMENTS`:
+- `$WORKSPACE_NAME` — the workspace to remove
+- `--archive` flag → copy to `.rihal/workspace-archive/` before deleting
+- `--force` flag → skip confirmation prompt
+
+If `$WORKSPACE_NAME` is empty, ask:
+
+```
+AskUserQuestion(
+  header: "Remove Workspace",
+  question: "Which workspace? (list: /rihal:list-workspaces)"
+)
+```
+
+## Step 2 — Locate workspace
+
+Read `.rihal/workspaces.csv` and find the row matching `$WORKSPACE_NAME`.
+
+Extract `$WORKSPACE_PATH` from the CSV row.
+
+If not found:
+
+```
+⚠ Workspace not found: {WORKSPACE_NAME}
+  List workspaces: /rihal:list-workspaces
+```
+
+STOP.
+
+Verify the directory exists:
+
+```bash
+if [[ ! -d "$WORKSPACE_PATH" ]]; then
+  echo "⚠ Workspace directory not found: $WORKSPACE_PATH"
+  exit 1
+fi
+```
+
+## Step 3 — Confirm deletion (unless --force)
+
+If NOT `--force` flag:
+
+```
+About to delete workspace: {WORKSPACE_NAME}
+  Location: {WORKSPACE_PATH}
+  
+This cannot be undone. Continue? (y/N)
+
+AskUserQuestion(
+  header: "Confirm Deletion",
+  question: "Delete {WORKSPACE_NAME}?"
+)
+```
+
+If user says no, STOP.
+
+## Step 4 — Archive workspace (if requested)
+
+If `--archive` flag:
+
+```bash
+ARCHIVE_BASE=".rihal/workspace-archive"
+mkdir -p "$ARCHIVE_BASE"
+ARCHIVE_PATH="$ARCHIVE_BASE/$(basename $WORKSPACE_PATH)-$(date +%s)"
+cp -r "$WORKSPACE_PATH" "$ARCHIVE_PATH"
+echo "✓ Workspace archived: $ARCHIVE_PATH"
+```
+
+## Step 5 — Delete workspace directory
+
+```bash
+rm -rf "$WORKSPACE_PATH"
+```
+
+Verify deletion:
+
+```bash
+if [[ ! -d "$WORKSPACE_PATH" ]]; then
+  echo "✓ Workspace deleted"
+else
+  echo "⚠ Failed to delete workspace. Check permissions."
+  exit 1
+fi
+```
+
+## Step 6 — Update workspaces registry
+
+Remove the row from `.rihal/workspaces.csv`:
+
+```bash
+grep -v "^$WORKSPACE_NAME," ".rihal/workspaces.csv" > ".rihal/workspaces.csv.tmp"
+mv ".rihal/workspaces.csv.tmp" ".rihal/workspaces.csv"
+```
+
+## Step 7 — Report
+
+Print:
+
+```
+✓ Workspace removed: {WORKSPACE_NAME}
+  [Archive location: {ARCHIVE_PATH}] (if --archive)
+  
+Remaining workspaces: {count}
+List: /rihal:list-workspaces
+```
+
+## Success Criteria
+
+- Workspace directory deleted
+- Workspace removed from registry (workspaces.csv)
+- If --archive: backed up to archive location
+- User sees confirmation message
+
+## On Error
+
+If directory deletion fails:
+
+```
+⚠ Failed to delete workspace directory. Check:
+  - File permissions
+  - Open file handles
+  - Disk space
+  
+Path: {WORKSPACE_PATH}
+```
+
+If registry update fails:
+
+```
+⚠ Failed to update workspace registry. Manual cleanup:
+  rm -rf {WORKSPACE_PATH}
+  Edit: .rihal/workspaces.csv (remove the {WORKSPACE_NAME} line)
+```

package/rihal/workflows/replay.md

@@ -0,0 +1,160 @@
+# Workflow: rihal:replay
+
+<purpose>
+Re-run a past council session with the same question for a fresh panel round. Useful when:
+
+- The first council was inconclusive and you want a second pass
+- Facts or context have shifted and the original question deserves re-evaluation
+- You want to see how a different panel composition answers the same question
+
+This is NOT `--resume` (which asks a follow-up question with prior context). Replay re-asks the original question from a clean slate, then links the new artifact back to the original for comparison.
+</purpose>
+
+<output_format>
+Open with banner:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ RIHAL ► REPLAY
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+End with a single-line redirect (per `command-redirect-format.md`) so the user copy-pastes the resulting `/rihal:council` invocation.
+</output_format>
+
+<required_reading>
+@.rihal/references/command-redirect-format.md
+@.rihal/references/output-format.md
+</required_reading>
+
+<process>
+## Step 0 — Usage check
+
+If `$ARGUMENTS` is empty or contains only `--help` / `-h`:
+
+```
+/rihal:replay <session-path-or-slug> [--agents a,b,c]
+
+  <session-path-or-slug>   Full path to .planning/council-sessions/council-YYYY-MM-DD-<slug>.md
+                           OR just the slug (e.g. "should-i-ship-v2") — the first matching
+                           file, newest-first, will be used.
+  --agents a,b,c           Override the panel for the replay (otherwise council auto-selects)
+```
+
+STOP — do not proceed.
+
+## Step 1 — Resolve the session file
+
+Parse `$ARGUMENTS` — first positional token is the session identifier, remaining tokens pass through.
+
+```bash
+SESSIONS_DIR=".planning/council-sessions"
+ARG="${1}"
+
+# Full path: use as-is
+if [ -f "$ARG" ]; then
+  SESSION_FILE="$ARG"
+# Slug: find newest matching file
+elif ls "${SESSIONS_DIR}" >/dev/null 2>&1; then
+  SESSION_FILE=$(ls -t "${SESSIONS_DIR}"/council-*"${ARG}"*.md 2>/dev/null | head -1)
+fi
+
+if [ -z "$SESSION_FILE" ] || [ ! -f "$SESSION_FILE" ]; then
+  echo "No session matched \"$ARG\". Available:"
+  ls -t "${SESSIONS_DIR}"/council-*.md 2>/dev/null | head -10
+  exit 0
+fi
+```
+
+If no sessions directory exists at all:
+
+```
+No council sessions on disk yet. Run /rihal:council "<question>" to create the first one.
+```
+
+STOP.
+
+## Step 2 — Extract the original question
+
+Read `SESSION_FILE` and pull the text block under the `## Question` heading (until the next `##` heading or EOF). Trim leading/trailing whitespace. Strip surrounding blank lines.
+
+```bash
+QUESTION=$(awk '/^## Question$/{flag=1;next} /^## /{flag=0} flag' "$SESSION_FILE" | sed '/./,$!d' | awk 'NF{found=1} found')
+```
+
+If the extracted question is empty:
+
+```
+Could not extract "## Question" heading from $SESSION_FILE. The artifact may be malformed. Open it and copy the question manually:
+
+/rihal:council <question>
+```
+
+STOP.
+
+Also capture the original slug for the replay annotation:
+
+```bash
+ORIGINAL_SLUG=$(basename "$SESSION_FILE" .md | sed 's/^council-[0-9-]*-//')
+ORIGINAL_DATE=$(basename "$SESSION_FILE" .md | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}' | head -1)
+```
+
+## Step 3 — Show the replay preview
+
+Print a short summary so the user can confirm before the redirect:
+
+```
+Replaying session: {SESSION_FILE}
+Original date:    {ORIGINAL_DATE}
+Original slug:    {ORIGINAL_SLUG}
+
+Question to re-ask:
+  {QUESTION}
+```
+
+If `--agents` was passed, also print:
+```
+Panel override:   {agents_csv}
+```
+
+## Step 4 — Emit the redirect
+
+Per `command-redirect-format.md`, one line, copy-pastable:
+
+```
+Re-running the council with a fresh panel on the original question.
+
+Copy-paste this:
+
+/rihal:council {QUESTION}{agents_suffix}
+```
+
+Where `{agents_suffix}` is `  --agents=a,b,c` if `--agents` was passed, else empty.
+
+## Step 5 — Record the replay intent
+
+Append a lightweight replay record so history is traceable even before council runs:
+
+```bash
+node .rihal/bin/rihal-tools.cjs state add-decision \
+  "Replay of council session ${ORIGINAL_SLUG} (${ORIGINAL_DATE}) — re-asking: ${QUESTION:0:80}" \
+  2>/dev/null || true
+```
+
+The subsequent `/rihal:council` run will attach its own artifact; pairing the two by date + slug lets `/rihal:decisions` and state readers show the replay chain.
+</process>
+
+## Success Criteria
+
+- Slug argument resolves to the newest matching session file
+- Full path argument works as-is
+- `## Question` text is extracted verbatim, including any multi-line body
+- Malformed or empty question artifacts produce a clear error (not a crash)
+- Redirect is a single line, in the copy-paste format required by the command-redirect reference
+- `--agents` override passes through to the council invocation unchanged
+
+## On Error
+
+- Missing session directory → tell the user to run `/rihal:council` first
+- Slug ambiguity → list the top 10 newest matches so the user can paste a fuller path
+- Extraction returns empty → print the path and ask the user to copy the question manually

package/rihal/workflows/rerun.md

@@ -0,0 +1,77 @@
+<purpose>
+Re-execute a previously completed phase or plan. Resets its state to pending and re-runs the execute workflow, creating new commits (not amending old ones).
+</purpose>
+
+## Step 0: Usage Check
+
+Verify argument: `/rihal:rerun <phase-id|plan-id>`
+
+Examples:
+- `/rihal:rerun 03` — re-run all plans in phase 3
+- `/rihal:rerun 03-02` — re-run specific plan
+
+If empty: `Usage: /rihal:rerun <phase-id|plan-id> (e.g., /rihal:rerun 03 or /rihal:rerun 03-02)`
+
+## Step 0.5: Detect Target via Resolve
+
+Run: `node .rihal/bin/rihal-tools.cjs state resolve-id "$ARGUMENTS"`
+
+If type === "unknown": Return error `ID not found: $ARGUMENTS`
+
+Store: `target.type` (phase or plan) and `target.id`
+
+## Step 1: Confirm via AskUserQuestion
+
+Ask user:
+
+```
+Re-run {target.type} {target.id}?
+
+This will:
+  (a) Reset {target.type} tasks to status: pending in state.json
+  (b) Re-execute all plans in {target.type}
+  (c) New commits will be created (not amendments to existing commits)
+
+Proceed? (yes/no)
+```
+
+If user says "no" or does not confirm: Stop, return `Cancelled.`
+
+## Step 2: Mark as Pending in state.json
+
+Read `.rihal/state.json`
+
+If `target.type === "phase"`:
+- Find all `executions[].plan_id` in this phase
+- Set `executions[].status = "pending"` for each
+- Update `executions[].reset_at = ISO_TIMESTAMP`
+
+If `target.type === "plan"`:
+- Find `executions[].plan_id === target.id`
+- Set `status = "pending"`
+- Set `reset_at = ISO_TIMESTAMP`
+
+Write updated state.json back
+
+## Step 3: Invoke Execute
+
+Route to `/rihal:execute-phase {target.id}`
+
+The executor will:
+- See status=pending in state.json
+- Re-run all tasks
+- Create new commits
+
+## Success Criteria
+
+- [ ] ID resolves
+- [ ] User confirms
+- [ ] state.json updated with pending status
+- [ ] Execute workflow triggered
+- [ ] New commits logged (not amendments)
+
+## On Error
+
+- ID unresolvable → Show error
+- state.json corrupt → "Cannot read state. Check .rihal/state.json"
+- User declines → Stop gracefully