agentopology 0.2.5 → 0.4.0

package/dist/parser/__tests__/parser.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
+import { readFileSync, readdirSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse, parseSchemaType, parseSchemaFields, parseParams, parseInterfaceEndpoints, parseImports, parseIncludes } from "../index.js";
@@ -223,7 +223,14 @@ describe("Lexer", () => {
 describe("Parser sections", () => {
     describe("meta", () => {
         it("parses version, description, and patterns from header", () => {
-            const src = `topology test : [pipeline] {\n  meta {\n    version: "2.0.0"\n    description: "A test topology"\n    domain: legal\n  }\n  orchestrator {\n    model: opus\n    handles: [intake]\n  }\n  action intake {\n    kind: inline\n  }\n  flow {\n    intake -> intake\n  }\n}`;
+            const src = `topology test : [pipeline] {\n  meta {
+        version: "2.0.0"\n
+        description: "A test topology"\n
+        domain: legal\n
+      }\n  orchestrator {
+        model: opus\n
+        handles: [intake]\n
+      }\n  action intake {\n    kind: inline\n  }\n  flow {\n    intake -> intake\n  }\n}`;
             const ast = parse(src);
             expect(ast.topology.name).toBe("test");
             expect(ast.topology.version).toBe("2.0.0");
@@ -232,7 +239,14 @@ describe("Parser sections", () => {
             expect(ast.topology.domain).toBe("legal");
         });
         it("parses foundations and advanced lists", () => {
-            const src = `topology t : [pipeline] {\n  meta {\n    version: "1.0.0"\n    foundations: [pipeline, fan-out]\n    advanced: [consensus]\n  }\n  orchestrator {\n    model: opus\n    handles: [a]\n  }\n  action a { kind: inline }\n  flow { a -> a }\n}`;
+            const src = `topology t : [pipeline] {\n  meta {
+        version: "1.0.0"\n
+        foundations: [pipeline, fan-out]\n
+        advanced: [consensus]\n
+      }\n  orchestrator {
+        model: opus\n
+        handles: [a]\n
+      }\n  action a { kind: inline }\n  flow { a -> a }\n}`;
             const ast = parse(src);
             expect(ast.topology.foundations).toEqual(["pipeline", "fan-out"]);
             expect(ast.topology.advanced).toEqual(["consensus"]);
@@ -252,7 +266,10 @@ describe("Parser sections", () => {
     });
     describe("roles", () => {
         it("parses multiple role definitions", () => {
-            const src = `topology t : [pipeline] {\n  roles {\n    writer: "Writes drafts"\n    reviewer: "Reviews content"\n  }\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n}`;
+            const src = `topology t : [pipeline] {\n  roles {\n    writer: "Writes drafts"\n    reviewer: "Reviews content"\n  }\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n}`;
             const ast = parse(src);
             expect(ast.roles).toEqual({
                 writer: "Writes drafts",
@@ -262,7 +279,13 @@ describe("Parser sections", () => {
     });
     describe("action", () => {
         it("parses inline action", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a {\n    kind: inline\n    description: "Parse request"\n  }\n  flow { a -> a }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a {
+        kind: inline\n
+        description: "Parse request"\n
+      }\n  flow { a -> a }\n}`;
             const ast = parse(src);
             const action = ast.nodes.find((n) => n.id === "a");
             expect(action).toBeDefined();
@@ -273,7 +296,13 @@ describe("Parser sections", () => {
             }
         });
         it("parses external action with source", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [fetch] }\n  action fetch {\n    kind: external\n    source: "github-pr"\n  }\n  flow { fetch -> fetch }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [fetch]
+      }\n  action fetch {
+        kind: external\n
+        source: "github-pr"\n
+      }\n  flow { fetch -> fetch }\n}`;
             const ast = parse(src);
             const action = ast.nodes.find((n) => n.id === "fetch");
             if (action.type === "action") {
@@ -282,7 +311,13 @@ describe("Parser sections", () => {
             }
         });
         it("parses action with commands list", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [build] }\n  action build {\n    kind: inline\n    commands: [npm install, npm test]\n  }\n  flow { build -> build }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [build]
+      }\n  action build {
+        kind: inline\n
+        commands: [npm install, npm test]\n
+      }\n  flow { build -> build }\n}`;
             const ast = parse(src);
             const action = ast.nodes.find((n) => n.id === "build");
             if (action.type === "action") {
@@ -292,7 +327,25 @@ describe("Parser sections", () => {
     });
     describe("agent", () => {
         it("parses all basic fields", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent my-agent {\n    model: sonnet\n    phase: 2\n    tools: [Read, Write]\n    reads: ["workspace/input"]\n    writes: ["workspace/output"]\n    permissions: auto\n    behavior: advisory\n    invocation: manual\n    isolation: worktree\n    background: true\n    retry: 3\n    skip: "depth < 2"\n    description: "Test agent"\n    max-turns: 10\n  }\n  flow { a -> a }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent my-agent {
+        model: sonnet\n
+        phase: 2\n
+        tools: [Read, Write]\n
+        reads: ["workspace/input"]\n
+        writes: ["workspace/output"]\n
+        permissions: auto\n
+        behavior: advisory\n
+        invocation: manual\n
+        isolation: worktree\n
+        background: true\n
+        retry: 3\n
+        skip: "depth < 2"\n
+        description: "Test agent"\n
+        max-turns: 10\n
+      }\n  flow { a -> a }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "my-agent");
             expect(agent).toBeDefined();
@@ -312,7 +365,10 @@ describe("Parser sections", () => {
             expect(agent.maxTurns).toBe(10);
         });
         it("parses inline prompt block", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n    prompt {\n      You are a writer.\n      Write good content.\n    }\n  }\n  flow { a -> writer }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n    prompt {\n      You are a writer.\n      Write good content.\n    }\n  }\n  flow { a -> writer }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "writer");
             expect(agent.prompt).toBeDefined();
@@ -320,19 +376,31 @@ describe("Parser sections", () => {
             expect(agent.prompt).toContain("Write good content.");
         });
         it("parses disallowed-tools", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent safe {\n    model: opus\n    disallowed-tools: [Bash, Write]\n  }\n  flow { a -> safe }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent safe {
+        model: opus\n
+        disallowed-tools: [Bash, Write]\n
+      }\n  flow { a -> safe }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "safe");
             expect(agent.disallowedTools).toEqual(["Bash", "Write"]);
         });
         it("parses outputs block", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent scorer {\n    model: opus\n    outputs {\n      quality: high | medium | low\n    }\n  }\n  flow { a -> scorer }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent scorer {\n    model: opus\n    outputs {\n      quality: high | medium | low\n    }\n  }\n  flow { a -> scorer }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "scorer");
             expect(agent.outputs).toEqual({ quality: ["high", "medium", "low"] });
         });
         it("parses scale block", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent worker {\n    model: opus\n    scale {\n      mode: auto\n      by: doc-count\n      min: 2\n      max: 8\n      batch-size: 50\n    }\n  }\n  flow { a -> worker }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent worker {\n    model: opus\n    scale {\n      mode: auto\n      by: doc-count\n      min: 2\n      max: 8\n      batch-size: 50\n    }\n  }\n  flow { a -> worker }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "worker");
             expect(agent.scale).toEqual({
@@ -344,7 +412,16 @@ describe("Parser sections", () => {
             });
         });
         it("parses per-agent hooks block", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent hooked {\n    model: opus\n    hooks {\n      hook pre-tool {\n        on: PreToolUse\n        matcher: "Bash"\n        run: "scripts/check.sh"\n        type: command\n        timeout: 5000\n      }\n    }\n  }\n  flow { a -> hooked }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent hooked {\n    model: opus\n    hooks {\n      hook pre-tool {
+        on: PreToolUse\n
+        matcher: "Bash"\n
+        run: "scripts/check.sh"\n
+        type: command\n
+        timeout: 5000\n
+      }\n    }\n  }\n  flow { a -> hooked }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "hooked");
             expect(agent.hooks).toBeDefined();
@@ -357,7 +434,10 @@ describe("Parser sections", () => {
             expect(agent.hooks[0].timeout).toBe(5000);
         });
         it("parses extensions block", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent extended {\n    model: opus\n    extensions {\n      openclaw {\n        calendar-integration: true\n        port: 8080\n      }\n    }\n  }\n  flow { a -> extended }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent extended {\n    model: opus\n    extensions {\n      openclaw {\n        calendar-integration: true\n        port: 8080\n      }\n    }\n  }\n  flow { a -> extended }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "extended");
             expect(agent.extensions).toBeDefined();
@@ -367,19 +447,34 @@ describe("Parser sections", () => {
             });
         });
         it("parses mcp-servers list", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent mcp-user {\n    model: opus\n    mcp-servers: [storage, monitoring]\n  }\n  flow { a -> mcp-user }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent mcp-user {
+        model: opus\n
+        mcp-servers: [storage, monitoring]\n
+      }\n  flow { a -> mcp-user }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "mcp-user");
             expect(agent.mcpServers).toEqual(["storage", "monitoring"]);
         });
         it("parses skills list", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent skilled {\n    model: opus\n    skills: [extraction, classification]\n  }\n  flow { a -> skilled }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent skilled {
+        model: opus\n
+        skills: [extraction, classification]\n
+      }\n  flow { a -> skilled }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "skilled");
             expect(agent.skills).toEqual(["extraction", "classification"]);
         });
         it("attaches role from roles block", () => {
-            const src = `topology t : [pipeline] {\n  roles {\n    writer: "Writes things"\n  }\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n  }\n  flow { a -> writer }\n}`;
+            const src = `topology t : [pipeline] {\n  roles {\n    writer: "Writes things"\n  }\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n  }\n  flow { a -> writer }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "writer");
             expect(agent.role).toBe("Writes things");
@@ -387,14 +482,20 @@ describe("Parser sections", () => {
     });
     describe("flow", () => {
         it("parses simple chain", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a, c] }\n  action a { kind: inline }\n  agent b { model: opus }\n  action c { kind: report }\n  flow {\n    a -> b -> c\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a, c]
+      }\n  action a { kind: inline }\n  agent b { model: opus }\n  action c { kind: report }\n  flow {\n    a -> b -> c\n  }\n}`;
             const ast = parse(src);
             expect(ast.edges).toHaveLength(2);
             expect(ast.edges[0]).toEqual({ from: "a", to: "b", condition: null, maxIterations: null, per: null });
             expect(ast.edges[1]).toEqual({ from: "b", to: "c", condition: null, maxIterations: null, per: null });
         });
         it("parses fan-out [a, b]", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [start] }\n  action start { kind: inline }\n  agent x { model: opus }\n  agent y { model: opus }\n  flow {\n    start -> [x, y]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [start]
+      }\n  action start { kind: inline }\n  agent x { model: opus }\n  agent y { model: opus }\n  flow {\n    start -> [x, y]\n  }\n}`;
             const ast = parse(src);
             expect(ast.edges).toHaveLength(2);
             expect(ast.edges[0].from).toBe("start");
@@ -403,7 +504,10 @@ describe("Parser sections", () => {
             expect(ast.edges[1].to).toBe("y");
         });
         it("parses conditions [when x.y == z]", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { verdict: yes | no } }\n  agent c { model: opus }\n  flow {\n    b -> c [when b.verdict == yes]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { verdict: yes | no } }\n  agent c { model: opus }\n  flow {\n    b -> c [when b.verdict == yes]\n  }\n}`;
             const ast = parse(src);
             const edge = ast.edges.find((e) => e.from === "b" && e.to === "c");
             expect(edge).toBeDefined();
@@ -411,7 +515,10 @@ describe("Parser sections", () => {
             expect(edge.maxIterations).toBeNull();
         });
         it("parses bounded loops [max N]", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus }\n  agent c { model: opus }\n  flow {\n    c -> b [max 3]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent b { model: opus }\n  agent c { model: opus }\n  flow {\n    c -> b [max 3]\n  }\n}`;
             const ast = parse(src);
             const edge = ast.edges.find((e) => e.from === "c" && e.to === "b");
             expect(edge).toBeDefined();
@@ -419,7 +526,10 @@ describe("Parser sections", () => {
             expect(edge.condition).toBeNull();
         });
         it("parses combined [when x.y == z, max 3]", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { verdict: yes | no } }\n  agent c { model: opus }\n  flow {\n    c -> b [when c.verdict == no, max 3]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { verdict: yes | no } }\n  agent c { model: opus }\n  flow {\n    c -> b [when c.verdict == no, max 3]\n  }\n}`;
             const ast = parse(src);
             const edge = ast.edges.find((e) => e.from === "c" && e.to === "b");
             expect(edge).toBeDefined();
@@ -429,7 +539,18 @@ describe("Parser sections", () => {
     });
     describe("gates", () => {
         it("parses gate with all fields", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus }\n  agent c { model: opus }\n  gates {\n    gate quality {\n      after: b\n      before: c\n      run: "scripts/check.sh"\n      checks: [grammar, formatting]\n      on-fail: bounce-back\n      retry: 2\n      behavior: blocking\n    }\n  }\n  flow { a -> b -> c }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent b { model: opus }\n  agent c { model: opus }\n  gates {\n    gate quality {
+        after: b\n
+        before: c\n
+        run: "scripts/check.sh"\n
+        checks: [grammar, formatting]\n
+        on-fail: bounce-back\n
+        retry: 2\n
+        behavior: blocking\n
+      }\n  }\n  flow { a -> b -> c }\n}`;
             const ast = parse(src);
             const gate = ast.nodes.find((n) => n.id === "quality");
             expect(gate).toBeDefined();
@@ -443,7 +564,10 @@ describe("Parser sections", () => {
             expect(gate.behavior).toBe("blocking");
         });
         it("parses gate with extensions", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus }\n  gates {\n    gate ext-gate {\n      after: b\n      run: "check.sh"\n      extensions {\n        custom {\n          enabled: true\n        }\n      }\n    }\n  }\n  flow { a -> b }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent b { model: opus }\n  gates {\n    gate ext-gate {\n      after: b\n      run: "check.sh"\n      extensions {\n        custom {\n          enabled: true\n        }\n      }\n    }\n  }\n  flow { a -> b }\n}`;
             const ast = parse(src);
             const gate = ast.nodes.find((n) => n.id === "ext-gate");
             expect(gate.extensions).toBeDefined();
@@ -452,7 +576,10 @@ describe("Parser sections", () => {
     });
     describe("depth", () => {
         it("parses levels and factors", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  depth {\n    factors: [batch-count, token-volume]\n    level 1 "Quick" {\n      omit: [reviewer]\n    }\n    level 2 "Full" {\n      omit: []\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  depth {\n    factors: [batch-count, token-volume]\n    level 1 "Quick" {\n      omit: [reviewer]\n    }\n    level 2 "Full" {\n      omit: []\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.depth.factors).toEqual(["batch-count", "token-volume"]);
             expect(ast.depth.levels).toHaveLength(2);
@@ -462,7 +589,10 @@ describe("Parser sections", () => {
     });
     describe("memory", () => {
         it("parses workspace, domains, and metrics", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    workspace {\n      path: "workspace/"\n      protocol: "proto.md"\n      structure: [raw, processed]\n    }\n    domains {\n      path: "domains/"\n      routing: "FILE_MAP.md"\n    }\n    metrics {\n      path: "metrics.jsonl"\n      mode: append-only\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    workspace {\n      path: "workspace/"\n      protocol: "proto.md"\n      structure: [raw, processed]\n    }\n    domains {\n      path: "domains/"\n      routing: "FILE_MAP.md"\n    }\n    metrics {\n      path: "metrics.jsonl"\n      mode: append-only\n    }\n  }\n}`;
             const ast = parse(src);
             const ws = ast.memory["workspace"];
             expect(ws["path"]).toBe("workspace/");
@@ -478,7 +608,10 @@ describe("Parser sections", () => {
     });
     describe("batch", () => {
         it("parses parallel, per, workspace, and conflicts", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  batch {\n    parallel: true\n    per: ticket\n    workspace: "runs/{BATCH_ID}/"\n    conflicts {\n      detect: ["workspace/out.json"]\n      resolve: sequential-rebase\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  batch {\n    parallel: true\n    per: ticket\n    workspace: "runs/{BATCH_ID}/"\n    conflicts {\n      detect: ["workspace/out.json"]\n      resolve: sequential-rebase\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.batch["parallel"]).toBe(true);
             expect(ast.batch["per"]).toBe("ticket");
@@ -490,7 +623,10 @@ describe("Parser sections", () => {
     });
     describe("environments", () => {
         it("parses multiple named environment blocks", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  environments {\n    staging {\n      bucket: "stage-bucket"\n    }\n    production {\n      bucket: "prod-bucket"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  environments {\n    staging {\n      bucket: "stage-bucket"\n    }\n    production {\n      bucket: "prod-bucket"\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.environments["staging"]).toEqual({ bucket: "stage-bucket" });
             expect(ast.environments["production"]).toEqual({ bucket: "prod-bucket" });
@@ -498,7 +634,10 @@ describe("Parser sections", () => {
     });
     describe("triggers", () => {
         it("parses command with pattern", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  triggers {\n    command audit {\n      pattern: "/audit"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  triggers {\n    command audit {\n      pattern: "/audit"\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.triggers).toHaveLength(1);
             expect(ast.triggers[0].name).toBe("audit");
@@ -506,7 +645,10 @@ describe("Parser sections", () => {
             expect(ast.triggers[0].argument).toBeUndefined();
         });
         it("parses command with pattern and argument", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  triggers {\n    command create {\n      pattern: "/create <TOPIC>"\n      argument: TOPIC\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  triggers {\n    command create {\n      pattern: "/create <TOPIC>"\n      argument: TOPIC\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.triggers[0].name).toBe("create");
             expect(ast.triggers[0].pattern).toBe("/create <TOPIC>");
@@ -515,7 +657,16 @@ describe("Parser sections", () => {
     });
     describe("hooks", () => {
         it("parses hooks with on, run, type, matcher, timeout", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  hooks {\n    hook my-hook {\n      on: PreToolUse\n      matcher: "Bash"\n      run: "scripts/guard.sh"\n      type: command\n      timeout: 3000\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  hooks {\n    hook my-hook {
+        on: PreToolUse\n
+        matcher: "Bash"\n
+        run: "scripts/guard.sh"\n
+        type: command\n
+        timeout: 3000\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.hooks).toHaveLength(1);
             expect(ast.hooks[0].name).toBe("my-hook");
@@ -528,7 +679,10 @@ describe("Parser sections", () => {
     });
     describe("settings", () => {
         it("parses allow, deny, ask lists", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    allow: [Read, Write]\n    deny: [Bash]\n    ask: [Edit]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    allow: [Read, Write]\n    deny: [Bash]\n    ask: [Edit]\n  }\n}`;
             const ast = parse(src);
             expect(ast.settings["allow"]).toEqual(["Read", "Write"]);
             expect(ast.settings["deny"]).toEqual(["Bash"]);
@@ -537,7 +691,10 @@ describe("Parser sections", () => {
     });
     describe("mcp-servers", () => {
         it("parses stdio and http server types", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  mcp-servers {\n    storage {\n      type: stdio\n      command: "npx"\n      args: ["-y", "storage-server"]\n    }\n    monitor {\n      type: http\n      url: "https://mcp.example.com"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  mcp-servers {\n    storage {\n      type: stdio\n      command: "npx"\n      args: ["-y", "storage-server"]\n    }\n    monitor {\n      type: http\n      url: "https://mcp.example.com"\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.mcpServers["storage"]).toBeDefined();
             expect(ast.mcpServers["storage"]["type"]).toBe("stdio");
@@ -549,7 +706,10 @@ describe("Parser sections", () => {
     });
     describe("metering", () => {
         it("parses track, per, output, format, pricing", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  metering {\n    track: [tokens-in, tokens-out, cost]\n    per: [agent, run]\n    output: "metrics/"\n    format: jsonl\n    pricing: anthropic-current\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  metering {\n    track: [tokens-in, tokens-out, cost]\n    per: [agent, run]\n    output: "metrics/"\n    format: jsonl\n    pricing: anthropic-current\n  }\n}`;
             const ast = parse(src);
             expect(ast.metering).not.toBeNull();
             expect(ast.metering.track).toEqual(["tokens-in", "tokens-out", "cost"]);
@@ -561,7 +721,10 @@ describe("Parser sections", () => {
     });
     describe("tools", () => {
         it("parses tool with script, args, lang, description", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  tools {\n    tool extract-pdf {\n      script: "scripts/extract.py"\n      args: [input, output]\n      lang: python\n      description: "Extract text from PDF"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  tools {\n    tool extract-pdf {\n      script: "scripts/extract.py"\n      args: [input, output]\n      lang: python\n      description: "Extract text from PDF"\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.toolDefs).toHaveLength(1);
             expect(ast.toolDefs[0].id).toBe("extract-pdf");
@@ -573,7 +736,10 @@ describe("Parser sections", () => {
     });
     describe("skill", () => {
         it("parses all skill fields", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  skill my-skill {\n    description: "A test skill"\n    scripts: [script-a, script-b]\n    domains: ["domains/rubric.md"]\n    references: ["ref/guide.md"]\n    prompt: "prompts/skill.md"\n    disable-model-invocation: true\n    user-invocable: false\n    context: fork\n    agent: task-agent\n    allowed-tools: [Read, Write]\n    extensions {\n      custom {\n        key: value\n      }\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  skill my-skill {\n    description: "A test skill"\n    scripts: [script-a, script-b]\n    domains: ["domains/rubric.md"]\n    references: ["ref/guide.md"]\n    prompt: "prompts/skill.md"\n    disable-model-invocation: true\n    user-invocable: false\n    context: fork\n    agent: task-agent\n    allowed-tools: [Read, Write]\n    extensions {\n      custom {\n        key: value\n      }\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.skills).toHaveLength(1);
             const skill = ast.skills[0];
@@ -594,7 +760,10 @@ describe("Parser sections", () => {
     });
     describe("context", () => {
         it("parses file and includes", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  context {\n    file: "CONTEXT.md"\n    includes: [README.md, CONTRIBUTING.md]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  context {\n    file: "CONTEXT.md"\n    includes: [README.md, CONTRIBUTING.md]\n  }\n}`;
             const ast = parse(src);
             expect(ast.context.file).toBe("CONTEXT.md");
             expect(ast.context.includes).toEqual(["README.md", "CONTRIBUTING.md"]);
@@ -602,7 +771,10 @@ describe("Parser sections", () => {
     });
     describe("env", () => {
         it("parses key-value pairs", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  env {\n    API_KEY: "sk-123"\n    REGION: "us-east-1"\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  env {\n    API_KEY: "sk-123"\n    REGION: "us-east-1"\n  }\n}`;
             const ast = parse(src);
             expect(ast.env["API_KEY"]).toBe("sk-123");
             expect(ast.env["REGION"]).toBe("us-east-1");
@@ -610,7 +782,10 @@ describe("Parser sections", () => {
     });
     describe("providers", () => {
         it("parses provider with all fields", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  providers {\n    anthropic {\n      api-key: "\${ANTHROPIC_API_KEY}"\n      base-url: "https://api.anthropic.com"\n      models: [opus, sonnet, haiku]\n      default: true\n    }\n    openai {\n      api-key: "\${OPENAI_API_KEY}"\n      models: [gpt-4o]\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  providers {\n    anthropic {\n      api-key: "\${ANTHROPIC_API_KEY}"\n      base-url: "https://api.anthropic.com"\n      models: [opus, sonnet, haiku]\n      default: true\n    }\n    openai {\n      api-key: "\${OPENAI_API_KEY}"\n      models: [gpt-4o]\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.providers).toHaveLength(2);
             expect(ast.providers[0].name).toBe("anthropic");
@@ -625,7 +800,13 @@ describe("Parser sections", () => {
     });
     describe("schedule", () => {
         it("parses job with cron", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job nightly {\n      cron: "0 0 * * *"\n      agent: worker\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job nightly {
+        cron: "0 0 * * *"\n
+        agent: worker\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.schedules).toHaveLength(1);
             expect(ast.schedules[0].id).toBe("nightly");
@@ -634,7 +815,14 @@ describe("Parser sections", () => {
             expect(ast.schedules[0].enabled).toBe(true);
         });
         it("parses job with every", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job weekly {\n      every: "monday 9:00"\n      agent: worker\n      enabled: true\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job weekly {
+        every: "monday 9:00"\n
+        agent: worker\n
+        enabled: true\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.schedules).toHaveLength(1);
             expect(ast.schedules[0].id).toBe("weekly");
@@ -643,14 +831,24 @@ describe("Parser sections", () => {
             expect(ast.schedules[0].enabled).toBe(true);
         });
         it("parses job with enabled: false", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job disabled-job {\n      cron: "0 0 * * *"\n      agent: worker\n      enabled: false\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent worker { model: opus }\n  flow { a -> worker }\n  schedule {\n    job disabled-job {
+        cron: "0 0 * * *"\n
+        agent: worker\n
+        enabled: false\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.schedules[0].enabled).toBe(false);
         });
     });
     describe("interfaces", () => {
         it("parses multiple interfaces with type and config", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  interfaces {\n    slack {\n      type: webhook\n      webhook: "\${SLACK_URL}"\n      channel: "alerts"\n    }\n    dashboard {\n      type: http\n      port: 8080\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  interfaces {\n    slack {\n      type: webhook\n      webhook: "\${SLACK_URL}"\n      channel: "alerts"\n    }\n    dashboard {\n      type: http\n      port: 8080\n    }\n  }\n}`;
             const ast = parse(src);
             expect(ast.interfaces).toHaveLength(2);
             const slack = ast.interfaces.find((i) => i.id === "slack");
@@ -666,32 +864,56 @@ describe("Parser sections", () => {
     });
     describe("sandbox", () => {
         it("parses sandbox field on agent (string value)", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent sandboxed { model: opus\n    sandbox: docker }\n  flow { a -> sandboxed }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent sandboxed {
+        model: opus\n
+        sandbox: docker
+      }\n  flow { a -> sandboxed }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "sandboxed");
             expect(agent.sandbox).toBe("docker");
         });
         it("parses sandbox: true on agent", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent sandboxed { model: opus\n    sandbox: true }\n  flow { a -> sandboxed }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent sandboxed {
+        model: opus\n
+        sandbox: true
+      }\n  flow { a -> sandboxed }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "sandboxed");
             expect(agent.sandbox).toBe(true);
         });
         it("parses sandbox in settings", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    sandbox: network-only\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    sandbox: network-only\n  }\n}`;
             const ast = parse(src);
             expect(ast.settings["sandbox"]).toBe("network-only");
         });
     });
     describe("fallback-chain", () => {
         it("parses fallback-chain on agent", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent resilient { model: opus\n    fallback-chain: [sonnet, haiku] }\n  flow { a -> resilient }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  agent resilient {
+        model: opus\n
+        fallback-chain: [sonnet, haiku]
+      }\n  flow { a -> resilient }\n}`;
             const ast = parse(src);
             const agent = ast.nodes.find((n) => n.id === "resilient");
             expect(agent.fallbackChain).toEqual(["sonnet", "haiku"]);
         });
         it("parses fallback-chain in settings", () => {
-            const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    fallback-chain: [opus, sonnet, haiku]\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  orchestrator {
+        model: opus\n
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  settings {\n    fallback-chain: [opus, sonnet, haiku]\n  }\n}`;
             const ast = parse(src);
             expect(ast.settings["fallbackChain"]).toEqual(["opus", "sonnet", "haiku"]);
         });
@@ -1366,33 +1588,60 @@ describe("Integration: example files", () => {
 // =========================================================================
 describe("Edge cases", () => {
     it("inline comments are stripped from agent model", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent worker {\n    model: opus  # main model\n    tools: [Read, Write]  # core tools\n  }\n  flow { a -> worker }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent worker {
+      model: opus  # main model\n
+      tools: [Read, Write]  # core tools\n
+    }\n  flow { a -> worker }\n}`;
         const ast = parse(src);
         const agent = ast.nodes.find((n) => n.id === "worker");
         expect(agent.model).toBe("opus");
         expect(agent.tools).toEqual(["Read", "Write"]);
     });
     it("prompt blocks with # characters inside are preserved", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n    prompt {\n      # Step 1: Research\n      Do research.\n      # Step 2: Write\n      Write content.\n    }\n  }\n  flow { a -> writer }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent writer {\n    model: opus\n    prompt {\n      # Step 1: Research\n      Do research.\n      # Step 2: Write\n      Write content.\n    }\n  }\n  flow { a -> writer }\n}`;
         const ast = parse(src);
         const agent = ast.nodes.find((n) => n.id === "writer");
         expect(agent.prompt).toContain("# Step 1: Research");
         expect(agent.prompt).toContain("# Step 2: Write");
     });
     it("nested braces in prompt blocks", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent coder {\n    model: opus\n    prompt {\n      Output JSON like:\n      { "key": { "nested": true } }\n    }\n  }\n  flow { a -> coder }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent coder {\n    model: opus\n    prompt {\n      Output JSON like:\n      { "key": { "nested": true } }\n    }\n  }\n  flow { a -> coder }\n}`;
         const ast = parse(src);
         const agent = ast.nodes.find((n) => n.id === "coder");
         expect(agent.prompt).toContain('"key"');
     });
     it("agent with decimal phase numbers", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent precise {\n    model: opus\n    phase: 4.5\n  }\n  flow { a -> precise }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent precise {
+      model: opus\n
+      phase: 4.5\n
+    }\n  flow { a -> precise }\n}`;
         const ast = parse(src);
         const agent = ast.nodes.find((n) => n.id === "precise");
         expect(agent.phase).toBe(4.5);
     });
     it("multiple agents with same phase number", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent p1 {\n    model: opus\n    phase: 1\n  }\n  agent p2 {\n    model: opus\n    phase: 1\n  }\n  flow { a -> [p1, p2] }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent p1 {
+      model: opus\n
+      phase: 1\n
+    }\n  agent p2 {
+      model: opus\n
+      phase: 1\n
+    }\n  flow { a -> [p1, p2] }\n}`;
         const ast = parse(src);
         const p1 = ast.nodes.find((n) => n.id === "p1");
         const p2 = ast.nodes.find((n) => n.id === "p2");
@@ -1400,14 +1649,26 @@ describe("Edge cases", () => {
         expect(p2.phase).toBe(1);
     });
     it("gate with only after (no before)", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus }\n  gates {\n    gate after-only {\n      after: b\n      run: "check.sh"\n    }\n  }\n  flow { a -> b }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent b { model: opus }\n  gates {\n    gate after-only {
+      after: b\n
+      run: "check.sh"\n
+    }\n  }\n  flow { a -> b }\n}`;
         const ast = parse(src);
         const gate = ast.nodes.find((n) => n.id === "after-only");
         expect(gate.after).toBe("b");
         expect(gate.before).toBeUndefined();
     });
     it("hook with only on and run (minimal)", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  hooks {\n    hook minimal {\n      on: Stop\n      run: "cleanup.sh"\n    }\n  }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  flow { a -> a }\n  hooks {\n    hook minimal {
+      on: Stop\n
+      run: "cleanup.sh"\n
+    }\n  }\n}`;
         const ast = parse(src);
         expect(ast.hooks).toHaveLength(1);
         expect(ast.hooks[0].name).toBe("minimal");
@@ -1417,21 +1678,30 @@ describe("Edge cases", () => {
         expect(ast.hooks[0].timeout).toBeUndefined();
     });
     it("empty sections produce reasonable defaults", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n  }\n  settings {\n  }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n  }\n  settings {\n  }\n}`;
         const ast = parse(src);
         expect(ast.memory).toEqual({});
         expect(ast.settings).toEqual({ allow: [], deny: [], ask: [] });
     });
     it("extremely long prompt block", () => {
         const longContent = "This is a very long line. ".repeat(500);
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent verbose {\n    model: opus\n    prompt {\n      ${longContent}\n    }\n  }\n  flow { a -> verbose }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent verbose {\n    model: opus\n    prompt {\n      ${longContent}\n    }\n  }\n  flow { a -> verbose }\n}`;
         const ast = parse(src);
         const agent = ast.nodes.find((n) => n.id === "verbose");
         expect(agent.prompt).toBeDefined();
         expect(agent.prompt.length).toBeGreaterThan(1000);
     });
     it("flow with combined [when x.y == z, max 3]", () => {
-        const src = `topology t : [pipeline] {\n  orchestrator { model: opus\n    handles: [a] }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { status: pass | fail } }\n  agent c { model: opus }\n  flow {\n    c -> b [when b.status == fail, max 3]\n  }\n}`;
+        const src = `topology t : [pipeline] {\n  orchestrator {
+      model: opus\n
+      handles: [a]
+    }\n  action a { kind: inline }\n  agent b { model: opus\n    outputs { status: pass | fail } }\n  agent c { model: opus }\n  flow {\n    c -> b [when b.status == fail, max 3]\n  }\n}`;
         const ast = parse(src);
         const edge = ast.edges.find((e) => e.from === "c" && e.to === "b");
         expect(edge).toBeDefined();
@@ -1465,7 +1735,10 @@ describe("Parse errors (should throw)", () => {
 describe("Validation errors", () => {
     it("V1 UniqueNames: two agents with the same id", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent dup { model: opus }
   agent dup { model: sonnet }
@@ -1479,7 +1752,10 @@ describe("Validation errors", () => {
     });
     it("V3 FlowReferences: flow edge referencing a non-existent node", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent real { model: opus }
   flow { a -> ghost }
@@ -1492,7 +1768,10 @@ describe("Validation errors", () => {
     });
     it("V14 ToolExclusivity: agent with both tools and disallowed-tools", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent confused {
     model: opus
@@ -1509,7 +1788,10 @@ describe("Validation errors", () => {
     });
     it("V6 LoopBound: back-edge without max N annotation", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent step1 { model: opus }
   agent step2 { model: opus }
@@ -1527,7 +1809,10 @@ describe("Validation errors", () => {
     });
     it("V6 NoSelfEdges: self-referencing edge without max bound", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent analyzer { model: opus }
   flow {
@@ -1543,7 +1828,10 @@ describe("Validation errors", () => {
     });
     it("V13 GateAnchors: gate with after referencing non-existent node", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent worker { model: opus }
   gates {
@@ -1567,7 +1855,10 @@ describe("Validation errors", () => {
 describe("Validation warnings", () => {
     it("V18 ModelNotInProvider: agent uses model not listed in any provider", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent worker {
     model: mystery-model
@@ -1588,7 +1879,10 @@ describe("Validation warnings", () => {
     });
     it("V22 FallbackNotInProvider: fallback chain model not in provider", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent worker {
     model: opus
@@ -1615,7 +1909,10 @@ describe("Validation warnings", () => {
 describe("Edge cases that should NOT throw", () => {
     it("agent with no tools parses fine", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent bare { model: opus }
   flow { a -> bare }
@@ -1627,7 +1924,10 @@ describe("Edge cases that should NOT throw", () => {
     });
     it("agent with empty prompt block", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent empty-prompt {
     model: opus
@@ -1642,7 +1942,10 @@ describe("Edge cases that should NOT throw", () => {
     });
     it("flow with no conditions (all unconditional edges)", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent s1 { model: opus }
   agent s2 { model: opus }
@@ -1661,7 +1964,10 @@ describe("Edge cases that should NOT throw", () => {
     });
     it("topology with no agents (just an orchestrator)", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
 }`;
@@ -1741,7 +2047,10 @@ topology test-v12-invalid : [pipeline] {
     it("[max 3] alone (no when) should produce no V12 error", () => {
         const src = `
 topology test-v12-maxonly : [pipeline] {
-  orchestrator { model: sonnet handles: [intake] }
+  orchestrator {
+    model: sonnet
+    handles: [intake]
+  }
   action intake {}
   agent worker { model: sonnet }
   flow {
@@ -1776,7 +2085,10 @@ topology test-v12-whenonly : [pipeline] {
 describe("Flow parsing edge cases (Phase 2)", () => {
     it("chain with 3+ nodes: a -> b -> c -> d produces 3 edges", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   agent c { model: opus }
@@ -1815,7 +2127,10 @@ describe("Flow parsing edge cases (Phase 2)", () => {
     });
     it("empty flow block produces empty edges array", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow {
   }
@@ -1825,9 +2140,15 @@ describe("Flow parsing edge cases (Phase 2)", () => {
     });
     it("single node (no arrow) produces no edges", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
-  agent lonely { model: opus invocation: manual }
+  agent lonely {
+    model: opus
+    invocation: manual
+  }
   flow {
   }
 }`;
@@ -1841,7 +2162,10 @@ describe("Role prefix matching (Phase 2)", () => {
   roles {
     review: "Performs reviews"
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent review-security {
     model: opus
@@ -1859,7 +2183,10 @@ describe("Role prefix matching (Phase 2)", () => {
     review: "Generic reviewer"
     review-security: "Security reviewer"
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent review-security {
     model: opus
@@ -1876,7 +2203,10 @@ describe("Role prefix matching (Phase 2)", () => {
   roles {
     writer: "Writes content"
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent analyzer {
     model: opus
@@ -1961,7 +2291,10 @@ describe("Line number tracking", () => {
         // Gate after: a human node — cannot be wired as a SubagentStop hook
         // because human nodes do not register as subagent_types.
         const ast = parse(`topology t : [pipeline] {
-    orchestrator { model: opus handles: [a] }
+    orchestrator {
+      model: opus
+      handles: [a]
+    }
     action a { kind: inline }
     agent b { model: opus }
     human review-step {
@@ -1989,7 +2322,10 @@ describe("Line number tracking", () => {
         // Gate after: an agent node — compiles to a SubagentStop hook that
         // blocks (exit 2 prevents subagent from stopping). No warning needed.
         const ast = parse(`topology t : [pipeline] {
-    orchestrator { model: opus handles: [a] }
+    orchestrator {
+      model: opus
+      handles: [a]
+    }
     action a { kind: inline }
     agent b { model: opus }
     agent c { model: opus }
@@ -2056,7 +2392,10 @@ describe("Line number tracking", () => {
     });
     it("V87: orchestrator with no delegation field is accepted (defaults to subagent)", () => {
         const ast = parse(`topology t : [pipeline] {
-    orchestrator { model: opus handles: [a] }
+    orchestrator {
+      model: opus
+      handles: [a]
+    }
     action a { kind: inline }
     flow { a -> a }
   }`);
@@ -2071,7 +2410,10 @@ describe("Line number tracking", () => {
 describe("C12: env sub-map inside mcp-servers entries", () => {
     it("parses env block inside an mcp-server entry", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   mcp-servers {
@@ -2097,7 +2439,10 @@ describe("C12: env sub-map inside mcp-servers entries", () => {
     });
     it("mcp-server without env block still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   mcp-servers {
@@ -2115,7 +2460,10 @@ describe("C12: env sub-map inside mcp-servers entries", () => {
     });
     it("parses multiple mcp-servers with env blocks", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   mcp-servers {
@@ -2142,7 +2490,10 @@ describe("C12: env sub-map inside mcp-servers entries", () => {
 describe("C13: extensions block inside hook bodies", () => {
     it("parses extensions inside a global hook", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   hooks {
@@ -2168,7 +2519,10 @@ describe("C13: extensions block inside hook bodies", () => {
     });
     it("parses extensions inside a per-agent hook", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: opus
@@ -2195,7 +2549,10 @@ describe("C13: extensions block inside hook bodies", () => {
     });
     it("hook without extensions still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   hooks {
@@ -2215,7 +2572,10 @@ describe("C13: extensions block inside hook bodies", () => {
 describe("C14: top-level extensions block in topology body", () => {
     it("parses a top-level extensions block", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   extensions {
@@ -2241,7 +2601,10 @@ describe("C14: top-level extensions block in topology body", () => {
     });
     it("topology without extensions block has no extensions field", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: opus }
   flow { a -> w }
@@ -2257,7 +2620,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
     describe("Parsing", () => {
         it("agent with timeout parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2271,7 +2637,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("agent with on-fail: halt parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2285,7 +2654,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("agent with on-fail: retry parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2299,7 +2671,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("agent with on-fail: skip parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2313,7 +2688,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("agent with on-fail: fallback parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2330,7 +2708,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("simple retry: 3 still works (backward compat)", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2344,7 +2725,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("retry block parses all fields", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -2372,7 +2756,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("action with timeout and on-fail parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a {
     kind: inline
     timeout: 30s
@@ -2389,7 +2776,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
         });
         it("gate with timeout parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: sonnet }
   gates {
@@ -2560,7 +2950,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "I" },
-                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: { max: 3, backoff: "random" } },
+                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: {
+                            max: 3,
+                            backoff: "random"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -2573,7 +2966,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "I" },
-                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: { max: 3, interval: "forever" } },
+                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: {
+                            max: 3,
+                            interval: "forever"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -2586,7 +2982,10 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "I" },
-                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: { max: 3, maxInterval: "nope" } },
+                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: {
+                            max: 3,
+                            maxInterval: "nope"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -2599,7 +2998,14 @@ describe("Error Handling (timeout, on-fail, retry block)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "I" },
-                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: { max: 3, backoff: "exponential", interval: "1s", maxInterval: "60s", jitter: true, nonRetryable: ["auth-error"] } },
+                    { id: "worker", type: "agent", label: "W", model: "sonnet", retry: {
+                            max: 3,
+                            backoff: "exponential",
+                            interval: "1s",
+                            maxInterval: "60s",
+                            jitter: true,
+                            nonRetryable: ["auth-error"]
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -2904,7 +3310,10 @@ topology code-review : [pipeline] {
 describe("Wave 2: Error edges (-x->)", () => {
     it("parses -x-> as an error edge with isError: true", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent analyzer { model: opus }
   agent error-handler { model: opus }
@@ -2921,7 +3330,10 @@ describe("Wave 2: Error edges (-x->)", () => {
     });
     it("parses -x[timeout]-> as a typed error edge", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent analyzer { model: opus }
   agent fallback { model: opus }
@@ -2938,7 +3350,10 @@ describe("Wave 2: Error edges (-x->)", () => {
     });
     it("parses -x[auth-error]-> with hyphenated error type", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent caller { model: opus }
   agent auth-fallback { model: opus }
@@ -2955,7 +3370,10 @@ describe("Wave 2: Error edges (-x->)", () => {
     });
     it("normal edges do not have isError set", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   flow {
@@ -2969,7 +3387,10 @@ describe("Wave 2: Error edges (-x->)", () => {
     });
     it("mixed normal and error edges on same node", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent analyzer { model: opus }
   agent reviewer { model: opus }
@@ -2992,7 +3413,10 @@ describe("Wave 2: Error edges (-x->)", () => {
 describe("Wave 2: [tolerance] edge attribute", () => {
     it("parses [tolerance: 2] as integer tolerance", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   agent c { model: opus }
@@ -3010,7 +3434,10 @@ describe("Wave 2: [tolerance] edge attribute", () => {
     });
     it("parses [tolerance: 33%] as percentage string", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   agent c { model: opus }
@@ -3029,7 +3456,10 @@ describe("Wave 2: [tolerance] edge attribute", () => {
 describe("Wave 2: [race] edge attribute", () => {
     it("parses [race] as boolean edge attribute", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent fast { model: opus }
   agent slow { model: opus }
@@ -3048,7 +3478,10 @@ describe("Wave 2: [race] edge attribute", () => {
 describe("Wave 2: [wait N] edge attribute", () => {
     it("parses [wait 30s] as inline timer", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent notifier { model: opus }
   flow {
@@ -3062,7 +3495,10 @@ describe("Wave 2: [wait N] edge attribute", () => {
     });
     it("parses [wait 5m] with minute duration", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent notifier { model: opus }
   flow {
@@ -3078,7 +3514,10 @@ describe("Wave 2: [wait N] edge attribute", () => {
 describe("Wave 2: join field on agent/action", () => {
     it("parses join: all on agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent synthesizer {
     model: opus
@@ -3092,7 +3531,10 @@ describe("Wave 2: join field on agent/action", () => {
     });
     it("parses join: any on agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent fast-consumer {
     model: opus
@@ -3106,7 +3548,10 @@ describe("Wave 2: join field on agent/action", () => {
     });
     it("parses join: all-done on agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent collector {
     model: opus
@@ -3120,7 +3565,10 @@ describe("Wave 2: join field on agent/action", () => {
     });
     it("parses join on action", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [merge-step] }
+  orchestrator {
+    model: opus
+    handles: [merge-step]
+  }
   action merge-step {
     kind: inline
     join: none-failed
@@ -3140,7 +3588,10 @@ describe("Wave 2: Topology meta timeout and error-handler", () => {
     version: "1.0.0"
     timeout: 30m
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
 }`;
@@ -3153,7 +3604,10 @@ describe("Wave 2: Topology meta timeout and error-handler", () => {
     version: "1.0.0"
     error-handler: global-error-agent
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent global-error-agent { model: opus }
   flow { a -> global-error-agent }
@@ -3168,7 +3622,10 @@ describe("Wave 2: Topology meta timeout and error-handler", () => {
     timeout: 2h
     error-handler: catch-all
   }
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent catch-all { model: opus }
   flow { a -> catch-all }
@@ -3409,7 +3866,10 @@ describe("Wave 2: Validator rules V39-V45", () => {
 describe("Wave 2: Backward compatibility", () => {
     it("existing flow syntax with [when] and [max] still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus
     outputs { verdict: yes | no } }
@@ -3429,7 +3889,10 @@ describe("Wave 2: Backward compatibility", () => {
     });
     it("existing fan-out syntax still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [start] }
+  orchestrator {
+    model: opus
+    handles: [start]
+  }
   action start { kind: inline }
   agent x { model: opus }
   agent y { model: opus }
@@ -3446,7 +3909,10 @@ describe("Wave 2: Backward compatibility", () => {
     });
     it("existing chain syntax a -> b -> c still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   agent c { model: opus }
@@ -3461,7 +3927,10 @@ describe("Wave 2: Backward compatibility", () => {
     });
     it("existing [per id] syntax still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   flow {
@@ -3475,7 +3944,10 @@ describe("Wave 2: Backward compatibility", () => {
     });
     it("existing [when ..., max N] combined syntax still works", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus
     outputs { status: pass | fail } }
@@ -3881,10 +4353,13 @@ topology test : [pipeline] {
 // =========================================================================
 describe("Sensitive and Secret env values", () => {
     const minimalPrefix = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
-  action a { kind: inline }
-  flow { a -> a }`;
-    it("parses sensitive env var reference as SensitiveValue", () => {
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
+  action a { kind: inline }
+  flow { a -> a }`;
+    it("parses sensitive env var reference as SensitiveValue", () => {
         const src = `${minimalPrefix}
   env {
     API_KEY: sensitive "\${API_KEY}"
@@ -3958,7 +4433,10 @@ describe("Sensitive and Secret env values", () => {
 });
 describe("V51 - Sensitive literal warning", () => {
     const minimalPrefix = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }`;
     it("warns when sensitive is used with a literal string", () => {
@@ -4010,7 +4488,10 @@ describe("V51 - Sensitive literal warning", () => {
 });
 describe("V52 - Secret URI scheme validation", () => {
     const minimalPrefix = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }`;
     it("errors on unknown secret URI scheme", () => {
@@ -4058,7 +4539,10 @@ describe("V52 - Secret URI scheme validation", () => {
 describe("Wave 3: Observability block parsing", () => {
     it("full observability block parses correctly", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
   observability {
@@ -4101,7 +4585,10 @@ describe("Wave 3: Observability block parsing", () => {
     });
     it("observability with only capture sub-block", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
   observability {
@@ -4129,7 +4616,10 @@ describe("Wave 3: Observability block parsing", () => {
     });
     it("observability with only spans sub-block", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
   observability {
@@ -4154,7 +4644,10 @@ describe("Wave 3: Observability block parsing", () => {
     });
     it("defaults are applied when fields omitted", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
   observability {
@@ -4179,7 +4672,10 @@ describe("Wave 3: Observability block parsing", () => {
     });
     it("backward compat: topology without observability -> null", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
 }`;
@@ -4188,7 +4684,10 @@ describe("Wave 3: Observability block parsing", () => {
     });
     it("observability with enabled: false", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   flow { a -> a }
   observability {
@@ -4849,7 +5348,10 @@ topology simple : [pipeline] {
 describe("Wave 5 — Compensation / Saga (F27)", () => {
     it("parses agent with compensates field", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent deployer {
     model: sonnet
@@ -4867,7 +5369,10 @@ describe("Wave 5 — Compensation / Saga (F27)", () => {
     });
     it("agent without compensates has no compensates field", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent worker {
     model: sonnet
@@ -4881,7 +5386,10 @@ describe("Wave 5 — Compensation / Saga (F27)", () => {
     });
     it("V58: compensates referencing non-existent agent -> error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent rollback {
     model: sonnet
@@ -4899,7 +5407,10 @@ describe("Wave 5 — Compensation / Saga (F27)", () => {
     });
     it("V58: compensates referencing existing agent -> no error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent deployer {
     model: sonnet
@@ -4917,7 +5428,10 @@ describe("Wave 5 — Compensation / Saga (F27)", () => {
     });
     it("backward compat: existing topologies without compensates still work", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w1 { model: sonnet }
   agent w2 { model: opus }
@@ -4942,7 +5456,10 @@ describe("Circuit Breaker (F26)", () => {
     describe("Parsing", () => {
         it("agent with circuit-breaker block parses correctly", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w {
     model: sonnet
@@ -4963,7 +5480,10 @@ describe("Circuit Breaker (F26)", () => {
         });
         it("agent without circuit-breaker has no circuitBreaker field", () => {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w { model: sonnet }
   flow { a -> w }
@@ -5021,7 +5541,11 @@ describe("Circuit Breaker (F26)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "Intake" },
-                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: { threshold: 5, window: "5m", cooldown: "30s" } },
+                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: {
+                            threshold: 5,
+                            window: "5m",
+                            cooldown: "30s"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -5033,7 +5557,11 @@ describe("Circuit Breaker (F26)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "Intake" },
-                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: { threshold: 0, window: "5m", cooldown: "30s" } },
+                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: {
+                            threshold: 0,
+                            window: "5m",
+                            cooldown: "30s"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -5046,7 +5574,11 @@ describe("Circuit Breaker (F26)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "Intake" },
-                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: { threshold: 3, window: "five-min", cooldown: "30s" } },
+                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: {
+                            threshold: 3,
+                            window: "five-min",
+                            cooldown: "30s"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -5059,7 +5591,11 @@ describe("Circuit Breaker (F26)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "Intake" },
-                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: { threshold: 3, window: "5m", cooldown: "invalid" } },
+                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: {
+                            threshold: 3,
+                            window: "5m",
+                            cooldown: "invalid"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -5072,7 +5608,11 @@ describe("Circuit Breaker (F26)", () => {
                 nodes: [
                     { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
                     { id: "intake", type: "action", label: "Intake" },
-                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: { threshold: -1, window: "bad", cooldown: "worse" } },
+                    { id: "worker", type: "agent", label: "Worker", model: "sonnet", circuitBreaker: {
+                            threshold: -1,
+                            window: "bad",
+                            cooldown: "worse"
+                        } },
                 ],
             });
             const results = validate(ast);
@@ -5093,7 +5633,10 @@ describe("Circuit Breaker (F26)", () => {
 describe("Human node type (F32)", () => {
     it("parses human node with all fields", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   human approval {
     description: "Human reviews and approves the deployment plan"
@@ -5113,7 +5656,10 @@ describe("Human node type (F32)", () => {
     });
     it("human node appears in flow edges", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   human review {
     description: "Review step"
@@ -5128,7 +5674,10 @@ describe("Human node type (F32)", () => {
     });
     it("V59: invalid on-timeout -> error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   human approval {
     timeout: 1h
@@ -5147,7 +5696,10 @@ describe("Human node type (F32)", () => {
     it("V59: valid on-timeout values pass", () => {
         for (const value of ["halt", "skip", "fallback backup-agent"]) {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   human approval {
     timeout: 1h
@@ -5163,7 +5715,10 @@ describe("Human node type (F32)", () => {
     });
     it("V30: invalid timeout on human node -> error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   human approval {
     timeout: forever
@@ -5179,7 +5734,10 @@ describe("Human node type (F32)", () => {
     });
     it("backward compat: existing topologies without human nodes still work", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent w1 { model: sonnet }
   agent w2 { model: opus }
@@ -5200,7 +5758,10 @@ describe("Human node type (F32)", () => {
 describe("F31: Quorum join (N-of-M)", () => {
     it("parses join: 2-of-3 on agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent synthesizer {
     model: opus
@@ -5214,7 +5775,10 @@ describe("F31: Quorum join (N-of-M)", () => {
     });
     it("parses join: 3-of-5 on agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent voter {
     model: opus
@@ -5285,7 +5849,10 @@ describe("F31: Quorum join (N-of-M)", () => {
 describe("F35: Weighted routing [weight N]", () => {
     it("parses [weight 0.7] as edge attribute", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   flow {
@@ -5299,7 +5866,10 @@ describe("F35: Weighted routing [weight N]", () => {
     });
     it("parses [weight 1.0] as edge attribute", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [a] }
+  orchestrator {
+    model: opus
+    handles: [a]
+  }
   action a { kind: inline }
   agent b { model: opus }
   flow {
@@ -5313,7 +5883,10 @@ describe("F35: Weighted routing [weight N]", () => {
     });
     it("parses [weight N] on fan-out edges", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [router] }
+  orchestrator {
+    model: opus
+    handles: [router]
+  }
   action router { kind: inline }
   agent a { model: opus }
   agent b { model: opus }
@@ -5447,7 +6020,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     ttl: 7d
   }
 
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5466,7 +6042,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     version: "1.0.0"
     durable: true
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5477,7 +6056,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     it("durable defaults to undefined when not set", () => {
         const src = `topology t : [pipeline] {
   meta { version: "1.0.0" }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5488,7 +6070,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     it("checkpoint defaults to null when not present", () => {
         const src = `topology t : [pipeline] {
   meta { version: "1.0.0" }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5502,7 +6087,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     backend: mongodb
     strategy: every-node
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5521,7 +6109,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     backend: ${backend}
     strategy: every-node
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5538,7 +6129,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     backend: postgres
     strategy: periodic
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5557,7 +6151,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     strategy: every-node
     ttl: forever
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5575,7 +6172,10 @@ describe("Checkpoint / Durable Execution (F34)", () => {
     strategy: every-node
     ttl: 7d
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5601,7 +6201,10 @@ describe("Time-Travel / Replay (F37)", () => {
       branch: true
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5622,7 +6225,10 @@ describe("Time-Travel / Replay (F37)", () => {
       enabled: true
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5641,7 +6247,10 @@ describe("Time-Travel / Replay (F37)", () => {
       enabled: true
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5661,7 +6270,10 @@ describe("Time-Travel / Replay (F37)", () => {
       max-history: -5
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5680,7 +6292,10 @@ describe("Time-Travel / Replay (F37)", () => {
       enabled: true
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5710,7 +6325,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       depends-on: [research-notes]
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent researcher {
     model: sonnet
@@ -5740,7 +6358,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
     });
     it("empty artifacts block returns empty array", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5758,7 +6379,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       type: json
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5777,7 +6401,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       type: markdown
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker {
     model: sonnet
@@ -5799,7 +6426,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       type: markdown
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker {
     model: sonnet
@@ -5821,7 +6451,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       depends-on: [phantom]
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5843,7 +6476,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       depends-on: [notes]
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent writer {
     model: sonnet
@@ -5869,7 +6505,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       depends-on: [a]
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5896,7 +6535,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
       depends-on: [clean]
     }
   }
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent worker { model: sonnet }
   flow { intake -> worker }
@@ -5913,7 +6555,10 @@ describe("Asset / Artifact Lineage (F38)", () => {
 describe("Reflection edge attribute (F33)", () => {
     it("parses [reflection] attribute — sets reflection to true", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent writer { model: sonnet }
   agent evaluator { model: opus }
@@ -5931,7 +6576,10 @@ describe("Reflection edge attribute (F33)", () => {
     });
     it("V62: [reflection] without [max N] — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent writer { model: sonnet }
   agent evaluator { model: opus }
@@ -5951,7 +6599,10 @@ describe("Reflection edge attribute (F33)", () => {
     });
     it("V62: [reflection] on non-back-edge — warning", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent writer { model: sonnet }
   agent evaluator { model: opus }
@@ -5972,7 +6623,10 @@ describe("Reflection edge attribute (F33)", () => {
 describe("Group chat node (F36)", () => {
     it("parses group node with all fields", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent architect { model: opus }
   agent critic { model: sonnet }
@@ -6000,7 +6654,10 @@ describe("Group chat node (F36)", () => {
     });
     it("group node appears in flow edges", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent a1 { model: sonnet }
   agent a2 { model: sonnet }
@@ -6017,7 +6674,10 @@ describe("Group chat node (F36)", () => {
     });
     it("V63: members reference non-existent agents — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent a1 { model: sonnet }
   group chat {
@@ -6034,7 +6694,10 @@ describe("Group chat node (F36)", () => {
     });
     it("V64: invalid speaker-selection — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent a1 { model: sonnet }
   group chat {
@@ -6052,7 +6715,10 @@ describe("Group chat node (F36)", () => {
     });
     it("V65: max-rounds is 0 — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent a1 { model: sonnet }
   group chat {
@@ -6069,7 +6735,10 @@ describe("Group chat node (F36)", () => {
     });
     it("group node with minimal fields (just members) — succeeds", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent a1 { model: sonnet }
   agent a2 { model: sonnet }
@@ -6096,7 +6765,10 @@ describe("Group chat node (F36)", () => {
 describe("Rate limiting (F39)", () => {
     it("parses rate-limit: 60/min", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6111,7 +6783,10 @@ describe("Rate limiting (F39)", () => {
     });
     it("parses rate-limit: 1000/hour", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6125,7 +6800,10 @@ describe("Rate limiting (F39)", () => {
     });
     it("V66: invalid format rate-limit: fast — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6142,7 +6820,10 @@ describe("Rate limiting (F39)", () => {
     });
     it("V66: invalid unit rate-limit: 60/week — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6158,7 +6839,10 @@ describe("Rate limiting (F39)", () => {
     });
     it("V66: zero rate rate-limit: 0/min — error", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6175,7 +6859,10 @@ describe("Rate limiting (F39)", () => {
     it("valid rate-limit values pass validation", () => {
         for (const rl of ["1/sec", "60/min", "1000/hour", "10000/day"]) {
             const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent api-caller {
     model: sonnet
@@ -6324,7 +7011,10 @@ describe("Registry imports (F28-F30)", () => {
 describe("Prompt variants (F40)", () => {
     it("parses variants block in agent", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent reviewer {
     model: sonnet
@@ -6357,7 +7047,10 @@ describe("Prompt variants (F40)", () => {
     });
     it("parses variant with model override", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent reviewer {
     model: sonnet
@@ -6449,7 +7142,10 @@ describe("Prompt variants (F40)", () => {
 describe("Encrypted values (F41)", () => {
     it("parses encrypted value in env block", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent w { model: sonnet }
   env {
@@ -6466,7 +7162,10 @@ describe("Encrypted values (F41)", () => {
     });
     it("encrypted implies sensitive", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent w { model: sonnet }
   env {
@@ -6518,7 +7217,10 @@ describe("Encrypted values (F41)", () => {
 describe("Auth block in providers (F42)", () => {
     it("parses auth block in provider", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent w { model: sonnet }
   providers {
@@ -6543,7 +7245,10 @@ describe("Auth block in providers (F42)", () => {
     });
     it("provider without auth block (backward compat) passes", () => {
         const src = `topology t : [pipeline] {
-  orchestrator { model: opus handles: [intake] }
+  orchestrator {
+    model: opus
+    handles: [intake]
+  }
   action intake { kind: inline }
   agent w { model: sonnet }
   providers {
@@ -6618,7 +7323,14 @@ describe("Auth block in providers (F42)", () => {
     // =========================================================================
     describe("store and retrieval blocks", () => {
         it("parses a basic store with type, backend, and path", () => {
-            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator { model: opus handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store my-store {\n      type: semantic\n      backend: lancedb\n      path: ".memory/"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator {
+        model: opus
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store my-store {
+        type: semantic\n
+        backend: lancedb\n
+        path: ".memory/"\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.stores).toHaveLength(1);
             expect(ast.stores[0].id).toBe("my-store");
@@ -6627,7 +7339,19 @@ describe("Auth block in providers (F42)", () => {
             expect(ast.stores[0].path).toBe(".memory/");
         });
         it("parses multiple stores in one memory block", () => {
-            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator { model: opus handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store kb {\n      type: semantic\n      backend: lancedb\n    }\n    store relations {\n      type: graph\n      backend: kuzu\n    }\n    store history {\n      type: episodic\n      backend: sqlite-vec\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator {
+        model: opus
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store kb {
+        type: semantic\n
+        backend: lancedb\n
+      }\n    store relations {
+        type: graph\n
+        backend: kuzu\n
+      }\n    store history {
+        type: episodic\n
+        backend: sqlite-vec\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.stores).toHaveLength(3);
             expect(ast.stores[0].id).toBe("kb");
@@ -6727,7 +7451,14 @@ describe("Auth block in providers (F42)", () => {
             expect(store.backendConfig["replicas"]).toBe(3);
         });
         it("parses store with connection secret", () => {
-            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator { model: opus handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store remote-db {\n      type: semantic\n      backend: pinecone\n      connection: secret "DB_URL"\n    }\n  }\n}`;
+            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator {
+        model: opus
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {\n    store remote-db {
+        type: semantic\n
+        backend: pinecone\n
+        connection: secret "DB_URL"\n
+      }\n  }\n}`;
             const ast = parse(src);
             expect(ast.stores).toHaveLength(1);
             expect(ast.stores[0].connection).toBe("DB_URL");
@@ -6818,7 +7549,10 @@ describe("Auth block in providers (F42)", () => {
             expect(agent.retrieval).toBe("planner");
         });
         it("parses empty memory block with no stores", () => {
-            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator { model: opus handles: [a] }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {}\n}`;
+            const src = `topology t : [pipeline] {\n  meta { version: "1.0.0" }\n  orchestrator {
+        model: opus
+        handles: [a]
+      }\n  action a { kind: inline }\n  flow { a -> a }\n  memory {}\n}`;
             const ast = parse(src);
             expect(ast.stores).toEqual([]);
             expect(ast.retrievals).toEqual([]);
@@ -7059,4 +7793,616 @@ describe("Auth block in providers (F42)", () => {
         });
     });
 });
+describe("Company brain — pattern, brain store type, custody primitive", () => {
+    const brainSrc = `topology cb : [brain] {
+    meta {
+      version: "1.0.0"
+      description: "x"
+    }
+    memory {
+      store brain {
+        type: brain
+        description: "the company brain"
+        path: "brain/"
+        format: obsidian
+      }
+    }
+    agent librarian {
+      model: sonnet
+      description: "keeps the brain"
+      tools: [Read, Write, Grep]
+      custodian-of: [brain] {
+        does: [link, tag, index, dedupe]
+      }
+    }
+    agent researcher {
+      model: sonnet
+      description: "reads the brain"
+      tools: [Read, Grep]
+      memory: [brain]
+    }
+    action intake {
+      kind: inline
+      description: "in"
+    }
+    flow {
+      intake -> librarian
+      librarian -> researcher
+    }
+  }`;
+    it("parses a brain-type store with files backend default and format", () => {
+        const ast = parse(brainSrc);
+        const store = (ast.stores ?? []).find((s) => s.id === "brain");
+        expect(store).toBeDefined();
+        expect(store.type).toBe("brain");
+        expect(store.backend).toBe("files"); // file-native default, not lancedb
+        expect(store.format).toBe("obsidian");
+        expect(store.path).toBe("brain/");
+    });
+    it("parses custodian-of and the optional does verbs on an agent", () => {
+        const ast = parse(brainSrc);
+        const librarian = ast.nodes.find((n) => n.id === "librarian");
+        expect(librarian.custodianOf).toEqual(["brain"]);
+        expect(librarian.custodianDoes).toEqual(["link", "tag", "index", "dedupe"]);
+    });
+    it("custody is optional — bare custodian-of with no verbs parses", () => {
+        const src = brainSrc.replace("custodian-of: [brain] {\n        does: [link, tag, index, dedupe]\n      }", "custodian-of: [brain]");
+        const ast = parse(src);
+        const librarian = ast.nodes.find((n) => n.id === "librarian");
+        expect(librarian.custodianOf).toEqual(["brain"]);
+        expect(librarian.custodianDoes).toBeUndefined();
+    });
+    it("the brain pattern tag is recognized (no V2 reserved-keyword error)", () => {
+        const ast = parse(brainSrc);
+        expect(ast.topology.patterns).toContain("brain");
+        const results = validate(ast);
+        expect(results.filter((r) => r.level === "error")).toHaveLength(0);
+    });
+    it("V81: a brain store needs no DB backend (exempt from backend enum)", () => {
+        const ast = parse(brainSrc);
+        const results = validate(ast);
+        expect(results.filter((r) => r.rule === "V81")).toHaveLength(0);
+    });
+    it("V88: custodian-of referencing an undeclared store is an error", () => {
+        const ast = minimalASTForWave6({
+            nodes: [
+                { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
+                { id: "intake", type: "action", label: "Intake" },
+                { id: "keeper", type: "agent", label: "Keeper", model: "sonnet", custodianOf: ["ghost-store"] },
+            ],
+            edges: [{ from: "intake", to: "keeper", condition: null, maxIterations: null }],
+            stores: [{ id: "brain", type: "brain", backend: "files" }],
+            retrievals: [],
+        });
+        const v88 = validate(ast).filter((r) => r.rule === "V88" && r.level === "error");
+        expect(v88).toHaveLength(1);
+        expect(v88[0].message).toContain("ghost-store");
+    });
+    it("V88: custody over a declared brain store is clean", () => {
+        const ast = minimalASTForWave6({
+            nodes: [
+                { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
+                { id: "intake", type: "action", label: "Intake" },
+                { id: "keeper", type: "agent", label: "Keeper", model: "sonnet", custodianOf: ["brain"] },
+            ],
+            edges: [{ from: "intake", to: "keeper", condition: null, maxIterations: null }],
+            stores: [{ id: "brain", type: "brain", backend: "files" }],
+            retrievals: [],
+        });
+        const v88 = validate(ast).filter((r) => r.rule === "V88");
+        expect(v88).toHaveLength(0);
+    });
+    it("V88: custody over a non-brain store is a warning, not an error", () => {
+        const ast = minimalASTForWave6({
+            nodes: [
+                { id: "orchestrator", type: "orchestrator", label: "O", model: "opus", handles: ["intake"] },
+                { id: "intake", type: "action", label: "Intake" },
+                { id: "keeper", type: "agent", label: "Keeper", model: "sonnet", custodianOf: ["kg"] },
+            ],
+            edges: [{ from: "intake", to: "keeper", condition: null, maxIterations: null }],
+            stores: [{ id: "kg", type: "graph", backend: "kuzu" }],
+            retrievals: [],
+        });
+        const v88 = validate(ast).filter((r) => r.rule === "V88");
+        expect(v88).toHaveLength(1);
+        expect(v88[0].level).toBe("warning");
+    });
+    it("parses a brain store's presentation-only `sources` block", () => {
+        const src = `topology cb : [brain] {
+      meta {
+        version: "1.0.0"
+        description: "x"
+      }
+      memory {
+        store brain {
+          type: brain
+          path: "brain/"
+          sources {
+            gmail {
+              color: "#EA4335"
+              icon: "./logos/gmail.svg"
+            }
+            slack {
+              color: "#4A154B"
+            }
+          }
+        }
+      }
+      agent lib {
+        model: sonnet
+        description: "k"
+        tools: [Read, Write]
+        custodian-of: [brain]
+      }
+      action intake {
+        kind: inline
+        description: "in"
+      }
+      flow { intake -> lib }
+    }`;
+        const ast = parse(src);
+        const store = (ast.stores ?? []).find((s) => s.id === "brain");
+        expect(store?.sources).toEqual({
+            gmail: { color: "#EA4335", icon: "./logos/gmail.svg" },
+            slack: { color: "#4A154B" },
+        });
+        // It is presentation-only — purely data on the AST, no validation error.
+        expect(validate(ast).filter((r) => r.level === "error")).toHaveLength(0);
+    });
+    it("V24: a store's `sources` sub-block does not trigger memory sub-block warnings", () => {
+        // Regression: the V24 scanner used to regex the whole memory body flatly,
+        // flagging blocks NESTED in a store (sources/gmail/slack) as unknown memory
+        // sub-blocks. The scanner is now depth-aware — only top-level memory blocks
+        // are checked, and `store <id> {` is recognized by its leading keyword.
+        const src = `topology cb : [brain] {
+      meta {
+        version: "1.0.0"
+        description: "x"
+      }
+      memory {
+        store brain {
+          type: brain
+          path: "brain/"
+          scope: org
+          sources {
+            gmail { color: "#EA4335" }
+            slack { color: "#4A154B" }
+          }
+        }
+      }
+      agent lib {
+        model: sonnet
+        description: "k"
+        tools: [Read, Write]
+        custodian-of: [brain]
+      }
+      action intake {
+        kind: inline
+        description: "in"
+      }
+      flow { intake -> lib }
+    }`;
+        const v24 = validate(parse(src)).filter((r) => r.rule === "V24");
+        expect(v24).toHaveLength(0);
+    });
+    it("V89: a KV `prompt:` on an agent is an error, not a silent drop", () => {
+        // Regression: spec/grammar.md:350 defines agent.prompt as a BLOCK. The
+        // string form belongs to `skill` (grammar.md:1377). Writing
+        // `prompt: "path.md"` on an agent parsed to nothing and validate() said
+        // PASS — so the agent shipped with no instructions and the binding fell
+        // back to repeating its role sentence. examples/code-review.at did this on
+        // four agents, pointing at a prompts/ directory that never existed.
+        const src = `topology t : [pipeline] {
+      meta {
+        version: "1.0.0"
+        description: "x"
+      }
+      agent worker {
+        model: sonnet
+        description: "w"
+        prompt: "prompts/worker.md"
+      }
+      action intake {
+        kind: inline
+        description: "in"
+      }
+      flow { intake -> worker }
+    }`;
+        const ast = parse(src);
+        expect(ast.nodes.find((n) => n.id === "worker")).not.toHaveProperty("prompt");
+        const v89 = validate(ast).filter((r) => r.rule === "V89");
+        expect(v89).toHaveLength(1);
+        expect(v89[0].level).toBe("error");
+        expect(v89[0].node).toBe("worker");
+    });
+    it("V89: the `prompt { }` block form is accepted and reaches the AST", () => {
+        const src = `topology t : [pipeline] {
+      meta {
+        version: "1.0.0"
+        description: "x"
+      }
+      agent worker {
+        model: sonnet
+        description: "w"
+        prompt {
+          Do the thing.
+        }
+      }
+      action intake {
+        kind: inline
+        description: "in"
+      }
+      flow { intake -> worker }
+    }`;
+        const ast = parse(src);
+        const worker = ast.nodes.find((n) => n.id === "worker");
+        expect(worker.prompt).toBe("Do the thing.");
+        expect(validate(ast).filter((r) => r.rule === "V89")).toHaveLength(0);
+    });
+    it("V90: a collapsed meta block is caught — it corrupts the version", () => {
+        // The damaging case. `version` silently became `1.0.0" description: "x`,
+        // which then printed in every binding's output and in the plan brief.
+        const src = [
+            "topology t : [pipeline] {",
+            '  meta { version: "1.0.0" description: "x" }',
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const v90 = validate(parse(src)).filter((r) => r.rule === "V90");
+        expect(v90).toHaveLength(1);
+        expect(v90[0].message).toContain("version");
+    });
+    it("V90: a collapsed agent block is caught", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a { model: sonnet retry: 3 }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const v90 = validate(parse(src)).filter((r) => r.rule === "V90");
+        expect(v90.some((r) => r.message.includes("model"))).toBe(true);
+    });
+    it("V90: a colon inside a prose description is NOT flagged", () => {
+        // `parseMeta` strips quotes, so a description arrives as bare prose. A
+        // colon in English is ordinary — "Demo: agent pipeline with DuckDB".
+        // Two shipped examples do exactly this and must stay clean.
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "Demo: agent pipeline with DuckDB storage"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "Static analysis: complexity and blast radius"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        expect(validate(parse(src)).filter((r) => r.rule === "V90")).toHaveLength(0);
+    });
+    it("V90: a quoted value FOLLOWED by more content is still a swallow", () => {
+        // Where quotes survive parsing, the check is sharper: one well-formed
+        // quoted token then more content means a field was eaten.
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a {",
+            '    description: "k" model: sonnet',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        expect(validate(parse(src)).filter((r) => r.rule === "V90").length).toBeGreaterThan(0);
+    });
+    it("V90: every shipped example is free of swallowed fields", () => {
+        const dir = resolve(dirname(fileURLToPath(import.meta.url)), "../../../examples");
+        for (const f of readdirSync(dir).filter((x) => x.endsWith(".at"))) {
+            const v90 = validate(parse(readFileSync(resolve(dir, f), "utf8"))).filter((r) => r.rule === "V90");
+            expect(v90, `${f}: ${v90.map((r) => r.message).join("; ")}`).toHaveLength(0);
+        }
+    });
+    it("V90: a spec-legal single-line nested object is NOT a swallow", () => {
+        // `spec/grammar.md:117` gives `outputs: { depth: 1 | 2 | 3 }` verbatim as
+        // legal, and it parses correctly. V90 flagged it, which rejected valid
+        // topologies — a false positive is worse than a miss.
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "    outputs: { verdict: approve | reject }",
+            "    tools: [Read, Write]",
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const ast = parse(src);
+        expect(validate(ast).filter((r) => r.rule === "V90")).toHaveLength(0);
+        // and it really did parse — the exemption must not hide a broken parse
+        const a = ast.nodes.find((n) => n.id === "a");
+        expect(a.outputs?.verdict).toEqual(["approve", "reject"]);
+    });
+    it("V90: a swallow with no space after the colon is still caught", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a { model: sonnet retry:3 }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        expect(validate(parse(src)).filter((r) => r.rule === "V90").length).toBeGreaterThan(0);
+    });
+    it("V90: orchestrator, human and group blocks are checked too", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  orchestrator { model: opus handles: [i] }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const v90 = validate(parse(src)).filter((r) => r.rule === "V90");
+        expect(v90.length).toBeGreaterThan(0);
+        expect(v90[0].node).toBe("orchestrator");
+    });
+    it("V92: two bracket groups on an edge are rejected, not silently mangled", () => {
+        // The annotation matcher spanned from the first `[` to the last `]`, so
+        // `[when a.verdict == fail] [max 3]` produced the condition string
+        // `a.verdict == fail] [max 3` — brackets and all — with no error.
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "    outputs: {",
+            "      verdict: pass | fail",
+            "    }",
+            "  }",
+            "  agent b {",
+            "    model: sonnet",
+            '    description: "b"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a",
+            "         a -> b [when a.verdict == fail] [max 3] }",
+            "}",
+        ].join("\n");
+        const v92 = validate(parse(src)).filter((r) => r.rule === "V92");
+        expect(v92).toHaveLength(1);
+        expect(v92[0].message).toContain("ONE bracket");
+    });
+    it("V92: a fan-out list plus an annotation is legal, not two annotations", () => {
+        // `analyzer -> [reporter, alerter] [when ...]` ships in
+        // examples/scheduled-monitor.at. Testing for `] [` alone flagged it.
+        const src = [
+            "topology t : [pipeline, fan-out] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "    outputs: {",
+            "      verdict: pass | fail",
+            "    }",
+            "  }",
+            "  agent b {",
+            "    model: sonnet",
+            '    description: "b"',
+            "  }",
+            "  agent c {",
+            "    model: sonnet",
+            '    description: "c"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a",
+            "         a -> [b, c] [when a.verdict == fail] }",
+            "}",
+        ].join("\n");
+        expect(validate(parse(src)).filter((r) => r.rule === "V92")).toHaveLength(0);
+    });
+    it("V92: the legal single-bracket form is unaffected", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "    outputs: {",
+            "      verdict: pass | fail",
+            "    }",
+            "  }",
+            "  agent b {",
+            "    model: sonnet",
+            '    description: "b"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a",
+            "         a -> b [when a.verdict == fail, max 3] }",
+            "}",
+        ].join("\n");
+        const ast = parse(src);
+        expect(validate(ast).filter((r) => r.rule === "V92")).toHaveLength(0);
+        const e = ast.edges.find((x) => x.from === "a" && x.to === "b");
+        expect(e.condition).toBe("a.verdict == fail");
+        expect(e.maxIterations).toBe(3);
+    });
+    it("V91: a required field satisfied by an injected placeholder is still missing", () => {
+        // The parser substitutes a sentinel because the AST types are non-optional,
+        // and every downstream "is it present?" check then passed. V7 (model
+        // required) saw "unknown" and was satisfied; codex emitted it verbatim into
+        // config.toml as a model that does not exist.
+        const noVersion = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    description: "no version declared"',
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const ast = parse(noVersion);
+        expect(ast.topology.version).toBe("0.0.0"); // the sentinel is still injected
+        const v91 = validate(ast).filter((r) => r.rule === "V91");
+        expect(v91).toHaveLength(1);
+        expect(v91[0].message).toContain("version");
+    });
+    it("V91: an orchestrator with no model is caught, where V7 was satisfied", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  orchestrator {",
+            "    handles: [i]",
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        const results = validate(parse(src));
+        expect(results.filter((r) => r.rule === "V7")).toHaveLength(0); // V7 still passes
+        expect(results.filter((r) => r.rule === "V91")).toHaveLength(1); // V91 does not
+    });
+    it("V91: a topology declaring both required fields is clean", () => {
+        const src = [
+            "topology t : [pipeline] {",
+            "  meta {",
+            '    version: "1.0.0"',
+            '    description: "x"',
+            "  }",
+            "  orchestrator {",
+            "    model: opus",
+            "    handles: [i]",
+            "  }",
+            "  agent a {",
+            "    model: sonnet",
+            '    description: "a"',
+            "  }",
+            "  action i {",
+            "    kind: inline",
+            '    description: "in"',
+            "  }",
+            "  flow { i -> a }",
+            "}",
+        ].join("\n");
+        expect(validate(parse(src)).filter((r) => r.rule === "V91")).toHaveLength(0);
+    });
+    it("V91: every shipped example declares its required fields", () => {
+        const dir = resolve(dirname(fileURLToPath(import.meta.url)), "../../../examples");
+        for (const f of readdirSync(dir).filter((x) => x.endsWith(".at"))) {
+            const v91 = validate(parse(readFileSync(resolve(dir, f), "utf8"))).filter((r) => r.rule === "V91");
+            expect(v91, `${f}: ${v91.map((r) => r.message).join("; ")}`).toHaveLength(0);
+        }
+    });
+    it("round-trips the company-brain.at example with no validation errors", () => {
+        const src = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../../../examples/company-brain.at"), "utf8");
+        const ast = parse(src);
+        const errors = validate(ast).filter((r) => r.level === "error");
+        expect(errors).toHaveLength(0);
+    });
+    it("round-trips the team-of-N company-brain-team.at example cleanly", () => {
+        const src = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../../../examples/company-brain-team.at"), "utf8");
+        const ast = parse(src);
+        const errors = validate(ast).filter((r) => r.level === "error");
+        expect(errors).toHaveLength(0);
+    });
+    it("team example: two distinct custodians of the same brain, with different verbs", () => {
+        const src = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../../../examples/company-brain-team.at"), "utf8");
+        const ast = parse(src);
+        const librarian = ast.nodes.find((n) => n.id === "librarian");
+        const auditor = ast.nodes.find((n) => n.id === "auditor");
+        // Both own the same brain store — custody is not exclusive.
+        expect(librarian.custodianOf).toEqual(["brain"]);
+        expect(auditor.custodianOf).toEqual(["brain"]);
+        // But they perform different maintenance verbs (different roles, same layer).
+        expect(librarian.custodianDoes).toEqual(["link", "tag", "index", "dedupe"]);
+        expect(auditor.custodianDoes).toEqual(["heal", "dedupe", "index"]);
+    });
+});
 //# sourceMappingURL=parser.test.js.map