@hanzlaa/rcode 2.6.3 → 2.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "2.6.3",
+  "version": "2.6.5",
   "description": "Rihal Code (rcode) — installable context-brain for Rihalians. 43 agents, 99 slash commands, 56 skills, pullable Rihal standards. Unified install for Claude Code, Cursor, and Gemini.",
   "main": "cli/index.js",
   "bin": {

package/rihal/references/verb-dictionary.md

@@ -0,0 +1,129 @@
+# Verb Dictionary — multilingual intent matching
+
+**Purpose:** single source of truth for action verbs across all Rihal workflows that do intent matching. Without this, each workflow's matcher diverges and Roman Urdu / Hindi instructions silently miss.
+
+**How to use from a workflow:** include this file via `@.rihal/references/verb-dictionary.md` and reference categories by name (e.g. *"verbs from §Create"*) instead of restating English-only lists inline.
+
+---
+
+## §Create — make / start / new / open
+
+Match if `$QUESTION` contains any of these (case-insensitive):
+
+- **English:** `create`, `make`, `start`, `build`, `set up`, `setup`, `kick off`, `spin up`, `open`, `begin`, `draft`, `generate`, `produce`, `initialize`, `init`, `bootstrap`, `establish`, `form`
+- **Roman Urdu / Hindi:** `bnao`, `banao`, `bana do`, `bnado`, `banaa`, `banade`, `banayein`, `banadijiye`, `shuru karo`, `shuro karo`, `start karo`, `create karo`, `naya banao`, `nya banao`, `draft karo`, `banalo`, `khol do`, `khol lo`, `kholiye`
+- **Arabic transliteration:** `ansha'`, `inshaa'`, `a3mal`, `ibda'`
+
+## §Add — append / include / attach / extend
+
+- **English:** `add`, `append`, `include`, `attach`, `insert`, `extend`, `expand`, `register`
+- **Roman Urdu / Hindi:** `add karo`, `daal do`, `daalo`, `daal de`, `jor do`, `jor de`, `lagao`, `lagado`, `shamil karo`, `shaamil karo`, `barhao`
+- **Arabic transliteration:** `azif`, `dam'`
+
+## §Plan — design / scope / outline
+
+- **English:** `plan`, `design`, `draft`, `scope`, `outline`, `architect`, `lay out`, `schedule`
+- **Roman Urdu / Hindi:** `plan karo`, `design karo`, `sochlo`, `soch lo`, `layout banao`, `tarteeb do`, `tartib karo`
+- **Arabic transliteration:** `khattit`, `tasmim`
+
+## §Execute — run / build / ship / implement / do
+
+- **English:** `execute`, `run`, `build`, `ship`, `complete`, `do`, `implement`, `deliver`, `finish`, `wrap up`, `compile`
+- **Roman Urdu / Hindi:** `chalao`, `chala do`, `run karo`, `kar do`, `kardo`, `kar lo`, `karlo`, `implement karo`, `mukammal karo`, `complete karo`, `khatam karo`, `pura karo`
+- **Arabic transliteration:** `naffidh`, `aakmel`, `nafidh`
+
+## §Review — audit / check / inspect / verify / validate
+
+- **English:** `review`, `audit`, `check`, `inspect`, `verify`, `validate`, `examine`, `assess`, `evaluate`
+- **Roman Urdu / Hindi:** `dekho`, `dekh lo`, `dekhlo`, `check karo`, `audit karo`, `verify karo`, `validate karo`, `parkho`, `parakhh`, `mulahiza karo`, `nazar dalo`, `jaiza lo`
+- **Arabic transliteration:** `raji'`, `tahaqqaq`, `dakhq`
+
+## §Show — list / display / get / fetch / see
+
+- **English:** `show`, `list`, `display`, `get`, `fetch`, `see`, `view`, `print`, `output`, `summarize`
+- **Roman Urdu / Hindi:** `dikhao`, `dikha do`, `dikhado`, `dikha de`, `list karo`, `batao`, `bata do`, `bata de`, `kholo`, `khol do`
+- **Arabic transliteration:** `azhir`, `arini`, `aktub`
+
+## §Remove — delete / drop / undo / revert / kill
+
+- **English:** `remove`, `delete`, `drop`, `undo`, `revert`, `rollback`, `kill`, `purge`, `uninstall`, `clear`, `wipe`, `erase`
+- **Roman Urdu / Hindi:** `hatao`, `hata do`, `hatado`, `mita do`, `mita lo`, `mitao`, `delete karo`, `ulto`, `revert karo`, `nikalo`, `nikal do`, `khaali karo`
+- **Arabic transliteration:** `ihdhif`, `azhil`, `imhu`
+
+## §Update — modify / change / edit / refresh / fix
+
+- **English:** `update`, `modify`, `change`, `edit`, `refresh`, `fix`, `patch`, `tweak`, `adjust`, `correct`, `repair`
+- **Roman Urdu / Hindi:** `update karo`, `badlo`, `badal do`, `badal de`, `change karo`, `edit karo`, `theek karo`, `theek kar do`, `thiek karo`, `fix karo`, `behtar karo`, `behter karo`, `improve karo`
+- **Arabic transliteration:** `ghair`, `aslih`, `hadith`
+
+## §Pause — stop / wait / hold / cancel
+
+- **English:** `pause`, `stop`, `wait`, `hold`, `cancel`, `abort`, `halt`, `freeze`, `defer`
+- **Roman Urdu / Hindi:** `ruko`, `ruk jao`, `band karo`, `band kardo`, `cancel karo`, `roko`, `rok do`, `rok de`, `pause karo`, `wapas karo`
+- **Arabic transliteration:** `tawaqaf`, `intazir`
+
+## §Resume — continue / pick up / restart
+
+- **English:** `resume`, `continue`, `pick up`, `restart`, `re-run`, `replay`, `re-do`, `keep going`, `proceed`
+- **Roman Urdu / Hindi:** `phir se shuru karo`, `aage barho`, `aage chalao`, `continue karo`, `wapas chalao`, `dobara chalao`, `dobara karo`
+- **Arabic transliteration:** `astamir`, `i'ad`
+
+---
+
+## Scope nouns (paired with verbs to detect intent)
+
+These are matched alongside §Create / §Add / §Plan verbs to determine the dispatch route.
+
+| Scope noun | Aliases (English + Urdu) | Maps to (workflow) |
+|---|---|---|
+| milestone | `milestone`, `milestones`, `release`, `version`, `cycle` | `/rihal:new-milestone` |
+| phase | `phase`, `phases` (singular intent — "add a phase") | `/rihal:add-phase` |
+| story | `story`, `stories`, `user story`, `kahani` | `/rihal:create-story` |
+| epic | `epic`, `epics`, `epics and stories` | `/rihal:create-epics-and-stories` |
+| sprint | `sprint`, `iteration` | `/rihal:sprint-planning` |
+| PRD | `PRD`, `requirements doc`, `product requirements` | `/rihal:create-prd` |
+| roadmap | `roadmap`, `plan` (top-level) | `/rihal:create-milestone` |
+| council | `council`, `majlis`, `panel`, `mashwara`, `salah` | `/rihal:council` |
+| plan (verb form — "plan phase N") | `plan` | `/rihal:plan` |
+| story (impl) | `dev story`, `implement story`, `build story` | `/rihal:dev-story` |
+| brainstorm | `brainstorm`, `ideas`, `sochain`, `sochna` | `/rihal:brainstorm` |
+| review (code) | `code review`, `karpathy`, `check my diff` | `/rihal:karpathy-audit` / `/rihal:code-review` |
+| debug | `debug`, `fix`, `bug`, `error`, `crash`, `kharab`, `theek` | `/rihal:debug` |
+
+---
+
+## Usage examples
+
+**From a workflow (e.g. `do.md`):**
+
+```markdown
+## Step: Match intent
+
+Apply §Create + scope-noun match per @.rihal/references/verb-dictionary.md.
+
+If `$QUESTION` contains any verb from §Create AND any scope noun from the
+table above, dispatch directly to the mapped workflow without an
+ambiguity prompt.
+
+Example: "milestone bnao" → §Create matches "bnao", scope matches
+"milestone" → /rihal:new-milestone (with state-aware redirect to
+/rihal:add-phase if a milestone is already active).
+```
+
+**From an agent file (e.g. `rihal-codebase-mapper.md`) when interpreting the orchestrator prompt:**
+
+```markdown
+@.rihal/references/verb-dictionary.md
+
+## Workflow
+
+Recognize §Show / §Review / §Update verbs against the codebase. Honor
+multilingual phrasing — never silently fall through because a Roman
+Urdu instruction was the verb form.
+```
+
+---
+
+## Maintenance
+
+Every entry must be a verb actually observed in user input — not invented. When you discover a new phrasing that broke matching, add it to the relevant category here rather than to the consuming workflow's local list. Single source of truth.

package/rihal/workflows/do.md

@@ -4,6 +4,7 @@ Analyze freeform text from the user and route to the most appropriate Rihal comm
 
 <required_reading>
 @.rihal/references/output-format.md
+@.rihal/references/verb-dictionary.md
 Read all files referenced by the invoking prompt's execution_context before starting.
 </required_reading>
 
@@ -149,25 +150,23 @@ When the user uses a literal create/make/start verb paired with a scope-noun (mi
 
 This was a real bug: `/rihal:do "milestone bnao aur ... list down karo"` triggered an ambiguity prompt offering new-milestone vs add-phase vs create-epics-and-stories — even though the user literally said "milestone bnao" (= "create a milestone" in Roman Urdu). That second-guessing wasted the user's time and broke trust.
 
-**Verb dictionary — match if `$QUESTION` contains any of these (case-insensitive):**
+**Verb + scope detection — sourced from `@.rihal/references/verb-dictionary.md`.**
 
-- English: `create`, `make`, `start`, `add`, `new`, `set up`, `setup`, `kick off`, `spin up`
-- Roman Urdu / Hindi: `bnao`, `banao`, `bana do`, `bnado`, `banaa`, `banade`, `shuru karo`, `start karo`, `create karo`, `naya banao`, `add karo`, `daal do`
-- Arabic transliteration: `ansha'`, `inshaa`
+Match if `$QUESTION` contains any verb from §Create or §Add (English + Roman Urdu/Hindi + Arabic transliteration — full list lives in the dictionary file, do not duplicate here). Pair with a scope noun to determine the route.
 
-**Scope-noun → command map:**
+The full mapping is in the dictionary's "Scope nouns" table. Pre-conditions enforced by this workflow:
 
-| Scope noun in input | Direct route | Pre-condition |
+| Scope noun | Direct route | Pre-condition (this workflow only) |
 |---|---|---|
-| `milestone`, `milestones` | `/rihal:new-milestone` | none — methodology chain assumed when greenfield_guard cleared |
-| `phase`, `phases` (singular intent — "add a phase") | `/rihal:add-phase` | HAS_PHASES OR HAS_PRD true |
-| `story`, `stories`, `user story` | `/rihal:create-story` | HAS_EPICS true |
-| `epic`, `epics`, `epics and stories` | `/rihal:create-epics-and-stories` | HAS_PRD true |
-| `sprint` | `/rihal:sprint-planning` | HAS_EPICS true |
-| `PRD`, `requirements doc`, `product requirements` | `/rihal:create-prd` | none |
-| `roadmap` | `/rihal:create-milestone` | HAS_PRD true |
-| `council`, `majlis` | `/rihal:council` | none |
-| `plan` (verb — "plan phase N") | `/rihal:plan` | HAS_PHASES true |
+| milestone | `/rihal:new-milestone` | none — methodology chain assumed when greenfield_guard cleared |
+| phase | `/rihal:add-phase` | HAS_PHASES OR HAS_PRD true |
+| story | `/rihal:create-story` | HAS_EPICS true |
+| epic | `/rihal:create-epics-and-stories` | HAS_PRD true |
+| sprint | `/rihal:sprint-planning` | HAS_EPICS true |
+| PRD | `/rihal:create-prd` | none |
+| roadmap | `/rihal:create-milestone` | HAS_PRD true |
+| council | `/rihal:council` | none |
+| plan (verb) | `/rihal:plan` | HAS_PHASES true |
 
 **Behavior:**
 1. If both a verb AND a scope-noun match, fire this step.

package/rihal/workflows/quick.md

@@ -1,44 +1,88 @@
 <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.
+Execute small ad-hoc tasks with guarantees. Two real modes the workflow auto-detects:
 
-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.
+- **Trivial inline** — single ≤ 3-file change, finishes in 1-2 minutes, no planning needed.
+- **Bulk-task auto-route** — when the input contains many tasks (numbered list with 5+ items, or several distinct bugs/asks), automatically route to /rihal:add-phase with the task list pre-extracted, so the user doesn't have to copy-paste their list a second time.
 
-Use /rihal:quick for anything that needs multi-step planning or research.
+Closes the gap where /rihal:quick used to refuse + show a 4-option menu when given many tasks (forcing the user to re-enter the same list into another command).
 </purpose>
 
+<required_reading>
+@.rihal/references/verb-dictionary.md
+</required_reading>
+
 <process>
 
 <step name="parse_task">
-Parse `$ARGUMENTS` for the task description.
+Parse `$ARGUMENTS` for the task description. If empty, ask:
 
-If empty, ask:
 ```
-What's the quick fix? (one sentence)
+What's the quick fix? (one sentence — or paste a bug list and I'll auto-route)
 ```
 
 Store as `$TASK`.
 </step>
 
-<step name="scope_check">
-**Before doing anything, verify this is actually trivial.**
+<step name="bulk_detection" priority="first-match">
+**Detect 'many tasks in one input'** — auto-route instead of refusing.
+
+Match if `$TASK` contains ANY of:
+
+- 5+ numbered list items (`/^\s*\d+\.\s/m` with ≥ 5 matches)
+- 5+ bullet items (`/^\s*[-*]\s/m` with ≥ 5 matches)
+- 3+ "Bug Report:" / "Issue:" / "Severity:" headers
+- 3+ separate "Status:" or "Priority:" lines
+- > 60 lines total
+- Contains the phrase "buht zada bugs" / "many bugs" / "list of bugs" / "bug list" / "saare bugs" / "all these bugs"
+
+If matched, **AUTO-ROUTE to `/rihal:add-phase`** without asking. Do not refuse, do not show a menu, do not ask the user to repaste.
+
+Procedure:
+
+1. Detect active milestone (per `do.md` state-aware logic):
+   ```bash
+   ACTIVE_MILESTONE=$(grep -m1 '^## Current Milestone' .planning/PROJECT.md 2>/dev/null | sed 's/^## Current Milestone[: ]*//' | xargs)
+   ```
+2. Generate a phase slug from the bulk content topic:
+   - If most items mention "bug" / "fix" / "broken" → `09-ui-bug-cleanup` (use next phase number)
+   - If most mention "feature" / "add" / "new" → `09-feature-batch`
+   - Otherwise → `09-task-batch`
+3. Print the auto-route banner:
+   ```
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    /rihal:quick — AUTO-ROUTING
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+   Detected: {N} tasks in input — too many for inline.
+   Active milestone: {ACTIVE_MILESTONE or "none"}
+   Routing to: /rihal:add-phase {phase-slug}
+   Reason: bulk-detection threshold ({matched signal}) — auto-route avoids
+           refusing and forcing you to re-paste the list.
+   ```
+4. Dispatch `/rihal:add-phase {phase-slug}` and pass `$TASK` verbatim. The add-phase workflow uses the pre-extracted task list as the phase task list — no user re-entry needed.
+5. STOP this workflow — add-phase takes over from here.
+
+If the bulk detection does NOT match, continue to scope_check.
+</step>
 
-A task is trivial if it can be completed in:
+<step name="scope_check">
+**Lightweight trivial-task gate** for the inline path. Reasonable scope for inline:
 - ≤ 3 file edits
-- ≤ 1 minute of work
+- ≤ 2 minutes of work
 - No new dependencies or architecture changes
-- No research needed
+- No multi-file research needed
 
-If the task seems non-trivial (multi-file refactor, new feature, needs research),
-say:
+If the task seems non-trivial but did NOT trigger bulk_detection above (e.g., a single complex task — not a list), redirect:
 
 ```
-This looks like it needs planning. Use /rihal:quick instead:
-  /rihal:quick "{task description}"
+This is a single task but looks non-trivial. Recommended:
+  /rihal:add-phase — for multi-file refactor / new feature / structural change
+  /rihal:plan      — when scope is clear, jump straight to a SPRINT.md plan
+
+Or paste --force-inline at the end of your input to override and try inline anyway.
 ```
 
-And stop.
+If `$TASK` contains `--force-inline`, skip this gate and continue.
 </step>
 
 <step name="execute_inline">
@@ -46,33 +90,86 @@ 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)
+3. Verify (run existing tests if applicable, or quick sanity check)
+
+**No SPRINT.md. No subagents. Just do it.**
+</step>
+
+<step name="blocker_handling">
+**When investigation reveals a blocker, do NOT present a multi-option menu.** Pick ONE response per the rules below.
+
+Common blocker types:
+- Need a screenshot / browser-rendered state to confirm
+- Need the dev server running
+- Need a decision the user hasn't given yet
+- Need access to an external system (production logs, Sentry, etc.)
+
+**Rules:**
+
+1. **If the original input was a LIST of tasks** (bulk_detection-eligible OR the user passed multiple tasks): silently SKIP the blocked task, log the blocker in the running tracker, and PIVOT to the next clearly-runnable task in the list. Do not stop. Do not ask. Do not present 5 options.
+
+   Example log line (appended to `.planning/BUG-TRACKER-YYYY-MM-DD.md` if it exists, or stdout otherwise):
+
+   ```
+   ⏸  #36 (Extraction wizard CSS) — skipped: needs runtime screenshot to confirm cascade-layer hypothesis. Will resume when dev server is available.
+   ```
+
+   Then continue with #19 / #17 / whichever is the next-most-runnable in the list. State the pivot in one line:
 
-**No SPRINT.md.** Just do it.
+   ```
+   ▶ Pivoting to next runnable: #19 (Breadcrumb UUID→name) — clear scope, no runtime needed.
+   ```
+
+2. **If the input was a SINGLE task and there's nothing to pivot to**: stop with ONE line stating the single specific blocker and how to unblock it. No menu. No options. The user pastes back the resolved info and re-runs.
+
+   ```
+   ⏸  Blocked on: a screenshot of the broken Extraction wizard. Paste the screenshot or run `pnpm dev` and share what you see — I'll resume from where I left off.
+   ```
+
+3. **If the user passed `--force-inline` AND the input was single-task AND blocked**: attempt the highest-confidence speculative fix, COMMIT it with a clear "speculative — needs runtime verification" prefix in the commit message, and proceed. The user explicitly chose this path.
+
+**Never present a 4+ option menu in blocker_handling.** Multi-option menus during execution are decision-fatigue. Pick one response, do it, move on.
+</step>
+
+<step name="next_task_loop">
+**If the original input was a list and there are remaining tasks after this one** (whether the current task succeeded, failed, or was skipped due to blocker), automatically continue to the next task without asking. State the pivot in one line and re-enter execute_inline.
+
+**Stop the loop only when:**
+- All tasks in the list are processed (done / skipped / blocked)
+- A task touches `> 5` files (escalate the rest of the list to /rihal:add-phase)
+- The user types stop / cancel / pause
+
+At the end of the loop, summarise:
+
+```
+✅ Loop complete: {N} done · {M} skipped · {K} blocked
+   Done:    {bullet list with commit hashes}
+   Skipped: {bullet list with reasons}
+   Blocked: {bullet list with what info is needed}
+
+Resume blocked tasks: {one-line guidance on what to provide and re-run}
+```
 </step>
 
 <step name="commit">
-Commit the change atomically:
+Commit atomically with conventional commit format (`fix:`, `feat:`, `docs:`, `chore:`, `refactor:`):
 
 ```bash
 git add -A
-git commit -m "fix: {concise description of what changed}"
+git commit -m "{type}: {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.
+If `.planning/STATE.md` exists with a "Quick Tasks Completed" table, append:
 
 ```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
+  echo "| $(date +%Y-%m-%d) | quick | $TASK | ✅ |" >> .planning/STATE.md
 fi
 ```
+
+Skip silently if the table doesn't exist.
 </step>
 
 <step name="done">
@@ -81,7 +178,7 @@ Report completion:
 ```
 ✅ Done: {what was changed}
    Commit: {short hash}
-   Files: {list of changed files}
+   Files:  {list of changed files}
 ```
 
 No next-step suggestions. No workflow routing. Just done.
@@ -90,16 +187,16 @@ No next-step suggestions. No workflow routing. Just done.
 </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
+- NEVER spawn a Task/subagent — this runs inline (except via the add-phase auto-route, which is itself a workflow dispatch, not a Task spawn)
+- NEVER create SPRINT.md or SUMMARY.md files directly (add-phase will, when bulk-routed)
+- NEVER run research or plan-checking inline
+- If bulk_detection matches, auto-route silently — do not stop and ask
+- If a single non-bulk task exceeds 3 file edits and the user did NOT pass `--force-inline`, redirect to /rihal:add-phase or /rihal:plan
 </guardrails>
 
 <success_criteria>
-- [ ] Task completed in current context (no subagents)
-- [ ] Atomic git commit with conventional message
+- [ ] Bulk inputs are auto-routed to /rihal:add-phase without forcing the user to re-paste
+- [ ] Trivial inputs are completed inline (single context, ≤3 files, conventional commit)
 - [ ] STATE.md updated if it exists
-- [ ] Total operation under 2 minutes wall time
+- [ ] No self-referential redirects (the old quick.md redirected to /rihal:quick — that infinite loop is closed)
 </success_criteria>