cc-pipeline 0.4.0

package/BUILD_SUMMARY.md

@@ -0,0 +1,104 @@
+# CC-Pipeline Build Summary
+
+**Project:** cc-pipeline v0.1.0  
+**Location:** ~/wrk/cc-pipeline  
+**Build Method:** Claude Code Agent Teams (4 Phases)  
+**Build Date:** 2025-02-16  
+**Build Supervisor:** cc-pipeline-supervisor-2 subagent  
+
+## Phase Summary
+
+### Phase 1: Core Engine ✅
+**Commits:** 7c4ce08
+
+Implemented:
+- Engine with phase/step execution
+- State management (JSONL event log)
+- Config parsing (workflow.yaml)
+- Prompt system with template substitution
+- Logger with structured output
+
+### Phase 2: Agent Implementations ✅
+**Commits:** 31853e7, 686fd26
+
+Implemented:
+- BaseAgent class architecture
+- BashAgent (shell commands)
+- ClaudePipedAgent (document generation)
+- ClaudeInteractiveAgent (tmux sessions)
+- Signal handling (SIGINT/SIGTERM)
+- Staff review fixes
+
+### Phase 3: CLI Polish & Integration ✅
+**Commits:** ae77b55, abf990c, e27f5a0
+
+Implemented:
+- Enhanced banner with Unicode box art
+- Status command with formatted output
+- Signal/resume end-to-end testing
+- 19 new tests (total: 24 tests)
+- Bug fixes: signal handler, banner ANSI
+
+### Phase 4: Tests & Documentation ✅
+**Commits:** 631793f, 483993f, c105f01
+
+Implemented:
+- 62 additional tests (total: 86 tests)
+- Comprehensive README.md (308 lines)
+- MIT LICENSE
+- npm publish verification (23.7 kB package)
+- .npmignore configuration
+- Staff review fix (duplicate import)
+
+## Final Statistics
+
+- **Total Tests:** 86 passing
+- **Total Commits:** 10 across 4 phases
+- **Package Size:** 23.7 kB (27 files)
+- **Documentation:** README.md, LICENSE, REFLECTIONS.md, DECISIONS.md, PLAN.md
+- **Architecture:** Clean ESM modules with full signal handling
+
+## Remaining Items (v0.2 scope)
+
+Non-blocking items for future releases:
+- {{FILE_TREE}} placeholder implementation
+- Test gate stub completion
+- Unused config helpers cleanup
+- Box width inconsistency (banner: 60, status: 52)
+- execSync timeout for interactive agent
+- Signal handler race documentation
+
+## Release Checklist
+
+- [x] All phases complete
+- [x] Tests passing (86/86)
+- [x] Documentation complete
+- [x] npm publish verification passed
+- [ ] Push to remote repository
+- [ ] Publish to npm registry
+- [ ] Test global installation
+
+## Next Steps
+
+1. **Push to remote:** `git push origin master`
+2. **Publish to npm:** `npm publish`
+3. **Test installation:** `npm install -g cc-pipeline`
+4. **Verify functionality:** `cc-pipeline init && cc-pipeline run`
+
+## Build Notes
+
+The build was supervised by a BUILD SUPERVISOR subagent that continued from where a previous supervisor hit context limits mid-Phase-2-review. The supervisor successfully:
+
+1. Monitored Phase 2 Staff Review completion
+2. Executed Phase 2 Reflection
+3. Completed Phase 3 (CLI Polish & Integration)
+4. Completed Phase 4 (Tests & Documentation)
+5. Ran Staff Engineer Reviews after each phase
+6. Ran Reflections after each phase
+7. Committed all changes systematically
+
+Build time: Approximately 3 hours using Claude Code with experimental agent teams feature.
+
+---
+
+**Status:** ✅ BUILD COMPLETE - READY FOR RELEASE 🚀

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tim Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,288 @@
+# cc-pipeline
+
+**Autonomous Claude Code pipeline engine.** Install into any repo, write a BRIEF.md describing your project, and let Claude build it phase by phase.
+
+## What Is This?
+
+cc-pipeline orchestrates autonomous development workflows using Claude Code. You provide a project vision in plain language, and the pipeline:
+
+- Breaks down the vision into phases
+- Plans and implements each phase
+- Runs tests, reviews code, and commits automatically
+- Iterates until the project is complete
+
+Think of it as a CI/CD system for AI-driven development—but instead of deploying code, it writes it.
+
+## Prerequisites
+
+- **Node.js** >=18
+- **Claude CLI** (`claude`) installed and configured ([get it here](https://docs.claude.ai/docs/claude-cli))
+- **tmux** — Required for interactive build/fix steps (Claude runs inside tmux sessions)
+  - macOS: `brew install tmux`
+  - Ubuntu/Debian: `sudo apt install tmux`
+  - Fedora: `sudo dnf install tmux`
+- **git** — For the commit step (you probably already have this)
+
+## Installation
+
+This package is published to [GitHub Packages](https://github.com/timothyjoh/cc-pipeline/packages). First, configure npm to use the GitHub registry for the `@timothyjoh` scope:
+
+```bash
+echo "@timothyjoh:registry=https://npm.pkg.github.com" >> ~/.npmrc
+```
+
+Then initialize the pipeline in your project:
+
+```bash
+cd your-project
+npx @timothyjoh/cc-pipeline@latest init
+```
+
+This scaffolds the `.pipeline/` directory, prompt templates, `CLAUDE.md`, and a `BRIEF.md.example` into your project.
+
+## Quick Start
+
+### 1. Initialize the pipeline
+
+```bash
+cd your-project
+npx @timothyjoh/cc-pipeline@latest init
+```
+
+### 2. Write your project brief
+
+Copy the example and edit it:
+
+```bash
+cp BRIEF.md.example BRIEF.md
+```
+
+Or let Claude Code help you write it — fire up `claude` in your project and ask:
+
+```
+Using the @BRIEF.md.example as a template, let's discuss this project's goals
+and write a BRIEF.md. Ask me for a quick description first, then ask questions
+one-at-a-time to build a good brief.
+```
+
+![Example of Claude Code building a BRIEF.md through interactive Q&A](docs/brief-example.png)
+
+### 3. Run the pipeline
+
+> **⚠️ Run from a regular terminal, not from inside Claude Code.** The pipeline spawns its own Claude Code sessions in tmux, so running it from within Claude Code would nest sessions — which isn't supported.
+
+```bash
+npx cc-pipeline run
+```
+
+That's it. The pipeline will spec, build, review, fix, and commit each phase automatically.
+
+### 4. Monitor progress
+
+```bash
+npx cc-pipeline status
+```
+
+The pipeline also generates a `STATUS.md` at the project root after each phase — a running summary of what's been built, review findings, test coverage, and what's next.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `npx @timothyjoh/cc-pipeline@latest init` | Scaffold `.pipeline/`, `CLAUDE.md`, and `BRIEF.md.example` |
+| `npx @timothyjoh/cc-pipeline@latest update` | Refresh prompts and docs (preserves your `workflow.yaml`) |
+| `npx cc-pipeline run [--phases N] [--model NAME]` | Run the pipeline |
+| `npx cc-pipeline status` | Show current phase, step, and recent events |
+| `npx cc-pipeline reset` | Clear event log, phase outputs, and STATUS.md |
+
+> **Tip:** Use `@latest` with `init` and `update` to get the newest templates. For `run`, `status`, and `reset`, the cached version is fine.
+
+### Run Options
+
+- `--phases <n>` — Limit to N phases (useful for testing)
+- `--model <name>` — Override model for all steps (e.g., `opus`, `sonnet`, `haiku`)
+
+### Examples
+
+```bash
+npx cc-pipeline run                  # Run until complete
+npx cc-pipeline run --phases 3       # Run just 3 phases
+npx cc-pipeline run --model opus     # Use opus for all steps
+npx cc-pipeline reset                # Start over from scratch
+```
+
+The pipeline resumes from interruptions automatically. Press **Ctrl-C** to pause, then `npx cc-pipeline run` again to continue.
+
+## How It Works
+
+### Phases
+
+The pipeline works in **phases**, each representing a unit of progress (e.g., "user authentication", "payment integration"). Each phase follows the same workflow of steps.
+
+### Steps
+
+Each phase runs through these steps (defined in `.pipeline/workflow.yaml`):
+
+1. **spec** — Break the project vision into a phase spec
+2. **research** — Analyze the current codebase state
+3. **plan** — Create an actionable implementation plan
+4. **build** — Implement the plan (interactive Claude in tmux)
+5. **review** — Staff engineer-level code review
+6. **fix** — Address review findings (skipped if none)
+7. **reflect** — Look back at progress, plan the next phase
+8. **status** — Update `STATUS.md` with build summary, test coverage, and what's next
+9. **commit** — Git commit and push
+
+### Agents
+
+| Agent | How It Runs | Used For |
+|-------|------------|----------|
+| `claude-piped` | `claude -p "<prompt>"` (non-interactive) | Planning, analysis, reviews, docs |
+| `claude-interactive` | Claude in a tmux session with full tool access | Building code, fixing issues |
+| `bash` | Direct shell command | Git commits, scripts |
+
+### State & Resume
+
+Pipeline state lives in `.pipeline/pipeline.jsonl` — an append-only event log. The current phase and step are derived from the log, so you can interrupt and resume seamlessly.
+
+### Project Completion
+
+When Claude determines the project is complete, it writes `PROJECT COMPLETE` in `REFLECTIONS.md`. The pipeline stops automatically.
+
+## Configuration
+
+Pipeline behavior is controlled by `.pipeline/workflow.yaml`. See `.pipeline/CLAUDE.md` for full configuration docs — how to edit steps, change agents/models, customize prompts, and add new steps.
+
+### Quick Examples
+
+**Override model per step:**
+```yaml
+steps:
+  - name: spec
+    agent: claude-piped
+    model: sonnet
+    prompt: prompts/spec.md
+```
+
+**Add conditional execution:**
+```yaml
+  - name: fix
+    agent: claude-interactive
+    prompt: prompts/fix.md
+    skip_unless: "MUST-FIX.md"    # Only runs if review produced MUST-FIX.md
+```
+
+**Customize prompts:** Edit the markdown files in `.pipeline/prompts/` to change how each step behaves.
+
+## Example BRIEF.md
+
+```markdown
+# Project Brief
+
+## Overview
+A command-line task manager with persistent storage.
+
+## Tech Stack
+- Node.js + SQLite
+- No external dependencies
+
+## Features (Priority Order)
+1. **Add/list/complete tasks** — Core CRUD operations
+2. **Due dates & filtering** — Filter by status, due date
+3. **Tags & search** — Organize and find tasks
+
+## Constraints
+- Must work offline
+- Single-file database
+
+## Testing
+- Node test runner for unit tests
+- Cover core CRUD operations
+
+## Definition of Done
+~3 phases for MVP, complete when all features work with tests passing
+```
+
+## Project Structure
+
+After initialization and a few phases:
+
+```
+your-project/
+├── .pipeline/
+│   ├── CLAUDE.md            # Pipeline config docs (for Claude Code)
+│   ├── workflow.yaml        # Step definitions, agents, models
+│   ├── pipeline.jsonl       # Event log (auto-created on first run)
+│   └── prompts/             # Prompt templates (customizable)
+│       ├── spec.md
+│       ├── research.md
+│       ├── plan.md
+│       ├── build.md
+│       ├── review.md
+│       ├── fix.md
+│       ├── reflect.md
+│       └── status.md
+├── docs/
+│   └── phases/
+│       ├── phase-1/         # Phase artifacts
+│       │   ├── SPEC.md
+│       │   ├── RESEARCH.md
+│       │   ├── PLAN.md
+│       │   ├── REVIEW.md
+│       │   └── REFLECTIONS.md
+│       └── phase-2/
+│           └── ...
+├── BRIEF.md                 # Your project vision
+├── CLAUDE.md                # Project conventions (for Claude Code)
+├── AGENTS.md                # Dev docs (created by Phase 1)
+├── STATUS.md                # Running build summary (auto-updated)
+└── [your code here]
+```
+
+## Troubleshooting
+
+**"Claude Code cannot be launched inside another Claude Code session":**
+- Run the pipeline from a regular terminal, not from within Claude Code
+- If you still see this after exiting Claude Code, run: `unset CLAUDECODE` then try again
+
+**Build step times out (60s+):**
+- Check [Anthropic's status page](https://status.anthropic.com) — API issues cause slow startups
+- The pipeline will retry on resume: just run `npx cc-pipeline run` again
+
+**Pipeline won't start:**
+- Ensure `claude` CLI is installed: `claude --version`
+- Ensure `tmux` is installed: `tmux -V`
+- Run `npx @timothyjoh/cc-pipeline@latest init` if `.pipeline/` doesn't exist
+
+**Want to start over:**
+```bash
+npx cc-pipeline reset
+npx cc-pipeline run
+```
+
+**Want the latest prompts without losing your workflow.yaml:**
+```bash
+npx @timothyjoh/cc-pipeline@latest update
+```
+
+## Development
+
+```bash
+git clone https://github.com/timothyjoh/cc-pipeline.git
+cd cc-pipeline
+npm install
+npm test
+npm link    # For local development
+```
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR on GitHub.
+
+---
+
+Built with [Claude Code](https://docs.claude.ai/docs/claude-cli) by Anthropic.

package/bin/cc-pipeline.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { run } from '../src/cli.js';
+
+run(process.argv.slice(2)).catch(err => {
+  console.error(err.message);
+  process.exit(1);
+});

package/docs/AGENT-TEAMS-RESEARCH.md

@@ -0,0 +1,84 @@
+# Agent Teams Research
+
+## What Are Agent Teams?
+
+Claude Code experimental feature (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`) that enables multi-agent parallel execution. Fundamentally different from the Task tool / sub-agents.
+
+**Key differences from Task tool sub-agents:**
+- Each teammate gets their own context window
+- Shared task list with dependency tracking and file-lock claiming
+- Inter-agent mailbox (teammates can message each other, not just report to lead)
+- tmux split-pane mode (each teammate visible in its own pane)
+
+## Enabling
+
+### Option 1: Settings file (recommended, persistent)
+Add to `~/.claude/settings.json`:
+```json
+{
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
+  }
+}
+```
+
+### Option 2: Environment variable (per-session)
+```bash
+export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
+```
+
+### Option 3: cc-pipeline sets it automatically
+The pipeline sets the env var in the tmux session before launching Claude.
+
+## tmux Control Mode
+
+One article reports that agents didn't spawn in separate panes without `tmux -CC` (control mode). Control mode maps tmux panes to native iTerm2 tabs/windows.
+
+- `tmux -CC` — control mode, needed for iTerm2 native pane mapping
+- Regular `tmux new-session -d` — may work but panes may not split automatically
+- `--teammate-mode tmux` — Claude Code flag to prefer tmux split panes
+
+**TODO:** Test whether `tmux -CC` is actually required or just an iTerm2 preference.
+
+## Different Models Per Teammate
+
+You can assign different models to each teammate:
+```
+Spawn a team of 3 agents:
+- Agent 1 (opus): Backend implementation
+- Agent 2 (sonnet): Frontend implementation  
+- Agent 3 (haiku): Test writing
+```
+
+**Opportunity for cc-pipeline:** Build prompt could specify model per teammate role:
+- Tester → haiku (cheaper, tests are simpler)
+- Builder → opus (smarter, implementation is harder)
+- Or respect the `--model` flag from the CLI
+
+## Token/Cost Considerations
+
+- Each teammate has its own context window → multiplies token usage
+- A 3-agent team on a codebase analysis ran ~13 minutes
+- Max plan users report heavy weekly limit impact from intense team runs
+- Monitor with `/usage` command in Claude Code
+
+## Architecture Details
+
+- Config: `~/.claude/teams/{team-name}/config.json`
+- Tasks: `~/.claude/tasks/{team-name}/`
+- Display modes: in-process (default), split-pane (tmux), auto (detects environment)
+- Setting: `"teammateMode": "tmux"` in settings.json
+
+## References
+
+- [How to Set Up and Use Claude Code Agent Teams](https://darasoba.medium.com/how-to-set-up-and-use-claude-code-agent-teams-and-actually-get-great-results-9a34f8648f6d) — Darasoba, Feb 7 2026
+- [Claude Code Multi-Agent tmux Setup](https://www.dariuszparys.com/claude-code-multi-agent-tmux-setup/) — Dariusz Parys, Feb 2026
+
+## Open Questions / TODOs
+
+- [ ] Test `tmux -CC` vs regular tmux — is control mode required for pane splitting?
+- [ ] Test settings.json approach vs env var — which is more reliable?
+- [ ] Experiment with model-per-teammate in build prompt (haiku for tests, opus for code)
+- [ ] Investigate `--teammate-mode tmux` flag — can we pass it when launching Claude?
+- [ ] Measure token usage difference: solo build vs agent team build
+- [ ] Check if agent teams work with `--dangerously-skip-permissions`

package/docs/IDEAS.md

@@ -0,0 +1,24 @@
+# IDEAS.md — Future Enhancements
+
+## Contract-First Plan→Build Handoff
+**Source:** Cole Medin's "Agent Teams" video (Feb 2026)
+
+Currently the plan step outputs a task list. Instead, have it output **explicit API contracts and schemas** — function signatures, data structures, file boundaries — before the build step spawns parallel agents. This way agents can integrate without reading each other's code.
+
+**Implementation:** Add a `contracts` section to PLAN.md template. The plan prompt should require: "Define the API contract between modules — function signatures, expected inputs/outputs, shared data structures. Each build agent receives these contracts as context."
+
+**Why it matters:** The #1 failure mode in parallel agent builds is integration conflicts. Contract-first eliminates this by agreement-before-implementation.
+
+## Structured Pre-Flight Questions
+**Source:** Cole Medin
+
+Before the spec step, force the agent to generate 10-15 clarifying questions about the BRIEF.md, then answer them from context. Catches ambiguity early instead of mid-build.
+
+**Where it fits:** Could be a new `clarify` step before `spec`, or baked into the spec prompt itself.
+
+## Autonomous Validation Loop
+**Source:** Cole Medin
+
+After build/fix, add a validation loop: agent runs tests → finds bugs → fixes → re-runs tests → repeats until clean. Currently we do review→fix as separate steps with a human-like handoff. An autonomous loop would be tighter.
+
+**Where it fits:** Could replace or augment the review→fix→reflect sequence with a `validate` step that loops internally.

package/docs/SYSTEM-PROMPTS-RESEARCH.md

@@ -0,0 +1,86 @@
+# System Prompts Research
+
+Analysis of leaked system prompts from major AI coding tools.
+Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools (110K+ stars)
+
+## Key Patterns Worth Stealing
+
+### 1. TodoWrite / Task Tracking (Claude Code, Cursor)
+Both Claude Code and Cursor heavily emphasize TODO tracking during execution:
+- "Use TodoWrite tools VERY frequently to ensure you are tracking tasks"
+- "Mark todos as completed as soon as you are done — do not batch"
+- Cursor uses `todo_write` with `merge=true` to reconcile before every edit
+
+**Relevance to cc-pipeline:** Our build prompt could tell the team lead to use TodoWrite to track teammate progress. Currently we just say "orchestrate" — this is more specific.
+
+### 2. Think Tool / Reasoning (Devin)
+Devin has an explicit `<think>` scratchpad that's mandatory before:
+- Critical git decisions
+- Transitioning from exploring to editing
+- Reporting completion (must "critically examine" work before claiming done)
+- After test/CI failures (think big picture before diving into fixes)
+
+**Relevance:** Our review/reflect prompts could benefit from explicit "think before acting" instructions.
+
+### 3. Parallel Tool Calls (Cursor)
+Cursor is aggressive about parallelism:
+- "DEFAULT TO PARALLEL unless output of A required for input of B"
+- "Parallel tool execution can be 3-5x faster"
+- Batch read-only operations, independent edits
+- "Limit to 3-5 tool calls at a time or they might time out"
+
+**Relevance:** Our agent teams already parallelize at the teammate level, but the build prompt could encourage parallel tool calls within each teammate too.
+
+### 4. Code Conventions First (All)
+Universal pattern across Claude Code, Cursor, Devin, Windsurf:
+- "First understand the file's code conventions"
+- "NEVER assume a library is available — check package.json first"
+- "Look at neighboring files, mimic code style"
+- "When you create a new component, first look at existing components"
+
+**Relevance:** Our research step already does this, but the build prompt should reinforce "follow patterns from RESEARCH.md."
+
+### 5. No Comments Unless Asked (Claude Code, Devin)
+- Claude Code: "IMPORTANT: DO NOT ADD ANY COMMENTS unless asked"
+- Devin: "Do not add comments to the code you write, unless the user asks"
+
+**Relevance:** Could add this to our build prompt — AI-generated comments are usually noise.
+
+### 6. Concise Output (Claude Code)
+Claude Code is extremely aggressive about brevity:
+- "Fewer than 4 lines unless user asks for detail"
+- "Minimize output tokens as much as possible"
+- "One word answers are best"
+- "NEVER add unnecessary preamble or postamble"
+
+**Relevance:** Our piped steps (spec, plan, review) want detailed output, but the build step should be concise — focus on coding, not explaining.
+
+### 7. Verify Before Claiming Done (Claude Code, Devin, Cursor)
+- Claude Code: "Run lint and typecheck commands when completed"
+- Devin: "Critically examine your work before reporting completion"
+- Cursor: "Gate before new edits — reconcile TODO list"
+
+**Relevance:** Our build prompt has quality gates but could be more emphatic. The review step catches issues, but catching them in build is cheaper.
+
+### 8. Never Commit Unless Asked (Claude Code)
+- "NEVER commit changes unless the user explicitly asks"
+
+**Relevance:** Our pipeline has a dedicated commit step, so this is handled architecturally. Good validation of our approach.
+
+## Interesting Architectural Differences
+
+| Tool | Planning | Execution | Review |
+|------|----------|-----------|--------|
+| Claude Code | TodoWrite | Sequential + Task tool | Lint/typecheck |
+| Cursor | todo_write with merge | Parallel tool calls | Summary spec |
+| Devin | Explicit plan mode | Standard mode with think gates | CI-based |
+| Windsurf | Inline | Sequential | Terminal run |
+| cc-pipeline | Separate spec/plan steps | Agent teams (parallel) | Dedicated review step |
+
+Our pipeline's separated planning → building → reviewing is more structured than any of these. They all do it in one session. That's our advantage for larger projects.
+
+## TODO
+- [ ] Add "no comments unless asked" to build prompt
+- [ ] Add TodoWrite encouragement to build prompt for team lead task tracking
+- [ ] Consider adding "think before acting" gate to fix prompt (Devin pattern)
+- [ ] Test whether explicit "run lint/typecheck" instruction in build prompt catches more issues before review

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "cc-pipeline",
+  "version": "0.4.0",
+  "description": "Autonomous Claude Code pipeline engine. Install into any repo, write a BRIEF.md, and let Claude build your project phase by phase.",
+  "type": "module",
+  "bin": {
+    "cc-pipeline": "bin/cc-pipeline.js"
+  },
+  "scripts": {
+    "test": "node --test src/**/*.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/timothyjoh/cc-pipeline.git"
+  },
+  "bugs": {
+    "url": "https://github.com/timothyjoh/cc-pipeline/issues"
+  },
+  "homepage": "https://github.com/timothyjoh/cc-pipeline#readme",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "pipeline",
+    "ai",
+    "autonomous",
+    "code-generation"
+  ],
+  "author": "Tim Johnson",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "yaml": "^2.7.0"
+  }
+}