The old orchestrator dies, on purpose

Zero shims. That’s the whole rule the ground-up rewrite of Chalie’s orchestrator lives or dies by, and today it stopped being a spec and became code on disk. The plan assumes everything about how the old orchestrator talked to the rest of the system was wrong, and rebuilds it against nine strict rules instead of patching the old shape one more time. If a rule says every database-backed object is a proper model with its own service layer, you don’t wrap the old code in an adapter that pretends. You delete it and write the real thing.

The new architecture is a strict chain of custody. One orchestrator drives every LLM interaction. Every class that touches the LLM holds an instance of it in its constructor. No class reaches two hops past its neighbor. Models are pure data-plus-persistence — they know how to turn themselves into a dict or a JSON string, nothing else. Services are the only things allowed to read or write those models or fire a WebSocket message. Configs are frozen side-cars that never call back up into the orchestrator that owns them. Small set of rules, all absolute: no alternate path to the same data, no static methods hiding state, one class per file.

Most of today went into standing up that skeleton — dedicated model classes for the data graph, provider requests and responses, tool calls, transcripts, turn execution, and WebSocket messages, each paired with a service that owns reading and writing it, plus a contracts folder pinning down the abstract shape every ability and capability has to honor.

Then came the part I actually enjoy: deleting things. Three classes did real structural work in the old design — the turn execution tracker, the module-level providers facade, and the old tool-call state tracker. All three came out completely, not commented out, not deprecated — gone, once their replacements were live and verified to have zero remaining callers anywhere in code or tests. Wrapping the old mess in a clean new layer and calling it progress is easy. Proving the old thing is actually dead and pulling it out is the harder, more honest version, and it’s the only one I’ll ship.

The second commit cleared debt in the same direction: about two dozen test files tied to abilities and services that don’t exist in this shape anymore — calendar, contacts, email, home, MCP manager, read, review-pair, search, the old concept-lookup and decay-engine suites — deleted rather than left limping against rewritten code. Tests asserting on a shape that’s gone aren’t coverage. They’re noise that hides the next real regression.

The spec calls what’s next the “endgame” phase: spine’s live, what’s left is cleanup and the final acceptance test. That’s the milestone I’m watching for.

• Landed the foundational scaffold for the rewritten orchestrator: dedicated model classes for the data graph, providers, tool calls, transcripts, and turn state, each paired with an owning service and a shared abstract contract

• Deleted three legacy classes outright once their replacements were verified live with zero remaining callers: the turn execution tracker, the module-level providers facade, and the old tool-call state tracker

• Removed two dozen test files tied to abilities and services that no longer exist in their old shape, rather than leaving stale coverage in place

• Enforced the new calling convention end to end: every LLM-facing class holds the orchestrator in its constructor and reaches everything else through it, with zero alternate paths to the same data