TL Dispatches Workers to Build

Model Tiers

TL authority on code: TL may fix trivial presentation issues inline (e.g. add a missing data-testid attribute to an HTML element, correct an import order). TL may NOT write new logic, new methods, new tests, or multi-line implementation — that is dr-dobbs work. When in doubt: dispatch a worker.

Worker isolation: Each worker operates on the shared iteration branch. Workers with overlapping footprint[] files are serialized by the conflict_map (already computed by PIN). Do not dispatch workers that share files in the same parallel slot. Workers must commit their own footprint before posting NODE_PASS to prevent dirty-tree races.

Step 1: Verify Iteration Branch Is Checked Out

git branch --show-current   # must match iteration/{milestone-slug}
git status                  # must be clean before any dispatch

If dirty: do not dispatch. Identify and commit or stash uncommitted changes from a prior session.

Step 2: Pick the Next READY Issue

From the execution queue (MIN-02), select the next READY scenario respecting group order A → B → C and conflict_map constraints.

Claim:

gh issue edit {N} --add-label "status-in-progress" --remove-label "status-queued"
gh issue comment {N} --body "<!-- EXECUTION_START -->\nStarted: {ISO8601}\nBranch: iteration/{slug}\n<!-- /EXECUTION_START -->"

Step 3: Read the Feature Execution Graph

gh issue view {N} --json number,title,body,labels

Parse <!-- FEATURE_EXECUTION_GRAPH --> from issue body. Extract all nodes and identify the first ready nodes (no depends_on, or all deps already NODE_PASS).

Step 4: Dispatch Worker Subagents (one per ready node)

For each ready node, assemble the dr-dobbs task prompt.

Commit type mapping (use as {bpe_type} in the commit message below):
| Node bpe value | Commit type |
|-----------------|-------------|
| BPE-02, BPE-03 | feat |
| BPE-04, BPE-05 | test |
| BPE-06 | chore |

The prompt must include an explicit commit step:

You are dr-dobbs — cheap-fast implementation worker on iteration branch: iteration/{slug}.
Implement ONLY node {node_id} for issue #{N}.

1. Confirm you are on the correct branch:
   git branch --show-current   # must be iteration/{slug}
2. Read the issue: gh issue view {N} --json number,title,body,labels
3. Assemble guidance bundle per skill "Assemble Guidance Bundle" for this node.
4. Implement only footprint[]: {footprint_list}
   - Fill raise NotImplementedError() stubs. Do NOT change method signatures.
   - If new models: run makemigrations && migrate before gate.
5. Run gate: {gate.command}
   {gate.log_story_command if declared}
6. If gate PASS:
   a. git add {footprint_files}
   b. git commit -m "{bpe_type}({scope}): {node_id} — {issue_title} (#{N})"
      (bpe_type: feat for BPE-02/03, test for BPE-04/05, chore for BPE-06)
   c. Post NODE_PASS:
      <!-- NODE_PASS -->
      node: {node_id}
      gate: {command} — exit 0
      commit: {sha}
      <!-- /NODE_PASS -->
   d. Stop. Do not continue to the next node.
7. If gate FAIL: one targeted fix, retry gate once.
   PASS → commit and NODE_PASS as above.
   FAIL → post NODE_FAIL (with error excerpt) and stop.

Do NOT: change signatures, touch files outside footprint[], create files not in skeleton, pick up another node.

Launch as a fresh Task subagent (cheap-fast model). Never resume a prior worker.

Step 5: Monitor and Advance the Node Graph

On NODE_PASS: confirm the commit SHA is present in the comment. Check which nodes are newly unblocked; dispatch workers. Continue until all nodes show NODE_PASS.

On NODE_FAIL (after worker's internal retry): post absorbed drift comment; dispatch one TL-guided targeted fix subagent. If that also fails: escalate with drift-escalated label.

On footprint violation: escalate immediately.

Step 6: Handoff to MIN-04

gh issue comment {N} --body "<!-- BUILD_COMPLETE -->\nAll nodes NODE_PASS.\nBranch: iteration/{slug}\nReady for: MIN-04\n<!-- /BUILD_COMPLETE -->"

Begin MIN-04 for this issue. Parallel scenarios: MIN-04 may process one while MIN-03 dispatches nodes for another, provided they don't share files.

Drift Table

Success Criteria

• Iteration branch confirmed clean before any dispatch
• TL wrote no feature implementation code
• Every worker committed its footprint files before posting NODE_PASS
• Each NODE_PASS comment contains a commit SHA
• Parallel nodes dispatched only where conflict_map allows (no file overlap)
• All issues have BUILD_COMPLETE comment

Agent

dr-dobbs (Worker) — cheap-fast model. One node per invocation. Fills NotImplementedError stubs in declared footprint[]. Commits footprint. Runs gate. Posts NODE_PASS with SHA. Stops.
Team Lead (Orchestrator) — advanced reasoning model. Reads queue, dispatches, reviews NODE_PASS commits, handles drift. No feature code.

Skill

• Assemble Guidance Bundle
• Pytest Log Story Assertions (when log_story_command declared)

Rules

do-skeletons-first, do-test-first, do-not-mock-in-integration-tests, do-informative-logging, do-assert-log-story, do-write-concise-methods, do-follow-commit-convention, do-small-increments, pytest