skillscript-runtime 0.5.0 → 0.7.2

package/dist/help-content.js.map

@@ -1 +1 @@
-{"version":3,"file":"help-content.js","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"help-content.js","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"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"}

package/dist/lint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,WAAW,EAAgB,MAAM,aAAa,CAAC;AAEzF,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,kBAAkB,IAAI,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAC9D,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,mBAAmB,CAAC;IAC/C;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;;;OAOG;IACH,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;AAED,UAAU,WAAW;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAE,KAAK,CAAC;QAAE,kBAAkB,IAAI,kBAAkB,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IAC9E,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IACnC,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,mBAAmB,CAAC;IAC9C,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,iBAAiB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACxC,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAChE,WAAW,EAAE,MAAM,CAAC;CACrB;AAID,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAoCrF;AAED,kFAAkF;AAClF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,UAAU,CAmC1E;AAED,6HAA6H;AAC7H,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAW3D;AAygDD,mFAAmF;AACnF,wBAAgB,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAElE"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"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"}

package/dist/lint.js

@@ -658,7 +658,7 @@ const UNPARSED_JSON_FIELD_ACCESS = {
     remediation: "Replace with `$ json_parse $(VAR) -> P` then access `$(P.field)`. The op binds the parsed structure so dotted descent works in conditions + emit. See help({topic: \"ops\"}).",
     check: (ctx) => {
         const findings = [];
-        const BAD = /\$\([^)]*\|\s*json_parse\s*\)\.([A-Za-z_]\w*)/;
+        const BAD = /\$(?:\([^)]*\|\s*json_parse\s*\)|\{[^}]*\|\s*json_parse\s*\})\.([A-Za-z_]\w*)/;
         const reportIfMatches = (text, targetName) => {
             const m = BAD.exec(text);
             if (m === null)
@@ -1073,8 +1073,8 @@ const MUTATING_TOOL_PATTERN = /^(?:write_|update_|delete_|remove_|set_|create_|i
 const UNCONFIRMED_MUTATION = {
     id: "unconfirmed-mutation",
     severity: "warning",
-    description: "A `$` op invokes a tool whose name suggests mutation (write/update/delete/...) without a preceding `??` confirmation step. Silent when the skill declares `# Autonomous: true` (v0.4.2).",
-    remediation: "Add a `??` confirmation op before the mutation, or declare `# Autonomous: true` at the skill header level when the skill is intentionally autonomous (cron-fired, agent-fired, etc.) and the user-confirmation pattern doesn't apply.",
+    description: "A mutation-class op runs without author authorization. Mutation classes: `$ tool` with mutating-name shape (write/update/delete/...); `$ memory_write` MCP dispatch; `file_write(...)` function-call op. Silent when the skill declares `# Autonomous: true` (v0.4.2), when a preceding `??` / `ask(...)` confirmation gates the op, or (v0.7.0+) when the op carries `approved=\"reason\"` per-op authorization.",
+    remediation: "Three ways to authorize: (1) add `# Autonomous: true` at the skill header for cron/agent-fired skills; (2) add a preceding `??` / `ask(prompt=\"...\")` confirmation op in the same target; (3) v0.7.0+: pass `approved=\"reason\"` kwarg on the mutation op itself (any non-empty string; presence is what matters, value not parsed semantically).",
     check: (ctx) => {
         // v0.4.2 — `# Autonomous: true` skills are unattended by design;
         // the user-confirmation pattern doesn't apply. Silent for the
@@ -1085,19 +1085,44 @@ const UNCONFIRMED_MUTATION = {
         for (const [targetName, target] of ctx.parsed.targets) {
             let sawConfirm = false;
             for (const op of target.ops) {
+                // v0.7.0+: ask(prompt=...) parses to kind "??" in the AST, so the
+                // existing check captures both legacy `??` and canonical `ask()`.
                 if (op.kind === "??")
                     sawConfirm = true;
-                if (op.kind === "$" && !sawConfirm) {
+                if (sawConfirm)
+                    continue;
+                // v0.7.0+: per-op `approved="reason"` kwarg authorizes individual ops
+                // without requiring # Autonomous: true skill-level or `??` step.
+                const isApproved = typeof op.approved === "string" && op.approved.length > 0;
+                if (isApproved)
+                    continue;
+                // Class 1: `$` MCP dispatch with mutating tool name.
+                if (op.kind === "$") {
                     const toolName = op.body.split(/\s+/)[0] ?? "";
-                    if (MUTATING_TOOL_PATTERN.test(toolName)) {
+                    // memory_write is explicitly a mutation tool name — flag it even
+                    // though it doesn't start with `write_` (the pattern's anchor).
+                    const isMemoryWrite = toolName === "memory_write" || /(?:^|_)memory_write(?:_|$)/.test(toolName);
+                    if (MUTATING_TOOL_PATTERN.test(toolName) || isMemoryWrite) {
                         findings.push({
                             rule: "unconfirmed-mutation",
                             severity: "warning",
-                            message: `\`$\` op in target '${targetName}' invokes '${toolName}' (mutating shape) without a preceding \`??\` confirmation.`,
+                            message: `\`$\` op in target '${targetName}' invokes '${toolName}' (mutating shape) without authorization. Add \`approved="..."\` kwarg, precede with \`ask(...)\`, or declare \`# Autonomous: true\`.`,
                             block: targetName,
+                            extras: { tool_name: toolName },
                         });
                     }
                 }
+                // Class 2: file_write runtime-intrinsic op (v0.7.0).
+                if (op.kind === "file_write") {
+                    const path = op.fileParams?.path ?? "";
+                    findings.push({
+                        rule: "unconfirmed-mutation",
+                        severity: "warning",
+                        message: `\`file_write(path="${path}")\` in target '${targetName}' is a mutation op without authorization. Add \`approved="..."\` kwarg, precede with \`ask(...)\`, or declare \`# Autonomous: true\`.`,
+                        block: targetName,
+                        extras: { op_kind: "file_write", path },
+                    });
+                }
             }
         }
         return findings;
@@ -1445,7 +1470,7 @@ const APPEND_TO_NON_LIST = {
         const findings = [];
         for (const [targetName, target] of ctx.parsed.targets) {
             walkOps(target.ops, (op) => {
-                if (op.kind === "$set" && op.setName !== undefined && op.setValue !== undefined && !/\$\(/.test(op.setValue)) {
+                if (op.kind === "$set" && op.setName !== undefined && op.setValue !== undefined && !/\$[(\{]/.test(op.setValue)) {
                     staticInits.set(op.setName, op.setValue);
                 }
             });
@@ -1485,7 +1510,7 @@ function buildBindingOrigins(parsed) {
                 // v0.5.0 item 3: $set RHS interpolates $(REF) at bind time. If the
                 // RHS is a static literal (no $(REF)), record its value for the
                 // whitespace check. If it contains $(REF), treat as suspect.
-                if (/\$\(/.test(op.setValue)) {
+                if (/\$[(\{]/.test(op.setValue)) {
                     origins.set(op.setName, { kind: "set-ref" });
                 }
                 else {
@@ -1530,51 +1555,84 @@ function isOriginSuspect(origin) {
 const UNQUOTED_SUBSTITUTION_IN_KWARG_VALUE = {
     id: "unquoted-substitution-in-kwarg-value",
     severity: "warning",
-    description: "A `$ tool key=$(VAR)` op kwarg has an unquoted `$(VAR)` substitution where VAR may resolve to a value containing whitespace. Runtime renders into `key=value with spaces` then re-tokenizes on whitespace — only the first chunk binds to `key`. Silent arg truncation.",
-    remediation: "Wrap the substitution in quotes: `key=\"$(VAR)\"`. The MCP arg tokenizer respects quoted regions, preventing the re-tokenization split.",
+    description: "A `$ tool key=$(VAR)` op kwarg OR a legacy `@ cmd ... $(VAR)` shell arg has an unquoted `$(VAR)` / `${VAR}` substitution where VAR may resolve to a value containing whitespace. Runtime renders into `key=value with spaces` then re-tokenizes on whitespace — only the first chunk binds to `key` (MCP) or first arg (shell). Silent arg truncation. v0.7.2 extends coverage from `$` ops to `@` ops per R4 minion 4 finding.",
+    remediation: "Wrap the substitution in quotes: `key=\"$(VAR)\"` for MCP kwargs, `\"$(VAR)\"` for shell args. The arg tokenizer respects quoted regions, preventing the re-tokenization split.",
     check: (ctx) => {
         const findings = [];
         const origins = buildBindingOrigins(ctx.parsed);
         const reported = new Set();
+        // v0.7.2: shared pattern matches both legacy `$(VAR)` and canonical
+        // `${VAR}` substitution forms. Only the opening delimiter + var-name
+        // are required to match (no closing `)`/`}`) so filter chains like
+        // `$(VAR|trim)` and `${VAR|filter:"x"}` parse cleanly. The capture
+        // groups (1 = paren-form name, 2 = brace-form name) get coalesced.
+        const subStPattern = /\$(?:\(([^|)\s]+)|\{([^|}\s]+))/;
         for (const [targetName, target] of ctx.parsed.targets) {
             walkOps(target.ops, (op) => {
-                if (op.kind !== "$")
-                    return;
-                // Scan op.body for `key=$(VAR)` patterns where the $( is NOT
-                // immediately preceded by a quote character. Tokenize once, then
-                // inspect each token.
-                const tokens = tokenizeKeywordArgs(op.body);
-                for (const tok of tokens) {
-                    const eq = tok.indexOf("=");
-                    if (eq === -1)
-                        continue;
-                    const key = tok.slice(0, eq);
-                    const value = tok.slice(eq + 1);
-                    // Unquoted $(VAR) pattern: starts with $( (not " or '). May
-                    // include filter chain and trailing characters.
-                    if (!value.startsWith("$("))
-                        continue;
-                    // Extract the var name (everything up to | or ) ).
-                    const m = /^\$\(([^|)\s]+)/.exec(value);
-                    if (m === null)
-                        continue;
-                    const varName = m[1];
-                    // Dotted access: trim to the root.
-                    const rootVar = varName.split(".")[0];
-                    const origin = origins.get(rootVar);
-                    if (!isOriginSuspect(origin))
-                        continue;
-                    const key2 = `${targetName}:${key}:${varName}`;
-                    if (reported.has(key2))
-                        continue;
-                    reported.add(key2);
-                    findings.push({
-                        rule: "unquoted-substitution-in-kwarg-value",
-                        severity: "warning",
-                        message: `\`$ ... ${key}=$(${varName})\` in target '${targetName}': unquoted substitution. ${describeOriginRisk(origin)} Wrap as \`${key}="$(${varName})"\` to prevent silent arg truncation if the value contains whitespace.`,
-                        block: targetName,
-                        extras: { kwarg: key, var_name: varName, origin: origin.kind },
-                    });
+                if (op.kind === "$") {
+                    // $ MCP dispatch — scan kwarg values for unquoted substitutions.
+                    const tokens = tokenizeKeywordArgs(op.body);
+                    for (const tok of tokens) {
+                        const eq = tok.indexOf("=");
+                        if (eq === -1)
+                            continue;
+                        const key = tok.slice(0, eq);
+                        const value = tok.slice(eq + 1);
+                        if (!(value.startsWith("$(") || value.startsWith("${")))
+                            continue;
+                        const m = subStPattern.exec(value);
+                        if (m === null)
+                            continue;
+                        const varName = (m[1] ?? m[2]);
+                        const rootVar = varName.split(".")[0];
+                        const origin = origins.get(rootVar);
+                        if (!isOriginSuspect(origin))
+                            continue;
+                        const dedupKey = `${targetName}:$:${key}:${varName}`;
+                        if (reported.has(dedupKey))
+                            continue;
+                        reported.add(dedupKey);
+                        findings.push({
+                            rule: "unquoted-substitution-in-kwarg-value",
+                            severity: "warning",
+                            message: `\`$ ... ${key}=\${${varName}}\` in target '${targetName}': unquoted substitution. ${describeOriginRisk(origin)} Wrap as \`${key}="\${${varName}}"\` to prevent silent arg truncation if the value contains whitespace.`,
+                            block: targetName,
+                            extras: { kwarg: key, var_name: varName, origin: origin.kind, op: "$" },
+                        });
+                    }
+                }
+                else if (op.kind === "@") {
+                    // v0.7.2 — legacy @ shell op. Tokenize the body the same way the
+                    // runtime would (whitespace-separated, quotes respected), then
+                    // flag any token that is a bare unquoted substitution. Quoted
+                    // tokens (`"${VAR}"` / `'${VAR}'`) are safe.
+                    const tokens = tokenizeKeywordArgs(op.body);
+                    for (const tok of tokens) {
+                        // Skip quoted tokens — the quotes protect against whitespace split.
+                        if ((tok.startsWith('"') && tok.endsWith('"')) || (tok.startsWith("'") && tok.endsWith("'")))
+                            continue;
+                        if (!(tok.startsWith("$(") || tok.startsWith("${")))
+                            continue;
+                        const m = subStPattern.exec(tok);
+                        if (m === null)
+                            continue;
+                        const varName = (m[1] ?? m[2]);
+                        const rootVar = varName.split(".")[0];
+                        const origin = origins.get(rootVar);
+                        if (!isOriginSuspect(origin))
+                            continue;
+                        const dedupKey = `${targetName}:@:${varName}`;
+                        if (reported.has(dedupKey))
+                            continue;
+                        reported.add(dedupKey);
+                        findings.push({
+                            rule: "unquoted-substitution-in-kwarg-value",
+                            severity: "warning",
+                            message: `\`@ ... \${${varName}}\` shell arg in target '${targetName}': unquoted substitution. ${describeOriginRisk(origin)} Wrap as \`"\${${varName}}"\` to prevent silent word-splitting if the value contains whitespace.`,
+                            block: targetName,
+                            extras: { var_name: varName, origin: origin.kind, op: "@" },
+                        });
+                    }
                 }
             });
         }
@@ -1595,6 +1653,183 @@ function describeOriginRisk(origin) {
             return `Variable is a \`foreach\` iterator — element type unknown statically.`;
     }
 }
+/**
+ * v0.7.1 — tier-2 visibility nudge for legacy symbol-form ops (`~`, `>`,
+ * `@`, `!`, `??`, `&`). The parser still accepts these during the v0.7.x
+ * grace period; the runtime dispatches them as before. This rule surfaces
+ * the canonical replacement so authors editing skills see the migration
+ * path. Tier-1 promotion (refuse-to-compile) lands in v0.8 or v0.9 once
+ * the adopter ecosystem confirms migration is settled.
+ *
+ * The `$ tool` op is NOT flagged — that shape is canonical (MCP dispatch
+ * marker). Only the 6 symbol ops that became function-call ops in v0.7.0.
+ */
+const DEPRECATED_SYMBOL_OP_REPLACEMENT = {
+    // v0.7.2: bridge classes ship default-wired so `$ llm` / `$ memory` work
+    // out of the box in default deployments. Suggestions are load-bearing
+    // (no more "(or your wired connector name)" caveat).
+    "~": "$ llm prompt=\"...\" [maxTokens=N] [model=\"...\"] -> R",
+    ">": "$ memory mode=\"fts|semantic|rerank\" query=\"...\" limit=N -> R",
+    "@": "shell(command=\"...\") [-> R]",
+    "!": "emit(text=\"...\")",
+    "??": "ask(prompt=\"...\") -> R",
+    "&": "inline(skill=\"...\")   (or execute_skill(skill_name=\"...\", ...) -> R for procedural composition)",
+};
+const DEPRECATED_SYMBOL_OP = {
+    id: "deprecated-symbol-op",
+    severity: "warning",
+    description: "An op uses the legacy symbol form deprecated in v0.7.0.",
+    remediation: "Rewrite to the canonical v0.7.0 form (see message). All legacy ops continue to compile during the grace period; tier-1 promotion (refuse-to-compile) lands in v0.8/v0.9. See CHANGELOG.md `## 0.7.0 — Migration` for the full rewrite rules.",
+    check: (ctx) => {
+        const findings = [];
+        for (const [targetName, target] of ctx.parsed.targets) {
+            const reported = new Set();
+            walkOps(target.ops, (op) => {
+                const replacement = DEPRECATED_SYMBOL_OP_REPLACEMENT[op.kind];
+                if (replacement === undefined)
+                    return;
+                // v0.7.1: skip ops authored in canonical function-call form. The
+                // parser collapses both `! x` and `emit(text="x")` to kind "!",
+                // so without the sourceForm marker the lint would fire on
+                // canonical code. Source-form marker preserves which surface
+                // the author wrote.
+                if (op.sourceForm === "function-call")
+                    return;
+                // Dedupe per-kind-per-target — one nudge per legacy op type per
+                // target is plenty; further occurrences don't add signal.
+                const key = `${targetName}:${op.kind}`;
+                if (reported.has(key))
+                    return;
+                reported.add(key);
+                findings.push({
+                    rule: "deprecated-symbol-op",
+                    severity: "warning",
+                    message: `Op '${op.kind}' in target '${targetName}' is deprecated in v0.7.0. Rewrite as: \`${replacement}\``,
+                    block: targetName,
+                    extras: { legacy_op: op.kind, canonical_replacement: replacement },
+                });
+            });
+            if (target.elseBlock !== undefined) {
+                walkOps(target.elseBlock, (op) => {
+                    const replacement = DEPRECATED_SYMBOL_OP_REPLACEMENT[op.kind];
+                    if (replacement === undefined)
+                        return;
+                    if (op.sourceForm === "function-call")
+                        return;
+                    const key = `${targetName}:else:${op.kind}`;
+                    if (reported.has(key))
+                        return;
+                    reported.add(key);
+                    findings.push({
+                        rule: "deprecated-symbol-op",
+                        severity: "warning",
+                        message: `Op '${op.kind}' in target '${targetName}' (else block) is deprecated in v0.7.0. Rewrite as: \`${replacement}\``,
+                        block: targetName,
+                        extras: { legacy_op: op.kind, canonical_replacement: replacement },
+                    });
+                });
+            }
+        }
+        return findings;
+    },
+};
+/**
+ * v0.7.1 — tier-2 visibility nudge for legacy `$(VAR)` substitution form.
+ * Canonical v0.7.0+ form is `${VAR}`. Parser/runtime accept both during
+ * grace period. Dedupes per-var-per-target; one nudge per `$(VAR)` form
+ * per scope.
+ *
+ * Skips the `$$(...)` escape (used in `@ unsafe` op bodies for shell
+ * literal pass-through). Skips ops where the body is `$set` source
+ * (because $set's RHS is its own substitution context and the lint would
+ * double-fire).
+ */
+const DEPRECATED_SUBSTITUTION_SHAPE = {
+    id: "deprecated-substitution-shape",
+    severity: "warning",
+    description: "A `$(VAR)` substitution uses the legacy v0.6.x form deprecated in v0.7.0.",
+    remediation: "Rewrite to `${VAR}` canonical form. Both forms produce identical results during the v0.7.x grace period; tier-1 promotion lands in v0.8/v0.9. The `$$(VAR)` escape (for `@ unsafe` shell literal pass-through) is unchanged.",
+    check: (ctx) => {
+        const findings = [];
+        // Negative lookbehind blocks `$$(VAR)` escape form so the lint doesn't
+        // fire on shell-escape sites authors deliberately wrote.
+        const legacyRe = /(?<!\$)\$\(([^|)\s]+)/g;
+        for (const [targetName, target] of ctx.parsed.targets) {
+            const reported = new Set();
+            const scanOp = (op, scope) => {
+                const text = collectOpText(op);
+                let m;
+                while ((m = legacyRe.exec(text)) !== null) {
+                    const varName = m[1];
+                    const key = `${targetName}:${scope}:${varName}`;
+                    if (reported.has(key))
+                        continue;
+                    reported.add(key);
+                    findings.push({
+                        rule: "deprecated-substitution-shape",
+                        severity: "warning",
+                        message: `Substitution '$(${varName})' in target '${targetName}'${scope === "else" ? " (else block)" : ""} uses the legacy v0.6.x form. Rewrite as '\${${varName}}'.`,
+                        block: targetName,
+                        extras: { var_name: varName, legacy_form: `$(${varName})`, canonical_form: `\${${varName}}` },
+                    });
+                }
+                legacyRe.lastIndex = 0;
+            };
+            walkOps(target.ops, (op) => scanOp(op, "main"));
+            if (target.elseBlock !== undefined) {
+                walkOps(target.elseBlock, (op) => scanOp(op, "else"));
+            }
+        }
+        return findings;
+    },
+};
+/**
+ * v0.7.2 — tier-3 advisory for the R4 cold-author footgun (4 of 5 minions).
+ * `foreach IT in ${VAR}` where VAR's binding origin is a `$` MCP tool output
+ * (and the iteration expression has no `.field` accessor). MCP tools commonly
+ * wrap arrays in an envelope object (e.g., `{issuesPage: [...], hasNextPage}`,
+ * `{items: [...]}`, `{results: [...]}`) — cold authors iterating the bare
+ * bound var get silent stringification + a single-iteration loop with the
+ * stringification as the iterator value. Downstream `${IT.field}` errors.
+ *
+ * Placeholder for the v0.8 tool-schema-introspection solution that catches
+ * this precisely. Advisory hints at the common envelope-field names.
+ */
+const OBJECT_ITERATION_ADVISORY = {
+    id: "object-iteration-advisory",
+    severity: "info",
+    description: "A `foreach IT in ${VAR}` iterates a bound variable whose origin is a `$` MCP tool output, without a `.field` accessor. MCP tools commonly wrap arrays in an envelope.",
+    remediation: "Check the tool's response shape — most MCP services wrap arrays under fields like `.items`, `.results`, `.issuesPage`, `.data`, `.records`. Rewrite as `foreach IT in ${VAR.items}` (or the correct field) once you know the shape. v0.8 tool-schema introspection will catch this precisely; today the advisory is a soft nudge.",
+    check: (ctx) => {
+        const findings = [];
+        const origins = buildBindingOrigins(ctx.parsed);
+        // Bare var ref pattern: `$(VAR)` or `${VAR}` — no dotted accessor, no filter chain.
+        const bareRef = /^\s*\$(?:\(([A-Za-z_]\w*)\)|\{([A-Za-z_]\w*)\})\s*$/;
+        for (const [targetName, target] of ctx.parsed.targets) {
+            walkOps(target.ops, (op) => {
+                if (op.kind !== "foreach" || op.foreachList === undefined)
+                    return;
+                const m = bareRef.exec(op.foreachList);
+                if (m === null)
+                    return;
+                const varName = (m[1] ?? m[2]);
+                const origin = origins.get(varName);
+                if (origin === undefined)
+                    return;
+                if (origin.kind !== "op-output" || origin.op !== "$")
+                    return;
+                findings.push({
+                    rule: "object-iteration-advisory",
+                    severity: "info",
+                    message: `In target '${targetName}': \`foreach ${op.foreachIter} in \${${varName}}\` iterates a bare \`$\` op output without a \`.field\` accessor. Most MCP tools wrap arrays in an envelope (e.g., \`.items\`, \`.results\`, \`.issuesPage\`, \`.data\`). Check the tool's response shape; rewrite as \`foreach ${op.foreachIter} in \${${varName}.items}\` (or the actual array field) if so.`,
+                    block: targetName,
+                    extras: { var_name: varName, foreach_iter: op.foreachIter },
+                });
+            });
+        }
+        return findings;
+    },
+};
 const RULES = [
     // Tier-1 (error)
     PARSE_ERROR,
@@ -1628,6 +1863,8 @@ const RULES = [
     MISSING_SKILLSTORE_FOR_DATA_REF,
     // Tier-2 (warning)
     DEPRECATED_QUESTION,
+    DEPRECATED_SYMBOL_OP,
+    DEPRECATED_SUBSTITUTION_SHAPE,
     UNSAFE_SHELL_AMBIGUOUS_SUBST,
     UNSAFE_SHELL_OP,
     UNSAFE_SHELL_DISABLED,
@@ -1642,6 +1879,7 @@ const RULES = [
     DUPLICATE_SKILL_NAME,
     PLUGIN_COLLISION,
     UNPARSED_JSON_FIELD_ACCESS,
+    OBJECT_ITERATION_ADVISORY,
 ];
 /** Read-only view of the rule registry — for tooling that introspects v1 rules. */
 export function listRules() {
@@ -1692,14 +1930,17 @@ function extractVarRefs(op) {
     // suppressed from undeclared-var. The author has explicitly opted into
     // "may not resolve at runtime" semantics — making this a lint error
     // would defeat the purpose.
-    const re = /\$\(([^|)\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\)/g;
+    // v0.7.0: alternation matches both `$(REF|chain)` and `${REF|chain}`.
+    // Capture groups: 1+2 = paren form, 3+4 = brace form.
+    const re = /\$(?:\(([^|)\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\)|\{([^|}\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\})/g;
     const refs = [];
     let m;
     while ((m = re.exec(text)) !== null) {
-        const chain = m[2] ?? "";
+        const name = m[1] ?? m[3];
+        const chain = (m[2] ?? m[4]) ?? "";
         if (/\|\s*fallback(?:\s*:|[\s|)])/.test(chain))
             continue;
-        refs.push(m[1]);
+        refs.push(name);
     }
     return refs;
 }
@@ -1709,12 +1950,14 @@ function extractVarRefsWithFilter(op) {
     // Multiple filters in a chain produce one entry per filter (preserves
     // the per-filter unknown-filter check that pre-existed for single-filter
     // refs).
-    const re = /\$\(([^|)\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\)/g;
+    // v0.7.0: alternation matches both `$(REF|chain)` and `${REF|chain}`.
+    // Capture groups: 1+2 = paren form, 3+4 = brace form.
+    const re = /\$(?:\(([^|)\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\)|\{([^|}\s]+)((?:\s*\|\s*[A-Za-z_]\w*(?:\s*:\s*"[^"]*")?)*)\})/g;
     const out = [];
     let m;
     while ((m = re.exec(text)) !== null) {
-        const name = m[1];
-        const chain = m[2];
+        const name = (m[1] ?? m[3]);
+        const chain = (m[2] ?? m[4]) ?? "";
         if (!chain) {
             out.push({ name });
             continue;