devflow-kit 0.9.0 → 1.1.0

package/README.md

@@ -1,372 +1,248 @@
-# DevFlow - Agentic Development Toolkit
+# DevFlow
 
-A comprehensive collection of Claude Code commands and configurations designed to enhance developer workflows when working with AI coding assistants.
+[![npm version](https://img.shields.io/npm/v/devflow-kit)](https://www.npmjs.com/package/devflow-kit)
+[![CI](https://github.com/dean0x/devflow/actions/workflows/ci.yml/badge.svg)](https://github.com/dean0x/devflow/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js 18+](https://img.shields.io/badge/node-18%2B-brightgreen.svg)](https://nodejs.org/)
+[![Website](https://img.shields.io/badge/Website-dean0x.github.io%2Fx%2Fdevflow-blue)](https://dean0x.github.io/x/devflow/)
 
-## Installation
+**Development workflows for Claude Code — spec, implement, code-review, debug in one command.**
 
-```bash
-# Run with npx (recommended - no global install needed)
-npx devflow-kit init
-```
+<p align="center">
+  <img src=".github/assets/devflow-init.gif" alt="DevFlow init demo" width="720" />
+</p>
 
-### Installation Scopes
+## Why DevFlow
 
-DevFlow supports two installation scopes:
+Claude Code is powerful but workflows are manual — you write ad-hoc prompts, lose context on every restart, and repeat the same review steps across projects.
 
-**User Scope (Default)** - Install for all projects
-```bash
-npx devflow-kit init --scope user
-# Or interactively: npx devflow-kit init (prompts for scope)
-```
-- Installs to `~/.claude/` and `~/.devflow/`
-- Available across all projects
-- Recommended for personal use
+DevFlow adds structured commands that handle the full lifecycle: specify features, implement with exploration and planning, review with multiple perspectives, and debug with parallel investigation. Session memory persists automatically across restarts and compaction.
+
+## Features
+
+- **Structured code review** — multiple specialized reviewers (security, architecture, performance, and more)
+- **Full-lifecycle implementation** — spec, explore, plan, code, validate, refine in one command
+- **Automatic session memory** — survives restarts, `/clear`, and context compaction
+- **Parallel debugging** — competing hypotheses investigated simultaneously
+- **26 quality skills** — 12 auto-activating, plus specialized review and agent skills
+
+## Quick Start
 
-**Local Scope** - Install for current project only
 ```bash
-npx devflow-kit init --scope local
+npx devflow-kit init
 ```
-- Installs to `<git-root>/.claude/` and `<git-root>/.devflow/`
-- Only available in the current project
-- Recommended for team projects where DevFlow should be project-specific
-- Requires a git repository (run `git init` first)
-- Add `.claude/` and `.devflow/` to `.gitignore` (done automatically)
-
-That's it! DevFlow is now installed and ready to use in Claude Code.
-
-## What's Included
-
-### 🎯 Skills (Auto-Activate)
-
-**Skills are model-invoked** - Claude automatically activates them based on context, enforcing quality without manual invocation.
-
-| Skill | Purpose | Auto-Triggers When |
-|-------|---------|---------------------|
-| `pattern-check` | Architectural pattern validation (Result types, DI, immutability) | Code changes are made, new functions added |
-| `test-design` | Test quality enforcement (setup complexity, mocking, behavior vs implementation) | Tests are written or modified |
-| `code-smell` | Anti-pattern detection (fake solutions, unlabeled workarounds, magic values) | Features are implemented, code is reviewed |
-| `research` | Pre-implementation planning, documentation study, integration strategy | Unfamiliar features requested, architectural decisions needed |
-| `debug` | Systematic debugging with hypothesis testing and root cause analysis | Errors occur, tests fail, performance issues detected |
-| `input-validation` | Boundary validation enforcement (parse-don't-validate, SQL injection prevention) | API endpoints created, external data handled |
-| `error-handling` | Result type consistency and exception boundary enforcement | Error handling code written, functions that can fail |
-
-**How Skills Work:**
-- **Proactive enforcement** - Catch issues during implementation, not after
-- **No manual invocation** - Model decides when skills are relevant
-- **Quality gates** - Block anti-patterns automatically
-- **Context-aware** - Activate based on what you're doing
-
-**IMPORTANT**: Skills are **automatically activated** by Claude based on context. They cannot be manually invoked like slash commands.
-
-**Dual-Mode Pattern**: The `debug` skill also exists as a slash command (`/debug`) for manual control:
-- **Skill mode** (auto): Activates when Claude detects errors or failures
-- **Command mode** (manual): Use `/debug` when you want explicit control over the debugging workflow
-
-This gives you the best of both worlds: automatic assistance when needed, manual control when preferred.
-
-### 📊 Slash Commands (User-Invoked)
-
-| Command | Purpose | When to Use |
-|---------|---------|-------------|
-| `/catch-up` | Smart summaries for starting new sessions with status validation | Starting a session |
-| `/brainstorm` | Explore design decisions and architectural approaches | Before implementation, evaluating options |
-| `/design` | Create detailed implementation plan with integration points | After brainstorming, ready for detailed design |
-| `/plan` | Triage issues - implement now, defer to GitHub issue, or skip | After code-review or discussion, deciding what to tackle |
-| `/breakdown` | Quickly break down discussion into actionable tasks | After planning discussion, quick task capture |
-| `/get-issue` | Fetch GitHub issue details and create working branch | Starting work on a GitHub issue |
-| `/implement` | Streamlined todo implementation, only stopping for design decisions | After planning, ready to implement todos |
-| `/debug` | Systematic debugging workflow with hypothesis testing | When errors occur, tests fail, or investigating issues |
-| `/code-review` | Comprehensive code review using specialized sub-agents | Before committing or creating PR |
-| `/commit` | Intelligent atomic commit creation with safety checks | When ready to commit |
-| `/pull-request` | Create PR with comprehensive analysis and smart description | After commits, ready to create PR |
-| `/resolve-comments` | Systematically address PR review feedback | After PR feedback, need to resolve comments |
-| `/release` | Automated release workflow with version management and publishing | Creating a new release |
-| `/devlog` | Development log for comprehensive session documentation | Ending a session |
-
-### 🤖 Sub-Agents
-
-| Sub-Agent | Specialty | Purpose |
-|-----------|-----------|---------|
-| `audit-security` | Security Analysis | Expert vulnerability detection and security code review |
-| `audit-performance` | Performance | Optimization and bottleneck detection |
-| `audit-architecture` | Architecture | Design pattern analysis and code structure review |
-| `audit-tests` | Testing | Test quality, coverage, and effectiveness analysis (surgical execution) |
-| `audit-complexity` | Complexity | Code complexity and maintainability assessment |
-| `audit-dependencies` | Dependencies | Dependency management and security analysis |
-| `audit-database` | Database | Database design and optimization review |
-| `audit-documentation` | Documentation | Docs-code alignment, API accuracy, comment quality |
-| `audit-typescript` | TypeScript | Type safety enforcement and TypeScript code quality |
-| `brainstorm` | Design Decisions | Explore architectural approaches and evaluate trade-offs |
-| `design` | Implementation Planning | Detailed implementation design with integration points and edge cases |
-| `catch-up` | Context Restoration | Project status and context restoration with validation |
-| `commit` | Git Operations | Intelligent commit creation with safety checks |
-| `get-issue` | GitHub Issues | Fetch issue details and create working branches |
-| `pull-request` | PR Creation | Analyze commits/changes and generate comprehensive PR descriptions |
-| `release` | Release Automation | Project-agnostic release workflow with version management |
-| `debug` | Debugging | Systematic debugging with hypothesis testing and issue tracking |
-
-**How Sub-Agents Work:**
-- Specialized AI assistants with deep expertise in specific domains
-- Separate context windows for focused analysis
-- Can be invoked explicitly or automatically by orchestrator commands
-- Restricted tool access appropriate to their domain
-
-**Invoking Sub-Agents:**
-```bash
-# Explicit invocation
-"Use the audit-security sub-agent to analyze this authentication code"
 
-# Automatic delegation (Claude Code decides which sub-agent to use)
-"Review this code for security issues"
+Then in Claude Code:
+
+```
+/code-review
 ```
 
-### 📊 Smart Statusline
+## Commands
 
-Real-time project context display showing:
-- Current model and session duration
-- Git branch and uncommitted changes indicator
-- Session cost tracking
-- Project context
-- Zero configuration - works immediately after installation
+| Plugin | Command | Description |
+|--------|---------|-------------|
+| `devflow-specify` | `/specify` | Interactive feature specification with clarification gates |
+| `devflow-implement` | `/implement` | Complete task lifecycle — explore, plan, code, validate, refine |
+| `devflow-code-review` | `/code-review` | Multi-perspective code review with severity classification |
+| `devflow-resolve` | `/resolve` | Process review issues — fix or defer to tech debt |
+| `devflow-debug` | `/debug` | Parallel hypothesis debugging |
+| `devflow-self-review` | `/self-review` | Self-review workflow (Simplifier + Scrutinizer) |
+| `devflow-ambient` | `/ambient` | Ambient mode — auto-loads relevant skills based on each prompt |
+| `devflow-core-skills` | (auto) | Auto-activating quality enforcement skills |
 
-### 🔒 Security & Token Optimization
+## Command Details
 
-DevFlow automatically creates a comprehensive `.claudeignore` file at your git repository root to:
+### /specify
 
-**Protect Sensitive Data:**
-- Environment files (`.env`, `.env.*`, `.envrc`)
-- Credentials & keys (`*.key`, `*.pem`, SSH keys)
-- Cloud configs (`.aws/`, `.gcp/`, `.azure/`)
-- Package tokens (`.npmrc`, `.pypirc`)
-- Database files (`*.sql`, `*.db`)
+Guides you through defining a feature with three mandatory gates:
 
-**Optimize Token Usage:**
-- Dependencies (`node_modules/`, `vendor/`, `venv/`)
-- Build artifacts (`dist/`, `build/`, `.next/`)
-- IDE files (`.vscode/`, `.idea/`)
-- Lock files (`package-lock.json`, `yarn.lock`)
-- Media and binaries
+1. **Understanding Gate** - Confirm the feature idea is understood
+2. **Scope Gate** - Validate priorities and boundaries
+3. **Acceptance Gate** - Confirm success criteria
 
-Covers patterns for all major languages and operating systems.
+Creates a GitHub issue with well-defined requirements ready for `/implement`.
 
-## Documentation Structure
+### /implement
+
+Executes a single task through the complete development lifecycle:
+
+1. **Exploration** — analyze codebase for relevant patterns and dependencies
+2. **Planning** — design the implementation approach
+3. **Implementation** — write code on a feature branch
+4. **Validation** — run build, typecheck, lint, and tests
+5. **Refinement** — simplify and review for quality
+6. **Alignment Check** — verify implementation matches the original request
+
+Creates a PR when complete.
+
+### /code-review
+
+Multi-perspective code review with specialized reviewers:
+
+- **Core**: Security, Architecture, Performance, Quality
+- **Conditional** (activated when relevant): TypeScript, React, Accessibility, Database, Dependencies, Documentation
+- Findings classified as must-fix, should-fix, or nit with severity and confidence levels
+
+Provides actionable feedback with specific file locations and suggested fixes.
+
+### /debug
+
+Investigates bugs using competing hypotheses:
+
+1. **Hypothesis Generation** — identify 3-5 plausible explanations
+2. **Parallel Investigation** — each hypothesis investigated independently
+3. **Evidence Evaluation** — hypotheses ranked by supporting evidence
+4. **Root Cause** — the best-supported explanation with fix recommendation
+
+Produces a root cause analysis report with confidence level.
+
+### /resolve
+
+Processes issues from `/code-review`:
+
+- Validates each issue is real (not false positive)
+- Assesses risk of fixing (low vs high)
+- Fixes low-risk issues immediately
+- Defers high-risk issues to tech debt backlog
 
-DevFlow agents automatically create and maintain project documentation in the `.docs/` directory with a consistent, predictable structure.
+## Auto-Activating Skills
 
-### Directory Layout
+The `devflow-core-skills` plugin provides quality enforcement skills that activate automatically:
 
+| Skill | Triggers When |
+|-------|---------------|
+| `core-patterns` | Implementing business logic, error handling |
+| `docs-framework` | Creating documentation artifacts in .docs/ |
+| `git-safety` | Rebasing, force-pushing, merge conflicts |
+| `git-workflow` | Staging files, creating commits, PRs |
+| `github-patterns` | GitHub API operations, PR comments, releases |
+| `test-driven-development` | Implementing new features (RED-GREEN-REFACTOR) |
+| `test-patterns` | Writing or modifying tests |
+| `input-validation` | Creating API endpoints |
+| `typescript` | Working in TypeScript codebases |
+| `react` | Working with React components |
+| `accessibility` | Creating UI components, forms, interactive elements |
+| `frontend-design` | Working with CSS, styling, visual design |
+
+## Requirements
+
+- [Claude Code](https://claude.ai/download) (latest)
+- Node.js 18+
+
+## Installation
+
+### Install All Plugins
+
+```bash
+npx devflow-kit init
 ```
-.docs/
-├── audits/{branch-slug}/       # Code review reports per branch
-│   ├── {type}-report-{timestamp}.md
-│   └── review-summary-{timestamp}.md
-├── brainstorm/                 # Design explorations
-│   └── {topic-slug}-{timestamp}.md
-├── design/                     # Implementation plans
-│   └── {topic-slug}-{timestamp}.md
-├── debug/                      # Debug sessions
-│   ├── debug-{timestamp}.md
-│   └── KNOWLEDGE_BASE.md
-├── releases/                   # Release notes
-│   └── RELEASE_NOTES_v{version}.md
-├── status/                     # Development logs
-│   ├── {timestamp}.md
-│   ├── compact/{timestamp}.md
-│   └── INDEX.md
-└── CATCH_UP.md                 # Latest summary
+
+### Install Specific Plugins
+
+```bash
+# List available plugins
+npx devflow-kit list
+
+# Install specific plugin(s)
+npx devflow-kit init --plugin=implement
+npx devflow-kit init --plugin=implement,code-review
 ```
 
-### Naming Conventions
+### Scopes
 
-**Timestamps**: `YYYY-MM-DD_HHMM` (sortable, chronological)
-- Example: `2025-11-14_2030`
+- `--scope user` (default) - Install for all projects (`~/.claude/`)
+- `--scope local` - Install for current project only (`.claude/`)
 
-**Branch slugs**: Sanitized branch names (slashes replaced with dashes)
-- `feature/auth` → `feature-auth`
+## Working Memory
 
-**Topic slugs**: Lowercase, alphanumeric with dashes
-- `"JWT Authentication"` → `jwt-authentication`
+DevFlow automatically preserves session context across restarts, `/clear`, and context compaction — zero ceremony required.
 
-### What Gets Created
+Three shell hooks run behind the scenes:
 
-- **`/catch-up`** → `.docs/CATCH_UP.md` (overwritten each run)
-- **`/devlog`** → `.docs/status/{timestamp}.md` + compact version + INDEX
-- **`/debug`** → `.docs/debug/debug-{timestamp}.md` + KNOWLEDGE_BASE
-- **`/brainstorm`** → `.docs/brainstorm/{topic}-{timestamp}.md`
-- **`/design`** → `.docs/design/{topic}-{timestamp}.md`
-- **`/code-review`** → `.docs/audits/{branch}/` (9 audit reports + summary)
-- **`/release`** → `.docs/releases/RELEASE_NOTES_v{version}.md`
+| Hook | When | What |
+|------|------|------|
+| **Stop** | After each response | Updates `.memory/WORKING-MEMORY.md` with current focus, decisions, and progress. Throttled — skips if updated <2 min ago. |
+| **SessionStart** | On startup, `/clear`, resume, compaction | Injects previous working memory + fresh git state as system context. Warns if memory is >1h stale. |
+| **PreCompact** | Before context compaction | Backs up git state to JSON. Bootstraps a minimal working memory from git if none exists yet. |
 
-### Version Control
+Working memory is **per-project** — scoped to each repo's `.memory/` directory. Multiple sessions across different repos don't interfere.
 
-**Recommended `.gitignore`**:
-```gitignore
-# Exclude ephemeral catch-up summaries
-.docs/CATCH_UP.md
+## Documentation Structure
 
-# Optional: Exclude debug sessions (team preference)
-.docs/debug/
+DevFlow creates project documentation in `.docs/` and working memory in `.memory/`:
 
-# Keep everything else for project history
 ```
+.docs/
+├── reviews/{branch}/         # Review reports per branch
+└── design/                   # Implementation plans
 
-The `.docs/` structure provides a searchable history of decisions, designs, and debugging sessions.
-
-## Development Workflow
-
-### Starting a Session
-1. `/catch-up` - Review what was done previously
-2. Check statusline for current model, git state, duration
-3. Review recommended next actions
-
-### During Development
-1. **Skills auto-activate** - `research` skill triggers for unfamiliar features, `pattern-check` validates architecture
-2. **Plan your work** - `/plan` to triage issues, or `/breakdown` for quick task capture
-3. **Implement efficiently** - `/implement` flows through todos automatically
-4. **Code with confidence** - Skills catch anti-patterns and violations during implementation
-5. `/code-review` - Review changes before committing
-6. `/commit` - Create intelligent atomic commits
-
-### Creating Pull Requests
-1. `/code-review` - Comprehensive branch review
-2. `/commit` - Final commits with validation
-3. `/pull-request` - Create PR with smart description
-4. Wait for review feedback
-5. `/resolve-comments` - Address feedback systematically
-6. Repeat steps 4-5 until approved
-
-### Ending a Session
-1. `/devlog` - Document decisions and state
-2. `/code-review` - Review branch before creating PR
-3. `/commit` - Final commits with validation
-4. `/pull-request` - Create PR if ready
-
-### Creating a Release
-1. `/code-review` - Comprehensive branch review
-2. `/release` - Automated release workflow
-   - Detects project type (Node.js, Rust, Python, Go, etc.)
-   - Analyzes commits and suggests version bump
-   - Generates changelog from git history
-   - Builds and tests before publishing
-   - Creates git tags and platform releases
-3. Verify package in registry
-
-### When Things Go Wrong
-1. **Skills auto-activate** - `debug` skill triggers on errors/failures with systematic approach
-2. Check git log and recent commits
-3. Revert changes using git
-4. Document lessons learned in `.docs/debug/`
-
-## CLI Commands
-
-| Command | Purpose | Options |
-|---------|---------|---------|
-| `npx devflow-kit init` | Initialize DevFlow for Claude Code | `--scope <user\|local>` - Installation scope (user: user-wide, local: project-only)<br>`--verbose` - Show detailed installation output<br>`--skip-docs` - Skip creating `.docs/` structure |
-| `npx devflow-kit uninstall` | Remove DevFlow from Claude Code | `--scope <user\|local>` - Uninstall from specific scope only (default: auto-detect all)<br>`--keep-docs` - Keep `.docs/` directory |
-
-**What `npx devflow-kit init` does:**
-
-**User Scope** (default):
-- Installs commands to `~/.claude/commands/devflow/`
-- Installs sub-agents to `~/.claude/agents/devflow/`
-- Installs skills to `~/.claude/skills/`
-- Installs scripts to `~/.devflow/scripts/`
-- Updates `~/.claude/settings.json` (statusline and model)
-- Creates `.claudeignore` at git repository root
-- Creates `.docs/` structure for project documentation
-
-**Local Scope** (`--scope local`):
-- Installs commands to `<git-root>/.claude/commands/devflow/`
-- Installs sub-agents to `<git-root>/.claude/agents/devflow/`
-- Installs skills to `<git-root>/.claude/skills/`
-- Installs scripts to `<git-root>/.devflow/scripts/`
-- Creates `<git-root>/.claude/settings.json` (statusline and model)
-- Creates `.claudeignore` at git repository root
-- Creates `.docs/` structure for project documentation
-- Adds `.claude/` and `.devflow/` to `.gitignore`
-
-**First Run:**
-```bash
-devflow init
-/devlog      # Document your current project state
-/catch-up    # Get oriented with the project
+.memory/
+├── WORKING-MEMORY.md         # Auto-maintained by Stop hook
+├── PROJECT-PATTERNS.md       # Accumulated patterns across sessions
+└── backup.json               # Pre-compact git state snapshot
 ```
 
-## Advanced Usage
+## Workflow Examples
 
-### Custom Audit Rules
+### Implementing a Feature
 ```bash
-# Extend sub-agents for project-specific patterns
-echo "Check for exposed API keys in config files" >> ~/.claude/agents/devflow/audit-security.md
+/specify     # Define the feature with clarification gates
+/implement   # Execute the full lifecycle
 ```
 
-### Team Usage
+### Debugging an Issue
 ```bash
-# Share session documentation with team
-/devlog
-git add .docs/status/
-git commit -m "Session status: completed user auth feature"
+/debug "login fails after session timeout"
+/debug #42   # Investigate from GitHub issue
 ```
 
-### Integration Examples
+### Before Creating a PR
 ```bash
-# Skills auto-activate during development
-"Add JWT authentication"  # research skill triggers for unfamiliar features
-"Fix this error"          # debug skill activates and guides systematic approach
-
-# Manual command invocation for structured workflows
-/brainstorm user authentication  # Explore architectural approaches
-/design JWT token system         # Create detailed implementation plan
-/code-review                     # Review changes before committing
-/commit                          # Create atomic commits
-/release                         # Automated release workflow
+/code-review      # Multi-perspective code review
+/resolve     # Fix low-risk issues, defer high-risk to backlog
 ```
 
-## Philosophy
+### Session Continuity
+
+Session context is saved and restored automatically via Working Memory hooks — no manual steps needed.
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `npx devflow-kit init` | Install all plugins |
+| `npx devflow-kit init --plugin=<names>` | Install specific plugin(s) |
+| `npx devflow-kit list` | List available plugins |
+| `npx devflow-kit ambient --enable` | Enable always-on ambient mode |
+| `npx devflow-kit ambient --disable` | Disable ambient mode |
+| `npx devflow-kit uninstall` | Remove DevFlow |
+
+### Init Options
+
+| Option | Description |
+|--------|-------------|
+| `--plugin <names>` | Comma-separated plugin names (e.g., `implement,code-review`) |
+| `--scope <user\|local>` | Installation scope (default: user) |
+| `--teams` / `--no-teams` | Enable/disable experimental Agent Teams (default: off) |
+| `--verbose` | Show detailed output |
 
-Modern development increasingly involves AI agents that can read, write, and modify code autonomously. DevFlow provides:
+### Uninstall Options
 
-- **Trust but Verify** - Tools to catch AI agent mistakes
-- **Context Preservation** - Memory across long-term projects
-- **Quality Gates** - Automated checks for AI changes
-- **Developer Empowerment** - Enhance human judgment, not replace it
+| Option | Description |
+|--------|-------------|
+| `--scope <user\|local>` | Uninstall scope (default: user) |
+| `--keep-docs` | Preserve .docs/ directory |
 
 ## Building from Source
 
 ```bash
-# Clone and build
 git clone https://github.com/dean0x/devflow.git
 cd devflow
 npm install
 npm run build
-
-# Test locally
 node dist/cli.js init
-
-# Watch mode for development
-npm run dev
-```
-
-**Project Structure:**
 ```
-src/
-├── cli/                   # CLI source code (TypeScript)
-│   ├── commands/           # init.ts, uninstall.ts
-│   └── cli.ts             # CLI entry point
-└── claude/                # Claude Code configuration
-    ├── agents/devflow/     # Sub-agent definitions (.md)
-    ├── commands/devflow/   # Slash command definitions (.md)
-    ├── skills/devflow/     # Skill source (installed flat to ~/.claude/skills/)
-    ├── scripts/            # statusline.sh
-    └── settings.json       # Claude Code settings
-```
-
-## Support
-
-- Check installed command documentation
-- Review `.docs/status/` for recent sessions
-- Skills auto-activate for systematic troubleshooting
-- Report issues at https://github.com/dean0x/devflow/issues
 
 ## License
 

package/dist/cli.js

@@ -5,6 +5,9 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { initCommand } from './commands/init.js';
 import { uninstallCommand } from './commands/uninstall.js';
+import { listCommand } from './commands/list.js';
+import { ambientCommand } from './commands/ambient.js';
+import { memoryCommand } from './commands/memory.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read version from package.json
@@ -15,10 +18,13 @@ program
     .description('Agentic Development Toolkit for Claude Code\n\nEnhance your AI-assisted development with intelligent commands and workflows.')
     .version(packageJson.version, '-v, --version', 'Display version number')
     .helpOption('-h, --help', 'Display help information')
-    .addHelpText('after', '\nExamples:\n  $ devflow init              Install DevFlow for Claude Code\n  $ devflow init --verbose    Install with detailed output\n  $ devflow init --skip-docs  Install without creating .docs/ structure\n  $ devflow uninstall         Remove DevFlow from Claude Code\n  $ devflow --version         Show version\n  $ devflow --help            Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
+    .addHelpText('after', '\nExamples:\n  $ devflow init                       Install all DevFlow plugins\n  $ devflow init --plugin=implement    Install specific plugin\n  $ devflow init --plugin=implement,review  Install multiple plugins\n  $ devflow list                       List available plugins\n  $ devflow ambient --enable           Enable always-on ambient mode\n  $ devflow memory --status            Check working memory state\n  $ devflow uninstall                  Remove DevFlow from Claude Code\n  $ devflow --version                  Show version\n  $ devflow --help                     Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
 // Register commands
 program.addCommand(initCommand);
 program.addCommand(uninstallCommand);
+program.addCommand(listCommand);
+program.addCommand(ambientCommand);
+program.addCommand(memoryCommand);
 // Handle no command
 program.action(() => {
     program.help();

package/dist/commands/ambient.d.ts

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+/**
+ * Add the ambient UserPromptSubmit hook to settings JSON.
+ * Idempotent — returns unchanged JSON if hook already exists.
+ */
+export declare function addAmbientHook(settingsJson: string, devflowDir: string): string;
+/**
+ * Remove the ambient UserPromptSubmit hook from settings JSON.
+ * Idempotent — returns unchanged JSON if hook not present.
+ * Preserves other UserPromptSubmit hooks. Cleans empty arrays/objects.
+ */
+export declare function removeAmbientHook(settingsJson: string): string;
+/**
+ * Check if the ambient hook is registered in settings JSON.
+ */
+export declare function hasAmbientHook(settingsJson: string): boolean;
+export declare const ambientCommand: Command;
+//# sourceMappingURL=ambient.d.ts.map