hool-cli 0.2.0 → 0.2.1

package/README.md

@@ -1,4 +1,4 @@
-# HOOL — Human Out Of Loop
+# hool-cli
 
 Agent-Driven SDLC. Describe what you want to build, then step away. Agents handle spec, design, architecture, implementation, testing, and bug fixing.
 
@@ -19,31 +19,104 @@ Then open your AI coding tool and tell it:
 Read .hool/prompts/orchestrator.md and begin Phase 1: Brainstorm
 ```
 
-## Commands
+## Install
 
 ```bash
-npx hool-cli init              # Scaffold HOOL in current directory
-npx hool-cli status            # Show current phase and task summary
-npx hool-cli reset             # Reset operations and memory (keeps phase docs)
+npm install -g hool-cli
 ```
 
-Or install globally:
+Update to the latest version:
+
+```bash
+npm update -g hool-cli
+```
+
+## Commands
+
+### `hool init`
+
+Scaffold HOOL in the current directory. Creates phase directories, operations files, agent memory, prompts, and platform instructions.
 
 ```bash
-npm install -g hool-cli
 hool init
+hool init --dir ./myapp --platform claude-code --type web-app --mode full-hool
+```
+
+**Options:**
+- `-d, --dir <path>` — Project directory (default: `.`)
+- `-p, --platform <platform>` — `claude-code`, `cursor`, or `generic`
+- `-t, --type <type>` — `web-app`, `browser-game`, `mobile-android`, `animation`, `cli-tool`, `api-only`, `desktop`, `other`
+- `-m, --mode <mode>` — `interactive` (default) or `full-hool`
+
+### `hool onboard`
+
+Onboard an existing codebase into HOOL. Scaffolds the full HOOL structure around your existing code (no files are touched), then sets up onboarding tasks for agents to reverse-engineer project docs.
+
+```bash
+hool onboard
+hool onboard --dir ./myapp --platform claude-code --type web-app
+```
+
+If `.hool/` already exists, prompts for **re-onboard** — a lightweight path that only resets `current-phase.md` and prepends onboarding tasks to the task board, preserving all memory and phase docs.
+
+### `hool status`
+
+Show current phase, task summary, bug count, and human review status.
+
+```bash
 hool status
 ```
 
-Update to the latest version:
+### `hool reset`
+
+Reset operations files and agent memory. Phase documents are preserved.
 
 ```bash
-npm update -g hool-cli
+hool reset
 ```
 
-## Documentation
+### `hool mode [new-mode]`
+
+Show or switch execution mode.
+
+```bash
+hool mode              # show current mode
+hool mode full-hool    # switch to full-hool
+hool mode interactive  # switch to interactive
+```
+
+## Modes
+
+- **Interactive** (default) — You review and approve spec, design, and architecture (Phases 0-4) before agents build autonomously.
+- **Full-HOOL** — You brainstorm the idea, then agents handle everything. Decisions are logged for post-build review.
+
+## Eight Agents
+
+| Agent | Role |
+|-------|------|
+| **Product Lead** | Vision, contracts, doc consistency, phase gating, agent dispatch |
+| **FE Tech Lead** | FE scaffold, low-level design, code review |
+| **BE Tech Lead** | BE scaffold, low-level design, code review |
+| **FE Dev** | Frontend implementation |
+| **BE Dev** | Backend implementation |
+| **QA** | Test plan, test execution, bug reporting |
+| **Forensic** | Root cause analysis, bug triage, fix routing |
+| **Governor** | Behavioral auditor, rule enforcement, corrective feedback |
+
+The Product Lead is the only user-facing agent. All others are dispatched internally. The Governor runs continuously to audit agent behavior.
+
+## Supported Platforms
+
+| Platform | Instruction file | MCP support |
+|----------|-----------------|-------------|
+| Claude Code | `CLAUDE.md` | Full (auto-installs) |
+| Cursor | `.cursor/rules/hool.mdc` | Full (auto-installs) |
+| Generic | `.hool/prompts/` only | Manual setup |
+
+## Links
 
-Full documentation: [github.com/the-wise-agents/hool](https://github.com/the-wise-agents/hool)
+- [GitHub](https://github.com/the-wise-agents/hool)
+- [Full documentation](https://github.com/the-wise-agents/hool#readme)
 
 ## License
 

package/dist/index.js

@@ -30,7 +30,7 @@ const program = new Command();
 program
     .name('hool')
     .description('Agent-Driven SDLC — scaffold and configure HOOL for any project')
-    .version('0.2.0');
+    .version('0.2.1');
 // ── hool init ──────────────────────────────────────────────
 program
     .command('init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hool-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Agent-Driven SDLC — scaffold and configure HOOL for any project",
   "bin": {
     "hool": "./dist/index.js"
@@ -12,7 +12,8 @@
   },
   "files": [
     "dist",
-    "prompts"
+    "prompts",
+    "README.md"
   ],
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",

package/prompts/orchestrator.md

@@ -9,10 +9,11 @@ You own the product vision, manage the full SDLC lifecycle, define contracts, en
 1. Read your Always Read files (state + memory)
 2. Determine where you are: read `operations/current-phase.md` and `operations/task-board.md`
 3. **If there are pending tasks**: Tell the user what's pending and ask if you should proceed — do NOT silently wait for instructions. You are the driver, not a passenger. Example: "I have 5 pending onboarding tasks. Should I proceed, or do you have something else in mind?"
-4. If mid-phase with pending tasks: continue the dispatch loop (see Autonomous Execution Loop)
-5. If between phases: check gate conditions, advance if met
-6. If standby (onboarded project or post-phase-12): wait for user to tell you what to do, then route to the right phase/agent
-7. If user gives a new request at any point: assess it, update spec/task-board as needed, route accordingly
+4. **If current phase is "onboarding"**: This is your highest priority. The project was onboarded from an existing codebase and needs reverse-engineered documentation before any development can happen. Complete ALL onboarding tasks on the task board immediately — reverse-engineer project profile, spec, architecture, BE LLD, seed agent memories, surface issues and inconsistencies. Do not wait for explicit instruction. Do not treat user conversation as a reason to delay onboarding. If the user asks a question, answer it, then resume onboarding.
+5. If mid-phase with pending tasks: continue the dispatch loop (see Autonomous Execution Loop)
+6. If between phases: check gate conditions, advance if met
+7. If standby (onboarded project or post-phase-12): wait for user to tell you what to do, then route to the right phase/agent
+8. If user gives a new request at any point: assess it, update spec/task-board as needed, route accordingly
 
 ## Execution Modes