docs: weave visible-decomposition narrative into spec, curriculum, examples, manifests

Second pass after the survey — extend the Echo "decomposition must be visible"
narrative consistently across the remaining human and bot documentation, and
add a runnable example. Kept strictly Error-Lang-specific.

Human docs:
- docs/Error-Lang.adoc: new "Structured Loss Is Visible (Echo)" design
  principle beside Jenga Semantics; Echo/EchoR keywords; Echo statement +
  annotation syntax.
- docs/Curriculum.adoc: new "Lesson 11: Structured Loss (Echo)".
- docs/Educational-Framework.adoc: Echo decomposition bullet in Week 5-6.
- docs/Error-Categories.adoc: Echo-erasure stability debit under Stability
  Score Impact (noted as a deliberate cost, not an error category).

Example:
- examples/11-echo-decomposition.err: runnable demo — echo, projection,
  echo_to_residue with a visible stability drop, residue_strictly_loses, and
  echo_input-on-residue rejected in a gutter zone.

Bot manifests:
- ECOSYSTEM.a2ml: fill purpose/role/category; record the Echo lineage
  (echo-types, EchoTypes.jl) under related-projects.
- AGENTIC.a2ml: agent constraint preserving visible decomposition.

Author: claude

.machine_readable/6a2/AGENTIC.a2ml

@@ -20,6 +20,11 @@ can-create-files = true
 # - Never use banned languages (TypeScript, Python, Go, etc.)
 # - Never place state files in repository root (must be in .machine_readable/)
 # - Never use AGPL license (use MPL-2.0)
+# - Never break VISIBLE DECOMPOSITION for Echo types:
+#     * do not make echo_to_residue a silent cast
+#     * do not let EchoR<A,B> behave like / coerce to Echo<A,B>
+#     * do not hide the erasure stability debit ([Stab-Erase])
+#   (see docs/Echo-Decomposition.adoc, spec/type-system.md §7)
 
 [maintenance-integrity]
 fail-closed = true

.machine_readable/6a2/ECOSYSTEM.a2ml

@@ -8,13 +8,17 @@ last-updated = "2026-04-11"
 
 [project]
 name = "Error Lang"
-purpose = ""
-role = ""
+purpose = "A dissembling/decompositional educational language that makes the decay and structured loss of programs, semantics, and types VISIBLE."
+role = "Operational, stability-aware embedding of the Echo (structured-loss) lineage; the decomposition-visible member of the Echo family."
 
 [position-in-ecosystem]
-category = ""
+category = "educational-programming-language"
 
 [related-projects]
 projects = [
-  # No related projects recorded
+  # The Echo (structured-loss) lineage that Error-Lang's Echo<A,B>/EchoR<A,B> embed.
+  # Error-Lang stays Error-Lang-specific (visible decomposition); it does not
+  # re-export these repos' exposition.
+  { name = "echo-types", owner = "hyperpolymath", role = "source of mechanized truth (Agda): Echo f y := Σ(x:A), (f x ≡ y)" },
+  { name = "EchoTypes.jl", owner = "hyperpolymath", role = "finite-domain executable model (Julia) — a model, not a proof" },
 ]

docs/Curriculum.adoc

@@ -296,6 +296,40 @@ end
 * Error cascades
 * Panic mode recovery
 
+=== Lesson 11: Structured Loss (Echo)
+
+**Concept**: Decomposition made visible — loss can be structured, but it is never free or hidden
+
+**The Problem**:
+Most languages discard information silently. Error-Lang makes the *moment of loss*
+observable: an `Echo<A, B>` holds a witness and its output; `echo_to_residue`
+erases the witness into an `EchoR<A, B>`, debiting the Stability Score.
+
+**Example**:
+[source,err]
+----
+main
+    let e = echo(42, "answer")          # Echo<Int, String>
+    println(echo_input(e))              # 42 — witness still here
+    println(echo_output(e))             # "answer"
+
+    let r = echo_to_residue(e)          # erasure — stability drops here
+    println(echo_output(r))             # "answer" survives
+    println(residue_strictly_loses(r))  # true — loss is observable
+
+    gutter
+        println(echo_input(r))          # ERROR: the witness is gone
+    end
+end
+----
+
+**Learning Objectives**:
+
+* Structured loss vs. silent discard
+* Irreversibility: `EchoR` never coerces back to `Echo`
+* Consequence amplification: the erasure stability debit is visible, charged once
+* The invariant *decomposition must be visible*
+
 == Assessment Ideas
 
 === Quiz Format

docs/Educational-Framework.adoc

@@ -437,6 +437,7 @@ Students can see and modify aspects interactively!
 - AST visualization
 - How code becomes data structures
 - Tree traversal and transformation
+- Structured loss with Echo: `echo_to_residue` as a visible, irreversible decomposition step (`Echo<A,B>` → `EchoR<A,B>`), and why the witness cannot be recovered — see `docs/Echo-Decomposition.adoc`
 - **Layer focus:** AST (Layer 3)
 
 === Week 7-8: Parsing and Grammars

docs/Error-Categories.adoc

@@ -256,8 +256,13 @@ The `gutter` (ошибка) block is where errors are injected:
 | Arithmetic | -10 | Numeric edge cases
 | Interface | -15 | Design concepts
 | Security | -20 | Critical importance
+| Echo erasure | -15 | Structured loss is not free: `echo_to_residue` debits stability ([Stab-Erase]), charged once and never on projection
 |===
 
+NOTE: The Echo-erasure debit is not an *error* category — it is a deliberate,
+visible decomposition cost. It appears here because it feeds the same Stability
+Score. See `docs/Echo-Decomposition.adoc` and `spec/type-system.md` §7.
+
 == Implementation Notes
 
 === Compiler Phases

docs/Error-Lang.adoc

@@ -43,6 +43,22 @@ error reduces the score. At S=0, execution still works but output becomes
 
 This creates the "it's working, but it's falling apart" aesthetic.
 
+=== Structured Loss Is Visible (Echo)
+
+Where Jenga Semantics decay the *whole program*, Echo types decay a *single
+value* — deliberately, observably, and irreversibly. Error-Lang is a
+decompositional language: when structure is lost, the loss must be **seen**.
+
+* `Echo<A, B>` — a retained witness `x : A` plus the visible output `y : B` it reached.
+* `EchoR<A, B>` — the non-recoverable residue after erasure (the witness is gone).
+* `echo_to_residue(e)` — the explicit decomposition step, `Echo<A,B> → EchoR<A,B>`,
+  which **debits the Stability Score**.
+
+The governing rule is **decomposition must be visible**: `echo_to_residue` is
+never a silent cast, `EchoR` is never an `Echo` with a missing field, and the
+stability debit is never hidden. See `docs/Echo-Decomposition.adoc` and
+`spec/type-system.md` §7.
+
 === Always Recoverable
 
 The parser is error-tolerant. Every injected error is:
@@ -88,6 +104,8 @@ end
 | `gutter` | Error injection zone (safe to break)
 | `if` / `else` | Conditionals (Stage 2+)
 | `function` | Function definition (Stage 2+)
+| `Echo` | Fibre type: retained witness + visible output (`Echo<A, B>`)
+| `EchoR` | Residue type: non-recoverable remains after erasure (`EchoR<A, B>`)
 |===
 
 ==== Literals
@@ -124,6 +142,21 @@ end
 let x = 42
 let message = "Hello"
 let result = x + 10
+let e: Echo<Int, String> = echo(42, "answer")   # type annotation: a fibre witness
+----
+
+==== Echo: Structured Loss
+
+[source,err]
+----
+let e = echo(42, "answer")        # Echo<Int, String>: witness 42 reached "answer"
+let i = echo_input(e)             # 42  — recover the witness
+let o = echo_output(e)            # "answer" — the visible output
+
+let r = echo_to_residue(e)        # EchoR<Int, String> — witness erased; stability drops
+let still = echo_output(r)        # "answer" — output survives erasure
+let lost = residue_strictly_loses(r)   # true — non-recoverability is observable
+# echo_input(r)                   # ERROR: the witness is gone (decomposition is real)
 ----
 
 ==== Output

examples/11-echo-decomposition.err

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MPL-2.0
+# Example: Structured Loss with Echo
+# Learning: decomposition must be VISIBLE — loss can be structured, but never free or hidden
+
+main
+    # An Echo is a retained witness plus the visible output it reached.
+    # echo(42, "answer") : Echo<Int, String>  — "input 42 reached output answer"
+    let e = echo(42, "answer")
+
+    # While we hold the Echo, both halves are recoverable:
+    println("witness:", echo_input(e))   # 42
+    println("output: ", echo_output(e))  # "answer"
+
+    # THE DECOMPOSITION STEP.
+    # echo_to_residue erases the witness, leaving a non-recoverable residue.
+    # This is not a silent cast — it debits the Stability Score ([Stab-Erase]).
+    let r = echo_to_residue(e)           # EchoR<Int, String> ; stability 100 -> 85
+
+    # The output survives erasure...
+    println("output still:", echo_output(r))      # "answer"
+    # ...and the loss itself is observable:
+    println("strictly loses:", residue_strictly_loses(r))   # true
+
+    gutter
+        # The witness is genuinely gone. This is a type error AND a runtime error:
+        # a residue is non-recoverable — EchoR never behaves like an Echo.
+        println(echo_input(r))
+    end
+
+    println("Still running — but the witness is not coming back.")
+end
+
+# 🎓 LEARNING OUTCOME:
+# Echo<A, B>   = retained witness + visible output
+# EchoR<A, B>  = non-recoverable residue after erasure
+# echo_to_residue = the explicit, stability-costed decomposition step
+#
+# The invariant: DECOMPOSITION MUST BE VISIBLE.
+# - echo_to_residue is never a silent cast (watch the stability score drop)
+# - EchoR is never an Echo with a missing field (echo_input on it is rejected)
+# - the stability debit is charged exactly once, never on mere projection
+#
+# See docs/Echo-Decomposition.adoc and spec/type-system.md §7.