@lifeaitools/rdc-skills 0.8.7

package/commands/release.md

@@ -0,0 +1,159 @@
+---
+name: rdc:release
+description: >-
+  Atomic release. Usage `rdc:release <repo> [version]` or `rdc:release <repo> --patch|--minor|--major` or `rdc:release <repo> --dry-run` — bump, commit, tag, push, wait CI, install, verify, restart. Known repos: clauth, rdc-skills, regen-media, gws. No user handoff.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw git/npm/CI dumps.
+> One checklist upfront, updated in place, shown again at end with 1-line verdict.
+
+> **Sandbox contract:** This skill honors `RDC_TEST=1` per `guides/agent-bootstrap.md` § RDC_TEST Sandbox Contract. Destructive external calls (git tag push, CI poll, npm publish verification, global install, daemon restart) short-circuit under the flag — the checklist still runs, but each destructive step echoes `[RDC_TEST] skipping <step>` instead of mutating external state.
+
+# rdc:release — Atomic LIFEAI Package Release
+
+## Purpose
+
+Dave has Bash access. Therefore Dave should never be asked to run install
+commands. This skill handles the complete release loop for any LIFEAI-published
+package so the user sees one checklist and one verdict, not a series of "now run
+this" handoffs.
+
+## Arguments
+
+- `rdc:release <repo>` — patch bump (default), full loop
+- `rdc:release <repo> <version>` — explicit version (e.g. `1.6.0`)
+- `rdc:release <repo> --minor` | `--major` | `--patch` — semver bump
+- `rdc:release <repo> --dry-run` — show checklist and planned version, do nothing
+- `rdc:release` (no args) — list known repos, ask which
+
+## Known repos
+
+Resolve `<repo>` to source path + install mechanism:
+
+| Repo | Source path | Publish | Install | Post-install |
+|------|-------------|---------|---------|--------------|
+| `clauth` | `C:/Dev/clauth` | npm via tag → GitHub Actions | `npm install -g @lifeaitools/clauth@latest` | `curl -s -X POST http://127.0.0.1:52437/restart` |
+| `rdc-skills` | `C:/Dev/rdc-skills` | local (no npm) | `bash C:/Dev/rdc-skills/scripts/install.sh` + cp fallback | none |
+| `regen-media` | `C:/Dev/regen-root/mcp-servers/regen-media` | local | restart MCP server | none |
+| `gws` | `C:/Dev/regen-root/mcp-servers/gws` | local | restart MCP server | none |
+
+Add new repos to this table as they emerge. If user specifies an unknown repo,
+ask for the source path and install command.
+
+## Checklist (run every mode)
+
+```
+rdc:release: <repo> vX.Y.Z → vA.B.C
+[ ] Source path resolved
+[ ] Working tree clean (git status)
+[ ] Current version detected (package.json)
+[ ] New version computed
+[ ] Dry-run gate (if --dry-run, stop here)
+[ ] package.json bumped (all version fields)
+[ ] Commit created
+[ ] Tag vA.B.C created
+[ ] Push to origin
+[ ] Push --tags to origin
+[ ] CI run located (gh run list, if applicable)
+[ ] CI completed successfully (poll every 20s, 10min timeout)
+[ ] npm registry shows vA.B.C (if npm package, poll every 15s, 3min timeout)
+[ ] Local install executed
+[ ] Installed version verified matches vA.B.C
+[ ] Post-install action (daemon restart, etc., if applicable)
+[ ] Smoke test (ping health endpoint or binary --version)
+✅ rdc:release <repo>: vA.B.C live and installed
+```
+
+## Execution details (silent to user — don't narrate)
+
+### 1. Version bump
+- Read `package.json`, parse version
+- Apply bump: patch (default), minor, major, or explicit
+- Rewrite all `version` fields (some packages have version in `claude.version` too)
+
+### 2. Commit + tag + push
+```bash
+cd <source_path>
+git add package.json
+git commit -m "chore(release): vA.B.C"
+if [ "$RDC_TEST" != "1" ]; then
+  git tag vA.B.C
+  git push && git push --tags
+else
+  echo "[RDC_TEST] skipping git tag + git push --tags"
+fi
+```
+Never `--no-verify`. Never `--force`. If pre-commit hook fails, fix root cause, don't skip.
+
+*Under `$RDC_TEST=1`, sections 3 (CI poll), 4 (npm registry poll), 5 (install), 6 (verify install), 7 (post-install), and 8 (smoke test) are also skipped — echo `[RDC_TEST] skipping <section>` for each and mark the checklist line as `[~]`.*
+
+### 3. CI poll (for repos with GH Actions publish)
+```bash
+# Locate the run triggered by the tag push
+gh run list --repo LIFEAI/<repo> --limit 5 --json status,conclusion,headBranch,databaseId
+# Poll its status field every 20s until conclusion ∈ {success, failure, cancelled}
+# Max 10 minutes — if timeout, fail with [!] and report run URL
+```
+
+### 4. npm registry poll (only if published to npm)
+```bash
+npm view @lifeaitools/<repo> version
+# Poll every 15s until matches new version
+# Max 3 minutes — usually lands within 30-60s after CI success
+```
+
+### 5. Install
+- **clauth:** `npm install -g @lifeaitools/clauth@latest`
+- **rdc-skills:** `bash C:/Dev/rdc-skills/scripts/install.sh` — if output shows only one file copied (known bug), fall back to `cp C:/Dev/rdc-skills/skills/*.md ~/.claude/skills/user/ && cp C:/Dev/rdc-skills/skills/*.md C:/Dev/regen-root/.claude/skills/user/`
+- **MCP servers:** restart the server process (find its PID, kill, respawn — or document how)
+
+### 6. Verify install
+- **clauth:** `curl -s http://127.0.0.1:52437/ping | jq -r .app_version` — must equal new version
+- **rdc-skills:** `ls ~/.claude/skills/user/rdc-release.md` (or whichever file is new in this release) — must exist
+- **Global npm:** `npm list -g --depth=0 @lifeaitools/<repo>` — version matches
+
+### 7. Post-install
+- **clauth:** `curl -s -X POST http://127.0.0.1:52437/restart` — wait 3s — ping again
+- Others: N/A
+
+### 8. Smoke test
+- **clauth:** new tool roundtrip (e.g., `curl -s http://127.0.0.1:52437/get/openai | head -c 10` succeeds without error)
+- **rdc-skills:** load one new skill file and check frontmatter parses
+- **MCP:** server responds to `tools/list`
+
+## Failure modes → checklist outcome
+
+| Failure | Marker | Next |
+|---------|--------|------|
+| Dirty working tree | `[!]` line 2 | Abort with one-sentence diff summary; ask user to commit or stash |
+| Pre-commit hook fails | `[!]` line 7 | Fix root cause, re-stage, retry (NEVER --no-verify) |
+| CI fails | `[!]` line 11 | Print run URL, tail 20 lines of failing job, ask user |
+| npm doesn't register | `[!]` line 12 | Print npm error, check if CI actually published (not a silent skip) |
+| Install script broken | `[!]` line 13 | Fall back to manual cp; note the installer bug as a task |
+| Version mismatch after install | `[!]` line 14 | Uninstall + clean install; if still wrong, likely cache issue |
+| Post-install restart fails | `[!]` line 15 | Print ping error; instruct user to run `scripts\restart-clauth.bat` manually |
+
+Even on failure, show the full checklist with `[!]` markers so user sees exactly
+where it stopped.
+
+## Dry-run mode
+
+Prints the checklist + resolved version bump + every command that WOULD run, but
+executes nothing beyond reads. Use when user says "what would you do" or before
+risky major bumps.
+
+## Never
+
+- Never release on behalf of the user without an explicit `rdc:release` invocation
+- Never skip CI verification ("it'll probably work" is how stale installs happen)
+- Never `--force` push, never `--no-verify`, never `--no-gpg-sign`
+- Never touch `main` — release tags go on the default branch the repo uses (`master` for clauth, rdc-skills)
+- Never declare success without verifying the installed version matches
+
+## Related
+
+- `.claude/rules/clauth.md` — clauth release workflow source of truth
+- `feedback_version_bump_must_tag.md` (memory) — never bump without tagging
+- `feedback_clauth_ci.md` (memory) — CI publish pattern
+- `feedback_just_do_it.md` (memory) — don't hand commands to Dave; run them

package/commands/report.md

@@ -0,0 +1,99 @@
+---
+name: rdc:report
+description: >-
+  Usage `rdc:report [--unattended]` — nightly markdown report, writes to .rdc/reports/YYYY-MM-DD.md. Covers completed/open work items, per-project progress, infra status, git stats, test counts.
+---
+
+> **⚠️ 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:report — Nightly Report
+
+## When to Use
+- End of a build session
+- Project lead asks for a report or summary
+- Nightly scheduled task
+- Before handing off to another session
+- Called by `rdc:overnight` at the end of every session
+
+## Arguments
+- `rdc:report` — interactive, prints summary to conversation
+- `rdc:report --unattended` — silent mode, writes file only, returns status block
+
+## Procedure
+
+1. **Query completed work (last 24h or since last report):**
+   ```sql
+   SELECT title, labels, completed_at, notes
+   FROM work_items
+   WHERE completed_at > now() - interval '24 hours'
+   ORDER BY completed_at;
+   ```
+
+2. **Query open work:**
+   ```sql
+   SELECT title, status, priority, labels
+   FROM work_items
+   WHERE status IN ('todo', 'in_progress', 'blocked')
+   ORDER BY priority, created_at;
+   ```
+
+3. **Git stats (since last report or last 24h):**
+   ```bash
+   git log --since="24 hours ago" --shortstat --oneline
+   git diff --shortstat HEAD~N  # where N = commits in window
+   ```
+
+4. **Infrastructure deployment snapshot** (if MCP available):
+   - List all apps with current status
+   - Flag any failures
+
+5. **Write report** to `.rdc/reports/YYYY-MM-DD.md` (fallback: `.rdc/reports/YYYY-MM-DD.md` if `.rdc/` does not exist):
+   ```markdown
+   # Daily Report — YYYY-MM-DD
+
+   ## Completed Today
+   | Item | Project | Priority |
+
+   ## Git Activity
+   - Commits: N
+   - Files changed: N
+   - Lines: +N / -N
+
+   ## Open Work
+   ### Urgent (N)
+   ### High (N)
+   ### Normal (N)
+
+   ## Deployment Status
+   | App | Domain | Status |
+
+   ## Blockers
+   <any blocked items or failed deploys>
+
+   ## Next Session Recommendation
+   <highest priority unstarted work>
+   ```
+
+6. **Check if weekly rollup needed** (if today is Sunday):
+   - Aggregate daily reports for the week
+   - Write `.rdc/reports/week-YYYY-WNN.md` (fallback: `.rdc/reports/week-YYYY-WNN.md`)
+
+7. **Report results:**
+   - Interactive: print summary to conversation
+   - Unattended: no interactive output, emit status block only:
+     ```
+     REPORT_STATUS: { report_path, completed_count, open_count, blockers_count }
+     ```
+
+## Rules
+- Reports go in `.rdc/reports/` (fallback: `.rdc/reports/`) — create dir if missing
+- One report per day — overwrite if re-run same day
+- Keep under 100 lines — scannable, not exhaustive
+- Include links to relevant CLAUDE.md files where helpful
+- Always end with "Next Session Recommendation"
+- Unattended: NEVER print to conversation — write file only

package/commands/review.md

@@ -0,0 +1,120 @@
+---
+name: rdc:review
+description: >-
+  Usage `rdc:review [--unattended]` — tests, typecheck, stale docs, export conflicts across modified packages. Fixes issues found. Use after a build session or before merging to main.
+---
+
+> **⚠️ 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:review — Quality Gate
+
+## When to Use
+- After a build session (especially overnight builds)
+- Before merging development → main/production
+- Project lead asks "review the work", "is everything clean"
+- Before any production deployment
+- Called by `rdc:overnight` after each epic build completes
+
+## Arguments
+- `rdc:review` — interactive review, pauses on issues needing judgment
+- `rdc:review --unattended` — silent mode, auto-fixes everything fixable
+
+## Procedure
+
+1. **Identify modified packages:**
+   ```bash
+   git diff --name-only origin/main...HEAD | grep "^packages/" | cut -d/ -f2 | sort -u
+   ```
+
+2. **Run tests for each modified package:**
+   ```bash
+   cd packages/<name> && npx vitest run 2>&1 | tail -10
+   ```
+   Report: package → test count → pass/fail → new tests added
+
+   **IMPORTANT:** `pnpm build` must NEVER be run (crashes system). Use `npx tsc --noEmit --project <path>/tsconfig.json` for typecheck instead. For packages without tests, typecheck is the verification method. Do NOT run vitest across the entire monorepo — check only modified packages individually.
+
+3. **Check test coverage delta:**
+   ```bash
+   git diff origin/main...HEAD -- packages/*/src/ | grep -c "^+" | head -5
+   git diff origin/main...HEAD -- packages/*/test* packages/*/src/**/*.test.* packages/*/src/**/*.spec.* 2>/dev/null | grep -c "^+" || echo 0
+   ```
+   Flag any package where implementation lines added > 50 but test lines added = 0.
+
+4. **Check for export conflicts:**
+   - Read `packages/*/src/index.ts` for any package with new exports
+   - Look for duplicate export names across the barrel
+   - Verify aliased exports don't shadow each other
+
+5. **Check for TODO/FIXME/HACK:**
+   ```bash
+   grep -rn "TODO\|FIXME\|HACK\|XXX" packages/*/src/ --include="*.ts" --include="*.tsx"
+   ```
+
+6. **Check package versions:**
+   - Any package with significant new code should have a version bump
+   - Compare package.json versions to what's in `docs/SYSTEM-STATE.md`
+
+7. **Check for stale CLAUDE.md:**
+   - If new modules were added to a package, does its CLAUDE.md mention them?
+   - Flag any package where exports grew by >10 lines but CLAUDE.md wasn't updated
+
+8. **Orphan work item audit:**
+   ```sql
+   SELECT id, title, item_type, status, source, created_at::date
+   FROM work_items
+   WHERE parent_id IS NULL
+     AND item_type NOT IN ('epic', 'bug')
+     AND status NOT IN ('done', 'archived')
+   ORDER BY created_at DESC;
+   ```
+   For each orphaned task found:
+   - If it clearly belongs to an open epic → attach it: `UPDATE work_items SET parent_id = '<epic-id>' WHERE id = '<task-id>'`
+   - If unclear → report (interactive) or flag in REVIEW_STATUS (unattended)
+   - Never silently leave orphaned tasks
+
+9. **Verification gate — dispatch the verify agent:**
+   After any fixes land, run the verify gate on every touched package. See `guides/agents/verify.md`.
+   **Iron Law: no CLEAN verdict without fresh evidence.** Quote the vitest + tsc output in the report.
+   If verify fails → do NOT emit CLEAN. Loop back, fix, re-run verify.
+
+10. **Fix issues found:**
+   - Failing tests → fix and commit
+   - Export conflicts → resolve and commit
+   - Missing version bumps → bump and commit
+   - All fixes as separate commits with descriptive messages
+
+   **Judgment calls:**
+   - Interactive: report — don't guess
+   - Unattended: escalate via advisor tool with: error message, surrounding context,
+     two most likely fix paths. Resume with advisor's recommendation.
+     If advisor unavailable: take the most conservative path, flag in status block.
+
+11. **Report:**
+    - Interactive:
+      ```
+      ## Review Results
+      | Package | Tests | Pass/Fail | New Tests | Issues |
+      ## Fixed
+      ## Remaining Issues
+      ## Verdict: CLEAN / HAS ISSUES
+      ```
+    - Unattended: emit status block only:
+      ```
+      REVIEW_STATUS: { verdict: "CLEAN|HAS_ISSUES", packages_checked, tests_passed, tests_failed, new_tests_added, fixes_applied, escalations }
+      ```
+
+## Rules
+- Do NOT run `pnpm build` (crashes system) — vitest only
+- Interactive: fix what you can, flag what needs decision
+- Unattended: fix everything fixable; escalate judgment calls to advisor
+- Each fix is a separate commit (not batched)
+- Always push fixes to origin after committing *(skip if `$RDC_TEST=1` — echo `[RDC_TEST] skipping git push` instead)*
+- Unattended: NEVER pause for input

package/commands/self-test.md

@@ -0,0 +1,107 @@
+---
+name: rdc:self-test
+description: >-
+  Usage `rdc:self-test [--strict] [--skill <name>] [--json] [--fix] [--tier2] [--parallel <n>] [--quick]` — validates every rdc-*.md skill: frontmatter, Usage marker, name↔filename match, referenced guides/rules/hooks exist, output contract banner, plugin manifest, duplicate-name + collision checks. Tier 1 static lint; Tier 2 behavioral runs via headless claude in isolated worktrees + Supabase branch. Run before every release.
+---
+
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Checklist-only output. No tool-call narration. No raw runner dumps — summarize.
+> One checklist upfront, updated in place, shown again at end with a 1-line verdict.
+
+
+# rdc:self-test — Skill Library Self-Test (Tier 1)
+
+## When to Use
+- Before every `rdc:release rdc-skills` tag push
+- After editing any skill description or frontmatter
+- When a skill mysteriously disappears from the menu (backtick bug repro)
+- In CI on every rdc-skills PR (once wired)
+
+## Tiers
+
+| Tier | What it checks | Status |
+|------|----------------|--------|
+| Tier 1 | Static lint — frontmatter, Usage line, referenced files, name match | ✅ live |
+| Tier 2 | Behavioral — headless Claude runs each skill in sandbox, asserts artifacts | ✅ live, see `.rdc/plans/skill-self-test-tier-2.md` |
+| Tier 3 | Golden checklists — snapshot output format, regress on drift | 🔒 future |
+
+## Procedure (Tier 1)
+
+1. **Run the linter:**
+   ```bash
+   node C:/Dev/rdc-skills/scripts/self-test.mjs
+   ```
+
+2. **Interpret exit codes:**
+   - `0` = all skills pass
+   - `1` = at least one FAIL or (in `--strict` mode) at least one WARN
+   - `2` = runner itself crashed (e.g., skills dir unreadable)
+   - `3` = `.claude-plugin/plugin.json` missing entirely (distinct from skill failures)
+
+3. **Common findings and fixes:**
+
+   | Finding code | Cause | Fix |
+   |---|---|---|
+   | `description-backtick-leading` | Folded YAML starts with `` ` `` — parser drops skill | Rewrite description to start with a word |
+   | `usage-marker-missing` | No `` Usage `rdc:name <args>` `` in description | Front-load arg contract |
+   | `usage-marker-mismatch` | `Usage` line references a different skill's name (copy-paste drift) | Fix the skill name in the Usage marker |
+   | `name-filename-mismatch` | frontmatter `name:` ≠ filename | `--fix` auto-renames; or rewrite name |
+   | `guide-not-found` / `rule-not-found` / `hook-not-found` | Dead reference in skill body | Create file or fix link |
+   | `banner-missing` | Skill missing OUTPUT CONTRACT banner | `--fix` auto-inserts |
+   | `manifest-missing` / `manifest-version-mismatch` | `.claude-plugin/plugin.json` missing or out-of-sync with `package.json` | Create/update manifest |
+   | `duplicate-skill-name` / `skill-guide-filename-collision` | Two skills claim same name, or skill collides with agent guide | Rename one |
+   | `orphan-hook` | File under `hooks/` isn't referenced by any skill, settings.json, or plugin.json | Wire it up or delete |
+
+4. **Flags:**
+   - `--strict` — promotes warnings to failures (use in CI and before release)
+   - `--skill <name>` — run against a single skill (e.g. `--skill rdc:build`)
+   - `--json` — machine-readable schema v2 (per-skill `findings[]` with `code` + `level`, plugin_manifest block, global_findings, summary.exit_code). Consumed by Tier 2 runner as pre-gate.
+   - `--fix` — auto-repair fixable findings: insert missing OUTPUT CONTRACT banner, rename files to match frontmatter name. Prints `FIXED:` lines + touched file list so you can git diff + commit. Backtick-leading descriptions are NOT auto-fixed (need human rewrite).
+
+5. **Report to the project lead:**
+   ```
+   Self-test: X/Y pass, Z warnings, W failures
+   Failures: <list>
+   Verdict: PASS | FAIL
+   ```
+
+## Procedure (Tier 2)
+
+Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed state (files touched, commits made, work items, exit code). Use it before shipping behavioral changes — Tier 1 alone can't catch runtime drift.
+
+1. **Prerequisites:**
+   - `claude` CLI on PATH (headless mode: `claude --print`)
+   - clauth daemon unlocked (`curl -s http://127.0.0.1:52437/ping`)
+   - Supabase MCP reachable (runner creates a throwaway test branch)
+   - Clean git tree in `rdc-skills` (worktrees are added under `.rdc/sandbox/<run-id>/`)
+
+2. **Run:**
+   ```bash
+   node scripts/self-test.mjs --tier2                    # all skills with manifests
+   node scripts/self-test.mjs --tier2 --skill rdc:build  # single skill
+   node scripts/self-test.mjs --tier2 --parallel 3       # up to 3 skills in parallel
+   node scripts/self-test.mjs --tier2 --quick            # skip long-running assertions
+   ```
+
+3. **What it does:**
+   - Runs Tier 1 as a pre-gate (fails fast if static lint fails)
+   - Creates one Supabase test branch for the run
+   - For each skill: `git worktree add` into `.rdc/sandbox/<run-id>/<skill>/`, sets `RDC_TEST=1`, invokes `claude --print` with the skill prompt, waits for exit
+   - Asserts per the skill's manifest: exit code, files touched, commits made, stdout patterns
+   - Cleans up worktrees + deletes the Supabase branch at the end (even on failure)
+
+4. **Reports:**
+   - `.rdc/reports/self-test-tier2-<iso>.json` — full per-skill result, findings, timings
+   - Exit codes: `0` pass, `1` fail (one or more skills failed assertions), `2` runner error (couldn't set up sandbox / branch)
+
+5. **Adding a new manifest:**
+   - Create `skills/tests/<skill>.test.json` (one per skill, colocated)
+   - Validate the shape against the schema at `scripts/lib/manifest-schema.mjs`
+   - Test it in isolation: `node scripts/self-test.mjs --tier2 --skill rdc:name`
+   - Commit the manifest alongside any skill body changes
+
+## Rules
+- Run Tier 1 **before every `rdc:release rdc-skills`** — it catches the backtick-drift class of bugs that break the skill menu silently.
+- Use `--strict` in CI. Warnings matter in the release path.
+- Do NOT skip findings by relaxing the linter. Fix the skill.
+- Tier 2 is in planning — see epic `462b3e0a-37dd-4c9d-bed7-a1ad260b8bc1`.

package/commands/status.md

@@ -0,0 +1,86 @@
+---
+name: rdc:status
+description: >-
+  Usage `rdc:status` — open epics, work items by project, Coolify health, blockers, next recommended action. Read-only situational awareness.
+---
+
+> **⚠️ 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:status — Project Dashboard
+
+## When to Use
+- Start of any session
+- Project lead asks "what's the status", "where are we", "what's open"
+- Before deciding what to work on next
+
+## Procedure
+
+1. **Open epics:**
+   ```sql
+   SELECT get_open_epics();
+   ```
+
+2. **Work item counts by status:**
+   ```sql
+   SELECT status, count(*) FROM work_items 
+   WHERE status != 'archived' 
+   GROUP BY status ORDER BY status;
+   ```
+
+3. **Items by label/project (top 10 labels):**
+   ```sql
+   SELECT unnest(labels) as label, count(*), 
+          count(*) FILTER (WHERE status = 'done') as done,
+          count(*) FILTER (WHERE status = 'todo') as todo,
+          count(*) FILTER (WHERE status = 'in_progress') as wip
+   FROM work_items 
+   GROUP BY label ORDER BY count DESC LIMIT 10;
+   ```
+
+4. **Recent activity (last 48 hours):**
+   ```sql
+   SELECT title, status, updated_at 
+   FROM work_items 
+   WHERE updated_at > now() - interval '48 hours'
+   ORDER BY updated_at DESC LIMIT 15;
+   ```
+
+5. **Git status:**
+   ```bash
+   git log --oneline -10
+   git status
+   git branch -v
+   ```
+
+6. **Infrastructure health** (if MCP available):
+   - Get infrastructure overview or diagnose issues
+   - Report any apps with failed builds or down containers
+
+7. **Present as a compact dashboard:**
+   ```
+   ## Open Epics (N)
+   <table>
+   
+   ## Work Items: X done | Y todo | Z in_progress
+   
+   ## Recent (48h)
+   <list>
+   
+   ## Deployments
+   <green/red/yellow status>
+   
+   ## Recommended Next
+   <highest priority unstarted epic>
+   ```
+
+## Rules
+- Keep output concise — this is a glance, not a deep dive
+- Always end with a recommendation for what to work on next
+- After the Recommended Next section, suggest which guide file from `.rdc/guides/` (fallback: `.rdc/guides/`) the recommended work would need
+- Use database MCP for queries (not raw curl)
+- If infrastructure MCP is unavailable, skip deployment status and note it

package/commands/watch.md

@@ -0,0 +1,92 @@
+---
+name: rdc:watch
+description: >-
+  Usage `rdc:watch` — initialize a session log and open a browser viewer that tails Claude activity live. Zero infra, pure filesystem + static HTML.
+---
+
+> **⚠️ 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:watch — Session Log Watcher
+
+## When to Use
+- Start of any long-running session where Dave needs visibility into what you're doing
+- Before `rdc:overnight`, `rdc:build` on a large epic, or any multi-hour grind
+- Anytime the user asks for "a log", "a viewer", "tail", or "what are you doing right now"
+
+## Procedure
+
+1. **Initialize the log and viewer.** Run the helper script from the plugin directory in the user's current project:
+   ```bash
+   node ${CLAUDE_PLUGIN_ROOT}/scripts/watch-init.mjs
+   ```
+   (If `CLAUDE_PLUGIN_ROOT` is not set, resolve the plugin path from your invocation context. On Windows it's typically `C:/Dev/rdc-skills`.)
+
+2. **Parse the output.** The script prints `run_id`, `log_path`, `current`, `viewer`, and `open_hint`. Capture `log_path` and `viewer` for the rest of the session.
+
+3. **Open the viewer in the browser.** Run the exact `open_hint` line from the script output. On Windows that's `start "" "<viewer-path>"`.
+
+4. **Report to the user.** One line:
+   ```
+   watcher live at <viewer-path> — tailing <log-path>
+   ```
+
+5. **Append one line per substantive action for the rest of the session.** Use the documented format — one line, no multi-line payloads:
+   ```
+   [<ISO-timestamp>] [<kind>] <message>
+   ```
+   Append to BOTH `<log-path>` (the full history) AND `current.log` (what the viewer polls). The viewer diffs `current.log` by length and only appends new lines.
+
+### Log format
+
+- `ISO-timestamp` — `new Date().toISOString()`
+- `kind` — one of: `dispatch`, `commit`, `test`, `error`, `note`, `banner`
+- `message` — single line, no newlines. Keep under ~200 chars.
+
+### Kinds
+
+| Kind | When to append |
+|------|----------------|
+| `dispatch` | About to dispatch a subagent — include role + epic/task id |
+| `commit` | After a git commit lands — include short sha + subject |
+| `test` | Test run kicked off or result came back |
+| `error` | Anything that failed — include what and why in one line |
+| `note` | General progress ticks (reading files, analyzing, planning) |
+| `banner` | Session start/end markers, major phase changes |
+
+### Examples
+
+```
+[2026-04-15T23:14:02.318Z] [dispatch] frontend agent → epic abc123 task 4 (rebuild DynamicForm)
+[2026-04-15T23:17:41.902Z] [commit] 3f2a1b9 feat(marketing-engine): DynamicForm rhf+zod
+[2026-04-15T23:18:05.113Z] [test] pnpm --filter @regen/rdc-marketing-engine test
+[2026-04-15T23:18:41.002Z] [error] tsc: src/components/Form.tsx:42 — Property 'foo' does not exist
+[2026-04-15T23:19:00.000Z] [note] retrying with corrected type import
+[2026-04-15T23:45:10.000Z] [banner] Phase 2 complete — moving to review
+```
+
+### Appending from bash (Windows-safe)
+
+```bash
+printf '[%s] [%s] %s\n' "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "dispatch" "your message" >> "$LOG_PATH"
+printf '[%s] [%s] %s\n' "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "dispatch" "your message" >> "$CURRENT_PATH"
+```
+
+Or from Node:
+```js
+import { appendFileSync } from "node:fs";
+const line = `[${new Date().toISOString()}] [note] ${msg}\n`;
+appendFileSync(logPath, line);
+appendFileSync(currentPath, line);
+```
+
+## Notes
+
+- Log files live in the **user's project**, not the rdc-skills repo. Path: `<projectRoot>/.rdc/session-log/`
+- Each invocation creates a **new run id** and overwrites `current.log`. Prior run logs remain on disk as `<runId>.log`.
+- The viewer is a single static HTML file polling `current.log` via `fetch()` every 2s — no server, no deps.
+- This skill does NOT replace `rdc:report` (the end-of-session Obsidian writeup). It's a live tail for attended or semi-attended sessions.