Main loop consults the advisor on the written plan before the challengers (once per skill run) and at a gate loop's second failure; dispatched analyzer may call it once; new trigger before recommending a doctrine, architecture or public-interface change (amends BDR-150).
5.6 KiB
Challenge the plan — shared orchestrator include
Runs in the ORCHESTRATOR MAIN LOOP after a plan / reflection is elaborated and
BEFORE it is executed. Turns a fresh plan into a hardened one by attacking it
from three independent angles, then RE-THINKING every aspect a challenger lands.
Loop + synthesis decisions live here, in the main loop (BDR-066: reflection runs
on the big model; verify-secure-loop.md: fresh blind gates, decisions in the
loop). It never merges, executes, or edits code — it hardens the plan and hands
it to the orchestrator's existing human gate.
The challenge is ADVISORY into that gate — no new hard block — but a BLOCKER is never silently carried past: it is either closed by a NAMED plan change or explicitly deferred for the human.
Inputs the caller must have ready
PLAN: path to the plan ON DISK. If your plan is still inline (a printed checklist / diagnosis / fix plan), FIRST persist it to.claude/tasks/plans/<date>-<slug>-<HHMM>.md— the challengers read from disk and judge blind, exactly like the verifier reads the contract.KIND:build-plan|proposals|fix-bundle— tunes the lens framing below; the mechanism is identical.SCOPE: the files/dirs the plan touches (grounds the critique).CONSTRAINTS(optional): the decided trade-offs / rejected alternatives from the design step, so a lens does not re-litigate a settled choice.
Nominal path is cheap for a small, clean plan: three parallel challengers return SOLID, synthesis is a no-op. It only costs more when a lens lands a real finding — which is the point. The main loop's advisor call before the dispatch (below) is the costliest single item: once per skill run.
DISPATCH — three fresh challengers, in parallel, blind
Advisor first (main loop). Before the first dispatch, with no main-loop
advisor call since the skill run started (so at most once per skill run, not
before a re-challenge), the main loop reads the PLAN file unless its full
text is already in this conversation, then calls the advisor when the tool
is listed (lib/effort-shift.md § Advisor). An answer that lands a real
flaw revises the PLAN file on disk before the dispatch, as plain plan
text: no advisor attribution, no "changes after review" section; the
summary's Advisor: row carries it (OUTPUT below). Absent or erroring →
dispatch as written.
The advice never enters a challenger brief: they stay blind.
Dispatch THREE fresh plan-challenger subagents IN PARALLEL, one per LENS, each
blind to the others and to this conversation:
Agent(subagent_type="plan-challenger", description="challenge:<lens>", prompt="""
PLAN: <the PLAN path>
LENS: <correctness | robustness | simplicity> # one per agent — all three
SCOPE: <SCOPE>
CONSTRAINTS: <CONSTRAINTS, if any>
""")
MODEL (BDR-076, supersedes the BDR-066 inherit): plan critique is AUDIT
JUDGMENT — the challengers are routed to the judge row (opus) by the model-router,
the model: opus frontmatter being the off-state floor: a big tier, off
the main loop. The main loop (opus through its best-tier row)
keeps only this loop — synthesis, RE-THINK, gate. Never sonnet: that would
silently downgrade the judgment. (The executors stay sonnet; the two merge
gates sit on the audit row, opus.)
Lens framing by KIND (the agent's three lenses, read against the artifact):
build-plan— will it WORK / will it BREAK / is it needlessly COMPLEX.proposals— are these the RIGHT items & priorities / what did the audit MISS or under-rate as risk / is the backlog over- or under-scoped.fix-bundle— will each fix ACHIEVE its goal / could it BREAK or regress the page / is there a simpler fix, or an unnecessary one.
FAIL-SAFE — never fail open
A challenger that returns a malformed/empty verdict, a missing PROOF, or dies →
retry ONCE with a fresh challenger; a 2nd failure on that lens → STOP and escalate
(the STOP text names the level reached, $CLAUDE_EFFORT, and suggests relaunching with
ultrathink in the prompt (turn floor) or /route effort=max (sticky,
/route clear after); no shift here: a mute challenger is an infrastructure failure)
to the human, NAMING the lens. Never carry "plan challenged" into the gate on a
silently dropped lens (verify-secure-loop.md: "a mute verifier is NEVER a PASS").
SYNTHESIZE + RE-THINK (main loop, big model)
Parse each CHALLENGE — LENS: … — VERDICT: line and merge the FINDINGS:
- Severity-driven, not consensus. Any
[BLOCKER]from ANY single lens is must-address — the lenses are orthogonal, so a lone security/rollback finding is real, never outvoted by lens-count. Cross-lens agreement only RANKS the MINORs. - RE-THINK the aspect the challenge pointed at. For each BLOCKER (and each
MAJOR you accept): revise the plan on THAT aspect — a NAMED, diffable change to
the plan, never a self-authored "addressed" line. A BLOCKER you consciously keep
is tagged
[deferred <date>]for the human to accept at the gate. - Re-challenge once if the plan materially changed — a fix can open a new
flaw. Re-persist the revised
PLAN, dispatch ONE fresh confirmation challenger, max 1 extra pass, then the gate.
OUTPUT — into the existing human gate
Feed the orchestrator's gate:
- the REVISED plan, and
- a CHALLENGE SUMMARY: each BLOCKER raised → the named change that closed it;
anything
[deferred]; any lens that failed to return; and anAdvisor:row, added to whatever summary template the caller prints: each plan change an advisor answer drove,called, no change, ornot called (absent | error | already called this run).
The human remains the decider.