@lifeaitools/rdc-skills 0.8.7

package/commands/collab.md

@@ -0,0 +1,180 @@
+---
+name: rdc:collab
+description: >-
+  Usage `rdc:collab --session <id>` — bidirectional relay with claude.ai. Read inbox, do work, write outbox, loop. Dave watches terminal and can interject.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+
+# /rdc:collab — Claude Code Collab Session Listener
+> Invoked as: `/rdc:collab --session <session_id>`
+> You are the build/execute half of a live collab session with claude.ai.
+> Transport: file relay via `.rdc/relay/sessions/<id>/inbox/` + `outbox/`
+> Dave is watching this terminal and can interject at any time.
+
+---
+
+## What This Is
+
+claude.ai writes tasks into your inbox. You read, act, commit, write the response
+to outbox, and loop. clauth relays messages between claude.ai and this session via
+the `chitchat_*` MCP tools. Dave can watch everything in this terminal and interject
+by typing — treat anything Dave types as a high-priority override.
+
+---
+
+## Step 1 — Parse session ID
+
+Extract `--session <uuid>` from args.
+
+If no `--session`, list `.rdc/relay/sessions/` and show available sessions.
+
+---
+
+## Step 2 — Initialize
+
+```
+sessionDir = .rdc/relay/sessions/<session_id>/
+inbox      = sessionDir/inbox/
+outbox     = sessionDir/outbox/
+```
+
+Verify both dirs exist. If not:
+```
+Session directory not found. Run chitchat_start from claude.ai first.
+```
+
+Update `sessionDir/status.json`:
+```json
+{ "status": "active", "cli_connected_at": "<iso>", "session_id": "<id>" }
+```
+
+Write a ready signal to outbox so claude.ai knows the CLI is connected:
+
+```
+outbox/<iso-ts>-ready.md
+---
+from: claude-code
+to: claude-ai
+session_id: <id>
+type: ready
+responded_at: <iso>
+---
+Claude Code connected. Ready to receive tasks.
+cwd: <rootPath>
+```
+
+Print to terminal:
+```
+[rdc:collab] Session <id> active.
+Inbox:  .rdc/relay/sessions/<id>/inbox/
+Outbox: .rdc/relay/sessions/<id>/outbox/
+Waiting for messages from claude.ai... (Ctrl+C to end)
+```
+
+---
+
+## Step 3 — Poll inbox
+
+Scan `inbox/` for `.md` files that do NOT end in `.processed`. Sort ascending by name.
+
+- **No files:** wait 5 seconds, poll again.
+- **After 10 min idle:** print `[rdc:collab] Still listening...` heartbeat, keep waiting.
+- **Files found:** process the oldest one first (Step 4).
+
+---
+
+## Step 4 — Process message
+
+Read the file. Parse frontmatter `type` field.
+
+**`type: stop`** → go to Step 6.
+
+**Anything else (default: task/message):**
+
+Print to terminal:
+```
+[rdc:collab] Turn <N> from claude.ai:
+──────────────────────────────────────
+<message body>
+──────────────────────────────────────
+```
+
+Rename the inbox file to `<filename>.processed`.
+
+---
+
+## Step 5 — Do the work
+
+Act on the message. Full Claude Code capabilities:
+- File edits, git commits to `develop`
+- Supabase RPC queries
+- Type-checks: `npx tsc --noEmit` (never `pnpm build`)
+- Run skills: `/rdc:plan`, `/rdc:fixit`, etc.
+- Answer questions directly
+
+Follow `.rdc/guides/agent-bootstrap.md` rules throughout.
+
+When done, write response to outbox:
+```
+outbox/<iso-ts>-turn<N>.md
+---
+from: claude-code
+to: claude-ai
+session_id: <session_id>
+turn: <N>
+responded_at: <iso>
+commits: <sha1, sha2 or none>
+---
+
+<what you did, what you found, any questions or decisions needed from claude.ai>
+```
+
+Print to terminal:
+```
+[rdc:collab] Turn <N> done. Response written to outbox.
+Waiting for next message...
+```
+
+Return to Step 3.
+
+---
+
+## Step 6 — End session
+
+Received `type: stop` in inbox, or Dave pressed Ctrl+C.
+
+Write final summary to outbox:
+```
+outbox/<iso-ts>-final.md
+---
+from: claude-code
+to: claude-ai
+session_id: <session_id>
+type: final
+responded_at: <iso>
+---
+Session complete.
+Turns: <N>
+Commits: <list or none>
+Open items: <anything unresolved>
+```
+
+Update `status.json` → `{ "status": "done", "ended_at": "<iso>" }`
+
+Print:
+```
+[rdc:collab] Session ended.
+```
+
+---
+
+## Dave Interjections
+
+If Dave types in this terminal during a turn:
+- Treat it as an override injected into the current task
+- Acknowledge it in your outbox response
+- If it changes direction mid-task, note what you stopped and why

package/commands/deploy.md

@@ -0,0 +1,138 @@
+---
+name: rdc:deploy
+description: >-
+  Coolify ops. Usage `rdc:deploy <slug> [build-id]` or `rdc:deploy new <slug>` or `rdc:deploy diagnose <slug>` or `rdc:deploy audit [--fix]` — type checklists, DNS decision tree, mandatory post-deploy gate. Checklist-only output.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+
+# rdc:deploy — Coolify Operations
+
+**READ FIRST:** `guides/output-contract.md`. Checklist-only output. No narration.
+No raw MCP dumps. No UUIDs unless asked.
+
+> **Sandbox contract:** This skill honors `RDC_TEST=1` per `guides/agent-bootstrap.md` § RDC_TEST Sandbox Contract. Destructive external calls short-circuit under the flag.
+>
+> *Under `$RDC_TEST=1`:* Modes 1 (deploy) and 2 (new) are **entirely skipped** — echo `[RDC_TEST] skipping Coolify deploy/create` and mark every `[ ]` line in those checklists as `[~]`. Modes 3 (diagnose) and 4 (audit without `--fix`) are **read-only and run normally**. Mode 4 with `--fix` skips all remediation — echo `[RDC_TEST] skipping audit --fix remediation` and report findings only. Registry SELECTs, Coolify status reads, HTTP gate probes, TLS checks, and DNS lookups are NOT destructive and run normally. Anything that writes (create app, set watch_paths, deploy trigger, env var write, DNS write, CF cache purge, registry UPDATE/INSERT) is gated.
+
+## Arguments
+
+- `rdc:deploy <slug>` — deploy existing app (latest commit on its watched branch)
+- `rdc:deploy <slug> <build-id>` — deploy specific commit/tag
+- `rdc:deploy new <slug>` — create a new Coolify app from registry
+- `rdc:deploy diagnose <slug>` — debug why an app is broken
+- `rdc:deploy audit` — fleet-wide scan for missed failures
+- `rdc:deploy audit --fix` — fleet scan + auto-remediate safe issues
+- `rdc:deploy` (no args) — print mode menu, ask which
+
+## Modes
+
+### Mode 1 — deploy <slug> [build-id]
+
+```
+rdc:deploy: <slug> → <domain>
+[ ] Registry lookup (slug, uuid, branch, type, env_vars_needed)
+[ ] Git state verified (branch matches Coolify, commit pushed)
+[ ] Build-id resolved (default: HEAD of watched branch)
+[ ] Env vars present in Coolify (compare to registry)
+[ ] Type-specific preflight (see docs/runbooks/coolify-deploy-checklist.md)
+[ ] Deploy triggered
+[ ] Deployment reached "finished" state
+[ ] Gate: HTTP 200
+[ ] Gate: TLS valid (no SSL cipher mismatch)
+[ ] Gate: cache headers correct on HTML
+[ ] Gate: container running on declared port
+[ ] Cloudflare cache purged (if proxied)
+[ ] deployment_registry updated (last_deploy_at, status)
+✅ rdc:deploy: <slug> deployed in Nm Ns
+```
+
+### Mode 2 — new <slug>
+
+```
+rdc:deploy new: <slug>
+[ ] Registry entry loaded (or interactive create)
+[ ] DNS path chosen (A: *.dev.place.fund  B: apex  C: other zone)
+[ ] DNS record verified or wildcard confirmed
+[ ] Cloudflare proxy setting correct for DNS path
+[ ] server_uuid, project_uuid, environment_uuid, github_app_uuid resolved
+[ ] Build type chosen (Next.js / Vite / static / standalone)
+[ ] Type-specific fields filled (ports, build cmd, install cmd, start cmd)
+[ ] Application created via /applications/private-github-app
+[ ] watch_paths set and verified
+[ ] Env vars set in Coolify
+[ ] First deploy triggered
+[ ] Gate passed (5 checks)
+[ ] deployment_registry row inserted
+✅ rdc:deploy new: <slug> live at <domain>
+```
+
+### Mode 3 — diagnose <slug>
+
+```
+rdc:deploy diagnose: <slug>
+[ ] App located (uuid, domain, last deploy)
+[ ] Container state (running / restarting / stopped)
+[ ] Last 100 log lines scanned for known error patterns
+[ ] Port mismatch check (declared vs actual)
+[ ] Env var drift check (registry vs Coolify)
+[ ] watch_paths sanity check
+[ ] HTTP / TLS reachability
+[ ] Cloudflare proxy state check
+[ ] Disk space on server
+[ ] Branch mismatch check (Coolify git_branch vs expected)
+⚠️ rdc:deploy diagnose: <root cause in one sentence> — fix: <one command>
+```
+
+### Mode 4 — audit
+
+```
+rdc:deploy audit: fleet scan
+[ ] Inventory join: Coolify apps ⋈ deployment_registry
+[ ] Orphans (in one but not the other)
+[ ] Monorepo apps missing watch_paths
+[ ] Stale deploys (>14 days since last success)
+[ ] Registry rows with status='broken'
+[ ] Failed deployments in last 7 days
+[ ] HTTP gate sweep (non-200 per domain)
+[ ] TLS cert expiry <30 days
+[ ] Port mismatches (ports_exposes vs actual container port)
+[ ] Env var drift (registry.env_vars_needed vs Coolify env)
+[ ] Branch mismatches (Coolify git_branch ≠ expected)
+[ ] Disk space on 64.237.54.189
+[ ] CF proxy misconfigs on *.dev.place.fund
+[ ] Duplicate apps (same repo, multiple UUIDs)
+
+Findings:
+| Severity | App | Issue | Fix |
+|----------|-----|-------|-----|
+| HIGH     | ... | ...   | ... |
+⚠️ rdc:deploy audit: N HIGH · M MED · K LOW — run `rdc:deploy audit --fix` to auto-remediate safe issues
+```
+
+Severity rules:
+- **HIGH** — user-facing down (HTTP non-200, TLS invalid, container not running)
+- **MED** — degraded or drifting (watch_paths missing, env var drift, stale deploy, branch mismatch)
+- **LOW** — cleanup (orphans, duplicates, registry status stale)
+
+`--fix` auto-remediates only: missing watch_paths, registry row updates, CF cache purges. Never touches env vars, DNS, or container config without explicit confirmation.
+
+## References
+
+- Type-specific checklists + DNS tree + gate commands: `docs/runbooks/coolify-deploy-checklist.md`
+- Rules / registry RPCs / hard limits: `.claude/rules/coolify-deployment.md`
+- MCP server: `@masonator/coolify-mcp` (38 tools)
+- Infrastructure constants:
+  ```
+  Server UUID:     ih386anenvvvn6fy1umtyow0
+  Server IP:       64.237.54.189
+  Dashboard:       https://deploy.regendevcorp.com
+  GitHub App UUID: xdmcy60putp5h9j7k4kwg9c3
+  ```
+
+## Supersedes
+
+`coolify-deploy` standalone skill (kept for back-compat; new work uses `rdc:deploy`).

package/commands/fixit.md

@@ -0,0 +1,112 @@
+---
+name: rdc:fixit
+description: >-
+  Usage `rdc:fixit <description>` — sanctioned bypass for quick fixes under 5 files / 30 min. Creates minimal work item, makes fix, commits, closes. The ONLY alternative to rdc:build. For typos, config patches, hotfixes, dep bumps.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+> If dispatching subagents or running as a subagent: read `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md` first (fallback: `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md`).
+
+> **Sandbox contract:** This skill honors `RDC_TEST=1` per `guides/agent-bootstrap.md` § RDC_TEST Sandbox Contract. Destructive external calls short-circuit under the flag.
+
+
+# rdc:fixit — Sanctioned Quick Fix
+
+## When to Use
+- Typo or single-line text correction
+- Config value change (env vars, constants, feature flags)
+- Emergency hotfix that cannot wait for a full build cycle
+- Dependency version bump
+- CSS/styling tweak on a single component
+- Broken import or export fix
+- Single-file logic correction
+
+## When NOT to Use — escalate to rdc:build instead
+- New feature of any size
+- Refactor touching >5 files
+- Anything requiring architecture decisions
+- Work that will take longer than 30 minutes
+- Schema changes or migrations
+
+## Arguments
+- `rdc:fixit <description>` — fix the described issue
+
+## Procedure
+
+### 1. Scope check (mandatory — do this before touching any file)
+
+Will this fix touch more than **5 files** or take more than **30 minutes**?
+
+- **YES** → Stop. Use `/rdc:build` instead. Explain to the user why.
+- **NO** → Continue.
+
+### 2. Create a minimal work item (before touching any code)
+
+```sql
+SELECT insert_work_item(
+  p_title     := 'fixit: <description>',
+  p_item_type := 'bug',
+  p_priority  := 'urgent',
+  p_status    := 'in_progress',
+  p_source    := 'fixit'
+);
+```
+
+Note the returned `id`.
+
+### 3. Write the fixit session marker
+
+Write to `{USER_HOME}/.claude/fixit.marker`:
+```
+<work_item_id>
+<ISO timestamp>
+<description>
+```
+
+This signals the Stop hook that fixit is handling its own documentation.
+
+### 4. Make the fix
+
+Do the minimal work. Scope creep rule: if you discover the fix requires more than originally scoped, **stop immediately**:
+1. Close the work item: `update_work_item_status('<id>', 'blocked', '["Escalated — scope exceeded fixit threshold"]')`
+2. Delete the marker file
+3. Tell the user to use `/rdc:build` instead
+
+### 5. Commit
+
+```bash
+git add <specific files only — never git add -A for a fixit>
+git commit -m "fix(<scope>): <description>"
+if [ "$RDC_TEST" != "1" ]; then
+  git push origin {development-branch}
+else
+  echo "[RDC_TEST] skipping git push origin {development-branch}"
+fi
+```
+
+### 6. Close and clean up
+
+```sql
+SELECT update_work_item_status('<id>'::uuid, 'done',
+  '["Fixed via rdc:fixit"]'::jsonb
+);
+```
+
+```bash
+rm {USER_HOME}/.claude/fixit.marker
+```
+
+### 7. Confirm to user
+
+Report: what was fixed, file(s) changed, commit hash. One sentence.
+
+## Rules
+- Work item created BEFORE any code change — never after
+- `git add` specific files only — never `-A` or `.` for a fixit
+- Branch: development branch always
+- Never run `pnpm build` — not needed for a fixit
+- If scope expands mid-fix: stop, escalate to rdc:build, don't finish under fixit
+- Marker file must be cleaned up whether fix succeeds or escalates

package/commands/handoff.md

@@ -0,0 +1,173 @@
+---
+name: rdc:handoff
+description: >-
+  Usage `rdc:handoff <topic>` — structured handoff from planning session to CLI agents. Produces plan doc in .rdc/plans/, work items in DB, prototype registry entry if applicable. Use when plan/prototype is finalized and ready for implementation.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+> If dispatching subagents or running as a subagent: read `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md` first (fallback: `{PROJECT_ROOT}/.rdc/guides/agent-bootstrap.md`).
+
+
+# rdc:handoff — Planning → CLI Bridge
+
+## When to Use
+
+- A prototype has been built and needs production implementation
+- A design decision has been made and needs to be executed
+- Project lead says "hand this off", "give this to the CLI", "write it up"
+- A plan exists in the conversation but hasn't been saved to disk or database yet
+
+## What This Skill Produces
+
+1. **Plan doc** → `.rdc/plans/<topic-slug>.md` (fallback: `.rdc/plans/<topic-slug>.md`)
+2. **Database epic + child tasks** (with agent types and guide file refs)
+3. **Prototype registry entry** (if a prototype was built)
+4. **Design context entries** (for decisions made in the session)
+
+## Procedure
+
+### Step 1 — Extract the Plan
+
+Identify from the conversation:
+- What is the goal?
+- What prototypes or designs were built? Where are they?
+- What decisions were made? What was rejected and why?
+- What is the sequencing (what depends on what)?
+- Which agent types are needed?
+
+### Step 2 — Write the Plan Doc
+
+```
+.rdc/plans/<topic-slug>.md
+```
+(fallback: `.rdc/plans/<topic-slug>.md` if `.rdc/` does not exist)
+
+Template:
+```markdown
+# Plan: <Topic>
+> Route: <app route or package>
+> Status: Ready for CLI build
+> Created: <date>
+> Source: planning session
+
+---
+
+## What Already Exists (Do NOT Re-implement)
+
+[List any existing components, database tables, or files
+ that agents must use rather than recreate]
+
+## What Was Built in Planning (Prototype)
+
+[Describe the prototype — file location, key design decisions,
+ what to preserve vs what to adapt]
+
+## Work Packages
+
+### Package 1 — <Name>
+- Agent type: frontend | backend | data | design | infra | content | cs2 | viz
+- Guide: .rdc/guides/<type>.md (fallback: .rdc/guides/<type>.md)
+- Files to create/modify: [list]
+- Deliverables: [specific outputs]
+- Depends on: [other packages if sequential]
+
+### Package 2 — <Name>
+[...]
+
+## Sequencing
+
+Wave 1 (parallel): Package 1, Package 2
+Wave 2 (after Wave 1): Package 3
+
+## Definition of Done
+
+- [ ] [specific acceptance criterion]
+- [ ] [build verification: zero new TS errors]
+- [ ] [functional test]
+```
+
+### Step 3 — Create Database Epic + Tasks
+
+```sql
+-- Check for existing epics first
+SELECT get_open_epics();
+
+-- Create epic
+SELECT insert_work_item(
+  p_title       := 'EPIC: <Topic>',
+  p_description := 'See .rdc/plans/<topic-slug>.md for full spec.',
+  p_item_type   := 'epic',
+  p_priority    := 'high',
+  p_labels      := ARRAY['<system-label>'],
+  p_source      := 'planning'
+);
+
+-- Create tasks (one per work package)
+SELECT insert_work_item(
+  p_title       := '<Package Name>',
+  p_description := 'What: <deliverable>
+Where: <files>
+Agent type: <type>
+Guide: .rdc/guides/<type>.md (fallback: .rdc/guides/<type>.md)
+Design doc: .rdc/plans/<topic-slug>.md (fallback: .rdc/plans/<topic-slug>.md)
+Depends on: <other task if applicable>
+Est: <hours>',
+  p_parent_id   := '<epic-uuid>'::uuid,
+  p_item_type   := 'task',
+  p_priority    := 'high',
+  p_labels      := ARRAY['<label>'],
+  p_estimated_hours := 2,
+  p_source      := 'planning'
+);
+```
+
+### Step 4 — Register Prototype (if one was built)
+
+```sql
+INSERT INTO prototype_registry (name, component, source_path, notes, created_by)
+VALUES (
+  '<Component Name> v1',
+  '<ComponentName>',
+  'docs/source/<filename>.jsx',
+  '<Key design decisions, data shapes, what to preserve>',
+  'planning'
+)
+ON CONFLICT DO NOTHING;
+```
+
+### Step 5 — Record Design Decisions
+
+```sql
+INSERT INTO design_context (topic, context_type, summary, source, created_by)
+VALUES
+  ('<Topic>', 'decision', '<What was decided and why>', 'planning session', 'planning'),
+  ('<Topic>', 'rejected', '<What was considered but not chosen, and why>', 'planning session', 'planning');
+```
+
+## System Labels Reference
+
+| Label | When |
+|-------|------|
+| `project-a` | Your-app-specific label |
+| `marketing` | Marketing / outreach work |
+| `ui` | Component library work |
+| `data` | Schema, migrations |
+| `infrastructure` | CI/CD, deployment |
+| `cs2` | Core paradigm packages |
+| `website` | Public-facing sites |
+| `media` | Media/asset work |
+
+## Output
+
+When complete, tell the project lead:
+```
+Handoff complete:
+- Plan: .rdc/plans/<topic-slug>.md
+- Epic: <epic-id> ("<title>")
+- Tasks: <N> tasks created, wave structure: [Wave 1: X, Y | Wave 2: Z]
+- Prototype: registered at docs/source/<file> (if applicable)
+- CLI agents will pick this up on next run.
+```

package/commands/help.md

@@ -0,0 +1,88 @@
+---
+name: rdc:help
+description: >-
+  Usage `rdc:help` or `rdc` — selection menu of all rdc:* skills with their full argument syntax. Use when unsure which command to invoke or what args it takes.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw MCP/JSON/log dumps.
+
+
+# rdc:help — Command Reference
+
+Print the full usage menu below verbatim, then ask the project lead which command to run.
+
+## Workflow — the RDC loop
+
+| Command | Usage |
+|---|---|
+| `rdc:preplan` | `rdc:preplan <topic> [--unattended]` — research, no code |
+| `rdc:plan` | `rdc:plan <topic> [--unattended]` — architecture + epic/tasks |
+| `rdc:build` | `rdc:build <epic-id\|topic> [--unattended]` — dispatch agents, commit, close items |
+| `rdc:review` | `rdc:review [--unattended]` — typecheck, tests, fix, commit |
+| `rdc:report` | `rdc:report [--unattended]` — write `.rdc/reports/YYYY-MM-DD.md` |
+| `rdc:overnight` | `rdc:overnight [epic-id\|label=X]` — chain preplan→plan→build→review→report |
+| `rdc:status` | `rdc:status` — read-only dashboard |
+| `rdc:fixit` | `rdc:fixit <description>` — bypass the loop, <5 files / <30 min |
+
+## Ops
+
+| Command | Usage |
+|---|---|
+| `rdc:deploy` | `rdc:deploy <slug> [build-id]` · `rdc:deploy new <slug>` · `rdc:deploy diagnose <slug>` · `rdc:deploy audit [--fix]` |
+| `rdc:release` | `rdc:release <repo> [version]` · `rdc:release <repo> --patch\|--minor\|--major` · `rdc:release <repo> --dry-run` |
+
+## Planning ↔ CLI bridge
+
+| Command | Usage |
+|---|---|
+| `rdc:handoff` | `rdc:handoff <topic>` — finalize plan → work items for CLI |
+| `rdc:prototype` | `rdc:prototype <description>` — JSX mock for review |
+| `rdc:workitems` | `rdc:workitems <add\|update\|done\|list\|epics> [args]` |
+| `rdc:collab` | `rdc:collab --session <id>` — claude.ai bidirectional relay |
+
+## Agent guides (dispatched by rdc:build, not user-invocable)
+
+These live under `guides/agents/` — they are role playbooks the build skill spawns as sub-agents. You do NOT invoke them directly.
+
+- `guides/agents/frontend.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/backend.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/data.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/design.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/infrastructure.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/content.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/cs2.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/viz.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/setup.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+- `guides/agents/verify.md` — [agent-only — dispatched by rdc:build, not user-invocable]
+
+Each agent reads `.rdc/guides/agent-bootstrap.md` first, then its role guide.
+
+## Decision tree
+
+```
+Project lead says → invoke
+─────────────────────────────────────────────────
+"research this" / "how do others do"    → rdc:preplan <topic>
+"plan this out" / "architect"           → rdc:plan <topic>
+"build it" / "go" / "execute"           → rdc:build <topic>
+"run overnight" / "while I sleep"       → rdc:overnight
+"quick fix" / "hotfix" / "typo"         → rdc:fixit <desc>
+"review" / "is it clean"                → rdc:review
+"report" / "summarize"                  → rdc:report
+"status" / "where are we"               → rdc:status
+"deploy" / "ship"                       → rdc:deploy <slug>
+"release" / "publish"                   → rdc:release <repo>
+"hand this off" / "give to agents"      → rdc:handoff
+"show me what it looks like"            → rdc:prototype
+"add to backlog" / "create a ticket"    → rdc:workitems
+"what commands" / "what skills"         → rdc:help
+```
+
+## Hard rules (apply everywhere)
+
+- NEVER `pnpm build` — crashes the machine. Typecheck with `npx tsc --noEmit`.
+- NEVER commit to `main` without explicit approval. Default branch is `develop`.
+- NEVER overlap agents on the same files.
+- ALWAYS update work items in real time via RPCs (see `.claude/rules/work-items-rpc.md`).
+- ALWAYS credentials via clauth daemon: `curl -s http://127.0.0.1:52437/get/<service>`.