@hanzlaa/rcode 2.6.3 → 2.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "2.6.3",
+  "version": "2.6.4",
   "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/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,30 @@ 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.** Just do it.
+**No SPRINT.md. No subagents. Just do it.**
 </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 +122,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 +131,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>