skillscript-runtime 0.5.0 → 0.7.2

package/dist/parser.js

@@ -1,6 +1,23 @@
 // Source text → AST. The parser recognizes the full v1 grammar but performs
 // no resolution against external state. Semantic analysis (variable resolution,
 // data-skill inlining, topo-sort) lives in compile.ts.
+/**
+ * v0.7.0 — runtime-intrinsic function-call names. Closed set of ops the
+ * language implements directly (no MCP dispatch). Function-call grammar:
+ * `verb(kwarg=value, ...) [-> BINDING]`.
+ *
+ * Anything else with function-call shape is rejected by parser with a
+ * remediation pointing at `$ tool args -> R` for MCP dispatch.
+ */
+export const RUNTIME_INTRINSIC_FN_NAMES = [
+    "emit", // → ! (output to skill consumer)
+    "ask", // → ?? (prompt user)
+    "inline", // → & (compile-time skill composition)
+    "execute_skill", // → $ execute_skill (runtime skill invocation)
+    "shell", // → @ (local subprocess)
+    "file_read", // new — read file contents at runtime
+    "file_write", // new — write file contents at runtime
+];
 /**
  * Case-insensitive accept, canonical-form return. The `allowed` list defines
  * canonical form (the first match for any case-folded input). Returns `null`
@@ -21,12 +38,17 @@ const REQUIRES_LINE = /^(user-var|system-var):([A-Za-z0-9_-]+)\s*(?:→|->)\s*([
 const CAPABILITY_TOKEN = /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*$/;
 /** `&` op: `& skill-name [arg=value ...] [-> VARNAME]`. Skill names follow the same charset as filesystem-safe identifiers (alphanumeric, hyphen, underscore). */
 const AMPERSAND_OP_REGEX = /^&\s+([A-Za-z0-9][\w-]*)\s*(.*?)(?:\s*->\s*([A-Za-z_]\w*))?(?:\s+\(fallback\s*:\s*(.+?)\))?\s*$/s;
-const SET_OP_REGEX = /^\$set\s+([A-Za-z_]\w*)\s*=\s*(.*)$/;
+// v0.7.2 — `(.*)` widened to `([\s\S]*)` so multi-line triple-quote
+// (`"""..."""`) values fold into a single $set value capture. Without the
+// dotall-equivalent, the `.` excludes newlines and the regex stops at the
+// first line's `"""` opening.
+const SET_OP_REGEX = /^\$set\s+([A-Za-z_]\w*)\s*=\s*([\s\S]*)$/;
 // v0.3.0 accumulator. `$append VAR <value>` — single-value append to a
 // list-typed VAR. Form: `$append IDENT <space> <value>`. Mirrors $set
 // in shape (var name + value) but the runtime mutates an outer-scope
 // list rather than overwriting. See spec memory `9d6079bb` + `442cf4bb`.
-const APPEND_OP_REGEX = /^\$append\s+([A-Za-z_]\w*)\s+(.+)$/;
+// v0.7.2 — `(.+)` widened to `([\s\S]+)` for same multi-line reason.
+const APPEND_OP_REGEX = /^\$append\s+([A-Za-z_]\w*)\s+([\s\S]+)$/;
 const FOREACH_OP_REGEX = /^foreach\s+([A-Za-z_]\w*)\s+in\s+(.+?):\s*$/;
 const IF_OP_REGEX = /^if\s+(.+?):\s*$/;
 const ELIF_OP_REGEX = /^elif\s+(.+?):\s*$/;
@@ -53,20 +75,21 @@ const LOCAL_MODEL_OP_REGEX = /^~\s+(.+?)\s+->\s+([A-Za-z_]\w*)(?:\s+\(fallback\s
 const MCP_CONNECTOR_PREFIX = /^([a-z_][a-z0-9_-]*)\.(?=[A-Za-z_])([\s\S]*)$/;
 // Narrow v1 condition grammar.
 // v0.3.4: filter chain support — each `(REF)(|filter)?` became `(REF)(|filter)*`
-// to match `substituteRuntime`'s chain capture (runtime.ts:1158). Closes the
-// recurring "filter chain works in substitution but not conditions" gap named
-// in dev-log §14. Runtime regex set mirrors this; both update together.
-const COND_TRUTHY = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*$/;
+// to match `substituteRuntime`'s chain capture. Closes the recurring "filter
+// chain works in substitution but not conditions" gap named in dev-log §14.
+// v0.7.0: REF_PATTERN accepts both `$(REF)` (legacy) and `${REF}` (canonical).
+// Both forms have identical semantics; migration tool rewrites old → new.
+const REF_PATTERN = "\\$(?:\\([A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*(?:\\s*\\|\\s*[A-Za-z_]\\w*(?:\\s*:\\s*\"[^\"]*\")?)*\\)|\\{[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*(?:\\s*\\|\\s*[A-Za-z_]\\w*(?:\\s*:\\s*\"[^\"]*\")?)*\\})";
+const REF_PATTERN_NO_FILTER = "\\$(?:\\([A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*\\)|\\{[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*\\})";
+const COND_TRUTHY = new RegExp(`^\\s*${REF_PATTERN}\\s*$`);
 /** `$(REF) ==/!= "literal"` — ref-vs-string equality. Filter chain on the ref side. */
-const COND_EQ = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*(?:==|!=)\s*"[^"]*"\s*$/;
+const COND_EQ = new RegExp(`^\\s*${REF_PATTERN}\\s*(?:==|!=)\\s*"[^"]*"\\s*$`);
 /**
  * `$(REF) ==/!= $(REF)` — ref-vs-ref equality. Extended 2026-05-21 per
- * language reference §5; surfaced by the cold-agent skills battery (a
- * sub-agent reached for `$(FP|trim) == $(LAST_FP|trim)` unprompted as
- * the natural change-detection pattern). Filter chain + dotted field
- * access permitted on either side.
+ * language reference §5. Filter chain + dotted field access permitted on
+ * either side.
  */
-const COND_EQ_REF = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*(?:==|!=)\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*$/;
+const COND_EQ_REF = new RegExp(`^\\s*${REF_PATTERN}\\s*(?:==|!=)\\s*${REF_PATTERN}\\s*$`);
 /**
  * `$(REF) </>/<=/>= "literal"` and `$(REF) </>/<=/>= $(REF)` — numeric
  * comparison. v0.2.5 addition per the orchestration carve-out: comparison
@@ -75,9 +98,9 @@ const COND_EQ_REF = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]
  * chain + dotted field access permitted on either side, matching
  * EQ/EQ_REF shape.
  */
-const COND_CMP = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*(?:<=|>=|<|>)\s*"[^"]*"\s*$/;
-const COND_CMP_REF = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*(?:<=|>=|<|>)\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s*$/;
-const COND_IN = /^\s*\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*\)\s+(?:not\s+)?in\s+\$\([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*\)\s*$/;
+const COND_CMP = new RegExp(`^\\s*${REF_PATTERN}\\s*(?:<=|>=|<|>)\\s*"[^"]*"\\s*$`);
+const COND_CMP_REF = new RegExp(`^\\s*${REF_PATTERN}\\s*(?:<=|>=|<|>)\\s*${REF_PATTERN}\\s*$`);
+const COND_IN = new RegExp(`^\\s*${REF_PATTERN}\\s+(?:not\\s+)?in\\s+${REF_PATTERN_NO_FILTER}\\s*$`);
 function validateCondition(cond) {
     return validateCompoundCondition(cond.trim());
 }
@@ -161,20 +184,20 @@ function stripOuterCondParens(cond) {
     }
     return trimmed.slice(1, -1).trim();
 }
-/** Detects `$(REF) = "literal"` — a single `=` in condition position. */
-const SINGLE_EQ_IN_COND = /\$\([^)]+\)\s*=(?!=)\s*"[^"]*"/;
+/** Detects `$(REF) = "literal"` or `${REF} = "literal"` — single `=` in condition position. */
+const SINGLE_EQ_IN_COND = /\$(?:\([^)]+\)|\{[^}]+\})\s*=(?!=)\s*"[^"]*"/;
 /**
- * If the condition contains `$(REF) = "..."` (single `=`), emit a specific
- * diagnostic suggesting `==`. Returns the diagnostic string when matched,
- * `null` otherwise. The grammar rejects single-`=` in condition position;
- * this surfaces the JS-shaped-bug pattern as a specific error rather than
- * the generic "unsupported condition" fallback.
+ * If the condition contains `$(REF) = "..."` or `${REF} = "..."` (single `=`),
+ * emit a specific diagnostic suggesting `==`. Returns the diagnostic string
+ * when matched, `null` otherwise.
  */
 function detectSingleEqualsInCondition(cond) {
     const m = SINGLE_EQ_IN_COND.exec(cond);
     if (m === null)
         return null;
-    const fixed = cond.replace(/\$\(([^)]+)\)\s*=(?!=)\s*"([^"]*)"/, '$($1) == "$2"');
+    const fixed = cond
+        .replace(/\$\(([^)]+)\)\s*=(?!=)\s*"([^"]*)"/, '$($1) == "$2"')
+        .replace(/\$\{([^}]+)\}\s*=(?!=)\s*"([^"]*)"/, '${$1} == "$2"');
     return `\`=\` is not valid in a condition; use \`==\` for equality. rewrite as: \`${fixed}\``;
 }
 /**
@@ -299,10 +322,22 @@ function splitVarsLine(value) {
 function foldQuotedContinuations(lines) {
     const out = [];
     let buffer = null;
+    // v0.7.2 — triple-quote folding engages regardless of op kind. Three
+    // consecutive `"` chars don't accidentally appear in natural English
+    // prose, so the "phantom-scope from apostrophe" risk that gates single-
+    // quote folding to kwarg-bearing ops doesn't apply. inTripleAccum tracks
+    // which fold mode the buffer is in so we know which closing condition
+    // to test against.
+    let inTripleAccum = false;
     for (const line of lines) {
         if (buffer === null) {
-            if (isKwargBearingLine(line) && hasUnclosedQuote(line)) {
+            if (hasUnclosedTriple(line)) {
+                buffer = line;
+                inTripleAccum = true;
+            }
+            else if (isKwargBearingLine(line) && hasUnclosedQuote(line)) {
                 buffer = line;
+                inTripleAccum = false;
             }
             else {
                 out.push(line);
@@ -310,9 +345,11 @@ function foldQuotedContinuations(lines) {
         }
         else {
             buffer = buffer + "\n" + line;
-            if (!hasUnclosedQuote(buffer)) {
+            const closed = inTripleAccum ? !hasUnclosedTriple(buffer) : !hasUnclosedQuote(buffer);
+            if (closed) {
                 out.push(buffer);
                 buffer = null;
+                inTripleAccum = false;
             }
         }
     }
@@ -344,6 +381,24 @@ function hasUnclosedQuote(text) {
     }
     return inDouble || inSingle;
 }
+/**
+ * v0.7.2 — true if `text` contains an odd number of `"""` triple-quote
+ * delimiters (i.e., an unterminated triple-quote literal). Scans the
+ * string counting non-overlapping `"""` occurrences.
+ */
+function hasUnclosedTriple(text) {
+    let count = 0;
+    for (let i = 0; i <= text.length - 3;) {
+        if (text[i] === '"' && text[i + 1] === '"' && text[i + 2] === '"') {
+            count++;
+            i += 3;
+        }
+        else {
+            i++;
+        }
+    }
+    return count % 2 === 1;
+}
 /**
  * Split a `# Triggers:` header value into separate trigger entries.
  *
@@ -366,21 +421,56 @@ function splitTriggersLine(value) {
     return value.split(splitRegex);
 }
 /**
- * `$set` and `>` / `~` arg-value quote-strip rules:
- *   - Matching outer `"..."` or `'...'`: stripped, inner whitespace preserved.
+ * `$set` / `>` / `~` / kwarg arg-value quote-strip rules:
+ *   - Matching outer `"..."`: stripped + interpret \n/\t/\\/\" escapes (v0.7.2).
+ *   - Matching outer `'...'`: stripped, no escape interpretation (literal).
  *   - Mismatched / unquoted: verbatim, trailing whitespace trimmed.
+ *
+ * v0.7.2 — escape interpretation in double-quoted strings closes the R4
+ * cold-author footgun where `$set X = "line1\nline2"` stored literal
+ * `\n` bytes. Bash/Python/JS/Go all interpret these escapes; skillscript
+ * not interpreting was the surprise. Single-quoted strings reserved for
+ * v0.8+ explicit literal-pass-through semantics if a real use case
+ * surfaces.
  */
 export function processSetValue(raw) {
     const trimmed = raw.replace(/\s+$/, "");
+    // v0.7.2 — triple-quote `"""..."""` multi-line literal. Check before the
+    // single-quote pair check; a value like `"""abc"""` shouldn't be shortened
+    // to `""abc""` via the `"..."` branch.
+    if (trimmed.length >= 6 && trimmed.startsWith('"""') && trimmed.endsWith('"""')) {
+        return interpretDoubleQuotedEscapes(trimmed.slice(3, -3));
+    }
     if (trimmed.length >= 2) {
         const first = trimmed[0];
         const last = trimmed[trimmed.length - 1];
-        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+        if (first === '"' && last === '"') {
+            return interpretDoubleQuotedEscapes(trimmed.slice(1, -1));
+        }
+        if (first === "'" && last === "'") {
             return trimmed.slice(1, -1);
         }
     }
     return trimmed;
 }
+/**
+ * v0.7.2 — interpret common escape sequences in double-quoted string
+ * literals: `\n` → newline, `\t` → tab, `\\` → literal backslash,
+ * `\"` → literal quote. Other `\X` sequences pass through verbatim
+ * (no over-eager interpretation; future v0.8+ may add `\r` / `\0` /
+ * etc. if cold-author demand surfaces).
+ */
+function interpretDoubleQuotedEscapes(s) {
+    return s.replace(/\\(["\\nt])/g, (match, ch) => {
+        switch (ch) {
+            case '"': return '"';
+            case "\\": return "\\";
+            case "n": return "\n";
+            case "t": return "\t";
+            default: return match;
+        }
+    });
+}
 /**
  * Tokenize whitespace-separated `key=value` pairs, respecting matching
  * single/double quotes and `[...]` brackets.
@@ -389,15 +479,35 @@ export function tokenizeKeywordArgs(input) {
     const tokens = [];
     let current = "";
     let inQuote = null;
+    let inTriple = false; // v0.7.2 — triple-quote `"""..."""` state
     let bracketDepth = 0;
     for (let i = 0; i < input.length; i++) {
         const ch = input[i];
+        // Triple-quote state takes precedence: inside `"""..."""`, single `"`
+        // and whitespace are content, not delimiters.
+        if (inTriple) {
+            current += ch;
+            if (ch === '"' && input[i + 1] === '"' && input[i + 2] === '"') {
+                current += input[i + 1];
+                current += input[i + 2];
+                i += 2;
+                inTriple = false;
+            }
+            continue;
+        }
         if (inQuote) {
             current += ch;
             if (ch === inQuote)
                 inQuote = null;
             continue;
         }
+        // Check for triple-quote OPEN before single-quote (greedy match).
+        if (ch === '"' && input[i + 1] === '"' && input[i + 2] === '"') {
+            current += '"""';
+            i += 2;
+            inTriple = true;
+            continue;
+        }
         if (ch === '"' || ch === "'") {
             current += ch;
             inQuote = ch;
@@ -425,6 +535,99 @@ export function tokenizeKeywordArgs(input) {
         tokens.push(current);
     return tokens;
 }
+/**
+ * v0.7.0 — paren-balanced extraction. Given text and the index of an opening
+ * `(`, return the substring between matched parens plus the index of the
+ * closing `)`. Quote-aware (skips parens inside `"..."`/`'...'`). Returns
+ * null on unbalanced parens.
+ */
+function extractParenBody(text, openIdx) {
+    if (text[openIdx] !== "(")
+        return null;
+    let depth = 1;
+    let inQuote = null;
+    let inTriple = false; // v0.7.2 — `"""..."""` state
+    for (let i = openIdx + 1; i < text.length; i++) {
+        const ch = text[i];
+        if (inTriple) {
+            if (ch === '"' && text[i + 1] === '"' && text[i + 2] === '"') {
+                i += 2;
+                inTriple = false;
+            }
+            continue;
+        }
+        if (inQuote !== null) {
+            if (ch === inQuote)
+                inQuote = null;
+            continue;
+        }
+        if (ch === '"' && text[i + 1] === '"' && text[i + 2] === '"') {
+            i += 2;
+            inTriple = true;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inQuote = ch;
+            continue;
+        }
+        if (ch === "(")
+            depth++;
+        else if (ch === ")") {
+            depth--;
+            if (depth === 0)
+                return { body: text.slice(openIdx + 1, i), endIdx: i };
+        }
+    }
+    return null;
+}
+/**
+ * v0.7.0 — split a function-call argument list on top-level commas.
+ * Respects matched single/double quotes and `[...]`/`{...}`/`(...)` nesting.
+ */
+function splitTopLevelCommas(text) {
+    const parts = [];
+    let cur = "";
+    let depth = 0;
+    let inQuote = null;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inQuote !== null) {
+            cur += ch;
+            if (ch === inQuote)
+                inQuote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            cur += ch;
+            inQuote = ch;
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{") {
+            depth++;
+            cur += ch;
+            continue;
+        }
+        if (ch === ")" || ch === "]" || ch === "}") {
+            depth = Math.max(0, depth - 1);
+            cur += ch;
+            continue;
+        }
+        if (ch === "," && depth === 0) {
+            const t = cur.trim();
+            if (t !== "")
+                parts.push(t);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    const t = cur.trim();
+    if (t !== "")
+        parts.push(t);
+    return parts;
+}
+/** v0.7.0 — prefix probe for function-call shape: `name(`. */
+const FN_CALL_PREFIX = /^([a-z_][\w]*)\s*\(/;
 function splitMcpConnectorPrefix(body) {
     const m = MCP_CONNECTOR_PREFIX.exec(body);
     if (m === null)
@@ -455,7 +658,7 @@ function parseRetrievalArgs(argsStr, targetName) {
     // validate at parse time.
     let limit = 0;
     const rawLimit = map["limit"] ?? "";
-    if (/\$\(/.test(rawLimit)) {
+    if (/\$[(\{]/.test(rawLimit)) {
         limit = rawLimit;
     }
     else {
@@ -512,7 +715,7 @@ function parseLocalModelArgs(argsStr, targetName) {
         if (!(key in map))
             return undefined;
         const raw = map[key];
-        if (/\$\(/.test(raw))
+        if (/\$[(\{]/.test(raw))
             return raw;
         const n = parseInt(raw, 10);
         if (!Number.isFinite(n) || n <= 0) {
@@ -676,7 +879,7 @@ export function parse(source) {
             else if (key === "timeout") {
                 // Per lesson ab6c19db: defer integer validation when value contains
                 // `$(VAR)` ref. Runtime resolves via resolveIntParam at op dispatch.
-                if (/\$\(/.test(value)) {
+                if (/\$[(\{]/.test(value)) {
                     result.timeout = value;
                 }
                 else {
@@ -1177,6 +1380,149 @@ export function parse(source) {
             });
             continue;
         }
+        // v0.7.0 — function-call op grammar: `verb(kwarg=value, ...) [-> VAR] [(fallback: "...")]`
+        // Closed runtime-intrinsic op set in RUNTIME_INTRINSIC_FN_NAMES. Unknown
+        // function-call names are parse-errors with remediation pointing at `$`.
+        {
+            const fnPrefix = FN_CALL_PREFIX.exec(stripped0);
+            if (fnPrefix !== null) {
+                const fnName = fnPrefix[1];
+                const parenOpenIdx = fnPrefix[0].length - 1;
+                const parsed = extractParenBody(stripped0, parenOpenIdx);
+                if (parsed === null) {
+                    result.parseErrors.push(`Malformed function-call op '${fnName}(...)' in target '${currentTarget.name}' — unbalanced parens.`);
+                    continue;
+                }
+                // Parse comma-separated kwargs.
+                const kwArgs = {};
+                let argErr = false;
+                for (const arg of splitTopLevelCommas(parsed.body)) {
+                    const eq = arg.indexOf("=");
+                    if (eq === -1) {
+                        result.parseErrors.push(`Malformed function-call arg '${arg}' in '${fnName}(...)' (target '${currentTarget.name}') — expected name=value.`);
+                        argErr = true;
+                        continue;
+                    }
+                    const k = arg.slice(0, eq).trim();
+                    const v = arg.slice(eq + 1).trim();
+                    kwArgs[k] = processSetValue(v);
+                }
+                if (argErr)
+                    continue;
+                // Trailing `-> VAR` and optional `(fallback: "...")`.
+                const tail = stripped0.slice(parsed.endIdx + 1).trim();
+                let outputVar;
+                let fallback;
+                if (tail !== "") {
+                    const tailMatch = /^(?:->\s*([A-Za-z_]\w*))?(?:\s*\(fallback\s*:\s*(.+?)\))?\s*$/.exec(tail);
+                    if (tailMatch !== null) {
+                        if (tailMatch[1] !== undefined)
+                            outputVar = tailMatch[1];
+                        if (tailMatch[2] !== undefined)
+                            fallback = processSetValue(tailMatch[2]);
+                    }
+                    else {
+                        result.parseErrors.push(`Malformed function-call op '${fnName}(...)' trailer in target '${currentTarget.name}': '${tail}' — expected '-> VAR' and/or '(fallback: "value")'.`);
+                        continue;
+                    }
+                }
+                const approved = kwArgs["approved"];
+                // Per-op dispatch — map function-call form to canonical AST shapes.
+                if (fnName === "emit") {
+                    const text = kwArgs["text"] ?? "";
+                    opBucket.push({
+                        kind: "!",
+                        body: text,
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "ask") {
+                    const prompt = kwArgs["prompt"] ?? "";
+                    opBucket.push({
+                        kind: "??",
+                        body: prompt,
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "inline") {
+                    const skill = kwArgs["skill"] ?? "";
+                    opBucket.push({
+                        kind: "&",
+                        body: stripped0,
+                        ampParams: { skillName: skill, args: {} },
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(fallback !== undefined ? { fallback } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "execute_skill") {
+                    const skillName = kwArgs["skill_name"] ?? "";
+                    const rest = Object.entries(kwArgs).filter(([k]) => k !== "skill_name" && k !== "approved");
+                    const inner = rest.map(([k, v]) => /\s/.test(v) || v.startsWith("{") || v.startsWith("[") ? `${k}=${v}` : `${k}="${v}"`).join(" ");
+                    opBucket.push({
+                        kind: "$",
+                        body: `execute_skill skill_name="${skillName}"${inner ? " " + inner : ""}`,
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(fallback !== undefined ? { fallback } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "shell") {
+                    const command = kwArgs["command"] ?? "";
+                    const unsafe = kwArgs["unsafe"] === "true";
+                    opBucket.push({
+                        kind: "@",
+                        body: command,
+                        ...(unsafe ? { policy: "unsafe" } : {}),
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(fallback !== undefined ? { fallback } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "file_read") {
+                    const path = kwArgs["path"] ?? "";
+                    opBucket.push({
+                        kind: "file_read",
+                        body: stripped0,
+                        fileParams: { path },
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(fallback !== undefined ? { fallback } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                if (fnName === "file_write") {
+                    const path = kwArgs["path"] ?? "";
+                    const content = kwArgs["content"] ?? "";
+                    opBucket.push({
+                        kind: "file_write",
+                        body: stripped0,
+                        fileParams: { path, content },
+                        ...(outputVar !== undefined ? { outputVar } : {}),
+                        ...(approved !== undefined ? { approved } : {}),
+                        sourceForm: "function-call",
+                    });
+                    continue;
+                }
+                // Unknown function-call name — runtime-intrinsic set is closed.
+                result.parseErrors.push(`Unknown function-call op '${fnName}(...)' in target '${currentTarget.name}'. ` +
+                    `Runtime-intrinsic ops are: ${RUNTIME_INTRINSIC_FN_NAMES.join(", ")}. ` +
+                    `If this is an MCP tool, use \`$ ${fnName} args -> R\` shape instead.`);
+                continue;
+            }
+        }
         const stripped = line.replace(/^\s+/, "");
         let kind = null;
         let body = "";