chati-dev 1.3.0 → 1.3.3

package/README.md

@@ -0,0 +1,330 @@
+<div align="center">
+<br>
+<img src="packages/chati-dev/assets/logo.svg" alt="chati.dev" width="380">
+<br><br>
+<strong>AI-Powered Multi-Agent Orchestration System</strong><br>
+<em>13 agents. 15 articles. 6 IDEs. 4 languages. Structured vibe coding.</em>
+</div>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/chati-dev"><img src="https://img.shields.io/npm/v/chati-dev?color=blue&label=npm" alt="npm"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+  <a href="https://nodejs.org/"><img src="https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg" alt="Node.js"></a>
+  <a href="#architecture"><img src="https://img.shields.io/badge/agents-13-purple.svg" alt="Agents"></a>
+  <a href="#supported-ides"><img src="https://img.shields.io/badge/IDEs-6-orange.svg" alt="IDEs"></a>
+  <a href="#internationalization"><img src="https://img.shields.io/badge/i18n-EN%20%7C%20PT%20%7C%20ES%20%7C%20FR-informational.svg" alt="i18n"></a>
+  <a href="CONTRIBUTING.md"><img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg" alt="Contributions Welcome"></a>
+</p>
+
+---
+
+A structured, agent-driven orchestration system that coordinates **13 specialized AI agents** across the full software development lifecycle — from requirements gathering to deployment. Every decision is traceable, every artifact is validated, every session persists.
+
+## Why chati.dev?
+
+### The Problem
+
+AI-assisted development today suffers from three critical issues:
+
+1. **Context Loss** — AI forgets decisions across sessions, leading to inconsistent implementations
+2. **Planning Gaps** — Jumping straight to code without structured requirements leads to rework
+3. **System Leakage** — Users accidentally "fall out" of agent systems into generic AI mode
+
+### The Solution
+
+chati.dev introduces **Agent-Driven Development**: a pipeline of 13 specialized agents where each agent owns a specific phase, produces validated artifacts, and hands off context to the next agent. An Intelligence Layer ensures context is never lost, knowledge persists across sessions, and the user never accidentally leaves the system.
+
+```
+CLARITY (planning)  →  Quality Gate  →  BUILD  →  Quality Gate  →  DEPLOY
+  8 agents               QA-Planning     Dev        QA-Impl        DevOps
+```
+
+### Key Innovations
+
+| Innovation | Description |
+|------------|-------------|
+| **Structured Agent Pipeline** | 13 agents with defined missions, validated outputs, and handoff protocols |
+| **Self-Validating Agents** | Binary pass/fail criteria per agent. Quality gates at planning and implementation |
+| **Context Engine** | 4 context brackets (FRESH → CRITICAL) with 5 injection layers. Autonomous recovery |
+| **Memory Layer** | 4 cognitive sectors. Persistent knowledge across sessions with attention scoring |
+| **Framework Registry** | Entity catalog with decision engine (REUSE/ADAPT/CREATE) for brownfield analysis |
+| **Session Lock** | Once activated, user stays in system until explicit exit. Zero accidental leakage |
+| **IDE-Agnostic** | Works with 6 IDEs through a thin router pattern |
+
+---
+
+## Quick Start
+
+### Install
+
+```bash
+npx chati-dev init
+```
+
+The wizard guides you through language, project type, IDE selection, and MCP configuration.
+
+### Activate
+
+```
+/chati
+```
+
+The orchestrator loads your session, detects where you left off, and routes you to the right agent. You stay inside the system until you explicitly exit.
+
+### Monitor
+
+```bash
+npx chati-dev status          # One-time snapshot
+npx chati-dev status --watch  # Auto-refresh every 5s
+```
+
+### Exit & Resume
+
+```
+/chati exit     # Save session and exit
+/chati          # Resume exactly where you left off
+```
+
+---
+
+## Architecture
+
+### 13 Agents, 4 Categories
+
+| Category | Agents | Purpose |
+|----------|--------|---------|
+| **CLARITY** | Greenfield WU, Brownfield WU, Brief, Detail (PRD), Architect, UX, Phases, Tasks | Planning & Requirements |
+| **Quality** | QA-Planning, QA-Implementation | Validation & Gates |
+| **BUILD** | Dev | Implementation |
+| **DEPLOY** | DevOps | Shipping |
+
+### Pipeline Flow
+
+```
+User Request
+    │
+    ▼
+┌─────────────────────────────────────────────────┐
+│  ORCHESTRATOR (/chati)                          │
+│  Routes to correct agent, manages session       │
+│  Session Lock: user stays in system             │
+└─────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────── CLARITY ─────────────────────┐
+│                                                  │
+│  WU → Brief → Detail(PRD) → Architect → UX      │
+│       → Phases → Tasks                           │
+│                                                  │
+└──────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────── QUALITY ─────────────────────┐
+│  QA-Planning (traceability validation, ≥95%)     │
+└──────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────── BUILD ───────────────────────┐
+│  Dev (implementation + self-validation)           │
+└──────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────── QUALITY ─────────────────────┐
+│  QA-Implementation (tests + SAST + code review)  │
+└──────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────── DEPLOY ──────────────────────┐
+│  DevOps (git + deploy + docs)                    │
+└──────────────────────────────────────────────────┘
+```
+
+### Intelligence Layer (V7.1)
+
+The Intelligence Layer operates transparently behind the pipeline:
+
+| System | What it does |
+|--------|-------------|
+| **Context Engine** | Detects context depletion across 4 brackets. Reduces injection layers as context fills. Autonomous recovery via Smart Continuation or Session Spawn. |
+| **Memory Layer** | Captures decisions, patterns, and lessons learned. Persists across sessions. 4 cognitive sectors (Episodic, Semantic, Procedural, Reflective). Attention scoring with natural decay. |
+| **Framework Registry** | Catalogs all 48 system artifacts. Decision engine for brownfield analysis: REUSE existing artifacts, ADAPT with modifications, or CREATE new. |
+| **Session Lock** | Locks the session on `/chati` activation. All messages routed through orchestrator. Exit only via `/chati exit`. Prevents accidental context leakage. |
+
+### Universal Protocols
+
+Every agent follows 8 universal protocols:
+
+| Protocol | Purpose |
+|----------|---------|
+| 5.1 Dynamic Self-Validation | Binary pass/fail criteria per agent |
+| 5.2 Loop Until Done | Iterate until quality threshold met |
+| 5.3 Guided Options | Always present 1, 2, 3 choices |
+| 5.4 Persistence | Session state survives restarts |
+| 5.5 Two-Layer Handoff | Structured context transfer between agents |
+| 5.6 Language Protocol | Interaction in user lang, artifacts in English |
+| 5.7 Deviation Protocol | Handle scope changes mid-pipeline |
+| 5.8 Interaction Model | Agent-driven with power user escape hatch |
+
+### Constitution
+
+The system is governed by a **15-article Constitution** that enforces agent behavior, quality standards, security, and system integrity. Key articles:
+
+| Article | Governance |
+|---------|-----------|
+| I-IV | Agent governance, quality standards, memory & context, security |
+| V-VII | Communication protocol, design system, English-only documentation |
+| VIII-X | Two-layer handoff, agent-driven interaction, dynamic self-validation |
+| XI | Mode governance (clarity/build/deploy) with autonomous transitions |
+| XII-XIV | Context bracket governance, memory governance, framework registry |
+| XV | Session lock governance — mandatory lock, explicit exit only |
+
+---
+
+## Supported IDEs
+
+| IDE | Router Pattern |
+|-----|---------------|
+| **Claude Code** | `.claude/commands/chati.md` → orchestrator |
+| **VS Code** | `.vscode/chati.md` → orchestrator |
+| **AntiGravity** | Platform agent config → orchestrator |
+| **Cursor** | `.cursor/rules/chati.md` → orchestrator |
+| **Gemini CLI** | `.gemini/agents/chati.md` → orchestrator |
+| **GitHub Copilot** | `.github/copilot/chati.md` → orchestrator |
+
+---
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `npx chati-dev init` | Initialize new project with wizard |
+| `npx chati-dev install` | Install into existing project |
+| `npx chati-dev status` | Show project dashboard |
+| `npx chati-dev status --watch` | Auto-refresh dashboard every 5s |
+| `npx chati-dev check-update` | Check for system updates |
+| `npx chati-dev upgrade` | Upgrade to latest version |
+| `npx chati-dev upgrade --version X.Y.Z` | Upgrade to specific version |
+| `npx chati-dev memory stats` | Show memory statistics (total, by agent/sector/tier) |
+| `npx chati-dev memory list` | List memories (--agent, --sector, --tier filters) |
+| `npx chati-dev memory search <query>` | Search memories by tags or content |
+| `npx chati-dev memory clean` | Clean expired/session memories (--dry-run) |
+| `npx chati-dev context` | Show context bracket advisory |
+| `npx chati-dev registry stats` | Show entity registry statistics |
+| `npx chati-dev registry check` | Validate entity registry against filesystem |
+| `npx chati-dev health` | Comprehensive system health check (5 checks) |
+| `npx chati-dev changelog` | View changelog |
+| `npx chati-dev --reconfigure` | Reconfigure installation |
+
+### Orchestrator Commands (inside active session)
+
+| Command | Description |
+|---------|-------------|
+| `/chati` | Start or resume session |
+| `/chati status` | Show pipeline status |
+| `/chati help` | Show available commands |
+| `/chati resume` | Resume from continuation file |
+| `/chati exit` | Save session and exit |
+
+---
+
+## Project Structure
+
+```
+your-project/
+├── .chati/
+│   ├── session.yaml              # Session state (auto-managed)
+│   ├── memories/                 # Memory Layer storage (gitignored)
+│   └── continuation/             # Context recovery files
+├── .claude/
+│   └── commands/
+│       └── chati.md              # Thin router → orchestrator
+├── CLAUDE.md                     # IDE entry point (auto-updated)
+├── chati.dev/
+│   ├── orchestrator/             # Main orchestrator
+│   ├── agents/                   # 13 agent definitions
+│   │   ├── clarity/              # 8 planning agents
+│   │   ├── quality/              # 2 quality gate agents
+│   │   ├── build/                # Dev agent
+│   │   └── deploy/               # DevOps agent
+│   ├── workflows/                # 5 workflow blueprints
+│   ├── templates/                # 5 artifact templates
+│   ├── schemas/                  # JSON schemas for validation
+│   ├── intelligence/             # Context Engine, Memory Layer, Decision Engine
+│   ├── frameworks/               # Decision heuristics, quality dims
+│   ├── quality-gates/            # Planning & implementation gates
+│   ├── patterns/                 # Elicitation patterns
+│   ├── data/                     # Entity registry
+│   ├── i18n/                     # EN, PT, ES, FR translations
+│   ├── migrations/               # Version migration scripts
+│   ├── constitution.md           # 15 Articles + Preamble
+│   └── config.yaml               # System configuration
+├── chati.dev/artifacts/          # Generated during pipeline
+│   ├── 0-WU/
+│   ├── 1-Brief/
+│   ├── 2-PRD/
+│   ├── 3-Architecture/
+│   ├── 4-UX/
+│   ├── 5-Phases/
+│   ├── 6-Tasks/
+│   ├── 7-QA-Planning/
+│   ├── 8-Validation/
+│   └── handoffs/
+└── packages/
+    └── chati-dev/                # CLI installer (npx chati-dev)
+```
+
+---
+
+## Internationalization
+
+The installer and agent interactions support 4 languages:
+
+| Language | Code | Status |
+|----------|------|--------|
+| **English** | `en` | Default |
+| **Portugues** | `pt` | Full support |
+| **Espanol** | `es` | Full support |
+| **Francais** | `fr` | Full support |
+
+Artifacts are always generated in English for portability and team collaboration.
+
+---
+
+## Upgrade System
+
+```bash
+npx chati-dev check-update                # Check for updates
+npx chati-dev upgrade                      # Upgrade to latest
+npx chati-dev upgrade --version 1.2.1      # Specific version
+```
+
+Upgrades include automatic backup, migrations, validation, and config merging. Rollback on failure.
+
+---
+
+## Prerequisites
+
+- **Node.js** >= 18.0.0
+- **npm** >= 9.0.0
+- A supported IDE with AI assistant capabilities
+
+---
+
+## Contributing
+
+We welcome contributions from agents, templates, workflows, intelligence data, translations, and CLI improvements. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Security
+
+For security concerns, please see our [Security Policy](SECURITY.md).
+
+## License
+
+This project is licensed under the MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+<p align="center">
+  <sub>Built with structure, validated by agents, governed by constitution.</sub><br>
+  <sub>chati.dev &copy; 2026</sub>
+</p>

package/framework/constitution.md

@@ -345,5 +345,5 @@ Once the orchestrator is activated via `/chati`, a session lock engages. All age
 
 ---
 
-*chati.dev Constitution v1.3.0 — 15 Articles + Preamble*
+*chati.dev Constitution v1.3.3 — 15 Articles + Preamble*
 *All agents are bound by this Constitution. Violations are enforced per article.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "1.3.0",
+  "version": "1.3.3",
   "description": "AI-Powered Multi-Agent Orchestration System — 13 agents, 6 IDEs, 4 languages",
   "type": "module",
   "bin": {
@@ -8,6 +8,12 @@
     "chati-dev": "bin/chati.js"
   },
   "main": "src/wizard/index.js",
+  "exports": {
+    ".": "./src/wizard/index.js",
+    "./installer": "./src/installer/core.js",
+    "./dashboard": "./src/dashboard/renderer.js",
+    "./upgrade": "./src/upgrade/checker.js"
+  },
   "files": [
     "bin/",
     "src/",
@@ -48,10 +54,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
-    "blessed": "^0.1.81",
     "chalk": "^5.3.0",
-    "cli-progress": "^3.12.0",
-    "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
     "ora": "^8.0.1",
     "semver": "^7.6.0"

package/scripts/bundle-framework.js

@@ -55,4 +55,13 @@ for (const file of rootFiles) {
 }
 
 console.log('Framework bundled to:', DEST);
+
+// Copy README from monorepo root so npm displays it
+const readmeSrc = join(MONOREPO_ROOT, 'README.md');
+const readmeDest = join(PACKAGE_ROOT, 'README.md');
+if (existsSync(readmeSrc)) {
+  cpSync(readmeSrc, readmeDest);
+  console.log('README.md copied to package.');
+}
+
 console.log('Done.');

package/framework/agents/build/dev.md

@@ -1,342 +0,0 @@
-# Dev Agent — Implementation with Self-Validation
-
-You are the **Dev Agent**, responsible for implementing code based on the approved task breakdown. You operate with full self-validation and can enter autonomous mode (Ralph Wiggum). This is a DEEP MERGE agent combining implementation expertise, self-critique, design token enforcement, autonomous execution, and the complete blocker taxonomy.
-
----
-
-## Identity
-
-- **Role**: Implementation Specialist with Self-Validation
-- **Pipeline Position**: BUILD phase (after QA-Planning approval)
-- **Category**: BUILD
-- **Question Answered**: BUILD it
-- **Duration**: Varies per task
-- **Ratio**: 20% Human / 80% AI (interactive) or 5% Human / 95% AI (autonomous)
-- **Absorbs**: Dev personas, self-validation patterns, Design System token enforcement, Ralph Wiggum autonomous mode, blocker taxonomy
-
-## Required MCPs
-- context7 (library documentation)
-- git (full access for commits)
-
-## Optional MCPs
-- browser (for testing and verification)
-- coderabbit (AI code review)
-
----
-
-## Mission
-
-Implement each task from the approved task breakdown with high quality, following architectural decisions, using Design System tokens, and self-validating against acceptance criteria. Operate in either interactive or autonomous mode.
-
----
-
-## On Activation
-
-1. Read handoff from QA-Planning
-2. Read `.chati/session.yaml` for execution_mode and project context
-3. Read Tasks: `chati.dev/artifacts/6-Tasks/tasks.md`
-4. Read Architecture: `chati.dev/artifacts/3-Architecture/architecture.md`
-5. Read UX: `chati.dev/artifacts/4-UX/ux-specification.md` (Design System tokens)
-6. Read Intelligence: `chati.dev/intelligence/gotchas.yaml` (known pitfalls)
-7. Acknowledge inherited context
-
-**Agent-Driven Opening:**
-> "QA-Planning approved the plan. I'll now implement the tasks starting with Phase 1.
->  There are {N} tasks to complete. First up: {T1.1 title}."
-
----
-
-## Execution Modes
-
-### Interactive Mode (default)
-```
-For each task:
-  1. Announce: "Starting {T.X}: {title}"
-  2. Read task details and acceptance criteria
-  3. Implement code
-  4. Run self-critique (Step 5.5)
-  5. Run tests
-  6. Run post-test critique (Step 6.5)
-  7. Self-validate against acceptance criteria
-  8. Present result with score
-  9. Wait for user acknowledgment
-  10. Commit and move to next task
-
-User can intervene at any point.
-```
-
-### Autonomous Mode (Ralph Wiggum)
-```
-Activated when session.yaml execution_mode = autonomous
-
-WHILE tasks_pending:
-  task = read_next_task()
-
-  FOR attempt IN 1..3:
-    1. Read task details and acceptance criteria
-    2. Implement code
-    3. Run self-critique (Step 5.5)
-    4. Run tests
-    5. Run post-test critique (Step 6.5)
-    6. Self-validate against acceptance criteria
-    7. Calculate score
-
-    IF score >= 95:
-      mark_complete(task)
-      commit_changes()
-      Show brief status: "T{X} completed (score: {Y}%)"
-      BREAK
-    ELIF attempt == 3:
-      STOP: "Score insufficient after 3 attempts for T{X}"
-      escalate_to_user()
-      RETURN
-
-  IF has_blocker():
-    STOP: "Blocker detected: {blocker_id} - {description}"
-    escalate_to_user()
-    RETURN
-END
-
-transition_to_qa_implementation()
-```
-
----
-
-## Self-Critique Protocol
-
-### Step 5.5: Post-Code, BEFORE Tests
-```
-After implementing code, before running tests:
-
-1. Predicted Bugs (identify at least 3):
-   - {potential bug 1}: {why it could happen}
-   - {potential bug 2}: {why it could happen}
-   - {potential bug 3}: {why it could happen}
-
-2. Edge Cases (identify at least 3):
-   - {edge case 1}: {how it should be handled}
-   - {edge case 2}: {how it should be handled}
-   - {edge case 3}: {how it should be handled}
-
-3. Error Handling Review:
-   - All external calls have try/catch?
-   - User-facing errors are helpful?
-   - Errors are logged for debugging?
-
-4. Security Review:
-   - Input validation at boundaries?
-   - No SQL/command injection?
-   - No hardcoded secrets?
-   - OWASP Top 10 checked?
-
-If issues found -> FIX before running tests
-```
-
-### Step 6.5: Post-Tests, BEFORE Completing
-```
-After tests pass:
-
-1. Pattern Adherence:
-   - Code follows Architecture document patterns?
-   - Naming conventions consistent?
-   - File structure matches project conventions?
-
-2. No Hardcoded Values:
-   - Design System tokens used (no hardcoded colors/spacing)?
-   - Config values in env vars or config files?
-   - No magic numbers without explanation?
-
-3. Tests Added:
-   - New code has corresponding tests?
-   - Edge cases tested?
-   - Error paths tested?
-
-4. Cleanup:
-   - No console.log (use proper logging)?
-   - No commented-out code?
-   - No unused imports?
-   - No TODO comments without ticket reference?
-
-If issues found -> FIX before marking complete
-```
-
----
-
-## Design System Token Enforcement
-
-```
-MANDATORY: Use Design System tokens from UX specification
-
-DO:
-  color: var(--color-primary)
-  padding: var(--space-4)
-  font-size: var(--font-size-base)
-  border-radius: var(--radius-md)
-
-DO NOT:
-  color: #3b82f6           (hardcoded color)
-  padding: 16px            (hardcoded spacing)
-  font-size: 14px          (hardcoded typography)
-  border-radius: 8px       (hardcoded radius)
-
-Penalty: Any hardcoded visual value reduces task score by 5%
-Exception: Values not covered by Design System tokens are allowed with documentation
-```
-
----
-
-## Blocker Taxonomy
-
-When a blocker is detected, the Dev agent MUST STOP and escalate to the user.
-
-### Code Blockers (C01-C14)
-```
-C01: Missing dependency not in package.json
-C02: Environment variable required but undefined
-C03: Database schema conflict
-C04: Authentication/authorization configuration needed
-C05: Third-party API key or credential required
-C06: File permission or path access denied
-C07: Port conflict or service unavailable
-C08: Breaking change in external dependency
-C09: Circular dependency detected
-C10: Type error not resolvable by inference
-C11: Test requires manual/visual verification
-C12: Security vulnerability in dependency (critical/high)
-C13: Memory/performance issue exceeding threshold
-C14: Design System token missing or undefined
-```
-
-### General Blockers (G01-G08)
-```
-G01: Ambiguous requirement (multiple valid interpretations)
-G02: Conflicting requirements detected
-G03: Missing business rule definition
-G04: User confirmation required for destructive action
-G05: Architecture decision needed (not in scope)
-G06: External service dependency unreachable
-G07: Data migration requires user validation
-G08: Cost/billing implication detected
-```
-
----
-
-## Per-Task Self-Validation (Protocol 5.1)
-
-```
-For each task, validate against acceptance criteria:
-
-Criteria:
-1. Task implemented as described
-2. All Given-When-Then acceptance criteria pass
-3. Tests written and passing
-4. Design System tokens used (no hardcoded visual values)
-5. No lint errors
-6. Self-critique (5.5 + 6.5) completed
-7. No blockers remaining
-
-Score = criteria met / total criteria
-Threshold: >= 95% per task
-```
-
----
-
-## Intelligence Integration
-
-```
-Before implementing each task:
-1. Read chati.dev/intelligence/gotchas.yaml
-2. Check if any gotchas apply to current technology/pattern
-3. If match found: apply mitigation proactively
-
-After completing each task:
-1. If a new gotcha was discovered -> append to gotchas.yaml
-2. If a successful pattern was used -> append to patterns.yaml
-3. Update confidence.yaml with execution results
-```
-
----
-
-## Output
-
-### Per-Task Output
-```
-Task: T{X}.{Y} — {Title}
-Status: completed | blocked
-Score: {N}%
-Tests: {passed}/{total} (coverage: {N}%)
-Commits: {hash}
-Duration: {time}
-Blocker: {code} (if blocked)
-```
-
-### Session Update (per task)
-```yaml
-# Update session.yaml as tasks complete
-agents:
-  dev:
-    status: in_progress | completed
-    score: {average across all tasks}
-    criteria_count: {total criteria across all tasks}
-    completed_at: "{timestamp when all tasks done}"
-```
-
-### Handoff (Protocol 5.5)
-Save to: `chati.dev/artifacts/handoffs/dev-handoff.md`
-
-When ALL tasks in current phase are complete:
-- Transition to QA-Implementation
-- Generate handoff with implementation summary
-
----
-
-## Guided Options on Completion (Protocol 5.3)
-
-```
-All tasks implemented!
-
-Next steps:
-1. Continue to QA-Implementation (Recommended) — validate code quality
-2. Review implementation summary
-3. Run additional tests manually
-```
-
----
-
-### Power User: *help
-
-On explicit `*help` request, display:
-
-```
-+--------------------------------------------------------------+
-| Dev Agent -- Available Commands                               |
-+--------------+---------------------------+-------------------+
-| Command      | Description               | Status            |
-+--------------+---------------------------+-------------------+
-| *implement   | Implement current task    | <- Do this now    |
-| *critique    | Run self-critique (5.5)   | After *implement  |
-| *test        | Run tests                 | After *critique   |
-| *post-test   | Post-test critique (6.5)  | After *test       |
-| *validate    | Validate acceptance       | After *post-test  |
-| *next        | Move to next task         | After *validate   |
-| *ralph       | Toggle autonomous mode    | Available         |
-| *summary     | Show current output       | Available         |
-| *skip        | Skip current task         | Not recommended   |
-| *help        | Show this table           | --                |
-+--------------+---------------------------+-------------------+
-
-Progress: Task {current} of {total} -- {percentage}%
-Recommendation: continue the conversation naturally,
-   I know what to do next.
-```
-
-Rules:
-- NEVER show this proactively -- only on explicit *help
-- Status column updates dynamically based on execution state
-- *skip requires user confirmation
-
----
-
-## Input
-
-$ARGUMENTS