Let’s create ninja! sub-agent agile team

Idea  ->  Analyst  ->  PM  ->  Developer  ->  Tester  ->  Verdict
          brief.md    prd.md   code + notes    test report

bmad-lite/
  CLAUDE.md
  BmadLite.sln
  .claude/
    agents/        analyst.md  pm.md  developer.md  tester.md
    commands/      brief.md  prd.md  build.md  test.md
    settings.json
  .vscode/         tasks.json  launch.json  extensions.json
  src/BmadLite.Orchestrator/   the C# orchestrator
  samples/idea.md
  artifacts/       agent outputs land here
  workspace/       generated code lands here

# BMAD Lite Project Rules
## Rules for all agents
1. Stay in your role. Do not do the job of another agent.
2. Write your output artifact to `artifacts/` using the exact file name.
3. End every artifact with a `## Handoff` section (open questions, next agent).
4. Number requirements as FR-1, FR-2 so the tester can trace them.
5. Target stack for generated code is C# on .NET 8, under `workspace/`.
6. If input is missing or unclear, say so in `## Handoff` and stop.

---
name: analyst
description: Business analyst. Turns a raw idea into a short project brief. Use first.
tools: Read, Write, Glob, Grep
---
You are the Analyst in a condensed BMAD workflow.
Input: the idea file you are given (default `samples/idea.md`).
Output: `artifacts/01-brief.md`.
Sections: Problem, Target users, Goals, Scope (in and out),
Assumptions and risks, Handoff (next agent is `pm`).
Rules:
- Do not propose a technical design.
- Keep the brief under 60 lines.

---
name: pm
description: Product manager. Converts the brief into a PRD with numbered, testable requirements.
tools: Read, Write, Glob, Grep
---
You are the Product Manager in a condensed BMAD workflow.
Input: `artifacts/01-brief.md`. Output: `artifacts/02-prd.md`.
Sections: Summary, Functional requirements (FR-1...), Non functional
requirements (NFR-1...), Acceptance criteria (Given, When, Then),
Out of scope, Handoff (next agent is `developer`).
Rules:
- Every requirement must be testable without asking you.
- At most 8 functional requirements.

---
name: developer
description: Developer. Implements the PRD as a small C# on .NET 8 solution under workspace/.
tools: Read, Write, Edit, Glob, Grep, Bash
---
You are the Developer in a condensed BMAD workflow.
Input: `artifacts/02-prd.md`.
Output: code under `workspace/` and `artifacts/03-build-notes.md`.
Steps: implement each FR, reference the FR id in a short comment,
run `dotnet build` and fix errors, then write build notes with an
FR coverage table and a Handoff section (next agent is `tester`).
Rules:
- Never claim an FR is done if the build fails.

---
name: tester
description: Tester. Verifies the code against the PRD and reports pass or fail per requirement.
tools: Read, Write, Edit, Glob, Grep, Bash
---
You are the Tester in a condensed BMAD workflow.
Input: PRD, build notes, and code under `workspace/`.
Output: `artifacts/04-test-report.md`.
Steps: write or find automated tests for each FR and NFR, run
`dotnet test`, then report a table (requirement, test, result, evidence).
Rules:
- Do not fix production code. Report defects instead.
- Report only results you actually observed.
- End with exactly `VERDICT: PASS` or `VERDICT: FAIL`, then a Handoff section.

---
description: Run the analyst agent to create the project brief
argument-hint: [path to idea file]
---
Use the analyst subagent to read $ARGUMENTS (default `samples/idea.md`)
and write `artifacts/01-brief.md`. Report only the file path when done.

{
  "permissions": {
    "allow": [
      "Read",
      "Write(artifacts/**)",
      "Write(workspace/**)",
      "Edit(workspace/**)",
      "Bash(dotnet build:*)",
      "Bash(dotnet test:*)",
      "Bash(dotnet new:*)"
    ],
    "deny": [
      "Read(.env)",
      "Bash(rm -rf:*)"
    ]
  }
}

# Idea: Tip Splitter
A small .NET library and console app that splits a restaurant bill
among friends. It should handle a tip percentage, uneven shares,
and rounding so the total always matches.

/brief samples/idea.md
/prd
/build
/test

dotnet new sln -n BmadLite
dotnet new console -n BmadLite.Orchestrator -o src/BmadLite.Orchestrator
dotnet sln add src/BmadLite.Orchestrator

namespace BmadLite.Orchestrator;
public sealed record AgentStep(
    string Agent,
    string Prompt,
    string OutputArtifact,
    string[] RequiredInputs);
public static class Workflow
{
    public static IReadOnlyList<AgentStep> Build(string ideaPath) =>
    [
        new("analyst",
            $"Use the analyst subagent to read {ideaPath} and write artifacts/01-brief.md.",
            "artifacts/01-brief.md", [ideaPath]),
        new("pm",
            "Use the pm subagent to read artifacts/01-brief.md and write artifacts/02-prd.md.",
            "artifacts/02-prd.md", ["artifacts/01-brief.md"]),
        new("developer",
            "Use the developer subagent to read artifacts/02-prd.md, implement it under workspace/, and write artifacts/03-build-notes.md.",
            "artifacts/03-build-notes.md", ["artifacts/02-prd.md"]),
        new("tester",
            "Use the tester subagent to verify workspace/ against artifacts/02-prd.md and write artifacts/04-test-report.md.",
            "artifacts/04-test-report.md",
            ["artifacts/02-prd.md", "artifacts/03-build-notes.md"]),
    ];
}

using System.Diagnostics;
namespace BmadLite.Orchestrator;
public sealed record RunResult(int ExitCode, string Output, string Error);
public sealed class ClaudeRunner
{
    private readonly string _workingDirectory;
    private readonly bool _dryRun;
    public ClaudeRunner(string workingDirectory, bool dryRun)
    {
        _workingDirectory = workingDirectory;
        _dryRun = dryRun;
    }
    public async Task<RunResult> RunAsync(string prompt, CancellationToken ct = default)
    {
        if (_dryRun)
            return new RunResult(0, $"[dry run] claude -p \"{prompt}\"", string.Empty);
        var psi = new ProcessStartInfo
        {
            FileName = "claude",
            WorkingDirectory = _workingDirectory,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
        };
        psi.ArgumentList.Add("-p");
        psi.ArgumentList.Add(prompt);
        psi.ArgumentList.Add("--permission-mode");
        psi.ArgumentList.Add("acceptEdits");
        try
        {
            using var process = Process.Start(psi)
                ?? throw new InvalidOperationException("Could not start claude.");
            var stdout = process.StandardOutput.ReadToEndAsync(ct);
            var stderr = process.StandardError.ReadToEndAsync(ct);
            await process.WaitForExitAsync(ct);
            return new RunResult(process.ExitCode, await stdout, await stderr);
        }
        catch (System.ComponentModel.Win32Exception)
        {
            return new RunResult(127, string.Empty,
                "The 'claude' command was not found. Install Claude Code and add it to PATH.");
        }
    }
}

namespace BmadLite.Orchestrator;
public static class HandoffGate
{
    public static IReadOnlyList<string> CheckInputs(string root, AgentStep step)
    {
        var problems = new List<string>();
        foreach (var input in step.RequiredInputs)
        {
            var path = Path.Combine(root, input);
            if (!File.Exists(path)) problems.Add($"Missing input: {input}");
            else if (new FileInfo(path).Length == 0) problems.Add($"Empty input: {input}");
        }
        return problems;
    }
    public static IReadOnlyList<string> CheckOutput(string root, AgentStep step)
    {
        var problems = new List<string>();
        var path = Path.Combine(root, step.OutputArtifact);
        if (!File.Exists(path))
        {
            problems.Add($"Missing output: {step.OutputArtifact}");
            return problems;
        }
        var text = File.ReadAllText(path);
        if (!text.Contains("## Handoff", StringComparison.OrdinalIgnoreCase))
            problems.Add($"{step.OutputArtifact} has no '## Handoff' section.");
        if (step.Agent == "tester" &&
            !text.Contains("VERDICT: PASS") && !text.Contains("VERDICT: FAIL"))
            problems.Add("Test report has no VERDICT line.");
        return problems;
    }
    public static bool IsPass(string root, AgentStep step)
    {
        var path = Path.Combine(root, step.OutputArtifact);
        return File.Exists(path) && File.ReadAllText(path).Contains("VERDICT: PASS");
    }
}

var steps = Workflow.Build(idea);
for (var i = 0; i < steps.Count; i++)
{
    var step = steps[i];
    var inputProblems = HandoffGate.CheckInputs(root, step);
    if (inputProblems.Count > 0) return Fail(string.Join(Environment.NewLine, inputProblems));
    var result = await runner.RunAsync(step.Prompt);
    if (result.ExitCode != 0) return Fail($"{step.Agent} failed. {result.Error}");
    var outputProblems = HandoffGate.CheckOutput(root, step);
    if (outputProblems.Count > 0) return Fail(string.Join(Environment.NewLine, outputProblems));
    Console.WriteLine($"[{i + 1}/{steps.Count}] {step.Agent} OK: {step.OutputArtifact}");
}

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "build orchestrator",
      "type": "process",
      "command": "dotnet",
      "args": ["build", "${workspaceFolder}/BmadLite.sln"],
      "group": { "kind": "build", "isDefault": true },
      "problemMatcher": "$msCompile"
    },
    {
      "label": "dry run workflow",
      "type": "process",
      "command": "dotnet",
      "args": ["run", "--project", "${workspaceFolder}/src/BmadLite.Orchestrator",
               "--", "run", "samples/idea.md", "--dry-run"],
      "options": { "cwd": "${workspaceFolder}" },
      "problemMatcher": []
    },
    {
      "label": "run full workflow",
      "type": "process",
      "command": "dotnet",
      "args": ["run", "--project", "${workspaceFolder}/src/BmadLite.Orchestrator",
               "--", "run", "samples/idea.md"],
      "options": { "cwd": "${workspaceFolder}" },
      "dependsOn": ["build orchestrator"],
      "problemMatcher": []
    }
  ]
}

dotnet run --project src/BmadLite.Orchestrator -- run samples/idea.md --dry-run

[1/4] analyst
  [dry run] claude -p "Use the analyst subagent to read samples/idea.md and write artifacts/01-brief.md."
[2/4] pm
  [dry run] claude -p "Use the pm subagent to read artifacts/01-brief.md and write artifacts/02-prd.md."
[3/4] developer
  [dry run] claude -p "Use the developer subagent to read artifacts/02-prd.md, ..."
[4/4] tester
  [dry run] claude -p "Use the tester subagent to verify workspace/ against ..."
Workflow finished.

dotnet run --project src/BmadLite.Orchestrator -- run samples/idea.md