@hanzlaa/rcode 3.6.15 → 4.0.0

package/rihal/workflows/help.md

@@ -1,343 +0,0 @@
-<purpose>
-Display the Rihal command reference at the requested tier. Output ONLY the tier section. Do NOT add project-specific analysis, git status, next-step suggestions, or any commentary beyond the reference.
-</purpose>
-
-## Step 0 — Parse arguments
-
-Read `$ARGUMENTS` and resolve to one of: `basic`, `intermediate`, `advanced`, `all`.
-
-| Input | Tier shown |
-|-------|------------|
-| (empty) or `basic` or `1` | **TIER 1 — Basic** |
-| `intermediate` or `int` or `2` | **TIER 2 — Intermediate** |
-| `advanced` or `adv` or `3` | **TIER 3 — Advanced** |
-| `all` or `full` | **All three tiers in sequence** |
-| `--help` or `-h` | Show usage block, then exit |
-
-Usage block:
-
-```
-Usage: /rihal-help [basic|intermediate|advanced|all]
-
-  basic         Show the 8 essentials (default)
-  intermediate  Show real-project ops (council, review, ship, capture)
-  advanced      Show power tools (audits, workspaces, council variants, etc.)
-  all           Show everything
-```
-
-## Step 1 — Render the requested tier
-
-Output the matching `<tier-N>` block below verbatim. For `all`, output all three blocks separated by `---`.
-
----
-
-<tier-1>
-# Rihal — Tier 1 (Basic)
-
-> **Rihal** is council-driven project automation built for solo agentic work in Claude Code.
-> Tier 1 is everything you need to ship a small project end-to-end. **8 commands.**
-
-## Not installed yet?
-
-```bash
-npx @hanzlaa/rcode install    # install into current project
-```
-
-Run this once from your project root. Then open a new Claude Code session and use the commands below.
-Need help? See `docs/getting-started.md` or run `/rihal-help` after install.
-
-## The loop
-
-```
-init → new-project → plan → execute → next → status → ship
-```
-
-## Commands
-
-| Command | What it does |
-|---------|--------------|
-| `/rihal-init` | First-time setup in this repo. Detects state, asks config questions, writes `.rihal/RIHLA.md`. Run once per project. |
-| `/rihal-new-project` | Take an idea to a planned roadmap. Questioning → optional research → REQUIREMENTS → ROADMAP. |
-| `/rihal-plan <phase>` | Create executable plans for a phase. Produces `SPRINT.md` files. |
-| `/rihal-execute <phase>` | Run all plans in a phase in dependency waves. Updates STATE on completion. |
-| `/rihal-next` | Auto-route to the next logical step based on project state. Zero friction. |
-| `/rihal-status` | Where am I — current phase, plan progress, recent decisions, blockers. |
-| `/rihal-progress` | Visual progress + intelligent suggestion for next action. |
-| `/rihal-help [tier]` | This reference. Add `intermediate`, `advanced`, or `all` for more. |
-
-## Minimal happy path
-
-```
-/rihal-init
-/rihal-new-project
-/rihal-plan 1
-/rihal-execute 1
-/rihal-next
-```
-
-## Files Rihal creates
-
-```
-.planning/
-├── PROJECT.md            # vision
-├── REQUIREMENTS.md       # scoped requirements
-├── ROADMAP.md            # phase breakdown
-├── STATE.md              # project memory
-└── phases/
-    └── 01-foundation/
-        ├── 01-1-SPRINT.md   # the plan
-        └── 01-01-SUMMARY.md  # what got done
-```
-
-**Done with Tier 1?** → `/rihal-help intermediate` for council, review, ship, and capture.
-</tier-1>
-
----
-
-<tier-2>
-# Rihal — Tier 2 (Intermediate)
-
-> Real-project ops: strategic input, quality gates, capture, and session continuity.
-> Assumes you know Tier 1. **~18 commands.**
-
-## Strategy & input
-
-| Command | When to use |
-|---------|-------------|
-| `/rihal-council <question>` | Strategic decision needing multiple perspectives — 3-5 agents debate in parallel, 2 rounds with cross-talk. |
-| `/rihal-discuss <agent> <q>` | Quick single-agent sync — fast, conversational, no artifact. |
-| `/rihal-discuss-phase <n>` | Gather context through adaptive questioning before planning. Produces CONTEXT.md. |
-| `/rihal-explore <topic>` | Socratic ideation — think through ideas before committing to plans. |
-| `/rihal-do <description>` | Smart router — natural language in, picks the right `/rihal-*` command. |
-
-## Quality & shipping
-
-| Command | When to use |
-|---------|-------------|
-| `/rihal-code-review` | Adversarial code review of changed files — bugs, security, style. |
-| `/rihal-code-review-fix` | Auto-apply fixes from a code-review report. |
-| `/rihal-verify-phase <n>` | Goal-backward audit — does the codebase deliver what the phase promised? |
-| `/rihal-verify-work` | Conversational UAT against acceptance criteria. |
-| `/rihal-ship [phase] [--draft]` | Push feature branch + open PR with auto-generated body (goal, changes, requirements, verification status). Use AFTER `/rihal-verify-phase` passes. **Not for npm publish or tagging releases.** |
-
-## Phase & plan management
-
-| Command | When to use |
-|---------|-------------|
-| `/rihal-show <id>` | Print a phase or plan in full with execution status. |
-| `/rihal-phase <name> [--insert \| --remove]` | **Unified phase CRUD.** Default: append next integer phase. `--insert <parent>` slots a decimal phase. `--remove <id>` deletes an unstarted future phase. |
-| `/rihal-add-phase <name>` | Alias for `/rihal-phase <name>`. |
-| `/rihal-insert-phase <after> <name>` | Alias for `/rihal-phase --insert <after> <name>`. |
-| `/rihal-remove-phase <n>` | Alias for `/rihal-phase --remove <n>`. |
-| `/rihal-quick [flags]` | Small ad-hoc tasks with Rihal guarantees but skip optional agents. Flags: `--discuss`, `--research`, `--full`. |
-| `/rihal-fast "<task>"` | Trivial inline task — typo, gitignore tweak, etc. No subagents, ≤3 file edits. *Not yet implemented (#482-B).* |
-
-## Capture & session continuity
-
-| Command | When to use |
-|---------|-------------|
-| `/rihal-capture "<text>" [--note \| --seed \| --list]` | **Unified capture.** Default: todo. `--note` for passive observation. `--seed` for forward-looking idea with trigger conditions. `--list` to show pending todos. |
-| `/rihal-add-todo [desc]` | Alias for `/rihal-capture` (default mode). |
-| `/rihal-note "<text>"` | Alias for `/rihal-capture --note`. |
-| `/rihal-plant-seed "<idea>"` | Alias for `/rihal-capture --seed`. |
-| `/rihal-check-todos [area]` | Alias for `/rihal-capture --list`. |
-| `/rihal-resume-work` | Restore project context after a break. |
-| `/rihal-pause-work` | Create HANDOFF.json and continue-here.md before stopping mid-phase. |
-| `/rihal-session-report` | Work summary, decisions, open blockers from this session. |
-
-**Done with Tier 2?** → `/rihal-help advanced` for audits, workspaces, milestone ops, and power variants.
-</tier-2>
-
----
-
-<tier-3>
-# Rihal — Tier 3 (Advanced)
-
-> Power tools: milestone ops, parallel workspaces, audits, council variants, and rare ops.
-> Assumes Tier 1 + 2. Use these when you know exactly what you need.
-
-## Milestone lifecycle
-
-| Command | Use |
-|---------|-----|
-| `/rihal-new-milestone` | Start the next milestone — initializes ROADMAP, REQUIREMENTS, STATE. |
-| `/rihal-complete-milestone <ver>` | Archive milestone → move to `.planning/milestones/`. |
-| `/rihal-milestone-summary` | Human-readable summary of all phases, decisions, outcomes. |
-| `/rihal-audit-milestone` | Cross-phase audit — verify completion against original goals. |
-| `/rihal-plan-milestone-gaps` | Create phases to close gaps from the audit. |
-| `/rihal-cleanup` | Archive accumulated phase dirs from completed milestones. |
-
-## Workspaces & parallel work
-
-| Command | Use |
-|---------|-----|
-| `/rihal-new-workspace` | Isolated workspace with separate ROADMAP/STATE for parallel work. |
-| `/rihal-list-workspaces` | List all active workspaces. |
-| `/rihal-remove-workspace` | Delete a workspace and clean up artifacts. |
-| `/rihal-workstream` | Manage parallel workstreams (milestone tracks). |
-
-## Audits & specialty review
-
-| Command | Use |
-|---------|-----|
-| `/rihal-secure-phase <n>` | Retroactively verify threat mitigations exist in code. |
-| `/rihal-validate-phase <n>` | Audit Nyquist validation gaps for a completed phase. |
-| `/rihal-add-tests <n>` | Generate unit + E2E tests based on SPRINT/SUMMARY/CONTEXT. |
-| `/rihal-audit-uat` | Cross-phase audit of all outstanding UAT items. |
-| `/rihal-audit-fix` | Autonomous audit-to-fix pipeline — find, classify, fix, test, commit. |
-| `/rihal-code-review --karpathy` | Audit recent code against Karpathy's 4 LLM coding principles. |
-| `/rihal-karpathy-audit` | Full Karpathy engineering principles audit across the codebase. |
-| `/rihal-check-implementation-readiness` | Verify a feature is fully ready to implement before writing code. |
-| `/rihal-review-edge-case-hunter` | Hunt for edge cases and boundary conditions before execution. |
-| `/rihal-diagnose-issues` | Triage and diagnose systemic issues before a debug session. |
-| `/rihal-ui-phase <n>` | Generate UI design contract (UI-SPEC.md) for frontend phases. |
-| `/rihal-ui-review` | Retroactive 6-pillar visual audit of completed UI work. |
-| `/rihal-code-review --attack` | Hostile-perspective report — vulnerabilities, race conditions, abuse. |
-| `/rihal-code-review --edge-cases` | Enumerate edge cases by category and severity. |
-| `/rihal-review` | Cross-AI peer review — invoke external AI CLIs to review plans. |
-
-## Council variants & strategy power tools
-
-| Command | Use |
-|---------|-----|
-| `/rihal-discuss-phase --power` | Bulk question generation with async UI for context-heavy phases. |
-| `/rihal-discuss-phase-power` | Standalone deep-dive phase discussion with full research + assumptions. |
-| `/rihal-chain <preset> <topic>` | Sequential agent pipeline (research → scope → build), typed artifacts. |
-| `/rihal-brainstorm` | Guided brainstorming — pick a method, generate ideas systematically. |
-| `/rihal-why <decision>` | Explain reasoning behind a decision, classification, or panel pick. |
-
-## Document, scaffold, integrate
-
-| Command | Use |
-|---------|-----|
-| `/rihal-map-codebase` | Brownfield: parallel Explore agents → 7 codebase docs. |
-| `/rihal-scan` | Rapid codebase assessment — lighter than map-codebase. |
-| `/rihal-document-project` | Audit missing/stale docs, file SPRINT tasks for each gap. |
-| `/rihal-docs-update` | Generate or update docs verified against codebase. |
-| `/rihal-install <module>` | Install a Rihal capability bundle into the project. |
-| `/rihal-enable-hooks` | Install optional Rihal hooks into `.claude/settings.json`. |
-| `/rihal-scaffold-project` | Scaffold a new project from the official Rihal template. |
-| `/rihal-bootstrap` | Bootstrap repo with Vercel-linked resources and integrations. *Not yet implemented (#481).* |
-
-## Story-level epics workflow
-
-| Command | Use |
-|---------|-----|
-| `/rihal-create-prd` | Create a PRD from scratch through guided facilitation. |
-| `/rihal-edit-prd` | Update an existing PRD with revisions or clarifications. |
-| `/rihal-validate-prd` | Validate an existing PRD for completeness and consistency. |
-| `/rihal-create-epics-and-stories` | Parse a PRD into numbered epic + story files. |
-| `/rihal-create-story` | Prepare a dev-ready STORY.md with full implementation context. |
-| `/rihal-dev-story <file>` | Execute an approved STORY by writing tests + code per AC. |
-| (internal) `check-implementation-readiness` | Guard called by `/rihal-plan` and `/rihal-execute` to verify PRD + architecture aligned before build. |
-| `/rihal-create-architecture` | Write an Architecture Decision Record (ADR). |
-| `/rihal-correct-course` | Course-correct mid-sprint when major change is discovered. |
-| `/rihal-sprint-planning` | Compute capacity, prioritize stories, create SPRINT.md. |
-| `/rihal-sprint-status` | Sprint progress — stories, points, velocity, burndown. |
-| `/rihal-list-plans` | Table of every SPRINT.md across phases — goal, stories, points, state. |
-| `/rihal-decisions` | Browse decisions across every Rihal project (~/.rihal/decisions.jsonl). |
-| `/rihal-replay <slug>` | Re-run a past council session with the same question — fresh panel round. |
-| `/rihal-export-to-github` | Push phases/stories/decisions to GitHub issues (wraps `rihal-code github-sync`). |
-| `/rihal-notify-test` | Verify Slack/Discord/MS Teams webhook wiring — posts a test message. |
-| `/rihal-from-template <type>` | Seed .planning/ from a starter template (saas-b2b, api-backend, mobile-app). |
-| `/rihal-retrospective` | Run an epic retrospective and produce owned action items. |
-| `/rihal-new-project-research` | Research subcommand — deep research before new project roadmap creation. |
-| `/rihal-new-project-roadmap` | Roadmap subcommand — generate phase roadmap from new project research. |
-
-## Memory
-
-| Command | Use |
-|---------|-----|
-| `/rihal-memory-init` | Initialize the memory bank for a project (first-time setup). |
-| `/rihal-memory-update` | Update a specific memory entry with new information. |
-| `/rihal-memory-audit` | Audit all memory files for staleness and coverage gaps. |
-| `/rihal-memory-distill` | Distill verbose memory into concise, LLM-friendly summaries. |
-
-## Operational / rare
-
-| Command | Use |
-|---------|-----|
-| `/rihal-debug "<issue>"` | Systematic debugging with persistent state across `/clear`. |
-| `/rihal-forensics` | Diagnose incomplete executions — timeline of what broke. |
-| `/rihal-undo <id>` | Safe git revert for a phase or plan with dependency checks. |
-| `/rihal-rerun <id>` | Re-execute a phase or plan, resetting state, fresh commits. |
-| `/rihal-diff <a> <b>` | Show changes to plans and state between commits. |
-| `/rihal-import <path>` | Ingest external plans with conflict detection against decisions. |
-| `/rihal-inbox` | Triage incoming issues and PRs against contribution templates. |
-| `/rihal-pr-branch` | Create clean PR branch — filter out `.planning/` commits. |
-| `/rihal-autonomous` | Run remaining phases autonomously — plan → execute → verify cycles. |
-| `/rihal-research-phase <n>` | Standalone research (usually use `/rihal-plan` instead). |
-| `/rihal-analyze-dependencies` | Suggest "Depends on" entries for ROADMAP.md. |
-| `/rihal-profile-user` | Classify developer on 4 dimensions, produce profile artifact. |
-| `/rihal-dashboard` | Start the Diwan view-only dashboard (port 7717). |
-| `/rihal-health` | 6-point health check of the Rihal installation. |
-| `/rihal-stats` | Phases, plans, decisions, council sessions, timeline. |
-| `/rihal-settings` | Interactive config wizard — model profile, gates, branching. |
-| `/rihal-config` | View or edit Rihal configuration directly. |
-| `/rihal-update` | Update Rihal to latest version with changelog preview. |
-| `/rihal-note` | (also Tier 2) Inline note capture. |
-
-## Common compound flows
-
-**New project (full quality):**
-```
-/rihal-new-project → /clear → /rihal-plan 1 → /clear → /rihal-execute 1 → /rihal-verify-phase 1 → /rihal-ship
-```
-
-**Mid-milestone urgent work:**
-```
-/rihal-insert-phase 5 "Critical security fix" → /rihal-plan 5.1 → /rihal-execute 5.1
-```
-
-**Resume after break:**
-```
-/rihal-resume-work   # or just /rihal-next
-```
-
-**Debug across context resets:**
-```
-/rihal-debug "form submission fails" → ...investigation... → /clear → /rihal-debug   # resumes
-```
-
-**Complete + start next milestone:**
-```
-/rihal-audit-milestone → /rihal-plan-milestone-gaps → /rihal-complete-milestone 1.0.0 → /rihal-new-milestone
-```
-
-## Configuration reference
-
-`.planning/config.json`:
-
-```json
-{
-  "mode": "interactive",            // or "yolo"
-  "planning": {
-    "commit_docs": true,            // false = .planning/ kept local
-    "search_gitignored": false      // true = ripgrep with --no-ignore
-  }
-}
-```
-
-## Where to find context
-
-- `.planning/PROJECT.md` — vision
-- `.planning/STATE.md` — current memory
-- `.planning/ROADMAP.md` — phase status
-- `.planning/RETROSPECTIVE.md` — living retrospective
-- `.planning/codebase/` — brownfield maps (STACK, ARCHITECTURE, etc.)
-
-**End of reference.**
-</tier-3>
-
-## Success Criteria
-
-- [ ] Correct tier section is rendered based on `$ARGUMENTS`
-- [ ] No extra analysis, commentary, or project state added
-- [ ] "Next tier" pointer present at end of Tier 1 and Tier 2
-- [ ] `all` renders all three tiers separated by `---`
-- [ ] Unknown args fall back to Tier 1 silently (do not error)
-
-## On Error
-
-- If unable to load or render reference: display fallback `See rihal/workflows/help.md for full reference`
-- Handle missing sections gracefully without breaking output

package/rihal/workflows/import.md

@@ -1,320 +0,0 @@
-# Import Workflow
-
-<purpose>
-External plan ingestion with conflict detection and agent delegation. Imports an externally-authored plan, detects conflicts against existing project decisions, writes SPRINT.md, and validates via rihal-sprint-checker.
-</purpose>
-
-External plan ingestion with conflict detection and agent delegation.
-
-- **--from**: Import external plan → conflict detection → write SPRINT.md → validate via rihal-sprint-checker
-
-Future: `--prd` mode (PRD extraction into PROJECT.md + REQUIREMENTS.md + ROADMAP.md) is planned for a follow-up PR.
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-- Print the usage block below
-- STOP — do not proceed
-
-**Usage:**
-```
-/rihal-import --from <path>
-```
-
-**Examples:**
-```
-/rihal-import --from ./external-plan.md
-/rihal-import --from ../other-project/SPRINT.md
-```
-
----
-
-<step name="banner">
-
-Display the stage banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► IMPORT
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-</step>
-
-<step name="parse_arguments">
-
-Parse `$ARGUMENTS` to determine the execution mode:
-
-- If `--from` is present: extract FILEPATH (the next token after `--from`), set MODE=plan
-- If `--prd` is present: display message that `--prd` is not yet implemented and exit:
-  ```
-  RIHAL > --prd mode is planned for a future release. Use --from to import plan files.
-  ```
-- If neither flag is found: display usage and exit:
-
-```
-Usage: /rihal-import --from <path>
-
-  --from <path>   Import an external plan file into Rihal format
-```
-
-**Validate the file path:**
-
-Verify the path does not contain traversal sequences and the file exists:
-
-```bash
-case "{FILEPATH}" in
-  *..* ) echo "SECURITY_ERROR: path contains traversal sequence"; exit 1 ;;
-esac
-test -f "{FILEPATH}" || echo "FILE_NOT_FOUND"
-```
-
-If FILE_NOT_FOUND: display error and exit:
-
-```
-╔══════════════════════════════════════════════════════════════╗
-║  ERROR                                                       ║
-╚══════════════════════════════════════════════════════════════╝
-
-File not found: {FILEPATH}
-
-**To fix:** Verify the file path and try again.
-```
-
-</step>
-
----
-
-## Path A: MODE=plan (--from)
-
-<step name="plan_load_context">
-
-Load project context for conflict detection:
-
-1. Read `.planning/ROADMAP.md` — extract phase structure, phase numbers, dependencies
-2. Read `.planning/PROJECT.md` — extract project constraints, tech stack, scope boundaries.
-   **If PROJECT.md does not exist:** skip constraint checks that rely on it and display:
-   ```
-   RIHAL > Note: No PROJECT.md found. Conflict checks against project constraints will be skipped.
-   ```
-3. Read `.planning/REQUIREMENTS.md` — extract existing requirements for overlap and contradiction checks.
-   **If REQUIREMENTS.md does not exist:** skip requirement conflict checks and continue.
-4. Glob for all CONTEXT.md files across phase directories:
-   ```bash
-   find .planning/phases/ -name "*-CONTEXT.md" -o -name "CONTEXT.md" 2>/dev/null | sort | tail -5
-   ```
-   Read each CONTEXT.md found — extract locked decisions (any decision in a `<decisions>` block)
-
-Store loaded context for conflict detection in the next step.
-
-</step>
-
-<step name="plan_read_input">
-
-Read the imported file at FILEPATH.
-
-Determine the format:
-- **RIHAL SPRINT.md format**: Has YAML frontmatter with `phase:`, `plan:`, `type:` fields
-- **Freeform document**: Any other format (markdown spec, design doc, task list, etc.)
-
-Extract from the imported content:
-- **Phase target**: Which phase this plan belongs to (from frontmatter or inferred from content)
-- **Plan objectives**: What the plan aims to accomplish
-- **Tasks listed**: Individual work items described in the plan
-- **Files modified**: Any files mentioned as targets
-- **Dependencies**: Any referenced prerequisites
-
-</step>
-
-<step name="plan_conflict_detection">
-
-Run conflict checks against the loaded project context. Output as a plain-text conflict report using [BLOCKER], [WARNING], and [INFO] labels. Do NOT use markdown tables (no `|---|` format).
-
-### BLOCKER checks (any one prevents import):
-
-- Plan targets a phase number that does not exist in ROADMAP.md → [BLOCKER]
-- Plan specifies a tech stack that contradicts PROJECT.md constraints → [BLOCKER]
-- Plan contradicts a locked decision in any CONTEXT.md `<decisions>` block → [BLOCKER]
-- Plan contradicts an existing requirement in REQUIREMENTS.md → [BLOCKER]
-
-### WARNING checks (user confirmation required):
-
-- Plan partially overlaps existing requirement coverage in REQUIREMENTS.md → [WARNING]
-- Plan has `depends_on` referencing plans that are not yet complete → [WARNING]
-- Plan modifies files that overlap with existing incomplete plans → [WARNING]
-- Plan phase number conflicts with existing phase numbering in ROADMAP.md → [WARNING]
-
-### INFO checks (informational, no action needed):
-
-- Plan uses a library not currently in the project tech stack → [INFO]
-- Plan adds a new phase to the ROADMAP.md structure → [INFO]
-
-Display the full Conflict Detection Report:
-
-```
-## Conflict Detection Report
-
-### BLOCKERS ({N})
-
-[BLOCKER] {Short title}
-  Found: {what the imported plan says}
-  Expected: {what project context requires}
-  → {Specific action to resolve}
-
-### WARNINGS ({N})
-
-[WARNING] {Short title}
-  Found: {what was detected}
-  Impact: {what could go wrong}
-  → {Suggested action}
-
-### INFO ({N})
-
-[INFO] {Short title}
-  Note: {relevant information}
-```
-
-**If any [BLOCKER] exists:**
-
-Display:
-```
-RIHAL > BLOCKED: {N} blockers must be resolved before import can proceed.
-```
-
-Exit WITHOUT writing any files. This is the safety gate — no SPRINT.md is written when blockers exist.
-
-**If only WARNINGS and/or INFO (no blockers):**
-
-Ask via AskUserQuestion using the approve-revise-abort pattern:
-- question: "Review the warnings above. Proceed with import?"
-- header: "Approve?"
-- options: Approve | Abort
-
-If user selects "Abort": exit cleanly with message "Import cancelled."
-
-</step>
-
-<step name="plan_convert">
-
-Convert the imported content to RIHAL SPRINT.md format.
-
-Ensure the SPRINT.md has all required frontmatter fields:
-```yaml
----
-phase: "{NN}-{slug}"
-plan: "{NN}-{MM}"
-type: "feature|refactor|config|test|docs"
-wave: 1
-depends_on: []
-files_modified: []
-autonomous: true
-must_haves:
-  truths: []
-  artifacts: []
----
-```
-
-**Reject PBR naming conventions in source content:**
-If the imported plan references PBR plan naming (e.g., `PLAN-01.md`, `plan-01.md`), rename all references to RIHAL `{NN}-{MM}-SPRINT.md` convention during conversion.
-
-Apply RIHAL naming convention for the output filename:
-- Format: `{NN}-{MM}-SPRINT.md` (e.g., `04-1-SPRINT.md`)
-- NEVER use `PLAN-01.md`, `plan-01.md`, or any other format
-- NN = phase number (zero-padded), MM = plan number within the phase (zero-padded)
-
-Determine the target directory:
-```
-.planning/phases/{NN}-{slug}/
-```
-
-If the directory does not exist, create it:
-```bash
-mkdir -p ".planning/phases/{NN}-{slug}/"
-```
-
-Write the SPRINT.md file to the target directory.
-
-</step>
-
-<step name="plan_validate">
-
-Delegate validation to rihal-sprint-checker:
-
-```
-Task({
-  subagent_type: "rihal-sprint-checker",
-  prompt: "Validate: .planning/phases/{phase}/{plan}-SPRINT.md — check frontmatter completeness, task structure, and RIHAL conventions. Report any issues."
-})
-```
-
-**If the Task() call itself fails** (subagent could not start, tool error, or unexpected exception):
-
-Display:
-```
-⚠  Sprint-checker could not run (subagent error). The plan file was written but validation was skipped.
-   You can validate manually later with: /rihal-discuss fatima review .planning/phases/{phase}/{plan}-SPRINT.md
-```
-
-Proceed to plan_finalize — do NOT abort the import over a validator failure.
-
-**If the checker returns errors:**
-- Display the errors to the user
-- Ask the user to resolve issues before the plan is considered imported
-- Do not delete the written file — the user can fix and re-validate manually
-
-**If the checker returns clean:**
-- Display: "Plan validation passed"
-
-</step>
-
-<step name="plan_finalize">
-
-Update `.planning/ROADMAP.md` to reflect the new plan:
-- Add the plan to the Plans list under the correct phase section
-- Include the plan name and description
-
-Update `.planning/STATE.md` if appropriate (e.g., increment total plan count).
-
-Commit the imported plan and updated files:
-```bash
-node "$HOME/.rihal/bin/rihal-tools.cjs" commit "docs({phase}): import plan from {basename FILEPATH}" --files .planning/phases/{phase}/{plan}-SPRINT.md .planning/ROADMAP.md
-```
-
-Display completion:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► IMPORT COMPLETE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-Show: plan filename written, phase directory, validation result, next steps.
-
-</step>
-
----
-
-## Anti-Patterns
-
-Do NOT:
-- Use markdown tables (`|---|`) in the conflict detection report — use plain-text [BLOCKER]/[WARNING]/[INFO] labels
-- Write SPRINT.md files as `PLAN-01.md` or `plan-01.md` — always use `{NN}-{MM}-SPRINT.md`
-- Use `pbr:sprint-checker` or `pbr:planner` — use `rihal-sprint-checker` and `rihal-planner`
-- Write `.planning/.active-skill` — this is a PBR pattern with no RIHAL equivalent
-- Reference `pbr-tools`, `pbr:`, or `PLAN-BUILD-RUN` anywhere
-- Write any SPRINT.md file when blockers exist — the safety gate must hold
-- Skip path validation on the --from file argument
-
-## Success Criteria
-
-- [ ] Task completed as requested
-- [ ] Output saved or reported
-- [ ] State updated if necessary
-- [ ] No errors encountered
-
-## On Error
-
-If arguments are invalid, missing files, or subagent fails:
-- Validate inputs match expected format
-- Check that required files exist
-- Retry with clearer arguments or report the specific error to the user
-