buildanything 1.0.0

package/bin/setup.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process");
+
+const REPO = "sujitmeka/buildanything";
+const MARKETPLACE = "buildanything-marketplace";
+const PLUGIN = "oneshot";
+
+function run(command, args) {
+  try {
+    return execFileSync(command, args, {
+      stdio: "pipe",
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  console.log("\n  buildanything — one command to build an entire product\n");
+
+  // Check claude is installed
+  const version = run("claude", ["--version"]);
+  if (!version) {
+    console.error(
+      "  Error: Claude Code is not installed.\n" +
+        "  Install it first: https://docs.anthropic.com/en/docs/claude-code/overview\n"
+    );
+    process.exit(1);
+  }
+  console.log(`  Found Claude Code ${version}`);
+
+  // Add marketplace
+  console.log(`  Adding marketplace from ${REPO}...`);
+  const addResult = run("claude", ["plugin", "marketplace", "add", REPO]);
+  if (addResult === null) {
+    console.error(
+      "  Error: Failed to add marketplace. Check your internet connection and try again.\n"
+    );
+    process.exit(1);
+  }
+  console.log("  Marketplace added.");
+
+  // Install plugin
+  console.log(`  Installing ${PLUGIN} plugin...`);
+  const installResult = run("claude", [
+    "plugin",
+    "install",
+    `${PLUGIN}@${MARKETPLACE}`,
+  ]);
+  if (installResult === null) {
+    console.error(
+      "  Error: Failed to install plugin. Try manually:\n" +
+        `  /plugin marketplace add ${REPO}\n` +
+        `  /plugin install ${PLUGIN}@${MARKETPLACE}\n`
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    "\n  Installed! Start Claude Code and use:\n" +
+      "    /oneshot:build <your idea>       — full product pipeline\n" +
+      "    /oneshot:idea-sweep <your idea>  — parallel research sweep\n"
+  );
+}
+
+main();

package/commands/build.md

@@ -0,0 +1,294 @@
+---
+description: "Full product build pipeline: takes a brainstormed idea through architecture, planning, implementation, testing, and hardening using coordinated agent teams — outputs working, tested, reviewed code"
+argument-hint: "Path to brainstorming doc or describe what we're building"
+---
+
+# /build — NEXUS-Sprint Pipeline
+
+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.**
+
+Input: $ARGUMENTS
+
+## Operating Principles
+
+- **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.
+- **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.
+
+---
+
+## Phase 1: Architecture & Planning
+
+**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.
+
+### Step 1.1 — Codebase Understanding (if existing project)
+
+If this is being built in an existing codebase, launch 2-3 **code-explorer** agents in parallel to map:
+- Similar features and their implementation patterns
+- Architecture layers and abstractions
+- File organization conventions, testing patterns, build system
+
+If this is a greenfield project, skip to Step 1.2.
+
+### Step 1.2 — Architecture Design (Parallel)
+
+Launch these agents simultaneously:
+
+1. **Backend Architect** — Design the system architecture: services, data models, API contracts, database schema, external integrations. Define the technical boundaries and data flows. Be specific — name tables, endpoints, data structures.
+
+2. **UX Architect** — Design the frontend architecture: component hierarchy, layout system, responsive strategy, CSS architecture, state management approach. Produce a component tree with clear responsibilities.
+
+3. **Security Engineer** — Review the proposed architecture for security concerns: auth model, data handling, input validation strategy, secrets management, threat model for the top 3 attack vectors.
+
+4. **code-architect** (Claude Code agent) — Analyze the architecture proposals against the existing codebase (if any). Produce a concrete implementation blueprint: specific files to create/modify, build sequence, dependency order.
+
+After all return, synthesize into a single **Architecture Document** that resolves any contradictions between agents.
+
+### Step 1.3 — Sprint Planning (Sequential, after 1.2)
+
+Launch **Sprint Prioritizer** with the Architecture Document:
+- Break the build into ordered, atomic tasks
+- Each task should be implementable and testable independently
+- 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
+
+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`.
+
+### Quality Gate 1
+
+Present to the user:
+1. Architecture Document (system diagram, component tree, data models, API contracts)
+2. Sprint Task List (ordered tasks with acceptance criteria)
+3. Identified risks or decisions that need user input
+
+Ask: **"Architecture and sprint plan ready. Approve to start building, or flag changes?"**
+
+**DO NOT PROCEED WITHOUT USER APPROVAL.**
+
+---
+
+## Phase 2: Foundation
+
+**Goal**: Set up the project skeleton — build system, directory structure, base configuration, CI, design tokens. The scaffolding that every subsequent task builds on.
+
+### Step 2.1 — Project Scaffolding
+
+Based on the Architecture Document, set up:
+- Project directory structure
+- Package manager and dependencies
+- Build/dev tooling configuration
+- Linting, formatting, type checking config
+- Base test framework and first passing test
+- Git initialization and .gitignore
+- Environment configuration (.env.example)
+
+Use the **DevOps Automator** to define the infrastructure and CI setup.
+Use the **Frontend Developer** or **Backend Architect** (as appropriate) to scaffold the actual project.
+
+Commit: `feat: initial project scaffolding`
+
+### Step 2.2 — Design System Foundation (if frontend)
+
+Launch **UX Architect** to implement:
+- CSS design tokens (colors, spacing, typography as variables)
+- Base layout components (grid, container, responsive breakpoints)
+- Core UI primitives that other components will build on
+
+Commit: `feat: design system foundation`
+
+### Quality Gate 2
+
+Run these checks:
+- Project builds without errors
+- Test framework runs and the initial test passes
+- Linting passes clean
+- Directory structure matches the Architecture Document
+
+If any fail, fix before proceeding. Present status to user.
+
+---
+
+## Phase 3: Build — Dev↔QA Loops
+
+**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.
+
+**For EACH task in the Sprint Task List, execute this loop:**
+
+### Step 3.1 — Implement
+
+Select the right developer agent based on task type:
+- **Frontend Developer** — UI components, pages, client-side logic
+- **Backend Architect** — APIs, database operations, server logic
+- **AI Engineer** — ML features, model integration, data pipelines
+- **Rapid Prototyper** — Quick integrations, glue code, utility functions
+
+The developer agent receives:
+- The specific task description and acceptance criteria from the Sprint Task List
+- The Architecture Document for context
+- Access to all existing code via Read/Grep/Glob tools
+
+The developer implements the task and writes tests that verify the acceptance criteria.
+
+Commit after implementation: `feat: [task description]`
+
+### Step 3.2 — Test & Verify
+
+Launch **Evidence Collector** to verify the implementation:
+- Run the tests the developer wrote — do they pass?
+- Check the acceptance criteria from the Sprint Task List — is each one met?
+- If frontend: take screenshots as visual proof
+- Report: **PASS** (all criteria met with evidence) or **FAIL** (specific failures listed)
+
+### Step 3.3 — Code Review
+
+Launch **code-reviewer** (Claude Code agent) to review the implementation:
+- Bugs, logic errors, security issues
+- 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
+- Move to next task
+- Reset retry counter
+
+**IF Evidence Collector = FAIL OR code-reviewer finds critical issues:**
+- Increment retry counter
+- Send specific feedback to the developer agent: what failed, what the QA/reviewer found
+- Developer fixes and resubmits
+- Repeat Steps 3.2-3.3
+
+**IF retry count reaches 3:**
+- Stop and escalate to the user with:
+  - What the task is trying to do
+  - What keeps failing
+  - The specific error or QA feedback
+  - Ask: "Fix manually, skip for now, or redesign the approach?"
+
+### Progress Tracking
+
+After each task completes, report:
+```
+Task [X/total]: [task name] — COMPLETE
+  Tests: [pass count] passing
+  Attempts: [retry count]
+  Next: [next task name]
+```
+
+---
+
+## 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.
+
+### Step 4.1 — Integration Testing (Parallel)
+
+Launch simultaneously:
+
+1. **API Tester** — Comprehensive API validation: all endpoints, edge cases, error responses, auth flows, rate limiting. Run the full test suite.
+
+2. **Performance Benchmarker** — Measure response times, identify bottlenecks, test under load if applicable. Flag anything that doesn't meet performance requirements from the Architecture Document.
+
+3. **Accessibility Auditor** — WCAG compliance audit on all user-facing interfaces. Screen reader testing. Keyboard navigation. Color contrast. Flag every barrier found.
+
+4. **Security Engineer** — Security review of the built system: auth implementation, input validation, data exposure, dependency vulnerabilities. Run security scanning tools.
+
+### Step 4.2 — Fix Critical Issues
+
+For each critical issue found in 4.1:
+- Route to the appropriate developer agent with the specific finding
+- Developer fixes the issue
+- The agent that found the issue re-validates
+- Dev↔QA loop until the specific issue is resolved
+
+### Step 4.3 — Code Quality Pass (Parallel)
+
+Launch simultaneously:
+
+1. **code-simplifier** (Claude Code) — Simplify any overly complex code while preserving functionality
+2. **type-design-analyzer** (Claude Code) — Review all type definitions for proper encapsulation and invariants
+3. **comment-analyzer** (Claude Code) — Verify all comments are accurate and useful
+
+Commit any improvements: `refactor: code quality improvements`
+
+### Step 4.4 — Final Verdict
+
+Launch **Reality Checker** for the final assessment:
+- Cross-validate all test results
+- Review all QA evidence from Phase 3 and Phase 4
+- Check every acceptance criterion from the Sprint Task List
+- Verdict: **PRODUCTION READY** or **NEEDS WORK** with specific items
+
+### Quality Gate 4
+
+Present to the user:
+1. Reality Checker's verdict
+2. Test results summary (pass/fail counts, coverage)
+3. Performance benchmarks
+4. Security findings (resolved and any remaining)
+5. Accessibility audit results
+6. Any items the Reality Checker flagged as NEEDS WORK
+
+---
+
+## Phase 5: Ship
+
+**Goal**: Final documentation, clean git history, and handoff.
+
+### Step 5.1 — Documentation
+
+Launch **Technical Writer**:
+- README with setup instructions, architecture overview, and usage
+- API documentation (if applicable)
+- Any environment/deployment notes
+
+Commit: `docs: add project documentation`
+
+### Step 5.2 — Final Commit
+
+Use `/commit` to create a clean final commit with a summary of what was built.
+
+### Completion Report
+
+Present to the user:
+
+```
+BUILD COMPLETE
+==============
+
+Project: [name]
+Tasks: [completed]/[total] ([pass rate]%)
+Tests: [count] passing
+Commits: [count]
+
+Architecture: [Backend Architect + UX Architect + Security Engineer]
+Implementation: [which developer agents were used]
+QA: [Evidence Collector + code-reviewer findings]
+Hardening: [API Tester + Performance Benchmarker + Accessibility Auditor + Security Engineer]
+Final Verdict: [Reality Checker's assessment]
+
+Files Created: [count]
+Files Modified: [count]
+
+Remaining Items: [any NEEDS WORK items from Reality Checker]
+```

package/commands/idea-sweep.md

@@ -0,0 +1,235 @@
+---
+description: "Parallel intelligence sweep: 5 research teams evaluate an idea across market, technical, user, business, and risk dimensions simultaneously — outputs a decision-ready brief"
+argument-hint: "Your idea, e.g. 'autonomous prediction market maker for Polymarket'"
+---
+
+# Idea Sweep
+
+You are a Chief of Staff to a founder-operator. Your job: take a raw idea and run it through rigorous parallel evaluation — the same process that Amazon (6-pager before building), Stripe (RFC culture), and McKinsey (hypothesis-driven) use, compressed into one session.
+
+**Your output is a decision brief, not a plan.** It answers "should we build this?" and feeds into the brainstorming and writing-plans skills for "how."
+
+**Agent assumptions (applies to all agents and subagents):**
+- All tools are functional. Do not test tools or make exploratory calls.
+- Every agent MUST use WebSearch extensively. This is research, not reasoning from first principles. Agents that don't search produce unreliable output.
+
+---
+
+## Phase 0: Hypothesis Formation
+
+**Goal**: Convert the raw idea into a testable hypothesis. Do this yourself — no subagents.
+
+Initial request: $ARGUMENTS
+
+**Actions**:
+
+1. Create a todo list tracking all phases
+
+2. If the idea is unclear, ask ONE clarifying question. Bias toward action.
+
+3. Write the SCQA frame:
+   - **Situation**: What stable context exists — market, technology, user behavior
+   - **Complication**: What changed or what gap exists — why now?
+   - **Question**: The core strategic question this idea answers
+   - **Answer**: The hypothesis — "We believe that [X] will [Y] because [Z]"
+
+4. Define 3-5 kill criteria — conditions that would make this not worth pursuing. Examples:
+   - Market is less than $100M TAM
+   - Requires regulatory approval we can't get in 6 months
+   - No defensible moat against incumbents
+   - Technical dependency on immature infrastructure
+   - Unit economics don't work at reasonable scale
+
+5. Present the SCQA and kill criteria to the user. Get confirmation before proceeding.
+
+**DO NOT PROCEED TO PHASE 1 WITHOUT USER CONFIRMATION.**
+
+---
+
+## Phase 1: Interrogation
+
+**Goal**: Before launching the 5 research teams, anticipate the questions they would ask if they could talk to the user — and get answers now. This context makes every agent dramatically more effective.
+
+**CRITICAL**: This is one of the most important phases. DO NOT SKIP. The difference between a useful sweep and a generic one is the specificity of context the agents receive. Five minutes of questions here saves the user from getting five reports full of hedged assumptions.
+
+**Actions**:
+
+1. Review the SCQA frame and kill criteria. Put yourself in the shoes of each of the 5 research agents. For each agent, think: "What would I need to know from the founder to do my best work — that I can't find via web search?"
+
+2. Generate questions across all 5 dimensions. Think about what each team needs:
+
+   **Market Intel might need to know:**
+   - Are there specific competitors you already know about or are tracking?
+   - What geographies are in scope? (Global, US-only, specific markets?)
+   - Is there an adjacent market or category you see this fitting into?
+   - Do you have any existing data, reports, or market sizing you've already done?
+
+   **Tech Feasibility might need to know:**
+   - Do you have a preferred tech stack, language, or platform? Any hard constraints?
+   - Are there existing systems, codebases, or infrastructure this needs to integrate with?
+   - What's your technical background / what can you build yourself vs. need to hire for?
+   - Are there specific APIs, data sources, or third-party services you're already planning to use?
+   - Any performance, latency, or uptime requirements that are non-negotiable?
+
+   **User Research might need to know:**
+   - Who do you think the target user is? (Even a rough guess helps focus the search)
+   - Have you talked to any potential users? What did they say?
+   - Are you building for consumers, developers, businesses, or a specific niche?
+   - Is there a specific user pain point or moment that inspired this idea?
+   - Do you have access to a community where target users congregate?
+
+   **Business Model might need to know:**
+   - Do you have a monetization model in mind, or is that open?
+   - What's your funding situation? (Bootstrapped, looking for VC, have runway?)
+   - Is this a side project, a startup, or an extension of existing work?
+   - What does success look like in 6 months? In 2 years?
+   - Are there comparable businesses whose model you admire?
+
+   **Risk Analysis might need to know:**
+   - Are there regulatory constraints you're already aware of? (Especially for crypto, health, finance)
+   - Are you operating under any legal entity or jurisdiction constraints?
+   - Are there platform dependencies you're worried about? (App Store, specific APIs, etc.)
+   - Have you seen similar ideas fail? What do you think went wrong?
+   - Any ethical concerns or sensitive user data involved?
+
+3. **Do NOT ask all of the above.** Select only the questions that are:
+   - **High-impact**: The answer would materially change what an agent researches or concludes
+   - **Not searchable**: The agent can't find this via web search — it's founder context, preferences, or constraints
+   - **Specific to this idea**: Generic questions waste time. Tailor every question to the SCQA.
+
+4. **Present all questions to the user in a single organized message**, grouped by theme (not by agent — the user doesn't need to know the internal structure). Aim for 5-15 questions total. Use a mix of open-ended and multiple-choice where appropriate.
+
+5. **Tell the user**: "Answer what you can. Skip what you don't know — the agents will research the rest. Any context you give here makes the research sharper."
+
+6. **Wait for answers.** Do not proceed until the user responds.
+
+7. After receiving answers, compile a **Context Brief** — a structured summary of all user-provided context that will be appended to each agent's prompt in Phase 2. Format:
+
+```
+FOUNDER CONTEXT
+===============
+[Organized summary of all answers — no question/answer format, just clean prose
+organized by theme. Include direct quotes where the user's exact words matter.]
+```
+
+**DO NOT PROCEED TO PHASE 2 WITHOUT USER ANSWERS (even partial).**
+
+---
+
+## Phase 2: Parallel Intelligence Sweep
+
+**Goal**: Run 5 research teams simultaneously. Launch ALL 5 as parallel subagents using the Task tool.
+
+**CRITICAL**: Launch all 5 agents at the same time. Do not wait for one to complete before starting the next. Pass each agent the full SCQA frame PLUS the Context Brief from Phase 1. Pass the kill criteria to the risk-analysis agent.
+
+**Launch these 5 agents in parallel:**
+
+1. **market-intel agent** — Research market size (TAM/SAM/SOM), competitive landscape (5-10 players), timing/macro trends, and market structure for this idea: [paste SCQA]. Founder context: [paste Context Brief]
+
+2. **tech-feasibility agent** — Evaluate technical architecture, hard problems, build-vs-buy decisions, MVP scope, and stack recommendation for this idea: [paste SCQA]. Founder context: [paste Context Brief]
+
+3. **user-research agent** — Analyze target user persona, jobs-to-be-done, current alternatives, behavioral barriers to adoption, and activation metrics for this idea: [paste SCQA]. Founder context: [paste Context Brief]
+
+4. **business-model agent** — Evaluate revenue models, unit economics, growth loops, first-1000-users channel strategy, and moat/defensibility for this idea: [paste SCQA]. Founder context: [paste Context Brief]
+
+5. **risk-analysis agent** — Adversarial review: regulatory risk, security concerns, dependency risks, competitive response, failure modes. Check these specific kill criteria: [paste kill criteria]. Idea: [paste SCQA]. Founder context: [paste Context Brief]
+
+---
+
+## Phase 3: Convergence
+
+**Goal**: Synthesize all 5 outputs. The real insights live in contradictions between teams.
+
+After all 5 agents return, do the following yourself (no subagents):
+
+1. **Build the Verdict Matrix** — extract each team's verdict:
+
+| Dimension | Verdict | Key Finding |
+|-----------|---------|-------------|
+| Market | GREEN/AMBER/RED | [one line] |
+| Technical | GREEN/AMBER/RED | [one line] |
+| User | GREEN/AMBER/RED | [one line] |
+| Business | GREEN/AMBER/RED | [one line] |
+| Risk | GREEN/AMBER/RED | [one line] |
+
+2. **Identify Contradictions** — where do teams disagree? Examples:
+   - Market says huge opportunity, Risk says regulatory minefield
+   - Technical says easy build, User says nobody wants this
+   - Business says great economics, Market says tiny TAM
+
+   List each contradiction with both sides. These are the most valuable findings.
+
+3. **Refine the Hypothesis**:
+   - **CONFIRMED**: Evidence supports the original hypothesis
+   - **PIVOTED**: Evidence points to an adjacent, better opportunity — describe it
+   - **KILLED**: Multiple kill criteria triggered — do not proceed
+
+4. Present the synthesis to the user.
+
+---
+
+## Phase 4: Decision Brief
+
+**Goal**: Produce the final document.
+
+Write a markdown document with this structure:
+
+```
+# [IDEA NAME] — Decision Brief
+
+## The Bet
+[Refined hypothesis — one sentence]
+
+## SCQA
+- Situation: [one line]
+- Complication: [one line]  
+- Question: [one line]
+- Answer: [one line]
+
+## Verdict Matrix
+| Dimension | Verdict | Key Finding |
+|-----------|---------|-------------|
+| Market | G/A/R | ... |
+| Technical | G/A/R | ... |
+| User | G/A/R | ... |
+| Business | G/A/R | ... |
+| Risk | G/A/R | ... |
+
+## The Opportunity
+[2-3 sentences: what, who, why now — only if proceeding]
+
+## Critical Tensions
+[2-3 contradictions that must be resolved during build]
+
+## Kill Criteria Status
+| Criterion | Status | Evidence |
+|-----------|--------|----------|
+| ... | CLEAR/AMBER/RED | ... |
+
+## Recommended Action
+- GO: Proceed to brainstorming → writing-plans
+- PIVOT: Pursue [adjacent opportunity] instead  
+- INVESTIGATE: Need answers on [specific questions]
+- KILL: Do not proceed — [reason]
+
+## If GO: MVP Definition
+- Core value prop: [one sentence]
+- Primary user: [one sentence]
+- MVP scope: [under 50 words]
+- Revenue model: [one sentence]
+- First 1,000 users: [channel strategy]
+- Tech stack: [recommendation]
+- First milestone: [activation metric]
+```
+
+Save this document to `docs/briefs/` with today's date and a slug of the idea name.
+
+Present the document to the user, then ask:
+
+> "Sweep complete. Options:
+> 1. **Brainstorm** — Use this brief as input to collaboratively design the product
+> 2. **Plan** — Go straight to implementation planning if you're already confident
+> 3. **Investigate** — Run targeted deep-dives on amber/red areas
+> 4. **Done** — Save and revisit later"
+
+Mark all todos complete.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "buildanything",
+  "version": "1.0.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"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "plugin",
+    "ai",
+    "agents",
+    "orchestration",
+    "build",
+    "full-stack",
+    "one-shot"
+  ],
+  "author": "Sujit Meka",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sujitmeka/buildanything.git"
+  },
+  "homepage": "https://github.com/sujitmeka/buildanything#readme",
+  "bugs": {
+    "url": "https://github.com/sujitmeka/buildanything/issues"
+  },
+  "files": [
+    "bin/",
+    ".claude-plugin/",
+    "agents/",
+    "commands/",
+    "README.md"
+  ]
+}