@grimoirelabs/core 0.1.0

package/dist/compiler/grimoire/parser.js

@@ -0,0 +1,2148 @@
+/**
+ * Recursive descent parser for Grimoire syntax
+ */
+import { ParseError } from "./errors.js";
+import { tokenize } from "./tokenizer.js";
+// =============================================================================
+// PARSER CLASS
+// =============================================================================
+export class Parser {
+    tokens;
+    source;
+    pos = 0;
+    constructor(tokens, source) {
+        this.tokens = tokens;
+        this.source = source;
+    }
+    // ===========================================================================
+    // UTILITIES
+    // ===========================================================================
+    /** Get current token */
+    current() {
+        return (this.tokens[this.pos] ?? {
+            type: "EOF",
+            value: "",
+            location: { line: 0, column: 0, offset: 0 },
+        });
+    }
+    /** Peek at token at offset */
+    peek(offset = 1) {
+        return (this.tokens[this.pos + offset] ?? {
+            type: "EOF",
+            value: "",
+            location: { line: 0, column: 0, offset: 0 },
+        });
+    }
+    /** Check if current token matches */
+    check(type, value) {
+        const token = this.current();
+        if (token.type !== type)
+            return false;
+        if (value !== undefined && token.value !== value)
+            return false;
+        return true;
+    }
+    /** Advance and return previous token */
+    advance() {
+        const token = this.current();
+        if (token.type !== "EOF") {
+            this.pos++;
+        }
+        return token;
+    }
+    /** Expect and consume a specific token */
+    expect(type, value) {
+        const token = this.current();
+        if (token.type !== type) {
+            throw new ParseError(`Expected ${type}${value ? ` '${value}'` : ""} but got ${token.type} '${token.value}'`, { location: token.location, source: this.source });
+        }
+        if (value !== undefined && token.value !== value) {
+            throw new ParseError(`Expected '${value}' but got '${token.value}'`, {
+                location: token.location,
+                source: this.source,
+            });
+        }
+        return this.advance();
+    }
+    /** Skip newlines */
+    skipNewlines() {
+        while (this.check("NEWLINE")) {
+            this.advance();
+        }
+    }
+    /** Consume a newline (required) */
+    expectNewline() {
+        if (!this.check("NEWLINE") && !this.check("EOF")) {
+            throw new ParseError(`Expected newline but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+        }
+        if (this.check("NEWLINE")) {
+            this.advance();
+        }
+    }
+    /** Create a source span from a start location to the current token's location */
+    makeSpan(startToken) {
+        const end = this.current().location;
+        return { start: startToken.location, end };
+    }
+    // ===========================================================================
+    // TOP-LEVEL PARSING
+    // ===========================================================================
+    /** Parse a complete spell file */
+    parseSpellFile() {
+        this.skipNewlines();
+        // Expect: spell Name
+        this.expect("KEYWORD", "spell");
+        const nameToken = this.expect("IDENTIFIER");
+        const name = nameToken.value;
+        this.expectNewline();
+        this.skipNewlines();
+        // Parse sections and triggers
+        const sections = [];
+        const triggers = [];
+        const imports = [];
+        const blocks = [];
+        // Expect INDENT for spell body
+        if (!this.check("INDENT")) {
+            throw new ParseError("Expected indented spell body", {
+                location: this.current().location,
+                source: this.source,
+            });
+        }
+        this.advance(); // INDENT
+        while (!this.check("DEDENT") && !this.check("EOF")) {
+            this.skipNewlines();
+            if (this.check("DEDENT") || this.check("EOF"))
+                break;
+            // Check for import or block or trigger
+            if (this.check("KEYWORD", "import")) {
+                imports.push(this.parseImport());
+            }
+            else if (this.check("KEYWORD", "block")) {
+                blocks.push(this.parseBlock());
+            }
+            else if (this.check("KEYWORD", "on")) {
+                triggers.push(this.parseTriggerHandler());
+            }
+            else {
+                sections.push(this.parseSection());
+            }
+            this.skipNewlines();
+        }
+        // Consume DEDENT
+        if (this.check("DEDENT")) {
+            this.advance();
+        }
+        return {
+            kind: "spell",
+            name,
+            sections,
+            triggers,
+            imports,
+            blocks,
+        };
+    }
+    // ===========================================================================
+    // SECTION PARSING
+    // ===========================================================================
+    /** Parse import declaration: import "path" */
+    parseImport() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "import");
+        const pathToken = this.expect("STRING");
+        let alias;
+        if (this.check("KEYWORD", "as") ||
+            (this.check("IDENTIFIER") && this.current().value === "as")) {
+            this.advance();
+            if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                alias = this.advance().value;
+            }
+            else {
+                throw new ParseError("Expected alias name after 'as'", {
+                    location: this.current().location,
+                    source: this.source,
+                });
+            }
+        }
+        this.expectNewline();
+        const node = { kind: "import", path: pathToken.value, alias };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse block definition: block name(arg, ...): */
+    parseBlock() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "block");
+        const name = this.expect("IDENTIFIER").value;
+        const params = [];
+        if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN")) {
+                const param = this.expect("IDENTIFIER").value;
+                params.push(param);
+                if (this.check("COMMA")) {
+                    this.advance();
+                }
+            }
+            this.expect("RPAREN");
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        const node = { kind: "block", name, params, body };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse a section (version, assets, params, etc.) */
+    parseSection() {
+        const token = this.current();
+        if (token.type === "KEYWORD") {
+            switch (token.value) {
+                case "version":
+                    return this.parseVersionSection();
+                case "description":
+                    return this.parseDescriptionSection();
+                case "assets":
+                    return this.parseAssetsSection();
+                case "params":
+                    return this.parseParamsSection();
+                case "limits":
+                    return this.parseLimitsSection();
+                case "venues":
+                    return this.parseVenuesSection();
+                case "state":
+                    return this.parseStateSection();
+                case "skills":
+                    return this.parseSkillsSection();
+                case "advisors":
+                    return this.parseAdvisorsSection();
+                case "guards":
+                    return this.parseGuardsSection();
+            }
+        }
+        // Could be a simple key: value
+        if (token.type === "IDENTIFIER") {
+            const key = token.value;
+            this.advance();
+            this.expect("COLON");
+            // Handle known identifiers as sections
+            if (key === "version") {
+                const value = this.parseSimpleValue();
+                this.expectNewline();
+                return { kind: "version", value: String(value) };
+            }
+        }
+        throw new ParseError(`Unexpected token in section: ${token.type} '${token.value}'`, {
+            location: token.location,
+            source: this.source,
+        });
+    }
+    /** Parse version: "1.0.0" */
+    parseVersionSection() {
+        this.expect("KEYWORD", "version");
+        this.expect("COLON");
+        const value = this.parseSimpleValue();
+        this.expectNewline();
+        return { kind: "version", value: String(value) };
+    }
+    /** Parse description: "..." */
+    parseDescriptionSection() {
+        this.expect("KEYWORD", "description");
+        this.expect("COLON");
+        const value = this.parseSimpleValue();
+        this.expectNewline();
+        return { kind: "description", value: String(value) };
+    }
+    /** Parse simple value (string, number, boolean) */
+    parseSimpleValue() {
+        const token = this.current();
+        if (token.type === "STRING") {
+            this.advance();
+            return token.value;
+        }
+        if (token.type === "NUMBER") {
+            this.advance();
+            return Number.parseFloat(token.value);
+        }
+        if (token.type === "BOOLEAN") {
+            this.advance();
+            return token.value === "true";
+        }
+        throw new ParseError(`Expected value but got ${token.type}`, {
+            location: token.location,
+            source: this.source,
+        });
+    }
+    /** Parse list of strings/identifiers (e.g., [a, "b"]) */
+    parseStringList() {
+        const items = [];
+        if (this.check("LBRACKET")) {
+            this.advance();
+            while (!this.check("RBRACKET")) {
+                if (this.check("STRING")) {
+                    items.push(this.advance().value);
+                }
+                else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    items.push(this.advance().value);
+                }
+                else if (this.check("VENUE_REF")) {
+                    items.push(this.advance().value);
+                }
+                else {
+                    throw new ParseError("Expected list item", {
+                        location: this.current().location,
+                        source: this.source,
+                    });
+                }
+                if (this.check("COMMA"))
+                    this.advance();
+            }
+            this.expect("RBRACKET");
+            return items;
+        }
+        // Single item
+        if (this.check("STRING")) {
+            items.push(this.advance().value);
+            return items;
+        }
+        if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+            items.push(this.advance().value);
+            return items;
+        }
+        if (this.check("VENUE_REF")) {
+            items.push(this.advance().value);
+            return items;
+        }
+        throw new ParseError("Expected list", {
+            location: this.current().location,
+            source: this.source,
+        });
+    }
+    /** Parse assets: [USDC, USDT] or assets block */
+    parseAssetsSection() {
+        this.expect("KEYWORD", "assets");
+        this.expect("COLON");
+        const items = [];
+        // Inline array: [USDC, USDT, DAI]
+        if (this.check("LBRACKET")) {
+            this.advance();
+            while (!this.check("RBRACKET")) {
+                const symbol = this.expect("IDENTIFIER").value;
+                items.push({ symbol });
+                if (this.check("COMMA")) {
+                    this.advance();
+                }
+            }
+            this.expect("RBRACKET");
+            this.expectNewline();
+        }
+        else {
+            // Block form
+            this.expectNewline();
+            if (this.check("INDENT")) {
+                this.advance();
+                while (!this.check("DEDENT") && !this.check("EOF")) {
+                    this.skipNewlines();
+                    if (this.check("DEDENT") || this.check("EOF"))
+                        break;
+                    const symbol = this.expect("IDENTIFIER").value;
+                    const asset = { symbol };
+                    this.expect("COLON");
+                    if (this.check("NEWLINE")) {
+                        this.expectNewline();
+                        if (!this.check("INDENT")) {
+                            throw new ParseError("Expected indented asset block", {
+                                location: this.current().location,
+                                source: this.source,
+                            });
+                        }
+                        this.advance();
+                        while (!this.check("DEDENT") && !this.check("EOF")) {
+                            this.skipNewlines();
+                            if (this.check("DEDENT") || this.check("EOF"))
+                                break;
+                            const key = this.expect("IDENTIFIER").value;
+                            this.expect("COLON");
+                            if (key === "chain") {
+                                const val = this.expect("NUMBER").value;
+                                asset.chain = Number.parseInt(val, 10);
+                                this.expectNewline();
+                            }
+                            else if (key === "address") {
+                                if (this.check("ADDRESS")) {
+                                    asset.address = this.advance().value;
+                                }
+                                else if (this.check("STRING")) {
+                                    asset.address = this.advance().value;
+                                }
+                                else {
+                                    throw new ParseError("Expected address value", {
+                                        location: this.current().location,
+                                        source: this.source,
+                                    });
+                                }
+                                this.expectNewline();
+                            }
+                            else if (key === "decimals") {
+                                const val = this.expect("NUMBER").value;
+                                asset.decimals = Number.parseInt(val, 10);
+                                this.expectNewline();
+                            }
+                            else {
+                                this.parseExpression();
+                                this.expectNewline();
+                            }
+                        }
+                        if (this.check("DEDENT"))
+                            this.advance();
+                    }
+                    else {
+                        // Inline asset defaults: assets: SYMBOL: <ignored>
+                        this.parseExpression();
+                        this.expectNewline();
+                    }
+                    items.push(asset);
+                }
+                if (this.check("DEDENT"))
+                    this.advance();
+            }
+        }
+        return { kind: "assets", items };
+    }
+    /** Parse params section */
+    parseParamsSection() {
+        this.expect("KEYWORD", "params");
+        this.expect("COLON");
+        this.expectNewline();
+        const items = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                const item = { name };
+                // Block form: param:
+                if (this.check("NEWLINE")) {
+                    this.expectNewline();
+                    if (!this.check("INDENT")) {
+                        throw new ParseError("Expected indented param block", {
+                            location: this.current().location,
+                            source: this.source,
+                        });
+                    }
+                    this.advance();
+                    while (!this.check("DEDENT") && !this.check("EOF")) {
+                        this.skipNewlines();
+                        if (this.check("DEDENT") || this.check("EOF"))
+                            break;
+                        const keyToken = this.current();
+                        if (!(this.check("IDENTIFIER") || this.check("KEYWORD"))) {
+                            throw new ParseError(`Expected param field but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                        }
+                        const key = keyToken.value;
+                        this.advance();
+                        this.expect("COLON");
+                        if (key === "type") {
+                            if (this.check("STRING")) {
+                                item.type = this.advance().value;
+                            }
+                            else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                item.type = this.advance().value;
+                            }
+                            else {
+                                throw new ParseError("Expected param type value", {
+                                    location: keyToken.location,
+                                    source: this.source,
+                                });
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "asset") {
+                            if (this.check("STRING")) {
+                                item.asset = this.advance().value;
+                            }
+                            else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                item.asset = this.advance().value;
+                            }
+                            else {
+                                throw new ParseError("Expected asset identifier", {
+                                    location: keyToken.location,
+                                    source: this.source,
+                                });
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "default") {
+                            item.value = this.parseExpression();
+                            this.expectNewline();
+                        }
+                        else if (key === "min") {
+                            const val = this.expect("NUMBER").value;
+                            item.min = Number.parseFloat(val);
+                            this.expectNewline();
+                        }
+                        else if (key === "max") {
+                            const val = this.expect("NUMBER").value;
+                            item.max = Number.parseFloat(val);
+                            this.expectNewline();
+                        }
+                        else {
+                            // Unknown field - parse and ignore
+                            this.parseExpression();
+                            this.expectNewline();
+                        }
+                    }
+                    if (this.check("DEDENT"))
+                        this.advance();
+                }
+                else {
+                    // Inline form: name: value
+                    item.value = this.parseExpression();
+                    this.expectNewline();
+                }
+                items.push(item);
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        return { kind: "params", items };
+    }
+    /** Parse limits section */
+    parseLimitsSection() {
+        this.expect("KEYWORD", "limits");
+        this.expect("COLON");
+        this.expectNewline();
+        const items = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                const value = this.parseExpression();
+                items.push({ name, value });
+                this.expectNewline();
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        return { kind: "limits", items };
+    }
+    /** Parse venues section */
+    parseVenuesSection() {
+        this.expect("KEYWORD", "venues");
+        this.expect("COLON");
+        this.expectNewline();
+        const groups = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                const venues = [];
+                // Single venue: swap: @uniswap_v3
+                if (this.check("VENUE_REF")) {
+                    const venueToken = this.advance();
+                    venues.push({ kind: "venue_ref", name: venueToken.value });
+                }
+                // Array of venues: lending: [@aave_v3, @morpho]
+                else if (this.check("LBRACKET")) {
+                    this.advance();
+                    while (!this.check("RBRACKET")) {
+                        if (this.check("VENUE_REF")) {
+                            const venueToken = this.advance();
+                            venues.push({ kind: "venue_ref", name: venueToken.value });
+                        }
+                        if (this.check("COMMA")) {
+                            this.advance();
+                        }
+                    }
+                    this.expect("RBRACKET");
+                }
+                groups.push({ name, venues });
+                this.expectNewline();
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        return { kind: "venues", groups };
+    }
+    /** Parse state section */
+    parseStateSection() {
+        this.expect("KEYWORD", "state");
+        this.expect("COLON");
+        this.expectNewline();
+        const persistent = [];
+        const ephemeral = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT"))
+                    break;
+                const scope = this.expect("KEYWORD").value;
+                this.expect("COLON");
+                this.expectNewline();
+                const items = scope === "persistent" ? persistent : ephemeral;
+                if (this.check("INDENT")) {
+                    this.advance();
+                    while (!this.check("DEDENT") && !this.check("EOF")) {
+                        this.skipNewlines();
+                        if (this.check("DEDENT"))
+                            break;
+                        const name = this.expect("IDENTIFIER").value;
+                        this.expect("COLON");
+                        const initialValue = this.parseExpression();
+                        items.push({ name, initialValue });
+                        this.expectNewline();
+                        this.skipNewlines();
+                    }
+                    if (this.check("DEDENT"))
+                        this.advance();
+                }
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        return { kind: "state", persistent, ephemeral };
+    }
+    /** Parse skills section */
+    parseSkillsSection() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "skills");
+        this.expect("COLON");
+        this.expectNewline();
+        const items = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                this.expectNewline();
+                let type;
+                const adapters = [];
+                let defaultMaxSlippage;
+                if (this.check("INDENT")) {
+                    this.advance();
+                    while (!this.check("DEDENT") && !this.check("EOF")) {
+                        this.skipNewlines();
+                        if (this.check("DEDENT") || this.check("EOF"))
+                            break;
+                        const keyToken = this.current();
+                        if (!(this.check("IDENTIFIER") || this.check("KEYWORD"))) {
+                            throw new ParseError(`Expected skill field but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                        }
+                        const key = keyToken.value;
+                        this.advance();
+                        this.expect("COLON");
+                        if (key === "type") {
+                            // Accept identifier or string
+                            if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                type = this.advance().value;
+                            }
+                            else if (this.check("STRING")) {
+                                type = this.advance().value;
+                            }
+                            else {
+                                throw new ParseError("Expected skill type value", {
+                                    location: this.current().location,
+                                    source: this.source,
+                                });
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "adapters") {
+                            if (this.check("LBRACKET")) {
+                                this.advance();
+                                while (!this.check("RBRACKET")) {
+                                    if (this.check("VENUE_REF")) {
+                                        adapters.push(this.advance().value);
+                                    }
+                                    else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                        adapters.push(this.advance().value);
+                                    }
+                                    else if (this.check("STRING")) {
+                                        adapters.push(this.advance().value);
+                                    }
+                                    else {
+                                        throw new ParseError("Expected adapter name", {
+                                            location: this.current().location,
+                                            source: this.source,
+                                        });
+                                    }
+                                    if (this.check("COMMA"))
+                                        this.advance();
+                                }
+                                this.expect("RBRACKET");
+                            }
+                            else {
+                                // Single adapter
+                                if (this.check("VENUE_REF")) {
+                                    adapters.push(this.advance().value);
+                                }
+                                else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                    adapters.push(this.advance().value);
+                                }
+                                else if (this.check("STRING")) {
+                                    adapters.push(this.advance().value);
+                                }
+                                else {
+                                    throw new ParseError("Expected adapter name", {
+                                        location: this.current().location,
+                                        source: this.source,
+                                    });
+                                }
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "default_constraints") {
+                            this.expectNewline();
+                            if (this.check("INDENT")) {
+                                this.advance();
+                                while (!this.check("DEDENT") && !this.check("EOF")) {
+                                    this.skipNewlines();
+                                    if (this.check("DEDENT") || this.check("EOF"))
+                                        break;
+                                    const dcKey = this.expect("IDENTIFIER").value;
+                                    this.expect("COLON");
+                                    const value = this.parseExpression();
+                                    if (dcKey === "max_slippage") {
+                                        defaultMaxSlippage = value;
+                                    }
+                                    this.expectNewline();
+                                }
+                                if (this.check("DEDENT"))
+                                    this.advance();
+                            }
+                        }
+                        else {
+                            // Unknown field, parse and ignore
+                            this.parseExpression();
+                            this.expectNewline();
+                        }
+                    }
+                    if (this.check("DEDENT"))
+                        this.advance();
+                }
+                if (!type) {
+                    throw new ParseError(`Skill '${name}' missing type`, {
+                        location: this.current().location,
+                        source: this.source,
+                    });
+                }
+                items.push({
+                    name,
+                    type,
+                    adapters,
+                    defaultConstraints: defaultMaxSlippage ? { maxSlippage: defaultMaxSlippage } : undefined,
+                });
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = { kind: "skills", items };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse advisors section */
+    parseAdvisorsSection() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "advisors");
+        this.expect("COLON");
+        this.expectNewline();
+        const items = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                this.expectNewline();
+                const advisor = {
+                    name,
+                    model: "sonnet",
+                };
+                if (this.check("INDENT")) {
+                    this.advance();
+                    while (!this.check("DEDENT") && !this.check("EOF")) {
+                        this.skipNewlines();
+                        if (this.check("DEDENT") || this.check("EOF"))
+                            break;
+                        const keyToken = this.current();
+                        if (!(this.check("IDENTIFIER") || this.check("KEYWORD"))) {
+                            throw new ParseError(`Expected advisor field but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                        }
+                        const key = keyToken.value;
+                        this.advance();
+                        this.expect("COLON");
+                        if (key === "model") {
+                            if (this.check("STRING")) {
+                                advisor.model = this.advance().value;
+                            }
+                            else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                                advisor.model = this.advance().value;
+                            }
+                            else {
+                                throw new ParseError("Expected model value", {
+                                    location: this.current().location,
+                                    source: this.source,
+                                });
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "system" || key === "system_prompt") {
+                            const value = this.expect("STRING").value;
+                            advisor.systemPrompt = value;
+                            this.expectNewline();
+                        }
+                        else if (key === "skills") {
+                            advisor.skills = this.parseStringList();
+                            this.expectNewline();
+                        }
+                        else if (key === "allowed_tools") {
+                            advisor.allowedTools = this.parseStringList();
+                            this.expectNewline();
+                        }
+                        else if (key === "mcp") {
+                            advisor.mcp = this.parseStringList();
+                            this.expectNewline();
+                        }
+                        else if (key === "timeout") {
+                            const value = this.expect("NUMBER").value;
+                            advisor.timeout = Number.parseFloat(value);
+                            this.expectNewline();
+                        }
+                        else if (key === "fallback") {
+                            if (this.check("BOOLEAN")) {
+                                advisor.fallback = this.advance().value === "true";
+                            }
+                            else {
+                                throw new ParseError("Expected boolean fallback", {
+                                    location: this.current().location,
+                                    source: this.source,
+                                });
+                            }
+                            this.expectNewline();
+                        }
+                        else if (key === "rate_limit") {
+                            this.expectNewline();
+                            if (this.check("INDENT")) {
+                                this.advance();
+                                while (!this.check("DEDENT") && !this.check("EOF")) {
+                                    this.skipNewlines();
+                                    if (this.check("DEDENT") || this.check("EOF"))
+                                        break;
+                                    const rlKey = this.expect("IDENTIFIER").value;
+                                    this.expect("COLON");
+                                    const value = this.expect("NUMBER").value;
+                                    if (rlKey === "max_per_run") {
+                                        advisor.maxPerRun = Number.parseFloat(value);
+                                    }
+                                    else if (rlKey === "max_per_hour") {
+                                        advisor.maxPerHour = Number.parseFloat(value);
+                                    }
+                                    this.expectNewline();
+                                }
+                                if (this.check("DEDENT"))
+                                    this.advance();
+                            }
+                        }
+                        else {
+                            // Unknown field - parse and ignore
+                            this.parseExpression();
+                            this.expectNewline();
+                        }
+                    }
+                    if (this.check("DEDENT"))
+                        this.advance();
+                }
+                items.push(advisor);
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = { kind: "advisors", items };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse guards section: guards:\n    id: expression */
+    parseGuardsSection() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "guards");
+        this.expect("COLON");
+        this.expectNewline();
+        const items = [];
+        if (this.check("INDENT")) {
+            this.advance(); // consume INDENT
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                // Each line: id: expression
+                const id = this.current().value;
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    this.advance();
+                }
+                else {
+                    throw new ParseError(`Expected guard identifier but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                }
+                this.expect("COLON");
+                const check = this.parseExpression();
+                let severity = "halt";
+                let message;
+                let fallback;
+                if (this.check("KEYWORD", "with")) {
+                    const meta = this.parseConstraintClause();
+                    for (const { key, value } of meta.constraints) {
+                        if (key === "severity" && value.kind === "literal") {
+                            severity = String(value.value);
+                        }
+                        else if (key === "message" && value.kind === "literal") {
+                            message = String(value.value);
+                        }
+                        else if (key === "fallback" && value.kind === "literal") {
+                            fallback = Boolean(value.value);
+                        }
+                    }
+                }
+                this.expectNewline();
+                items.push({
+                    id,
+                    check,
+                    severity,
+                    message,
+                    fallback,
+                });
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = { kind: "guards", items };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    // ===========================================================================
+    // TRIGGER PARSING
+    // ===========================================================================
+    /** Parse trigger handler: on manual: ... */
+    parseTriggerHandler() {
+        this.expect("KEYWORD", "on");
+        const triggerType = this.parseTriggerType();
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        return {
+            kind: "trigger_handler",
+            trigger: triggerType,
+            body,
+        };
+    }
+    /** Parse trigger type */
+    parseTriggerType() {
+        const token = this.current();
+        if (token.type === "KEYWORD" || token.type === "IDENTIFIER") {
+            switch (token.value) {
+                case "manual":
+                    this.advance();
+                    return { kind: "manual" };
+                case "hourly":
+                    this.advance();
+                    return { kind: "hourly" };
+                case "daily":
+                    this.advance();
+                    return { kind: "daily" };
+                case "condition": {
+                    this.advance();
+                    const expression = this.parseExpression();
+                    let pollInterval;
+                    if (this.check("KEYWORD", "every") ||
+                        (this.check("IDENTIFIER") && this.current().value === "every")) {
+                        this.advance();
+                        const durationToken = this.expect("NUMBER");
+                        pollInterval = Number.parseFloat(durationToken.value);
+                    }
+                    return { kind: "condition", expression, pollInterval };
+                }
+                case "event": {
+                    this.advance();
+                    let eventName = "";
+                    if (this.check("STRING")) {
+                        eventName = this.advance().value;
+                    }
+                    else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                        eventName = this.advance().value;
+                    }
+                    else {
+                        throw new ParseError("Expected event name", {
+                            location: this.current().location,
+                            source: this.source,
+                        });
+                    }
+                    let filter;
+                    if (this.check("KEYWORD", "where") ||
+                        (this.check("IDENTIFIER") && this.current().value === "where")) {
+                        this.advance();
+                        filter = this.parseExpression();
+                    }
+                    return { kind: "event", event: eventName, filter };
+                }
+            }
+        }
+        // Could be a cron expression or condition
+        if (token.type === "STRING") {
+            const cron = token.value;
+            this.advance();
+            return { kind: "schedule", cron };
+        }
+        throw new ParseError(`Expected trigger type but got ${token.type} '${token.value}'`, {
+            location: token.location,
+            source: this.source,
+        });
+    }
+    // ===========================================================================
+    // STATEMENT PARSING
+    // ===========================================================================
+    /** Parse an indented block of statements */
+    parseStatementBlock() {
+        const statements = [];
+        if (!this.check("INDENT")) {
+            return statements;
+        }
+        this.advance(); // INDENT
+        while (!this.check("DEDENT") && !this.check("EOF")) {
+            this.skipNewlines();
+            if (this.check("DEDENT") || this.check("EOF"))
+                break;
+            statements.push(this.parseStatement());
+            this.skipNewlines();
+        }
+        if (this.check("DEDENT")) {
+            this.advance();
+        }
+        return statements;
+    }
+    /** Parse a single statement */
+    parseStatement() {
+        const token = this.current();
+        // Keywords
+        if (token.type === "KEYWORD") {
+            switch (token.value) {
+                case "if":
+                    return this.parseIfStatement();
+                case "for":
+                    return this.parseForStatement();
+                case "repeat":
+                    return this.parseRepeatStatement();
+                case "loop":
+                    return this.parseUntilStatement();
+                case "try":
+                    return this.parseTryStatement();
+                case "parallel":
+                    return this.parseParallelStatement();
+                case "do":
+                    return this.parseDoStatement();
+                case "atomic":
+                    return this.parseAtomicStatement();
+                case "emit":
+                    return this.parseEmitStatement();
+                case "halt":
+                    return this.parseHaltStatement();
+                case "wait":
+                    return this.parseWaitStatement();
+                case "pass": {
+                    const startToken = this.current();
+                    this.advance();
+                    this.expectNewline();
+                    const node = { kind: "pass" };
+                    node.span = this.makeSpan(startToken);
+                    return node;
+                }
+            }
+        }
+        // Assignment or expression statement
+        // Check for: identifier = ...
+        if (token.type === "IDENTIFIER") {
+            // Look ahead for assignment
+            if (this.peek().type === "ASSIGN") {
+                return this.parseAssignment();
+            }
+        }
+        // Expression statement (method call, etc.)
+        const startToken = this.current();
+        const expr = this.parseExpression();
+        // Pipeline expression statement
+        if (this.check("OPERATOR") && this.current().value === "|") {
+            const node = this.parsePipeline(expr, undefined, startToken);
+            return node;
+        }
+        // If it's a method call, convert to statement
+        if (expr.kind === "call") {
+            const callExpr = expr;
+            if (callExpr.callee.kind === "property_access") {
+                const prop = callExpr.callee;
+                const node = {
+                    kind: "method_call",
+                    object: prop.object,
+                    method: prop.property,
+                    args: callExpr.args,
+                };
+                // Check for using clause: ... using skill
+                if (this.check("KEYWORD") && this.current().value === "using") {
+                    node.skill = this.parseUsingClause();
+                }
+                // Check for constraint clause: ... with key=value
+                if (this.check("KEYWORD") && this.current().value === "with") {
+                    node.constraints = this.parseConstraintClause();
+                }
+                this.expectNewline();
+                node.span = this.makeSpan(startToken);
+                return node;
+            }
+        }
+        this.expectNewline();
+        // Treat as assignment with expression
+        throw new ParseError("Unexpected expression statement", {
+            location: token.location,
+            source: this.source,
+        });
+    }
+    /** Parse assignment: x = expr [with key=value, ...] */
+    parseAssignment() {
+        const startToken = this.current();
+        const target = this.expect("IDENTIFIER").value;
+        this.expect("ASSIGN");
+        // Special case: advise statement
+        if (this.check("KEYWORD", "advise")) {
+            const node = this.parseAdviseStatement(target, startToken);
+            return node;
+        }
+        const value = this.parseExpression();
+        // Pipeline assignment
+        if (this.check("OPERATOR") && this.current().value === "|") {
+            const node = this.parsePipeline(value, target, startToken);
+            return node;
+        }
+        let skill;
+        if (this.check("KEYWORD") && this.current().value === "using") {
+            skill = this.parseUsingClause();
+        }
+        let constraints;
+        if (this.check("KEYWORD") && this.current().value === "with") {
+            constraints = this.parseConstraintClause();
+        }
+        this.expectNewline();
+        const node = { kind: "assignment", target, value, constraints, skill };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse advise statement (assignment form) */
+    parseAdviseStatement(target, startToken) {
+        this.expect("KEYWORD", "advise");
+        const advisor = this.expect("IDENTIFIER").value;
+        this.expect("COLON");
+        const prompt = this.expect("STRING").value;
+        this.expectNewline();
+        let outputSchema;
+        let timeout;
+        let fallback;
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                const keyToken = this.current();
+                if (!(this.check("IDENTIFIER") || this.check("KEYWORD"))) {
+                    throw new ParseError(`Expected advise field but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                }
+                const key = keyToken.value;
+                this.advance();
+                this.expect("COLON");
+                if (key === "output") {
+                    outputSchema = this.parseOutputSchemaBlock(keyToken);
+                }
+                else if (key === "timeout") {
+                    const value = this.expect("NUMBER").value;
+                    timeout = Number.parseFloat(value);
+                    this.expectNewline();
+                }
+                else if (key === "fallback") {
+                    fallback = this.parseExpression();
+                    this.expectNewline();
+                }
+                else {
+                    this.parseExpression();
+                    this.expectNewline();
+                }
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        if (!outputSchema || timeout === undefined || fallback === undefined) {
+            throw new ParseError("Advise statement requires output, timeout, and fallback", {
+                location: startToken.location,
+                source: this.source,
+            });
+        }
+        const node = {
+            kind: "advise",
+            target,
+            advisor,
+            prompt,
+            outputSchema,
+            timeout,
+            fallback,
+        };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    parseOutputSchemaBlock(keyToken) {
+        if (!this.check("NEWLINE")) {
+            // Allow inline type: output: boolean
+            const inlineType = this.parseSchemaType();
+            this.expectNewline();
+            return { kind: "advisory_output_schema", type: inlineType };
+        }
+        this.expectNewline();
+        if (!this.check("INDENT")) {
+            throw new ParseError("Expected indented output block", {
+                location: keyToken.location,
+                source: this.source,
+            });
+        }
+        this.advance();
+        return this.parseSchemaObject(keyToken);
+    }
+    parseSchemaAfterColon(keyToken) {
+        if (this.check("NEWLINE")) {
+            this.expectNewline();
+            if (!this.check("INDENT")) {
+                throw new ParseError("Expected indented schema block", {
+                    location: keyToken.location,
+                    source: this.source,
+                });
+            }
+            this.advance();
+            return this.parseSchemaObject(keyToken);
+        }
+        const inlineType = this.parseSchemaType();
+        this.expectNewline();
+        return { kind: "advisory_output_schema", type: inlineType };
+    }
+    parseSchemaObject(keyToken) {
+        let outType;
+        let values;
+        let min;
+        let max;
+        let minLength;
+        let maxLength;
+        let pattern;
+        let fields;
+        let items;
+        while (!this.check("DEDENT") && !this.check("EOF")) {
+            this.skipNewlines();
+            if (this.check("DEDENT") || this.check("EOF"))
+                break;
+            if (!(this.check("IDENTIFIER") || this.check("KEYWORD"))) {
+                throw new ParseError(`Expected output schema field but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+            }
+            const outKey = this.current().value;
+            this.advance();
+            this.expect("COLON");
+            if (outKey === "type") {
+                outType = this.parseSchemaType();
+                this.expectNewline();
+            }
+            else if (outKey === "values") {
+                values = this.parseStringList();
+                this.expectNewline();
+            }
+            else if (outKey === "min") {
+                const val = this.expect("NUMBER").value;
+                min = Number.parseFloat(val);
+                this.expectNewline();
+            }
+            else if (outKey === "max") {
+                const val = this.expect("NUMBER").value;
+                max = Number.parseFloat(val);
+                this.expectNewline();
+            }
+            else if (outKey === "min_length") {
+                const val = this.expect("NUMBER").value;
+                minLength = Number.parseFloat(val);
+                this.expectNewline();
+            }
+            else if (outKey === "max_length") {
+                const val = this.expect("NUMBER").value;
+                maxLength = Number.parseFloat(val);
+                this.expectNewline();
+            }
+            else if (outKey === "pattern") {
+                pattern = this.expect("STRING").value;
+                this.expectNewline();
+            }
+            else if (outKey === "fields") {
+                fields = this.parseSchemaFields(keyToken);
+            }
+            else if (outKey === "items") {
+                items = this.parseSchemaAfterColon(keyToken);
+            }
+            else {
+                this.parseExpression();
+                this.expectNewline();
+            }
+        }
+        if (this.check("DEDENT"))
+            this.advance();
+        if (!outType) {
+            throw new ParseError("Advisory output type is required", {
+                location: keyToken.location,
+                source: this.source,
+            });
+        }
+        return {
+            kind: "advisory_output_schema",
+            type: outType,
+            values,
+            min,
+            max,
+            minLength,
+            maxLength,
+            pattern,
+            fields,
+            items,
+        };
+    }
+    parseSchemaFields(keyToken) {
+        this.expectNewline();
+        if (!this.check("INDENT")) {
+            throw new ParseError("Expected indented fields block", {
+                location: keyToken.location,
+                source: this.source,
+            });
+        }
+        this.advance();
+        const fields = {};
+        while (!this.check("DEDENT") && !this.check("EOF")) {
+            this.skipNewlines();
+            if (this.check("DEDENT") || this.check("EOF"))
+                break;
+            const fieldName = this.expect("IDENTIFIER").value;
+            this.expect("COLON");
+            fields[fieldName] = this.parseSchemaAfterColon(keyToken);
+        }
+        if (this.check("DEDENT"))
+            this.advance();
+        return fields;
+    }
+    parseSchemaType() {
+        if (this.check("STRING")) {
+            return this.advance().value;
+        }
+        if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+            return this.advance().value;
+        }
+        throw new ParseError("Expected output schema type", {
+            location: this.current().location,
+            source: this.source,
+        });
+    }
+    /** Parse using clause: using skill_name */
+    parseUsingClause() {
+        this.expect("KEYWORD", "using");
+        if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+            return this.advance().value;
+        }
+        if (this.check("STRING")) {
+            return this.advance().value;
+        }
+        throw new ParseError("Expected skill name after 'using'", {
+            location: this.current().location,
+            source: this.source,
+        });
+    }
+    /** Parse repeat statement */
+    parseRepeatStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "repeat");
+        const countToken = this.expect("NUMBER");
+        const count = {
+            kind: "literal",
+            value: countToken.value.includes(".")
+                ? Number.parseFloat(countToken.value)
+                : Number.parseInt(countToken.value, 10),
+            literalType: "number",
+        };
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        const node = { kind: "repeat", count, body };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse loop-until statement */
+    parseUntilStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "loop");
+        this.expect("KEYWORD", "until");
+        const condition = this.parseExpression();
+        let maxIterations;
+        if (this.check("KEYWORD", "max")) {
+            this.advance();
+            const maxToken = this.expect("NUMBER");
+            maxIterations = Number.parseFloat(maxToken.value);
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        const node = { kind: "until", condition, maxIterations, body };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse try/catch/finally */
+    parseTryStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "try");
+        this.expect("COLON");
+        this.expectNewline();
+        const tryBody = this.parseStatementBlock();
+        const catches = [];
+        while (this.check("KEYWORD", "catch")) {
+            catches.push(this.parseCatchBlock());
+        }
+        let finallyBody;
+        if (this.check("KEYWORD", "finally")) {
+            this.advance();
+            this.expect("COLON");
+            this.expectNewline();
+            finallyBody = this.parseStatementBlock();
+        }
+        const node = { kind: "try", tryBody, catches, finallyBody };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse catch block */
+    parseCatchBlock() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "catch");
+        let error = "*";
+        if (this.check("OPERATOR") && this.current().value === "*") {
+            this.advance();
+        }
+        else if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+            error = this.advance().value;
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const body = [];
+        let action;
+        let retry;
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                if ((this.check("IDENTIFIER") || this.check("KEYWORD")) &&
+                    this.current().value === "action") {
+                    this.advance();
+                    this.expect("COLON");
+                    if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                        action = this.advance().value;
+                    }
+                    else if (this.check("STRING")) {
+                        action = this.advance().value;
+                    }
+                    this.expectNewline();
+                    continue;
+                }
+                if ((this.check("IDENTIFIER") || this.check("KEYWORD")) &&
+                    this.current().value === "retry") {
+                    this.advance();
+                    this.expect("COLON");
+                    this.expectNewline();
+                    retry = this.parseRetrySpec();
+                    continue;
+                }
+                body.push(this.parseStatement());
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = { kind: "catch", error, action, retry, body };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse retry spec block */
+    parseRetrySpec() {
+        const startToken = this.current();
+        let maxAttempts = 3;
+        let backoff = "none";
+        let backoffBase;
+        let maxBackoff;
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                const key = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                if (key === "max_attempts") {
+                    maxAttempts = Number.parseFloat(this.expect("NUMBER").value);
+                }
+                else if (key === "backoff") {
+                    if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                        backoff = this.advance().value;
+                    }
+                    else if (this.check("STRING")) {
+                        backoff = this.advance().value;
+                    }
+                }
+                else if (key === "backoff_base") {
+                    backoffBase = Number.parseFloat(this.expect("NUMBER").value);
+                }
+                else if (key === "max_backoff") {
+                    maxBackoff = Number.parseFloat(this.expect("NUMBER").value);
+                }
+                else {
+                    this.parseExpression();
+                }
+                this.expectNewline();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = {
+            kind: "retry",
+            maxAttempts,
+            backoff,
+            backoffBase,
+            maxBackoff,
+        };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse parallel statement */
+    parseParallelStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "parallel");
+        let join;
+        let onFail;
+        // Optional header config before colon: join=..., on_fail=...
+        while (!this.check("COLON") && !this.check("NEWLINE") && !this.check("EOF")) {
+            if (!(this.check("IDENTIFIER") || this.check("KEYWORD")))
+                break;
+            const key = this.advance().value;
+            if (!this.check("ASSIGN"))
+                break;
+            this.advance();
+            if (key === "join") {
+                let joinType = "all";
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    joinType = this.advance().value;
+                }
+                else if (this.check("STRING")) {
+                    joinType = this.advance().value;
+                }
+                join = {
+                    kind: "parallel_join",
+                    type: joinType,
+                };
+            }
+            else if (key === "on_fail") {
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    onFail = this.advance().value;
+                }
+                else if (this.check("STRING")) {
+                    onFail = this.advance().value;
+                }
+            }
+            else if (key === "metric") {
+                if (!join) {
+                    join = { kind: "parallel_join", type: "best" };
+                }
+                join.metric = this.parseExpression();
+            }
+            else if (key === "order") {
+                if (!join) {
+                    join = { kind: "parallel_join", type: "best" };
+                }
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    join.order = this.advance().value;
+                }
+            }
+            else if (key === "count") {
+                if (!join) {
+                    join = { kind: "parallel_join", type: "any" };
+                }
+                if (this.check("NUMBER")) {
+                    join.count = Number.parseFloat(this.advance().value);
+                }
+            }
+            else {
+                // Unknown header option, skip value
+                this.parseExpression();
+            }
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const branches = [];
+        if (this.check("INDENT")) {
+            this.advance();
+            while (!this.check("DEDENT") && !this.check("EOF")) {
+                this.skipNewlines();
+                if (this.check("DEDENT") || this.check("EOF"))
+                    break;
+                const name = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                this.expectNewline();
+                const body = this.parseStatementBlock();
+                branches.push({ kind: "parallel_branch", name, body });
+                this.skipNewlines();
+            }
+            if (this.check("DEDENT"))
+                this.advance();
+        }
+        const node = { kind: "parallel", join, onFail, branches };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse pipeline after source expression */
+    parsePipeline(source, outputBinding, startToken) {
+        const stages = [];
+        while (this.check("OPERATOR") && this.current().value === "|") {
+            this.advance(); // consume |
+            const opToken = this.expect("IDENTIFIER");
+            const op = opToken.value;
+            let initial;
+            let count;
+            let order;
+            let by;
+            // Optional args
+            if (op === "reduce" && this.check("LPAREN")) {
+                this.advance();
+                initial = this.parseExpression();
+                this.expect("RPAREN");
+            }
+            else if ((op === "take" || op === "skip") && this.check("NUMBER")) {
+                count = Number.parseFloat(this.advance().value);
+            }
+            else if (op === "sort") {
+                if (this.check("IDENTIFIER") && this.current().value === "by") {
+                    this.advance();
+                    by = this.parseExpression();
+                }
+                if (this.check("IDENTIFIER") && this.current().value === "order") {
+                    this.advance();
+                    if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                        order = this.advance().value;
+                    }
+                }
+            }
+            this.expect("COLON");
+            this.expectNewline();
+            const body = this.parseStatementBlock();
+            if (body.length === 0 &&
+                (op === "map" || op === "filter" || op === "reduce" || op === "pmap")) {
+                throw new ParseError(`Pipeline stage '${op}' requires a body`, {
+                    location: opToken.location,
+                    source: this.source,
+                });
+            }
+            const stageStep = (body[0] ?? { kind: "pass" });
+            stages.push({
+                kind: "pipeline_stage",
+                op,
+                step: stageStep,
+                initial,
+                count,
+                order,
+                by,
+            });
+        }
+        const node = { kind: "pipeline", source, stages, outputBinding };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse do statement (block invocation) */
+    parseDoStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "do");
+        const nameParts = [];
+        nameParts.push(this.expect("IDENTIFIER").value);
+        while (this.check("DOT")) {
+            this.advance();
+            nameParts.push(this.expect("IDENTIFIER").value);
+        }
+        const name = nameParts.join(".");
+        const args = [];
+        if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN")) {
+                args.push(this.parseExpression());
+                if (this.check("COMMA"))
+                    this.advance();
+            }
+            this.expect("RPAREN");
+        }
+        this.expectNewline();
+        const node = { kind: "do", name, args };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse if statement */
+    parseIfStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "if");
+        // Check for advisory condition: if **prompt**:
+        let condition;
+        if (this.check("ADVISORY")) {
+            const prompt = this.advance().value;
+            let advisor;
+            if (this.check("KEYWORD", "via")) {
+                this.advance();
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    advisor = this.advance().value;
+                }
+            }
+            condition = { kind: "advisory_expr", prompt, advisor };
+        }
+        else {
+            condition = this.parseExpression();
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const thenBody = this.parseStatementBlock();
+        const elifs = [];
+        let elseBody = [];
+        // Check for elif
+        while (this.check("KEYWORD", "elif")) {
+            this.advance();
+            const elifCondition = this.parseExpression();
+            this.expect("COLON");
+            this.expectNewline();
+            const elifBody = this.parseStatementBlock();
+            elifs.push({ condition: elifCondition, body: elifBody });
+        }
+        // Check for else
+        if (this.check("KEYWORD", "else")) {
+            this.advance();
+            this.expect("COLON");
+            this.expectNewline();
+            elseBody = this.parseStatementBlock();
+        }
+        const node = { kind: "if", condition, thenBody, elifs, elseBody };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse for loop */
+    parseForStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "for");
+        const variable = this.expect("IDENTIFIER").value;
+        this.expect("KEYWORD", "in");
+        const iterable = this.parseExpression();
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        const node = { kind: "for", variable, iterable, body };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse atomic block: atomic: / atomic skip: / atomic halt: / atomic revert: */
+    parseAtomicStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "atomic");
+        let onFailure;
+        // Check for failure mode: atomic skip: / atomic halt: / atomic revert:
+        // Note: "halt" is a keyword, "skip" and "revert" are identifiers
+        const failureModes = ["skip", "halt", "revert"];
+        if ((this.check("IDENTIFIER") || this.check("KEYWORD")) &&
+            failureModes.includes(this.current().value)) {
+            onFailure = this.current().value;
+            this.advance();
+        }
+        this.expect("COLON");
+        this.expectNewline();
+        const body = this.parseStatementBlock();
+        const node = { kind: "atomic", body, onFailure };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse emit statement: emit event_name(key=value) */
+    parseEmitStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "emit");
+        const event = this.expect("IDENTIFIER").value;
+        const data = [];
+        if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN")) {
+                let key;
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    key = this.advance().value;
+                }
+                else {
+                    throw new ParseError(`Expected identifier in emit but got ${this.current().type} '${this.current().value}'`, { location: this.current().location, source: this.source });
+                }
+                this.expect("ASSIGN");
+                const value = this.parseExpression();
+                data.push({ key, value });
+                if (this.check("COMMA")) {
+                    this.advance();
+                }
+            }
+            this.expect("RPAREN");
+        }
+        this.expectNewline();
+        const node = { kind: "emit", event, data };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse halt statement */
+    parseHaltStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "halt");
+        let reason = "halted";
+        if (this.check("STRING")) {
+            reason = this.advance().value;
+        }
+        this.expectNewline();
+        const node = { kind: "halt", reason };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse wait statement */
+    parseWaitStatement() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "wait");
+        const durationToken = this.expect("NUMBER");
+        const duration = Number.parseFloat(durationToken.value);
+        this.expectNewline();
+        const node = { kind: "wait", duration };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    /** Parse constraint clause: with key=value, key=value, ... */
+    parseConstraintClause() {
+        const startToken = this.current();
+        this.expect("KEYWORD", "with");
+        const constraints = [];
+        do {
+            const key = this.expect("IDENTIFIER").value;
+            this.expect("ASSIGN");
+            const value = this.parseExpression();
+            constraints.push({ key, value });
+        } while (this.check("COMMA") &&
+            (() => {
+                this.advance();
+                return true;
+            })());
+        const node = { kind: "constraint_clause", constraints };
+        node.span = this.makeSpan(startToken);
+        return node;
+    }
+    // ===========================================================================
+    // EXPRESSION PARSING
+    // ===========================================================================
+    /** Parse an expression */
+    parseExpression() {
+        return this.parseTernary();
+    }
+    /** Parse ternary: cond ? then : else */
+    parseTernary() {
+        const condition = this.parseOr();
+        if (this.check("QUESTION")) {
+            this.advance();
+            const thenExpr = this.parseTernary();
+            this.expect("COLON");
+            const elseExpr = this.parseTernary();
+            return {
+                kind: "ternary",
+                condition,
+                thenExpr,
+                elseExpr,
+            };
+        }
+        return condition;
+    }
+    /** Parse or: a or b */
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.check("KEYWORD", "or")) {
+            this.advance();
+            const right = this.parseAnd();
+            left = { kind: "binary", op: "or", left, right };
+        }
+        return left;
+    }
+    /** Parse and: a and b */
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.check("KEYWORD", "and")) {
+            this.advance();
+            const right = this.parseEquality();
+            left = { kind: "binary", op: "and", left, right };
+        }
+        return left;
+    }
+    /** Parse equality: == != */
+    parseEquality() {
+        let left = this.parseComparison();
+        while (this.check("OPERATOR") &&
+            (this.current().value === "==" || this.current().value === "!=")) {
+            const op = this.advance().value;
+            const right = this.parseComparison();
+            left = { kind: "binary", op, left, right };
+        }
+        return left;
+    }
+    /** Parse comparison: < > <= >= */
+    parseComparison() {
+        let left = this.parseAdditive();
+        while (this.check("OPERATOR") && ["<", ">", "<=", ">="].includes(this.current().value)) {
+            const op = this.advance().value;
+            const right = this.parseAdditive();
+            left = { kind: "binary", op, left, right };
+        }
+        return left;
+    }
+    /** Parse additive: + - */
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.check("OPERATOR") &&
+            (this.current().value === "+" || this.current().value === "-")) {
+            const op = this.advance().value;
+            const right = this.parseMultiplicative();
+            left = { kind: "binary", op, left, right };
+        }
+        return left;
+    }
+    /** Parse multiplicative: * / % */
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.check("OPERATOR") && ["*", "/", "%"].includes(this.current().value)) {
+            const op = this.advance().value;
+            const right = this.parseUnary();
+            left = { kind: "binary", op, left, right };
+        }
+        return left;
+    }
+    /** Parse unary: not - */
+    parseUnary() {
+        if (this.check("KEYWORD", "not")) {
+            this.advance();
+            const arg = this.parseUnary();
+            return { kind: "unary", op: "not", arg };
+        }
+        if (this.check("OPERATOR", "-")) {
+            this.advance();
+            const arg = this.parseUnary();
+            return { kind: "unary", op: "-", arg };
+        }
+        return this.parsePostfix();
+    }
+    /** Parse postfix: . [] () */
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.check("DOT")) {
+                this.advance();
+                const property = this.expect("IDENTIFIER").value;
+                expr = { kind: "property_access", object: expr, property };
+            }
+            else if (this.check("LBRACKET")) {
+                this.advance();
+                const index = this.parseExpression();
+                this.expect("RBRACKET");
+                expr = { kind: "array_access", array: expr, index };
+            }
+            else if (this.check("LPAREN")) {
+                this.advance();
+                const args = [];
+                const kwargs = [];
+                while (!this.check("RPAREN")) {
+                    // Check for kwarg: key=value
+                    if (this.check("IDENTIFIER") && this.peek().type === "ASSIGN") {
+                        const key = this.advance().value;
+                        this.expect("ASSIGN");
+                        const value = this.parseExpression();
+                        kwargs.push({ key, value });
+                    }
+                    else {
+                        args.push(this.parseExpression());
+                    }
+                    if (this.check("COMMA")) {
+                        this.advance();
+                    }
+                }
+                this.expect("RPAREN");
+                expr = {
+                    kind: "call",
+                    callee: expr,
+                    args,
+                    kwargs: kwargs.length > 0 ? kwargs : undefined,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    /** Parse primary expression */
+    parsePrimary() {
+        const token = this.current();
+        // Number
+        if (token.type === "NUMBER") {
+            this.advance();
+            const value = token.value.includes(".")
+                ? Number.parseFloat(token.value)
+                : Number.parseInt(token.value, 10);
+            if (this.check("IDENTIFIER")) {
+                const unit = this.advance().value;
+                return { kind: "unit_literal", value, unit };
+            }
+            return { kind: "literal", value, literalType: "number" };
+        }
+        // String
+        if (token.type === "STRING") {
+            this.advance();
+            return { kind: "literal", value: token.value, literalType: "string" };
+        }
+        // Boolean
+        if (token.type === "BOOLEAN") {
+            this.advance();
+            return {
+                kind: "literal",
+                value: token.value === "true",
+                literalType: "boolean",
+            };
+        }
+        // Address
+        if (token.type === "ADDRESS") {
+            this.advance();
+            return { kind: "literal", value: token.value, literalType: "address" };
+        }
+        // Percentage
+        if (token.type === "PERCENTAGE") {
+            this.advance();
+            return { kind: "percentage", value: Number.parseFloat(token.value) };
+        }
+        // Venue reference: @name
+        if (token.type === "VENUE_REF") {
+            this.advance();
+            return { kind: "venue_ref_expr", name: token.value };
+        }
+        // Advisory: **text**
+        if (token.type === "ADVISORY") {
+            this.advance();
+            let advisor;
+            if (this.check("KEYWORD", "via")) {
+                this.advance();
+                if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+                    advisor = this.advance().value;
+                }
+            }
+            return { kind: "advisory_expr", prompt: token.value, advisor };
+        }
+        // Array literal: [a, b, c]
+        if (token.type === "LBRACKET") {
+            this.advance();
+            const elements = [];
+            while (!this.check("RBRACKET")) {
+                elements.push(this.parseExpression());
+                if (this.check("COMMA")) {
+                    this.advance();
+                }
+            }
+            this.expect("RBRACKET");
+            return { kind: "array_literal", elements };
+        }
+        // Object literal: {key: value}
+        if (token.type === "LBRACE") {
+            this.advance();
+            const entries = [];
+            while (!this.check("RBRACE")) {
+                const key = this.expect("IDENTIFIER").value;
+                this.expect("COLON");
+                const value = this.parseExpression();
+                entries.push({ key, value });
+                if (this.check("COMMA")) {
+                    this.advance();
+                }
+            }
+            this.expect("RBRACE");
+            return { kind: "object_literal", entries };
+        }
+        // Parenthesized expression
+        if (token.type === "LPAREN") {
+            this.advance();
+            const expr = this.parseExpression();
+            this.expect("RPAREN");
+            return expr;
+        }
+        // Identifier or keyword used as identifier in expression context
+        // Many keywords can be used as identifiers when they appear in expressions
+        const keywordsAsIdentifiers = new Set([
+            "max",
+            "assets",
+            "params",
+            "limits",
+            "state",
+            "venues",
+            "lending",
+            "swap",
+            "persistent",
+            "ephemeral",
+            "version",
+            "description",
+            "skills",
+            "advisors",
+            "guards",
+            "block",
+        ]);
+        if (token.type === "IDENTIFIER" ||
+            (token.type === "KEYWORD" && keywordsAsIdentifiers.has(token.value))) {
+            this.advance();
+            return { kind: "identifier", name: token.value };
+        }
+        throw new ParseError(`Unexpected token in expression: ${token.type} '${token.value}'`, {
+            location: token.location,
+            source: this.source,
+        });
+    }
+}
+// =============================================================================
+// PUBLIC API
+// =============================================================================
+/**
+ * Parse Grimoire source code into AST
+ */
+export function parse(source) {
+    const tokens = tokenize(source);
+    const parser = new Parser(tokens, source);
+    return parser.parseSpellFile();
+}
+//# sourceMappingURL=parser.js.map