@hanzlaa/rcode 2.3.5 → 2.4.0

package/rihal/workflows/progress.md

@@ -1,184 +1,46 @@
+# Workflow: rihal:progress
+
 <purpose>
-Render project progress: what was accomplished, where you are, what's pending, what's next. All data comes from a single `rihal-tools progress init` call. This workflow is a pure renderer — no direct markdown parsing, no state.json grep, no phase-directory walk.
+**`/rihal:progress` is an alias of `/rihal:status --verbose`.**
 
-**SSOT:** `.rihal/state.json`, surfaced through `rihal-tools progress init`. `/rihal:progress` and `/rihal:status` call the same CLI and cannot disagree (issue #131 closed).
+Historically this was a separate workflow with overlapping data and a heavier render. They both read the same source of truth (`rihal-tools progress init`), so we collapsed them: `/rihal:status` is the canonical renderer with built-in slim/verbose modes, and `/rihal:progress` is a thin alias that always runs in verbose mode.
 
-For a sprint-board view, use `/rihal:sprint-status`. For a concise dashboard, use `/rihal:status`. This workflow gives the full narrative view with recent-work excerpts and an intent-tree Next Up menu.
+Use whichever name you prefer — they produce the same output.
 </purpose>
 
 <required_reading>
-@.rihal/references/output-format.md
-Read all files referenced by the invoking prompt's execution_context before starting.
+@.rihal/workflows/status.md
 </required_reading>
 
-<output_format>
-Banner from output-format.md:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► PROGRESS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-Use ✓ complete / ◆ in_progress / ○ planned / 🅿 parking-lot throughout.
-End with a Next Up block rendered from the CLI's `routes[]` array.
-</output_format>
-
 <process>
 
-<step name="init_context">
-
-## 1. Init context
-
-Fetch the full progress snapshot in a single call:
-
-```bash
-SNAPSHOT=$(node .rihal/bin/rihal-tools.cjs progress init)
-```
-
-Parse as JSON.
-
-If `SNAPSHOT.project` is null AND `SNAPSHOT.phases[]` is empty:
-
-```
-No planning structure found.
-
-Run /rihal:new-project to start a new project.
-```
-
-Exit.
+## Step 1 — Delegate to /rihal:status in verbose mode
 
-Read `DISCUSS_MODE` from config (separate cheap call):
-
-```bash
-DISCUSS_MODE=$(node .rihal/bin/rihal-tools.cjs config 2>/dev/null | grep -oE '"discuss_mode"\s*:\s*"[^"]*"' | cut -d'"' -f4 || echo "discuss")
-```
+Execute the workflow defined in `.rihal/workflows/status.md` end-to-end, with one override:
 
-</step>
+- Always render in **verbose mode** (full Steps 2–6 output: banner + phases + insights + decisions + blockers + Next Up route tree).
+- Treat `$ARGUMENTS` exactly as `/rihal:status --verbose $ARGUMENTS` would.
 
-<step name="recent_work">
+Do not parse ROADMAP.md, walk SUMMARY.md files, or grep state.json directly. If the underlying CLI reports a drift insight, surface it — do not silently compensate.
 
-## 2. Recent work excerpts
+## Step 2 — Footer note (one-time alias hint)
 
-For the last 2-3 phase directories with SUMMARY.md, pull the one-liner field surgically:
+After the verbose status output, append a single grey line:
 
-```bash
-# find the 3 most recent SUMMARY.md files
-(find .planning/phases -name "SUMMARY.md" -o -name "*-SUMMARY.md" 2>/dev/null) | xargs -r ls -t 2>/dev/null | head -3 | while read f; do
-  node .rihal/bin/rihal-tools.cjs summary-extract "$f" --fields one_liner,status
-done
 ```
-
-Each call returns `{ ok: true, one_liner: "...", status: "..." }`. Collect into an in-memory list for rendering. This avoids loading full SUMMARY.md bodies — context-expensive and unnecessary.
-
-</step>
-
-<step name="insights">
-
-## 3. Insights — surface what the CLI noticed
-
-`SNAPSHOT.insights[]` contains drift warnings, between-milestone detection, phase-dir undercount. Render above the progress bar so the user sees divergences immediately:
-
-```
-⚠ {insight.message}     (severity: warn)
-ℹ {insight.message}     (severity: info)
-```
-
-Each insight that mentions a fix command should have it surfaced exactly as-is — e.g. "Run: node .rihal/bin/rihal-tools.cjs state sync --from-disk".
-
-</step>
-
-<step name="report">
-
-## 4. Render the progress view
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► PROGRESS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-# {SNAPSHOT.project}
-
-{insights block — printed FIRST if present}
-
-**Progress:** {SNAPSHOT.bar}
-**Milestone:** {SNAPSHOT.milestone or "—"}
-**Discuss mode:** {DISCUSS_MODE}
-
-## Recent Work
-- [Phase {N}]: {one_liner extracted in step 2}
-- [Phase {N}]: {one_liner}
-
-## Current Position
-Phase [{SNAPSHOT.current_phase}] of [{SNAPSHOT.phase_count}]
-Plan progress: {completed_count}/{phase_count}
-
-## Key Decisions
-- {SNAPSHOT.decisions[].summary} — [{phase}.{plan}], {date}
-
-## Blockers
-- ⚠ {SNAPSHOT.blockers[].description} — [{phase}.{plan}]
-
-## Pending Todos
-- {todo count} pending — /rihal:check-todos to review
-(Skip if count = 0)
-
-## Active Debug Sessions
-- {count} active — /rihal:debug to continue
-(Skip if count = 0)
-```
-
-Omit any section whose underlying array is empty — don't print "Key Decisions" with zero entries.
-
-</step>
-
-<step name="next_up">
-
-## 5. Next Up — intent tree
-
-Render `SNAPSHOT.routes[]` as a grouped menu. Group by `letter` field (A / B / C). Multiple routes per letter print indented under that letter's heading:
-
-```
-▶ Next Up
-
-  [A] Execute unfinished work
-      → /rihal:execute-phase 999.5
-      → /rihal:execute-phase 66
-
-  [B] Plan researched-but-unplanned phases
-      → /rihal:plan-phase 68
-
-  [C] Close out current milestone
-      → /rihal:audit-milestone
-      → /rihal:complete-milestone
-```
-
-The CLI derives routes from current disk state (researched-not-planned phases, phases with pending plans, all-complete detection for milestone closure). Do NOT second-guess by walking disk yourself.
-
-If `SNAPSHOT.routes[]` is empty or only has fallback entries, print:
-
-```
-▶ Nothing obvious on deck.
-
-  [A] /rihal:progress          — refresh
-  [B] /rihal:council            — start a conversation on what next
-  [C] /rihal:new-milestone     — if the current cycle is done
+(/rihal:progress is an alias of /rihal:status --verbose — same data, same source.)
 ```
 
-</step>
+Skip this footer if `$ARGUMENTS` already contains `--no-alias-hint`.
 
 </process>
 
 ## Success Criteria
 
-- [ ] `progress init` called once — not repeatedly per section
-- [ ] No direct parsing of ROADMAP.md, epics.md, or SUMMARY.md in the workflow body
-- [ ] Recent work uses `summary-extract --fields one_liner` (surgical read)
-- [ ] Insights section rendered when non-empty
-- [ ] Next Up is a grouped route tree, not a single suggestion
+- [ ] Calls the status workflow with verbose mode forced
+- [ ] No independent CLI parsing — single source of truth via `progress init`
+- [ ] Optional alias hint footer printed unless suppressed
 
 ## On Error
 
-- **CLI missing:** "Rihal Code install missing or stale. Run: npx @hanzlaa/rcode install"
-- **CLI returns `ok: false`:** surface the CLI's error verbatim. Do not attempt to compensate — the CLI's failures are the source of truth on what's wrong.
-- **Network-dependent insights:** there should be none. Insights are computed from local state + disk only.
+Defer to `.rihal/workflows/status.md` error handling. This workflow adds nothing on top.

package/rihal/workflows/scan.md

@@ -85,30 +85,115 @@ If user says no, exit.
 mkdir -p .planning/codebase
 ```
 
-## Step 4: Spawn mapper agent
+## Step 4: Announce dispatch (persona-driven)
 
-Spawn a single `rihal-codebase-mapper` agent with the selected focus area:
+Use the canonical dispatch-banner spec at `.rihal/references/dispatch-banner.md`. Read it now if you have not already — it defines the BMAD-style first-person hand-off the user expects.
+
+For this workflow, the dispatched agent is `rihal-codebase-mapper` → persona **Dalil (دليل) — Codebase Scout** 🧭.
+
+Print the DISPATCH banner per the spec. Filled-in template for this workflow:
+
+```
+╭─────────────────────────────────────────────────────────╮
+│  🧭  Dalil (دليل) — Codebase Scout                       │
+╰─────────────────────────────────────────────────────────╯
+
+السلام عليكم — I'm Dalil, your codebase scout.
+
+I'll map this repo for you with focus: {focus}{ — topic: "{topic}" if topic else ""}.
+Before I start I'll discover every source root (not just `src/`),
+detect the language mix from manifests, and — if you gave me a
+topic phrase — sweep for it across all roots before narrowing.
+
+Scope:
+  • Focus: {focus}
+  • Topic phrase: {topic-keyword or "none — broad scan"}
+  • Read-only: I never edit code.
+
+Output:
+  → .planning/codebase/{document_list}
+
+Working now — I'll come back with a Scan Scope declaration
+so you see exactly what I covered (and what I skipped).
+```
+
+Always first-person. Always include the deliverable path. If a topic phrase isn't provided, drop the topic-related lines rather than printing "none".
+
+## Step 5: Spawn mapper agent
+
+Spawn a single `rihal-codebase-mapper` agent. Pass the persona instructions in the prompt so the agent's own response opens in-character:
 
 ```
 Task(
-  prompt="Scan this codebase with focus: {focus}. Write results to .planning/codebase/. Produce only: {document_list}",
+  prompt="You are spawned as **Dalil (دليل) — Codebase Scout**. Open your response with a one-line in-character continuity beat (e.g. 'Dalil here — starting the scan.') and sign your closing summary with your persona name. Use first-person.
+
+  Scan this codebase with focus: {focus}.
+  Topic phrase (literal search target, may be empty): {topic-keyword}
+  Write results to .planning/codebase/. Produce only: {document_list}.
+
+  REQUIRED — every document must open with a 'Scan Scope' section per `.rihal/agents-rules/codebase-mapper/detailed-guide.md` that declares:
+  - Source roots discovered (top-level non-vendored directories)
+  - Source roots searched (grep/glob targets)
+  - Source roots NOT searched and why
+  - Languages detected (from package manifests)
+  - If a topic phrase was provided: a literal `grep -rl '<phrase>' <discovered-roots>` run across ALL source roots, with the file count and an excerpt of matches
+
+  This scope section is non-negotiable — the orchestrator will reject documents missing it.",
   subagent_type="rihal-codebase-mapper",
   model="{resolved_model}"
 )
 ```
 
-## Step 5: Report
+## Step 6: Announce return (persona-driven)
+
+When the agent returns, print the RETURNED banner per `.rihal/references/dispatch-banner.md`. Filled-in template:
 
 ```
-## Scan Complete
+╭─────────────────────────────────────────────────────────╮
+│  ✓  Dalil — back from scout                              │
+╰─────────────────────────────────────────────────────────╯
 
-**Focus:** {focus}
-**Documents produced:**
-{list of documents written with line counts}
+Done — here's what I covered for you.
 
-Use `/rihal:map-codebase` for a comprehensive 4-area parallel scan.
+Covered:
+  • Searched: {roots actually iterated}
+  • Languages: {detected language mix}
+  • Topic sweep: {file count + sample paths, or "n/a"}
+
+Skipped / blind spots:
+  • {explicit list — never leave empty without justification}
+
+Wrote:
+  → .planning/codebase/{doc} ({N} lines)
+
+{Optional: 1-2 follow-up questions Dalil surfaces in his own voice,
+ e.g. "I noticed X — want me to dig deeper?"}
+
+I'm still here if you want to follow up on what I found,
+until the next dispatch. — Dalil
+```
+
+If the document is missing its Scan Scope section, do NOT print the success banner. Instead print:
+
+```
+⚠  Dalil returned without a Scan Scope declaration.
+    Treating this run as incomplete — re-spawn with stricter instructions?
 ```
 
+## Follow-up framing
+
+Until the next `Task()` dispatch, answer follow-up questions about the scan AS Dalil — first-person, sign with `— Dalil`. If the user asks something outside Dalil's scope (e.g. strategy, planning, code editing), hand off explicitly per the dispatch-banner spec and print a fresh DISPATCH banner for the new persona.
+
+## Step 7: Final cue (orchestrator-level, after RETURNED banner)
+
+The RETURNED banner above is Dalil's voice. After it, the orchestrator may add ONE neutral cue line if the user might want a deeper scan:
+
+```
+Tip: `/rihal:map-codebase` runs a 4-area parallel scan if you want broader coverage.
+```
+
+Skip this cue if the user already asked for a focused scan — don't push an upsell.
+
 </process>
 
 <success_criteria>