@hanzlaa/rcode 3.6.16 → 4.0.0

package/README.md

@@ -1,177 +1,198 @@
-# Rihal Code (rcode)
+# rcode
 
 <div dir="rtl">طريقة رحال</div>
 
-> **The AI team that never forgets.** Persistent memory, 45 specialist agents, 109 commands — install once, and your AI IDE gets a project brain that survives every session reset.
+> **A curated composition of the best AI-development practices — shipped as files.** Surgical-change discipline, parallel-agent orchestration, persistent Memory Bank patterns, phase-driven planning — packaged as one workflow for Claude Code power users. No multi-agent harness. No vector DB. Your IDE keeps the methodology; the project keeps the memory.
 
 ```bash
-npx @hanzlaa/rcode install    # one command, zero dependencies
+pnpm dlx @hanzlaa/rcode install
 ```
 
 [![npm version](https://img.shields.io/npm/v/@hanzlaa/rcode)](https://www.npmjs.com/package/@hanzlaa/rcode)
 [![downloads](https://img.shields.io/npm/dw/@hanzlaa/rcode)](https://www.npmjs.com/package/@hanzlaa/rcode)
+[![CI](https://github.com/hanzlahabib/rihal-code/actions/workflows/test.yml/badge.svg)](https://github.com/hanzlahabib/rihal-code/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-Status: actively developed — published on npm as `@hanzlaa/rcode` v3.6.x, with an automated test suite covered by `node --test`.
+Status: `@hanzlaa/rcode` v4.0.0 on npm. 339 automated tests across 58 files, 45 agents, 116 commands, 86 skills. Actively dogfooded on real projects every week.
 
 ---
 
-## See it work
+## About the author
 
-The full loop runs in three commands — `/rihal-council` → `/rihal-plan` → `/rihal-execute`. The Diwan dashboard (`npm run dashboard`) renders project state, decisions, and the Memory Bank in one view.
+Built by [Hanzla Habib](https://github.com/hanzlahabib). rcode is a curated composition of the best public AI-development practices — surgical-change discipline, parallel-agent orchestration, persistent Memory Bank patterns, phase-driven planning — packaged as one workflow for Claude Code power users. Every workflow, agent, and skill in this repo was designed in dialogue with the same LLM you'll be running. The methodology shipped here is the one used to build rcode itself.
 
 ---
 
-## Why this exists
+## Who builds this
 
-Every project carries unwritten context — how the team reviews PRs, what "done" means, how milestones sequence. That context sits in people's heads, Slack, and senior engineers' review comments. AI assistants pick it up never, because every new chat session starts knowing nothing about how this project actually works.
+One developer ([Hanzla Habib](https://github.com/hanzlahabib)) — building rcode **with** Claude, not just for it. Every workflow, agent, and skill in this repo was designed in dialogue with the same LLM you'll be running. The methodology shipped here is the one I use to build rcode itself.
 
-You'll feel rcode pay off if you've lived any of these:
+That means two things:
+- **The dogfood loop is the test suite.** Every release is run against fresh projects (calories-counter RN, reelspeed services) before publish. Bugs surface as GitHub issues, get fixed, ship.
+- **The tool grows from real friction, not theory.** Half the v3.6.20 fixes came from a single dogfeed session where 3 parallel agents found 50+ real bugs in 4 hours.
 
-- **AI agents lose context mid-project.** Three sessions in, the assistant has forgotten the architectural decision you made on day one.
-- **Onboarding a teammate** means a 30-minute archaeology dig through Slack, Notion, and review comments.
-- **Late client requirements** keep shifting the goal posts, with no record of what was decided when.
-- **MVPs that work but can't be revamped** without rewriting from scratch — the original context is lost.
+If you're a solo dev or small team using Claude Code (or Cursor, Gemini, VS Code), rcode gives you the **scaffolding a 10-person engineering org would have**: code review standards, sprint cadence, decision archives, onboarding context — without hiring the org.
 
-rcode fixes that with a checked-in **Memory Bank** (`.rihal/memory/`), distinctive engineering personas, and a phased workflow that survives session resets. One install, and the AI knows. Every session. Every repo. Every contributor.
+---
 
-It's not a chatbot. It's a methodology.
+## What it actually is
 
----
+Three layers, specialised for software delivery:
 
-## Quickstart
+| Layer | What lives here | Example |
+|-------|-----------------|---------|
+| **Memory** | `.rcode/memory/` — git-tracked markdown, lossless distillates | "We chose Postgres over Mongo because of JSON-B + RLS — see ADR-007" |
+| **Skills** | `rcode/skills/` — 85 phrase-activated playbooks | `rcode-sprint-checker` validates file/symbol refs before execute |
+| **Workflows** | `rcode/workflows/` — orchestrated multi-step paths | `/rcode-plan` runs research → planner → checker → confirm |
 
-### Install — two steps, one minute
+Single agent navigates the structure. No LangChain, no AutoGen, no orchestrator process. Just folders the model can read.
 
-rcode ships in two parts. Run them both up front so nothing surfaces as an afterthought later:
+---
 
-**Step 1 — project files (required).** In any project directory (existing codebase OR empty folder):
+## Why I built it
 
-```bash
-npx @hanzlaa/rcode install
-```
+I've shipped products solo for years and watched the same failure repeat in every project:
 
-**Step 2 — `rcode` on your PATH (optional).** For the `rcode` CLI command (e.g. `rcode version`, `rcode update`), install globally once:
+- **Session 1:** Productive — agent helps me design auth, picks Postgres, plans the schema.
+- **Session 5:** Agent has no idea I picked Postgres. Suggests Mongo. We argue. I copy-paste the decision back in.
+- **Session 20:** I'm pasting in 4K tokens of "here's what we decided" every session. The agent never learns. The project file structure isn't enough — decisions live in chat.
 
-```bash
-npm install -g @hanzlaa/rcode
-```
+rcode is the answer I built for myself. **The decision lives in `.rcode/memory/decisions.md`. The agent reads it. Done.**
 
-[Live on npm](https://www.npmjs.com/package/@hanzlaa/rcode) as `@hanzlaa/rcode`. Pure file shipping, no runtime dependencies. Step 1 installs into:
+Same problem at team scale: onboarding takes 30 minutes of archaeology. Late requirements shift goalposts with no audit trail. MVPs work but can't be revamped because the original "why" is gone. rcode checks the context in, so the next person (or session) starts oriented.
 
-- `.rihal/` — config, workflows, references, bin (Rihal infrastructure)
-- `.claude/agents/` — 45 first-class subagents
-- `.claude/commands/rihal/` — 109 slash commands
-- `.claude/skills/` — 85 phrase-activated skills
-- `rihal/brain/` — Rihal standards pulled from upstream
-- `.planning/` — where your artifacts land
+---
 
-Restart Claude Code (or your IDE), type `/`, and every `rihal-*` command appears. Update anytime with `npx @hanzlaa/rcode update`.
+## Concrete benefits
 
-See [`docs/install.md`](docs/install.md) for flavors (module subsets, IDE options, version pinning, yolo mode).
+What you'll feel in week one:
 
-### Then begin the rihla
+- **No more re-explaining.** Decisions, blockers, conventions live in `.rcode/memory/` — agent reads them at session start automatically (~5K tokens, fully oriented).
+- **Phased delivery without ceremony.** `/rcode-new-project` produces a roadmap with phases → sprints → tasks. `/rcode-plan` produces SPRINT.md files. `/rcode-execute` runs them with atomic commits. No Jira required.
+- **Specialist review on tap.** Want a Karpathy-style review of your last commit? `/rcode-review --karpathy`. Want a council debate on a decision? `/rcode-council should I rewrite auth?` — 5 agents answer in parallel, round 2 they challenge each other.
+- **Intent guards.** Run the wrong command and get a one-line redirect, not a useless output.
+- **Health check.** `rcode-tools health` returns JSON — milestone health, state snapshot, project status. Wire it into your dashboard.
+- **Drift detection.** SEO-style drift baselines for any URL the project ships. Catches when somebody silently breaks your `<title>` or schema markup.
 
-```
-/rihal-init
-```
+What you won't get:
+- Magic. The agent still needs precise prompts; rcode just removes the boilerplate context-loading from each one.
+- A productivity multiplier on a 200-line side project. You'll feel it on real work — multi-week, multi-contributor, multi-decision.
 
-`/rihal-init` is the single first command — there is no other entry point to choose. It detects your project state (fresh / existing-with-no-rihal / returning), asks a few configuration questions, and routes you to the right first action. For a greenfield project it routes into `/rihal-new-project` automatically — you never call that directly, it's a sub-path of `/rihal-init`.
+---
 
-### The full loop
+## What it isn't (anti-hype)
 
-```
-/rihal-council should I rewrite auth?        → 5 agents debate in parallel, 2 rounds
-/rihal-plan --research build a rental app    → researcher grounds, sprint-checker verifies
-/rihal-execute .planning/plans/01/PLAN.md    → atomic commits + post-gates
-/rihal-status                                → phases, decisions, blockers, sessions
-```
+I dogfood this hard, so the honest version:
 
-**Brand new?** Do the [Golden Path](docs/TIERS.md#-starter--the-golden-path): scaffold → PRD → stories → sprint → dev → review → status. Seven skills, one project, end-to-end.
+- **Not a chatbot wrapper.** Zero opinions about which LLM. Works with Claude Code, Cursor, Gemini, VS Code, Antigravity, Windsurf. Bring your own keys.
+- **Not a multi-agent framework.** No agent-to-agent message bus. One agent reads markdown structure and navigates it.
+- **Not a no-code tool.** You will read markdown files. You will write commit messages. You will type slash commands.
+- **Not finished.** v4 is solid for solo and small-team work. Open issues are tracked at the [issues page](https://github.com/hanzlahabib/rihal-code/issues) — most P1 bugs get fixed within 48 hours of a dogfeed run.
+- **Not replacing senior engineers.** It gives you their scaffolding (review standards, sprint hygiene, decision archives). You still need judgment for the hard calls.
 
 ---
 
-## What makes Rihal different
+## How it stacks up
 
-Most AI tools give you one assistant pretending to be everything. **Rihal Code gives you Rihal's team — and Rihal's brain — inside every project.**
+| | Cursor / Windsurf | CrewAI / AutoGen | LangChain / LlamaIndex | **rcode** |
+|---|---|---|---|---|
+| **Per-project memory** | Per-user, not git-tracked | Vector DB | Vector DB + chunking | Git-tracked markdown |
+| **Specialist agents** | 1 generalist | Define in Python | Define in Python | 45 shipped |
+| **Install** | IDE extension | `pip install` + config | `pip install` + code | `pnpm dlx` — one command |
+| **Infrastructure** | Cloud API | Python server | Vector store + indexer | Zero — pure files |
+| **IDE lock-in** | Cursor only | Framework-specific | Framework-specific | Claude / Cursor / Gemini / VS Code / Antigravity / Windsurf |
+| **Auditability** | Chat scrollback | Tracing dashboard | Tracing dashboard | `git log` |
 
-How it stacks up against the tools you already know:
+The point isn't "I beat LangChain." The point is **you don't need LangChain for software delivery**. You need a methodology that survives session resets, and a methodology lives in files.
 
-| Dimension | Cursor / Windsurf | CrewAI / AutoGen | **Rihal Code** |
-|-----------|-------------------|------------------|----------------|
-| Per-project memory | Per-user, not git-tracked | Requires a vector DB | Git-tracked markdown in `.rihal/memory/` |
-| Specialist agents | 1 generalist with IDE context | Define your own in code | 45 shipped at install time |
-| Workflow gates | None | Build your own | Structural — refuses to run without upstream |
-| Infrastructure | Cloud API + local IDE | Python server + dependencies | Zero — pure files |
-| IDE lock-in | Cursor only | Framework-specific | Claude, Cursor, Gemini, Codex |
-| Install | IDE extension | `pip install` + config + code | `npx install` — one command |
+---
 
-Full breakdown: [`docs/USP.md`](docs/USP.md).
+## Quickstart
 
-### Persistent project memory
+```bash
+# 1. Install into any project (existing codebase or empty folder)
+pnpm dlx @hanzlaa/rcode install
 
-A checked-in **Memory Bank** at `.rihal/memory/` — visible in the Diwan dashboard, with lossless distillates for fast LLM hydration. A typical session loads ~5K tokens of Memory Bank and is fully oriented to the project's history, decisions, and known issues. See [`MEMORY_BANK.md`](MEMORY_BANK.md) for the spec.
+# 2. Restart Claude Code, then:
+/rcode-init
+```
 
-### Intent guards catch wrong commands
+`/rcode-init` detects your project state (fresh / existing / returning) and routes to the right first action. For a greenfield project it auto-routes to `/rcode-new-project`.
 
-Run the wrong command and you get a single-line copy-paste redirect — not a useless output.
+### The full loop
 
 ```
-/rihal-plan should we use postgres or mongo?
-⚠ That's a decision question, not a planning input.
-/rihal-council should we use postgres or mongo?
+/rcode-council should I rewrite auth?        → 5 agents debate, 2 rounds
+/rcode-plan --research build a rental app    → researcher grounds, sprint-checker verifies
+/rcode-execute .planning/plans/01/PLAN.md    → atomic commits + post-gates
+/rcode-status                                → phases, decisions, blockers, sessions
 ```
 
-Every workflow has a Step 0.5 intent detector.
+Full install flavors and IDE options: [`docs/install.md`](docs/install.md). Step-by-step first project: [`docs/getting-started.md`](docs/getting-started.md).
+
+---
+
+## What's next (roadmap)
+
+The directions I'm building toward — open to PRs on any of these:
 
-### Markdown-first agent design
+**Near-term (next 2 releases):**
+- **Dialogue → pillars extractor.** Run a discussion, get back reusable voice/constraint/methodology MDs. `/rcode-discuss-phase` already captures decisions; this would distill *style* and *constraints* too.
+- **User-level pillars** (`~/.rcode/pillars/`) for cross-project reuse — your voice, your review style, your testing standards live once, used everywhere.
+- **Token telemetry.** Real per-response cost tracking via Claude Code's Stop hook (issue #745).
+- **Slim agent split.** 6 agents currently exceed the 100-line lean target — splitting into role-focused variants.
 
-Most agent frameworks wrap their logic in Python classes, JSON schemas, and orchestration layers. rcode doesn't. Every agent is a markdown file — the model follows structured prose, no wrapper needed.
+**Mid-term:**
+- **Cloud sync for Memory Bank** (opt-in) — so distributed teams share `.rcode/memory/` without merge conflicts.
+- **Voice-controlled sessions** — drive rcode in a live meeting via voice; trigger workflows by keyword in conversation.
+- **Multi-language docs** — Arabic-first, English mirrored. Currently the methodology is English-only with Arabic naming.
 
-The design rule: **markdown owns the logic, scripts own the boundaries.** Heavy playbook content lives in `rihal/references/` and gets `@-include`d at spawn time, so agent files stay thin (≤100 lines) without losing context.
+**Long-term direction:**
+The bet: **methodology as a product**. Skills, workflows, and agents become a portable "engineering org in a folder" that travels with you across projects, IDEs, and LLM vendors. The methodology outlives any specific model.
 
-### Three execution modes
+The non-goal: building yet another agent framework. There are enough. rcode stays files.
 
-- **`/rihal-council`** — parallel debate: 3-5 agents answer simultaneously, then challenge each other in Round 2. For strategic decisions where you want disagreement, not consensus.
-- **`/rihal-chain`** — sequential pipeline: each agent reads the previous one's artifact (RESEARCH.md → SCOPE.md → PLAN.md).
-- **`/rihal-discuss`** — single agent, quick-sync: one expert, conversational, no mandatory artifact.
+---
+
+## Honest state of things
 
-### Karpathy coding guidelines
+- **v4.0.0** is the current release — Memory Bank now ships populated by default, brain-pull is live, and 50+ bug fixes landed from the most recent 3-project dogfeed run.
+- **Open issues**: ~50 — half are feature requests, the rest are backlog bugs ranked by severity.
+- **Test suite**: 339 automated tests across 58 files, 100% pass on every release. Coverage is structural (compliance + artifact schema + workflow behavioral), not line-coverage.
+- **Real users**: I run it on 4 projects daily. A handful of others run it on theirs. If you find a bug, file it — most P1s ship within 48 hours.
+- **Funding**: none. This is solo work. If your company wants commercial support, [email me](mailto:hanzla.dev@gmail.com).
+
+---
 
-4 behavioral principles from [Andrej Karpathy's observations on LLM coding pitfalls](https://github.com/forrestchang/andrej-karpathy-skills), wired into every code-writing agent as hard constraints: think before coding, simplicity first, surgical changes, goal-driven execution. `/rihal-code-review --karpathy` runs them as a post-hoc audit against any diff.
+## Why "rcode"
 
-### Verification built in
+رحّال (Rihāl) means "traveler" in Arabic — someone who carries knowledge between places. The persona names (Sadiq, Waleed, Fatima, Hussain, etc.) are Arabic placeholders. Swap them for your team in `rcode/team.yaml`. The methodology is the persona, not the names.
 
-`/rihal-plan` runs `rihal-sprint-checker` to validate file/symbol references before execution. `/rihal-execute` runs `rihal-integration-checker` (cross-phase E2E) and `rihal-nyquist-auditor` (test coverage) after completion.
+Named for the Arabic root **رحال** (rahhal) — the traveler. rcode walks alongside your code as a persistent companion across sessions.
 
 ---
 
 ## Learn more
 
 | Document | What's in it |
-|----------|--------------|
-| [`DOCS.md`](DOCS.md) | Complete documentation — install, concepts, all commands, Memory Bank, dashboard, testing & CI, architecture |
+|---|---|
+| [`DOCS.md`](DOCS.md) | Complete docs — install, concepts, all commands, Memory Bank, dashboard, testing, architecture |
 | [`docs/getting-started.md`](docs/getting-started.md) | Step-by-step first project |
 | [`docs/TIERS.md`](docs/TIERS.md) | Starter / Advanced / Power-user paths |
+| [`docs/dogfeed-flows.md`](docs/dogfeed-flows.md) | Live dogfeed log — every Q&A flow, every bug found, every fix shipped |
 | [`MEMORY_BANK.md`](MEMORY_BANK.md) | Memory Bank specification |
-| [`BRAND.md`](BRAND.md) | Naming, voice, and persona glossary |
-| [`MIGRATIONS.md`](MIGRATIONS.md) | Upgrade path from a pre-Memory-Bank install |
+| [`BRAND.md`](BRAND.md) | Naming, voice, persona glossary |
 | [`CHANGELOG.md`](CHANGELOG.md) | Release history |
 
 ---
 
-## Why "Rihal"
-
-رحّال (Rihāl) is Arabic for "traveler" — someone who journeys between places carrying knowledge. [Rihal](https://rihal.om) is also one of Oman's fastest-growing tech companies. The agent names are Arabic placeholders — swap them for your team in `rihal/team.yaml`.
-
----
-
 ## Credits
 
-- Karpathy coding guidelines adapted from [forrestchang/andrej-karpathy-skills](https://github.com/forrestchang/andrej-karpathy-skills) (MIT)
-- File-shipping installer pattern inspired by the broader agent-skill ecosystem
+- [Andrej Karpathy's coding observations](https://github.com/forrestchang/andrej-karpathy-skills) (MIT) — wired into the code-review agents as hard constraints.
+- Built solo with [Claude Code](https://claude.com/claude-code) — the methodology shipped here is the one used to build it.
 
 ---
 
 ## License
 
-Released under the [MIT License](LICENSE).
+Released under the [MIT License](LICENSE). Use it, fork it, ship it.

package/cli/agent.js

@@ -1,5 +1,5 @@
 /**
- * rcode agent <name> — launch a specialist agent via claude --agent rihal-<name>
+ * rcode agent <name> — launch a specialist agent via claude --agent rcode-<name>
  */
 
 const { spawnSync } = require('child_process');
@@ -7,13 +7,13 @@ const fs = require('fs');
 const path = require('path');
 
 module.exports = function agent(args, { packageRoot }) {
-  const agentDir = path.join(packageRoot, 'rihal/agents');
+  const agentDir = path.join(packageRoot, 'rcode/agents');
 
   // --list or zero args: enumerate available agents
   if (args.includes('--list') || args.length === 0) {
     const names = fs.readdirSync(agentDir)
-      .filter(f => f.startsWith('rihal-') && f.endsWith('.md'))
-      .map(f => f.replace(/^rihal-/, '').replace(/\.md$/, ''))
+      .filter(f => f.startsWith('rcode-') && f.endsWith('.md'))
+      .map(f => f.replace(/^rcode-/, '').replace(/\.md$/, ''))
       .sort();
     if (args.length === 0) {
       console.log('Usage: rcode agent <name> [-- extra args]\n');
@@ -24,14 +24,14 @@ module.exports = function agent(args, { packageRoot }) {
   }
 
   const name = args[0];
-  const agentName = `rihal-${name}`;
+  const agentName = `rcode-${name}`;
 
   // Validate agent file exists
   const agentFile = path.join(agentDir, `${agentName}.md`);
   if (!fs.existsSync(agentFile)) {
     const available = fs.readdirSync(agentDir)
-      .filter(f => f.startsWith('rihal-') && f.endsWith('.md'))
-      .map(f => f.replace(/^rihal-/, '').replace(/\.md$/, ''))
+      .filter(f => f.startsWith('rcode-') && f.endsWith('.md'))
+      .map(f => f.replace(/^rcode-/, '').replace(/\.md$/, ''))
       .sort()
       .join(', ');
     console.error(`Error: No agent named '${agentName}' found.`);
@@ -51,7 +51,7 @@ module.exports = function agent(args, { packageRoot }) {
   const dashIdx = args.indexOf('--');
   const extra = dashIdx !== -1 ? args.slice(dashIdx + 1) : [];
 
-  // Spawn claude --agent rihal-<name> [extra...]
+  // Spawn claude --agent rcode-<name> [extra...]
   const result = spawnSync('claude', ['--agent', agentName, ...extra], { stdio: 'inherit' });
   process.exit(result.status ?? 0);
 };

package/cli/config.js

@@ -1,12 +1,12 @@
 /**
- * rihal-code config — get, set, or list project configuration.
+ * rcode config — get, set, or list project configuration.
  *
  * Usage:
- *   rihal-code config                        # show all effective values
- *   rihal-code config <key>                  # get one value
- *   rihal-code config <key> <value>          # set in .rihal/config.json
- *   rihal-code config --global <key> <value> # set in ~/.rihal-code/defaults.json
- *   rihal-code config --list                 # show all with source annotations
+ *   rcode config                        # show all effective values
+ *   rcode config <key>                  # get one value
+ *   rcode config <key> <value>          # set in .rcode/config.json
+ *   rcode config --global <key> <value> # set in ~/.rcode/defaults.json
+ *   rcode config --list                 # show all with source annotations
  *
  * All reads/writes go through cli/lib/config.cjs so validation, atomic
  * writes, and typo suggestions stay centralized.
@@ -60,7 +60,7 @@ function printListing(cwd) {
   );
 
   console.log(
-    `\n🕌 Rihal Code — configuration\n`
+    `\n🕌 rcode — configuration\n`
   );
   console.log(`   Project: ${projectLevelPath(cwd)}`);
   console.log(`   User:    ${userLevelPath()}\n`);
@@ -87,9 +87,9 @@ module.exports = function config(args) {
 
   // No args OR --list → print everything
   if (opts.positional.length === 0 || opts.list) {
-    const rihalDir = path.join(cwd, '.rihal');
-    if (!fs.existsSync(rihalDir) && !opts.global) {
-      console.error(`❌ No .rihal/ directory found in ${cwd}`);
+    const rcodeDir = path.join(cwd, '.rcode');
+    if (!fs.existsSync(rcodeDir) && !opts.global) {
+      console.error(`❌ No .rcode/ directory found in ${cwd}`);
       console.error(`   Run 'rcode install' first, or use --global to manage user defaults.`);
       process.exit(1);
     }
@@ -115,9 +115,9 @@ module.exports = function config(args) {
     const [key, value] = opts.positional;
     const scope = opts.global ? 'global' : 'project';
 
-    // For global writes, we don't need .rihal/ to exist
-    if (scope === 'project' && !fs.existsSync(path.join(cwd, '.rihal'))) {
-      console.error(`❌ No .rihal/ directory found in ${cwd}`);
+    // For global writes, we don't need .rcode/ to exist
+    if (scope === 'project' && !fs.existsSync(path.join(cwd, '.rcode'))) {
+      console.error(`❌ No .rcode/ directory found in ${cwd}`);
       console.error(`   Run 'rcode install' first, or use --global.`);
       process.exit(1);
     }

package/cli/context.js

@@ -1,19 +1,19 @@
 /**
- * rihal-code context — inspect and refresh the .rihal/ memory bank freshness.
+ * rcode context — inspect and refresh the .rcode/ memory bank freshness.
  *
- * The memory bank (.rihal/context/active.md + project-brief.md) is what
- * every Rihal workflow reads at runtime. If it goes stale, agents silently
+ * The memory bank (.rcode/context/active.md + project-brief.md) is what
+ * every rcode workflow reads at runtime. If it goes stale, agents silently
  * work from outdated assumptions. This command makes staleness visible.
  *
  * Usage:
- *   rihal-code context                   show staleness report (default)
- *   rihal-code context --check           exit non-zero if stale (for CI/hooks)
- *   rihal-code context --refresh         write fresh fingerprint after a manual scan
- *   rihal-code context --install-hook    opt-in post-commit git hook that
+ *   rcode context                   show staleness report (default)
+ *   rcode context --check           exit non-zero if stale (for CI/hooks)
+ *   rcode context --refresh         write fresh fingerprint after a manual scan
+ *   rcode context --install-hook    opt-in post-commit git hook that
  *                                         prints a warning when stale
  *
  * The refresh does NOT rewrite active.md or project-brief.md — that's
- * /rihal-init's job (the scan requires an LLM). --refresh just stores the
+ * /rcode-init's job (the scan requires an LLM). --refresh just stores the
  * current fingerprint so the next check sees things as fresh.
  */
 
@@ -42,9 +42,9 @@ function parseArgs(args) {
   return opts;
 }
 
-function ensureRihalDir(cwd) {
-  if (!fs.existsSync(path.join(cwd, '.rihal'))) {
-    console.error(`❌ No .rihal/ directory found in ${cwd}`);
+function ensureRcodeDir(cwd) {
+  if (!fs.existsSync(path.join(cwd, '.rcode'))) {
+    console.error(`❌ No .rcode/ directory found in ${cwd}`);
     console.error(`   Run 'rcode install' first.`);
     process.exit(1);
   }
@@ -78,8 +78,8 @@ function printReport(cwd) {
   console.log(`   Context files:`);
   const activeMark = report.context_files.active ? '✓' : '✗';
   const briefMark = report.context_files.brief ? '✓' : '✗';
-  console.log(`     ${activeMark} .rihal/context/active.md`);
-  console.log(`     ${briefMark} .rihal/context/project-brief.md`);
+  console.log(`     ${activeMark} .rcode/context/active.md`);
+  console.log(`     ${briefMark} .rcode/context/project-brief.md`);
   console.log();
 
   if (report.stored) {
@@ -117,20 +117,20 @@ function printReport(cwd) {
   console.log();
 
   if (report.status !== 'fresh') {
-    console.log(`   ➡ Refresh with: /rihal-init (in your editor)`);
+    console.log(`   ➡ Refresh with: /rcode-init (in your editor)`);
     console.log();
   }
 }
 
 /**
- * --refresh: recompute and save the fingerprint to .rihal/state.json.
+ * --refresh: recompute and save the fingerprint to .rcode/state.json.
  * Only use this when you know the memory bank was actually refreshed
- * (e.g. by /rihal-init running end-to-end). Does NOT rewrite context files.
+ * (e.g. by /rcode-init running end-to-end). Does NOT rewrite context files.
  */
 function doRefresh(cwd) {
-  ensureRihalDir(cwd);
+  ensureRcodeDir(cwd);
   const fp = writeFingerprint(cwd);
-  console.log(`\n✅ Fingerprint saved to .rihal/state.json`);
+  console.log(`\n✅ Fingerprint saved to .rcode/state.json`);
   console.log(`   git:       ${fp.git_head ? fp.git_head.slice(0, 7) : '(no git)'}`);
   console.log(`   manifest:  ${fp.manifest_name || '(none)'}`);
   console.log(`   structure: ${fp.structure_dirs.length} top-level dirs`);
@@ -154,14 +154,14 @@ function installHook(cwd) {
   const hookPath = path.join(hooksDir, 'post-commit');
 
   const hookContent = `#!/bin/sh
-# Rihal Code — memory bank freshness check
+# rcode — memory bank freshness check
 # Installed by: rcode context --install-hook
 # Non-blocking: prints a one-line warning if the memory bank is stale.
 if command -v rcode >/dev/null 2>&1; then
   output=$(rcode context --check 2>&1)
   if [ $? -ne 0 ]; then
     echo ""
-    echo "⚠ Rihal memory bank is stale — run /rihal-init in your editor to refresh."
+    echo "⚠ rcode memory bank is stale — run /rcode-init in your editor to refresh."
     echo "   $(echo "$output" | grep '•' | head -1 | sed 's/^ *//')"
   fi
 fi
@@ -170,7 +170,7 @@ fi
   // Don't clobber an existing hook without asking
   if (fs.existsSync(hookPath)) {
     const existing = fs.readFileSync(hookPath, 'utf8');
-    if (existing.includes('Rihal Code — memory bank freshness')) {
+    if (existing.includes('rcode — memory bank freshness')) {
       console.log(`✓ post-commit hook already installed at ${hookPath}`);
       return;
     }
@@ -200,8 +200,8 @@ module.exports = function context(args) {
     return;
   }
 
-  // Default / --check: need .rihal/ to exist
-  ensureRihalDir(cwd);
+  // Default / --check: need .rcode/ to exist
+  ensureRcodeDir(cwd);
   printReport(cwd);
 
   if (opts.check) {

package/cli/dashboard.js

@@ -1,5 +1,5 @@
 /**
- * rihal-code dashboard — start the Diwan view-only dashboard
+ * rcode dashboard — start the Diwan view-only dashboard
  */
 
 const path = require('path');
@@ -8,17 +8,17 @@ const { spawn } = require('child_process');
 module.exports = function dashboard(args, { packageRoot }) {
   const serverPath = path.join(packageRoot, 'server/dashboard.js');
   const cwd = process.cwd();
-  const rihalDir = path.join(cwd, '.rihal');
+  const rcodeDir = path.join(cwd, '.rcode');
 
   console.log(`\n🕌 Starting Diwan dashboard...`);
-  console.log(`   Scanning: ${rihalDir}`);
+  console.log(`   Scanning: ${rcodeDir}`);
 
-  // Fork the dashboard process with RIHAL_DIR pointing at the user's current project
+  // Fork the dashboard process with RCODE_DIR pointing at the user's current project
   const proc = spawn('node', [serverPath], {
     stdio: 'inherit',
     env: {
       ...process.env,
-      RIHAL_DIR: rihalDir,
+      RCODE_DIR: rcodeDir,
     },
   });
 

package/cli/digest.js

@@ -1,18 +1,18 @@
 /**
- * rihal-code digest — print compact agent digests
+ * rcode digest — print compact agent digests
  *
  * Resolution order for a specific agent:
- *   1. rihal/digests/<name>.md            (curated 20-line digest)
- *   2. rihal/agents/rihal-<name>.md       (fallback: full agent file)
+ *   1. rcode/digests/<name>.md            (curated 20-line digest)
+ *   2. rcode/agents/rcode-<name>.md       (fallback: full agent file)
  *
- * Accepts both `sadiq` and `rihal-sadiq` as input (rihal- prefix stripped).
+ * Accepts both `sadiq` and `rcode-sadiq` as input (rcode- prefix stripped).
  */
 
 const fs = require('fs');
 const path = require('path');
 
 function normalize(name) {
-  const stripped = name.replace(/^rihal-/, '');
+  const stripped = name.replace(/^rcode-/, '');
   // Reject path traversal attempts — names must be simple identifiers
   if (stripped.includes('..') || stripped.includes('/') || stripped.includes('\\')) {
     throw new Error(`Invalid agent name: '${name}'`);
@@ -26,8 +26,8 @@ function listAvailable(digestDir, agentsDir) {
     : [];
   const agentNames = fs.existsSync(agentsDir)
     ? fs.readdirSync(agentsDir)
-        .filter((f) => f.endsWith('.md') && f.startsWith('rihal-'))
-        .map((f) => f.replace(/^rihal-/, '').replace('.md', ''))
+        .filter((f) => f.endsWith('.md') && f.startsWith('rcode-'))
+        .map((f) => f.replace(/^rcode-/, '').replace('.md', ''))
     : [];
   return Array.from(new Set([...digestNames, ...agentNames])).sort();
 }
@@ -35,14 +35,14 @@ function listAvailable(digestDir, agentsDir) {
 function resolveAgentFile(name, digestDir, agentsDir) {
   const digestFile = path.join(digestDir, `${name}.md`);
   if (fs.existsSync(digestFile)) return { file: digestFile, source: 'digest' };
-  const agentFile = path.join(agentsDir, `rihal-${name}.md`);
+  const agentFile = path.join(agentsDir, `rcode-${name}.md`);
   if (fs.existsSync(agentFile)) return { file: agentFile, source: 'agent' };
   return null;
 }
 
 module.exports = function digest(args, { packageRoot }) {
-  const digestDir = path.join(packageRoot, 'rihal/digests');
-  const agentsDir = path.join(packageRoot, 'rihal/agents');
+  const digestDir = path.join(packageRoot, 'rcode/digests');
+  const agentsDir = path.join(packageRoot, 'rcode/agents');
   const specificAgent = args[0];
 
   if (specificAgent) {
@@ -61,7 +61,7 @@ module.exports = function digest(args, { packageRoot }) {
   }
 
   const names = listAvailable(digestDir, agentsDir);
-  console.log(`\n🕌 All Rihal Code Agent Digests\n`);
+  console.log(`\n🕌 All rcode Agent Digests\n`);
   for (const name of names) {
     const resolved = resolveAgentFile(name, digestDir, agentsDir);
     if (!resolved) continue;