@hanzlaa/rcode 2.1.0

package/rihal/templates/projects/mobile-app/ROADMAP.md

@@ -0,0 +1,93 @@
+# {{project_name}} — Roadmap
+
+**Milestone: M1 — Store launch** (v1.0)
+Template: mobile-app · Seeded {{date}}
+
+---
+
+## Phase 01 — Scaffolding
+
+**Goal:** App builds and runs on both platforms. Navigation is set up. Internal test builds can be distributed.
+
+**Delivers:**
+- Framework initialized (native / RN / Flutter — pick one, justify in ADR)
+- Navigation graph with placeholder screens for the core loop
+- CI producing signed iOS (TestFlight) and Android (Internal Track) builds on every main merge
+- Crash reporting wired (Crashlytics / Sentry)
+
+**Requirements:** REQ-MOBILE-SCAFFOLD, REQ-MOBILE-CI
+
+---
+
+## Phase 02 — Auth + onboarding
+
+**Goal:** A new user can install, sign up, reach the core screen in <60 seconds.
+
+**Delivers:**
+- Sign up / sign in (email + at least one social)
+- Onboarding flow (3-5 screens max — every extra screen costs activation)
+- Permission priming screens for any runtime permissions needed (notifications, location, camera)
+- Empty state for the core screen
+
+**Requirements:** REQ-MOBILE-AUTH, REQ-ONBOARDING
+
+---
+
+## Phase 03 — Core feature
+
+**Goal:** The one thing this app is for works end-to-end.
+
+**Delivers:**
+- The core action and its feedback loop, end-to-end, on both platforms
+- Analytics on the 3-5 events that prove the loop is working
+- At least one delightful moment (animation, haptic, micro-copy) that users will remember
+
+**Requirements:** REQ-MOBILE-CORE
+
+**Depends on:** Phase 02
+
+---
+
+## Phase 04 — Offline + sync
+
+**Goal:** Losing connection does not lose work. Reconnecting does not cause duplicates.
+
+**Delivers:**
+- Local-first data model for the core action (write locally, sync when online)
+- Conflict resolution strategy documented and tested
+- Clear UI for pending/syncing/failed states
+- Retry with backoff for failed sync
+
+**Requirements:** REQ-MOBILE-OFFLINE
+
+**Depends on:** Phase 03
+
+---
+
+## Phase 05 — Push + deep links
+
+**Goal:** The app can notify users of time-sensitive events and resume the right screen when tapped.
+
+**Delivers:**
+- Push notification infrastructure (APNs + FCM)
+- Deep links (universal links / app links) for core screens
+- Notification center inside the app for users who missed the push
+- Opt-out controls
+
+**Requirements:** REQ-MOBILE-PUSH, REQ-DEEPLINKS
+
+---
+
+## Phase 06 — Store submission + launch
+
+**Goal:** App is live on App Store + Play Store; you survived the first review round.
+
+**Delivers:**
+- Store listings: screenshots (5-6 per locale), description, privacy labels
+- Review-ready demo account for Apple
+- Privacy policy + support URL live
+- Post-launch monitoring: crash-free rate, conversion from install, 1-day retention
+
+**Requirements:** REQ-MOBILE-LAUNCH
+
+**Depends on:** Phase 05

package/rihal/templates/projects/mobile-app/template.yaml

@@ -0,0 +1,17 @@
+name: mobile-app
+display: "Mobile App"
+description: "iOS + Android app — onboarding, core feature, offline, push, store submission"
+recommended_modules:
+  - core
+  - execution
+phases:
+  - "01 — Scaffolding (framework, navigation, CI, TestFlight/Internal testing)"
+  - "02 — Auth + onboarding"
+  - "03 — Core feature"
+  - "04 — Offline + sync"
+  - "05 — Push notifications + deep links"
+  - "06 — Store submission + launch"
+next_steps: |
+  Seeded. Common follow-ups:
+    /rihal:council native (Swift/Kotlin) vs React Native vs Flutter for this app?
+    /rihal:plan phase 01

package/rihal/templates/projects/saas-b2b/PROJECT.md

@@ -0,0 +1,40 @@
+# {{project_name}} — Multi-tenant B2B SaaS
+
+**Template:** saas-b2b
+**Created:** {{date}}
+
+## What we're building
+_(One-sentence description — edit me.)_
+
+A multi-tenant B2B SaaS for {{target_customer}} that solves {{core_problem}}. Paying customers are organizations, not individuals.
+
+## Target customer
+- **Segment:** {{segment}} (e.g. mid-market ops teams, compliance-heavy industries)
+- **Size:** {{company_size}}
+- **Buying trigger:** {{trigger}}
+
+## Why now
+_(Market timing, regulatory shift, technology enabler, etc.)_
+
+## Monetization
+- **Model:** Subscription (per-seat / per-org / usage-based — pick one)
+- **Target ACV:** {{acv}}
+- **Trial strategy:** {{trial_length}} with {{trial_gating}}
+
+## Non-negotiables
+- Data isolation between tenants (hard requirement, not best-effort)
+- Audit log for every mutating action (for SOC2/ISO compliance paths)
+- SSO support by launch (SAML or OIDC — most B2B buyers require this)
+
+## Explicitly out of scope
+- Consumer tier
+- Self-serve free plan beyond trial
+- Mobile apps in v1
+
+## Key risks
+- **Technical:** multi-tenancy bugs = data leak = company-ending event
+- **Business:** long B2B sales cycles may outlast runway
+- **Regulatory:** PII/data-residency constraints depending on target market
+
+## Evolution
+_(Updated after each phase completion by `/rihal:execute`.)_

package/rihal/templates/projects/saas-b2b/REQUIREMENTS.md

@@ -0,0 +1,38 @@
+# {{project_name}} — Requirements
+
+Canonical REQ IDs for a B2B SaaS. Edit titles/acceptance, do not rename IDs once referenced by a phase.
+
+---
+
+## REQ-AUTH — User authentication
+Users can sign up, log in, reset passwords, and verify email. Sessions survive browser restart. Credentials are hashed with a modern algorithm (argon2/bcrypt). Rate-limited.
+
+## REQ-DB-BASE — Database baseline
+Migrations are versioned and reversible. Backups run daily with verified restore drill. Connection pooling configured.
+
+## REQ-CI — Continuous integration
+Every PR runs lint, type-check, unit tests. Main branch is protected. A failing CI blocks merge.
+
+## REQ-TENANCY — Tenant isolation
+No query can return data from a tenant the caller does not belong to. Proven by adversarial cross-tenant tests that must fail when isolation breaks.
+
+## REQ-RBAC — Role-based access control
+Every mutating endpoint checks role. Roles are declarative (in code) and tested. Permission denials are logged.
+
+## REQ-BILLING — Billing integration
+Customers can buy, upgrade, downgrade, cancel. Past-due state is reached and recovered from without manual intervention. Webhook events are idempotent.
+
+## REQ-PLANS — Plan + seat model
+Seat count is enforced at the API level. Adding a seat above plan limit either blocks or auto-upgrades (pick one).
+
+## REQ-ADMIN — Admin console
+Staff can list tenants, inspect one, impersonate (with audit entry), and adjust billing state. Non-staff cannot reach the console.
+
+## REQ-AUDIT — Audit log
+Every mutating action is written to an immutable log with actor, tenant, action, before/after, timestamp. Accessible to tenant admins for their own tenant.
+
+## REQ-OBSERVABILITY — Monitoring + alerting
+The top 3-5 business metrics have dashboards. The top ~5 failure modes have alerts with on-call routing. p50/p95/p99 latency is tracked for API.
+
+## REQ-LAUNCH — Public launch
+Marketing site, docs, pricing, signup funnel, ToS/privacy, status page, support channel — all live at a public URL.

package/rihal/templates/projects/saas-b2b/ROADMAP.md

@@ -0,0 +1,95 @@
+# {{project_name}} — Roadmap
+
+**Milestone: M1 — Production launch** (v1.0)
+Template: saas-b2b · Seeded {{date}}
+
+---
+
+## Phase 01 — Foundations
+
+**Goal:** Repo, CI, DB, auth stack, and environments ready for feature work. No business logic.
+
+**Delivers:**
+- Dev + staging + prod environments
+- Baseline auth (email/password + magic link) with password hashing best-practice
+- Database schema for `users`, `organizations`, `memberships`
+- CI pipeline running lint + test on every PR
+- Error reporting (Sentry/Highlight) and logs shipping somewhere queryable
+
+**Requirements:** REQ-AUTH, REQ-DB-BASE, REQ-CI
+
+---
+
+## Phase 02 — Multi-tenancy + RBAC
+
+**Goal:** Every query is tenant-scoped; every endpoint enforces role. This is the phase where a leak would be catastrophic, so it gets its own phase.
+
+**Delivers:**
+- Tenant-scoping middleware (or row-level security)
+- Role model: owner / admin / member (minimum)
+- Invitation + membership flows
+- Cross-tenant access tests that intentionally fail — proving isolation
+
+**Requirements:** REQ-TENANCY, REQ-RBAC
+
+**Depends on:** Phase 01
+
+---
+
+## Phase 03 — Billing + subscription lifecycle
+
+**Goal:** Customers can pay, change plan, cancel. Trial → active → past-due → canceled transitions handled correctly.
+
+**Delivers:**
+- Stripe (or equivalent) integration with webhooks
+- Plan model + seat counting
+- Past-due and dunning flows
+- Billing portal for customers to manage themselves
+
+**Requirements:** REQ-BILLING, REQ-PLANS
+
+**Depends on:** Phase 02
+
+---
+
+## Phase 04 — Admin console + audit log
+
+**Goal:** Internal tooling for support + compliance-ready audit trail.
+
+**Delivers:**
+- Staff-only admin console for inspecting tenants, impersonating (with audit entry), and resetting things
+- Immutable audit log table written for every mutating action
+- Export endpoint for tenant admins to pull their own audit data
+
+**Requirements:** REQ-ADMIN, REQ-AUDIT
+
+---
+
+## Phase 05 — Observability + incident response
+
+**Goal:** You notice problems before customers do.
+
+**Delivers:**
+- Dashboards for the 3-5 metrics that actually matter
+- Alerting (PagerDuty/on-call) for the handful of conditions that wake someone up
+- Runbooks in `docs/runbooks/` for the top incident patterns
+- SLO definition per critical path
+
+**Requirements:** REQ-OBSERVABILITY
+
+---
+
+## Phase 06 — Launch readiness
+
+**Goal:** First paying customer can sign up self-serve without a human escort.
+
+**Delivers:**
+- Public marketing site with pricing, demo request, signup
+- Docs site for customers + API reference
+- Support channel + response-time SLA
+- Legal (ToS, privacy, DPA template)
+- Status page
+
+**Requirements:** REQ-LAUNCH
+
+**Depends on:** Phase 05

package/rihal/templates/projects/saas-b2b/template.yaml

@@ -0,0 +1,18 @@
+name: saas-b2b
+display: "SaaS B2B"
+description: "Multi-tenant B2B SaaS — auth, orgs, billing, RBAC, admin console, audit log"
+recommended_modules:
+  - core
+  - execution
+  - discovery
+phases:
+  - "01 — Foundations (auth, DB, env)"
+  - "02 — Multi-tenancy + RBAC"
+  - "03 — Billing + subscription lifecycle"
+  - "04 — Admin console + audit log"
+  - "05 — Observability + incident response"
+  - "06 — Launch readiness (SLA, docs, support)"
+next_steps: |
+  Seeded. Common follow-ups:
+    /rihal:council what's the first customer segment we should focus on?
+    /rihal:plan phase 01

package/rihal/templates/settings-hooks.json

@@ -0,0 +1,36 @@
+{
+  "_comment": "pre-edit hook is currently advisory (logs warning, does not block). Full session-read tracking requires PostToolUse Read hook to write state file. Implemented in follow-up.",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .rihal/bin/rihal-hooks.cjs pre-edit"
+          }
+        ]
+      },
+      {
+        "matcher": "SlashCommand",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .rihal/bin/rihal-hooks.cjs pre-workflow"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .rihal/bin/rihal-hooks.cjs post-commit"
+          }
+        ]
+      }
+    ]
+  }
+}

package/rihal/templates/sprint.md

@@ -0,0 +1,70 @@
+# Sprint {sprint_id} — {sprint_goal}
+
+**Phase:** {phase_number} — {phase_name}
+**Status:** {status}
+**Velocity target:** {velocity_target} points
+**Started:** {started_at}
+
+---
+
+## Sprint Goal
+
+{sprint_goal}
+
+---
+
+## Stories
+
+| ID | Title | Points | Status | Acceptance |
+|----|-------|--------|--------|------------|
+| {story_id} | {title} | {points} | {status} | {acceptance} |
+
+---
+
+## Capacity
+
+- **Velocity target:** {velocity_target} points
+- **Average velocity (last 3):** {avg_velocity} points
+- **Total committed:** {total_points} points
+- **Buffer:** {buffer_points} points ({buffer_pct}%)
+
+---
+
+## Dependencies
+
+| Story | Depends on | Status |
+|-------|-----------|--------|
+| | | |
+
+---
+
+## Risks
+
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| | | |
+
+---
+
+## Sprint Review Notes
+
+_Filled at sprint completion._
+
+- Stories completed: {done_count}/{total_count}
+- Velocity actual: {velocity_actual} points
+- Carryover stories: {carryover}
+
+---
+
+## Retrospective
+
+_Filled at sprint completion._
+
+### What went well
+-
+
+### What didn't
+-
+
+### Action items
+-

package/rihal/workflows/add-phase.md

@@ -0,0 +1,112 @@
+<purpose>
+Add a new integer phase to the end of the current milestone in the roadmap. Automatically calculates next phase number, creates phase directory, and updates roadmap structure.
+</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:
+- All arguments become the phase description
+- Example: `/rihal:add-phase Add authentication` → description = "Add authentication"
+- Example: `/rihal:add-phase Fix critical performance issues` → description = "Fix critical performance issues"
+
+If no arguments provided:
+
+```
+ERROR: Phase description required
+Usage: /rihal:add-phase <description>
+Example: /rihal:add-phase Add authentication system
+```
+
+Exit.
+</step>
+
+<step name="init_context">
+Load phase operation context:
+
+```bash
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "0")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Check `roadmap_exists` from init JSON. If false:
+```
+ERROR: No roadmap found (.planning/ROADMAP.md)
+Run /rihal:new-project to initialize.
+```
+Exit.
+</step>
+
+<step name="add_phase">
+**Delegate the phase addition to rihal-tools:**
+
+```bash
+RESULT=$(node ".rihal/bin/rihal-tools.cjs" phase add "${description}")
+```
+
+The CLI handles:
+- Finding the highest existing integer phase number
+- Calculating next phase number (max + 1)
+- Generating slug from description
+- Creating the phase directory (`.planning/phases/{NN}-{slug}/`)
+- Inserting the phase entry into ROADMAP.md with Goal, Depends on, and Plans sections
+
+Extract from result: `phase_number`, `padded`, `name`, `slug`, `directory`.
+</step>
+
+<step name="update_project_state">
+Update STATE.md to reflect the new phase:
+
+1. Read `.planning/STATE.md`
+2. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
+   ```
+   - Phase {N} added: {description}
+   ```
+
+If "Roadmap Evolution" section doesn't exist, create it.
+</step>
+
+<step name="completion">
+Present completion summary:
+
+```
+Phase {N} added to current milestone:
+- Description: {description}
+- Directory: .planning/phases/{phase-num}-{slug}/
+- Status: Not planned yet
+
+Roadmap updated: .planning/ROADMAP.md
+
+---
+
+## ▶ Next Up
+
+**Phase {N}: {description}**
+
+`/clear` then:
+
+`/rihal:plan {N}`
+
+---
+
+**Also available:**
+- `/rihal:add-phase <description>` — add another phase
+- Review roadmap
+
+---
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] `rihal-tools phase add` executed successfully
+- [ ] Phase directory created
+- [ ] Roadmap updated with new phase entry
+- [ ] STATE.md updated with roadmap evolution note
+- [ ] User informed of next steps
+</success_criteria>