docs(tac): add fable5 methodology transfer + sleep-time compute

Folds fable5-methodology (github.com/UnpaidAttention/fable5-methodology),
fable-mode (github.com/mrtooher/fable-mode), and Letta Sleep-time
Compute (arxiv 2504.13171) into loop_engineering.md. Key insights:
method + enforcement recovers capability gaps; staged execution with
failable verification; model tier variants matching TAC's routing;
sleep-time compute as primitive RSI loop formalization.

plans/meta-prompts/loop_engineering.md

@@ -314,3 +314,27 @@ Reference: "Rewriting Bun in Rust" by Jarred Sumner (bun.com/blog/bun-in-rust, J
 - The Bun rewrite proves AI translation is viable for production codebases. The "spec → agent writes code" pipeline in the Model routing appendix is validated at scale.
 - Claude's multi-agent architecture confirms TAC's approach is aligned with industry best practices: shared vault, isolated sessions, persistent threads.
 - The adversarial agent review pattern (used on the Bun PR) is already part of TAC's verifier system — this validates the approach.
+
+## Fable 5 methodology transfer — method as capability multiplier
+
+Reference: github.com/UnpaidAttention/fable5-methodology — Claude Fable 5 documented its complete engineering methodology so weaker models can execute it cold. github.com/mrtooher/fable-mode — staged execution discipline with failable verification.
+
+**The core thesis: method + enforcement recovers capability gaps.** Fable 5 wrote down its concrete decision rules, reasoning strategies, and quality standards — playbook, skills, subagent contracts, lifecycle hooks — as executable instructions a weaker model can follow verbatim. The bet: a large part of what separates a strong model from a weaker one is not raw horsepower but **discipline** — comprehend before acting, plan before coding, reproduce before fixing, verify before claiming done.
+
+**Four enforcement layers** (from the fable5-methodology repo):
+1. **Prose** — the rulebook (PLAYBOOK.md): imperative, concrete, with decision rules and "done when" criteria. Read it.
+2. **Skills** — loadable modules that inject procedure on demand. You use them or you don't.
+3. **Subagents** — strict contracts with independent verification and adversarial review. Enforceable in code.
+4. **Lifecycle hooks** — block destructive commands, gate "done" declarations on actual verification. Cannot be skipped.
+
+**fable-mode** (from mrtooher/fable-mode): staged execution discipline — written stage plan → parallel delegation where the runtime allows it → failable verification check that *can actually fail* → skeptical self-review before delivery. Four variants (fable-mode, fable-opus, fable-sonnet, fable-haiku) that pin the work to different models — mapping directly to TAC's model routing tiers.
+
+**What does not transfer:** raw single-pass reasoning depth, coherence across very long tasks, the sub-verbal "this feels wrong" intuition. The methodology pairs each non-transferable limit with a **compensating behavior**: externalize reasoning to disk, work in smaller checkpointed chunks, re-read the request at every boundary, run the edge-case checklist literally, lean on mechanical tripwires.
+
+**Implications for TAC:**
+- TAC's verifier/reviewer system already implements the subagent-with-contracts pattern. The fable5-methodology validates this approach with production evidence.
+- The fable-opus/sonnet/haiku variants are direct analogs of TAC's model routing tiers (ZAI GLM-5.2 for planning, Go/DeepSeek V4 Flash for execution, Haiku for fast/cheap).
+- The lifecycle hook pattern (block destructive commands, gate "done" on verification) is exactly the signed-action-only deploy policy: the hook enforces the rule in code, not just in prose.
+- The "write methodology so a weaker model can execute it" pattern is what TAC's loop_engineering.md does for its agents — documented procedures with enforceable gates.
+
+**Sleep-time compute reference:** Letta Sleep-time Compute (arxiv 2504.13171) formalizes what TAC's RSI loop already does — offline computation between conversational turns for memory consolidation, reflection, and insight generation. The factory's skill_health.py cron that runs every 6 hours is a primitive implementation. Advanced sleep-time compute would add structured reflection, cross-skill pattern discovery, and automated methodology refinement.