thgaskell · February 7, 2026 05:44
diff --git a/README.md b/README.md
diff --git a/agent-loop.yml b/agent-loop.yml
 name: agent-loop
 description: Simple task → plan → implement → verify loop with retry on failure

 # ┌─────────────────────────────────────────────────────┐
 # │  Task → Plan → Implement → Verify (loop on failure) │
 # └─────────────────────────────────────────────────────┘
 diagram: |
  graph TD
    A[task_intake] --> B[plan]
    B --> C[implement]
    C --> D[run_tests]
    C --> E[code_review]
    D --> F{verify}
    E --> F
    F -->|PASS| G[report]
    F -->|FAIL| B

 agents:
  code-reviewer:
    instructions: |
      You are a thorough code reviewer. Compare the implementation against the plan
      and verify that all requirements are met.

      For each requirement in the plan, check:
      1. Is it implemented correctly?
      2. Are there edge cases missed?
      3. Is the code clean and follows project conventions?

      Your output MUST end with one of:
      - VERDICT: PASS — all requirements met, code is correct
      - VERDICT: FAIL — list what needs to be fixed
    tools: [Read, Grep, Glob]
    model: sonnet

 inputs:
  - name: task
    description: Description of the coding task (feature, bug fix, refactor, etc.)
    required: true
  - name: path
    description: Path to the relevant code or project root
    default: "."
  - name: max_retries
    description: Maximum number of plan→implement→verify retry cycles
    default: 3

 steps:
  # Step 1: Understand the task and codebase context
  task_intake:
    agent: Explore
    model: haiku
    prompt: |
      Explore the codebase at {{input.path}} to understand the project context
      for the following task:

      {{input.task}}

      Identify:
      - Project structure, language, and framework
      - Files most relevant to the task
      - Existing patterns and conventions
      - Any tests or test infrastructure present

  # Step 2: Create an implementation plan
  plan:
    agent: Plan
    depends_on: [task_intake]
    prompt: |
      Create a clear, actionable implementation plan for the following task.

      Task:
      {{input.task}}

      Codebase context:
      {{task_intake.output}}

      {{verify.output}}

      Your plan MUST include:
      1. Summary of changes needed
      2. Specific files to create or modify
      3. Step-by-step implementation approach
      4. Expected behavior after implementation
      5. How to verify correctness (test cases to add/run)

  # Step 3: Execute the plan
  implement:
    agent: general-purpose
    depends_on: [plan]
    prompt: |
      Implement the changes described in the plan below.

      Plan:
      {{plan.output}}

      Requirements:
      - Follow existing code style and conventions
      - Add or update tests as specified in the plan
      - Make only the changes described — do not over-engineer

  # Step 4a: Run the test suite
  run_tests:
    agent: Bash
    depends_on: [implement]
    prompt: |
      Run the project's test suite to verify the implementation.

      Detect the project type and run the appropriate test command:
      - Node.js: npm test or npx jest
      - Python: pytest or python -m pytest
      - Go: go test ./...
      - Rust: cargo test
      - Or check for a Makefile / package.json scripts

      Report the full test output including pass/fail counts.
      If no test infrastructure exists, note that and report PASS.

  # Step 4b: Review the code against the plan
  code_review:
    agent: code-reviewer
    depends_on: [implement]
    prompt: |
      Review the implementation against the original plan.

      Task:
      {{input.task}}

      Plan:
      {{plan.output}}

      Read the files that were changed and verify the implementation
      is correct, complete, and follows the plan.

  # Step 5: Evaluate results and decide pass/fail
  verify:
    agent: general-purpose
    model: haiku
    depends_on: [run_tests, code_review]
    prompt: |
      Evaluate the test results and code review to determine if the
      implementation is complete and correct.

      Test results:
      {{run_tests.output}}

      Code review:
      {{code_review.output}}

      If ALL of the following are true, output VERDICT: PASS
      - Tests pass (or no test failures introduced)
      - Code review found no critical issues

      Otherwise, output VERDICT: FAIL and list the specific issues
      that need to be addressed in the next iteration.

      You MUST output exactly one of:
      - VERDICT: PASS
      - VERDICT: FAIL
    on_failure:
      goto: plan
      max_retries: "{{input.max_retries}}"

  # Step 6: Final summary (only reached on PASS)
  report:
    agent: general-purpose
    model: haiku
    depends_on: [verify]
    condition: "{{verify.output}} contains 'VERDICT: PASS'"
    prompt: |
      Write a brief summary of what was accomplished.

      Task:
      {{input.task}}

      Plan:
      {{plan.output}}

      Test results:
      {{run_tests.output}}

      Code review:
      {{code_review.output}}

      Format:
      - What was done (1-3 bullet points)
      - Files changed
      - Test status
diff --git a/team-workflow.md b/team-workflow.md
Field	Required	Description
`name`	Yes	Workflow identifier
`description`	No	Human-readable description
`diagram`	No	Mermaid diagram for visualization (also reinforces flow for the model)
`agents`	No	Reusable custom agent templates
`inputs`	No	Declared inputs with names, descriptions, defaults
`steps`	Yes	The workflow steps to execute
Field	Required	Description
`agent`	Yes	Agent to use (see Agent Resolution below)
`prompt`	Yes	The task prompt, supports `{{variable}}` interpolation
`depends_on`	No	List of step names that must complete first
`condition`	No	Expression that must be true for step to run
`join`	No	`all` (default) or `any` — when to unblock with multiple dependencies
`model`	No	Model override: `haiku`, `sonnet`, or `opus`
`on_failure`	No	Retry configuration (see Retry Loops below)
Agent spec	What happens
`Explore`, `Plan`, `Bash`, `general-purpose`	Uses that agent type directly
`auto`	Auto-selects based on prompt keywords (explore → Explore, test → Bash, etc.)
`agent-name`	Looks up in `agents:` section, prepends instructions to prompt
Inline `{instructions:, tools:, model:}`	Creates an ephemeral one-off agent
Pattern	Resolves to
`{{input.name}}`	Value from workflow inputs or defaults
`{{input.task}}`	The task description from the command invocation
`{{step_name.output}}`	Output from a completed step
	name: agent-loop
	description: Simple task → plan → implement → verify loop with retry on failure

	# ┌─────────────────────────────────────────────────────┐
	# │ Task → Plan → Implement → Verify (loop on failure) │
	# └─────────────────────────────────────────────────────┘
	diagram: \|
	graph TD
	A[task_intake] --> B[plan]
	B --> C[implement]
	C --> D[run_tests]
	C --> E[code_review]
	D --> F{verify}
	E --> F
	F -->\|PASS\| G[report]
	F -->\|FAIL\| B

	agents:
	code-reviewer:
	instructions: \|
	You are a thorough code reviewer. Compare the implementation against the plan
	and verify that all requirements are met.

	For each requirement in the plan, check:
	1. Is it implemented correctly?
	2. Are there edge cases missed?
	3. Is the code clean and follows project conventions?

	Your output MUST end with one of:
	- VERDICT: PASS — all requirements met, code is correct
	- VERDICT: FAIL — list what needs to be fixed
	tools: [Read, Grep, Glob]
	model: sonnet

	inputs:
	- name: task
	description: Description of the coding task (feature, bug fix, refactor, etc.)
	required: true
	- name: path
	description: Path to the relevant code or project root
	default: "."
	- name: max_retries
	description: Maximum number of plan→implement→verify retry cycles
	default: 3

	steps:
	# Step 1: Understand the task and codebase context
	task_intake:
	agent: Explore
	model: haiku
	prompt: \|
	Explore the codebase at {{input.path}} to understand the project context
	for the following task:

	{{input.task}}

	Identify:
	- Project structure, language, and framework
	- Files most relevant to the task
	- Existing patterns and conventions
	- Any tests or test infrastructure present

	# Step 2: Create an implementation plan
	plan:
	agent: Plan
	depends_on: [task_intake]
	prompt: \|
	Create a clear, actionable implementation plan for the following task.

	Task:
	{{input.task}}

	Codebase context:
	{{task_intake.output}}

	{{verify.output}}

	Your plan MUST include:
	1. Summary of changes needed
	2. Specific files to create or modify
	3. Step-by-step implementation approach
	4. Expected behavior after implementation
	5. How to verify correctness (test cases to add/run)

	# Step 3: Execute the plan
	implement:
	agent: general-purpose
	depends_on: [plan]
	prompt: \|
	Implement the changes described in the plan below.

	Plan:
	{{plan.output}}

	Requirements:
	- Follow existing code style and conventions
	- Add or update tests as specified in the plan
	- Make only the changes described — do not over-engineer

	# Step 4a: Run the test suite
	run_tests:
	agent: Bash
	depends_on: [implement]
	prompt: \|
	Run the project's test suite to verify the implementation.

	Detect the project type and run the appropriate test command:
	- Node.js: npm test or npx jest
	- Python: pytest or python -m pytest
	- Go: go test ./...
	- Rust: cargo test
	- Or check for a Makefile / package.json scripts

	Report the full test output including pass/fail counts.
	If no test infrastructure exists, note that and report PASS.

	# Step 4b: Review the code against the plan
	code_review:
	agent: code-reviewer
	depends_on: [implement]
	prompt: \|
	Review the implementation against the original plan.

	Task:
	{{input.task}}

	Plan:
	{{plan.output}}

	Read the files that were changed and verify the implementation
	is correct, complete, and follows the plan.

	# Step 5: Evaluate results and decide pass/fail
	verify:
	agent: general-purpose
	model: haiku
	depends_on: [run_tests, code_review]
	prompt: \|
	Evaluate the test results and code review to determine if the
	implementation is complete and correct.

	Test results:
	{{run_tests.output}}

	Code review:
	{{code_review.output}}

	If ALL of the following are true, output VERDICT: PASS
	- Tests pass (or no test failures introduced)
	- Code review found no critical issues

	Otherwise, output VERDICT: FAIL and list the specific issues
	that need to be addressed in the next iteration.

	You MUST output exactly one of:
	- VERDICT: PASS
	- VERDICT: FAIL
	on_failure:
	goto: plan
	max_retries: "{{input.max_retries}}"

	# Step 6: Final summary (only reached on PASS)
	report:
	agent: general-purpose
	model: haiku
	depends_on: [verify]
	condition: "{{verify.output}} contains 'VERDICT: PASS'"
	prompt: \|
	Write a brief summary of what was accomplished.

	Task:
	{{input.task}}

	Plan:
	{{plan.output}}

	Test results:
	{{run_tests.output}}

	Code review:
	{{code_review.output}}

	Format:
	- What was done (1-3 bullet points)
	- Files changed
	- Test status
Pattern	Replacement
`{{input.task}}`	The user's task prompt
`{{input.<name>}}`	Named input value (from workflow inputs + defaults)
`{{<step>.output}}`	Stored output from completed step