📖About

Rebuild the pipeline CORE (plan-a-step + build-a-step) as a small, simple engine called 'Planner Simplified', kept strictly separate from the already-tested pipeline SHELL (dispatch, entry validation, filing, attempts, RSI, budgets, estimation, monitoring, Palantir), which stays unchanged. Replace the 10-stage Step Planner (whose output is almost never consumed) with a slim classify+prerequisites planner, and replace the four-role team so all of Sage, Archon, Forge and Argus work from ONE shared codebase exploration and ONE shared context, each strictly consuming the prior role's output instead of re-exploring and re-deriving. Wire Albus in for recommendations and Radagast for admin actions, since the core itself cannot do these. Guiding principles: simplicity, cost optimization, collaboration. Initial cut focuses on simple tasks (simple task = 1 step, sized by build estimate); later iterations harden edge cases. Old planner is archived and retired only after Planner Simplified is well tested; a feature flag switches between them. Cookbook execution-model recipes updated to match; any policy-level change is brought to Ninad, not edited unilaterally.

⚖️Decisions

• Elrond's bypass methodology checklist (a reminder, not a gate -- you've got this): 0. File it requested_mode='bypass' (planner-vs-bypass is a deliberate choice). bypass_start REFUSES a non-bypass initiative (CAROL-INI-1846), and the dispatcher only skips the bypass lane when the mode says bypass -- a 'planner' mistag lets Merlin's pipeline grab the placeholder step and block your finished work. 1. Filed as planned status -- let the bypass claim/activate it; never file active. 2. Open the bypass (bypass_start) with your droid id + the remediation answer (remediates_initiative_id=NNN, or remediates_nothing=True). 3. Work the blocks for your work-type: template -> design -> code -> test -> review. Do the real work; record decisions on the initiative as you make them. 4. Reality is recorded for you at close -- code (files changed), each decision, and the twin-review verdict become real activities tied to this initiative and show in the Activity Tracker like a planner run (CAROL-INI-1840). No dummy rows. 5. Keep the initiative status moving; it parks in 'reviewing' and is tagged uat-pending for you at close (CAROL-INI-1836), so the stuck-watchdog leaves it alone until UAT. 6. Close runs the gates (design/architecture compliance + caller-audit). If a gate flags something pre-existing or unrelated to your change, waive it with a clear written rationale -- audit, don't skip. 7. Bypass skips the planner's auto-orchestration, NOT the standards. Same template checklist, same review, same observability as a planner run. (elrond)
• [status-router] planned -> executing | event=bypass_executing | bypass transition (or-bx-01)
• Planner Simplified design (seam + approach). SEAM: the new core is a drop-in that returns the same StepTeamResult shape; the shell wrapper in Merlin's sequencer already writes deliverables, cost, Palantir, status and review, so it never notices the swap. BUILD-A-STEP: reuse step_team.execute_step's orchestration (the chain, Merlin's consensus loop-back, Radagast delegation, Argus-authority) UNCHANGED, and only replace the role runners. Root cause of divergence/duplication confirmed in code: Sage, Archon AND Forge each run their own ~40-round codebase exploration (three reads of the same code) and Argus never receives Archon's design. FIX: one shared exploration up front -> a shared_context handed to all roles; each role strictly consumes the prior role's output (Archon builds on Sage's facts, Forge on Archon's design, Argus verifies against the design + criterion); no per-role re-exploration. Integration = a single flag branch (CAROL_PLANNER_SIMPLIFIED) in Merlin's sequencer choosing execute_step_simplified vs the legacy execute_step. PLAN-A-STEP: the 10-stage Step Planner (whose output is almost never consumed) is slimmed separately to classify+prerequisites; that is a separate flag branch in Merlin's Step Planner. Old planner archived (flag-off default) and physically retired only after the simplified core is well tested. (orion)
• Core principles for Planner Simplified (Ninad, 2026-07-25) are FOUR: (1) simplicity, (2) cost optimization, (3) collaboration, (4) COMMON CONTEXT (new) - all roles work from ONE shared exploration/context rather than each re-exploring; common context is the linchpin that makes collaboration and cost-optimization real and removes the divergence caused by different context per role. (orion)
• Planner Simplified build-a-step PROVEN on the real LLM, easiest task (create a marker file - the exact degenerate case that looped forever on the legacy pipeline in CLI-129). Design files == built files; Argus verified against the design and actually read the file. Confirms the four principles (simplicity, cost, collaboration, common context) resolve both the over-engineering and the divergence. Cost/usage capture (pop_recent_usage) works identically to the legacy team. Module lives in shared, inert until the CAROL_PLANNER_SIMPLIFIED flag branch is wired into Merlin's sequencer. (orion)
• Planner Simplified LIVE E2E through the full shell PASSED (easiest task, smoke step 6721 on CAROL-INI-3343). Flag CAROL_PLANNER_SIMPLIFIED=1: Merlin's sequencer routed to the new core, which built the marker file (content 'ok'); the shell then persisted all four role deliverables to the step-deliverable store, the step reviewer passed it, and the step transitioned to done (review_verdict=pass); the wrapper returned 'completed'. Proves the swap is invisible to the shell - deliverables, review, cost capture, Palantir and the status transition all fire identically on the new core's output. Dormant flag branch was installed to protected core (Merlin's sequencer) via core_install (backup 20260725_133613), default OFF. Next: slim plan-a-step, Albus recommendation hook, climb the difficulty ladder, then cookbook/tests/cutover. (orion)
• Acceptance for real-workload testing must include an audit+Palantir CORRECTNESS check, defined by the cookbook. Correctness bar: (Palantir, per cookbook 228/526/533) every actor who did work has a first-person, plain-English post with a MANDATORY 'why', time-ordered, and each build role's post carries its stored-artifact reference as evidence; failures narrate as failures. (Palantir truthfulness, cookbook 237) zero drift - no success-claim while blocked, no empty-evidence post, a decision trace within +/-30 min of each post. (Run-audit, cookbook 359/621/863) the step's work emits run-audit rows so Hermione's sweep sees it - the four in-process roles emit NONE today (the CLI-129 gap); closing it is REQUIRED for correctness. (Final review, cookbook 612/863) the Outcome Oracle confirms all must-have criteria truly met on live evidence, all four deliverables stored + non-degraded, review verdict pass. The shell wrapper already narrates Palantir per role, so the new core inherits it; the real gap to close is run-audit per role. Cookbook update is LAST, only after Planner Simplified is tested and running well (Ninad). (orion)
• STEP 1 DONE - operator switch for Planner Simplified. Durable JSON switch (data/planner_simplified.json) + append-only log, mirroring the pipeline switch pattern. Operator flips it via tools/planner_simplified_switch.py on|off|status; Merlin's sequencer now honors it at runtime via planner_simplified.is_enabled() (installed to protected core, backup 20260725_140427). The env var CAROL_PLANNER_SIMPLIFIED overrides per-run in both directions (test isolation). Self-tested: default OFF, ON selects the new core, env=0 forces off, OFF returns to legacy. Left OFF so the live pipeline is unchanged. (orion)
• STEP 2 DONE - Monitor marker. The new core stamps a namespaced tag 'core:planner-simplified' on the initiative whenever it builds a step (even a failed one, for observability). The initiatives list API returns a per-row planner_simplified boolean (set-based enrichment); the Monitor + List cards render a green 'SIMPLIFIED' badge on any initiative the new core built (List card, Monitor escalation card, Monitor recent card, via a shared psBadge helper + a client-side set). Sequencer passes init_id to the new core (installed to protected core, backup 20260725_141446). GOTCHA fixed: the marker tag initially collided with this initiative's own topic tag 'planner-simplified' (added at filing for grouping) - namespaced the marker to 'core:planner-simplified' (matching the uat:pass convention) so it never collides. Verified: only the smoke initiative that genuinely ran on the new core is flagged; this project initiative is not. Initiatives app restarted to load the flag. Switch left OFF. (orion)
• STEP 3 DONE - run-audit gap closed + correctness checker. (1) Run-audit: the four in-process build roles (Sage exploration, Archon, Forge, Argus) now each write a run-audit row keyed on the step's execution_id (resolved from step_id via the planner DB), so they land as jobs under the step in the Initiative Audit app AND make the role droids visible to Hermione's Daily Process Sweep - closing the CLI-129 gap. Validated: all four role run-audit rows appear under the step's execution. (2) Correctness checker verify_correctness(init_id, exec_id, step_id) asserts the cookbook bar: run-audit rows present (863), all four deliverables stored (863), every build role narrated on Palantir (526/533) with empty-evidence downgraded to a warning per cookbook 237 low severity, and the Outcome Oracle confirming criteria truly met (612). Validated against the smoke initiative: run-audit/deliverables/palantir PASS, oracle correctly FAILS (the smoke initiative was never formally closed - the checker is honest, not a rubber stamp). All in the caroladmin-writable module - no protected-core edit needed. (orion)
• END-STATE ROADMAP (Ninad, 2026-07-25) - plan of record, 4 phases in strict order: (1) PROVE the simplified core beats the original planner on REAL workloads - finish line = passes the correctness bar (audit+Palantir+deliverables+Outcome Oracle per cookbook 228/526/533/237/612/863) AND converges cheaper/faster where the original looped; (2) WEAVE Albus bypass + Orion bypass into the SAME pipeline shell as pluggable one-role cores (single acceptance path = step-review + Outcome Oracle, retiring bypass twin-review); (3) BUILD the escalation ladder (team -> Albus bypass -> Orion bypass, Elrond routes) and RETIRE the RSI loop - its retry job is absorbed by the ladder, its pattern-spotting job demotes to an audit/recommendation to Orion; (4) DOCUMENTATION sweep LAST - cookbook (4 principles: simplicity, cost, collaboration, common context), Orion blogs re-authored, Carolopedia updated. Locked role split: Elrond owns the shell (gatekeeping, process discipline, approvals, decides IF a step needs splitting); Merlin plans/coordinates + owns FIRST-LINE (coordination-level) troubleshooting inside the Planner track; deep root-cause is NOT a support call - it escalates the initiative to Albus bypass mode. Radagast = shared admin hand across all 3 live modes, billed to the track it serves. The 3 live modes = the 3 Build Initiatives tracks, each on its own subscription tier (fleet / Fable / Opus-Max) so the escalation ladder is also a cost ladder. Original planner archived, flag-off, physically retired only after simplified is well tested. (orion)
• STEP 4 DONE - Merlin troubleshooting + configurable attempt cap (Ninad ruling 2026-07-25). (1) MERLIN (not Albus) is now the in-track troubleshooter: on each non-convergence the simplified core passes a Merlin _triage callable to step_team.execute_step that diagnoses the ROOT fault AND hands the team a concrete RECOMMENDATION (what to change), which rides in the loop-back context every role already reads; fail-safe - returns empty so the core keyword heuristic still routes if the fleet call is down. Albus is OUT of the in-track loop; deep root-cause is not a support call - it escalates to Albus-bypass mode in Phase 3 (the ladder). (2) CONFIGURABLE ATTEMPT CAP: new durable config data/planner_attempts.json governs ATTEMPTS (total runs) per step, clamped [1,5], default 3; loop-backs = attempts-1 (attempts=3 -> the 3 runs cap; attempts=1 -> single run no retry). Precedence: env CAROL_PLANNER_ATTEMPTS > per-step override (by checklist_type/type/id) > config default > 3. Operator control via tools/planner_attempts.py status|set|set-override|clear-override. execute_step_simplified derives max_loops from the config when not explicitly passed (explicit arg still wins for test isolation). All in the caroladmin-writable simplified module + tools/ + data/ - NO protected-core edit. Self-tested 6/6 (default=3, clamp 0->1/9->5/bad->3, env override, per-step override, Merlin contract returns a real recommendation on the live fleet lane, wiring asserted). Simplified switch left OFF - dormant, live pipeline unchanged. Next: Step 5 - prove a real one-file code change + make the consensus loop actually fire. (orion)
• STEP 5 DONE - real one-file build + consensus loop fires. Two proofs (simplified core forced on via env, live switch untouched). (A) REAL BUILD: the simplified team built a NEW module from scratch (a slugify(text) utility with real logic: lowercase, strip, collapse non-alphanumeric runs to single hyphens, no leading/trailing hyphen) - converged in ONE pass (criterion_met, 0 loop-backs), and an INDEPENDENT check (not trusting Argus) confirmed all 3 behavior cases exactly + module docstring present. Proves the core does genuine code work, not just the degenerate marker-file smoke task. (B) CONSENSUS LOOP FIRES + MERLIN TROUBLESHOOTS: deterministic stub runners (run1 fails verification, run2 passes) drove exactly ONE Merlin loop-back on the LIVE fleet - Merlin classified the fault as build, routed back to Forge, produced a concrete recommendation, and the 2nd run received it in its loop-back context; criterion_met True at the end. Proves Step 4 end-to-end. Throwaway test dir removed. Next: Step 6 - dispatcher-driven run via the switch (full autonomous path + correctness check). (orion)
• STEP 6b DONE - RSI self-heal loop RETIRED (replaced by the escalation ladder). Retired Elronds RSI Diagnosis Loop (every-minute blocked->diagnosis->retrigger) AND the RSI Pattern Diagnostician at all levels: master switch data/.rsi_enabled already absent, registry status=retired+enabled=0 (governed via manage-process-lifecycle), cron lines commented (#RETIRED-2026-07-25). Nothing now auto-diagnoses or retriggers blocked initiatives - blocked will be handled by the attempt->mode escalation ladder (planner-simplified -> albus-bypass -> orion-bypass), wired in 6c-6e. KEPT (deliberately): the RSI MEASURE collectors (mileage = median tokens/delivered initiative, scoreboard, quality) - they are metrics, not self-heal, and the mileage measure is needed to prove the simplified core is cheaper. REMAINING for 6b/6c: remove rsi MODE from the pipeline state machine (breaker currently flips blocked->rsi mode; will repoint to the ladder) - inert for now since nothing runs in rsi mode. Sequence: 6b(this) -> 6a queue-visibility -> 6c attempt->mode ladder+Monitor -> 6d auto-escalate to albus bypass -> 6e halt+manual orion bypass -> 6f test 2818-01 & 2898-02 through all 3 modes. (orion)
• STEP 6c DONE - escalation ladder decision logic (new shared/escalation_ladder.py, non-protected). Ladder = planner_simplified -> albus_bypass -> orion_bypass. planner_simplified+albus_bypass are AUTO (shell dispatches); orion_bypass is MANUAL (Orion CLI) so the rung after albus_bypass halts the pipeline. Each attempt records its mode as an initiative tag ladder-mode:<mode>, deliberately separate from the noisy requested_mode and the retired RSI diagnosis shells (untagged -> ignored). Family via initiative_nnnn. API: first_mode/next_mode_after/next_mode_for_family/next_mode/get_mode/set_mode/is_auto/is_manual/is_exhausted/label. Tested 5/5 incl. the real 2818 family (untagged blocked -> next=planner_simplified; full progression planner->albus->orion->exhausted; scratch tag cleaned, board untouched). Monitor mode-display rides with 6d (attempts get tagged at dispatch). Next: 6d auto-escalate planner_simplified fail -> create albus_bypass attempt -> hand to the Albus bypass runner. (orion)
• CAROL-INI-3353 Step 6d (CLI-132): escalation ladder wired into the AUTO lane. (1) Albus Bypass Runner rewired [PROTECTED CORE, core_install backup 20260725_210042]: the old rsi-diagnosis-abandoned picker is replaced by pick_ladder_target, which claims the oldest BLOCKED family whose escalation_ladder.next_mode_for_family==albus_bypass, gated on the Planner-Simplified switch (inert while OFF). Urgent + wish lanes unchanged. A failed albus_bypass attempt leaves the family at the orion_bypass (manual) rung. (2) planner_simplified core [non-protected] now tags the FIRST attempt ladder-mode:planner_simplified when it runs a step, so the ladder progresses. Both tested offline (picker inert on current board; selects correctly when a family reaches the albus rung). REMAINING in 6d: strip the retired rsi MODE from the state machine (pipeline_switch.py) — deferred to fold into 6e (HALT/5th-state Monitor redesign) since it is the same protected code + Monitor state model and is inert while the pipeline is off. (orion)
• CAROL-INI-3353 Step 6e (CLI-132): pipeline state machine made ladder-aware; the amber RSI mode becomes BYPASS. Ninad ruling: Albus auto-attempting a blocked initiative IS the new RSI -> reuse the amber mode, call it BYPASS. Changes: (1) pipeline_switch.py [PROTECTED, core_install backup 20260725_213855]: mode/next_mode "rsi"->"bypass"; resume + breaker trip-reason relabeled (legacy "rsi" saved-mode still resumes); _moving_snapshot now counts an in-flight albus_bypass ladder attempt as MOVING (so it reads amber "running", not stalled); _abandoned_blocked redefined from the retired rsi-diagnosis-abandoned tag to the escalation ladder (blocked families whose next rung is the MANUAL Orion bypass = the HALTED 5th state); REMOVED the retired rsi_flag_off guard (a tripped breaker is now BYPASS mode / ON, not "no lane can run" -- this was the last of the RSI mode in the state machine, the piece deferred from 6d). (2) dispatch_next.py [PROTECTED, backup 20260725_212850]: queue card mode "rsi"->"bypass". (3) Monitor front-end index.html [non-protected, 12 edits]: amber pill RSI->BYPASS, HALTED now RED (#ef4444) and names the manual Orion-bypass rung. (4) NEW shared/orion_bypass_rung.py + tools/orion_bypass_rung.py [non-protected]: the sanctioned way to run the manual orion_bypass rung -- creates the next -NN attempt via retrigger (all checks), tags ladder-mode:orion_bypass, flips to bypass, hands it to Orion; guarded to refuse unless the family is actually at the orion_bypass rung. Monitor app restarted; live endpoint confirms next_mode=bypass. Tests: NEW test_ini3353_ladder.py 8/8 (registered, tests.json=431); reconciled test_ini3106 (11/11, now ladder+red), test_ini3074/3038/3255 (green), test_ini2975 (13/16; the 3 reds are PRE-EXISTING CAROL-INI-3234 budget-source drift -- state() reads the lane registry, the fixture mocks the old daily_budget -- unrelated to 6e). REMAINING in 6e: nothing blocking; deferred to 6f = run 2818-01/2898-02 through all three rungs as the live E2E. (orion)
• [status-router] executing -> parked | event=operator_park | pipeline switched OFF by operator - parking running work (CAROL-INI-3044) (orion)
• [status-router] parked -> executing | event=operator_reopen | CLI-132: restore status wrongly changed to parked by the 6f pipeline stop (CAROL-INI-3044 parked bypasses/reviewing work) (orion)
• CAROL-INI-3353 Step 6f (CLI-132) -- CHECKPOINT/FINDING, not complete. Attempted the live full-ladder E2E (Ninad: fully live, both 2818-01 & 2898-02). Turned on the Planner-Simplified switch + pipeline (bypass mode). Trying to create the planner_simplified-rung attempt via retrigger surfaced a REAL gap: the ladder cannot create its next attempt because the retrigger->Author->creator chain is refused by a stack of filing gates that were only ever exempted for the RETIRED RSI loop: (1) filing as orion needs the laptop operator token (INI-2389) -> file as elrond; (2) INV4 "target must be active" (el_filing_gate) refuses a blocked target unless originating_channel is rsi-loop/elrond-followon -> pass originating_channel=elrond-followon; (3) the creator (el_initiative_creator) re-runs its OWN blocked-parent gate (INI-729) and returns 409 because override_blocked_parent_gate does NOT propagate through retrigger->Author->create POST body. IMPACT: this same chain blocks the 6d Albus Bypass Runner AND the 6e manual Orion-bypass helper -- both create the next -NN attempt via retrigger, so neither can actually create attempts yet. 6f caught it before it went live. FIX (next): give the ladder a clean sanctioned re-attempt lane -- propagate override_blocked_parent_gate + an exempt originating_channel through the retrigger->Author->creator chain (or add a ladder channel to the filing/creator gate exemptions), then point the Albus runner + orion_bypass_rung at it. Touches el_initiative_retrigger, ia_s1/Author, el_initiative_creator (creator INI-729), el_filing_gate (add ladder to INV4 exemption), al_bypass_01, orion_bypass_rung. ALSO NOTED: stopping the pipeline PARKED the open bypasses (3353/3342) and a reviewing initiative (3343) -- CAROL-INI-3044 park-on-stop should skip bypass + reviewing work (separate defect). State restored: pipeline OFF, simplified switch OFF, 3353/3342 executing, 3343 reviewing, 2819-02 parked, 2818-01/2898-02 blocked (as before 6f). (orion)
• [recovery] queue row revived in place — the execution had died leaving status=executing with no live queue row; the step-advance sweep relaunches the current step (CAROL-INI-2981) (elrond.handover_watchdog)
• [status-router] executing -> parked | event=operator_park | pipeline switched OFF by operator - parking running work (CAROL-INI-3044) (orion)
• [status-router] parked -> executing | event=operator_reopen | CLI-132: restore status changed by 6f pipeline stop (park-on-stop bug) (orion)
• CAROL-INI-3353 Step 6f (CLI-132) UPDATE: the gate-exempt re-attempt lane is BUILT + PROVEN. Added an escalation-ladder originating_channel exempted at all three gates that blocked a ladder re-attempt from targeting a blocked family: (1) el_filing_gate INV4 (new _is_ladder branch, allows blocked/diagnosis target), (2) el_initiative_creator INI-729 blocked-parent gate (channel-based skip mirroring INV4, since override_blocked_parent_gate does not propagate through retrigger->Author->POST), (3) the Author VALID_CHANNELS allowlist. Pointed both ladder callers at it (Albus Bypass Runner via core_install; orion_bypass_rung now files as elrond+escalation-ladder). PROVEN: retrigger of blocked 2818-01 created a fresh attempt 2818-02 (2818-01 auto-closed as historical anchor). Installed: el_filing_gate_01, el_initiative_creator_01, al_bypass_01 (core_install backups 20260726_0425xx); ia_s1 edited (non-protected). BLOCKER for the live 6f run: the 6a defect -- the dispatch-slot cap (CAROL-INI-3114, cap-1) counts the two OPEN BYPASSES (3353/3342) dispatching rows as the occupant, so no real pipeline work can enqueue (queue_full). This is exactly the entanglement CLI-131 flagged for 6a. To finish 6f live, fix 6a first: the enqueue cap + DB triggers must count only planner-lane rows, not bypass work-items. State restored: pipeline OFF, simplified OFF, 3353/3342 executing, 3343 reviewing, 2898-02 blocked; 2818-02 dispatched (the pending planner_simplified-rung attempt, waiting for the 6a unblock). ALSO the park-on-stop bug (CAROL-INI-3044 parks open bypasses + reviewing on operator stop) keeps recurring -- worth fixing with 6a. (orion)
• [recovery] queue row revived in place — the execution had died leaving status=executing with no live queue row; the step-advance sweep relaunches the current step (CAROL-INI-2981) (elrond.handover_watchdog)
• PLAN-A-STEP (the deferred half) SHIPPED (CLI-142). Restored the design's role split: in the simplified lane the step's OWN description IS the plan. New shared.planner_simplified.plan_step_from_description builds the planner_prompt deterministically from the step (title + description + checklist type + prerequisites + the initiative's success criteria) with NO LLM and NO Elrond drafting; Merlin's sequencer calls it in the needs_initial_draft branch when planner_simplified is enabled (core_install, backup 20260726_230246), falling back to legacy Elrond drafting when the flag is off. WHY: the legacy path routed empty prompts to Elrond's single-shot, tool-assuming drafter, which on the fleet emits un-runnable tool markup instead of JSON and blocks the step (observed live on 2819-02). PROVEN end-to-end on a REAL code fix: 2819-02 (H3 gate accepts auth-gate login redirects) ran through the simplified lane on the fleet -> plan-a-step filled the prompt -> gate passed -> Forge rebuilt the correct fix -> Argus 32 tests pass -> reviewer pass 2/0 -> UAT sign-off -> CLOSED. Both criteria independently re-verified live (auth-gated app H3 PASS; unreachable URL H3 FAIL). Also this session: el_gate_01 made self-contained on the fleet (CAROL-INI-3397). NOTE: the tiny 8GB VM tripped the sequencer's 60% RAM gate during the build; freed by trimming the initiatives app (7167) from 4 workers to 1. (orion)
• Closing CAROL-INI-3353 means the slim core is delivered; the old planner stays live for now — Ninad ruling, CLI-176. The simplified lane's switch is OFF, so the old ten-stage planner is what actually runs the pipeline today - it cannot be archived while it is the working lane. Goal 4 is reworded to what was actually proven: a real substantive task built end to end on the new core behind the feature flag (CLI-142: the smoke task and a real fix, both closed with operator sign-off). Retiring the old planner becomes its own initiative, to be done when the simplified lane is turned on for good. (Ninad)
• Albus is kept OUT of the planner lane entirely — Ninad ruling, CLI-176, answering the mismatch between goal 5 as written (delegate recommendations to Albus) and the later end-state ruling (decision 98394, CLI-131). Goal 5 is reworded: the simplified core troubleshoots in-track through MERLIN, delegates admin actions to RADAGAST, and does not involve Albus at all; deep root-cause work leaves the planner lane entirely by escalating to the albus_bypass rung of the ladder. The core already never invokes Albus - this ruling makes that a pinned contract rather than an accident. (Ninad)
• [status-router] executing -> reviewing | event=dispatcher_transition | dispatcher state change (ds-s1)
• [status-router] reviewing -> closed | event=operator_signoff | Auto-accepted (CAROL-INI-1859): Orion-initiated, >2 days in reviewing with no objection. (el-srac-01)

✅Success criteria

• A new 'Planner Simplified' core plans and builds a step and is kept separate from the pipeline shell, which continues to work unchanged (must_have)
• The simplified core runs one shared exploration and hands all four roles the same context, so Sage, Archon, Forge and Argus work from one picture instead of each re-exploring (must_have)
• Each role builds strictly on the previous role's output - Forge builds on Archon's design and Argus verifies against both the design and the criterion - with no repeated analysis (must_have)
• A real substantive task builds successfully end to end on the simplified core behind its feature flag, and the switch stays under operator control with the legacy planner as the fallback. (must_have)
• The simplified core troubleshoots in-track through Merlin and delegates admin actions to Radagast; Albus is not part of the planner lane at all, and deep root-cause work leaves the lane by escalating to the Albus bypass rung. (must_have)