reshape: decorator-as-seam — port @route codegen, prove decorate->serve, rewrite surface as decorated El

Ground-truth the three seams (route/telemetry+interoception/bus) with file:line
evidence. Port the tested @route codegen+parser from feat/el-route-decorators
into the worktree elc (decoration synthesizes el_route_dispatch — no hand-written
90-branch handle_request). Rebuild elc self-host; prove decorate->serve end-to-end
(route_proof.el on :8951). Rewrite surface.el as El-native decorated components:
@route + @accessor/@manager, in-process engram_* builtins (not http_get), @manager
ops emit on the real dharma_* bus (same transport as wt/swarm-ccr). Identity
keystones refused in write/relate/supersede. Gate-1 clone recipe (WAL-aside
cold-boot + ENGRAM_WAL=on) proves the FULL op set live on the clone. Boundary
auto-emit (telemetry/interoception/bus) staged as a reviewable cg_fn diff
(SEAM_STAGED.md) — needs the cognition-engram rebuild to verify link. Live :8742
untouched; no push, no cutover.

lang/el-compiler/src/parser.el

@@ -1758,23 +1758,68 @@ fn parse_stmt(tokens: [Any], pos: Int) -> Map<String, Any> {
         return make_result({ "stmt": "TryCatch", "try_body": try_body, "catch_name": catch_name, "catch_body": native_list_empty() }, p)
     }
 
-    // @decorator - capture decorator name and attach to following stmt
+    // @decorator - capture decorator name (and optional string args) and
+    // attach to the following stmt. Backward-compatible: bare @manager /
+    // @engine / @accessor still parse (no parens -> empty args). Decorators
+    // STACK: `@route("/p","GET") @manager fn f()` attaches BOTH to f via a
+    // `decorators` list [{name, args}]. The legacy `decorator` string is kept
+    // populated (topmost decorator) so the JS backend keeps working unchanged.
     if k == "At" {
         let p = pos + 1
         let dec_name = tok_value(tokens, p)
         let p = p + 1
+        // Optional decorator argument list: @name("a", "b", ...)
+        let dec_args = native_list_empty()
+        let ka = tok_kind(tokens, p)
+        if str_eq(ka, "LParen") {
+            let p = p + 1
+            let running_da = true
+            while running_da {
+                let kd = tok_kind(tokens, p)
+                if str_eq(kd, "RParen") {
+                    let running_da = false
+                } else {
+                    if str_eq(kd, "Eof") {
+                        let running_da = false
+                    } else {
+                        if str_eq(kd, "Str") {
+                            let dec_args = native_list_append(dec_args, tok_value(tokens, p))
+                        }
+                        let p = p + 1
+                        let kc = tok_kind(tokens, p)
+                        if str_eq(kc, "Comma") {
+                            let p = p + 1
+                        }
+                    }
+                }
+            }
+            let p = expect(tokens, p, "RParen")
+        }
         let r = parse_stmt(tokens, p)
         let inner = r["node"]
         let p2 = r["pos"]
         let inner_kind: String = inner["stmt"]
         if str_eq(inner_kind, "FnDef") {
+            // Stack this decorator (topmost-first) onto any decorators the inner
+            // FnDef already carries from decorators written below this one.
+            let this_dec = { "name": dec_name, "args": dec_args }
+            let existing = inner["decorators"]
+            let dlist = native_list_empty()
+            let dlist = native_list_append(dlist, this_dec)
+            let ne: Int = native_list_len(existing)
+            let ei = 0
+            while ei < ne {
+                let dlist = native_list_append(dlist, native_list_get(existing, ei))
+                let ei = ei + 1
+            }
             let with_dec = {
                 "stmt": "FnDef",
                 "name": inner["name"],
                 "params": inner["params"],
                 "body": inner["body"],
                 "ret_type": inner["ret_type"],
-                "decorator": dec_name
+                "decorator": dec_name,
+                "decorators": dlist
             }
             // r result map fully consumed — release to free peak heap.
             el_release(r)