devflow-kit 1.8.2 → 2.0.0

package/README.md

@@ -1,307 +1,227 @@
-# DevFlow
+# Devflow
 
 [![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/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/dean0x/devflow/blob/main/LICENSE)
+[![Node.js 22+](https://img.shields.io/badge/node-22%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/)
 
-**Development workflows for Claude Code — spec, implement, code-review, debug in one command.**
+**A meta-harness for Claude Code.** Claude Code gives you one brilliant engineer. Devflow installs the engineering organization around it: an orchestrator that delegates, a roster of specialized agents, a review culture, institutional memory, and a delivery pipeline. Built for developers turning agentic development into a team that ships.
 
-<p align="center">
-  <img src=".github/assets/devflow-init.gif" alt="DevFlow init demo" width="720" />
-</p>
+## The problem with AI-assisted development
 
-## Why DevFlow
+Claude Code is powerful. But a single agent is not a team. Every session starts from scratch, context evaporates between conversations, reviews are single-pass and shallow, and quality depends on what you remember to ask for. What's missing is exactly what makes an engineering team ship: memory, standards, review culture, and a delivery process.
 
-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.
+Devflow fixes this. Install once, forget about it.
 
-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.
+## See it work
 
-## Features
+One feature, four commands, bird's-eye view — each command is an agent pipeline, not a prompt:
 
-- **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
-- **Version notifications** — HUD shows `✦ Devflow vX.Y.Z · update: npx devflow-kit init` when a newer version is available
-- **35 quality skills** — 9 auto-activating core, 8 optional language/ecosystem, plus specialized review, agent, and orchestration skills
+```text
+you: /plan add rate limiting to the /api/upload endpoint
 
-## Quick Start
-
-```bash
-npx devflow-kit init
-```
-
-Then in Claude Code:
+  Skim · Explore         orient in the codebase — relevant modules, existing middleware patterns
+  Design                 gap analysis: completeness, security, performance
+  Plan · Synthesize      PR-ready plan document → .devflow/docs/design/
+  Git                    traceable issue #42 opened
 
-```
-/code-review
-```
-
-## Commands
+you: /implement (hand it the plan)
 
-| 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` | (hook) | Ambient mode — intent classification with agent orchestration |
-| `devflow-core-skills` | (auto) | Auto-activating quality enforcement skills |
+  Git                    branch feat/42-rate-limit-upload
+  Code                   implements the plan — your learned decisions, pitfalls, and feature knowledge preloaded
+  Validate               build ✓ typecheck ✓ lint ✓ tests ✓
+  Simplify · Scrutinize  cleanup pass, then 9-pillar quality gate
+  Evaluate               implementation matches the original request ✓
+  Test                   5/5 QA scenarios pass → PR opened
 
-## Command Details
+you: /code-review
 
-### /specify
+  Review ×12             security, architecture, performance, complexity, … (up to 20, in parallel)
+  Synthesize             18 findings ranked by severity + confidence → review-summary.md
 
-Guides you through defining a feature with three mandatory gates:
+you: /resolve
 
-1. **Understanding Gate** - Confirm the feature idea is understood
-2. **Scope Gate** - Validate priorities and boundaries
-3. **Acceptance Gate** - Confirm success criteria
+  Triage                 every finding validated against a blast-radius matrix — 11 fix-now, 3 by design, 4 false positives
+  Code ×11               each real issue fixed
+  Validate · Git         verification gate ✓ → pushed to the PR
+```
 
-Creates a GitHub issue with well-defined requirements ready for `/implement`.
+This is the **orchestrated flow** — you stay in the loop between every step. With ambient mode on you don't even need the commands: describe the task and the orchestrator routes it through the same pipelines.
 
-### /implement
+## What you get
 
-Executes a single task through the complete development lifecycle:
+**Ambient orchestration.** Your main session becomes the tech lead: a charter injected at session start turns it into a pure orchestrator that delegates work to specialized agents and keeps only judgment mainline. Plan-mode handoffs auto-run `/implement`. Init and forget.
 
-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
+**A staffed agent roster.** 16 specialized agents with explicit model assignments — Opus for analysis, Sonnet for execution, Haiku for I/O. Reassign any agent's model with `devflow agents`, including GPT models through external model routing (`devflow proxy`).
 
-Creates a PR when complete.
+**Up to 20 parallel Review agents.** Security, architecture, performance, complexity, consistency, regression, testing, and more. Each produces findings with severity, confidence scoring, and concrete fixes. Conditional Review agents activate when relevant (TypeScript for `.ts` files, database for schema changes, compliance when regulated surface detected in the diff). Every finding gets validated and resolved automatically.
 
-### /code-review
+**Memory that persists.** Session context survives restarts, `/clear`, and context compaction. Your agent picks up exactly where it left off.
 
-Multi-perspective code review with specialized reviewers:
+**Self learning.** A background agent detects architectural decisions and known pitfalls from your session dialogs and writes them to `.devflow/learning/decisions.md` and `.devflow/learning/pitfalls.md` — informing every future review and implementation session without any manual bookkeeping.
 
-- **Core**: Security, Architecture, Performance, Quality
-- **Conditional** (activated when relevant): TypeScript, React, Accessibility, Go, Python, Java, Rust, Database, Dependencies, Documentation
-- Findings classified as must-fix, should-fix, or nit with severity and confidence levels
+**Feature knowledge bases.** Curated `KNOWLEDGE.md` files per feature area — patterns, conventions, and gotchas — git-tracked and shared with your team. Planning, implementation, and review workflows load them automatically and refresh them after changes.
 
-Provides actionable feedback with specific file locations and suggested fixes.
+**Always-on rules.** 13 ultra-condensed engineering principles (~10 lines each) load on every prompt — security, quality, and language-specific guidance (TypeScript, React, Go, Python, Java, Rust), plus a compliance rule when compliance is enabled. Rules install from your selected plugins only, so a Go project won't get React rules. Override any rule via `~/.devflow/rules/{name}.md` or `devflow rules shadow <name>`.
 
-### /debug
+**41 skills** (40 universal + 1 feature-owned compliance skill, installed when compliance is enabled). Most are grounded in expert material — backed by peer-reviewed papers, canonical books, and industry standards: security (OWASP, Shostack), architecture (Parnas, Evans, Fowler), performance (Brendan Gregg), testing (Beck, Meszaros), design (Wlaschin, Hickey), compliance (GDPR, HIPAA, PCI DSS, SOC 2, ISO 27001, SOX, NIST SSDF, OWASP ASVS), 200+ sources total.
 
-Investigates bugs using competing hypotheses:
+**Skill shadowing.** Override any built-in skill with your own version. Drop a file into `~/.devflow/skills/{name}/` and the installer uses yours instead of the default — same activation, your rules.
 
-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
+**Compliance built in.** Six regulatory frameworks — GDPR, HIPAA, PCI DSS, SOC 2, ISO 27001, SOX — composed into a review skill and an always-on rule for exactly the frameworks you select. Compliance reviews activate automatically when a diff touches regulated surface. `devflow compliance --enable`.
 
-Produces a root cause analysis report with confidence level.
+**Full lifecycle.** Beyond the core flow: `/explore` maps a codebase into knowledge bases, `/research` runs multi-type research with trust-aware synthesis, `/debug` investigates with competing hypotheses in parallel, `/bug-analysis` hunts bugs before review, `/self-review` runs Simplify + Scrutinize quality passes, and `/release` ships with learned configuration.
 
-### /resolve
+**Everything is composable.** 21 plugins (12 core + 9 optional). Install only what you need.
 
-Processes issues from `/code-review`:
+**HUD.** A persistent status line updates on every prompt — project, branch, diff stats, context usage, model, cost with weekly/monthly totals, quota reset timers, and configuration counts at a glance.
 
-- 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 · main · +2 -1 · v2.0.0+3
+Context ████░░░░ 42% · 5h ████░░░░ 45% (2h 15m) · 7d ████████ 70% (3d 12h)
+Opus 4.6 (1M) · 3 MCPs 2 rules · $1.42 · $18.50/wk · $62.30/mo
+```
 
-## Auto-Activating Skills
+**Security.** Deny lists block dangerous tool patterns out of the box — configurable during init and toggleable any time with `devflow security` (`--enable`/`--disable`/`--status`).
 
-The `devflow-core-skills` plugin provides quality enforcement skills that activate automatically:
+## Graph workflows
 
-| 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 |
-| `search-first` | Adding utilities, helpers, or infrastructure code |
+Prompt engineering became context engineering; the current frontier is **graph engineering** — designing agentic work as an explicit graph of nodes, dependencies, and gates rather than one long conversation. Devflow ships it as ready-made recipes.
 
-## Language & Ecosystem Plugins
+When to use which: the orchestrated flow is for a **feature**; graph workflows are for a **system**. Start from a spec, break it into a dependency graph of tickets, then deliver it wave by wave — plan a wave, build a wave, repeat until the spec is shipped:
 
-Optional plugins for language-specific patterns. Install only what you need:
+```text
+you: /dynamic-tickets specs/billing-v2.md
 
-| Plugin | Skill | Triggers When |
-|--------|-------|---------------|
-| `devflow-typescript` | `typescript` | Working in TypeScript codebases |
-| `devflow-react` | `react` | Working with React components |
-| `devflow-accessibility` | `accessibility` | Creating UI components, forms |
-| `devflow-frontend-design` | `frontend-design` | Working with CSS, styling |
-| `devflow-go` | `go` | Working in Go codebases |
-| `devflow-python` | `python` | Working in Python codebases |
-| `devflow-java` | `java` | Working in Java codebases |
-| `devflow-rust` | `rust` | Working in Rust codebases |
+  Ticket factory         spec → 14 dependency-graphed tickets across 4 waves
+                         each ticket adversarially reviewed · tracking issue opened
 
-```bash
-# Install specific language plugins
-npx devflow-kit init --plugin=typescript,react
-npx devflow-kit init --plugin=go
-```
+you: /dynamic-plan (wave 1)
 
-## Requirements
+  Plan ×4                every wave-1 ticket plan-challenged in parallel: acceptance criteria + test plans
+  Preference profile     known decisions auto-resolved from ~/.devflow/preference-profile.md
+  Decision gate          DECISIONS-NEEDED.md — 2 calls only you can make
 
-- [Claude Code](https://claude.ai/download) (latest)
-- Node.js 18+
+you: (answer 2 decisions, walk away) /dynamic-build (wave 1)
 
-## Installation
+  Wave 1                 4 tickets   implement → review → verify, dependency-ordered
+  Git                    wave report posted to the tracking issue
 
-### Install All Plugins
+you: /dynamic-plan (wave 2) → /dynamic-build (wave 2) → …
 
-```bash
-npx devflow-kit init
+  — four waves later: 14/14 tickets landed, spec shipped —
 ```
 
-The interactive wizard walks through plugin selection, feature configuration (ambient mode, working memory, HUD, safe-delete), and security settings. In user scope, it discovers all projects Claude has worked on and batch-installs `.claudeignore` across them.
+Graph runs trade tokens for autonomy: you make your calls at each wave's decision gate, then the wave builds — a single build run can go 20+ hours unattended. In practice you'll live in the orchestrated flow day to day and reach for graph workflows when you're delivering a whole system. Both share the same agents, quality gates, memory, and learned decisions.
 
-### Install Specific Plugins
+## Quick Start
 
 ```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
+npx devflow-kit init
 ```
 
-### Scopes
+That's it. The interactive wizard offers Recommended defaults or an Advanced flow — plugin selection, feature configuration, compliance frameworks, and security settings. Ambient mode, working memory, and learning are on by default. Non-interactive: `npx devflow-kit init --recommended`.
 
-- `--scope user` (default) - Install for all projects (`~/.claude/`)
-- `--scope local` - Install for current project only (`.claude/`)
+## Privacy & Sharing
 
-## Working Memory
+Everything Devflow generates lives under `.devflow/` — working memory, decisions and pitfalls, feature knowledge bases, and transient locks. That directory is **gitignored wholesale by default**, so this per-developer runtime state stays on your machine and never lands in a commit. Devflow adds the `.devflow/` line to your project's root `.gitignore` automatically on first use.
 
-DevFlow automatically preserves session context across restarts, `/clear`, and context compaction — zero ceremony required.
+Sharing is opt-in. To share **everything** with your team, remove the `.devflow/` line from `.gitignore`. To share only curated knowledge (and keep memory, queues, and locks local), replace the `.devflow/` line with a pattern that ignores everything except the files you want tracked:
 
-Three shell hooks run behind the scenes:
+```gitignore
+# Ignore all Devflow runtime data…
+.devflow/**
+# …except the team knowledge you want to share
+!.devflow/learning/
+!.devflow/learning/decisions.md
+!.devflow/learning/pitfalls.md
+!.devflow/features/
+!.devflow/features/index.md
+!.devflow/features/*/
+!.devflow/features/*/KNOWLEDGE.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. |
+(The directory re-includes — `!.devflow/learning/` — are required: git won't descend into an excluded directory to reach a re-included file.)
 
-Working memory is **per-project** — scoped to each repo's `.memory/` directory. Multiple sessions across different repos don't interfere.
+## Commands
 
-## Documentation Structure
+| Command | What it does |
+|---------|-------------|
+| `/explore` | Codebase exploration with optional knowledge base creation |
+| `/research` | Multi-type research with trust-aware synthesis |
+| `/plan` | Full design pipeline: explore → gap analysis → design → PR-ready plan document |
+| `/implement` | Execute plan: accepts plan documents from `/plan`, issues, or task descriptions → PR |
+| `/self-review` | Simplify + Scrutinize quality pass |
+| `/code-review` | Multi-perspective parallel code review |
+| `/resolve` | Validate and fix all review issues |
+| `/debug` | Competing hypothesis investigation |
+| `/bug-analysis` | Proactive bug finding with static and semantic analysis |
+| `/release` | Adaptive release with learned configuration |
+| `/dynamic-tickets` | Graph workflows: spec or initiative → dependency-graphed, wave-structured ticket slate |
+| `/dynamic-plan` | Graph workflows: parallel plan-challenge, acceptance criteria, decision gate |
+| `/dynamic-build` | Graph workflows: dependency-aware engine — build, review, verify wave by wave |
+| `/dynamic-profile` | Distill session transcripts into a decision-preference profile |
 
-DevFlow creates project documentation in `.docs/` and working memory in `.memory/`:
+See [docs/commands.md](https://github.com/dean0x/devflow/blob/main/docs/commands.md) for detailed usage.
 
-```
-.docs/
-├── reviews/{branch}/         # Review reports per branch
-└── design/                   # Implementation plans
-
-.memory/
-├── WORKING-MEMORY.md         # Auto-maintained by Stop hook
-├── backup.json               # Pre-compact git state snapshot
-└── knowledge/
-    ├── decisions.md           # Architectural decisions (ADR-NNN, append-only)
-    └── pitfalls.md            # Known pitfalls (area-specific gotchas)
-```
+**PR-comment publication** for `/code-review` and `/resolve` is visibility-gated (counts-only stub on public repos by default) and every posted body is secret-scrubbed before it leaves your machine. Configure via `reviewPublication` in `.devflow/config.json` — details in [docs/commands.md](https://github.com/dean0x/devflow/blob/main/docs/commands.md).
 
-## Workflow Examples
+## Language Support
 
-### Implementing a Feature
-```bash
-/specify     # Define the feature with clarification gates
-/implement   # Execute the full lifecycle
-```
+Optional plugins add language-specific patterns for TypeScript, React, Go, Python, Java, Rust, accessibility, and UI design.
 
-### Debugging an Issue
 ```bash
-/debug "login fails after session timeout"
-/debug #42   # Investigate from GitHub issue
+npx devflow-kit init --plugin=typescript,react
 ```
 
-### Before Creating a PR
-```bash
-/code-review      # Multi-perspective code review
-/resolve     # Fix low-risk issues, defer high-risk to backlog
-```
+## How it works
 
-### Session Continuity
+Devflow is the meta-harness layer: Claude Code harnesses the model; Devflow harnesses Claude Code. Concretely, it's a registry-driven plugin system — each plugin installs commands, agents, and skills into your Claude Code environment. Skills are tiny markdown files that activate automatically based on context. Agents are specialized workers (review, triage, code, etc.) with explicit model assignments — Opus for analysis, Sonnet for execution, Haiku for I/O. Commands orchestrate agent pipelines.
 
-Session context is saved and restored automatically via Working Memory hooks — no manual steps needed.
+For deep dives: [Working Memory](https://github.com/dean0x/devflow/blob/main/docs/working-memory.md) | [CLI Reference](https://github.com/dean0x/devflow/blob/main/docs/cli-reference.md) | [Commands](https://github.com/dean0x/devflow/blob/main/docs/commands.md)
 
 ## 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 Agent Teams (experimental, default: off) |
-| `--ambient` / `--no-ambient` | Enable/disable ambient mode (default: on) |
-| `--memory` / `--no-memory` | Enable/disable working memory (default: on) |
-| `--hud` / `--no-hud` | Enable/disable HUD status line (default: on) |
-| `--hud-only` | Install only the HUD (no plugins, hooks, or extras) |
-| `--verbose` | Show detailed output |
-
-### HUD Options
-
-| Command | Description |
-|---------|-------------|
-| `npx devflow-kit hud --status` | Show current HUD config |
-| `npx devflow-kit hud --enable` | Enable HUD |
-| `npx devflow-kit hud --disable` | Disable HUD (version notifications still appear) |
-| `npx devflow-kit hud --detail` | Show tool/agent descriptions |
-| `npx devflow-kit hud --no-detail` | Hide tool/agent descriptions |
-
-### Skill Shadowing
-
-Override any DevFlow skill with your own version. Shadowed skills survive `devflow init` — they won't be overwritten on reinstall or upgrade.
-
 ```bash
-# Create a personal override (copies current version as reference)
-npx devflow-kit skills shadow core-patterns
-
-# Edit your override
-vim ~/.claude/skills/core-patterns/SKILL.md
-
-# List all overrides
-npx devflow-kit skills list-shadowed
-
-# Remove override (next init restores DevFlow's version)
-npx devflow-kit skills unshadow core-patterns
+npx devflow-kit init                    # Install (interactive wizard)
+npx devflow-kit init --plugin=implement # Install specific plugin
+npx devflow-kit ambient --enable        # Toggle ambient mode (orchestrator)
+npx devflow-kit learning --enable       # Toggle decision/pitfall tracking
+npx devflow-kit compliance --enable     # Enable compliance reviews (pick frameworks)
+npx devflow-kit rules --status          # Show installed rules
+npx devflow-kit security --status       # Show / manage the security deny list
+npx devflow-kit safe-delete --enable    # Install rm -> trash safe-delete
+npx devflow-kit proxy --enable          # Enable external model routing (GPT via Codex)
+npx devflow-kit proxy --disable         # Disable and revert agents to Claude defaults
+npx devflow-kit agents                  # Configure per-agent model assignments (TUI)
+npx devflow-kit agents --list           # List agents with current model assignments
+npx devflow-kit uninstall               # Remove Devflow
 ```
 
-### Uninstall Options
+See [docs/cli-reference.md](https://github.com/dean0x/devflow/blob/main/docs/cli-reference.md) for all options.
 
-| Option | Description |
-|--------|-------------|
-| `--scope <user\|local>` | Uninstall scope (default: user) |
-| `--plugin <names>` | Comma-separated plugin names to uninstall selectively |
-| `--keep-docs` | Preserve .docs/ directory |
-| `--dry-run` | Show what would be removed without deleting anything |
-| `--verbose` | Show detailed uninstall output |
+## Part of the AI Development Stack
+
+| Tool | Role | What It Does |
+|------|------|-------------|
+| **[Skim](https://github.com/dean0x/skim)** | Context Optimization | Code-aware AST parsing, command rewriting, output compression |
+| **Devflow** | Meta-Harness | Orchestrated + graph workflows, parallel review, memory, self-learning |
+| **[MDS](https://github.com/dean0x/mdscript)** | Prompt Engineering | Composable template language for prompts — variables, loops, conditionals, imports, compiled to clean Markdown |
 
 ## Building from Source
 
 ```bash
 git clone https://github.com/dean0x/devflow.git
-cd devflow
-npm install
-npm run build
+cd devflow && npm install && npm run build
 node dist/cli.js init
 ```
 
+## Requirements
+
+- [Claude Code](https://claude.ai/download) (latest)
+- Node.js 22+
+
 ## License
 
 MIT

package/dist/cli/agents-view/index.js

@@ -0,0 +1,9 @@
+/**
+ * agents-view barrel — re-exports for easy imports from consumers.
+ *
+ * applies ADR-013: CLI-layer module group.
+ */
+export { reduce, buildRow, buildModelCycle, pickerNames, buildPickerNameMap, isDirtyModel, isDirtyEffort, persistedModelFor, persistedEffortFor, unsavedCount, isOffCycle, rowState } from './state.js';
+export { renderFrame, FIXED_ROWS, computeViewportHeight, formatAgentName } from './render.js';
+export { runAgentsTui, MAX_KEYPRESSES } from './terminal.js';
+//# sourceMappingURL=index.js.map