ADR-303: Rewrite implement-task as a per-component dispatcher, add implement-direct

[jodavis-claude]

Work item

ADR-303: Rewrite implement-task as a per-component dispatcher, and add implement-direct for
Wrapper/Orchestrator components (and Tier 2 resolve_directly reuse), so the Developer's
implementing step routes each component in a task brief's Components in scope list to the
right implementation strategy while keeping the pipeline's single-spawn_agent interface
unchanged.

Changes

• plugins/dev-team/skills/implement-task/SKILL.md — rewrote steps 5–6 as a branch: absent or
  explicitly empty Components in scope falls back to the pre-existing single-agent
  test-driven-development flow (one commit for the whole task); one or more components
  dispatches each, in dependency order, to implement-direct (Wrapper/Orchestrator) or
  implement-tdd (Testable) — each of which commits its own component, so this skill's own
  commit step is skipped in that branch. Step 7's self-review now explicitly covers the
  cumulative multi-component diff and each component's tier-appropriate test expectation. Step
  8's report gained a "Known ambiguities" section for Tier 3 escalation notes. No change to the
  skill's single-spawn_agent interface with the pipeline.
• plugins/dev-team/skills/implement-direct/SKILL.md (new) — implements one Wrapper (no
  dedicated test) or Orchestrator (one narrow integration test against real, non-mocked direct
  dependencies, primary scenario only) component directly, then commit-changes. Documents an
  optional skip-commit trailing argument so implement-tdd's Tier 2 resolve_directly
  escalation stages instead of committing (that component's single commit still happens later,
  in implement-tdd's own step 7).
• Verified implement-tdd/SKILL.md's existing resolve_directly text ("follow the
  implement-direct skill... Stage the change, then go to step 6") already resolves correctly
  against implement-direct's new stage-vs-commit contract — no edit needed there, per the task
  brief's own expectation.

Design decisions

• Commit-vs-stage mechanism: a documented optional trailing argument, skip-commit
  (<component-row> <task-brief-path> <spec-path> [skip-commit]), consistent with the
  bracket-optional-argument convention already used elsewhere in this plugin.
• Dry-run fixture: extended the ADR-301/302 TTLCache scenario with a SystemClock
  Wrapper and a CachingService Orchestrator that genuinely wires SystemClock.now into an
  internally-owned TTLCache, so the Orchestrator's integration test exercises real wiring
  rather than pass-through construction.
• Environment constraint re-verified before the dry run: Agent/SendMessage spawning of
  tdd-tester/tdd-implementer/tdd-refactorer is still unavailable in this Claude Code
  session (same constraint recorded in ADR-301 PR ADR-301: Add tdd-tester/tdd-implementer agents and the implement-tdd red/green loop #52 and ADR-302 PR ADR-302: Add tdd-refactorer agent and wire post-done refactor turn into implement-tdd #53 — these agent types
  are not in the session's "Available agent types" list). Developer manually played each role's
  turn, running real pytest commands at every turn, so the protocol choreography and every
  build/test result are genuine — only literal sub-agent process isolation was simulated. Stated
  plainly rather than presented as a live spawn.

Testing completed

No unit tests apply to this diff — the deliverable is markdown-only skill-definition files with
no executable production code, per missing-test-harness (this repo has no test harness for
prose/instruction files, consistent with ADR-301/302's precedent). Verification instead took the
form of two dry runs (scratch fixtures under scratchpad/adr303_dryrun_{zero,three}, transcripts
under ~/.dev-team/jodavis/agent-plugins/logs/ADR-303-dryrun-*.log):

• Zero-component task brief: implemented directly via test-driven-development (unit test
  written first, confirmed red for the right reason, then green), single commit, no dispatcher
  iteration.
• Three-component task brief (SystemClock Wrapper → TTLCache Testable → CachingService
  Orchestrator depending on both): produced exactly one commit per component in dependency
  order, each routed to the correct skill. The Testable component went through a real
  structural/behavioral red-green loop (6 turns) with one interleaved refactor turn that
  consolidated two near-identical tests into a parametrized test, confirmed via real pytest
  runs at every turn. Full 7-test suite (6 TTLCache + 1 CachingService) passes.

[github-actions]

build-and-test: Python test results

Status: ✅ Passed

Test log

[jodavis-claude]

Reviewed against the ADR-303 exit criteria and the ADR-288 spec (_spec_TddForImplementation.md). All three exit criteria are met:

• implement-task/SKILL.md correctly branches on Components in scope (absent/empty vs. one-or-more) and dispatches each component to implement-direct (Wrapper/Orchestrator) or implement-tdd (Testable) in dependency order, with no change to the skill's single-spawn_agent interface.
• implement-direct/SKILL.md implements a Wrapper (no test) or Orchestrator (one narrow integration test against real, non-mocked dependencies) directly, plus commit-changes, and documents the skip-commit mechanism used by implement-tdd's Tier 2 resolve_directly escalation. Cross-checked against implement-tdd/SKILL.md's existing step 4 text ("Stage the change, then go to step 6") — the contract lines up correctly with no edit needed there, as the PR claims.
• Both dry runs (zero-component and three-component SystemClock/TTLCache/CachingService) are backed by real commits in their own scratch git repos and real pytest transcripts, not stubbed output. The three-component run shows a genuine structural/behavioral red-green loop across 6 turns plus an interleaved refactor consolidation, and the environment constraint (no live Agent/SendMessage spawning of the tdd-* agent types) is disclosed plainly rather than glossed over, consistent with ADR-301/302's precedent.
• No scope creep: only the two files named in the task brief changed; plugin.json and the pre-existing identify-work-item skill-name mismatch were correctly left untouched per the brief's own instructions.

One minor, non-blocking note left inline below. No Priority 1-4 issues found — approving.

[jodavis]

Most of my comments are about reconciling this new TDD procedure with the existing test-driven-development skill, which should be superseded, but has some useful concepts as well (e.g. writing E2E tests as an overarching TDD of the whole task). This will require some redesign that we should discuss, and we'll need to consider other skills where test-driven-development has been referenced.

[jodavis-claude]

Reviewed the rework of implement-task/SKILL.md and implement-direct/SKILL.md against ADR-303's exit criteria, the _spec_TddForImplementation.md design decisions, and the six human review comments from the earlier CHANGES_REQUESTED pass.

All eight exit criteria are met:

• The dispatcher (step 6) iterates Components in scope in dependency order, routing Wrapper/Orchestrator to implement-direct and Testable to implement-tdd, with no change to the pipeline's single-call interface (confirmed against workflow-orchestrate/SKILL.md, which still treats implement-task as one opaque step).
• Step 7's two-bucket triage (component-shaped-but-uncaptured via component-taxonomy, vs. non-component-shaped implemented directly) correctly collapses the absent/explicit-empty Components-in-scope cases into the same bucket, matching write-task-brief's documented conventions.
• Steps 8-10 correctly reorder to E2E re-run -> self-review -> fix -> one final commit, with an explicit skip condition when nothing remains, and per-component commits are untouched.
• implement-direct's step 3 now explicitly states to fix build/test failures before proceeding to step 4 -- resolves review comments #1 and #6 from the prior pass.
• Every test-driven-development reference is gone from both files (grep confirms zero hits) -- resolves review comments #2 and #7. The old "no components -> fall back to test-driven-development" bullet is removed outright from implement-direct, not just reworded.
• The four dry runs (three fresh: ADR-303-dryrun-adhoc.log, ADR-303-dryrun-leftover.log, plus the reused ADR-303-dryrun-three-*.log pair) are real: genuine pytest failures/passes at every red/green/refactor turn, not narrated. The adhoc and leftover runs specifically demonstrate exit criteria 6-8 with real forced self-review findings landing in the final commit.

One open question worth human confirmation before merge (non-blocking, already flagged as an unresolved ambiguity in the task brief): see inline comment on implement-direct/SKILL.md.

Two minor, non-blocking notes for awareness:

• The PR description/body still describes the pre-review (original PR #54) design rather than this rework -- worth updating so the PR overview matches the current diff.
• Exit criterion 5's three-component dry run reuses PR #54's original evidence (ADR-303-dryrun-three-*.log) rather than a fresh run against the rewritten skill text. This is reasonable since the dispatch mechanics for that flow are unchanged in substance (only citation renames), and it's disclosed transparently in the Implementation Summary, but flagging so it's visible during human sign-off.

No Priority 1-3 (correctness, security, performance) issues found. Approving.