Rebar Wiki

commands

5 min read

Commands

Rebar has 26 slash commands organized into five groups: client/app management, development workflow, wiki management, self-learning harness, and utilities.

All commands auto-resolve names from clients/, apps/, and tools/ directories.

Self-Learning Harness (new)

Three commands run after every shipped feature to keep the system compounding:

  • /close-loop [feature] — orchestrates the full cycle: evaluator validates → release gate scans for blocker language ("must generate migration", "cannot ship", "before any live DB") → /improve --from eval-file promotes cycle-scoped observations → /meta-improve detects 2+ occurrence patterns and queues template patches → /wiki-ingest captures durable knowledge.
  • /meta-improve — reads system/evaluator-log.md, detects recurring failure patterns, writes Edit-tool-compatible patches to system/meta-improve-queue/<date>-<slug>.patch.md. Never directly edits .claude/commands/* — sensitive-file boundary.
  • /meta-apply — human-in-loop reviewer. Walks the queue, shows each diff, asks y/n, applies via Edit, archives to applied/. Runs in the main session where sensitive writes are approvable.

The release gate is the load-bearing part — it stops “PASS with follow-ups” from being treated the same as “shipped.” See architecture.md → Close-Loop Harness.

Client / App Management

/create <name>

Create a new client or app. Prompts progressively for what you know, creates config files, then hands off to /discover.

> Client name: acme-integration
> Display name: Acme Logistics Integration
> Industry: trade compliance / logistics
> Goal: AI-assisted flow generation and deployment for Node-RED platform

/discover <name>

Auto-generate a Phase 0 discovery document and seed expertise.yaml. Pulls from every available source (Jira, Slack, live systems, codebase). Marks anything it cannot derive as TODO.

Phase 0 identified:
  - 4 core flows (receiving, compliance, filing, tracking)
  - Node-RED Admin API as deployment target
  - Credential nodes as special case (not returned by GET)
  - MQTT as inter-flow communication

/brief <name>

Generate a standup/handoff summary from expertise.yaml. This is typically the first command at the start of each session.

Site Builder — Briefing
━━━━━━━━━━━━━━━━━━━━━━
Status: Building (Day 2)
Pipeline: 4 steps, URL→Scrape→Generate→Build
Key gap: Content quality (generic output)
Unvalidated: 2 deferred observations (reviews, images)
Next priority: Enrich business data before generation step

Suggested focus:
  1. Add review scraping to maps_scraper.py
  2. Consider website scraping as supplementary data source
  3. Image generation for hero/gallery sections

/improve <name>

Validate unvalidated observations against current state. Promotes confirmed facts, discards stale ones, defers unverifiable ones.

Reviewing 4 unvalidated observations...

PROMOTED: "Website scraper color extraction is brittle"
  → Added to scraping.known_limitations

DISCARDED: "WebSocket progress reporting would be useful"
  Reason: Already implemented later in the same session.

3 promoted, 1 discarded, 0 deferred.

/check <name>

Design guidelines compliance check against a Phase 0 document. Reports what is compliant, incomplete, or missing.

Development Workflow

/new <app-name> <description>

Scaffold a new application under apps/ with expertise.yaml initialized and expertise bootstrapped.

/takeover <app-name>

Understand an existing app, build its expertise domain, and produce a prime context file. After this, the app is integrated into the framework and ready for /feature.

/feature <app-name> <request>

Expertise-informed feature workflow: load context, plan, build, then update the self-learn loop.

/bug <app-name> <symptom>

Investigation-first bug fixing: reproduce, locate faulty code, make minimal change, verify. Fires self-learn at the end to capture the bug pattern.

/plan <prompt>

Create a detailed implementation plan and save it to specs/. Explores the codebase to understand existing patterns before planning. Supports parallel scout subagents for complex features.

/build <path-to-plan>

Implement a plan file top-to-bottom, validate the work, then append passive expertise observations.

/test <app-name> [backend|frontend|all]

Run the test suite, parse results, report failures with exact locations. Optionally fix failures before reporting.

/review <app-name>

Code review of recent changes for correctness, security, pattern compliance, and test coverage. Produces a structured report with CRITICAL / WARNING / NOTE classifications.

/scout <app-name> <question>

Read-only codebase investigation. Analyzes issues, identifies root causes, suggests fixes without modifying files.

Wiki Management

/wiki-ingest

Scan raw/ folder for unprocessed files (markdown, PDF, text, HTML) and ingest them into wiki pages. Updates index, adds cross-links, moves processed files to raw/processed/.

/wiki-file <topic>

Capture an insight from the current conversation as a permanent wiki page. This is the compounding loop — when something is figured out, it never has to be figured out again.

/wiki-lint [fix]

Health check on wiki/: orphan pages, broken links, stale pages, contradictions with expertise.yaml, missing index entries. Pass fix to auto-repair.

Utilities

/meeting <client> [keyword]

Ingest meeting notes from Gmail (Gemini auto-notes) into notes.md and expertise.yaml.

/meta-prompt <request>

Create a new slash command prompt based on a description.

Advanced Workflow

/plan-build-improve <app> <request>

One-command full SDLC cycle. Chains /plan → /build → /improve sequentially. Loads expertise first so the plan is context-aware, builds from the plan, then validates the expertise against what changed.

/test-learn <app> [focus_area]

Run tests → analyze results → update expertise. Different from /test (which just runs) and /improve (which validates observations). This uses test results as a source of truth to discover undocumented system behavior and update expertise.yaml.

/plan-scout <prompt>

Enhanced planning with parallel context gathering. Deploys 8 scout agents (3 deep + 5 fast) to explore the codebase before creating the plan. Produces better plans for complex features.

/build-parallel <plan-file>

Parallel implementation. Reads a plan file and delegates file creation to parallel build agents, each handling one file with detailed specs. Faster than sequential /build for multi-file features.

Graph View

Backlinks