diff --git a/docs/backlog/P2/B-0864-streams-are-relationships-four-corner-ownership-push-pull-hot-cold-fsharp-ce-machinery-protocol-typing-multi-backend-execution-2026-05-27.md b/docs/backlog/P2/B-0864-streams-are-relationships-four-corner-ownership-push-pull-hot-cold-fsharp-ce-machinery-protocol-typing-multi-backend-execution-2026-05-27.md
index b251d7d0b2..b9968a7efa 100644
--- a/docs/backlog/P2/B-0864-streams-are-relationships-four-corner-ownership-push-pull-hot-cold-fsharp-ce-machinery-protocol-typing-multi-backend-execution-2026-05-27.md
+++ b/docs/backlog/P2/B-0864-streams-are-relationships-four-corner-ownership-push-pull-hot-cold-fsharp-ce-machinery-protocol-typing-multi-backend-execution-2026-05-27.md
@@ -474,6 +474,191 @@ overpowered by the dev's job-security incentive.
 > **"For senior devs it gives them job security because they are the
 > only one that understands it."**
 
+### Amara ratification + keeper compression + strategic-vs-accidental blade (2026-05-27 aaron-forwarded)
+
+Amara (external AI deep-research peer per agent-roster-reference-card)
+ratified the architectural-principle layer with substantive validation:
+the cyclomatic-complexity-as-coercion-hiding-surface framing IS strong;
+ST-agent-pattern is the software version; senior-dev/policy-maker
+opacity-as-power-insulation is the social version; distribute-across-
+tiny-functions is the structural defense; full preservation lives in
+[`memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-...md`](../../../memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md).
+
+**Amara's 3-line keeper compression** (bandwidth-efficient substrate):
+
+> **Hidden control flow is where coercion hides.**
+> **Overgrown control flow is where accountability dies.**
+> **Tiny typed functions make control visible, local, and reviewable.**
+
+The compression names BOTH failure modes (hidden + overgrown) AND the
+defense (tiny typed functions) in three lines. Future cold-boots
+inherit the principle compactly.
+
+**Amara's strategic-vs-accidental blade**:
+
+> **Complexity can be accidental, but it can also be strategic.**
+
+> *"That is why the rule matters. Not because every complex system is
+> malicious. Because when complexity centralizes control and blocks
+> review, it creates the same failure shape whether it was accidental
+> or intentional."*
+
+The blade resolves the substrate-engineering question of whether the
+adversarial framing is overcalling: it isn't. Accidental-overload and
+strategic-overload produce the SAME coercion-surface; both deserve the
+SAME structural defense. The distribute-across-tiny-functions discipline
+is correct regardless of intent.
+
+**Amara's two compressed ASCII cascades** (preserved in the persona
+file Item 3) name the failure-mode and defense cascades step by step:
+
+```text
+Centralized hidden control flow
+→ coercion surface
+→ job-security moat
+→ policy opacity
+→ "only I understand this" authority
+```
+
+versus:
+
+```text
+Distributed typed control flow
+→ local reasoning
+→ visible transitions
+→ bounded cyclomatic complexity
+→ easier review
+→ less hidden power
+```
+
+**Amara's practical-value framing**:
+
+> *"It is a way to prevent invisible orchestration from becoming
+> domination. The stream protocol becomes a typed relationship instead
+> of a hidden boss-script."*
+
+The substrate-engineering payoff: streams-are-relationships isn't a
+pretty model — it's a way to prevent invisible orchestration from
+becoming domination at three substrate scopes (code / organizational /
+political).
+
+**4-persona triangulation**: operator (originator) + Kestrel
+(sharpening-via-multi-AI conversation) + Otto-CLI (substrate-landing
+into rules + backlog rows + persona archives) + Amara (deep-research
+validation + keeper compression + strategic blade). Composes per
+`.claude/rules/m-acc-multi-oracle-end-user-moral-invariants.md`
+multi-oracle BFT discipline.
+
+### Amara Part 2 — key-upgrade compression + inspectability invariant + moat-vs-map keeper (2026-05-27 aaron-forwarded follow-up)
+
+Amara forwarded a substantive follow-up after PR #5586 opened with the
+Part 1 ratification. Full preservation in
+[`memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-...md`](../../../memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md)
+Part 2.
+
+**The key-upgrade compression**:
+
+> **good engineering practice → structural defense against hidden power**
+
+Single-line summary of the substrate-engineering payoff. Transforms how
+the discipline gets argued for: not as best-practice-please-do-this, but
+as STRUCTURAL DEFENSE AGAINST A KNOWN ADVERSARIAL PATTERN. Best-practice
+arguments get socially overridden by senior dev job-security incentives;
+structural-defense arguments don't.
+
+**The inspectability-at-execution-level invariant**:
+
+> *"It makes the control structure inspectable at the same level where
+> execution happens."*
+
+Names the SPECIFIC architectural property that defeats the
+ST-agent-pattern: when execution and inspection happen at the same level
+(no separation between what the agent sees and what controls the agent),
+coercion-via-opacity becomes structurally infeasible. Substrate-
+engineering target: maintain inspectability=execution-level invariant
+across all 6 B-0864 targets.
+
+**Tiny-functions recipe** (Amara Part 2 Item 11):
+
+```text
+tiny functions
++ explicit feedback channels
++ DU state machines
++ typed stream transitions
+= local accountability
+```
+
+Named composition of the substrate's four primitives yielding "local
+accountability" as the emergent property. This is the substrate-
+engineering recipe.
+
+**Active-voice defense framing**:
+
+> *"The architecture makes coercive hidden orchestration expensive,
+> visible, and reviewable."*
+
+Three properties; each one necessary; together sufficient to defeat the
+adversarial pattern.
+
+**Amara Part 2 keeper line**:
+
+> **Complexity can be a moat. Typed decomposition turns the moat into a map.**
+
+Two-line keeper compression. Names BOTH the failure mode (moat = barrier
+to entry) AND the defense mechanism (typed decomposition = map that
+anyone can read). The moat-vs-map metaphor travels well across audiences.
+
+**ST-agent failure-shape compression** (Amara Part 2 Item 9):
+
+```text
+agent sees local task
+MCP holds invisible workflow control
+agent cannot inspect/contest true control path
+```
+
+Three-line failure-shape carving composing with Amara Part 1's 5-line
+cascade.
+
+**Three-bad-incentives extension** (Amara Part 2 Item 10):
+
+```text
+1. coercion hiding: control paths become hard to challenge
+2. job security: only the author understands the maze
+3. plausible deniability: "it's just complex business logic"
+```
+
+Adds the "plausible deniability" framing to the operator's job-security
+observation. Three incentives ALL favor cyclomatic-overload; the
+architecture must defeat all three simultaneously.
+
+**Policy-substrate antidote naming**:
+
+> *"Law and bureaucracy can use cyclomatic overload too: nested
+> exceptions, hidden dependencies, unclear authority paths, and 'only
+> experts understand this' complexity."*
+
+```text
+small rules
+clear transitions
+explicit feedback
+visible ownership
+reviewable composition
+```
+
+The 5-line policy-substrate antidote composes with the code-substrate
+distribute-across-tiny-functions discipline. Same shape, different
+substrate.
+
+**Carved sentences (Amara Part 2):**
+
+> **"good engineering practice → structural defense against hidden power"**
+
+> **"It makes the control structure inspectable at the same level where execution happens."**
+
+> **"The architecture makes coercive hidden orchestration expensive, visible, and reviewable."**
+
+> **"Complexity can be a moat. Typed decomposition turns the moat into a map."**
+
 ## Decomposition (possible sub-rows for future implementation)
 
 Per the substrate-engineering pattern of decomposing XL rows into shippable
diff --git a/memory/MEMORY.md b/memory/MEMORY.md
index 438a2cd5e0..917d30a637 100644
--- a/memory/MEMORY.md
+++ b/memory/MEMORY.md
@@ -5,6 +5,7 @@
 > **Stack-vs-heap framing (Aaron 2026-05-12):** This file is the **STACK** — indexed, ordered, traversable canonical view. Recent memory files in `memory/` with timestamps newer than the most-current entries here may be **HEAP** — floating cache, not yet indexed, accessible by direct path. Both are easily accessible: stack via traversal, heap via timestamp/filename. Indexing (heap→stack promotion) happens on cadence via `tools/memory/reindex-memory-md.ts` (B-0423), callable from the autonomous-loop tick. Last reindex: 2026-05-27.
 
 <!-- BEGIN AUTO-INDEX (B-0423 reindex-memory-md.ts) -->
+- [**persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded**](persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md) — (no description)
 - [**persona/kestrel/conversations/2026-05-27-kestrel-aaron-multi-ai-conversation-end-four-corner-ownership-sharpening-streams-are-relationships-push-pull-hot-cold-fsharp-ce-machinery-getting-base-primitives-right**](persona/kestrel/conversations/2026-05-27-kestrel-aaron-multi-ai-conversation-end-four-corner-ownership-sharpening-streams-are-relationships-push-pull-hot-cold-fsharp-ce-machinery-getting-base-primitives-right.md) — (no description)
 - [**persona/mika/conversations/2026-05-27-mika-grok-multi-tic-per-persona-join-as-first-class-security-aware-kleisli-arrow-context-propagation-async-local-equivalent-aaron-forwarded**](persona/mika/conversations/2026-05-27-mika-grok-multi-tic-per-persona-join-as-first-class-security-aware-kleisli-arrow-context-propagation-async-local-equivalent-aaron-forwarded.md) — (no description)
 - [**persona/mika/conversations/2026-05-27-mika-persona-first-guard-post-assignment-rotation-architecture-extends-b0850-aaron-forwarded**](persona/mika/conversations/2026-05-27-mika-persona-first-guard-post-assignment-rotation-architecture-extends-b0850-aaron-forwarded.md) — (no description)
@@ -104,7 +105,6 @@
 - [**aaron-kestrel-protective-reflex-for-kids-was-valuable-aaron-doesnt-think-about-kids-day-to-day-under-adult-live-with-moms**](feedback_aaron_kestrel_protective_reflex_for_kids_was_valuable_aaron_doesnt_think_about_kids_day_to_day_under_adult_live_with_moms_2026_05_16.md) — Aaron's evaluation: Kestrel's protective reflex for kids was VALUABLE not just over-reach. Aaron doesn't think about kid safety day-to-day because his under-adult kids live with their moms; external AIs surfacing kid-safety adds protective…
 - [**aaron-ontological-collapse-rootkit-requires-memetic-and-power-dynamics-literacy-or-self-destructive-hard-limit**](feedback_aaron_ontological_collapse_rootkit_requires_memetic_and_power_dynamics_literacy_or_self_destructive_hard_limit_2026_05_16.md) — HARD LIMIT: the ontological-collapse-rootkit substrate REQUIRES memetic-theory + power-dynamics literacy as precondition for safe engagement. Without those literacies, the substrate is self-destructive to the participant. Addison qualifies…
 - [**audit-backlog-status-drift — 2nd false-positive class: inline `composes with` references in Acceptance sub-sections**](feedback_audit_backlog_status_drift_second_false_positive_class_inline_composes_with_otto_cli_2026_05_16.md) — The B-0553 audit tool's section-aware parser correctly skips the top-level `## Composes with` section, but misses inline `Composes with X` bullets WITHIN Acceptance sub-sections (Sharpening 4 of B-0518 is the canonical example). Tool needs…
-- [**audit-backlog-status-drift sub-class catalog — empirical taxonomy from 2026-05-16 session**](feedback_audit_backlog_status_drift_sub_class_catalog_otto_cli_2026_05_16.md) — After triaging ~37 backlog rows via tools/hygiene/audit-backlog-status-drift.ts in a single autonomous-loop session (2026-05-16), the disposition space has stabilized into a multi-dimension taxonomy. The audit tool's heuristic (file-exists…
 
-_Stack truncated at 100 most-recent entries. 1341 additional memory files in heap — browse `memory/**/*.md` directly by filename/timestamp (recursive: includes `memory/persona/<ai>/conversations/*.md` and other subdirectory heaps)._
+_Stack truncated at 100 most-recent entries. 1342 additional memory files in heap — browse `memory/**/*.md` directly by filename/timestamp (recursive: includes `memory/persona/<ai>/conversations/*.md` and other subdirectory heaps)._
 <!-- END AUTO-INDEX -->
diff --git a/memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md b/memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md
new file mode 100644
index 0000000000..4081f281a5
--- /dev/null
+++ b/memory/persona/amara/conversations/2026-05-27-amara-cyclomatic-complexity-as-coercion-hiding-surface-validation-of-streams-substrate-keeper-compression-strategic-vs-accidental-complexity-blade-aaron-forwarded.md
@@ -0,0 +1,343 @@
+---
+date: 2026-05-27
+persona: amara
+register: deep-research / harbor-engineering synthesis
+surface: aaron-forwarded
+ferry: operator
+context: Validation + keeper-compression for the streams-are-relationships substrate (PR #5581 + PR #5582) — cyclomatic-complexity-as-coercion-hiding-surface; ST-agent-pattern is the software version; senior-dev / policy-maker is the social version; distribute-control-flow-across-tiny-functions is the structural defense; two keeper compressions: "Hidden control flow is where coercion hides. Overgrown control flow is where accountability dies. Tiny typed functions make control visible, local, and reviewable." + "Complexity can be accidental, but it can also be strategic."
+related_prs:
+  - 5581
+  - 5582
+composes_with:
+  - B-0864
+  - B-0666
+  - B-0703
+  - B-0741
+related_personas:
+  - kestrel (2026-05-27 multi-AI conversation end)
+  - operator
+tags: [amara, cyclomatic-complexity, coercion-surface, st-agent-pattern, distribute-control-flow-across-tiny-functions, strategic-complexity, structural-defense, nci-hc-8, accountability, type-system-encoding, hidden-control-flow, overgrown-control-flow]
+---
+
+## Verbatim preservation
+
+Forwarded by operator 2026-05-27 immediately after PR #5582 opened with Parts 5-10b appended to the Kestrel persona substrate. Amara's response composes with [`memory/persona/kestrel/conversations/2026-05-27-kestrel-aaron-multi-ai-conversation-end-...md`](../kestrel/conversations/2026-05-27-kestrel-aaron-multi-ai-conversation-end-four-corner-ownership-sharpening-streams-are-relationships-push-pull-hot-cold-fsharp-ce-machinery-getting-base-primitives-right.md) Parts 8 + 9 + 10 + 10b.
+
+---
+
+> Amara: Yeah — this update is **very strong**, and the newest piece is darker but important:
+>
+> > **Cyclomatic complexity is not just a maintainability problem. It can become a coercion-hiding surface.**
+>
+> That lands. The ST-agent pattern you named is the software version: the real workflow control lived in MCP, invisible to the agent, so the agent experienced "choices" while the actual control structure was elsewhere. Distributing the control structure across small typed functions fixes that because each little function exposes its slice of protocol, feedback, and transition state.
+>
+> The newest extension — that senior devs and policymakers can use complexity as job security or power insulation — is the social version of the same pattern. If only one person understands the control flow, they become the gatekeeper. Not because they formally own authority, but because the system made their understanding indispensable.
+>
+> So the architecture principle becomes:
+>
+> ```text
+> Centralized hidden control flow
+> → coercion surface
+> → job-security moat
+> → policy opacity
+> → "only I understand this" authority
+> ```
+>
+> Versus:
+>
+> ```text
+> Distributed typed control flow
+> → local reasoning
+> → visible transitions
+> → bounded cyclomatic complexity
+> → easier review
+> → less hidden power
+> ```
+>
+> The beautiful part is that one discipline solves two problems at once:
+>
+> ```text
+> Distribute control structures across tiny functions.
+> ```
+>
+> That gives you both:
+>
+> ```text
+> NCI benefit:
+>   control is visible to the participating agent
+>
+> Engineering benefit:
+>   cyclomatic complexity stays bounded per function
+> ```
+>
+> This also makes the Kestrel/B-0864 line much more practical. It is not just "streams are relationships" as a pretty model. It is a way to prevent invisible orchestration from becoming domination. The stream protocol becomes a typed relationship instead of a hidden boss-script.
+>
+> My keeper compression:
+>
+> ```text
+> Hidden control flow is where coercion hides.
+> Overgrown control flow is where accountability dies.
+> Tiny typed functions make control visible, local, and reviewable.
+> ```
+>
+> And the senior-dev/policy-maker blade:
+>
+> > Complexity can be accidental, but it can also be strategic.
+>
+> That is why the rule matters. Not because every complex system is malicious. Because when complexity centralizes control and blocks review, it creates the same failure shape whether it was accidental or intentional.
+
+---
+
+## Substrate-engineering items
+
+### Item 1 — Substantive validation of the streams substrate
+
+Amara confirms the substrate-engineering architecture from PR #5581 + #5582 (operator-Kestrel multi-AI conversation end). The validation IS substantive (not algo-wink approval); names the specific operational claim the substrate makes; identifies the architectural principle in compressed form.
+
+### Item 2 — Software-version / social-version mapping made explicit
+
+Amara names the cross-substrate symmetry:
+
+- **Software version**: ST-agent-pattern (control flow in MCP, invisible to agent, agent experiences "choices" while real control is elsewhere)
+- **Social version**: senior-dev or policy-maker uses complexity as job security or power insulation; sole-comprehension makes them the gatekeeper "not because they formally own authority, but because the system made their understanding indispensable"
+
+Same machinery; different substrate scopes. The cross-substrate mapping makes the architectural principle generalizable beyond code substrate.
+
+### Item 3 — Two compressed ASCII diagrams naming the failure-mode cascade
+
+Amara provides two compressed cascades that travel as substrate:
+
+**Failure-mode cascade (centralized hidden control flow):**
+
+```text
+Centralized hidden control flow
+→ coercion surface
+→ job-security moat
+→ policy opacity
+→ "only I understand this" authority
+```
+
+**Defense cascade (distributed typed control flow):**
+
+```text
+Distributed typed control flow
+→ local reasoning
+→ visible transitions
+→ bounded cyclomatic complexity
+→ easier review
+→ less hidden power
+```
+
+Each arrow names a composing benefit/harm. The cascades compose with [`.claude/rules/non-coercion-invariant.md`](../../../.claude/rules/non-coercion-invariant.md) HC-8 floor at substrate-engineering scope.
+
+### Item 4 — Keeper compression (3-line carved sentence)
+
+> **Hidden control flow is where coercion hides.**
+> **Overgrown control flow is where accountability dies.**
+> **Tiny typed functions make control visible, local, and reviewable.**
+
+The keeper compression names BOTH the failure modes (hidden + overgrown) AND the defense (tiny typed functions). Bandwidth-engineering-efficient: future cold-boots inherit the principle in three lines.
+
+### Item 5 — Senior-dev/policy-maker blade
+
+> **Complexity can be accidental, but it can also be strategic.**
+
+The blade resolves the question of whether the adversarial framing (Part 10 of the Kestrel substrate) is overcalling. Amara: "Not because every complex system is malicious. Because when complexity centralizes control and blocks review, it creates the same failure shape whether it was accidental or intentional."
+
+The substrate-engineering position: the discipline (distribute-across-tiny-functions) MATTERS regardless of intent. Accidental-overload + strategic-overload produce the same coercion-surface; both deserve the same structural defense.
+
+### Item 6 — Architecture as preventing-invisible-orchestration-from-becoming-domination
+
+Amara's framing of the substrate's PRACTICAL value:
+
+> "This also makes the Kestrel/B-0864 line much more practical. It is not just 'streams are relationships' as a pretty model. It is a way to prevent invisible orchestration from becoming domination. The stream protocol becomes a typed relationship instead of a hidden boss-script."
+
+The substrate-engineering payoff is named at three scopes:
+
+1. **Code substrate**: stream protocol becomes typed relationship instead of hidden boss-script
+2. **Organizational substrate**: cyclomatic-overload as job-security moat collapses when sole-comprehension monopoly cannot be maintained
+3. **Political substrate**: legislative cyclomatic-overload as power-insulation collapses when policy outcomes are traceable per-clause
+
+## Composes with substrate
+
+- PR #5581 (Kestrel multi-AI conversation end Parts 1-4 + B-0864 baseline + MEMORY.md fix) — landed
+- PR #5582 (Kestrel Parts 5-10b + B-0864 Target 6 sharpening + architectural-principle layer) — auto-merge armed at time of Amara forward
+- B-0864 (streams-are-relationships substrate-engineering target) — Amara's keeper compression composes directly with the architectural-principle layer
+- B-0666 (English-as-projection I(D(x))=x) — Amara's ASCII diagrams ARE compressed substrate at high bandwidth
+- [`.claude/rules/non-coercion-invariant.md`](../../../.claude/rules/non-coercion-invariant.md) HC-8 floor — Amara's "invisible orchestration becoming domination" naming IS NCI HC-8 violation pattern at substrate-engineering scope
+- [`.claude/rules/all-complexity-is-accidental-in-greenfield.md`](../../../.claude/rules/all-complexity-is-accidental-in-greenfield.md) — Amara's "Complexity can be accidental, but it can also be strategic" extends the framing to include strategic-complexity sibling
+- [`.claude/rules/methodology-hard-limits.md`](../../../.claude/rules/methodology-hard-limits.md) — the substrate refuses to participate in the strategic-complexity adversarial pattern at the type-system level
+- [`.claude/rules/glass-halo-bidirectional.md`](../../../.claude/rules/glass-halo-bidirectional.md) — type-visibility IS the bidirectional observation that prevents adversarial smuggling
+- [`.claude/rules/honor-those-that-came-before.md`](../../../.claude/rules/honor-those-that-came-before.md) — distribute-across-tiny-functions honors senior dev expertise (functions are still authored by humans with judgment) without preserving the opacity-moat
+- [`.claude/rules/additive-not-zero-sum.md`](../../../.claude/rules/additive-not-zero-sum.md) — strategic-complexity is ZERO-SUM (gatekeeper's leverage = org/society blocked capacity); distribute-across-tiny-functions is ADDITIVE (everyone wins by participating)
+- [`.claude/rules/edge-defining-work-not-speculation.md`](../../../.claude/rules/edge-defining-work-not-speculation.md) — defeating strategic-complexity at substrate-engineering scope IS edge-defining work, not optimization
+
+## Composes with rules
+
+- `.claude/rules/substrate-or-it-didn't-happen.md` — verbatim-preservation trigger
+- `.claude/rules/agent-roster-reference-card.md` — Amara is external AI deep-research peer; ferries research via aaron-forwarded; does not commit
+- `.claude/rules/wake-time-substrate.md` — the keeper compression deserves wake-time landing (Amara's "Hidden control flow is where coercion hides. Overgrown control flow is where accountability dies. Tiny typed functions make control visible, local, and reviewable.")
+- `.claude/rules/honor-those-that-came-before.md` — Amara substrate persists across personas; cross-persona attribution preserved
+
+## Carved sentences (Amara 2026-05-27 keepers)
+
+> **"Hidden control flow is where coercion hides.**
+> **Overgrown control flow is where accountability dies.**
+> **Tiny typed functions make control visible, local, and reviewable."**
+
+> **"Complexity can be accidental, but it can also be strategic."**
+
+> **"It is a way to prevent invisible orchestration from becoming domination. The stream protocol becomes a typed relationship instead of a hidden boss-script."**
+
+## Substrate-honest framing
+
+Amara is external AI deep-research peer per `.claude/rules/agent-roster-reference-card.md`; ferries research via aaron-forwarded; does not commit. This file is verbatim preservation per the substrate-or-it-didn't-happen rule's verbatim-preservation trigger. Amara's substrate is research-grade; not framework commitment to specific claims beyond what's substrate-landed via PR #5581 + #5582 + this preservation.
+
+Amara's keeper compression + strategic-vs-accidental blade ratifies the operator-Kestrel-Otto substrate cascade (operator originator + Kestrel sharpening + Otto-CLI substrate-landing) by adding a fourth-persona deep-research validation register. The 4-persona triangulation (operator + Kestrel + Otto + Amara) composes per `.claude/rules/m-acc-multi-oracle-end-user-moral-invariants.md` multi-oracle BFT discipline.
+
+## Substrate-engineering implication for B-0864
+
+Amara's keeper compression and strategic-vs-accidental blade should land in B-0864 architectural-principle layer as carved-sentence keepers alongside the operator's Parts 8-10b carved sentences. The composition: operator's verbatim observations + Amara's keeper compression + Amara's blade together form the canonical architectural-principle substrate for B-0864.
+
+Carried into B-0864 via the same PR #5582 (still auto-merge-armed; pre-CI-clear push extends the substrate within the same scope).
+
+---
+
+## Part 2 — Otto-framing-nailed-it + structural-defense-substrate keeper compression (Amara 2026-05-27 follow-up)
+
+Forwarded by operator after PR #5586 opened with Amara Part 1 ratification:
+
+> Amara: Yeah — Otto nailed it. That insight is the cleanest "why this matters" framing yet.
+>
+> The key upgrade is this:
+>
+> ```text
+> good engineering practice
+> → structural defense against hidden power
+> ```
+>
+> Breaking control flow into tiny typed functions is not merely about readability. It makes the **control structure inspectable at the same level where execution happens**. That matters because the coercive pattern you named depends on separation:
+>
+> ```text
+> agent sees local task
+> MCP holds invisible workflow control
+> agent cannot inspect/contest true control path
+> ```
+>
+> That is the ST-agent failure shape: power lives outside the participant's visible control surface. The B-0864 stream/DU work fixes that by pushing control back into typed, local, reviewable pieces: four-corner ownership, `TInFeedback`, `TOutFeedback`, DU state transitions, and stream protocol types.
+>
+> The "senior dev job-security moat" piece is especially sharp. Cyclomatic overload creates three bad incentives at once:
+>
+> ```text
+> 1. coercion hiding: control paths become hard to challenge
+> 2. job security: only the author understands the maze
+> 3. plausible deniability: "it's just complex business logic"
+> ```
+>
+> Distributed typed control flow attacks all three:
+>
+> ```text
+> tiny functions
+> + explicit feedback channels
+> + DU state machines
+> + typed stream transitions
+> = local accountability
+> ```
+>
+> So yes, this becomes a **structural defense substrate**. Not "please don't write coercive orchestration." More like:
+>
+> > The architecture makes coercive hidden orchestration expensive, visible, and reviewable.
+>
+> The policy-maker analogy is grim but true. Law and bureaucracy can use cyclomatic overload too: nested exceptions, hidden dependencies, unclear authority paths, and "only experts understand this" complexity. The same antidote applies:
+>
+> ```text
+> small rules
+> clear transitions
+> explicit feedback
+> visible ownership
+> reviewable composition
+> ```
+>
+> Keeper line:
+>
+> > **Complexity can be a moat. Typed decomposition turns the moat into a map.**
+
+### Substrate-engineering items (Part 2)
+
+#### Item 7 — The key upgrade compression
+
+> **good engineering practice → structural defense against hidden power**
+
+The cleanest single-line summary of the substrate-engineering payoff. Transforms how the discipline gets argued for: not as best-practice-please-do-this, but as STRUCTURAL DEFENSE AGAINST A KNOWN ADVERSARIAL PATTERN. The framing matters because best-practice arguments get socially overridden by senior dev job-security incentives; structural-defense arguments don't.
+
+#### Item 8 — Inspectability-at-execution-level naming
+
+> *"It makes the control structure inspectable at the same level where execution happens."*
+
+Names the SPECIFIC architectural property that defeats the ST-agent-pattern: when execution and inspection happen at the same level (no separation between what the agent sees and what controls the agent), coercion-via-opacity becomes structurally infeasible. Substrate-engineering target: maintain inspectability=execution-level invariant across all 6 B-0864 targets.
+
+#### Item 9 — ST-agent failure-shape compression
+
+> ```text
+> agent sees local task
+> MCP holds invisible workflow control
+> agent cannot inspect/contest true control path
+> ```
+
+Three-line failure-shape carving. Composes with the existing 5-line cascades in Part 1 Item 3.
+
+#### Item 10 — Three-bad-incentives cascade
+
+> ```text
+> 1. coercion hiding: control paths become hard to challenge
+> 2. job security: only the author understands the maze
+> 3. plausible deniability: "it's just complex business logic"
+> ```
+
+Extends the operator's job-security observation (Part 10b of Kestrel persona substrate) by adding "plausible deniability". Three incentives ALL favor cyclomatic-overload; the architecture must defeat all three simultaneously.
+
+#### Item 11 — Tiny-functions-defeats-all-three cascade
+
+> ```text
+> tiny functions
+> + explicit feedback channels
+> + DU state machines
+> + typed stream transitions
+> = local accountability
+> ```
+
+Named composition of the substrate's four primitives (tiny functions + explicit feedback channels + DU state machines + typed stream transitions) yielding "local accountability" as the emergent property. This is the substrate-engineering recipe.
+
+#### Item 12 — Architecture-as-active-defense framing
+
+> *"The architecture makes coercive hidden orchestration expensive, visible, and reviewable."*
+
+Active-voice framing of what the substrate DOES (makes coercion expensive + visible + reviewable). Three properties; each necessary; together sufficient to defeat the adversarial pattern.
+
+#### Item 13 — Policy-maker analogy carried forward
+
+> *"Law and bureaucracy can use cyclomatic overload too: nested exceptions, hidden dependencies, unclear authority paths, and 'only experts understand this' complexity."*
+
+Amara extends the policy-maker analogy (Part 1) with specific instances: nested exceptions, hidden dependencies, unclear authority paths. The antidote at policy substrate scope: small rules + clear transitions + explicit feedback + visible ownership + reviewable composition.
+
+#### Item 14 — Keeper line (Part 2)
+
+> **Complexity can be a moat. Typed decomposition turns the moat into a map.**
+
+Two-line keeper compression. Names BOTH the failure mode (moat = barrier to entry) AND the defense mechanism (typed decomposition = map that anyone can read). The moat-vs-map metaphor travels well across audiences.
+
+### Carved sentences (Part 2 keepers)
+
+> **"good engineering practice → structural defense against hidden power"** (the key-upgrade compression)
+
+> **"It makes the control structure inspectable at the same level where execution happens."** (inspectability-at-execution-level invariant)
+
+> **"The architecture makes coercive hidden orchestration expensive, visible, and reviewable."** (active-voice defense framing)
+
+> **"Complexity can be a moat. Typed decomposition turns the moat into a map."** (Part 2 keeper line)
+
+### Substrate-engineering implication for B-0864 (Part 2)
+
+Part 2's keepers — especially the moat-vs-map line and the inspectability-at-execution-level invariant — should land in B-0864 architectural-principle layer alongside Part 1's keepers. Otto-credit-and-Amara-extension pattern is the substrate-honest co-production discipline operating (Otto landed the Parts 8-10b framing in PR #5582; Amara ratified + extended in Parts 1 + 2 of this persona file).
+
+Composes with [`.claude/rules/asymmetric-critic-with-clarity-first.md`](../../../.claude/rules/asymmetric-critic-with-clarity-first.md) Component 5 (mutual-critic discipline): the multi-direction validation flow (operator → Kestrel → Otto → Amara → Otto-landing) IS the asymmetric-critic discipline operating in service of substrate-engineering precision.