@hanzlaa/rcode 3.6.16 → 4.1.0

package/rihal/workflows/forensics.md

@@ -1,209 +0,0 @@
-# Workflow: rihal-forensics
-
-<purpose>
-Analyze execution history in state.json and filesystem to detect incomplete work. Show timeline of what happened, where it broke, and suggest resume command.
-</purpose>
-
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-
-```
-/rihal-forensics <argument-here>
-```
-
-**Examples:**
-```
-/rihal-forensics example 1
-/rihal-forensics example 2
-```
-
-STOP — do not proceed.
-
-## Step 1 — Load state
-
-Read `.rihal/state.json`:
-
-```bash
-cat .rihal/state.json 2>/dev/null || echo '{}'
-```
-
-Parse as JSON. If invalid or missing, print:
-```
-ℹ️ No rihal state found. Nothing to diagnose.
-```
-Exit.
-
-Extract:
-- **executions**: array of execution records (each has: id, phase, timestamp, status, error)
-- **current_phase**: string or null (name of current phase)
-- **last_session**: timestamp of most recent activity
-
-## Step 2 — Find failed executions
-
-From `$STATE.executions`, filter for ones where:
-- `status !== "complete"` OR
-- `error` field is present and non-empty OR
-- `status === "failed"`
-
-Store as `$FAILED_EXECS`.
-
-## Step 3 — Check for incomplete plans
-
-Scan `.planning/` directory for:
-
-```bash
-find .planning/ -maxdepth 5 -name "SPRINT.md" -type f | head -50
-```
-
-For each SPRINT.md found, check if a corresponding SUMMARY.md exists:
-
-```bash
-ls -1 .planning/*/SUMMARY.md 2>/dev/null || true
-```
-
-If SPRINT.md exists but no SUMMARY.md, that's an incomplete execution.
-
-Store as `$INCOMPLETE_PLANS` (list of plan IDs).
-
-## Step 4 — Check for checkpoint artifacts
-
-Search for checkpoint markers in recent planning artifacts:
-
-```bash
-grep -r "---CHECKPOINT REACHED---" .planning/ 2>/dev/null | head -10 || echo ""
-```
-
-If found, these indicate partial progress within a phase. Extract:
-- File containing checkpoint
-- Line number
-- Context around checkpoint
-
-Store as `$CHECKPOINTS`.
-
-## Step 5 — Scan recent git history for rihal commits
-
-If `.git/` exists, extract rihal-related commits:
-
-```bash
-git log --oneline -20 --pretty=format:'%h %s' -- .rihal rihal/ .planning/ 2>/dev/null || echo ""
-```
-
-Parse to identify:
-- Last commit on .rihal (install/config changes)
-- Last commit on rihal/ (workflow/agent changes)
-- Last commit on .planning/ (execution artifacts)
-
-Store as `$RECENT_COMMITS`.
-
-## Step 6 — Assemble timeline
-
-Build a chronological timeline from:
-1. `current_phase` (if set, this is where work stopped)
-2. Most recent execution from `$FAILED_EXECS` (when and why it failed)
-3. Last item in `$INCOMPLETE_PLANS` (phase with PLAN but no SUMMARY)
-4. Most recent checkpoint from `$CHECKPOINTS` (partial progress)
-5. Last commit from `$RECENT_COMMITS`
-
-Format as:
-
-```
-Timeline of Execution
-
-T-5h: Started phase "Feature X" (/rihal-plan feature-x)
-T-3h: Phase created, plan saved to .planning/feature-x/SPRINT.md
-T-2h: Execution began — checkpoint at step 3/8
-T-0h: ❌ FAIL — Execution error: "Dependency not installed"
-      Stuck at: .planning/feature-x/ (no SUMMARY.md yet)
-      Last git: commit abc1234 "draft plan"
-```
-
-## Step 7 — Suggest recovery
-
-Based on what was found:
-
-**If incomplete phase with checkpoint:**
-```
-💡 Suggested recovery:
-
-You were working on phase "phase-name" and reached checkpoint 3.
-
-To resume:
-  /rihal-resume-work
-```
-
-**If failed execution with error:**
-```
-💡 Suggested recovery:
-
-Phase "phase-name" failed during execution:
-  Error: [error message from state.json]
-
-To retry:
-  1. Fix the issue noted above
-  2. Run: /rihal-next
-```
-
-**If incomplete plan (PLAN exists, no SUMMARY):**
-```
-💡 Suggested recovery:
-
-Phase "phase-name" was planned but never executed.
-
-To continue:
-  /rihal-execute phase-name
-```
-
-**If no incomplete work found:**
-```
-✓ No incomplete executions detected. All phases complete or active.
-```
-
-## Step 8 — Print full diagnostic report
-
-If user needs more detail, print:
-
-```
-📋 Full Forensic Report
-
-Current Phase: {phase_name or "none"}
-Last Session: {last_session timestamp}
-
-Failed Executions: {count}
-  [List each with ID, phase, error, timestamp]
-
-Incomplete Plans: {count}
-  [List each with plan ID, created timestamp]
-
-Checkpoints Reached: {count}
-  [List each with location and progress]
-
-Recent Rihal Commits: {count}
-  [List with hash, message, timestamp]
-
-Recommendation: {recovery suggestion}
-```
-
-## 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
-
-
-## ▶ Next Up
-
-After reviewing the diagnostic report, pick your recovery path:
-
-- /rihal-resume-work
-- /rihal-execute {phase-number}
-- /rihal-progress

package/rihal/workflows/from-template.md

@@ -1,173 +0,0 @@
-# Workflow: rihal-from-template
-
-<purpose>
-Seed a fresh project's `.planning/` directory from a canonical starter template (saas-b2b, api-backend, mobile-app). Replaces the blank-page moment after `rihal init` with a PROJECT.md skeleton, a ROADMAP.md with typical phases for this kind of project, and a REQUIREMENTS.md of common REQ-IDs.
-
-Templates are a starting point, not a prescription. Every section is meant to be edited. The goal is to have something concrete to react to instead of an empty file.
-</purpose>
-
-<output_format>
-Open with banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► FROM TEMPLATE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-End with a file summary and Next Up routing.
-</output_format>
-
-<required_reading>
-@.rihal/references/output-format.md
-</required_reading>
-
-<process>
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty, contains `--help`, `-h`, or `list` — print the catalog:
-
-```
-/rihal-from-template <template-name> [--project-name "<name>"] [--force]
-
-Available templates:
-  saas-b2b      Multi-tenant B2B SaaS — auth, orgs, billing, RBAC, admin
-  api-backend   Headless API service — auth, contract, SDK, docs, SLOs
-  mobile-app    iOS + Android app — onboarding, offline, push, store launch
-
-Flags:
-  --project-name "<name>"   Name substituted into PROJECT.md / ROADMAP.md placeholders (default: basename of cwd)
-  --force                   Overwrite .planning/ files that already exist (destructive)
-```
-
-STOP.
-
-## Step 1 — Resolve the template
-
-```bash
-TEMPLATE="${1}"
-TEMPLATE_DIR=".rihal/templates/projects/${TEMPLATE}"
-
-if [ ! -d "$TEMPLATE_DIR" ]; then
-  echo "Unknown template: ${TEMPLATE}"
-  echo "Run: /rihal-from-template --help  for the catalog."
-  exit 0
-fi
-```
-
-Read `${TEMPLATE_DIR}/template.yaml` to show the user what will be seeded:
-
-```
-Template: {display}
-  {description}
-
-Phases that will be seeded:
-  - {phase_1}
-  - {phase_2}
-  ...
-
-Recommended modules: {modules}
-```
-
-## Step 2 — Safety check
-
-```bash
-PLANNING=".planning"
-EXISTING=()
-for f in PROJECT.md ROADMAP.md REQUIREMENTS.md; do
-  [ -f "${PLANNING}/${f}" ] && EXISTING+=("${f}")
-done
-```
-
-If `EXISTING` is non-empty and `--force` was NOT passed:
-
-```
-.planning/ already contains:
-  - {each existing file}
-
-Refusing to overwrite. Options:
-  - Pass --force to overwrite (destructive)
-  - Delete the existing files first, then re-run
-  - Use /rihal-new-project for the interactive discovery flow instead
-```
-
-STOP.
-
-## Step 3 — Substitute placeholders
-
-Compute substitutions:
-
-```bash
-PROJECT_NAME="${PROJECT_NAME_FLAG:-$(basename "$PWD")}"
-DATE="$(date -u +%Y-%m-%d)"
-```
-
-Placeholders supported in template files:
-- `{{project_name}}` → `$PROJECT_NAME`
-- `{{date}}` → `$DATE`
-
-All other `{{...}}` tokens are left in place intentionally — they're prompts for the user to fill in.
-
-## Step 4 — Copy + substitute
-
-```bash
-mkdir -p "${PLANNING}"
-
-for f in PROJECT.md ROADMAP.md REQUIREMENTS.md; do
-  SRC="${TEMPLATE_DIR}/${f}"
-  DEST="${PLANNING}/${f}"
-  [ -f "$SRC" ] || continue
-  # Substitute only the two known placeholders; leave all other {{...}} for the user to edit.
-  sed -e "s|{{project_name}}|${PROJECT_NAME//|/\\|}|g" \
-      -e "s|{{date}}|${DATE}|g" \
-      "$SRC" > "$DEST"
-done
-```
-
-## Step 5 — Record the seeding
-
-```bash
-node .rihal/bin/rihal-tools.cjs state add-decision \
-  "Seeded .planning/ from template '${TEMPLATE}' (project: ${PROJECT_NAME})" 2>/dev/null || true
-```
-
-This surfaces the seeding both in local state AND `/rihal-decisions` cross-project memory.
-
-## Step 6 — Commit
-
-Suggest (do not execute without confirmation) a baseline commit:
-
-```
-git add .planning/PROJECT.md .planning/ROADMAP.md .planning/REQUIREMENTS.md
-git commit -m "docs(planning): seed from template — ${TEMPLATE}"
-```
-
-## Step 7 — Summary + Next Up
-
-```
-✓ Seeded .planning/ from template '${TEMPLATE}'
-  - .planning/PROJECT.md       ({size})
-  - .planning/ROADMAP.md       ({size})
-  - .planning/REQUIREMENTS.md  ({size})
-
-Next Up (from template.yaml.next_steps):
-  {next_steps_block}
-
-Also consider:
-  /rihal-discuss-phase 01   — adapt phase 01 to your specifics
-  /rihal-council            — sanity-check the starter phases before committing to them
-```
-</process>
-
-## Success Criteria
-
-- Unknown template name → catalog is printed, not a crash
-- Existing `.planning/` files → refused unless `--force`
-- `{{project_name}}` and `{{date}}` are substituted; other `{{...}}` tokens remain for the user to edit
-- Seeded files are exactly the template files with only the two substitutions applied
-- Seeding is recorded via `state add-decision` for traceability
-
-## On Error
-
-- Missing `.rihal/templates/projects/` directory → tell the user their install is missing the module; suggest `rihal-install`
-- `sed` substitution failure (unusual characters in project name) → fall back to literal-string `awk` substitution, or ask the user to pass a simpler name via `--project-name`

package/rihal/workflows/health.md

@@ -1,258 +0,0 @@
-# Workflow: rihal-health
-
-<purpose>
-Run 9-point health check: 6 installation checks + 3 project-state checks. Each check is pass/fail. Summary at the end.
-</purpose>
-
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-
-```
-/rihal-health <argument-here>
-```
-
-**Examples:**
-```
-/rihal-health example 1
-/rihal-health example 2
-```
-
-STOP — do not proceed.
-
-## Step 0 — Verify .rihal/ directory exists and is writable
-
-**Action:** Check if `.rihal/` directory exists and current user can write to it.
-
-```bash
-test -d .rihal && test -w .rihal
-```
-
-**PASS if:**
-- `.rihal/` exists
-- Current user can write to it
-
-**Output on pass:**
-```
-✓ PASS — .rihal/ directory exists and is writable
-```
-
-**Output on fail:**
-```
-❌ FAIL — .rihal/ does not exist or is not writable. Run: /rihal-update to repair
-```
-
-## Step 1 — Verify file manifest exists and is valid CSV
-
-**Action:** Check `.rihal/_config/files-manifest.csv` and parse as CSV.
-
-```bash
-test -f .rihal/_config/files-manifest.csv
-```
-
-Verify:
-- File exists
-- Header row: `rel,sha256,size`
-- At least 1 data row
-- All rows have exactly 3 columns
-
-**Output on pass:**
-```
-✓ PASS — files-manifest.csv is valid (N files tracked)
-```
-
-**Output on fail:**
-```
-❌ FAIL — files-manifest.csv is missing or corrupted. Run: /rihal-update to repair
-```
-
-## Step 2 — Verify all manifest files exist and hashes match
-
-**Action:** For each row in files-manifest.csv, check file exists and hash matches.
-
-For each file:
-- Extract: `rel`, `sha256`, `size`
-- Verify file at `./{rel}` exists
-- Compute SHA256 hash of actual file
-- Compare against manifest entry
-
-Detect drift: files that exist but hash doesn't match.
-
-**Output on pass:**
-```
-✓ PASS — All files match manifest (no drift detected)
-```
-
-**Output on fail (drift found):**
-```
-❌ FAIL — File drift detected: N files changed or missing
-  Modified: file1.md, file2.js
-  Missing: file3.md
-Run: /rihal-update to repair
-```
-
-## Step 3 — Verify state.json exists and is valid
-
-**Action:** Check `.rihal/state.json` and validate JSON structure.
-
-```bash
-test -f .rihal/state.json
-```
-
-Parse as JSON. Verify top-level keys present:
-- `version`
-- `project`
-- `created`
-- `updated`
-- `phases` (array)
-- `executions` (array)
-- `decisions` (array)
-- `blockers` (array)
-- `council_sessions` (array)
-
-**Output on pass:**
-```
-✓ PASS — state.json is valid and initialized
-```
-
-**Output on fail:**
-```
-❌ FAIL — state.json is missing or invalid. Run: /rihal-update to repair
-```
-
-## Step 4 — Verify agent-manifest.csv is present and populated
-
-**Action:** Check `.rihal/_config/agent-manifest.csv` for header and at least one agent.
-
-```bash
-test -f .rihal/_config/agent-manifest.csv
-```
-
-Verify:
-- File exists
-- Header row present
-- At least 1 data row (one agent installed)
-
-**Output on pass:**
-```
-✓ PASS — agent-manifest.csv is valid (N agents installed)
-```
-
-**Output on fail:**
-```
-❌ FAIL — agent-manifest.csv is missing or empty. Run: /rihal-update to repair
-```
-
-## Step 5 — Verify rihal-tools.cjs is executable and responsive
-
-**Action:** Check rihal-tools.cjs exists, is executable, and responds to version command.
-
-```bash
-test -f .rihal/bin/rihal-tools.cjs && test -x .rihal/bin/rihal-tools.cjs
-node .rihal/bin/rihal-tools.cjs version
-```
-
-**Output on pass:**
-```
-✓ PASS — rihal-tools.cjs is executable and responsive
-```
-
-**Output on fail:**
-```
-❌ FAIL — rihal-tools.cjs is missing or broken. Run: /rihal-update to repair
-```
-
-## Step 6 — Project state health checks (3 checks)
-
-Run these after installation checks. Skip if `.rihal/state.json` doesn't exist.
-
-**Check 7 — state.json phase count matches ROADMAP.md**
-
-```bash
-ROADMAP_PHASES=$(grep -c '^## Phase\|^### Phase\|^- Phase' .planning/ROADMAP.md 2>/dev/null || echo 0)
-STATE_PHASES=$(node .rihal/bin/rihal-tools.cjs state read 2>/dev/null | python3 -c "import json,sys; d=json.load(sys.stdin); print(len(d.get('phases',[])) if d else 0)" 2>/dev/null || echo 0)
-```
-
-If counts match: `✓ PASS — {N} phases in ROADMAP.md and state.json are in sync`
-If they differ: `⚠ WARN — ROADMAP.md has ${ROADMAP_PHASES} phases, state.json has ${STATE_PHASES}. Run: /rihal-status to investigate`
-
-**Check 8 — current phase has a SPRINT.md or CONTEXT.md**
-
-```bash
-CURRENT=$(node .rihal/bin/rihal-tools.cjs state read 2>/dev/null | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('current_phase',''))" 2>/dev/null)
-find .planning/phases/*${CURRENT}* -name "*-SPRINT.md" -o -name "*-CONTEXT.md" 2>/dev/null | head -1
-```
-
-If current_phase is null or empty: skip this check (not started).
-If file found: `✓ PASS — current phase ${CURRENT} has planning artifacts`
-If no file: `⚠ WARN — current phase ${CURRENT} has no SPRINT.md or CONTEXT.md. Run: /rihal-plan ${CURRENT}`
-
-**Check 9 — no phantom-complete phases (ROADMAP says complete but no artifacts)**
-
-```bash
-node .rihal/bin/rihal-tools.cjs state snapshot 2>/dev/null | python3 -c "
-import json,sys
-d=json.load(sys.stdin)
-insights = d.get('insights', [])
-phantom = [i for i in insights if i.get('kind') == 'phantom-complete']
-print(len(phantom))
-" 2>/dev/null || echo 0
-```
-
-If 0 phantoms: `✓ PASS — no phantom-complete phases detected`
-If any: `⚠ WARN — {N} phantom-complete phase(s) detected. Run: /rihal-audit to inspect`
-
-**Check 10 — no orphaned executor worktrees or branches**
-
-```bash
-ORPHAN_WTS=$(git worktree list --porcelain \
-  | awk '/^branch /{if($2 ~ /refs\/heads\/worktree-agent-/) print $2}' \
-  | wc -l 2>/dev/null || echo 0)
-ORPHAN_BR=$(git branch --list 'worktree-agent-*' 2>/dev/null | wc -l || echo 0)
-ORPHANS=$((ORPHAN_WTS + ORPHAN_BR))
-echo "$ORPHANS"
-```
-
-If `ORPHANS` is 0: `✓ PASS — no orphaned executor worktrees or branches`
-If `ORPHANS > 0`: `⚠ WARN — ${ORPHANS} orphaned worktree-agent-* artifact(s) from a previous /rihal-execute. Run: /rihal-audit worktrees --prune`
-
----
-
-## Step 7 — Count results and print final summary
-
-**Action:** Count all pass/fail/warn results and display overall status.
-
-Total: `{N}/9 checks passed`
-
-If all 9 pass:
-```
-✓ All systems nominal — rihal is healthy (9/9)
-```
-
-If fewer than 9 pass:
-```
-⚠ {N}/9 checks passed — {M} issue(s) found
-Run: /rihal-update to repair installation issues
-Run: /rihal-status for project-state issues
-Run: /rihal-audit worktrees --prune to clean orphaned executor artifacts
-```
-
-## Success Criteria
-
-- [ ] All 9 checks executed (skip state checks if no state.json)
-- [ ] Each check result printed clearly
-- [ ] Final summary shows pass/fail count
-- [ ] Repair instructions shown if any checks fail
-
-## On Error
-
-- **Directory not readable:** Print error and suggest filesystem check
-- **CSV parsing fails:** Print error and suggest re-running update
-- **JSON corruption:** Print error and suggest state.json reset
-
-## ▶ Next Up
-
-- /rihal-forensics
-- /rihal-do
-- /rihal-correct-course {phase}