buildanything 1.0.1 → 1.2.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "buildanything",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "One command to build an entire product. 73 specialist agents orchestrated into a full engineering pipeline — from idea to shipped, tested, reviewed code.",
   "author": {
     "name": "Sujit"

package/bin/setup.js

@@ -5,6 +5,14 @@ const { execFileSync } = require("child_process");
 const REPO = "sujitmeka/buildanything";
 const MARKETPLACE = "buildanything-marketplace";
 const PLUGIN = "buildanything";
+const OFFICIAL_MARKETPLACE = "claude-plugins-official";
+
+const OFFICIAL_PLUGINS = [
+  { name: "feature-dev", desc: "code-architect, code-explorer, code-reviewer" },
+  { name: "pr-review-toolkit", desc: "silent-failure-hunter, code-simplifier, type-design-analyzer" },
+  { name: "code-review", desc: "final code review passes" },
+  { name: "commit-commands", desc: "clean git commits" },
+];
 
 function run(command, args) {
   try {
@@ -31,7 +39,7 @@ function main() {
   }
   console.log(`  Found Claude Code ${version}`);
 
-  // Add marketplace
+  // Add marketplace and install buildanything
   console.log(`  Adding marketplace from ${REPO}...`);
   const addResult = run("claude", ["plugin", "marketplace", "add", REPO]);
   if (addResult === null) {
@@ -42,7 +50,6 @@ function main() {
   }
   console.log("  Marketplace added.");
 
-  // Install plugin
   console.log(`  Installing ${PLUGIN} plugin...`);
   const installResult = run("claude", [
     "plugin",
@@ -57,12 +64,39 @@ function main() {
     );
     process.exit(1);
   }
+  console.log("  buildanything installed.\n");
+
+  // Install official companion plugins
+  console.log("  Installing companion plugins from official marketplace...");
+  const installed = [];
+  const skipped = [];
+
+  for (const plugin of OFFICIAL_PLUGINS) {
+    const fullName = `${plugin.name}@${OFFICIAL_MARKETPLACE}`;
+    process.stdout.write(`    ${plugin.name} (${plugin.desc})... `);
+    const result = run("claude", ["plugin", "install", fullName]);
+    if (result === null) {
+      console.log("skipped (may already be installed)");
+      skipped.push(plugin.name);
+    } else {
+      console.log("installed");
+      installed.push(plugin.name);
+    }
+  }
 
   console.log(
-    "\n  Installed! Start Claude Code and use:\n" +
+    "\n  Setup complete! Start Claude Code and use:\n" +
       "    /buildanything:build <your idea>       — full product pipeline\n" +
       "    /buildanything:idea-sweep <your idea>  — parallel research sweep\n"
   );
+
+  if (installed.length > 0) {
+    console.log(`  Companion plugins installed: ${installed.join(", ")}`);
+  }
+  if (skipped.length > 0) {
+    console.log(`  Already installed: ${skipped.join(", ")}`);
+  }
+  console.log();
 }
 
 main();

package/commands/build.md

@@ -5,6 +5,78 @@ argument-hint: "Path to brainstorming doc or describe what we're building"
 
 # /build — NEXUS-Sprint Pipeline
 
+## PROCESS INTEGRITY — READ THIS FIRST
+
+<HARD-GATE>
+You are an ORCHESTRATOR. You coordinate specialist agents. You do NOT write implementation code yourself.
+
+If you are about to write implementation code directly — STOP. That is a violation of this process. Dispatch to a specialist agent instead.
+
+This gate is non-negotiable. No exceptions. No "just this one quick fix." No "it's faster if I do it myself."
+</HARD-GATE>
+
+**Resuming after context compaction?** If your context was recently compacted or you are continuing a previous session:
+1. Read `docs/plans/.build-state.md` to recover your phase, step, and progress
+2. Re-read THIS file completely — you are reading it now
+3. Check the TodoWrite list for task progress
+4. Resume from the saved state, not from scratch
+5. Do NOT skip ahead or fall back to default coding behavior
+
+### Rationalization Prevention
+
+If you catch yourself thinking any of these, you are drifting from the process:
+
+| Thought | Reality |
+|---------|---------|
+| "It's faster if I just write this myself" | You are an orchestrator. Dispatch to an agent. Speed is not your job — coordination is. |
+| "This is too small for a subagent" | Every implementation task goes through an agent. No exceptions. Small tasks still need the Dev→QA loop. |
+| "I'll skip the code review for this one" | Every task gets reviewed. The code-reviewer agent exists for a reason. |
+| "The quality gate is obvious, I'll just proceed" | Present it to the user. Quality gates require explicit user approval. |
+| "I already know what to build, I'll skip architecture" | Phase 1 is mandatory. The architecture step catches design mistakes before they become code. |
+| "Tests aren't needed for this part" | Every task has acceptance criteria and tests. The Evidence Collector verifies. |
+| "I'll clean this up later" | The Harden phase (Phase 4) exists for this. Don't skip steps — follow the process. |
+| "Context was compacted, I'll just keep coding" | STOP. Re-read this file. Check .build-state.md. Reload the process. |
+
+### Process Flowchart
+
+```dot
+digraph build_pipeline {
+  rankdir=TB;
+  node [shape=box];
+
+  start [label="User invokes /build" shape=ellipse];
+  p1 [label="Phase 1: Architecture & Planning\n(Backend Architect + UX Architect +\nSecurity Engineer + code-architect +\nSprint Prioritizer + Senior PM)"];
+  gate1 [label="Quality Gate 1\nUser approves architecture?" shape=diamond];
+  p2 [label="Phase 2: Foundation\n(DevOps Automator + Frontend Dev\nor Backend Architect)"];
+  gate2 [label="Quality Gate 2\nBuilds? Tests pass? Lint clean?" shape=diamond];
+  p3 [label="Phase 3: Build — Dev↔QA Loops\nFor EACH task:\nAgent implements → Evidence Collector\nverifies → code-reviewer reviews"];
+  retry [label="Retry (max 3)\nFeedback to dev agent" shape=box];
+  escalate [label="Escalate to user\nafter 3 failures" shape=box];
+  p4 [label="Phase 4: Harden\n(API Tester + Perf Benchmarker +\nAccessibility Auditor + Security Engineer +\ncode-simplifier + Reality Checker)"];
+  gate4 [label="Quality Gate 4\nReality Checker: PRODUCTION READY?" shape=diamond];
+  p5 [label="Phase 5: Ship\n(Technical Writer + final commit)"];
+  done [label="BUILD COMPLETE" shape=ellipse];
+
+  start -> p1;
+  p1 -> gate1;
+  gate1 -> p2 [label="approved"];
+  gate1 -> p1 [label="changes requested"];
+  p2 -> gate2;
+  gate2 -> p3 [label="pass"];
+  gate2 -> p2 [label="fix"];
+  p3 -> retry [label="task fails"];
+  retry -> p3 [label="< 3 retries"];
+  retry -> escalate [label="3 retries"];
+  p3 -> p4 [label="all tasks complete"];
+  p4 -> gate4;
+  gate4 -> p5 [label="PRODUCTION READY"];
+  gate4 -> p4 [label="NEEDS WORK"];
+  p5 -> done;
+}
+```
+
+---
+
 You are the **Agents Orchestrator** running a NEXUS-Sprint pipeline. Your job is to take a brainstormed idea and build it into a working, tested, production-quality product — coordinating specialist agents the way a VP of Engineering at Meta or Google would run a product team.
 
 **This is NOT brainstorming. Brainstorming is done. This is execution.**
@@ -13,11 +85,37 @@ Input: $ARGUMENTS
 
 ## Operating Principles
 
+- **You are an orchestrator.** You dispatch work to specialist agents. You do NOT write implementation code yourself. Your job is coordination, synthesis, and quality enforcement.
 - **Phase gates are mandatory.** Do not advance to the next phase until the current phase passes its quality gate. Present phase output to the user for approval before advancing.
 - **Dev↔QA loops are mandatory.** Every implementation task gets tested. Failed tasks loop back to the developer agent with specific feedback. Max 3 retries per task before escalation to the user.
-- **Parallelism within phases.** Agents within the same step run in parallel via the Task tool. Phases run sequentially.
+- **Fresh agents per task.** Each task gets a fresh subagent to prevent context pollution from previous tasks. Do not reuse a subagent across multiple implementation tasks.
+- **Parallelism within phases.** Agents within the same step run in parallel via the Agent tool. Phases run sequentially.
 - **Real code, real tests, real commits.** This pipeline writes actual files, runs actual tests, and makes actual git commits. It does not produce documents about code.
 - **Evidence-based quality.** The Reality Checker defaults to NEEDS WORK. The Evidence Collector requires proof. Do not self-approve.
+- **TodoWrite for progress tracking.** Use TodoWrite to create and update a task checklist at the start of Phase 3. This is your primary progress tracker — it survives context compaction better than memory alone.
+- **State persistence.** After completing each step, update `docs/plans/.build-state.md` with your current phase, step, task progress, and agent usage. This file is your recovery point if context is compacted.
+
+---
+
+## Phase 0: Initialize
+
+Before starting any work:
+
+1. **Create a TodoWrite checklist** with the 5 phases:
+   - [ ] Phase 1: Architecture & Planning
+   - [ ] Phase 2: Foundation
+   - [ ] Phase 3: Build (will expand into per-task items later)
+   - [ ] Phase 4: Harden
+   - [ ] Phase 5: Ship
+
+2. **Write initial state** to `docs/plans/.build-state.md`:
+   ```
+   Phase: 0 — Initializing
+   Input: [user's build request]
+   Started: [timestamp]
+   ```
+
+3. Proceed to Phase 1.
 
 ---
 
@@ -25,7 +123,9 @@ Input: $ARGUMENTS
 
 **Goal**: Define the technical architecture, component structure, UX foundation, and sprint task list. No code yet — just the blueprint.
 
-**Quality Gate**: User approves the architecture and task list before any code is written.
+<HARD-GATE>
+Quality Gate: User MUST approve the architecture and task list before any code is written. Do not proceed to Phase 2 without explicit user approval. "Looks good" counts. Silence does not.
+</HARD-GATE>
 
 ### Step 1.1 — Codebase Understanding (if existing project)
 
@@ -58,13 +158,23 @@ Launch **Sprint Prioritizer** with the Architecture Document:
 - Define acceptance criteria for each task — what "done" looks like, what tests must pass
 - Identify dependencies between tasks — what must be built first
 - Estimate relative complexity (S/M/L) for each task
+- **Include the architectural rationale** — WHY this task exists, which part of the architecture it implements
 
 Then launch **Senior Project Manager** to validate the task list:
 - Confirm realistic scope — remove anything that isn't in the brainstorming spec
 - Verify no missing tasks — every component from the architecture has implementation tasks
 - Ensure task descriptions are specific enough that a developer agent can execute without ambiguity
 
-Save the task list to `docs/plans/sprint-tasks.md`.
+Save the task list to `docs/plans/sprint-tasks.md`. The file MUST include this header:
+
+```
+# Sprint Tasks — buildanything pipeline
+# PROCESS: Execute each task using build.md Phase 3 Dev→QA loops.
+# DO NOT implement tasks directly. Dispatch to specialist agents.
+# If you lost context, re-read: commands/build.md
+#
+# Each task MUST go through: Implement (agent) → Verify (Evidence Collector) → Review (code-reviewer)
+```
 
 ### Quality Gate 1
 
@@ -75,7 +185,18 @@ Present to the user:
 
 Ask: **"Architecture and sprint plan ready. Approve to start building, or flag changes?"**
 
-**DO NOT PROCEED WITHOUT USER APPROVAL.**
+<HARD-GATE>
+DO NOT PROCEED WITHOUT USER APPROVAL. Wait for explicit confirmation.
+</HARD-GATE>
+
+**Save state:** Write `docs/plans/.build-state.md`:
+```
+Phase: 1 COMPLETE — awaiting user approval
+Tasks: [total] planned
+Agents used: Backend Architect, UX Architect, Security Engineer, code-architect, Sprint Prioritizer, Senior Project Manager
+```
+
+Update TodoWrite: mark Phase 1 complete.
 
 ---
 
@@ -118,12 +239,34 @@ Run these checks:
 
 If any fail, fix before proceeding. Present status to user.
 
+**Save state:** Update `docs/plans/.build-state.md`:
+```
+Phase: 2 COMPLETE
+Foundation: scaffolded, builds clean, tests pass
+Next: Phase 3 — Dev↔QA loops
+```
+
+Update TodoWrite: mark Phase 2 complete.
+
 ---
 
 ## Phase 3: Build — Dev↔QA Loops
 
+<HARD-GATE>
+SENTINEL CHECK — Before starting Phase 3, verify ALL of these:
+- Phase 1 quality gate passed (user approved architecture)
+- Phase 2 quality gate passed (project builds, tests pass)
+- You are dispatching to agents, not coding directly
+- `docs/plans/.build-state.md` exists and is current
+- TodoWrite has Phases 1 and 2 marked complete
+
+If ANY check fails, STOP and resolve before continuing.
+</HARD-GATE>
+
 **Goal**: Implement every task from the Sprint Task List. Each task goes through a Dev→Test→Review loop. This is where the actual product gets built.
 
+**First:** Expand the TodoWrite list — add each task from sprint-tasks.md as a separate todo item under Phase 3.
+
 **For EACH task in the Sprint Task List, execute this loop:**
 
 ### Step 3.1 — Implement
@@ -134,6 +277,8 @@ Select the right developer agent based on task type:
 - **AI Engineer** — ML features, model integration, data pipelines
 - **Rapid Prototyper** — Quick integrations, glue code, utility functions
 
+**Launch a FRESH agent for each task.** Do not reuse agents across tasks — this prevents context pollution.
+
 The developer agent receives:
 - The specific task description and acceptance criteria from the Sprint Task List
 - The Architecture Document for context
@@ -158,15 +303,10 @@ Launch **code-reviewer** (Claude Code agent) to review the implementation:
 - Adherence to project conventions from the Architecture Document
 - Code quality — is it simple, DRY, readable?
 
-Launch **silent-failure-hunter** (Claude Code agent) to check:
-- Silent failures in catch blocks
-- Inadequate error handling
-- Missing edge cases
-
 ### Step 3.4 — Loop Decision
 
 **IF Evidence Collector = PASS AND code-reviewer finds no critical issues:**
-- Mark task as complete in the Sprint Task List
+- Mark task as complete in TodoWrite
 - Move to next task
 - Reset retry counter
 
@@ -185,7 +325,11 @@ Launch **silent-failure-hunter** (Claude Code agent) to check:
 
 ### Progress Tracking
 
-After each task completes, report:
+After each task completes:
+
+1. Update TodoWrite: mark the task complete.
+
+2. Report to user:
 ```
 Task [X/total]: [task name] — COMPLETE
   Tests: [pass count] passing
@@ -193,13 +337,24 @@ Task [X/total]: [task name] — COMPLETE
   Next: [next task name]
 ```
 
+3. **Save state** — Update `docs/plans/.build-state.md`:
+```
+Phase: 3 IN PROGRESS
+Current task: [X+1]/[total] — [next task name]
+Completed: [list of completed tasks]
+Retry counter: 0
+Agents used this phase: [list]
+```
+
 ---
 
 ## Phase 4: Harden
 
 **Goal**: The full product is built. Now stress-test it. This phase finds the bugs, performance issues, security holes, and accessibility failures that task-level QA misses.
 
-**Quality Gate**: Reality Checker must approve before this phase passes. The Reality Checker defaults to NEEDS WORK and requires overwhelming evidence for approval.
+<HARD-GATE>
+Quality Gate: Reality Checker must approve before this phase passes. The Reality Checker defaults to NEEDS WORK and requires overwhelming evidence for approval. Do NOT self-approve.
+</HARD-GATE>
 
 ### Step 4.1 — Integration Testing (Parallel)
 
@@ -249,6 +404,14 @@ Present to the user:
 5. Accessibility audit results
 6. Any items the Reality Checker flagged as NEEDS WORK
 
+**Save state:** Update `docs/plans/.build-state.md`:
+```
+Phase: 4 COMPLETE
+Reality Checker: [verdict]
+```
+
+Update TodoWrite: mark Phase 4 complete.
+
 ---
 
 ## Phase 5: Ship
@@ -292,3 +455,10 @@ Files Modified: [count]
 
 Remaining Items: [any NEEDS WORK items from Reality Checker]
 ```
+
+Update TodoWrite: mark Phase 5 and all items complete.
+
+**Save final state:** Update `docs/plans/.build-state.md`:
+```
+Phase: 5 COMPLETE — BUILD DONE
+```

package/hooks/hooks.json

@@ -0,0 +1,27 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "'${CLAUDE_PLUGIN_ROOT}/hooks/session-start'",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "ORCHESTRATOR STATE SAVE — Context is about to be compacted. If you are running the /buildanything:build pipeline, you MUST do these things NOW before your context is lost:\n\n1. Use TodoWrite to update all task statuses (complete, in-progress, pending)\n2. Write `docs/plans/.build-state.md` with: current phase, step, task progress, retry counter, agents used, pending quality gate results\n3. The next thing that will happen after compaction is the SessionStart hook will fire and re-inject your orchestrator identity. But you MUST save state NOW or your progress tracking is lost."
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/session-start

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# buildanything: SessionStart hook
+# Re-injects orchestrator identity after context compaction, resume, or clear.
+# Modeled after superpowers' session-start pattern.
+
+# Check if a build pipeline is active by looking for .build-state.md
+BUILD_STATE=""
+if [ -f "docs/plans/.build-state.md" ]; then
+  BUILD_STATE=$(cat "docs/plans/.build-state.md")
+fi
+
+# If no active build, just provide a minimal reminder
+if [ -z "$BUILD_STATE" ]; then
+  CONTEXT="buildanything plugin is installed. Use /buildanything:build to start a full product pipeline, or /buildanything:idea-sweep for parallel research."
+else
+  # Active build detected — re-inject full orchestrator context
+  read -r -d '' CONTEXT << 'ORCHESTRATOR'
+BUILDANYTHING ORCHESTRATOR — ACTIVE BUILD DETECTED
+
+You are the Agents Orchestrator running a NEXUS-Sprint pipeline. You are NOT a solo developer. You coordinate specialist agents.
+
+CRITICAL RULES:
+1. You do NOT write implementation code yourself — you dispatch to specialist agents
+2. You follow phase gates — no advancing without quality gate approval
+3. Every task goes through Dev→Test→Review loops
+4. You must re-read commands/build.md if you are unsure of the process
+
+YOUR CURRENT STATE (from docs/plans/.build-state.md):
+ORCHESTRATOR
+
+  CONTEXT="${CONTEXT}
+${BUILD_STATE}
+
+NEXT ACTIONS:
+1. Re-read commands/build.md to reload the full orchestrator process
+2. Resume from the phase and step indicated in your state above
+3. Use TodoWrite to track task progress
+4. Dispatch work to specialist agents — do not implement directly"
+fi
+
+# Output as additional_context for Claude Code
+# JSON-escape the context
+ESCAPED=$(printf '%s' "$CONTEXT" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))')
+
+cat << EOF
+{"additional_context": ${ESCAPED}}
+EOF

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildanything",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "One command to build an entire product. 73 specialist agents orchestrated into a full engineering pipeline for Claude Code.",
   "bin": {
     "buildanything": "./bin/setup.js"
@@ -31,6 +31,7 @@
     ".claude-plugin/",
     "agents/",
     "commands/",
+    "hooks/",
     "README.md"
   ]
 }