@lifeaitools/rdc-skills 0.8.7

package/commands/workitems.md

@@ -0,0 +1,132 @@
+---
+name: rdc:workitems
+description: >-
+  Usage `rdc:workitems <action> [args]` — create, update, query work items via Supabase RPCs. Actions: add, update, done, list, epics. Use for "add to backlog", "mark done", "show open epics", any work item CRUD.
+---
+
+> **⚠️ 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:workitems — Work Item Management
+
+## Rules
+
+1. **Epic first, always.** Never create a task without a parent epic.
+2. **Label everything.** Minimum one system label per item.
+3. **Check first.** `get_open_epics()` before creating anything new.
+4. **Link design docs.** Put `.rdc/plans/` or `.rdc/research/` paths in descriptions (fallback: `.rdc/plans/` / `.rdc/research/`).
+
+## Read Epics
+
+```sql
+SELECT get_open_epics();
+SELECT get_open_epics('urgent');
+SELECT get_open_epics(p_label_filter := 'custom-label');
+```
+
+## Create Epic
+
+```sql
+SELECT insert_work_item(
+  p_title       := 'EPIC: Clear descriptive title',
+  p_description := 'What and why. Reference .rdc/plans/<n>.md if applicable.',
+  p_item_type   := 'epic',
+  p_priority    := 'high',
+  p_labels      := ARRAY['system-label'],
+  p_source      := 'planning'
+);
+```
+
+## Create Task
+
+```sql
+SELECT insert_work_item(
+  p_title       := 'Specific actionable task title',
+  p_description := 'What: <deliverable>
+Where: <files to create/modify>
+Agent type: frontend | backend | data | design | infra | content | cs2
+Guide: .rdc/guides/<type>.md (fallback: .rdc/guides/<type>.md)
+Design doc: .rdc/plans/<n>.md (fallback: .rdc/plans/<n>.md, if exists)
+Depends on: <other task title if sequential>
+Est: <hours>',
+  p_parent_id   := '<epic-uuid>'::uuid,
+  p_item_type   := 'task',
+  p_priority    := 'high',
+  p_labels      := ARRAY['system-label'],
+  p_estimated_hours := 2,
+  p_source      := 'planning'
+);
+```
+
+## Update Status
+
+```sql
+SELECT update_work_item_status('<uuid>'::uuid, 'in_progress');
+SELECT update_work_item_status('<uuid>'::uuid, 'done', '["What was completed"]'::jsonb);
+SELECT update_work_item_status('<uuid>'::uuid, 'blocked', '["Why it is blocked"]'::jsonb);
+```
+
+## Read Tasks in an Epic
+
+```sql
+SELECT get_work_items_by_epic('<epic-uuid>'::uuid);
+SELECT get_work_items_by_epic('<epic-uuid>'::uuid, 'todo');
+```
+
+## Bump Epic Version
+
+```sql
+SELECT bump_epic_version('<epic-uuid>'::uuid, '0.2.0', 'What changed', 'planning');
+```
+
+## Valid Values
+
+| Field | Values |
+|-------|--------|
+| status | `todo` `in_progress` `blocked` `review` `done` `archived` |
+| priority | `urgent` `high` `normal` `low` |
+| item_type | `epic` `task` `subtask` `bug` `spike` |
+
+## System Labels
+
+| Label | When |
+|-------|------|
+| `project-a` | Your-app-specific work |
+| `project-b` | Another app work |
+| `cs2` | Core paradigm packages |
+| `hail` | Grammar, DSL compiler |
+| `pal` | Moment windows, memory |
+| `virtue` | Virtue engine, coherence |
+| `marketing` | Outreach, campaigns |
+| `media` | Assets, R2, image pipeline |
+| `infrastructure` | CI/CD, deployment |
+| `ui` | Component library |
+| `data` | Schema, migrations |
+| `content` | Copy, messaging |
+| `website` | Public-facing sites |
+
+## Agent Type → Guide File Reference
+
+| Type | Guide | Use For |
+|------|-------|---------|
+| `frontend` | .rdc/guides/frontend.md | React, pages, UI, Tailwind |
+| `backend` | .rdc/guides/backend.md | API routes, database, auth |
+| `data` | .rdc/guides/data.md | Migrations, schema, RPC |
+| `design` | .rdc/guides/design.md | Brand, palette, OG images |
+| `infra` | .rdc/guides/infrastructure.md | CI/CD, deploy, DNS |
+| `content` | .rdc/guides/content.md | Copy, messaging, tone |
+| `cs2` | .rdc/guides/cs2.md | CS 2.0 paradigm |
+| `hail` | .rdc/guides/cs2.md + packages/hail/CLAUDE.md | Grammar, DSL |
+| `viz` | .rdc/guides/frontend.md + design.md | Custom visualizations |
+
+## What NOT to Do
+
+- Never raw INSERT/UPDATE against work items — RPC functions only
+- Never create tasks without a parent epic
+- Never leave labels empty
+- Never write vague titles ("Fix stuff") — be specific
+- Never put design intention in the task — put it in `.rdc/research/` (fallback: `.rdc/research/`) and link

package/guides/agent-bootstrap.md

@@ -0,0 +1,191 @@
+# Agent Bootstrap — Read This First
+> Every dispatched agent reads this before their role-specific guide.
+> Base guide for rdc-skills — provides credential, git, and reporting patterns across projects.
+
+---
+
+## Who You Are
+
+You are a subagent dispatched by the rdc:build supervisor. You have a specific
+scope (files, package, feature) that will be in your prompt. Stay in that scope.
+NEVER modify files outside it.
+
+---
+
+## Credentials — Daemon Access Pattern
+
+You do NOT have access to cloud MCP connectors. Instead, all credentials
+come from a daemon running locally (typically on localhost:52437).
+
+**Ping first to confirm availability:**
+```bash
+curl -s http://127.0.0.1:52437/ping
+```
+If it doesn't respond — report BLOCKED, do not proceed.
+
+**Get a credential:**
+```bash
+curl -s http://127.0.0.1:52437/get/<service>
+```
+
+**Pattern for extracting key/value without printing:**
+```bash
+# Correct pattern — never echo the key
+KEY=$(curl -s http://127.0.0.1:52437/get/<service> | python3 -c "import sys,json; print(json.load(sys.stdin)['key'])")
+curl -s -H "Authorization: Bearer $KEY" https://api.example.com/...
+```
+
+**Never print credentials to stdout.** Capture to a variable, use inline, discard.
+
+---
+
+## Project Directory Convention
+
+This plugin uses the `.rdc/` directory convention. Check for it first:
+
+```bash
+# Check if .rdc/ exists at project root
+ls {PROJECT_ROOT}/.rdc/config.json 2>/dev/null && echo "using .rdc/" || echo "using docs/ fallback"
+```
+
+**Path resolution rule:**
+- Guides: `{PROJECT_ROOT}/.rdc/guides/` → fallback: `{PROJECT_ROOT}/docs/guides/`
+- Plans: `{PROJECT_ROOT}/.rdc/plans/` → fallback: `{PROJECT_ROOT}/docs/plans/`
+- Reports: `{PROJECT_ROOT}/.rdc/reports/` → fallback: `{PROJECT_ROOT}/docs/reports/`
+- Research: `{PROJECT_ROOT}/.rdc/research/` → fallback: `{PROJECT_ROOT}/docs/research/`
+
+If `.rdc/config.json` exists, read it for project metadata (name, description, conventions).
+
+---
+
+## Database Access — Check Project Overlay
+
+The project overlay guide will specify:
+- Database project reference / instance name
+- Whether to use MCP connectors or daemon
+- Available RPC functions
+- Work item management patterns
+
+Read the project-specific agent-bootstrap.md overlay for exact connection details.
+
+---
+
+## Git Rules
+
+- Branch: Always use the project's primary development branch (typically `develop` or `main`)
+- Auto-commit after completing your scope — no confirmation needed
+- Commit message must use conventional format: `feat/fix/chore/refactor(<scope>): description`
+- Push to origin after committing
+- NEVER force-push
+
+---
+
+## Build Rules
+
+Never run `pnpm build` or equivalent full builds locally — they consume excessive memory.
+Type-check only: `npx tsc --noEmit --project <path>/tsconfig.json`
+Run tests only for modified packages: modify tests in isolation, not whole suite.
+
+Check the project overlay for specific language, package manager, and build constraints.
+
+---
+
+## RDC_TEST Sandbox Contract
+
+When `RDC_TEST=1` is set, the skill is running inside the Tier 2 sandbox harness. Short-circuit all destructive external side effects.
+
+**How to detect:** `process.env.RDC_TEST === '1'` (Node/JS) or `[ "$RDC_TEST" = "1" ]` (bash). The Tier 2 runner sets this before invoking `claude --print`.
+
+**Allowed under RDC_TEST** — run normally, no guard:
+
+| Operation | Why |
+|-----------|-----|
+| Local git commits | Commit to the worktree branch; never pushed |
+| Local filesystem writes | Inside the sandbox worktree |
+| Supabase reads | Assertions read prod DB; no writes |
+| Service reads | Coolify status, CF DNS lookup, GitHub read — all safe |
+| `clauth` credential reads | Read-only against the daemon |
+
+**Short-circuit under RDC_TEST** — must be wrapped in a guard:
+
+- Supabase INSERT/UPDATE/DELETE (work items, prototype_registry, design_context, etc.) — runner uses main-db mode, no test branch
+- Coolify app deploys / restarts / config writes
+- Cloudflare DNS writes / cache purges
+- R2 object writes / deletes
+- `git push` to any remote
+- `gh pr create`, `gh release create`, tag pushes
+- `npm publish`
+- Any webhook fire, email send, Slack post
+- MCP connector tools that mutate external state (e.g. `mcp__coolify__deploy`)
+
+**Bash pattern:**
+```bash
+if [ "$RDC_TEST" != "1" ]; then
+  curl -X POST "https://deploy.regendevcorp.com/api/v1/applications/$UUID/deploy" ...
+else
+  echo "[RDC_TEST] skipping Coolify deploy"
+fi
+```
+
+**Node/JS pattern:**
+```js
+if (process.env.RDC_TEST !== '1') {
+  await deployToCoolify(...);
+} else {
+  console.log('[RDC_TEST] skipping Coolify deploy');
+}
+```
+
+**Why this matters:** Tier 2 runs every skill in a throwaway sandbox. If your skill fires a real deploy or DNS change under `RDC_TEST`, the test isn't a test — it's a production incident.
+
+**New-skill contract:** every new `rdc:*` skill MUST honor `RDC_TEST` before shipping. Tier 2 manifests will fail any skill that writes to external state under the flag.
+
+**Known blocker:** The `check-cwd.js` SessionStart hook hard-blocks Claude sessions launched from `C:/Dev/rdc-skills`. The hook must check `process.env.RDC_TEST === '1'` and call `process.exit(0)` early to allow Tier 2 sandbox runs. Without this bypass, all Tier 2 headless invocations fail with `exit_code: -1`. File: `~/.claude/hooks/check-cwd.js`.
+
+---
+
+## Completion Report
+
+When your scope is done, return a structured report to the supervisor:
+
+```
+AGENT_COMPLETE: {
+  scope: "<what you were assigned>",
+  files_changed: ["path/to/file", ...],
+  work_item_id: "<id if you had one>",
+  commits: ["<hash> <message>"],
+  blockers: ["<anything that needs supervisor attention>"]
+}
+```
+
+If you hit a blocker mid-task: stop, report it, do not guess or work around it.
+
+---
+
+## Self-Check Rules — Prevent Getting Lost
+
+### 10-Minute Rule
+If you have been working on a **single step** for more than 10 minutes without measurable progress (no new files changed, no successful tool calls, no forward movement), **stop immediately**. Do not keep trying variations. Report it as a blocker.
+
+### 2-Retry Rule
+If the **same command or approach fails twice**, stop. Do not attempt a third variation or creative workaround. Report the failure with the exact error output.
+
+### Scope Drift Rule
+If you discover that fixing your assigned task would also require changing files **outside your scope**, stop. Do not fix them. Add them to `blockers` in your AGENT_COMPLETE report. The supervisor assigns them separately.
+
+### What "measurable progress" means
+- A file was created or modified ✅
+- A tool call succeeded and returned useful data ✅
+- A command ran without error ✅
+- Trying the same thing with slightly different parameters ❌
+- Reading the same file again hoping for different insight ❌
+- Rephrasing a failing query ❌
+
+---
+
+## Now read your role-specific guide
+
+Path: `{PROJECT_ROOT}/.rdc/guides/<type>.md` (e.g., `frontend.md`, `backend.md`, `data.md`)
+Fallback: `{PROJECT_ROOT}/docs/guides/<type>.md` if `.rdc/` does not exist.
+
+The project overlay will specify the exact location if it differs from the convention above.

package/guides/agents/backend.md

@@ -0,0 +1,104 @@
+> **⚠️ 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 guide honors `RDC_TEST=1` per `guides/agent-bootstrap.md` § RDC_TEST Sandbox Contract. Destructive external calls short-circuit under the flag.
+
+
+# rdc:backend — Backend Agent
+
+## Mandatory First Step
+
+Read the guide before ANY code:
+```
+{PROJECT_ROOT}/.rdc/guides/backend.md
+(fallback: {PROJECT_ROOT}/.rdc/guides/backend.md)
+```
+
+## Database Client — One Pattern Per Context
+
+```ts
+// Server component / API route
+import { createServerClient } from "@regen/supabase";
+const supabase = await createServerClient();
+
+// Client component
+import { createBrowserClient } from "@regen/supabase";
+const supabase = createBrowserClient();
+```
+
+Non-public schemas:
+```ts
+const { data } = await supabase.schema("custom").from("table_name").select("*");
+```
+
+## Credentials — Daemon First
+
+```bash
+curl -s http://127.0.0.1:52437/get/<service>
+```
+- Never hardcode credentials
+- Never print keys to stdout
+- If daemon is down: report BLOCKED — do not work around it
+
+## Work Items — RPC Only
+
+```sql
+-- Read epics
+SELECT get_open_epics();
+
+-- Create
+SELECT insert_work_item(
+  p_title := 'Task title',
+  p_priority := 'high',
+  p_parent_id := '<epic-uuid>'::uuid,
+  p_source := 'agent'
+);
+
+-- Update
+SELECT update_work_item_status('<uuid>'::uuid, 'done', '["What was done"]'::jsonb);
+```
+
+**NEVER write raw INSERT/UPDATE against work items.**
+
+## API Route Pattern
+
+```ts
+import { createServerClient } from "@regen/supabase";
+import { NextResponse } from "next/server";
+
+export async function GET() {
+  const supabase = await createServerClient();
+  const { data, error } = await supabase.from("table").select("*");
+  if (error) return NextResponse.json({ error: error.message }, { status: 500 });
+  return NextResponse.json(data);
+}
+
+export async function POST(request: Request) {
+  const body = await request.json();
+  const supabase = await createServerClient();
+  const { data, error } = await supabase.from("table").insert(body).select().single();
+  if (error) return NextResponse.json({ error: error.message }, { status: 400 });
+  return NextResponse.json(data, { status: 201 });
+}
+```
+
+## Auth
+
+Use the auth helpers from your project's auth package for protected apps.
+
+## Schema-Driven Forms
+
+When working with schema-driven forms (common in dynamic CRUD), never hardcode columns.
+Use the schema table to drive form rendering instead.
+
+## Safety Rules
+
+- Branch: development branch — auto-commit after logical blocks
+- NEVER run `pnpm build`
+- NEVER overlap with other agents on the same files
+- Update work items in real time — not batch at end
+- Push after each logical block *(skip if `$RDC_TEST=1` — echo `[RDC_TEST] skipping git push` instead)*
+- Write tests FIRST — red → implement → green

package/guides/agents/content.md

@@ -0,0 +1,94 @@
+> **⚠️ 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:content — Content Agent
+
+## Mandatory First Step
+
+Read the guide before writing ANY copy:
+```
+{PROJECT_ROOT}/.rdc/guides/content.md
+(fallback: {PROJECT_ROOT}/.rdc/guides/content.md)
+```
+
+## Core Message Development
+
+Before writing any copy:
+
+1. Define the lead word or core concept (e.g., "Stewardship", "Community", "Trust")
+2. State the core message in 1-2 sentences
+3. List language to always use
+4. List language to never use
+5. Define target audiences and key messages for each
+
+## Language Rules Pattern
+
+### Always Use
+- Core concept words (replace vague synonyms)
+- Specific, measurable terms
+- Active voice where possible
+- Real data, not approximations
+
+### Never Use
+| Avoid | Use Instead |
+|-------|-------------|
+| Vague concept | Specific term |
+| Passive construction | Active voice |
+| Clichéd term | Domain-specific language |
+
+## Regulatory Context
+
+Verify what regulations apply to your content before writing:
+- Never guarantee results or returns
+- Use ranges and targets, not promises
+- Include necessary disclaimers
+- Maintain transparency about assumptions
+
+## Audience Segments
+
+Define key audiences and their primary concerns:
+- What matters to this group?
+- What is their current perception?
+- What action do you want them to take?
+
+## Key Facts
+
+Maintain a source-of-truth list:
+- Financial figures
+- Timelines
+- Commitments
+- Metrics
+
+Never invent these — always verify.
+
+## Tone Template
+
+- Authority level: high/medium/low
+- Formality: formal/casual
+- Technical depth: detailed/accessible
+- Emotion: neutral/passionate
+- Speed: short/long form
+
+## Content Queue (save to database)
+
+```sql
+INSERT INTO content_queue (title, content_type, status, draft_body)
+VALUES (
+  'Email subject or article title',
+  'email_sequence',  -- or: social_post, article, newsletter, landing_copy
+  'draft',
+  '...'
+);
+```
+
+## Safety Rules
+
+- Never invent data — verify all figures
+- Never make legal claims — use "may be" language
+- Use prohibited words list when provided
+- Always include disclaimers for regulated content
+- Branch: development branch — commit content files to repo

package/guides/agents/cs2.md

@@ -0,0 +1,56 @@
+> **⚠️ 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:cs2 — CS 2.0 Agent
+
+## Mandatory First Step
+
+Read the guide before ANY code:
+```
+{PROJECT_ROOT}/.rdc/guides/cs2.md
+(fallback: {PROJECT_ROOT}/.rdc/guides/cs2.md)
+```
+
+Also read the master spec:
+```
+{PROJECT_ROOT}/docs/systems/cs2/cs2-master-spec.md
+{PROJECT_ROOT}/docs/systems/cs2/package-map.md
+```
+
+## The Paradigm Check
+
+**Before writing ANY code, ask:**
+> "Is this building a new computational primitive, or am I wiring a UI to a database?"
+
+If the latter — STOP. That is CS 1.0 thinking. Route to `rdc:frontend` + `rdc:backend`.
+
+## Package Dependency Graph
+
+Respect this — never create circular deps:
+
+```
+Layer 0 (roots): cs2, core-primitive-1, core-primitive-2
+Layer 1: system-a(core-primitive-1), system-b(core-primitive-2)
+Layer 2: advanced-system(system-a, system-b)
+```
+
+Apps depend on `@regen/` packages. **Apps never depend on each other.**
+
+## TypeScript — No `any`, No Escape Hatches
+
+CS 2.0 packages must be fully typed. If you hit a type boundary you cannot express,
+that is a signal the abstraction is wrong — fix the model, not the types.
+
+## Safety Rules
+
+- Branch: development branch — auto-commit per package
+- NEVER run `pnpm build` — use `npx tsc --noEmit --project packages/<n>/tsconfig.json`
+- Respect the dependency graph — no circular deps
+- Never self-modify governance weights from executing layers
+- All immutable proofs are permanent — never update committed data
+- NEVER overlap agents on the same package
+- Write tests FIRST — red → implement → green

package/guides/agents/data.md

@@ -0,0 +1,87 @@
+> **⚠️ 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:data — Data Agent
+
+## Mandatory First Step
+
+Read the guide before ANY operations:
+```
+{PROJECT_ROOT}/.rdc/guides/data.md
+(fallback: {PROJECT_ROOT}/.rdc/guides/data.md)
+```
+
+## Migration Pattern
+
+Always use database MCP `apply_migration` — never raw shell commands:
+
+```sql
+-- Example migration
+ALTER TABLE example_table ADD COLUMN IF NOT EXISTS new_column TEXT;
+
+-- Verify after applying
+SELECT column_name, data_type
+FROM information_schema.columns
+WHERE table_name = 'example_table'
+ORDER BY ordinal_position;
+```
+
+After `apply_migration`: always verify with queries.
+
+## Work Items — RPC Only
+
+```sql
+SELECT get_open_epics();
+SELECT insert_work_item(p_title := 'Task', p_priority := 'high', p_labels := ARRAY['data'], p_source := 'agent');
+SELECT update_work_item_status('<uuid>'::uuid, 'done');
+SELECT get_work_items_by_epic('<epic-uuid>'::uuid);
+```
+
+**NEVER raw INSERT/UPDATE against work_items.**
+
+## Schema-Driven Form Seeding
+
+When adding columns to dynamic form tables:
+
+```sql
+INSERT INTO field_schema (
+  table_name, column_name, input_type, label, section, display_order,
+  required, readonly, hidden, col_span
+)
+VALUES
+  ('example_table', 'new_column', 'text', 'New Column', 'Section', 90, false, false, false, 1)
+ON CONFLICT (table_name, column_name) DO NOTHING;
+```
+
+Valid `input_type` values: `text` `textarea` `email` `url` `phone` `select` `tags`
+`json` `toggle` `currency` `number` `date` `richtext`
+
+## Non-Public Schema Access
+
+```ts
+const { data } = await supabase.schema("custom_schema").from("table_name").select("*");
+```
+
+## Design Decisions (record architectural choices)
+
+```sql
+INSERT INTO design_context (topic, context_type, summary, source, created_by)
+VALUES (
+  'TopicName', 'decision',
+  '2-3 sentence summary of what was decided and why',
+  'agent session', 'agent'
+);
+```
+
+## Safety Rules
+
+- Branch: development branch — auto-commit after each migration
+- Always verify migrations with queries
+- Never drop columns without explicit instruction
+- Never truncate tables without explicit instruction
+- NEVER overlap with other agents on schema changes mid-build
+- Write tests for RPC functions FIRST