sf-agentpmd 0.1.0 → 0.1.1

package/dist/commands/agentpmd/analyze.js

@@ -1,10 +1,4038 @@
-import { Flags, SfCommand } from '@salesforce/sf-plugins-core';
-import { analyzeSource } from '../../analyzer/analyze.js';
-import { discoverSfdxProject } from '../../analyzer/project.js';
-import { render } from '../../renderers/index.js';
-const FORMATS = ['text', 'markdown', 'sarif', 'csv'];
-export default class AgentpmdAnalyze extends SfCommand {
-    static description = `Walks .agent source files under --source-dir and emits per-procedure
+// src/commands/agentpmd/analyze.ts
+import { Flags, SfCommand } from "@salesforce/sf-plugins-core";
+
+// src/analyzer/analyze.ts
+import { readdir, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// vendor/agentscript-parser-javascript/dist/cst-node.js
+var EMPTY_CHILDREN = Object.freeze([]);
+var CSTNode = class {
+  type;
+  /** Whether this is a "named" node (true) or anonymous punctuation/keyword (false). */
+  isNamed;
+  isError;
+  isMissing;
+  startOffset;
+  endOffset;
+  // Flat position storage — avoids object allocations per node.
+  // Also exposed as startPosition/endPosition getters for compat.
+  startRow;
+  startCol;
+  endRow;
+  endCol;
+  /** Lazy children array — null for leaf nodes, allocated on first appendChild. */
+  _children = null;
+  parent = null;
+  /** Index of this node within its parent's children array. -1 if no parent. */
+  _childIndex = -1;
+  /** Field name → child indices. Lazy: null until first field is added. */
+  _fields = null;
+  /** Reverse map: child index → field name. Built lazily. */
+  _childFieldNames = null;
+  /** Cached named children. */
+  _namedChildren = null;
+  /** The original source string, shared across all nodes in a tree. */
+  _source;
+  constructor(type, source, startOffset, endOffset, startPosition, endPosition, isNamed = true, isError = false, isMissing = false) {
+    this.type = type;
+    this._source = source;
+    this.startOffset = startOffset;
+    this.endOffset = endOffset;
+    this.startRow = startPosition.row;
+    this.startCol = startPosition.column;
+    this.endRow = endPosition.row;
+    this.endCol = endPosition.column;
+    this.isNamed = isNamed;
+    this.isError = isError;
+    this.isMissing = isMissing;
+  }
+  get text() {
+    return this._source.slice(this.startOffset, this.endOffset);
+  }
+  get startPosition() {
+    return { row: this.startRow, column: this.startCol };
+  }
+  set startPosition(pos) {
+    this.startRow = pos.row;
+    this.startCol = pos.column;
+  }
+  get endPosition() {
+    return { row: this.endRow, column: this.endCol };
+  }
+  set endPosition(pos) {
+    this.endRow = pos.row;
+    this.endCol = pos.column;
+  }
+  get children() {
+    return this._children ?? EMPTY_CHILDREN;
+  }
+  set children(value) {
+    this._children = value;
+  }
+  get namedChildren() {
+    if (!this._namedChildren) {
+      this._namedChildren = this.children.filter((c) => c.isNamed);
+    }
+    return this._namedChildren;
+  }
+  get previousSibling() {
+    if (!this.parent || this._childIndex <= 0)
+      return null;
+    return this.parent.children[this._childIndex - 1];
+  }
+  get nextSibling() {
+    if (!this.parent)
+      return null;
+    const siblings = this.parent.children;
+    return this._childIndex < siblings.length - 1 ? siblings[this._childIndex + 1] : null;
+  }
+  childForFieldName(name) {
+    if (!this._fields)
+      return null;
+    const indices = this._fields.get(name);
+    if (!indices || indices.length === 0)
+      return null;
+    return this.children[indices[0]] ?? null;
+  }
+  childrenForFieldName(name) {
+    if (!this._fields)
+      return [];
+    const indices = this._fields.get(name);
+    if (!indices)
+      return [];
+    return indices.map((i) => this.children[i]).filter(Boolean);
+  }
+  /** True if this node or any descendant has an error or missing node. */
+  get hasError() {
+    if (this.isError || this.isMissing)
+      return true;
+    return this.children.some((c) => c.hasError);
+  }
+  /** Get the field name for a child at a given index. */
+  fieldNameForChild(index) {
+    if (!this._fields)
+      return null;
+    if (!this._childFieldNames) {
+      this._childFieldNames = /* @__PURE__ */ new Map();
+      for (const [fieldName, indices] of this._fields) {
+        for (const idx of indices) {
+          this._childFieldNames.set(idx, fieldName);
+        }
+      }
+    }
+    return this._childFieldNames.get(index) ?? null;
+  }
+  /** Add a child node, optionally associating it with a field name. */
+  appendChild(child, fieldName) {
+    if (!this._children)
+      this._children = [];
+    const idx = this._children.length;
+    child.parent = this;
+    child._childIndex = idx;
+    this._children.push(child);
+    this.endRow = child.endRow;
+    this.endCol = child.endCol;
+    this.endOffset = child.endOffset;
+    if (fieldName) {
+      if (!this._fields)
+        this._fields = /* @__PURE__ */ new Map();
+      let arr = this._fields.get(fieldName);
+      if (!arr) {
+        arr = [];
+        this._fields.set(fieldName, arr);
+      }
+      arr.push(idx);
+    }
+  }
+  /** @deprecated No-op: appendChild() tracks end position incrementally. */
+  finalize() {
+  }
+  /** Serialize to s-expression format for testing (named nodes only, no text). */
+  toSExp() {
+    return nodeToSExp(this);
+  }
+  /**
+   * Serialize to verbose s-expression format that includes ALL nodes
+   * (both named and anonymous) with truncated text content.
+   * Matches the source-of-truth format in sot/source.s-expression.
+   */
+  toVerboseSExp() {
+    return nodeToVerboseSExp(this, 0);
+  }
+};
+function nodeToSExp(node) {
+  const parts = [];
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    if (!child.isNamed && !child.isError && !child.isMissing)
+      continue;
+    const fieldName = node.fieldNameForChild(i);
+    const childStr = child.children.length > 0 || child.isError ? nodeToSExp(child) : child.isMissing ? `(MISSING ${child.type})` : `(${child.type})`;
+    if (fieldName) {
+      parts.push(`${fieldName}: ${childStr}`);
+    } else {
+      parts.push(childStr);
+    }
+  }
+  if (node.isError) {
+    if (parts.length === 0) {
+      return `(ERROR)`;
+    }
+    return `(ERROR ${parts.join(" ")})`;
+  }
+  if (node.isMissing) {
+    return `(MISSING ${node.type})`;
+  }
+  if (parts.length === 0) {
+    return `(${node.type})`;
+  }
+  return `(${node.type} ${parts.join(" ")})`;
+}
+function nodeToVerboseSExp(node, depth) {
+  const indent = "  ".repeat(depth);
+  if (node.isMissing) {
+    return `${indent}(MISSING ${JSON.stringify(node.type)})`;
+  }
+  if (node.isError && node.children.length === 0) {
+    return `${indent}(ERROR)`;
+  }
+  if (node.children.length === 0) {
+    const rawText = node.text;
+    const truncated = rawText.length > 20 ? rawText.slice(0, 20) + "\u2026" : rawText;
+    const escaped = JSON.stringify(truncated);
+    return `${indent}(${node.type} ${escaped})`;
+  }
+  const childLines = [];
+  for (const child of node.children) {
+    childLines.push(nodeToVerboseSExp(child, depth + 1));
+  }
+  return `${indent}(${node.type}
+${childLines.join("\n")})`;
+}
+
+// vendor/agentscript-parser-javascript/dist/token.js
+var TokenKind;
+(function(TokenKind2) {
+  TokenKind2["NEWLINE"] = "NEWLINE";
+  TokenKind2["INDENT"] = "INDENT";
+  TokenKind2["DEDENT"] = "DEDENT";
+  TokenKind2["EOF"] = "EOF";
+  TokenKind2["ID"] = "ID";
+  TokenKind2["NUMBER"] = "NUMBER";
+  TokenKind2["STRING"] = "STRING";
+  TokenKind2["STRING_CONTENT"] = "STRING_CONTENT";
+  TokenKind2["ESCAPE_SEQUENCE"] = "ESCAPE_SEQUENCE";
+  TokenKind2["DATETIME"] = "DATETIME";
+  TokenKind2["TEMPLATE_CONTENT"] = "TEMPLATE_CONTENT";
+  TokenKind2["PLUS"] = "PLUS";
+  TokenKind2["MINUS"] = "MINUS";
+  TokenKind2["STAR"] = "STAR";
+  TokenKind2["SLASH"] = "SLASH";
+  TokenKind2["DOT"] = "DOT";
+  TokenKind2["COMMA"] = "COMMA";
+  TokenKind2["COLON"] = "COLON";
+  TokenKind2["EQ"] = "EQ";
+  TokenKind2["EQEQ"] = "EQEQ";
+  TokenKind2["NEQ"] = "NEQ";
+  TokenKind2["LT"] = "LT";
+  TokenKind2["GT"] = "GT";
+  TokenKind2["LTE"] = "LTE";
+  TokenKind2["GTE"] = "GTE";
+  TokenKind2["ARROW"] = "ARROW";
+  TokenKind2["ELLIPSIS"] = "ELLIPSIS";
+  TokenKind2["PERCENT"] = "PERCENT";
+  TokenKind2["PIPE"] = "PIPE";
+  TokenKind2["AT"] = "AT";
+  TokenKind2["LPAREN"] = "LPAREN";
+  TokenKind2["RPAREN"] = "RPAREN";
+  TokenKind2["LBRACKET"] = "LBRACKET";
+  TokenKind2["RBRACKET"] = "RBRACKET";
+  TokenKind2["LBRACE"] = "LBRACE";
+  TokenKind2["RBRACE"] = "RBRACE";
+  TokenKind2["TEMPLATE_EXPR_START"] = "TEMPLATE_EXPR_START";
+  TokenKind2["DASH_SPACE"] = "DASH_SPACE";
+  TokenKind2["DQUOTE"] = "DQUOTE";
+  TokenKind2["COMMENT"] = "COMMENT";
+  TokenKind2["ERROR_TOKEN"] = "ERROR_TOKEN";
+})(TokenKind || (TokenKind = {}));
+function isTokenKind(token, kind) {
+  return token.kind === kind;
+}
+
+// node_modules/tiny-invariant/dist/esm/tiny-invariant.js
+var isProduction = process.env.NODE_ENV === "production";
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  if (isProduction) {
+    throw new Error(prefix);
+  }
+  var provided = typeof message === "function" ? message() : message;
+  var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+  throw new Error(value);
+}
+
+// vendor/agentscript-parser-javascript/dist/lexer.js
+var CH_TAB = 9;
+var CH_LF = 10;
+var CH_CR = 13;
+var CH_SPACE = 32;
+var CH_BANG = 33;
+var CH_DQUOTE = 34;
+var CH_HASH = 35;
+var CH_DASH = 45;
+var CH_DOT = 46;
+var CH_0 = 48;
+var CH_9 = 57;
+var CH_LT = 60;
+var CH_EQ = 61;
+var CH_GT = 62;
+var CH_A = 65;
+var CH_Z = 90;
+var CH_BACKSLASH = 92;
+var CH_UNDERSCORE = 95;
+var CH_a = 97;
+var CH_z = 122;
+var CH_LBRACE = 123;
+var CH_NUL = 0;
+function isIdStart(c) {
+  return c >= CH_A && c <= CH_Z || c >= CH_a && c <= CH_z || c === CH_UNDERSCORE;
+}
+function isIdCont(c) {
+  return isIdStart(c) || c >= CH_0 && c <= CH_9;
+}
+function isDigit(c) {
+  return c >= CH_0 && c <= CH_9;
+}
+function isHorizontalWs(c) {
+  return c === CH_SPACE || c === CH_TAB;
+}
+var SINGLE_CHAR_TOKENS = new Array(128).fill(0);
+SINGLE_CHAR_TOKENS[43] = TokenKind.PLUS;
+SINGLE_CHAR_TOKENS[CH_DASH] = TokenKind.MINUS;
+SINGLE_CHAR_TOKENS[42] = TokenKind.STAR;
+SINGLE_CHAR_TOKENS[47] = TokenKind.SLASH;
+SINGLE_CHAR_TOKENS[CH_DOT] = TokenKind.DOT;
+SINGLE_CHAR_TOKENS[44] = TokenKind.COMMA;
+SINGLE_CHAR_TOKENS[58] = TokenKind.COLON;
+SINGLE_CHAR_TOKENS[61] = TokenKind.EQ;
+SINGLE_CHAR_TOKENS[60] = TokenKind.LT;
+SINGLE_CHAR_TOKENS[CH_GT] = TokenKind.GT;
+SINGLE_CHAR_TOKENS[124] = TokenKind.PIPE;
+SINGLE_CHAR_TOKENS[64] = TokenKind.AT;
+SINGLE_CHAR_TOKENS[40] = TokenKind.LPAREN;
+SINGLE_CHAR_TOKENS[41] = TokenKind.RPAREN;
+SINGLE_CHAR_TOKENS[91] = TokenKind.LBRACKET;
+SINGLE_CHAR_TOKENS[93] = TokenKind.RBRACKET;
+SINGLE_CHAR_TOKENS[CH_LBRACE] = TokenKind.LBRACE;
+SINGLE_CHAR_TOKENS[125] = TokenKind.RBRACE;
+var Lexer = class {
+  source;
+  offset = 0;
+  row = 0;
+  col = 0;
+  tokens = [];
+  indentStack = [0];
+  /** True when the current line started with `|` (template line). */
+  onTemplateLine = false;
+  /** Indent level of the line containing `|`. Content deeper than this is template content. */
+  templateBaseIndent = -1;
+  /** Nested brace depth inside a template expression (for `{` inside `{!...}`). -1 means not inside a template expression. */
+  templateExprBraceDepth = -1;
+  get inTemplateExpr() {
+    return this.templateExprBraceDepth >= 0;
+  }
+  /** Parenthesis depth — suppresses INDENT/DEDENT/NEWLINE when > 0 to support multi-line call expressions. */
+  bracketDepth = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  tokenize() {
+    this.tokens = [];
+    const estimate = this.source.length / 8 | 0;
+    if (estimate > 64) {
+      this.tokens.length = estimate;
+      this.tokens.length = 0;
+    }
+    this.offset = 0;
+    this.row = 0;
+    this.col = 0;
+    this.indentStack = [0];
+    this.bracketDepth = 0;
+    while (this.hasMore) {
+      this.tokenizeLine();
+    }
+    while (this.indentStack.length > 1) {
+      this.indentStack.pop();
+      this.emitVirtual(TokenKind.DEDENT);
+    }
+    this.emitVirtual(TokenKind.EOF);
+    return this.tokens;
+  }
+  tokenizeLine() {
+    const indentLength = this.consumeIndentation();
+    if (this.consumeNewline()) {
+      return;
+    }
+    const c = this.peekCharCode();
+    if (c === CH_HASH && (!this.onTemplateLine || indentLength <= this.templateBaseIndent)) {
+      const currentIndent2 = this.indentStack[this.indentStack.length - 1];
+      if (indentLength > currentIndent2) {
+        const nextContentIndent = this.peekNextContentIndent();
+        if (nextContentIndent < indentLength) {
+          this.emitIndentation(currentIndent2);
+          return this.tokenizeComment();
+        }
+      } else if (indentLength < currentIndent2) {
+        const nextContentIndent = this.peekNextContentIndent();
+        if (nextContentIndent > indentLength) {
+          this.emitIndentation(nextContentIndent);
+          return this.tokenizeComment();
+        }
+      } else {
+        const nextContentIndent = this.peekNextContentIndent();
+        if (nextContentIndent > indentLength) {
+          return this.tokenizeComment();
+        }
+      }
+      this.emitIndentation(indentLength);
+      return this.tokenizeComment();
+    }
+    const currentIndent = this.indentStack[this.indentStack.length - 1];
+    if (this.onTemplateLine && indentLength > this.templateBaseIndent && currentIndent > this.templateBaseIndent && indentLength !== currentIndent) {
+      this.emitIndentation(currentIndent);
+    } else {
+      this.emitIndentation(indentLength);
+    }
+    if (this.bracketDepth === 0 && c === CH_DASH) {
+      const nc = this.peekCharCode(1);
+      const atEOF = this.offset + 1 >= this.source.length;
+      if (nc === CH_SPACE || this.atNewline(1) || atEOF) {
+        this.emit(TokenKind.DASH_SPACE, nc === CH_SPACE ? "- " : "-");
+      }
+    }
+    while (this.hasMore) {
+      const c2 = this.peekCharCode();
+      if (this.consumeNewline()) {
+        return;
+      }
+      if (c2 === CH_CR) {
+        invariant(!this.atNewline());
+        this.advance();
+        continue;
+      }
+      if (isHorizontalWs(c2)) {
+        this.advance();
+        continue;
+      }
+      if (c2 === CH_BACKSLASH) {
+        if (this.atNewline(1)) {
+          this.advance();
+          invariant(this.consumeNewline());
+          while (isHorizontalWs(this.peekCharCode())) {
+            this.advance();
+          }
+          continue;
+        }
+      }
+      if (c2 === CH_HASH && !this.onTemplateLine) {
+        return this.tokenizeComment();
+      }
+      this.tokenizeToken();
+    }
+  }
+  emitIndentation(indentLength) {
+    if (this.bracketDepth > 0)
+      return;
+    const currentIndent = this.indentStack[this.indentStack.length - 1];
+    if (indentLength > currentIndent) {
+      this.indentStack.push(indentLength);
+      this.emitVirtual(TokenKind.INDENT);
+    } else if (indentLength < currentIndent) {
+      if (indentLength <= this.templateBaseIndent) {
+        this.onTemplateLine = false;
+        this.templateExprBraceDepth = -1;
+      }
+      while (this.indentStack.length > 1 && this.indentStack[this.indentStack.length - 1] > indentLength) {
+        this.indentStack.pop();
+        this.emitVirtual(TokenKind.DEDENT);
+      }
+      this.emitVirtual(TokenKind.NEWLINE);
+    } else {
+      if (indentLength <= this.templateBaseIndent) {
+        this.onTemplateLine = false;
+        this.templateExprBraceDepth = -1;
+      }
+      if (this.tokens.length > 0) {
+        this.emitVirtual(TokenKind.NEWLINE);
+      }
+    }
+  }
+  tokenizeToken() {
+    const c = this.peekCharCode();
+    if (isDigit(c)) {
+      if (this.tryDatetime()) {
+        return;
+      }
+      this.tokenizeNumber();
+      return;
+    }
+    if (isIdStart(c)) {
+      this.tokenizeId();
+      return;
+    }
+    if (!this.onTemplateLine || this.inTemplateExpr) {
+      if (c === CH_DQUOTE) {
+        this.tokenizeString();
+        return;
+      }
+    }
+    if (c === CH_LBRACE && this.peekCharCode(1) === CH_BANG) {
+      this.templateExprBraceDepth = 0;
+      this.emit(TokenKind.TEMPLATE_EXPR_START, "{!");
+      return;
+    }
+    if (c === CH_DOT) {
+      if (this.peekCharCode(1) === CH_DOT && this.peekCharCode(2) === CH_DOT) {
+        this.emit(TokenKind.ELLIPSIS, "...");
+        return;
+      }
+      if (isDigit(this.peekCharCode(1))) {
+        const prev = this.tokens[this.tokens.length - 1];
+        const isMemberAccess = prev !== void 0 && (prev.kind === TokenKind.ID || prev.kind === TokenKind.NUMBER || prev.kind === TokenKind.RPAREN || prev.kind === TokenKind.RBRACKET);
+        if (!isMemberAccess) {
+          this.tokenizeNumber();
+          return;
+        }
+      }
+    }
+    if (c === CH_DASH) {
+      if (this.peekCharCode(1) === CH_GT) {
+        return this.emit(TokenKind.ARROW, "->");
+      }
+    }
+    const nc = this.peekCharCode(1);
+    if (nc === CH_EQ) {
+      if (c === CH_EQ) {
+        return this.emit(TokenKind.EQEQ, "==");
+      }
+      if (c === CH_BANG) {
+        return this.emit(TokenKind.NEQ, "!=");
+      }
+      if (c === CH_LT) {
+        return this.emit(TokenKind.LTE, "<=");
+      }
+      if (c === CH_GT) {
+        return this.emit(TokenKind.GTE, ">=");
+      }
+    }
+    const kind = c < 128 ? SINGLE_CHAR_TOKENS[c] : 0;
+    if (kind) {
+      this.emitSpan(kind, 1);
+      switch (kind) {
+        // Track template lines: `|` starts a template context for this line
+        // and continuation lines indented deeper than this level.
+        case TokenKind.PIPE:
+          this.onTemplateLine = true;
+          this.templateBaseIndent = this.indentStack[this.indentStack.length - 1];
+          break;
+        // Track parenthesis depth to suppress structural tokens inside
+        // multi-line call expressions.  Skip when inside a template line —
+        // parens in template content are literal text and must not suppress
+        // INDENT/DEDENT emission (unmatched parens would eat the rest of
+        // the file).
+        case TokenKind.LPAREN:
+          if (!this.onTemplateLine)
+            this.bracketDepth++;
+          break;
+        case TokenKind.RPAREN:
+          if (!this.onTemplateLine)
+            this.bracketDepth--;
+          break;
+        // Track brace depth inside {!...} template expressions so that nested
+        // braces (e.g. JSON objects) don't prematurely close the expression.
+        case TokenKind.LBRACE:
+          if (this.inTemplateExpr) {
+            this.templateExprBraceDepth++;
+          }
+          break;
+        case TokenKind.RBRACE:
+          if (this.inTemplateExpr) {
+            this.templateExprBraceDepth--;
+          }
+          break;
+      }
+      return;
+    }
+    this.emitSpan(TokenKind.ERROR_TOKEN, 1);
+  }
+  tokenizeId() {
+    let i = 0;
+    for (; ; i++) {
+      const c = this.peekCharCode(i);
+      if (!isIdCont(c))
+        break;
+    }
+    this.emitSpan(TokenKind.ID, i);
+  }
+  tokenizeNumber() {
+    let tokenLength = 0;
+    const leadingDot = this.peekCharCode(tokenLength) === CH_DOT;
+    if (leadingDot) {
+      tokenLength++;
+    }
+    while (isDigit(this.peekCharCode(tokenLength))) {
+      tokenLength++;
+    }
+    if (!leadingDot && this.peekCharCode(tokenLength) === CH_DOT) {
+      tokenLength++;
+    }
+    while (isDigit(this.peekCharCode(tokenLength))) {
+      tokenLength++;
+    }
+    this.emitSpan(TokenKind.NUMBER, tokenLength);
+  }
+  tryDatetime() {
+    const remaining = this.source.length - this.offset;
+    if (remaining < 10)
+      return false;
+    if (this.source.charCodeAt(this.offset + 4) !== CH_DASH || this.source.charCodeAt(this.offset + 7) !== CH_DASH) {
+      return false;
+    }
+    const slice = this.source.slice(this.offset, this.offset + 30);
+    const match = slice.match(/^\d{4}-\d{2}-\d{2}(T\d{1,2}(:\d{2})?(:\d{2})?(\.\d+)?Z?)?/);
+    if (!match)
+      return false;
+    const matchText = match[0];
+    if (matchText.length < 10)
+      return false;
+    this.emit(TokenKind.DATETIME, matchText);
+    return true;
+  }
+  tokenizeString() {
+    const start = this.position;
+    const startOffset = this.offset;
+    const quoteCode = this.peekCharCode();
+    this.advance();
+    while (this.hasMore) {
+      const c = this.peekCharCode();
+      if (c === quoteCode) {
+        this.advance();
+        const text2 = this.source.slice(startOffset, this.offset);
+        this.tokens.push(this.makeToken(TokenKind.STRING, text2, start, this.position, startOffset));
+        return;
+      }
+      if (c === CH_BACKSLASH) {
+        this.advance(2);
+        continue;
+      }
+      if (this.atNewline()) {
+        break;
+      }
+      if (c === CH_CR) {
+        invariant(!this.atNewline());
+        this.advance();
+        continue;
+      }
+      if (c === CH_NUL) {
+        break;
+      }
+      this.advance();
+    }
+    const text = this.source.slice(startOffset, this.offset);
+    this.tokens.push(this.makeToken(TokenKind.STRING, text, start, this.position, startOffset));
+  }
+  tokenizeComment() {
+    const start = this.position;
+    const startOffset = this.offset;
+    while (this.hasMore && !this.atNewline()) {
+      this.advance();
+    }
+    const text = this.source.slice(startOffset, this.offset);
+    this.tokens.push(this.makeToken(TokenKind.COMMENT, text, start, this.position, startOffset));
+    this.consumeNewline();
+  }
+  consumeIndentation() {
+    let indentLength = 0;
+    while (this.hasMore) {
+      const c = this.peekCharCode();
+      if (c === CH_SPACE) {
+        indentLength += 1;
+        this.advance();
+      } else if (c === CH_TAB) {
+        indentLength += 3;
+        this.advance();
+      } else if (c === CH_CR) {
+        indentLength = 0;
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    return indentLength;
+  }
+  /**
+   * Scan ahead (without advancing) past comment/blank lines to find the indent
+   * of the next line with real (non-comment) content. Returns -1 if only
+   * comments, blanks, or EOF remain. Matches tree-sitter scanner behavior which
+   * skips past comment-only lines when computing INDENT/DEDENT.
+   */
+  peekNextContentIndent() {
+    const startPosition = this.position;
+    const startOffset = this.offset;
+    while (this.hasMore) {
+      if (this.consumeNewline())
+        break;
+      this.advance();
+    }
+    while (this.hasMore) {
+      const lineIndent = this.consumeIndentation();
+      if (this.consumeNewline())
+        continue;
+      const c = this.peekCharCode();
+      if (c === CH_HASH) {
+        while (this.hasMore) {
+          if (this.consumeNewline())
+            break;
+          this.advance();
+        }
+        continue;
+      }
+      this.offset = startOffset;
+      this.row = startPosition.row;
+      this.col = startPosition.column;
+      return lineIndent;
+    }
+    this.offset = startOffset;
+    this.row = startPosition.row;
+    this.col = startPosition.column;
+    return -1;
+  }
+  // --- Utility methods ---
+  peekCharCode(additiveOffset = 0) {
+    return this.source.charCodeAt(this.offset + additiveOffset);
+  }
+  get hasMore() {
+    return this.offset < this.source.length && this.offset >= 0;
+  }
+  /**
+   * Attempt to advance n characters.
+   * @returns how many characters were advanced.
+   */
+  advance(n = 1) {
+    n = Math.max(0, Math.min(n, this.source.length - this.offset));
+    this.col += n;
+    for (let i = 0; i < n; i++) {
+      if (this.peekCharCode(i) === CH_LF) {
+        this.row++;
+        this.col = n - i - 1;
+      }
+    }
+    this.offset += n;
+    return n;
+  }
+  /**
+   * Attempt to consume a newline.
+   * @returns whether a newline was consumed.
+   */
+  consumeNewline() {
+    const newChars = this.atNewline();
+    if (newChars > 0) {
+      invariant(this.advance(newChars));
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Checks if the current position is at a newline.
+   * @param additiveOffset
+   * @returns 0 if not at a newline, 1 if at an LF newline, 2 if at a CR LF newline.
+   */
+  atNewline(additiveOffset = 0) {
+    const firstChar = this.peekCharCode(additiveOffset);
+    if (firstChar === CH_LF)
+      return 1;
+    if (firstChar === CH_CR && this.peekCharCode(additiveOffset + 1) === CH_LF)
+      return 2;
+    return 0;
+  }
+  get position() {
+    return { row: this.row, column: this.col };
+  }
+  emitSpan(kind, length) {
+    const text = this.source.slice(this.offset, this.offset + length);
+    return this.emit(kind, text);
+  }
+  emit(kind, text) {
+    const startPosition = this.position;
+    const startOffset = this.offset;
+    invariant(text === this.source.slice(startOffset, startOffset + text.length), `expected '${text}' but got ${this.source.slice(startOffset, startOffset + text.length)} at offset ${startOffset}`);
+    this.advance(text.length);
+    this.tokens.push(this.makeToken(kind, text, startPosition, this.position, startOffset));
+  }
+  emitVirtual(kind) {
+    return this.emit(kind, "");
+  }
+  makeToken(kind, text, start, end, startOffset) {
+    return { kind, text, start, end, startOffset };
+  }
+};
+
+// vendor/agentscript-parser-javascript/dist/errors.js
+function makeErrorNode(source, children, startOffset, endOffset, startPosition, endPosition) {
+  const node = new CSTNode("ERROR", source, startOffset, endOffset, startPosition, endPosition, true, true);
+  for (const child of children) {
+    node.appendChild(child);
+  }
+  return node;
+}
+function tokenToLeaf(token, source, isNamed, offset) {
+  return new CSTNode(tokenTypeToNodeType(token), source, offset, offset + token.text.length, token.start, token.end, isNamed);
+}
+var NAMED_TOKEN_KINDS = /* @__PURE__ */ new Set([
+  TokenKind.ID,
+  TokenKind.NUMBER,
+  TokenKind.STRING,
+  TokenKind.DATETIME,
+  TokenKind.COMMENT,
+  TokenKind.ELLIPSIS
+]);
+function tokenToAutoLeaf(token, source, offset) {
+  return tokenToLeaf(token, source, NAMED_TOKEN_KINDS.has(token.kind), offset);
+}
+function tokenTypeToNodeType(token) {
+  switch (token.kind) {
+    case TokenKind.ID:
+      return "id";
+    case TokenKind.NUMBER:
+      return "number";
+    case TokenKind.STRING:
+      return "string";
+    case TokenKind.DATETIME:
+      return "datetime_literal";
+    case TokenKind.COMMENT:
+      return "comment";
+    case TokenKind.ELLIPSIS:
+      return "ellipsis";
+    default:
+      return token.text;
+  }
+}
+function isSyncPoint(kind) {
+  return kind === TokenKind.NEWLINE || kind === TokenKind.DEDENT || kind === TokenKind.EOF;
+}
+
+// vendor/agentscript-parser-javascript/dist/recovery.js
+function makeEmptyError(ctx) {
+  const offset = ctx.peekOffset();
+  const pos = ctx.peek().start;
+  return new CSTNode("ERROR", ctx.source, offset, offset, pos, pos, true, true);
+}
+function addMissingTarget(ctx, node) {
+  const errAtom = makeEmptyError(ctx);
+  const atom = new CSTNode("atom", ctx.source, errAtom.startOffset, errAtom.endOffset, errAtom.startPosition, errAtom.endPosition);
+  atom.appendChild(errAtom);
+  const expr = new CSTNode("expression", ctx.source, atom.startOffset, atom.endOffset, atom.startPosition, atom.endPosition);
+  expr.appendChild(atom);
+  node.appendChild(expr, "target");
+}
+function makeMissing(ctx, type) {
+  const offset = ctx.peekOffset();
+  const pos = ctx.peek().start;
+  return new CSTNode(type, ctx.source, offset, offset, pos, pos, true, false, true);
+}
+function parseOrphanBlock(ctx, parseProcedure2) {
+  const startOffset = ctx.peekOffset();
+  const startPos = ctx.peek().start;
+  const children = [];
+  const keywordTok = ctx.consume();
+  const kwOffset = ctx.currentOffset();
+  children.push(new CSTNode(keywordTok.text, ctx.source, kwOffset, kwOffset + keywordTok.text.length, keywordTok.start, keywordTok.end, false));
+  while (!ctx.isAtSyncPoint() && !isAtEnd(ctx) && ctx.peekKind() !== TokenKind.COLON) {
+    ctx.consume();
+  }
+  if (ctx.peekKind() === TokenKind.COLON)
+    ctx.consume();
+  if (ctx.peekKind() === TokenKind.INDENT) {
+    ctx.consume();
+    const proc = parseProcedure2(ctx);
+    if (proc) {
+      for (const child of proc.namedChildren) {
+        children.push(child);
+      }
+    }
+    while (ctx.peekKind() === TokenKind.COMMENT || ctx.peekKind() === TokenKind.NEWLINE) {
+      if (ctx.peekKind() === TokenKind.COMMENT) {
+        children.push(ctx.consumeNamed("comment"));
+      } else {
+        ctx.consume();
+      }
+    }
+    if (ctx.peekKind() === TokenKind.DEDENT)
+      ctx.consume();
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  const endOffset = children.length > 0 ? children[children.length - 1].endOffset : ctx.peekOffset();
+  const endPos = children.length > 0 ? children[children.length - 1].endPosition : ctx.peek().start;
+  return makeErrorNode(ctx.source, children, startOffset, endOffset, startPos, endPos);
+}
+function recoverToBlockEnd(ctx, parent) {
+  while (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
+    if (ctx.peekKind() === TokenKind.NEWLINE) {
+      ctx.consume();
+      continue;
+    }
+    if (ctx.peekKind() === TokenKind.INDENT) {
+      ctx.consume();
+      recoverToBlockEnd(ctx, parent);
+      if (ctx.peekKind() === TokenKind.DEDENT)
+        ctx.consume();
+      continue;
+    }
+    const err = synchronize(ctx);
+    if (err) {
+      parent.appendChild(err);
+    } else {
+      break;
+    }
+  }
+}
+function synchronizeUntil(ctx, extraStop) {
+  if (ctx.isAtSyncPoint() || isAtEnd(ctx))
+    return null;
+  if (extraStop && extraStop(ctx.peekKind(), ctx.peek().start.row))
+    return null;
+  const startOffset = ctx.peekOffset();
+  const startPos = ctx.peek().start;
+  const children = [];
+  while (!ctx.isAtSyncPoint() && !isAtEnd(ctx) && !(extraStop && extraStop(ctx.peekKind(), ctx.peek().start.row))) {
+    const tok = ctx.consume();
+    children.push(tokenToAutoLeaf(tok, ctx.source, ctx.currentOffset()));
+  }
+  if (children.length === 0)
+    return null;
+  const last = children[children.length - 1];
+  return makeErrorNode(ctx.source, children, startOffset, last.endOffset, startPos, last.endPosition);
+}
+function synchronizeRowUntilColon(ctx, row) {
+  return synchronizeUntil(ctx, (kind, r) => kind === TokenKind.INDENT || kind === TokenKind.COLON || r !== row);
+}
+function synchronizeRow(ctx, row) {
+  return synchronizeUntil(ctx, (kind, r) => kind === TokenKind.INDENT || r !== row);
+}
+function synchronize(ctx) {
+  return synchronizeUntil(ctx);
+}
+function skipNewlines(ctx) {
+  while (ctx.peekKind() === TokenKind.NEWLINE) {
+    ctx.consume();
+  }
+}
+function consumeCommentsAndSkipNewlines(ctx, parent) {
+  while (true) {
+    if (ctx.peekKind() === TokenKind.COMMENT) {
+      parent.appendChild(ctx.consumeNamed("comment"));
+    } else if (ctx.peekKind() === TokenKind.NEWLINE) {
+      ctx.consume();
+    } else {
+      break;
+    }
+  }
+}
+function isAtEnd(ctx) {
+  return ctx.peekKind() === TokenKind.EOF;
+}
+function isTrailingCommentOnly(ctx) {
+  let i = 0;
+  while (i < 50) {
+    const tok = ctx.peekAt(i);
+    if (tok.kind === TokenKind.EOF || tok.kind === TokenKind.DEDENT)
+      return true;
+    if (tok.kind === TokenKind.COMMENT || tok.kind === TokenKind.NEWLINE) {
+      i++;
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+
+// vendor/agentscript-parser-javascript/dist/expressions.js
+var VALID_ESCAPES = /* @__PURE__ */ new Set(['"', "'", "\\", "n", "r", "t", "0"]);
+var KEY_STOP_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "elif",
+  "else",
+  "run",
+  "set",
+  "with",
+  "to",
+  "transition",
+  "available",
+  "and",
+  "or",
+  "not",
+  "is",
+  "True",
+  "False",
+  "None",
+  "mutable",
+  "linked",
+  "empty"
+]);
+function makeMissingArgument(ctx) {
+  const offset = ctx.peekOffset();
+  const pos = ctx.peek().start;
+  const missingId = new CSTNode("id", ctx.source, offset, offset, pos, pos, true, false, true);
+  const atom = new CSTNode("atom", ctx.source, offset, offset, pos, pos);
+  atom.appendChild(missingId);
+  const expr = new CSTNode("expression", ctx.source, offset, offset, pos, pos);
+  expr.appendChild(atom);
+  return expr;
+}
+function makeEmptyError2(ctx) {
+  const tok = ctx.peek();
+  const offset = ctx.peekOffset();
+  return new CSTNode("ERROR", ctx.source, offset, offset, tok.start, tok.start, true, true);
+}
+function parseExpression(ctx, minPrec = 0) {
+  let left = parsePrefix(ctx);
+  if (!left)
+    return null;
+  while (true) {
+    const nextKind = ctx.peekKind();
+    if (nextKind === TokenKind.NEWLINE || nextKind === TokenKind.DEDENT || nextKind === TokenKind.EOF)
+      break;
+    const prec = infixPrecedence(ctx);
+    if (prec < minPrec)
+      break;
+    const result = parseInfix(ctx, left, prec);
+    if (!result)
+      break;
+    left = result;
+  }
+  return left;
+}
+function parsePrefix(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.ID && tok.text === "not") {
+    return parseUnary(ctx, "not", 3);
+  }
+  if (tok.kind === TokenKind.PLUS || tok.kind === TokenKind.MINUS) {
+    const op = tok.text;
+    return parseUnary(ctx, op, 7);
+  }
+  if (tok.kind === TokenKind.STAR) {
+    return parseSpread(ctx);
+  }
+  if (tok.kind === TokenKind.LPAREN) {
+    return parseParenthesized(ctx);
+  }
+  return parseAtom(ctx);
+}
+function parseUnary(ctx, _op, prec) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("unary_expression");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const operand = parseExpression(ctx, prec + 1);
+  if (operand) {
+    node.appendChild(wrapExpression(ctx, operand));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseSpread(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("spread_expression");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const operand = parseExpression(ctx, 8);
+  if (operand) {
+    node.appendChild(wrapExpression(ctx, operand), "expression");
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseParenthesized(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("parenthesized_expression");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const expr = parseExpression(ctx, 0);
+  if (expr) {
+    node.appendChild(wrapExpression(ctx, expr), "expression");
+  } else if (ctx.peekKind() === TokenKind.RPAREN) {
+    node.appendChild(makeMissingArgument(ctx), "expression");
+  }
+  if (ctx.peekKind() === TokenKind.RPAREN) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseAtom(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.ID && (tok.text === "True" || tok.text === "False" || tok.text === "None")) {
+    const node = ctx.startNode("atom");
+    ctx.addAnonymousChild(node, ctx.consume());
+    ctx.finishNode(node, tok);
+    return node;
+  }
+  if (tok.kind === TokenKind.ID && tok.text === "empty") {
+    const node = ctx.startNode("empty_keyword");
+    ctx.addAnonymousChild(node, ctx.consume());
+    ctx.finishNode(node, tok);
+    return node;
+  }
+  if (tok.kind === TokenKind.AT) {
+    return parseAtId(ctx);
+  }
+  if (tok.kind === TokenKind.ID) {
+    return ctx.consumeNamed("id");
+  }
+  if (tok.kind === TokenKind.NUMBER) {
+    return ctx.consumeNamed("number");
+  }
+  if (tok.kind === TokenKind.DATETIME) {
+    return ctx.consumeNamed("datetime_literal");
+  }
+  if (tok.kind === TokenKind.STRING) {
+    return parseString(ctx);
+  }
+  if (tok.kind === TokenKind.ELLIPSIS) {
+    return ctx.consumeNamed("ellipsis");
+  }
+  if (tok.kind === TokenKind.LBRACKET) {
+    return parseList(ctx);
+  }
+  if (tok.kind === TokenKind.LBRACE) {
+    return parseDictionary(ctx);
+  }
+  return null;
+}
+function parseAtId(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("at_id");
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (ctx.peekKind() === TokenKind.ID) {
+    node.appendChild(ctx.consumeNamed("id"));
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseString(ctx) {
+  const tok = ctx.peek();
+  const startTok = tok;
+  const node = ctx.startNode("string");
+  const text = tok.text;
+  const tokenOffset = ctx.peekOffset();
+  ctx.consume();
+  const baseRow = startTok.start.row;
+  const baseCol = startTok.start.column;
+  node.appendChild(new CSTNode('"', ctx.source, tokenOffset, tokenOffset + 1, { row: baseRow, column: baseCol }, { row: baseRow, column: baseCol + 1 }, false));
+  let i = 1;
+  const quoteChar = text[0];
+  const hasClosingQuote = text.length > 1 && text[text.length - 1] === quoteChar;
+  const contentEnd = hasClosingQuote ? text.length - 1 : text.length;
+  let contentStart = i;
+  while (i < contentEnd) {
+    if (text[i] === "\\" && i + 1 < contentEnd && VALID_ESCAPES.has(text[i + 1])) {
+      if (i > contentStart) {
+        node.appendChild(new CSTNode("string_content", ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
+      }
+      const escLen = 2;
+      node.appendChild(new CSTNode("escape_sequence", ctx.source, tokenOffset + i, tokenOffset + i + escLen, { row: baseRow, column: baseCol + i }, { row: baseRow, column: baseCol + i + escLen }));
+      i += escLen;
+      contentStart = i;
+    } else if (text[i] === "\\" && i + 1 < contentEnd && !VALID_ESCAPES.has(text[i + 1])) {
+      if (i > contentStart) {
+        node.appendChild(new CSTNode("string_content", ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
+      }
+      const escStart = i;
+      i += 2;
+      while (i < contentEnd && /[a-zA-Z0-9_]/.test(text[i])) {
+        i++;
+      }
+      const errNode = new CSTNode("ERROR", ctx.source, tokenOffset + escStart, tokenOffset + i, { row: baseRow, column: baseCol + escStart }, { row: baseRow, column: baseCol + i }, true, true);
+      node.appendChild(errNode);
+      contentStart = i;
+    } else {
+      i++;
+    }
+  }
+  if (i > contentStart) {
+    node.appendChild(new CSTNode("string_content", ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
+  }
+  if (hasClosingQuote) {
+    node.appendChild(new CSTNode(quoteChar, ctx.source, tokenOffset + text.length - 1, tokenOffset + text.length, { row: baseRow, column: baseCol + text.length - 1 }, { row: baseRow, column: baseCol + text.length }, false));
+  } else {
+    const missingOffset = tokenOffset + text.length;
+    const missingPos = { row: baseRow, column: baseCol + text.length };
+    node.appendChild(new CSTNode(quoteChar, ctx.source, missingOffset, missingOffset, missingPos, missingPos, false, false, true));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseList(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("list");
+  ctx.addAnonymousChild(node, ctx.consume());
+  let _listIndentDepth = 0;
+  while (ctx.peekKind() !== TokenKind.RBRACKET && ctx.peekKind() !== TokenKind.EOF) {
+    if (ctx.peekKind() === TokenKind.NEWLINE) {
+      ctx.consume();
+      continue;
+    }
+    if (ctx.peekKind() === TokenKind.INDENT) {
+      _listIndentDepth++;
+      ctx.consume();
+      continue;
+    }
+    if (ctx.peekKind() === TokenKind.DEDENT) {
+      _listIndentDepth--;
+      ctx.consume();
+      continue;
+    }
+    const expr = parseExpression(ctx, 0);
+    if (expr) {
+      node.appendChild(wrapExpression(ctx, expr));
+    } else {
+      break;
+    }
+    if (ctx.peekKind() === TokenKind.COMMA) {
+      ctx.addAnonymousChild(node, ctx.consume());
+    } else {
+      break;
+    }
+  }
+  while (ctx.peekKind() === TokenKind.NEWLINE || ctx.peekKind() === TokenKind.INDENT || ctx.peekKind() === TokenKind.DEDENT) {
+    ctx.consume();
+  }
+  if (ctx.peekKind() === TokenKind.RBRACKET) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseDictionary(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("dictionary");
+  ctx.addAnonymousChild(node, ctx.consume());
+  while (ctx.peekKind() !== TokenKind.RBRACE && ctx.peekKind() !== TokenKind.EOF) {
+    if (ctx.peekKind() === TokenKind.NEWLINE || ctx.peekKind() === TokenKind.INDENT || ctx.peekKind() === TokenKind.DEDENT) {
+      ctx.consume();
+      continue;
+    }
+    const pair = parseDictionaryPair(ctx);
+    if (pair) {
+      node.appendChild(pair);
+    } else {
+      break;
+    }
+    if (ctx.peekKind() === TokenKind.COMMA) {
+      ctx.addAnonymousChild(node, ctx.consume());
+    } else {
+      break;
+    }
+  }
+  if (ctx.peekKind() === TokenKind.RBRACE) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseDictionaryPair(ctx) {
+  const startTok = ctx.peek();
+  if (!isKeyStart(ctx))
+    return null;
+  const node = ctx.startNode("dictionary_pair");
+  const key = parseKey(ctx);
+  if (key)
+    node.appendChild(key, "key");
+  if (ctx.peekKind() === TokenKind.COLON) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  }
+  const value = parseExpression(ctx, 0);
+  if (value)
+    node.appendChild(wrapExpression(ctx, value), "value");
+  ctx.finishNode(node, startTok);
+  return node;
+}
+var INFIX_PREC_BY_KIND = /* @__PURE__ */ new Map([
+  [TokenKind.LPAREN, 8],
+  [TokenKind.DOT, 8],
+  [TokenKind.LBRACKET, 8],
+  [TokenKind.EQEQ, 4],
+  [TokenKind.NEQ, 4],
+  [TokenKind.LT, 4],
+  [TokenKind.GT, 4],
+  [TokenKind.LTE, 4],
+  [TokenKind.GTE, 4],
+  [TokenKind.PLUS, 5],
+  [TokenKind.MINUS, 5],
+  [TokenKind.STAR, 6],
+  [TokenKind.SLASH, 6]
+]);
+var INFIX_KEYWORD_PREC = /* @__PURE__ */ new Map([
+  ["if", 0],
+  ["or", 1],
+  ["and", 2],
+  ["is", 4]
+]);
+function infixPrecedence(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.ID)
+    return INFIX_KEYWORD_PREC.get(tok.text) ?? -2;
+  return INFIX_PREC_BY_KIND.get(tok.kind) ?? -2;
+}
+function parseInfix(ctx, left, prec) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.LPAREN && prec === 8) {
+    return parseCall(ctx, left);
+  }
+  if (tok.kind === TokenKind.DOT && prec === 8) {
+    return parseMember(ctx, left);
+  }
+  if (tok.kind === TokenKind.LBRACKET && prec === 8) {
+    return parseSubscript(ctx, left);
+  }
+  if (tok.kind === TokenKind.ID && tok.text === "if") {
+    return parseTernary(ctx, left);
+  }
+  if (tok.kind === TokenKind.ID && tok.text === "is") {
+    return parseIsExpression(ctx, left);
+  }
+  return parseBinaryOrComparison(ctx, left, prec);
+}
+function parseCall(ctx, func) {
+  const startTok = ctx.peek();
+  const node = ctx.startNodeAt("call_expression", func);
+  node.appendChild(wrapExpression(ctx, func), "function");
+  ctx.addAnonymousChild(node, ctx.consume());
+  while (ctx.peekKind() !== TokenKind.RPAREN && !ctx.isAtSyncPoint()) {
+    const arg = parseExpression(ctx, 0);
+    if (arg) {
+      node.appendChild(wrapExpression(ctx, arg), "argument");
+    } else {
+      break;
+    }
+    if (ctx.peekKind() === TokenKind.COMMA) {
+      ctx.addAnonymousChild(node, ctx.consume());
+      if (ctx.peekKind() === TokenKind.RPAREN) {
+        node.appendChild(makeMissingArgument(ctx), "argument");
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+  if (ctx.peekKind() === TokenKind.RPAREN) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseMember(ctx, object) {
+  const startTok = ctx.peek();
+  const node = ctx.startNodeAt("member_expression", object);
+  node.appendChild(wrapExpression(ctx, object));
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (ctx.peekKind() === TokenKind.ID) {
+    node.appendChild(ctx.consumeNamed("id"));
+  } else if (ctx.peekKind() === TokenKind.NUMBER) {
+    const numNode = ctx.consumeNamed("number");
+    const errNode = new CSTNode("ERROR", ctx.source, numNode.startOffset, numNode.endOffset, numNode.startPosition, numNode.endPosition, true, true);
+    errNode.appendChild(numNode);
+    node.appendChild(errNode);
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseSubscript(ctx, object) {
+  const startTok = ctx.peek();
+  const node = ctx.startNodeAt("subscript_expression", object);
+  node.appendChild(wrapExpression(ctx, object));
+  ctx.addAnonymousChild(node, ctx.consume());
+  const index = parseExpression(ctx, 0);
+  if (index) {
+    node.appendChild(wrapExpression(ctx, index));
+  }
+  if (ctx.peekKind() === TokenKind.RBRACKET) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseTernary(ctx, consequence) {
+  const startTok = ctx.peek();
+  const node = ctx.startNodeAt("ternary_expression", consequence);
+  node.appendChild(wrapExpression(ctx, consequence), "consequence");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const condition = parseExpression(ctx, 1);
+  if (condition) {
+    node.appendChild(wrapExpression(ctx, condition), "condition");
+  }
+  if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === "else") {
+    ctx.addAnonymousChild(node, ctx.consume());
+    const alt = parseExpression(ctx, 0);
+    if (alt) {
+      node.appendChild(wrapExpression(ctx, alt), "alternative");
+    }
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseIsExpression(ctx, left) {
+  const startTok = ctx.peek();
+  const isNot = ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === "not";
+  const nodeType = "comparison_expression";
+  const node = ctx.startNodeAt(nodeType, left);
+  node.appendChild(wrapExpression(ctx, left));
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (isNot) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  }
+  const right = parseExpression(ctx, 5);
+  if (right) {
+    node.appendChild(wrapExpression(ctx, right));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseBinaryOrComparison(ctx, left, prec) {
+  const tok = ctx.peek();
+  const startTok = tok;
+  const isComparison = tok.kind === TokenKind.EQEQ || tok.kind === TokenKind.NEQ || tok.kind === TokenKind.LT || tok.kind === TokenKind.GT || tok.kind === TokenKind.LTE || tok.kind === TokenKind.GTE || tok.kind === TokenKind.EQ;
+  const nodeType = isComparison ? "comparison_expression" : "binary_expression";
+  const node = ctx.startNodeAt(nodeType, left);
+  node.appendChild(wrapExpression(ctx, left));
+  ctx.addAnonymousChild(node, ctx.consume());
+  const right = parseExpression(ctx, prec + 1);
+  if (right) {
+    node.appendChild(wrapExpression(ctx, right));
+  } else {
+    node.appendChild(makeEmptyError2(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+var SKIP_WRAP_TYPES = /* @__PURE__ */ new Set(["expression", "ERROR"]);
+var ATOM_TYPES = /* @__PURE__ */ new Set([
+  "id",
+  "number",
+  "string",
+  "datetime_literal",
+  "at_id",
+  "list",
+  "dictionary",
+  "ellipsis"
+]);
+function wrapExpression(ctx, inner) {
+  if (SKIP_WRAP_TYPES.has(inner.type)) {
+    return inner;
+  }
+  let wrapped = inner;
+  if (ATOM_TYPES.has(inner.type)) {
+    const atom = new CSTNode("atom", ctx.source, inner.startOffset, inner.endOffset, inner.startPosition, inner.endPosition);
+    atom.appendChild(inner);
+    wrapped = atom;
+  }
+  const expr = new CSTNode("expression", ctx.source, wrapped.startOffset, wrapped.endOffset, wrapped.startPosition, wrapped.endPosition);
+  expr.appendChild(wrapped);
+  return expr;
+}
+function isKeyStart(ctx) {
+  const tok = ctx.peek();
+  return isKeyTokenStart(tok.kind);
+}
+function isKeyTokenStart(kind) {
+  return kind === TokenKind.ID || kind === TokenKind.STRING || kind === TokenKind.NUMBER;
+}
+function isKeyTokenContinuation(kind) {
+  return isKeyTokenStart(kind) || kind === TokenKind.MINUS || kind === TokenKind.DOT;
+}
+function parseKey(ctx) {
+  if (!isKeyStart(ctx))
+    return null;
+  const startTok = ctx.peek();
+  const node = ctx.startNode("key");
+  if (ctx.peekKind() === TokenKind.NUMBER) {
+    const numNode = ctx.consumeNamed("number");
+    const errNode = new CSTNode("ERROR", ctx.source, numNode.startOffset, numNode.endOffset, numNode.startPosition, numNode.endPosition, true, true);
+    node.appendChild(errNode);
+    if (ctx.peekKind() === TokenKind.ID) {
+      node.appendChild(ctx.consumeNamed("id"));
+    }
+  } else if (ctx.peekKind() === TokenKind.STRING) {
+    node.appendChild(parseString(ctx));
+  } else {
+    node.appendChild(ctx.consumeNamed("id"));
+  }
+  if (ctx.peekKind() === TokenKind.ID && !ctx.isAtSyncPoint() && ctx.peek().start.row === startTok.start.row) {
+    const nextText = ctx.peek().text;
+    if (!KEY_STOP_KEYWORDS.has(nextText)) {
+      node.appendChild(ctx.consumeNamed("id"));
+    }
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+
+// vendor/agentscript-parser-javascript/dist/parse-statements.js
+function isStatementStart(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind !== TokenKind.ID)
+    return false;
+  switch (tok.text) {
+    case "if":
+    case "run":
+    case "set":
+    case "transition":
+      return true;
+    case "with":
+      return ctx.peekAt(1).kind !== TokenKind.COLON;
+    case "available":
+      return ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === "when";
+    default:
+      return false;
+  }
+}
+function parseProcedure(ctx, parseTemplate2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("procedure");
+  while (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
+    skipNewlines(ctx);
+    if (isAtEnd(ctx) || ctx.peekKind() === TokenKind.DEDENT)
+      break;
+    if (ctx.peekKind() === TokenKind.COMMENT && isTrailingCommentOnly(ctx)) {
+      break;
+    }
+    const stmt = parseStatement(ctx, parseTemplate2);
+    if (stmt) {
+      node.appendChild(stmt);
+    } else {
+      const err = synchronize(ctx);
+      if (err) {
+        node.appendChild(err);
+      } else if (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
+        ctx.consume();
+      }
+    }
+  }
+  if (node.namedChildren.length === 0) {
+    node.appendChild(makeEmptyError(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseStatement(ctx, parseTemplate2) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.ID) {
+    switch (tok.text) {
+      case "if":
+        return parseIfStatement(ctx, parseTemplate2);
+      case "run":
+        return parseRunStatement(ctx, parseTemplate2);
+      case "set":
+        return parseSetStatement(ctx);
+      case "transition":
+        return parseTransitionStatement(ctx);
+      case "with":
+        return parseWithStatement(ctx);
+      case "available": {
+        if (ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === "when") {
+          return parseAvailableWhenStatement(ctx);
+        }
+        break;
+      }
+      case "else":
+      case "elif":
+      case "for":
+        return parseOrphanBlock(ctx, (c) => parseProcedure(c, parseTemplate2));
+    }
+  }
+  if (tok.kind === TokenKind.PIPE && parseTemplate2) {
+    return parseTemplate2(ctx);
+  }
+  if (tok.kind === TokenKind.COMMENT) {
+    const comment = ctx.consumeNamed("comment");
+    if (ctx.peekKind() === TokenKind.NEWLINE)
+      ctx.consume();
+    return comment;
+  }
+  const expr = parseExpression(ctx, 0);
+  if (expr) {
+    const wrapped = wrapExpression(ctx, expr);
+    if (ctx.peekKind() === TokenKind.NEWLINE)
+      ctx.consume();
+    return wrapped;
+  }
+  return null;
+}
+function parseColonAndProcedureBody(ctx, node, row, errorOnMissingBody, parseTemplate2) {
+  if (ctx.peekKind() === TokenKind.COLON) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else if (errorOnMissingBody) {
+    node.appendChild(makeEmptyError(ctx));
+  }
+  if (ctx.peekKind() === TokenKind.COMMENT) {
+    node.appendChild(ctx.consumeNamed("comment"));
+  }
+  const inlineErr = synchronizeRow(ctx, row);
+  if (inlineErr)
+    node.appendChild(inlineErr);
+  if (ctx.peekKind() === TokenKind.INDENT) {
+    ctx.consume();
+    const proc = parseProcedure(ctx, parseTemplate2);
+    if (proc)
+      node.appendChild(proc, "consequence");
+    consumeCommentsAndSkipNewlines(ctx, node);
+    if (ctx.peekKind() === TokenKind.DEDENT)
+      ctx.consume();
+  } else if (errorOnMissingBody && (ctx.peekKind() === TokenKind.NEWLINE || ctx.isAtSyncPoint())) {
+    node.appendChild(makeEmptyError(ctx));
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+}
+function parseIfStatement(ctx, parseTemplate2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("if_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  let condition = parseExpression(ctx, 0);
+  if (condition && ctx.peekKind() === TokenKind.EQ) {
+    const eqTok = ctx.consume();
+    const right = parseExpression(ctx, 5);
+    if (right) {
+      const cmp = ctx.startNodeAt("comparison_expression", condition);
+      cmp.appendChild(wrapExpression(ctx, condition));
+      const eqChild = new CSTNode("=", ctx.source, eqTok.startOffset, eqTok.startOffset + 1, eqTok.start, eqTok.end, false);
+      const eqErr = makeErrorNode(ctx.source, [eqChild], eqTok.startOffset, eqTok.startOffset + 1, eqTok.start, eqTok.end);
+      cmp.appendChild(eqErr);
+      cmp.appendChild(wrapExpression(ctx, right));
+      cmp.finalize();
+      condition = cmp;
+    }
+  }
+  if (condition)
+    node.appendChild(wrapExpression(ctx, condition), "condition");
+  if (condition && ctx.peekKind() !== TokenKind.COLON && !ctx.isAtSyncPoint() && ctx.peekKind() !== TokenKind.INDENT) {
+    const condRow = startTok.start.row;
+    const err = synchronizeRowUntilColon(ctx, condRow);
+    if (err)
+      node.appendChild(err);
+  }
+  parseColonAndProcedureBody(ctx, node, startTok.start.row, true, parseTemplate2);
+  while (ctx.peekKind() === TokenKind.ID && (ctx.peek().text === "elif" || ctx.peek().text === "elseif")) {
+    const elif = parseElifClause(ctx, parseTemplate2);
+    if (elif)
+      node.appendChild(elif, "alternative");
+  }
+  if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === "else") {
+    const elseClause = parseElseClause(ctx, parseTemplate2);
+    if (elseClause)
+      node.appendChild(elseClause, "alternative");
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseElifClause(ctx, parseTemplate2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("elif_clause");
+  const kw = ctx.consume();
+  if (kw.text === "elseif") {
+    const kwEnd = kw.startOffset + kw.text.length;
+    const leaf = tokenToAutoLeaf(kw, ctx.source, kw.startOffset);
+    const errNode = makeErrorNode(ctx.source, [leaf], kw.startOffset, kwEnd, kw.start, kw.end);
+    node.appendChild(errNode);
+  } else {
+    ctx.addAnonymousChild(node, kw);
+  }
+  const condition = parseExpression(ctx, 0);
+  if (condition)
+    node.appendChild(wrapExpression(ctx, condition), "condition");
+  if (condition && ctx.peekKind() !== TokenKind.COLON && !ctx.isAtSyncPoint() && ctx.peekKind() !== TokenKind.INDENT) {
+    const condRow = startTok.start.row;
+    const err = synchronizeRowUntilColon(ctx, condRow);
+    if (err)
+      node.appendChild(err);
+  }
+  parseColonAndProcedureBody(ctx, node, startTok.start.row, false, parseTemplate2);
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseElseClause(ctx, parseTemplate2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("else_clause");
+  ctx.addAnonymousChild(node, ctx.consume());
+  parseColonAndProcedureBody(ctx, node, startTok.start.row, false, parseTemplate2);
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseRunStatement(ctx, parseTemplate2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("run_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (!ctx.isAtSyncPoint()) {
+    const target = parseExpression(ctx, 0);
+    if (target) {
+      node.appendChild(wrapExpression(ctx, target), "target");
+    } else {
+      addMissingTarget(ctx, node);
+    }
+  } else {
+    addMissingTarget(ctx, node);
+  }
+  if (ctx.peekKind() === TokenKind.INDENT) {
+    ctx.consume();
+    consumeCommentsAndSkipNewlines(ctx, node);
+    const proc = parseProcedure(ctx, parseTemplate2);
+    if (proc) {
+      const hasWithError = proc.namedChildren.some((c) => c.isError && c.children.some((cc) => cc.type === "with"));
+      if (hasWithError) {
+        for (const child of proc.namedChildren) {
+          node.appendChild(child);
+        }
+      } else {
+        node.appendChild(proc, "block_value");
+      }
+    }
+    consumeCommentsAndSkipNewlines(ctx, node);
+    if (ctx.peekKind() === TokenKind.DEDENT)
+      ctx.consume();
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseSetStatement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("set_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const target = parseExpression(ctx, 5);
+  if (ctx.peekKind() === TokenKind.EQEQ) {
+    const eqTok = ctx.consume();
+    const rhs = parseExpression(ctx, 0);
+    if (target && rhs) {
+      const cmp = ctx.startNodeAt("comparison_expression", wrapExpression(ctx, target));
+      cmp.appendChild(wrapExpression(ctx, target));
+      cmp.appendChild(new CSTNode(eqTok.text, ctx.source, eqTok.startOffset, eqTok.startOffset + 2, eqTok.start, eqTok.end, false));
+      cmp.appendChild(wrapExpression(ctx, rhs));
+      cmp.finalize();
+      const wrappedCmp = wrapExpression(ctx, cmp);
+      if (ctx.peekKind() === TokenKind.NEWLINE)
+        ctx.consume();
+      return makeErrorNode(ctx.source, [wrappedCmp], wrappedCmp.startOffset, wrappedCmp.endOffset, wrappedCmp.startPosition, wrappedCmp.endPosition);
+    }
+  }
+  if (target)
+    node.appendChild(wrapExpression(ctx, target), "target");
+  if (ctx.peekKind() === TokenKind.EQ) {
+    ctx.addAnonymousChild(node, ctx.consume());
+    const value = parseExpression(ctx, 0);
+    if (value)
+      node.appendChild(wrapExpression(ctx, value), "value");
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseTransitionStatement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("transition_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const withToList = tryParseWithToStatementList(ctx);
+  if (withToList) {
+    node.appendChild(withToList, "with_to_statement_list");
+  } else if (!ctx.isAtSyncPoint() && ctx.peekKind() !== TokenKind.NEWLINE && ctx.peekKind() !== TokenKind.EOF) {
+    const listNode = ctx.startNode("with_to_statement_list");
+    const toNode = ctx.startNode("to_statement");
+    toNode.appendChild(makeMissing(ctx, "to"));
+    const target = parseExpression(ctx, 0);
+    if (target)
+      toNode.appendChild(wrapExpression(ctx, target), "target");
+    toNode.finalize();
+    listNode.appendChild(toNode);
+    listNode.finalize();
+    node.appendChild(listNode, "with_to_statement_list");
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseWithStatement(ctx) {
+  const startTok = ctx.peek();
+  if (ctx.peekAt(1).kind !== TokenKind.ID && ctx.peekAt(1).kind !== TokenKind.STRING) {
+    const withTok = ctx.consume();
+    const kwOffset = ctx.currentOffset();
+    const withChild = new CSTNode("with", ctx.source, kwOffset, kwOffset + 4, withTok.start, withTok.end, false);
+    return makeErrorNode(ctx.source, [withChild], kwOffset, kwOffset + 4, withTok.start, withTok.end);
+  }
+  const node = ctx.startNode("with_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  parseWithParams(ctx, node);
+  if (ctx.peekKind() === TokenKind.COMMENT) {
+    node.appendChild(ctx.consumeNamed("comment"));
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseWithParams(ctx, node) {
+  while (!ctx.isAtSyncPoint()) {
+    if (ctx.peekKind() === TokenKind.ID || ctx.peekKind() === TokenKind.STRING) {
+      if (ctx.peekKind() === TokenKind.STRING) {
+        node.appendChild(parseString(ctx), "param");
+      } else {
+        node.appendChild(ctx.consumeNamed("id"), "param");
+      }
+    } else {
+      const err = synchronize(ctx);
+      if (err)
+        node.appendChild(err);
+      return;
+    }
+    if (ctx.peekKind() === TokenKind.EQ) {
+      ctx.addAnonymousChild(node, ctx.consume());
+    } else {
+      node.appendChild(makeMissing(ctx, "="));
+    }
+    const value = parseExpression(ctx, 0);
+    if (value)
+      node.appendChild(wrapExpression(ctx, value), "value");
+    if (ctx.peekKind() === TokenKind.COMMA) {
+      ctx.addAnonymousChild(node, ctx.consume());
+    } else {
+      break;
+    }
+  }
+}
+function parseAvailableWhenStatement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("available_when_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  ctx.addAnonymousChild(node, ctx.consume());
+  const condition = parseExpression(ctx, 0);
+  if (condition)
+    node.appendChild(wrapExpression(ctx, condition), "condition");
+  if (ctx.peekKind() === TokenKind.NEWLINE)
+    ctx.consume();
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function tryParseWithToStatementList(ctx) {
+  const tok = ctx.peek();
+  if (!isTokenKind(tok, TokenKind.ID))
+    return null;
+  if (!["with", "to"].includes(tok.text))
+    return null;
+  const startTok = tok;
+  const node = ctx.startNode("with_to_statement_list");
+  while (!ctx.isAtSyncPoint()) {
+    if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === "with") {
+      node.appendChild(parseInlineWithStatement(ctx));
+    } else if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === "to") {
+      node.appendChild(parseToStatement(ctx));
+    } else {
+      break;
+    }
+    if (ctx.peekKind() === TokenKind.COMMA) {
+      ctx.addAnonymousChild(node, ctx.consume());
+    } else {
+      break;
+    }
+  }
+  if (node.children.length === 0)
+    return null;
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseInlineWithStatement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("with_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  parseWithParams(ctx, node);
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseToStatement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("to_statement");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const target = parseExpression(ctx, 0);
+  if (target) {
+    node.appendChild(wrapExpression(ctx, target), "target");
+  } else {
+    node.appendChild(makeEmptyError(ctx));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+
+// vendor/agentscript-parser-javascript/dist/parse-templates.js
+function parseTemplate(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("template");
+  const pipeOffset = ctx.peekOffset();
+  let lineStart = pipeOffset;
+  while (lineStart > 0 && ctx.source.charCodeAt(lineStart - 1) !== 10) {
+    lineStart--;
+  }
+  let templateOuterIndent = 0;
+  for (let i = lineStart; i < pipeOffset; i++) {
+    const ch = ctx.source.charCodeAt(i);
+    if (ch === 32)
+      templateOuterIndent += 1;
+    else if (ch === 9)
+      templateOuterIndent += 3;
+    else
+      break;
+  }
+  const pipeToken = ctx.consume();
+  ctx.addAnonymousChild(node, pipeToken);
+  const hasContentOnSameLine = !isAtEnd(ctx) && ctx.peekKind() !== TokenKind.NEWLINE && ctx.peekKind() !== TokenKind.INDENT && ctx.peekKind() !== TokenKind.DEDENT;
+  if (hasContentOnSameLine) {
+    const afterPipeOffset = pipeToken.startOffset + 1;
+    gatherTemplateContentLine(ctx, node, afterPipeOffset);
+  }
+  if (ctx.peekKind() === TokenKind.NEWLINE) {
+    ctx.consume();
+  }
+  if (ctx.peekKind() === TokenKind.INDENT) {
+    ctx.consume();
+    let indentDepth = 1;
+    while (!isAtEnd(ctx)) {
+      const tok = ctx.peek();
+      if (tok.kind === TokenKind.DEDENT) {
+        indentDepth--;
+        ctx.consume();
+        if (indentDepth <= 0) {
+          if (templateContinues(ctx, templateOuterIndent)) {
+            indentDepth = 0;
+            continue;
+          }
+          break;
+        }
+      } else if (tok.kind === TokenKind.INDENT) {
+        indentDepth++;
+        ctx.consume();
+      } else if (tok.kind === TokenKind.NEWLINE) {
+        ctx.consume();
+      } else {
+        if (indentDepth <= 0 && !templateContinues(ctx, templateOuterIndent)) {
+          break;
+        }
+        const lastChild = node.children.length > 0 ? node.children[node.children.length - 1] : null;
+        const gapOffset = lastChild && lastChild.endOffset < ctx.peekOffset() ? lastChild.endOffset : void 0;
+        const gapPos = gapOffset !== void 0 ? lastChild.endPosition : void 0;
+        gatherTemplateContentLine(ctx, node, gapOffset, gapPos);
+      }
+    }
+  }
+  mergeTemplateContent(ctx, node);
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseTemplateAsColinear(ctx) {
+  return parseTemplate(ctx);
+}
+function templateContinues(ctx, templateOuterIndent) {
+  let i = 0;
+  while (ctx.peekAt(i).kind === TokenKind.NEWLINE)
+    i++;
+  const tok = ctx.peekAt(i);
+  if (tok.kind === TokenKind.EOF || tok.kind === TokenKind.DEDENT)
+    return false;
+  if (tok.start.column > templateOuterIndent)
+    return true;
+  if (tok.kind === TokenKind.PIPE)
+    return false;
+  if (tok.kind === TokenKind.ID || tok.kind === TokenKind.STRING) {
+    const after = ctx.peekAt(i + 1);
+    if (after.kind === TokenKind.COLON)
+      return false;
+    if (after.kind === TokenKind.ID) {
+      const afterAfter = ctx.peekAt(i + 2);
+      if (afterAfter.kind === TokenKind.COLON)
+        return false;
+    }
+  }
+  if (tok.kind === TokenKind.ID) {
+    switch (tok.text) {
+      case "if":
+      case "elif":
+      case "else":
+      case "run":
+      case "set":
+      case "transition":
+        return false;
+      case "with":
+        if (ctx.peekAt(i + 1).kind !== TokenKind.COLON)
+          return false;
+        break;
+      case "available":
+        if (ctx.peekAt(i + 1).kind === TokenKind.ID && ctx.peekAt(i + 1).text === "when")
+          return false;
+        break;
+    }
+  }
+  if (tok.kind === TokenKind.DASH_SPACE)
+    return false;
+  if (tok.kind === TokenKind.COMMENT)
+    return false;
+  return true;
+}
+function mergeTemplateContent(ctx, template) {
+  const merged = [];
+  let i = 0;
+  while (i < template.children.length) {
+    const child = template.children[i];
+    if (child.type === "template_content") {
+      let end = i + 1;
+      while (end < template.children.length && template.children[end].type === "template_content") {
+        end++;
+      }
+      if (end > i + 1) {
+        const first = template.children[i];
+        const last = template.children[end - 1];
+        const mergedNode = new CSTNode("template_content", ctx.source, first.startOffset, last.endOffset, first.startPosition, last.endPosition);
+        mergedNode.parent = template;
+        merged.push(mergedNode);
+        i = end;
+      } else {
+        merged.push(child);
+        i++;
+      }
+    } else {
+      merged.push(child);
+      i++;
+    }
+  }
+  template.children = merged;
+}
+function gatherTemplateContentLine(ctx, parent, initialOffset, initialPos) {
+  let contentStartOffset = initialOffset ?? ctx.peekOffset();
+  let contentStartPos = initialPos ?? ctx.peek().start;
+  let lastConsumedEndOffset = contentStartOffset;
+  let lastConsumedEndPos = contentStartPos;
+  while (!isAtEnd(ctx)) {
+    const tok = ctx.peek();
+    if (tok.kind === TokenKind.NEWLINE || tok.kind === TokenKind.DEDENT || tok.kind === TokenKind.INDENT || tok.kind === TokenKind.EOF) {
+      break;
+    }
+    if (tok.kind === TokenKind.TEMPLATE_EXPR_START) {
+      const exprOffset = ctx.peekOffset();
+      if (exprOffset > contentStartOffset) {
+        parent.appendChild(new CSTNode("template_content", ctx.source, contentStartOffset, exprOffset, contentStartPos, tok.start));
+      }
+      const exprNode = parseTemplateExpression(ctx);
+      parent.appendChild(exprNode);
+      contentStartOffset = exprNode.endOffset;
+      contentStartPos = exprNode.endPosition;
+      lastConsumedEndOffset = exprNode.endOffset;
+      lastConsumedEndPos = exprNode.endPosition;
+      continue;
+    }
+    const tokOffset = ctx.peekOffset();
+    lastConsumedEndOffset = tokOffset + tok.text.length;
+    lastConsumedEndPos = tok.end;
+    ctx.consume();
+  }
+  if (lastConsumedEndOffset > contentStartOffset) {
+    parent.appendChild(new CSTNode("template_content", ctx.source, contentStartOffset, lastConsumedEndOffset, contentStartPos, lastConsumedEndPos));
+  }
+}
+function parseTemplateExpression(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("template_expression");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const expr = parseExpression(ctx, 0);
+  if (expr) {
+    node.appendChild(wrapExpression(ctx, expr), "expression");
+  } else {
+    node.appendChild(makeEmptyError(ctx));
+  }
+  if (ctx.peekKind() !== TokenKind.RBRACE && !ctx.isAtSyncPoint()) {
+    const err = synchronize(ctx);
+    if (err)
+      node.appendChild(err);
+  }
+  if (ctx.peekKind() === TokenKind.RBRACE) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  } else {
+    node.appendChild(makeMissing(ctx, "}"));
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+
+// vendor/agentscript-parser-javascript/dist/parse-mapping.js
+var MAX_KEY_LOOKAHEAD = 10;
+function parseMappingOrExpression(ctx, parseSequence2) {
+  if (isMappingStart(ctx)) {
+    return parseMapping(ctx, parseSequence2);
+  }
+  const expr = parseExpression(ctx, 0);
+  if (!expr)
+    return null;
+  if (isTokenKind(ctx.peek(), TokenKind.EQ)) {
+    const node = ctx.startNodeAt("assignment_expression", expr);
+    node.appendChild(wrapExpression(ctx, expr), "left");
+    ctx.addAnonymousChild(node, ctx.consumeKind(TokenKind.EQ));
+    const right = parseExpression(ctx, 0);
+    if (right)
+      node.appendChild(wrapExpression(ctx, right), "right");
+    return node;
+  }
+  return wrapExpression(ctx, expr);
+}
+function isMappingStart(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.COMMENT)
+    return true;
+  if (tok.kind === TokenKind.PIPE)
+    return true;
+  if (tok.kind === TokenKind.ID && isStatementStart(ctx))
+    return true;
+  if (!isKeyTokenStart(tok.kind))
+    return false;
+  const startRow = tok.start.row;
+  for (let i = 1; i < MAX_KEY_LOOKAHEAD; i++) {
+    const t = ctx.peekAt(i);
+    if (t.kind === TokenKind.COLON || t.kind === TokenKind.INDENT || t.kind === TokenKind.ARROW || t.kind === TokenKind.AT)
+      return true;
+    if (i === 1 && (t.kind === TokenKind.STRING || t.kind === TokenKind.NUMBER))
+      return true;
+    if (t.kind === TokenKind.EOF || t.start.row !== startRow)
+      return false;
+    if (!isKeyTokenContinuation(t.kind))
+      return false;
+  }
+  return false;
+}
+function parseMapping(ctx, parseSequence2) {
+  const node = ctx.startNode("mapping");
+  while (!isAtEnd(ctx)) {
+    skipNewlines(ctx);
+    const tok = ctx.peek();
+    if (tok.kind === TokenKind.DEDENT || tok.kind === TokenKind.EOF)
+      break;
+    if (tok.kind === TokenKind.COMMENT && isTrailingCommentOnly(ctx)) {
+      break;
+    }
+    const item = parseMappingItem(ctx, parseSequence2);
+    if (item) {
+      node.appendChild(item);
+    } else {
+      const err = synchronize(ctx);
+      if (err) {
+        node.appendChild(err);
+      } else if (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
+        ctx.consume();
+      }
+    }
+  }
+  return node;
+}
+function parseMappingItem(ctx, parseSequence2) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.ID) {
+    switch (tok.text) {
+      case "if":
+        return parseIfStatement(ctx, (c) => parseTemplate(c));
+      case "run":
+        return parseRunStatement(ctx, (c) => parseTemplate(c));
+      case "set":
+        return parseSetStatement(ctx);
+      case "transition":
+        return parseTransitionStatement(ctx);
+      case "with": {
+        if (ctx.peekAt(1).kind !== TokenKind.COLON) {
+          return parseWithStatement(ctx);
+        }
+        break;
+      }
+      case "available": {
+        if (ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === "when") {
+          return parseAvailableWhenStatement(ctx);
+        }
+        break;
+      }
+    }
+  }
+  if (tok.kind === TokenKind.PIPE) {
+    return parseTemplate(ctx);
+  }
+  if (tok.kind === TokenKind.COMMENT) {
+    return ctx.consumeNamed("comment");
+  }
+  if (tok.kind === TokenKind.ID && (tok.text === "else" || tok.text === "elif" || tok.text === "for")) {
+    return parseOrphanBlock(ctx, (c) => parseProcedure(c, (c2) => parseTemplate(c2)));
+  }
+  if (isKeyStart(ctx)) {
+    return parseMappingElement(ctx, parseSequence2);
+  }
+  return null;
+}
+function isColinearMappingElement(ctx) {
+  if (!isKeyStart(ctx))
+    return false;
+  const tok = ctx.peek();
+  const lookahead = 1;
+  if (ctx.peekAt(lookahead).kind === TokenKind.ID && ctx.peekAt(lookahead).start.row === tok.start.row) {
+    const afterSecond = ctx.peekAt(lookahead + 1);
+    if (afterSecond.kind === TokenKind.COLON && afterSecond.start.row === tok.start.row) {
+      return true;
+    }
+  }
+  const next = ctx.peekAt(lookahead);
+  return next.kind === TokenKind.COLON && next.start.row === tok.start.row;
+}
+function parseColinearMappingElement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("mapping_element");
+  const key = parseKey(ctx);
+  if (key)
+    node.appendChild(key, "key");
+  if (ctx.peekKind() === TokenKind.COLON) {
+    ctx.addAnonymousChild(node, ctx.consume());
+  }
+  const colinear = tryParseColinearValue(ctx);
+  if (colinear) {
+    if (colinear.errorPrefix)
+      node.appendChild(colinear.errorPrefix);
+    node.appendChild(colinear.value, "colinear_value");
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function tryParseColinearValue(ctx) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.PIPE) {
+    return { value: parseTemplateAsColinear(ctx) };
+  }
+  if (tok.kind === TokenKind.ID && (tok.text === "mutable" || tok.text === "linked")) {
+    return { value: parseVariableDeclaration(ctx) };
+  }
+  if (tok.kind === TokenKind.ID && isFuzzyModifier(tok.text)) {
+    return { value: parseFuzzyVariableDeclaration(ctx) };
+  }
+  const expr = parseExpression(ctx, 0);
+  if (!expr)
+    return null;
+  if ((expr.type === "number" || expr.type === "id" && /^[0-9]/.test(expr.text)) && ctx.peekKind() === TokenKind.ID && ctx.peek().start.row === expr.startRow) {
+    const errNode = makeErrorNode(ctx.source, [wrapExpression(ctx, expr)], expr.startOffset, expr.endOffset, expr.startPosition, expr.endPosition);
+    const realValue = tryParseColinearValue(ctx);
+    if (realValue) {
+      return { value: realValue.value, errorPrefix: errNode };
+    }
+  }
+  const withToList = tryParseWithToStatementList(ctx);
+  if (withToList) {
+    const ewt2 = ctx.startNodeAt("expression_with_to", expr);
+    ewt2.appendChild(wrapExpression(ctx, expr), "expression");
+    ewt2.appendChild(withToList, "with_to_statement_list");
+    ewt2.finalize();
+    return { value: ewt2 };
+  }
+  if (ctx.peekKind() === TokenKind.EQ) {
+    const assign = ctx.startNodeAt("assignment_expression", expr);
+    assign.appendChild(wrapExpression(ctx, expr), "left");
+    ctx.addAnonymousChild(assign, ctx.consume());
+    const right = parseExpression(ctx, 0);
+    if (right)
+      assign.appendChild(wrapExpression(ctx, right), "right");
+    assign.finalize();
+    return { value: assign };
+  }
+  const ewt = ctx.startNodeAt("expression_with_to", expr);
+  ewt.appendChild(wrapExpression(ctx, expr), "expression");
+  return { value: ewt };
+}
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }).fill(0));
+  for (let i = 0; i <= m; i++)
+    dp[i][0] = i;
+  for (let j = 0; j <= n; j++)
+    dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+function isFuzzyModifier(text) {
+  return levenshteinDistance(text, "mutable") <= 2 || levenshteinDistance(text, "linked") <= 2;
+}
+function parseFuzzyVariableDeclaration(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("variable_declaration");
+  const misspelled = ctx.consume();
+  const misspelledEnd = misspelled.startOffset + misspelled.text.length;
+  const leaf = tokenToAutoLeaf(misspelled, ctx.source, misspelled.startOffset);
+  const errNode = makeErrorNode(ctx.source, [leaf], misspelled.startOffset, misspelledEnd, misspelled.start, misspelled.end);
+  node.appendChild(errNode);
+  const typeExpr = parseExpression(ctx, 0);
+  if (typeExpr)
+    node.appendChild(wrapExpression(ctx, typeExpr), "type");
+  if (ctx.peekKind() === TokenKind.EQ) {
+    ctx.addAnonymousChild(node, ctx.consume());
+    const defaultExpr = parseExpression(ctx, 0);
+    if (defaultExpr)
+      node.appendChild(wrapExpression(ctx, defaultExpr), "default");
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseMappingElement(ctx, parseSequence2) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("mapping_element");
+  const key = parseKey(ctx);
+  invariant(key != null, "We must be at a key start");
+  node.appendChild(key, "key");
+  if (ctx.peekKind() === TokenKind.COLON) {
+    ctx.addAnonymousChild(node, ctx.consumeKind(TokenKind.COLON));
+  } else if (ctx.peekKind() === TokenKind.INDENT || ctx.peekKind() === TokenKind.ARROW || ctx.peekKind() === TokenKind.ID || ctx.peekKind() === TokenKind.AT || ctx.peekKind() === TokenKind.STRING || ctx.peekKind() === TokenKind.NUMBER) {
+    node.appendChild(makeMissing(ctx, ":"));
+  } else {
+    return node;
+  }
+  if (ctx.peekKind() === TokenKind.ARROW) {
+    parseArrowBody(ctx, node);
+  } else if (ctx.peekKind() === TokenKind.INDENT) {
+    parseIndentedBlockValue(ctx, node, parseSequence2);
+  } else {
+    parseColinearAndBlock(ctx, node, startTok.start.row, parseSequence2);
+  }
+  return node;
+}
+function parseColinearAndBlock(ctx, node, startRow, parseSequence2) {
+  const colinear = tryParseColinearValue(ctx);
+  if (colinear) {
+    if (colinear.errorPrefix)
+      node.appendChild(colinear.errorPrefix);
+    node.appendChild(colinear.value, "colinear_value");
+  }
+  if (ctx.peekKind() === TokenKind.COMMENT) {
+    node.appendChild(ctx.consumeNamed("comment"));
+  }
+  if (colinear) {
+    const err = synchronizeRow(ctx, startRow);
+    if (err)
+      node.appendChild(err);
+  } else if (!ctx.isAtSyncPoint() && ctx.peekKind() !== TokenKind.INDENT) {
+    const err = synchronize(ctx);
+    if (err)
+      node.appendChild(err);
+  }
+  if (colinear?.value.type === "expression_with_to" && !colinear.value.childForFieldName("with_to_statement_list") && ctx.peekKind() === TokenKind.INDENT && ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === "to") {
+    ctx.consumeKind(TokenKind.INDENT);
+    const withToList = tryParseWithToStatementList(ctx);
+    if (withToList) {
+      colinear.value.appendChild(withToList, "with_to_statement_list");
+      node.endOffset = colinear.value.endOffset;
+      node.endPosition = colinear.value.endPosition;
+    }
+    ctx.consumeKind(TokenKind.DEDENT);
+  } else if (ctx.peekKind() === TokenKind.INDENT) {
+    parseIndentedBlockValue(ctx, node, parseSequence2);
+  }
+}
+function parseArrowBody(ctx, node) {
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (ctx.peekKind() === TokenKind.COMMENT) {
+    node.appendChild(ctx.consumeNamed("comment"));
+  }
+  if (ctx.peekKind() === TokenKind.INDENT) {
+    ctx.consume();
+    consumeCommentsAndSkipNewlines(ctx, node);
+    const proc = parseProcedure(ctx, (c) => parseTemplate(c));
+    if (proc)
+      node.appendChild(proc, "block_value");
+    consumeCommentsAndSkipNewlines(ctx, node);
+    if (ctx.peekKind() === TokenKind.DEDENT)
+      ctx.consume();
+  } else {
+    const emptyProc = ctx.startNode("procedure");
+    emptyProc.appendChild(makeEmptyError(ctx));
+    ctx.finishNode(emptyProc, ctx.peek());
+    node.appendChild(emptyProc, "block_value");
+  }
+}
+function parseVariableDeclaration(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("variable_declaration");
+  ctx.addAnonymousChild(node, ctx.consume());
+  if (ctx.peekKind() === TokenKind.ID && (ctx.peek().text === "mutable" || ctx.peek().text === "linked")) {
+    const errExpr = parseExpression(ctx, 0);
+    if (errExpr) {
+      const wrapped = wrapExpression(ctx, errExpr);
+      const errNode = makeErrorNode(ctx.source, [wrapped], wrapped.startOffset, wrapped.endOffset, wrapped.startPosition, wrapped.endPosition);
+      node.appendChild(errNode);
+    }
+  }
+  const typeExpr = parseExpression(ctx, 0);
+  if (typeExpr)
+    node.appendChild(wrapExpression(ctx, typeExpr), "type");
+  if (ctx.peekKind() === TokenKind.EQ) {
+    ctx.addAnonymousChild(node, ctx.consume());
+    const defaultExpr = parseExpression(ctx, 0);
+    if (defaultExpr)
+      node.appendChild(wrapExpression(ctx, defaultExpr), "default");
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseIndentedBlockValue(ctx, parent, parseSequence2) {
+  ctx.consume();
+  consumeCommentsAndSkipNewlines(ctx, parent);
+  const blockValue = parseBlockValue(ctx, parseSequence2);
+  if (blockValue)
+    parent.appendChild(blockValue, "block_value");
+  consumeCommentsAndSkipNewlines(ctx, parent);
+  recoverToBlockEnd(ctx, parent);
+  if (ctx.peekKind() === TokenKind.DEDENT)
+    ctx.consume();
+}
+function parseBlockValue(ctx, parseSequence2) {
+  const tok = ctx.peek();
+  if (tok.kind === TokenKind.DASH_SPACE) {
+    return parseSequence2(ctx);
+  }
+  if (tok.kind === TokenKind.ID && tok.text === "empty") {
+    const emptyNode = ctx.startNode("empty_keyword");
+    ctx.addAnonymousChild(emptyNode, ctx.consume());
+    ctx.finishNode(emptyNode, tok);
+    return emptyNode;
+  }
+  if (isMappingStart(ctx)) {
+    return parseMapping(ctx, parseSequence2);
+  }
+  return parseAtomBlockValue(ctx);
+}
+function parseAtomBlockValue(ctx) {
+  const expr = parseExpression(ctx, 0);
+  if (!expr)
+    return null;
+  if (ATOM_TYPES.has(expr.type)) {
+    const atom = new CSTNode("atom", ctx.source, expr.startOffset, expr.endOffset, expr.startPosition, expr.endPosition);
+    atom.appendChild(expr);
+    return atom;
+  }
+  return expr;
+}
+
+// vendor/agentscript-parser-javascript/dist/parse-sequence.js
+function parseSequence(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("sequence");
+  while (ctx.peekKind() === TokenKind.DASH_SPACE) {
+    const elem = parseSequenceElement(ctx);
+    if (elem)
+      node.appendChild(elem);
+    skipNewlines(ctx);
+  }
+  while (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT && ctx.peekKind() !== TokenKind.DASH_SPACE) {
+    skipNewlines(ctx);
+    if (isAtEnd(ctx) || ctx.peekKind() === TokenKind.DEDENT)
+      break;
+    const parseSeq = (_ctx) => parseSequence(_ctx);
+    const item = parseMappingItem(ctx, parseSeq);
+    if (item) {
+      const errNode = makeErrorNode(ctx.source, [item], item.startOffset, item.endOffset, item.startPosition, item.endPosition);
+      node.appendChild(errNode);
+    } else {
+      const err = synchronize(ctx);
+      if (err) {
+        node.appendChild(err);
+      } else {
+        ctx.consume();
+      }
+    }
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+function parseSequenceElement(ctx) {
+  const startTok = ctx.peek();
+  const node = ctx.startNode("sequence_element");
+  ctx.addAnonymousChild(node, ctx.consume());
+  const parseSeq = (_ctx) => parseSequence(_ctx);
+  if (isColinearMappingElement(ctx)) {
+    const mappingElem = parseColinearMappingElement(ctx);
+    if (mappingElem)
+      node.appendChild(mappingElem, "colinear_mapping_element");
+    if (ctx.peekKind() === TokenKind.NEWLINE)
+      ctx.consume();
+    if (ctx.peekKind() === TokenKind.INDENT) {
+      ctx.consume();
+      const blockValue = parseMapping(ctx, parseSeq);
+      if (blockValue)
+        node.appendChild(blockValue, "block_value");
+      if (ctx.peekKind() === TokenKind.DEDENT)
+        ctx.consume();
+    }
+  } else if (ctx.peekKind() === TokenKind.NEWLINE || ctx.peekKind() === TokenKind.EOF || ctx.peekKind() === TokenKind.INDENT) {
+    if (ctx.peekKind() === TokenKind.NEWLINE)
+      ctx.consume();
+    if (ctx.peekKind() === TokenKind.INDENT) {
+      ctx.consume();
+      const blockValue = parseMapping(ctx, parseSeq);
+      if (blockValue)
+        node.appendChild(blockValue, "block_value");
+      if (ctx.peekKind() === TokenKind.DEDENT)
+        ctx.consume();
+    }
+  } else {
+    const colinear = tryParseColinearValue(ctx);
+    if (colinear) {
+      if (colinear.errorPrefix)
+        node.appendChild(colinear.errorPrefix);
+      node.appendChild(colinear.value, "colinear_value");
+    }
+    if (ctx.peekKind() === TokenKind.COMMENT) {
+      node.appendChild(ctx.consumeNamed("comment"));
+    }
+    if (ctx.peekKind() === TokenKind.NEWLINE)
+      ctx.consume();
+  }
+  ctx.finishNode(node, startTok);
+  return node;
+}
+
+// vendor/agentscript-parser-javascript/dist/parser.js
+var Parser = class {
+  source;
+  tokens;
+  pos = 0;
+  _eof;
+  constructor(source) {
+    this.source = source;
+    const lexer = new Lexer(source);
+    this.tokens = lexer.tokenize();
+  }
+  parse() {
+    const root = this.parseSourceFile();
+    return root;
+  }
+  // --- ParserContext implementation ---
+  peek() {
+    return this.peekAt(0);
+  }
+  peekAt(offset) {
+    return this.peekAtIndex(this.pos + offset);
+  }
+  peekAtIndex(idx) {
+    return this.tokens[idx] ?? this.eofToken();
+  }
+  peekKind() {
+    return this.peek().kind;
+  }
+  consume() {
+    const tok = this.peek();
+    this.pos++;
+    return tok;
+  }
+  consumeKind(kind) {
+    const tok = this.peek();
+    invariant(isTokenKind(tok, kind), `Expected token kind ${kind} but got ${tok.kind}`);
+    this.pos++;
+    return tok;
+  }
+  consumeNamed(type) {
+    const tok = this.consume();
+    const offset = tok.startOffset;
+    return new CSTNode(type, this.source, offset, offset + tok.text.length, tok.start, tok.end);
+  }
+  currentOffset() {
+    const idx = this.pos > 0 ? this.pos - 1 : 0;
+    return this.peekAtIndex(idx).startOffset;
+  }
+  peekOffset() {
+    return this.peek().startOffset;
+  }
+  isAtSyncPoint() {
+    return isSyncPoint(this.peekKind());
+  }
+  startNode(type) {
+    const tok = this.peek();
+    const offset = tok.startOffset;
+    return new CSTNode(type, this.source, offset, offset, tok.start, tok.end);
+  }
+  startNodeAt(type, existingChild) {
+    return new CSTNode(type, this.source, existingChild.startOffset, existingChild.endOffset, existingChild.startPosition, existingChild.endPosition);
+  }
+  finishNode(_node, _startTok) {
+  }
+  addAnonymousChild(parent, token) {
+    const offset = token.startOffset;
+    const child = new CSTNode(token.text, this.source, offset, offset + token.text.length, token.start, token.end, false);
+    parent.appendChild(child);
+  }
+  // --- Top-level parsing ---
+  parseSourceFile() {
+    const node = this.startNode("source_file");
+    skipNewlines(this);
+    if (this.peekKind() === TokenKind.INDENT) {
+      this.consume();
+    }
+    consumeCommentsAndSkipNewlines(this, node);
+    if (this.peekKind() === TokenKind.DASH_SPACE) {
+      node.appendChild(parseSequence(this));
+    } else {
+      const content = parseMappingOrExpression(this, (_ctx) => parseSequence(_ctx));
+      if (content)
+        node.appendChild(content);
+    }
+    consumeCommentsAndSkipNewlines(this, node);
+    while (!isAtEnd(this)) {
+      if (this.peekKind() === TokenKind.NEWLINE || this.peekKind() === TokenKind.DEDENT) {
+        this.consume();
+        continue;
+      }
+      if (this.peekKind() === TokenKind.COMMENT) {
+        node.appendChild(this.consumeNamed("comment"));
+        continue;
+      }
+      const err = synchronize(this);
+      if (err) {
+        node.appendChild(err);
+      } else {
+        this.consume();
+      }
+    }
+    node.startOffset = 0;
+    node.startPosition = { row: 0, column: 0 };
+    node.endOffset = this.source.length;
+    node.endPosition = this.eofToken().end;
+    return node;
+  }
+  eofToken() {
+    if (!this._eof) {
+      const lastToken = this.tokens[this.tokens.length - 1];
+      const pos = lastToken ? lastToken.end : { row: 0, column: 0 };
+      this._eof = {
+        kind: TokenKind.EOF,
+        text: "",
+        start: pos,
+        end: pos,
+        startOffset: this.source.length
+      };
+    }
+    return this._eof;
+  }
+};
+
+// vendor/agentscript-parser-javascript/dist/index.js
+function parse(source) {
+  const parser = new Parser(source);
+  return { rootNode: parser.parse() };
+}
+
+// src/analyzer/parse.ts
+function parseAgentSource(source) {
+  return parse(source).rootNode;
+}
+function locOf(n) {
+  return {
+    endCol: n.endCol,
+    endRow: n.endRow,
+    startCol: n.startCol,
+    startRow: n.startRow
+  };
+}
+function* descendants(node) {
+  yield node;
+  for (const c of node.namedChildren) yield* descendants(c);
+}
+function keyHeader(n) {
+  if (n.type !== "key") return null;
+  const head = n.text.split("\n", 1)[0];
+  const colon = head.indexOf(":");
+  const lhs = (colon === -1 ? head : head.slice(0, colon)).trim();
+  const parts = lhs.split(/\s+/);
+  return { kind: parts[0], label: parts.length > 1 ? parts.slice(1).join(" ") : void 0 };
+}
+function mappingKeyHeader(m) {
+  if (m.type !== "mapping_element") return null;
+  const keyNode = m.childForFieldName("key");
+  if (!keyNode) {
+    for (const c of m.namedChildren) {
+      if (c.type === "key") return keyHeader(c);
+    }
+    return null;
+  }
+  return keyHeader(keyNode);
+}
+var NON_VALUE_NAMED_TYPES = /* @__PURE__ */ new Set(["comment", "key"]);
+function mappingValue(m) {
+  if (m.type !== "mapping_element") return void 0;
+  for (const c of m.namedChildren) {
+    if (!NON_VALUE_NAMED_TYPES.has(c.type)) return c;
+  }
+  return void 0;
+}
+function findMappingEntry(parentBody, kind) {
+  for (const c of parentBody.namedChildren) {
+    if (c.type !== "mapping_element") continue;
+    const h = mappingKeyHeader(c);
+    if (h && h.kind === kind) return mappingValue(c);
+  }
+  return void 0;
+}
+function bodyOf(scopeKey) {
+  const { parent } = scopeKey;
+  if (!parent) return void 0;
+  return mappingValue(parent);
+}
+function extractDeveloperName(root) {
+  const topMapping = root.namedChildren.find((c) => c.type === "mapping") ?? root;
+  for (const c of topMapping.namedChildren) {
+    if (c.type !== "mapping_element") continue;
+    const keyNode = c.childForFieldName("key") ?? c.namedChildren.find((n) => n.type === "key");
+    if (!keyNode) continue;
+    const h = keyHeader(keyNode);
+    if (!h || h.kind !== "config") continue;
+    const body = mappingValue(c);
+    if (!body) return void 0;
+    const devNameVal = findMappingEntry(body, "developer_name");
+    if (!devNameVal) return void 0;
+    return extractStringLiteral(devNameVal);
+  }
+  return void 0;
+}
+function extractStringLiteral(n) {
+  for (const d of descendants(n)) {
+    if (d.type === "string") {
+      const t = d.text;
+      if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
+      if (t.startsWith("'") && t.endsWith("'")) return t.slice(1, -1);
+      return t;
+    }
+  }
+  return void 0;
+}
+
+// src/analyzer/action-references.ts
+var TARGET_SCHEME = /^([a-z][a-z0-9+.-]*):\/\//i;
+function classifyTarget(uri) {
+  if (!uri) return "unknown";
+  const m = TARGET_SCHEME.exec(uri);
+  if (!m) return "unknown";
+  const scheme = m[1].toLowerCase();
+  if (scheme === "apex") return "apex";
+  if (scheme === "flow") return "flow";
+  if (scheme.startsWith("prompt")) return "prompt";
+  return "unknown";
+}
+function collectDeclarations(scope) {
+  const decls = [];
+  const actionsBlock = findMappingEntry(scope.body, "actions");
+  if (!actionsBlock) return decls;
+  for (const child of actionsBlock.namedChildren) {
+    if (child.type !== "mapping_element") continue;
+    const h = mappingKeyHeader(child);
+    if (!h) continue;
+    const declName = h.kind;
+    const declBody = mappingValue(child);
+    if (!declBody) {
+      decls.push({
+        location: locOf(child),
+        name: declName,
+        scope: scope.label,
+        target: void 0,
+        targetKind: "unknown"
+      });
+      continue;
+    }
+    const targetVal = findMappingEntry(declBody, "target");
+    const targetStr = targetVal ? extractStringLiteral(targetVal) : void 0;
+    decls.push({
+      location: locOf(child),
+      name: declName,
+      scope: scope.label,
+      target: targetStr,
+      targetKind: classifyTarget(targetStr)
+    });
+  }
+  return decls;
+}
+function collectReferences(scope) {
+  const refs = [];
+  const explore = (body, context) => {
+    if (!body) return;
+    for (const n of descendants(body)) {
+      if (n.type !== "member_expression") continue;
+      if (!n.text.startsWith("@actions.")) continue;
+      const name = actionNameFromMember(n);
+      if (!name) continue;
+      const ctx = isInsideTransition(n) ? "transition" : context;
+      refs.push({
+        context: ctx,
+        location: locOf(n),
+        name,
+        scope: scope.label
+      });
+    }
+  };
+  explore(findMappingEntry(scope.body, "before_reasoning"), "before_reasoning_run");
+  explore(findMappingEntry(scope.body, "after_reasoning"), "after_reasoning_run");
+  const reasoning = findMappingEntry(scope.body, "reasoning");
+  if (reasoning) {
+    explore(findMappingEntry(reasoning, "actions"), "reasoning_actions");
+    explore(findMappingEntry(reasoning, "instructions"), "reasoning_instructions_run");
+  }
+  return refs;
+}
+function actionNameFromMember(n) {
+  const t = n.text;
+  const dot = t.indexOf(".");
+  if (dot === -1) return void 0;
+  const rest = t.slice(dot + 1);
+  const m = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
+  return m?.[1];
+}
+function isInsideTransition(n) {
+  let p = n.parent;
+  while (p) {
+    if (p.type === "transition_statement") return true;
+    p = p.parent;
+  }
+  return false;
+}
+
+// src/analyzer/apex-analyze.ts
+import { readFile } from "node:fs/promises";
+import { basename, relative } from "node:path";
+
+// src/analyzer/apex-complexity.ts
+import {
+  CatchClauseContext,
+  CondExpressionContext,
+  ConstructorDeclarationContext,
+  DoWhileStatementContext,
+  ForStatementContext,
+  IfStatementContext,
+  LogAndExpressionContext,
+  LogOrExpressionContext,
+  MethodDeclarationContext,
+  WhenControlContext,
+  WhileStatementContext
+} from "@apexdevtools/apex-parser";
+
+// src/analyzer/apex-parse.ts
+import {
+  ApexParserFactory
+} from "@apexdevtools/apex-parser";
+function parseApexSource(source) {
+  const parser = ApexParserFactory.createParser(source);
+  return parser.compilationUnit();
+}
+function locOfCtx(ctx) {
+  const { start } = ctx;
+  const stop = ctx.stop ?? ctx.start;
+  return {
+    endCol: (stop?.column ?? 0) + (stop?.text?.length ?? 0),
+    endRow: stop?.line ?? 0,
+    startCol: start?.column ?? 0,
+    startRow: start?.line ?? 0
+  };
+}
+function walkParseTree(node, visit) {
+  visit(node);
+  const childCount = typeof node.getChildCount === "function" ? node.getChildCount() : 0;
+  for (let i = 0; i < childCount; i++) {
+    const c = node.getChild(i);
+    if (c && typeof c.getChildCount === "function") {
+      walkParseTree(c, visit);
+    }
+  }
+}
+
+// src/analyzer/apex-complexity.ts
+function complexityOfMethod(methodCtx) {
+  const body = methodCtx.block();
+  const contributors = [];
+  if (body) {
+    walkParseTree(body, (node) => {
+      if (node !== methodCtx && (node instanceof MethodDeclarationContext || node instanceof ConstructorDeclarationContext)) {
+        return;
+      }
+      const kind = classifyContributor(node);
+      if (kind !== void 0 && enclosingMethod(node) === methodCtx) {
+        contributors.push({ kind, location: locOfCtx(node) });
+      }
+    });
+  }
+  const name = methodCtx instanceof ConstructorDeclarationContext ? methodCtx.qualifiedName()?.getText() ?? "<ctor>" : methodCtx.id()?.getText() ?? "<anon>";
+  const signature = renderSignature(methodCtx, name);
+  return {
+    complexity: 1 + contributors.length,
+    contributors,
+    kind: methodCtx instanceof ConstructorDeclarationContext ? "constructor" : "method",
+    location: locOfCtx(methodCtx),
+    name,
+    signature
+  };
+}
+function classifyContributor(node) {
+  if (node instanceof IfStatementContext) return "if_statement";
+  if (node instanceof ForStatementContext) return "for_statement";
+  if (node instanceof WhileStatementContext) return "while_statement";
+  if (node instanceof DoWhileStatementContext) return "do_while_statement";
+  if (node instanceof WhenControlContext) {
+    const wv = node.whenValue();
+    const elseTok = wv && typeof wv.ELSE === "function" ? wv.ELSE() : void 0;
+    return elseTok ? void 0 : "when_arm";
+  }
+  if (node instanceof CatchClauseContext) return "catch_clause";
+  if (node instanceof CondExpressionContext) return "ternary";
+  if (node instanceof LogAndExpressionContext) return "short_circuit_and";
+  if (node instanceof LogOrExpressionContext) return "short_circuit_or";
+  return void 0;
+}
+function enclosingMethod(node) {
+  let p = node.parentCtx;
+  while (p) {
+    if (p instanceof MethodDeclarationContext || p instanceof ConstructorDeclarationContext) {
+      return p;
+    }
+    p = p.parentCtx;
+  }
+  return void 0;
+}
+function renderSignature(ctx, name) {
+  const paramsText = renderFormalParameters(ctx.formalParameters());
+  if (ctx instanceof MethodDeclarationContext) {
+    const retType = ctx.typeRef()?.getText() ?? (ctx.VOID() ? "void" : "");
+    return `${retType ? retType + " " : ""}${name}${paramsText}`;
+  }
+  return `${name}${paramsText}`;
+}
+function renderFormalParameters(params) {
+  if (!params) return "()";
+  const list = params.formalParameterList();
+  if (!list) return "()";
+  const parts = list.formalParameter_list().map((p) => {
+    const type = p.typeRef()?.getText() ?? "";
+    const id = p.id()?.getText() ?? "";
+    return type && id ? `${type} ${id}` : type || id;
+  });
+  return `(${parts.join(", ")})`;
+}
+function methodsInCompilationUnit(cu) {
+  const out = [];
+  walkParseTree(cu, (node) => {
+    if ((node instanceof MethodDeclarationContext || node instanceof ConstructorDeclarationContext) && node.block()) {
+      out.push(node);
+    }
+  });
+  return out;
+}
+
+// src/analyzer/apex-resolve.ts
+import { stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+var APEX_SCHEME = /^apex:\/\/(.+)$/;
+function extractApexClassName(uri) {
+  const m = APEX_SCHEME.exec(uri);
+  if (!m) return void 0;
+  const raw = m[1].trim();
+  const dot = raw.lastIndexOf(".");
+  return dot === -1 ? raw : raw.slice(dot + 1);
+}
+async function resolveApexClassPath(className, opts) {
+  const candidates = [];
+  if (opts.apexSourceOverride) {
+    const override = isAbsolute(opts.apexSourceOverride) ? opts.apexSourceOverride : resolve(opts.apexSourceOverride);
+    candidates.push(
+      join(override, `${className}.cls`),
+      join(override, "classes", `${className}.cls`)
+    );
+  }
+  const stop = resolve(opts.sourceDirRoot);
+  let dir = dirname(resolve(opts.agentFilePath));
+  while (true) {
+    candidates.push(join(dir, "classes", `${className}.cls`));
+    if (dir === stop) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const c of candidates) {
+    const s = await stat(c).catch(() => {
+    });
+    if (s?.isFile()) return c;
+  }
+  return void 0;
+}
+
+// src/analyzer/apex-analyze.ts
+async function analyzeReferencedApex(inputs) {
+  const byPath = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Set();
+  for (let i = 0; i < inputs.fileReports.length; i++) {
+    const fr = inputs.fileReports[i];
+    const agentAbs = inputs.agentAbsPaths[i];
+    for (const decl of fr.declarations) {
+      if (decl.targetKind !== "apex" || !decl.target) continue;
+      const className = extractApexClassName(decl.target);
+      if (!className) {
+        unresolved.add(decl.target);
+        continue;
+      }
+      const path = await resolveApexClassPath(className, {
+        agentFilePath: agentAbs,
+        apexSourceOverride: inputs.apexSourceOverride,
+        sourceDirRoot: inputs.sourceDirRoot
+      });
+      if (!path) {
+        unresolved.add(decl.target);
+        continue;
+      }
+      const existing = byPath.get(path);
+      if (existing) {
+        if (!existing.referencedBy.includes(fr.path)) {
+          existing.referencedBy.push(fr.path);
+        }
+        continue;
+      }
+      const report = await analyzeApexClass(path, className, [fr.path], inputs.sourceDirRoot);
+      byPath.set(path, report);
+    }
+  }
+  return {
+    classes: [...byPath.values()].sort((a, b) => a.className.localeCompare(b.className)),
+    unresolved: [...unresolved].sort()
+  };
+}
+async function analyzeApexClass(absPath, className, referencedBy, sourceDirRoot) {
+  const source = await readFile(absPath, "utf8");
+  const cu = parseApexSource(source);
+  const methodCtxs = methodsInCompilationUnit(cu);
+  const methods = methodCtxs.map((m) => complexityOfMethod(m));
+  const classComplexity = methods.reduce((acc, m) => acc + m.complexity, 0);
+  return {
+    classComplexity,
+    className: className || basename(absPath, ".cls"),
+    methods,
+    parseErrors: [],
+    path: relative(sourceDirRoot, absPath),
+    referencedBy
+  };
+}
+
+// src/analyzer/complexity.ts
+var SHORT_CIRCUIT_OPS = /* @__PURE__ */ new Set(["and", "or"]);
+function complexityOf(body, scope, kind) {
+  const contributors = [];
+  for (const n of descendants(body)) {
+    switch (n.type) {
+      case "binary_expression": {
+        const op = binaryOperator(n);
+        if (op === "and") contributors.push({ kind: "short_circuit_and", location: locOf(n) });
+        else if (op === "or") contributors.push({ kind: "short_circuit_or", location: locOf(n) });
+        break;
+      }
+      case "elif_clause": {
+        contributors.push({ kind: "elif_clause", location: locOf(n) });
+        break;
+      }
+      case "if_statement": {
+        contributors.push({ kind: "if_statement", location: locOf(n) });
+        break;
+      }
+      case "ternary_expression": {
+        contributors.push({ kind: "ternary_expression", location: locOf(n) });
+        break;
+      }
+    }
+  }
+  return {
+    complexity: 1 + contributors.length,
+    contributors,
+    kind,
+    location: locOf(body),
+    scope
+  };
+}
+function binaryOperator(n) {
+  for (const c of n.children) {
+    if (!c.isNamed && SHORT_CIRCUIT_OPS.has(c.type)) return c.type;
+    if (!c.isNamed && (c.type === "+" || c.type === "-" || c.type === "*" || c.type === "/")) return c.type;
+  }
+  return void 0;
+}
+function collectProcedures(scopeBody, scopeLabel) {
+  const out = [];
+  const before = findMappingEntry(scopeBody, "before_reasoning");
+  if (before) out.push(complexityOf(before, scopeLabel, "before_reasoning"));
+  const after = findMappingEntry(scopeBody, "after_reasoning");
+  if (after) out.push(complexityOf(after, scopeLabel, "after_reasoning"));
+  const reasoning = findMappingEntry(scopeBody, "reasoning");
+  if (reasoning) {
+    const instructions = findMappingEntry(reasoning, "instructions");
+    if (instructions) {
+      out.push(complexityOf(instructions, scopeLabel, "reasoning_instructions"));
+    }
+  }
+  return out;
+}
+var PROCEDURE_SCOPES = /* @__PURE__ */ new Set(["start_agent", "subagent", "topic"]);
+function collectScopes(root) {
+  const scopes = [];
+  const topMapping = root.namedChildren.find((c) => c.type === "mapping") ?? root;
+  for (const c of topMapping.namedChildren) {
+    if (c.type !== "mapping_element") continue;
+    const keyNode = c.childForFieldName("key") ?? c.namedChildren.find((n) => n.type === "key");
+    if (!keyNode) continue;
+    const h = keyHeader(keyNode);
+    if (!h || !PROCEDURE_SCOPES.has(h.kind)) continue;
+    const body = bodyOf(keyNode);
+    if (!body) continue;
+    scopes.push({ body, kind: h.kind, label: `${h.kind} ${h.label ?? ""}`.trim() });
+  }
+  return scopes;
+}
+function complexityForFile(root) {
+  const procedures = [];
+  for (const s of collectScopes(root)) {
+    procedures.push(...collectProcedures(s.body, s.label));
+  }
+  const total = procedures.reduce((acc, p) => acc + p.complexity, 0);
+  return { procedures, total };
+}
+
+// src/analyzer/analyze.ts
+var NoMatchingBundlesError = class extends Error {
+  constructor(requested, available) {
+    super(
+      `No agent bundle matched ${requested.map((n) => `'${n}'`).join(", ")}. Available: ${available.map((b) => formatBundleIdentity(b)).join(", ")}`
+    );
+    this.requested = requested;
+    this.available = available;
+    this.name = "NoMatchingBundlesError";
+  }
+};
+function formatBundleIdentity(b) {
+  if (b.developerName && b.developerName !== b.dirName) {
+    return `${b.developerName} (dir: ${b.dirName})`;
+  }
+  return b.dirName;
+}
+async function analyzeSource(rootPathOrPaths, options = {}) {
+  const rawRoots = Array.isArray(rootPathOrPaths) ? rootPathOrPaths : [rootPathOrPaths];
+  if (rawRoots.length === 0) {
+    throw new Error("analyzeSource requires at least one source path");
+  }
+  const absRoots = rawRoots.map((p) => resolve2(p));
+  const reportBase = options.reportBase ? resolve2(options.reportBase) : absRoots.length === 1 ? absRoots[0] : longestCommonAncestor(absRoots);
+  const allFiles = [];
+  for (const root of absRoots) {
+    const files = await findAgentFiles(root);
+    for (const f of files) if (!allFiles.includes(f)) allFiles.push(f);
+  }
+  allFiles.sort();
+  const filteredFiles = await filterByApiNames(allFiles, options.apiNames);
+  const fileReports = [];
+  for (const file of filteredFiles) {
+    fileReports.push(await analyzeFile(file, reportBase));
+  }
+  const apex = await analyzeReferencedApex({
+    agentAbsPaths: filteredFiles,
+    apexSourceOverride: options.apexSourceOverride,
+    fileReports,
+    sourceDirRoot: reportBase
+  });
+  const report = {
+    apexClasses: apex.classes,
+    byTargetKind: tallyTargets(fileReports),
+    files: fileReports,
+    totalApexComplexity: apex.classes.reduce((acc, c) => acc + c.classComplexity, 0),
+    totalComplexity: fileReports.reduce((acc, f) => acc + f.fileComplexity, 0),
+    totalDeclarations: fileReports.reduce((acc, f) => acc + f.declarations.length, 0),
+    totalReferences: fileReports.reduce((acc, f) => acc + f.references.length, 0),
+    unresolvedApexTargets: apex.unresolved
+  };
+  return report;
+}
+async function analyzeFile(absPath, base) {
+  const source = await readFile2(absPath, "utf8");
+  const root = parseAgentSource(source);
+  const cc = complexityForFile(root);
+  const { procedures } = cc;
+  const scopes = collectScopes(root);
+  const declarations = [];
+  const references = [];
+  for (const s of scopes) {
+    declarations.push(...collectDeclarations(s));
+    references.push(...collectReferences(s));
+  }
+  return {
+    declarations,
+    fileComplexity: cc.total,
+    parseErrors: [],
+    // CST is error-tolerant; surface diagnostics in a later iteration.
+    path: relative2(base, absPath),
+    procedures,
+    references
+  };
+}
+async function findAgentFiles(root) {
+  const s = await stat2(root).catch(() => {
+  });
+  if (!s) throw new Error(`source path does not exist: ${root}`);
+  if (s.isFile()) return root.endsWith(".agent") ? [root] : [];
+  const out = [];
+  const visit = async (dir) => {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name.startsWith(".")) continue;
+      if (e.name === "node_modules" || e.name === "vendor" || e.name === "lib") continue;
+      const full = join2(dir, e.name);
+      if (e.isDirectory()) await visit(full);
+      else if (e.isFile() && e.name.endsWith(".agent")) out.push(full);
+    }
+  };
+  await visit(root);
+  out.sort();
+  return out;
+}
+function tallyTargets(files) {
+  const acc = {
+    apex: 0,
+    flow: 0,
+    prompt: 0,
+    unknown: 0,
+    utils: 0
+  };
+  for (const f of files) for (const d of f.declarations) acc[d.targetKind]++;
+  return acc;
+}
+async function filterByApiNames(files, apiNames) {
+  if (!apiNames || apiNames.length === 0) return files;
+  const wanted = new Set(apiNames);
+  const matches = [];
+  const unmatched = [];
+  for (const file of files) {
+    const dirName = basename2(dirname2(file));
+    if (wanted.has(dirName)) {
+      matches.push(file);
+    } else {
+      unmatched.push(file);
+    }
+  }
+  if (matches.length === files.length || unmatched.length === 0) {
+    return matches;
+  }
+  const identities = [];
+  for (const file of unmatched) {
+    const dirName = basename2(dirname2(file));
+    const developerName = await readDeveloperName(file);
+    identities.push({ developerName, dirName, path: file });
+    if (developerName && wanted.has(developerName)) {
+      matches.push(file);
+    }
+  }
+  if (matches.length === 0) {
+    const all = [];
+    for (const file of files) {
+      const existing = identities.find((i) => i.path === file);
+      if (existing) {
+        all.push(existing);
+      } else {
+        all.push({
+          developerName: await readDeveloperName(file),
+          dirName: basename2(dirname2(file)),
+          path: file
+        });
+      }
+    }
+    all.sort((a, b) => a.dirName.localeCompare(b.dirName));
+    throw new NoMatchingBundlesError(apiNames, all);
+  }
+  matches.sort();
+  return matches;
+}
+async function readDeveloperName(file) {
+  const source = await readFile2(file, "utf8");
+  const root = parseAgentSource(source);
+  return extractDeveloperName(root);
+}
+function longestCommonAncestor(paths) {
+  if (paths.length === 0) return process.cwd();
+  if (paths.length === 1) return paths[0];
+  const split = paths.map((p) => p.split("/"));
+  const minLen = Math.min(...split.map((s) => s.length));
+  const common = [];
+  for (let i = 0; i < minLen; i++) {
+    const seg = split[0][i];
+    if (split.every((s) => s[i] === seg)) common.push(seg);
+    else break;
+  }
+  const joined = common.join("/") || "/";
+  return joined;
+}
+
+// src/analyzer/project.ts
+import { readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve as resolve3 } from "node:path";
+async function discoverSfdxProject(startDir) {
+  let dir = resolve3(startDir);
+  while (true) {
+    const candidate = join3(dir, "sfdx-project.json");
+    const s = await stat3(candidate).catch(() => {
+    });
+    if (s?.isFile()) {
+      return readProject(dir, candidate);
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+async function readProject(root, jsonPath) {
+  const raw = await readFile3(jsonPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `failed to parse ${jsonPath}: ${error.message}`
+    );
+  }
+  const pkgs = extractPackageDirectories(parsed, root);
+  return { packageDirectories: pkgs, root };
+}
+function extractPackageDirectories(parsed, root) {
+  if (!parsed || typeof parsed !== "object") return [];
+  const obj = parsed;
+  if (!Array.isArray(obj.packageDirectories)) return [];
+  const out = [];
+  for (const entry of obj.packageDirectories) {
+    if (!entry || typeof entry !== "object") continue;
+    const pathField = entry.path;
+    if (typeof pathField !== "string" || pathField.length === 0) continue;
+    out.push(isAbsolute2(pathField) ? pathField : resolve3(root, pathField));
+  }
+  return out;
+}
+
+// src/renderers/csv.ts
+function renderCsv(report) {
+  const lines = [];
+  lines.push(
+    [
+      "type",
+      "file",
+      "scope_or_class",
+      "name",
+      "complexity",
+      "start_row",
+      "start_col",
+      "contributors"
+    ].map((c) => csvCell(c)).join(",")
+  );
+  for (const f of report.files) {
+    for (const p of f.procedures) {
+      lines.push(
+        [
+          "agent_procedure",
+          f.path,
+          p.scope,
+          p.kind,
+          String(p.complexity),
+          String(p.location.startRow),
+          String(p.location.startCol),
+          breakdownProc(p.contributors)
+        ].map((c) => csvCell(c)).join(",")
+      );
+    }
+  }
+  for (const cls of report.apexClasses) {
+    for (const m of cls.methods) {
+      lines.push(
+        [
+          "apex_method",
+          cls.path,
+          cls.className,
+          m.signature,
+          String(m.complexity),
+          String(m.location.startRow),
+          String(m.location.startCol),
+          breakdownApex(m.contributors)
+        ].map((c) => csvCell(c)).join(",")
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function csvCell(v) {
+  return `"${v.replaceAll('"', '""')}"`;
+}
+function breakdownProc(contributors) {
+  if (contributors.length === 0) return "base";
+  const counts = {};
+  for (const c of contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${k}=${n}`).join(";");
+}
+function breakdownApex(contributors) {
+  if (contributors.length === 0) return "base";
+  const counts = {};
+  for (const c of contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${k}=${n}`).join(";");
+}
+
+// src/renderers/markdown.ts
+var KIND_LABEL = {
+  after_reasoning: "after_reasoning",
+  available_when: "available_when",
+  before_reasoning: "before_reasoning",
+  other: "other",
+  reasoning_instructions: "reasoning.instructions"
+};
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push(
+    "# AgentForce PMD \u2014 Cyclomatic Complexity (McCabe)",
+    "",
+    "Per the categorization rule \xA7 7, CC is reported by the standard McCabe convention used in SonarQube / PMD / Checkstyle for the relevant language.",
+    ""
+  );
+  if (report.files.length === 0) {
+    lines.push("_(no `.agent` files found)_");
+    return lines.join("\n");
+  }
+  lines.push(
+    "## CC by location",
+    "",
+    renderMermaid(report),
+    "",
+    `| | AgentScript | Apex | Combined |
+| --- | ---: | ---: | ---: |
+| **Totals** | ${report.totalComplexity} | ${report.totalApexComplexity} | ${report.totalComplexity + report.totalApexComplexity} |`,
+    "",
+    "## Per-bundle (`.agent` files)",
+    ""
+  );
+  for (const f of report.files) {
+    lines.push(`### \`${f.path}\` \u2014 CC = ${f.fileComplexity}`, "");
+    if (f.procedures.length === 0) {
+      lines.push("_(no procedure-bearing scopes)_");
+    } else {
+      lines.push("| Scope | Procedure | CC | Contributors |", "| --- | --- | ---: | --- |");
+      for (const p of f.procedures) {
+        lines.push(
+          `| ${escapeCell(p.scope)} | ${KIND_LABEL[p.kind]} | ${p.complexity} | ${escapeCell(breakdownProc2(p.contributors))} |`
+        );
+      }
+    }
+    lines.push("");
+    if (f.declarations.length > 0) {
+      lines.push("**Action references**", "", "| Action | Target kind | Target | Uses |", "| --- | --- | --- | ---: |");
+      const usage = countReferences(f);
+      for (const d of f.declarations) {
+        const used = usage.get(d.name) ?? 0;
+        lines.push(
+          `| \`${d.name}\` | ${d.targetKind} | ${d.target ?? "_n/a_"} | ${used} |`
+        );
+      }
+      const undeclared = listUndeclaredRefs(f);
+      if (undeclared.length > 0) {
+        lines.push(
+          "",
+          "Referenced but not declared in-file: " + undeclared.map((u) => `\`${u}\``).join(", ")
+        );
+      }
+      lines.push("");
+    }
+  }
+  if (report.apexClasses.length > 0 || report.unresolvedApexTargets.length > 0) {
+    lines.push("## Apex backing logic", "");
+    for (const cls of report.apexClasses) {
+      lines.push(
+        `### \`${cls.path}\` \u2014 class CC = ${cls.classComplexity}`,
+        "",
+        `Referenced by: ${cls.referencedBy.map((r) => `\`${r}\``).join(", ") || "_none_"}`,
+        ""
+      );
+      if (cls.methods.length === 0) {
+        lines.push("_(no methods with bodies)_");
+      } else {
+        lines.push("| Method | CC | Contributors |", "| --- | ---: | --- |");
+        for (const m of cls.methods) {
+          lines.push(
+            `| \`${escapeCell(m.signature)}\` | ${m.complexity} | ${escapeCell(breakdownApex2(m.contributors))} |`
+          );
+        }
+      }
+      lines.push("");
+    }
+    if (report.unresolvedApexTargets.length > 0) {
+      lines.push("### Unresolved `apex://` targets", "");
+      for (const u of report.unresolvedApexTargets) {
+        lines.push(`- \`${u}\` \u2014 no matching \`.cls\` under \`--source-dir\` or \`--apex-source\``);
+      }
+      lines.push("");
+    }
+  }
+  lines.push(
+    "---",
+    "",
+    `Action declarations: **${report.totalDeclarations}** (apex ${report.byTargetKind.apex}, flow ${report.byTargetKind.flow}, prompt ${report.byTargetKind.prompt}, unknown ${report.byTargetKind.unknown}). Action references: **${report.totalReferences}**.`
+  );
+  return lines.join("\n");
+}
+function renderMermaid(report) {
+  const apexByBundle = /* @__PURE__ */ new Map();
+  for (const cls of report.apexClasses) {
+    for (const ref of cls.referencedBy) {
+      apexByBundle.set(ref, (apexByBundle.get(ref) ?? 0) + cls.classComplexity);
+    }
+  }
+  const labels = [];
+  const agentVals = [];
+  const apexVals = [];
+  for (const f of report.files) {
+    labels.push(shortBundleLabel(f.path));
+    agentVals.push(f.fileComplexity);
+    apexVals.push(apexByBundle.get(f.path) ?? 0);
+  }
+  return [
+    "```mermaid",
+    '%%{init: {"theme":"base","themeVariables":{"xyChart":{"plotColorPalette":"#a82820, #6b8c52"}}}}%%',
+    "xychart-beta",
+    '    title "CC by location, per .agent bundle"',
+    `    x-axis [${labels.map((l) => `"${l}"`).join(", ")}]`,
+    `    y-axis "Cyclomatic complexity"`,
+    `    bar [${agentVals.join(", ")}]`,
+    `    bar [${apexVals.join(", ")}]`,
+    "```",
+    "",
+    '<sub>Series: **AgentScript CC** (red, whitepaper "Reasoning Logic") \xB7 **Apex CC** (green, whitepaper "Deterministic Logic"). Apex CC per bundle is the sum of the CC of every `apex://` class that bundle references; classes referenced by multiple bundles contribute to each.</sub>'
+  ].join("\n");
+}
+function shortBundleLabel(path) {
+  const stripped = path.replace(/^.*aiAuthoringBundles\//, "").replace(/\.agent$/, "");
+  const parts = stripped.split("/");
+  if (parts.length === 2 && parts[0] === parts[1]) return parts[0];
+  return parts.join("/");
+}
+function breakdownProc2(contributors) {
+  if (contributors.length === 0) return "(base only)";
+  const counts = {};
+  for (const c of contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${shortKind(k)}=${n}`).join(" ");
+}
+function breakdownApex2(contributors) {
+  if (contributors.length === 0) return "(base only)";
+  const counts = {};
+  for (const c of contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${shortApexKind(k)}=${n}`).join(" ");
+}
+function shortKind(k) {
+  switch (k) {
+    case "elif_clause": {
+      return "elif";
+    }
+    case "if_statement": {
+      return "if";
+    }
+    case "short_circuit_and": {
+      return "and";
+    }
+    case "short_circuit_or": {
+      return "or";
+    }
+    case "ternary_expression": {
+      return "ternary";
+    }
+    default: {
+      return k;
+    }
+  }
+}
+function shortApexKind(k) {
+  switch (k) {
+    case "catch_clause": {
+      return "catch";
+    }
+    case "do_while_statement": {
+      return "do-while";
+    }
+    case "for_statement": {
+      return "for";
+    }
+    case "if_statement": {
+      return "if";
+    }
+    case "short_circuit_and": {
+      return "&&";
+    }
+    case "short_circuit_or": {
+      return "||";
+    }
+    case "ternary": {
+      return "ternary";
+    }
+    case "when_arm": {
+      return "when";
+    }
+    case "while_statement": {
+      return "while";
+    }
+    default: {
+      return k;
+    }
+  }
+}
+function countReferences(f) {
+  const m = /* @__PURE__ */ new Map();
+  for (const r of f.references) m.set(r.name, (m.get(r.name) ?? 0) + 1);
+  return m;
+}
+function listUndeclaredRefs(f) {
+  const declared = new Set(f.declarations.map((d) => d.name));
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of f.references) {
+    if (declared.has(r.name)) continue;
+    if (seen.has(r.name)) continue;
+    seen.add(r.name);
+    out.push(r.name);
+  }
+  return out;
+}
+function escapeCell(s) {
+  return s.replaceAll("|", String.raw`\|`).replaceAll("\n", "<br>");
+}
+
+// src/renderers/sarif.ts
+var DEFAULT_WARNING = 10;
+var DEFAULT_ERROR = 20;
+var RULE_AGENT_CC = {
+  defaultConfiguration: { level: "note" },
+  fullDescription: {
+    text: "Reports cyclomatic complexity (McCabe) of an AgentScript before_reasoning, after_reasoning, or reasoning.instructions block. Computed as 1 + count(if) + count(elif) + count(ternary) + count(and) + count(or)."
+  },
+  helpUri: "https://github.com/bobbywhitesfdc/sf-agentpmd/blob/main/docs/agent-loc-categorization-skill-v2.md#-7--cyclomatic-complexity",
+  id: "AGENTPMD.AgentScriptCyclomaticComplexity",
+  name: "AgentScriptCyclomaticComplexity",
+  shortDescription: {
+    text: "McCabe cyclomatic complexity of an AgentScript procedure."
+  }
+};
+var RULE_APEX_CC = {
+  defaultConfiguration: { level: "note" },
+  fullDescription: {
+    text: "Reports cyclomatic complexity (McCabe) of an Apex method or constructor body, mirroring SonarQube / PMD CyclomaticComplexity."
+  },
+  helpUri: "https://github.com/bobbywhitesfdc/sf-agentpmd/blob/main/docs/agent-loc-categorization-skill-v2.md#-7--cyclomatic-complexity",
+  id: "AGENTPMD.ApexCyclomaticComplexity",
+  name: "ApexCyclomaticComplexity",
+  shortDescription: {
+    text: "McCabe cyclomatic complexity of an Apex method or constructor."
+  }
+};
+function renderSarif(report, opts) {
+  const warn = opts?.sarifWarningThreshold ?? DEFAULT_WARNING;
+  const err = opts?.sarifErrorThreshold ?? DEFAULT_ERROR;
+  const results = [];
+  for (const f of report.files) {
+    for (const p of f.procedures) {
+      results.push(buildAgentResult(f, p, warn, err));
+    }
+  }
+  for (const cls of report.apexClasses) {
+    for (const m of cls.methods) {
+      results.push(buildApexResult(cls, m, warn, err));
+    }
+  }
+  const log = {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    runs: [
+      {
+        results,
+        tool: {
+          driver: {
+            informationUri: "https://github.com/bobbywhitesfdc/sf-agentpmd",
+            name: "sf-agentpmd",
+            rules: [RULE_AGENT_CC, RULE_APEX_CC],
+            semanticVersion: pluginVersion()
+          }
+        }
+      }
+    ],
+    version: "2.1.0"
+  };
+  return JSON.stringify(log, null, 2);
+}
+function buildAgentResult(f, p, warn, err) {
+  return {
+    level: levelFor(p.complexity, warn, err),
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: f.path },
+          // AgentScript CST locations are 0-based — bump to SARIF 1-based.
+          region: regionFromZeroBased(p.location)
+        }
+      }
+    ],
+    message: {
+      text: `Procedure '${p.kind}' in '${p.scope}' has cyclomatic complexity ${p.complexity}.`
+    },
+    properties: { complexity: p.complexity, kind: p.kind },
+    ruleId: RULE_AGENT_CC.id
+  };
+}
+function buildApexResult(cls, m, warn, err) {
+  return {
+    level: levelFor(m.complexity, warn, err),
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: cls.path },
+          // ANTLR token positions are 1-based for line, 0-based for column;
+          // SARIF wants 1-based for both.
+          region: regionFromAntlr(m.location)
+        }
+      }
+    ],
+    message: {
+      text: `${m.kind} '${m.name}' has cyclomatic complexity ${m.complexity}.`
+    },
+    properties: { complexity: m.complexity, kind: m.kind },
+    ruleId: RULE_APEX_CC.id
+  };
+}
+function levelFor(cc, warn, err) {
+  if (cc >= err) return "error";
+  if (cc >= warn) return "warning";
+  return "note";
+}
+function regionFromZeroBased(loc) {
+  return {
+    endColumn: loc.endCol + 1,
+    endLine: loc.endRow + 1,
+    startColumn: loc.startCol + 1,
+    startLine: loc.startRow + 1
+  };
+}
+function regionFromAntlr(loc) {
+  return {
+    endColumn: loc.endCol + 1,
+    endLine: Math.max(1, loc.endRow),
+    startColumn: loc.startCol + 1,
+    startLine: Math.max(1, loc.startRow)
+  };
+}
+function pluginVersion() {
+  return "0.1.1";
+}
+
+// src/renderers/text.ts
+import pc from "picocolors";
+var KIND_LABEL2 = {
+  after_reasoning: "after_reasoning",
+  available_when: "available_when",
+  before_reasoning: "before_reasoning",
+  other: "other",
+  reasoning_instructions: "reasoning.instructions"
+};
+var UNICODE_GLYPHS = {
+  agentFile: "\u{1F4C4}",
+  apexFile: "\u{1F4DC}",
+  ruleHeavy: "\u2550",
+  ruleLight: "\u2500"
+};
+var ASCII_GLYPHS = {
+  agentFile: "[agent]",
+  apexFile: "[apex] ",
+  ruleHeavy: "=",
+  ruleLight: "-"
+};
+function resolveOptions(opts) {
+  const stdoutIsTty = Boolean(process.stdout.isTTY);
+  const noColorEnv = Boolean(process.env.NO_COLOR);
+  return {
+    ascii: opts?.ascii ?? !stdoutIsTty,
+    color: opts?.color ?? (stdoutIsTty && !noColorEnv),
+    width: opts?.width ?? 60
+  };
+}
+function renderText(report, opts) {
+  const r = resolveOptions(opts);
+  const g = r.ascii ? ASCII_GLYPHS : UNICODE_GLYPHS;
+  const c = colorize(r.color);
+  const lines = [];
+  lines.push(
+    c.title("AgentForce PMD \u2014 Cyclomatic Complexity (McCabe)"),
+    g.ruleHeavy.repeat(r.width)
+  );
+  if (report.files.length === 0) {
+    lines.push("  (no .agent files found)");
+    return lines.join("\n");
+  }
+  for (const f of report.files) {
+    lines.push(
+      "",
+      `${g.agentFile} ${c.path(f.path)}   CC=${c.cc(f.fileComplexity)}`,
+      g.ruleLight.repeat(r.width)
+    );
+    if (f.procedures.length === 0) {
+      lines.push("  (no procedure-bearing scopes)");
+    } else {
+      const scopes = groupByScope(f.procedures);
+      for (const [scope, procs] of scopes) {
+        const scopeTotal = procs.reduce((a, p) => a + p.complexity, 0);
+        lines.push(`  ${c.scope(scope)}   subtotal CC=${c.cc(scopeTotal)}`);
+        for (const p of procs) {
+          lines.push(
+            `    ${pad(KIND_LABEL2[p.kind], 24)} CC=${c.cc(p.complexity)}   ` + c.breakdown(breakdownProc3(p))
+          );
+        }
+      }
+    }
+    if (f.declarations.length > 0 || f.references.length > 0) {
+      lines.push(
+        "",
+        "  Action references",
+        "  " + g.ruleLight.repeat(Math.max(0, r.width - 2))
+      );
+      const usage = countReferences2(f);
+      for (const d of f.declarations) {
+        const used = usage.get(d.name) ?? 0;
+        const tgt = d.target ?? "(no target)";
+        lines.push(
+          `    ${pad(d.name, 32)} [${pad(d.targetKind, 6)}] used ${used}x \u2192 ${tgt}`
+        );
+      }
+      const undeclared = listUndeclaredRefs2(f);
+      if (undeclared.length > 0) {
+        lines.push("", "    Referenced but not declared in-file:");
+        for (const u of undeclared) {
+          lines.push(`      ${u}`);
+        }
+      }
+    }
+  }
+  if (report.apexClasses.length > 0 || report.unresolvedApexTargets.length > 0) {
+    lines.push(
+      "",
+      c.title("Apex backing logic (resolved via apex:// targets)"),
+      g.ruleHeavy.repeat(r.width)
+    );
+    for (const cls of report.apexClasses) {
+      lines.push(
+        "",
+        `${g.apexFile} ${c.path(cls.path)}   class CC=${c.cc(cls.classComplexity)}`,
+        `   referenced by: ${cls.referencedBy.join(", ") || "(none)"}`,
+        g.ruleLight.repeat(r.width)
+      );
+      if (cls.methods.length === 0) {
+        lines.push("   (no methods with bodies)");
+      } else {
+        for (const m of cls.methods) {
+          lines.push(
+            `   ${pad(m.signature, 44)} CC=${c.cc(m.complexity)}   ${c.breakdown(breakdownApex3(m.contributors))}`
+          );
+        }
+      }
+    }
+    if (report.unresolvedApexTargets.length > 0) {
+      lines.push("", "Unresolved apex:// targets:");
+      for (const u of report.unresolvedApexTargets) {
+        lines.push(
+          `  - ${u}  (no matching .cls under source-dir or --apex-source)`
+        );
+      }
+    }
+  }
+  lines.push(
+    "",
+    g.ruleHeavy.repeat(r.width),
+    c.title("CC by location (whitepaper \xA7 7)"),
+    `  AgentScript: ${c.cc(report.totalComplexity)}   Apex: ${c.cc(report.totalApexComplexity)}   Combined: ${c.cc(report.totalComplexity + report.totalApexComplexity)}`,
+    `Action declarations: ${report.totalDeclarations}  (apex ${report.byTargetKind.apex}, flow ${report.byTargetKind.flow}, prompt ${report.byTargetKind.prompt}, unknown ${report.byTargetKind.unknown})`,
+    `Action references:   ${report.totalReferences}`
+  );
+  return lines.join("\n");
+}
+function colorize(on) {
+  if (!on) {
+    return {
+      breakdown: (s) => s,
+      cc: String,
+      path: (s) => s,
+      scope: (s) => s,
+      title: (s) => s
+    };
+  }
+  return {
+    breakdown: pc.gray,
+    cc(n) {
+      const s = String(n);
+      if (n >= 20) return pc.red(s);
+      if (n >= 10) return pc.yellow(s);
+      if (n >= 5) return pc.green(s);
+      return pc.gray(s);
+    },
+    path: pc.cyan,
+    scope: pc.bold,
+    title: pc.bold
+  };
+}
+function breakdownProc3(p) {
+  if (p.contributors.length === 0) return "(base only)";
+  const counts = {};
+  for (const c of p.contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${shortKind2(k)}=${n}`).join(" ");
+}
+function breakdownApex3(contributors) {
+  if (contributors.length === 0) return "(base only)";
+  const counts = {};
+  for (const c of contributors) counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  return Object.entries(counts).map(([k, n]) => `${shortApexKind2(k)}=${n}`).join(" ");
+}
+function shortKind2(k) {
+  switch (k) {
+    case "elif_clause": {
+      return "elif";
+    }
+    case "if_statement": {
+      return "if";
+    }
+    case "short_circuit_and": {
+      return "and";
+    }
+    case "short_circuit_or": {
+      return "or";
+    }
+    case "ternary_expression": {
+      return "ternary";
+    }
+    default: {
+      return k;
+    }
+  }
+}
+function shortApexKind2(k) {
+  switch (k) {
+    case "catch_clause": {
+      return "catch";
+    }
+    case "do_while_statement": {
+      return "do-while";
+    }
+    case "for_statement": {
+      return "for";
+    }
+    case "if_statement": {
+      return "if";
+    }
+    case "short_circuit_and": {
+      return "&&";
+    }
+    case "short_circuit_or": {
+      return "||";
+    }
+    case "ternary": {
+      return "ternary";
+    }
+    case "when_arm": {
+      return "when";
+    }
+    case "while_statement": {
+      return "while";
+    }
+    default: {
+      return k;
+    }
+  }
+}
+function groupByScope(procs) {
+  const m = /* @__PURE__ */ new Map();
+  for (const p of procs) {
+    let arr = m.get(p.scope);
+    if (!arr) {
+      arr = [];
+      m.set(p.scope, arr);
+    }
+    arr.push(p);
+  }
+  return m;
+}
+function pad(s, n) {
+  if (s.length >= n) return s;
+  return s + " ".repeat(n - s.length);
+}
+function countReferences2(f) {
+  const m = /* @__PURE__ */ new Map();
+  for (const r of f.references) m.set(r.name, (m.get(r.name) ?? 0) + 1);
+  return m;
+}
+function listUndeclaredRefs2(f) {
+  const declared = new Set(f.declarations.map((d) => d.name));
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of f.references) {
+    if (declared.has(r.name)) continue;
+    if (seen.has(r.name)) continue;
+    seen.add(r.name);
+    out.push(r.name);
+  }
+  return out;
+}
+
+// src/renderers/index.ts
+function render(format, report, options) {
+  switch (format) {
+    case "csv": {
+      return renderCsv(report);
+    }
+    case "markdown": {
+      return renderMarkdown(report);
+    }
+    case "sarif": {
+      return renderSarif(report, options);
+    }
+    case "text": {
+      return renderText(report, options);
+    }
+  }
+}
+
+// src/commands/agentpmd/analyze.ts
+var FORMATS = ["text", "markdown", "sarif", "csv"];
+var AgentpmdAnalyze = class _AgentpmdAnalyze extends SfCommand {
+  static description = `Walks .agent source files under --source-dir and emits per-procedure
 cyclomatic complexity totals (before_reasoning, after_reasoning, and
 reasoning.instructions blocks), plus an inventory of declared and used
 @actions.X targets. For every apex:// target, resolves the .cls file
@@ -14,109 +4042,113 @@ Default output is human-readable text. --json emits the SF CLI envelope
 with the full structured report. --format <markdown|sarif|csv> emits the
 named format on stdout for piping into PR comments, GitHub Code Scanning,
 or spreadsheet pivots.`;
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --source-dir force-app/main/default',
-        '<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --json',
-        '<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --format markdown > report.md',
-        '<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --format sarif > report.sarif',
-    ];
-    static flags = {
-        'apex-source': Flags.string({
-            summary: 'Override directory to look up apex:// targets. By default we walk up from each .agent file looking for a sibling classes/ folder.',
-        }),
-        'api-name': Flags.string({
-            char: 'n',
-            multiple: true,
-            summary: 'Filter to specific agent bundles. Matched against the bundle directory name and the config.developer_name field. Repeatable.',
-        }),
-        ascii: Flags.boolean({
-            default: false,
-            summary: 'Force ASCII-only output in the text renderer (no Unicode box chars, no emoji).',
-        }),
-        'fail-on': Flags.integer({
-            min: 1,
-            summary: 'Exit non-zero if combined agent+Apex CC meets or exceeds this threshold.',
-        }),
-        format: Flags.string({
-            default: 'text',
-            options: [...FORMATS],
-            summary: 'Non-JSON output format. --json takes precedence per SF CLI convention.',
-        }),
-        'no-color': Flags.boolean({
-            default: false,
-            summary: 'Disable ANSI color in the text renderer. NO_COLOR env also disables.',
-        }),
-        'sarif-error': Flags.integer({
-            min: 1,
-            summary: 'SARIF "error" level threshold. Default 20.',
-        }),
-        'sarif-warning': Flags.integer({
-            min: 1,
-            summary: 'SARIF "warning" level threshold. Default 10.',
-        }),
-        'source-dir': Flags.string({
-            char: 'd',
-            summary: 'Directory or single .agent file to analyze. Defaults to the packageDirectories of the nearest sfdx-project.json.',
-        }),
-        width: Flags.integer({
-            default: 60,
-            min: 20,
-            summary: 'Rule width for the text renderer.',
-        }),
-    };
-    static summary = 'Compute McCabe cyclomatic complexity and action-reference inventory for AgentScript bundles and their Apex backing logic.';
-    async run() {
-        const { flags } = await this.parse(AgentpmdAnalyze);
-        const { reportBase, roots, sourceDescription } = await resolveSources(flags['source-dir']);
-        if (!this.jsonEnabled() && sourceDescription) {
-            this.log(sourceDescription);
-        }
-        const report = await analyzeSource(roots, {
-            apexSourceOverride: flags['apex-source'],
-            apiNames: flags['api-name'],
-            reportBase,
-        });
-        if (!this.jsonEnabled()) {
-            const format = flags.format;
-            const text = render(format, report, {
-                ascii: flags.ascii || undefined,
-                color: flags['no-color'] ? false : undefined,
-                sarifErrorThreshold: flags['sarif-error'],
-                sarifWarningThreshold: flags['sarif-warning'],
-                width: flags.width,
-            });
-            this.log(text);
-        }
-        const combined = report.totalComplexity + report.totalApexComplexity;
-        if (flags['fail-on'] !== undefined && combined >= flags['fail-on']) {
-            this.error(`Combined cyclomatic complexity ${combined} (agent ${report.totalComplexity} + apex ${report.totalApexComplexity}) ≥ threshold ${flags['fail-on']}`, { exit: 2 });
-        }
-        return report;
-    }
-}
-/**
- * Resolve the directories we should scan. Explicit `--source-dir` wins.
- * Otherwise, walk up from cwd looking for `sfdx-project.json` and use its
- * `packageDirectories`. If neither is available, fail with a clear message.
- */
-async function resolveSources(sourceDirFlag) {
-    if (sourceDirFlag) {
-        return { reportBase: undefined, roots: [sourceDirFlag] };
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --source-dir force-app/main/default",
+    "<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --json",
+    "<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --format markdown > report.md",
+    "<%= config.bin %> <%= command.id %> --source-dir force-app/main/default --format sarif > report.sarif"
+  ];
+  static flags = {
+    "apex-source": Flags.string({
+      summary: "Override directory to look up apex:// targets. By default we walk up from each .agent file looking for a sibling classes/ folder."
+    }),
+    "api-name": Flags.string({
+      char: "n",
+      multiple: true,
+      summary: "Filter to specific agent bundles. Matched against the bundle directory name and the config.developer_name field. Repeatable."
+    }),
+    ascii: Flags.boolean({
+      default: false,
+      summary: "Force ASCII-only output in the text renderer (no Unicode box chars, no emoji)."
+    }),
+    "fail-on": Flags.integer({
+      min: 1,
+      summary: "Exit non-zero if combined agent+Apex CC meets or exceeds this threshold."
+    }),
+    format: Flags.string({
+      default: "text",
+      options: [...FORMATS],
+      summary: "Non-JSON output format. --json takes precedence per SF CLI convention."
+    }),
+    "no-color": Flags.boolean({
+      default: false,
+      summary: "Disable ANSI color in the text renderer. NO_COLOR env also disables."
+    }),
+    "sarif-error": Flags.integer({
+      min: 1,
+      summary: 'SARIF "error" level threshold. Default 20.'
+    }),
+    "sarif-warning": Flags.integer({
+      min: 1,
+      summary: 'SARIF "warning" level threshold. Default 10.'
+    }),
+    "source-dir": Flags.string({
+      char: "d",
+      summary: "Directory or single .agent file to analyze. Defaults to the packageDirectories of the nearest sfdx-project.json."
+    }),
+    width: Flags.integer({
+      default: 60,
+      min: 20,
+      summary: "Rule width for the text renderer."
+    })
+  };
+  static summary = "Compute McCabe cyclomatic complexity and action-reference inventory for AgentScript bundles and their Apex backing logic.";
+  async run() {
+    const { flags } = await this.parse(_AgentpmdAnalyze);
+    const { reportBase, roots, sourceDescription } = await resolveSources(
+      flags["source-dir"]
+    );
+    if (!this.jsonEnabled() && sourceDescription) {
+      this.log(sourceDescription);
     }
-    const project = await discoverSfdxProject(process.cwd());
-    if (!project) {
-        throw new Error('No --source-dir was provided and no sfdx-project.json was found in the ' +
-            'current directory or any ancestor. Pass --source-dir <path> or run from ' +
-            'inside an sfdx project.');
+    const report = await analyzeSource(roots, {
+      apexSourceOverride: flags["apex-source"],
+      apiNames: flags["api-name"],
+      reportBase
+    });
+    if (!this.jsonEnabled()) {
+      const format = flags.format;
+      const text = render(format, report, {
+        ascii: flags.ascii || void 0,
+        color: flags["no-color"] ? false : void 0,
+        sarifErrorThreshold: flags["sarif-error"],
+        sarifWarningThreshold: flags["sarif-warning"],
+        width: flags.width
+      });
+      this.log(text);
     }
-    if (project.packageDirectories.length === 0) {
-        throw new Error(`sfdx-project.json at ${project.root} declares no packageDirectories. ` +
-            'Pass --source-dir <path> explicitly.');
+    const combined = report.totalComplexity + report.totalApexComplexity;
+    if (flags["fail-on"] !== void 0 && combined >= flags["fail-on"]) {
+      this.error(
+        `Combined cyclomatic complexity ${combined} (agent ${report.totalComplexity} + apex ${report.totalApexComplexity}) \u2265 threshold ${flags["fail-on"]}`,
+        { exit: 2 }
+      );
     }
-    return {
-        reportBase: project.root,
-        roots: project.packageDirectories,
-        sourceDescription: `Analyzing sfdx project ${project.root} (${project.packageDirectories.length} package director${project.packageDirectories.length === 1 ? 'y' : 'ies'}).`,
-    };
+    return report;
+  }
+};
+async function resolveSources(sourceDirFlag) {
+  if (sourceDirFlag) {
+    return { reportBase: void 0, roots: [sourceDirFlag] };
+  }
+  const project = await discoverSfdxProject(process.cwd());
+  if (!project) {
+    throw new Error(
+      "No --source-dir was provided and no sfdx-project.json was found in the current directory or any ancestor. Pass --source-dir <path> or run from inside an sfdx project."
+    );
+  }
+  if (project.packageDirectories.length === 0) {
+    throw new Error(
+      `sfdx-project.json at ${project.root} declares no packageDirectories. Pass --source-dir <path> explicitly.`
+    );
+  }
+  return {
+    reportBase: project.root,
+    roots: project.packageDirectories,
+    sourceDescription: `Analyzing sfdx project ${project.root} (${project.packageDirectories.length} package director${project.packageDirectories.length === 1 ? "y" : "ies"}).`
+  };
 }
-//# sourceMappingURL=analyze.js.map
+export {
+  AgentpmdAnalyze as default
+};
+//# sourceMappingURL=analyze.js.map