@intentius/chant 0.67.0 → 0.68.1

package/dist/attrref.d.ts

@@ -19,6 +19,27 @@ export declare class AttrRef implements Intrinsic {
      * Get the logical name assigned to this attribute reference.
      */
     getLogicalName(): string | undefined;
+    /**
+     * Refuse to become a string (#2349).
+     *
+     * An `AttrRef` stands for a value the build resolves later, so it has no
+     * string form here. Without this, `` `${bucket.arn}-suffix` `` produced
+     * `"[object Object]-suffix"` and shipped it — and the fold path produced
+     * exactly the same wrong string from the `{__attrRef}` envelope, so the two
+     * paths agreed and the differential harness reported nothing. Agreement on a
+     * wrong value is the failure this class of check exists to catch, which is
+     * why this throws rather than returning something more helpful-looking.
+     *
+     * `toJSON` below is the honest serialization and is untouched: a serializer
+     * that wants the envelope asks for it by name.
+     */
+    toString(): never;
+    /**
+     * The same refusal for `+` and for anything else that coerces, so
+     * `"prefix" + bucket.arn` fails where `` `${bucket.arn}` `` fails rather
+     * than taking a different path to the same wrong string.
+     */
+    [Symbol.toPrimitive](): never;
     /**
      * Serialize to a generic envelope. Lexicon-specific serializers should
      * read `getLogicalName()` and `attribute` directly instead of relying

package/dist/attrref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attrref.d.ts","sourceRoot":"","sources":["../src/attrref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,SAAS;IACvC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAG,IAAI,CAAU;IAC5C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAS;gBAEjB,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAK7C;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAInC;;OAEG;IACH,cAAc,IAAI,MAAM,GAAG,SAAS;IAIpC;;;;;OAKG;IACH,MAAM,IAAI;QAAE,SAAS,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAU/D"}
+{"version":3,"file":"attrref.d.ts","sourceRoot":"","sources":["../src/attrref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,SAAS;IACvC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAG,IAAI,CAAU;IAC5C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAS;gBAEjB,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAK7C;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAInC;;OAEG;IACH,cAAc,IAAI,MAAM,GAAG,SAAS;IAIpC;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,KAAK;IAUjB;;;;OAIG;IACH,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,KAAK;IAI7B;;;;;OAKG;IACH,MAAM,IAAI;QAAE,SAAS,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAU/D"}

package/dist/discovery/fold-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAMjC,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAkC,KAAK,iBAAiB,EAAyB,MAAM,cAAc,CAAC;AAuC7G,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,mGAAmG;AACnG,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC;AAElF,MAAM,MAAM,cAAc,GACtB;IACE,EAAE,EAAE,IAAI,CAAC;IACT;;;;;;;;OAQG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;;;;;;;OAaG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC;;;;;;;;;;;;OAYG;IACH,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;IACjE;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC,CAAC;CAC/E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EACvD,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,OAAO,UAAQ,GACd,WAAW,CAYb;AA2ID;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAQD,gKAAgK;AAChK,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,mBAAmB,CAAC,CAEnE;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAsTD,oDAAoD;AACpD,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;yEAGqE;IACrE,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC;CACjC;AAED,4FAA4F;AAC5F,UAAU,sBAAsB;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC;CACjC;AA66BD;;;;;;;;;;GAUG;AACH,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAC1B;;;;;;;;;;;;;OAaG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;IACnC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IACtD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;CACxF;AA+KD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB,GAAG,MAAM,GAAG,SAAS,CA0D3G;AA4pDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,cAAc,CAAC,CAEzB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAwCzG;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GACrD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAoCtB"}
+{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"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"}

package/dist/fold/fold.d.ts

@@ -121,6 +121,16 @@ export type FoldedValue = string | number | boolean | null | undefined | FoldedV
  * invented shape: it's the existing envelope, produced without running the
  * module that would otherwise construct the real `AttrRef`.
  */
+/**
+ * Which symbolic envelope a folded value is, in words a message can use — or
+ * `undefined` for a value that has an honest string form.
+ *
+ * These are the shapes `fold()` produces for things the build resolves later:
+ * a resource attribute, a lexicon intrinsic in either of its two forms, and a
+ * registered authoring helper. None of them can be concatenated into a string
+ * here, because what they stand for is not known until the build runs.
+ */
+export declare function symbolicEnvelopeKind(value: unknown): string | undefined;
 export interface AttrRefValue {
     __attrRef: {
         entity: string;

package/dist/fold/fold.d.ts.map

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

package/dist/lint/rules/evl011-symbolic-in-template.d.ts

@@ -0,0 +1,3 @@
+import type { LintRule } from "../rule.js";
+export declare const evl011SymbolicInTemplateRule: LintRule;
+//# sourceMappingURL=evl011-symbolic-in-template.d.ts.map

package/dist/lint/rules/evl011-symbolic-in-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evl011-symbolic-in-template.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/evl011-symbolic-in-template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,SAAS,CAAC;AAwFrE,eAAO,MAAM,4BAA4B,EAAE,QAU1C,CAAC"}

package/dist/lint/rules/index.d.ts

@@ -21,6 +21,7 @@ export { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body.js";
 export { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings.js";
 export { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant.js";
 export { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform.js";
+export { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template.js";
 export { cor017CompositeNameMatchRule } from "./cor017-composite-name-match.js";
 export { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type.js";
 export { cor021EnvLiteralNameRule } from "./cor021-env-literal-name.js";

package/dist/lint/rules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AA2B7D;;GAEG;AACH,wBAAgB,aAAa,IAAI,QAAQ,EAAE,CA2B1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AA4B7D;;GAEG;AACH,wBAAgB,aAAa,IAAI,QAAQ,EAAE,CA4B1C"}

package/dist/op/activities/converge.d.ts

@@ -66,6 +66,16 @@ export declare const sanitizeOneLine: typeof sanitizeLedgerText;
  * The gate a gated `chant run` stopped at, read off its JSON result (#2119) —
  * pure, unit-tested directly rather than only through `dispatchOp`'s
  * subprocess plumbing. `undefined` when the output says nothing about a gate.
+ *
+ * Reads `gate.name`, matching a real `OpRunStatus`/`OpRunRecord`
+ * (`../runtime.ts`'s own `gate?: { name: string; since: string }`) — a gated
+ * run's record never carries a nested field literally named `gate`. Checking
+ * `gate.gate` instead (chant#2396) is `typeof undefined === "string"`, always
+ * false, so every gated dispatch fell through to the regex below, which also
+ * never matches a `--json` result: the phrase it looks for belongs to the
+ * human-readable render `--json` mode suppresses. The regex stays as the
+ * fallback for exactly that human-mode case, where the caller's output is
+ * prose rather than JSON.
  */
 export declare function classifyDispatchFailure(raw: string): {
     gateName: string;

package/dist/op/activities/converge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converge.d.ts","sourceRoot":"","sources":["../../../src/op/activities/converge.ts"],"names":[],"mappings":"AAkCA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEzE,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAKL,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,iCAAiC,CAAC;AAQzC,+JAA+J;AAC/J,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC,eAAe,CAAC,CAAC;AAEnE,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IACxC,mHAAmH;IACnH,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,gIAAgI;IAChI,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;CACb;AAMD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,2BAAqB,CAAC;AA0BlD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAerF;AA0CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAKtH;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,SAAS,EAAE,WAAW,GAAG,SAAS,GACjC,mBAAmB,CAWrB;AAaD;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,sBAAsB,EAAE,EAC/B,YAAY,EAAE,kBAAkB,EAAE,EAClC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,gBAAgB,CAmDlB;AAoBD,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyF5G"}
+{"version":3,"file":"converge.d.ts","sourceRoot":"","sources":["../../../src/op/activities/converge.ts"],"names":[],"mappings":"AAkCA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEzE,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAKL,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,iCAAiC,CAAC;AAQzC,+JAA+J;AAC/J,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC,eAAe,CAAC,CAAC;AAEnE,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IACxC,mHAAmH;IACnH,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,gIAAgI;IAChI,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;CACb;AAMD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,2BAAqB,CAAC;AA0BlD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAerF;AA0CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAKtH;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,SAAS,EAAE,WAAW,GAAG,SAAS,GACjC,mBAAmB,CAWrB;AAaD;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,sBAAsB,EAAE,EAC/B,YAAY,EAAE,kBAAkB,EAAE,EAClC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,gBAAgB,CAmDlB;AAoBD,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyF5G"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.67.0",
+  "version": "0.68.1",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/attrref.test.ts

@@ -146,3 +146,34 @@ describe("AttrRef", () => {
     });
   });
 });
+
+describe("stringification is refused (#2349)", () => {
+  test("a template literal throws instead of yielding \"[object Object]\"", () => {
+    const ref = new AttrRef({}, "arn");
+    expect(() => `${ref}`).toThrow(/no string form/);
+  });
+
+  test("concatenation takes the same path, not a different one to the same wrong string", () => {
+    const ref = new AttrRef({}, "arn");
+    expect(() => "prefix-" + (ref as unknown as string)).toThrow(/no string form/);
+  });
+
+  test("the message names the attribute and points at the remedy", () => {
+    const ref = new AttrRef({}, "arn");
+    ref._setLogicalName("Bucket");
+    try {
+      `${ref}`;
+      throw new Error("expected a refusal");
+    } catch (e) {
+      const m = (e as Error).message;
+      expect(m).toContain("Bucket.arn");
+      expect(m).toMatch(/Sub|intrinsic/);
+    }
+  });
+
+  test("toJSON is untouched — a serializer that wants the envelope asks by name", () => {
+    const ref = new AttrRef({}, "arn");
+    ref._setLogicalName("Bucket");
+    expect(ref.toJSON()).toEqual({ __attrRef: { entity: "Bucket", attribute: "arn" } });
+  });
+});

package/src/attrref.ts

@@ -31,6 +31,39 @@ export class AttrRef implements Intrinsic {
     return this.logicalName;
   }
 
+  /**
+   * Refuse to become a string (#2349).
+   *
+   * An `AttrRef` stands for a value the build resolves later, so it has no
+   * string form here. Without this, `` `${bucket.arn}-suffix` `` produced
+   * `"[object Object]-suffix"` and shipped it — and the fold path produced
+   * exactly the same wrong string from the `{__attrRef}` envelope, so the two
+   * paths agreed and the differential harness reported nothing. Agreement on a
+   * wrong value is the failure this class of check exists to catch, which is
+   * why this throws rather than returning something more helpful-looking.
+   *
+   * `toJSON` below is the honest serialization and is untouched: a serializer
+   * that wants the envelope asks for it by name.
+   */
+  toString(): never {
+    const where = this.logicalName ? `${this.logicalName}.${this.attribute}` : `.${this.attribute}`;
+    throw new Error(
+      `A resource attribute reference (${where}) has no string form: it stands for a value the build ` +
+        "resolves later, and interpolating it into a plain template literal would produce " +
+        '"[object Object]". Use the lexicon\'s own intrinsic, whose interior handles references — ' +
+        "`Sub`${…}`` for CloudFormation — or move the reference out of the template.",
+    );
+  }
+
+  /**
+   * The same refusal for `+` and for anything else that coerces, so
+   * `"prefix" + bucket.arn` fails where `` `${bucket.arn}` `` fails rather
+   * than taking a different path to the same wrong string.
+   */
+  [Symbol.toPrimitive](): never {
+    return this.toString();
+  }
+
   /**
    * Serialize to a generic envelope. Lexicon-specific serializers should
    * read `getLogicalName()` and `attribute` directly instead of relying

package/src/discovery/fold-composite.test.ts

@@ -197,6 +197,76 @@ describe("composite factory interpretation (chant #1023)", () => {
     expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
   });
 
+
+  // ───────────────────────────────────────────────────────────────────────
+  // The interpretation depth bound (#2370).
+  // ───────────────────────────────────────────────────────────────────────
+
+  /**
+   * A chain of composites each calling the next, `depth` links long, across
+   * separate modules so every link is a fresh `resolveInterpretableFactory`.
+   * Link 0 is the one `main.ts` calls; the last link builds a real resource.
+   */
+  async function writeChain(depth: number): Promise<void> {
+    for (let i = 0; i < depth; i++) {
+      const isLast = i === depth - 1;
+      const body = isLast
+        ? `(props) => ({ bucket: new Bucket({ BucketName: props.name }) })`
+        : `(props) => ({ inner: Link${i + 1}({ name: props.name }) })`;
+      await writeFile(
+        join(testDir, `link${i}.ts`),
+        `
+          import { Bucket } from ${JSON.stringify(LEXICON)};
+          import { Composite } from ${JSON.stringify(compositePath)};
+          ${isLast ? "" : `import { Link${i + 1} } from "./link${i + 1}";`}
+          export const Link${i} = Composite(${body}, "Link${i}");
+        `,
+      );
+    }
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `
+        import { Link0 } from ${JSON.stringify(join(testDir, "link0"))};
+        export const top = Link0({ name: "deep" });
+      `,
+    );
+  }
+
+  test("a chain within the bound interprets all the way down", async () => {
+    // The control. Without this, a test asserting the deep chain falls back
+    // proves only that something went wrong somewhere.
+    await writeChain(4);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 4, projectFactoryInvocations: 0 });
+  });
+
+  test("exhausting the bound falls the file back to run, naming the bound", async () => {
+    // 17 links against a bound of 16. Before #2370 this returned the "not
+    // interpretable" answer, so the factory was invoked and the file was
+    // still reported folded — a different evaluation than the one reported,
+    // with nothing in the output saying so.
+    await writeChain(17);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    const decision = result.foldDecisions.find((d) => d.file.endsWith("main.ts"));
+    expect(decision?.mode).toBe("run");
+    expect(decision?.reason).toMatch(/interpretation depth exceeded 16/);
+    // The remedy half of the message: what a reader should suspect.
+    expect(decision?.reason).toMatch(/recursive/);
+    // Falling back means the estate is still built, by the other path. F-Depth
+    // asks for a fallback, not a failure.
+    expect(result.errors).toEqual([]);
+    // And it is a fallback rather than a degradation: the factory was not
+    // invoked instead. Before #2370 this read `projectFactoryInvocations: 1`
+    // with the file still reported folded.
+    expect(foldExecutionCounts()).toMatchObject({ projectFactoryInvocations: 0, factoryInvocations: 0 });
+  });
+
   test("a sibling reference inside the body is a LIVE AttrRef on the real instance", async () => {
     await writeComposite(ADMISSIBLE_BODY);
     await writeMain(CALL_WEBAPP);

package/src/discovery/fold-import.ts

@@ -1769,9 +1769,39 @@ async function resolveCallArguments(
  * inside one module's source, crossing no file boundary — so this is what
  * terminates it. Deliberately small: real composite nesting is 2-3 deep, and a
  * chain past this is a bug, not a design.
+ *
+ * Exhausting it falls the file back to run, naming this bound (#2370). That is
+ * the second half of the specification's `F-Depth`: an implementation states
+ * its bounds and, on exhaustion, falls back rather than fails. The other two —
+ * {@link MAX_RESOLUTION_DEPTH} and `fold()`'s `MAX_FUNCTION_CALL_DEPTH` —
+ * already did.
+ *
+ * It previously returned `undefined` here, which
+ * {@link resolveInterpretableFactory}'s contract defines as "not
+ * interpretable", so the caller invoked the factory instead and the file was
+ * still reported as folded. That conflated two different facts: a factory
+ * whose shape is outside the subset (invoking it is correct) and a factory we
+ * stopped looking at (invoking it is a different evaluation than the one being
+ * reported). The first is a verdict; the second was a silent degradation, and
+ * a reader comparing chant's output against the reference implementation's
+ * "fell back at depth 16" had nothing to explain the difference.
  */
 const MAX_INTERPRETATION_DEPTH = 16;
 
+/**
+ * Exhaustion of {@link MAX_INTERPRETATION_DEPTH}, as its own type so it can
+ * pass through {@link interpretCompositeFactory}'s decline.
+ *
+ * That decline — a blanket `catch { return undefined }` — is right for every
+ * other failure inside a factory body: the body turned out not to interpret,
+ * the caller invokes it instead, and the file still folds. It is wrong for
+ * this one, because giving up at a depth bound is not a statement about the
+ * body. Without a type to test, the depth error was caught by the *enclosing*
+ * interpretation, declined, and the factory invoked — which is how the bound
+ * came to be silent (#2370).
+ */
+class InterpretationDepthError extends FoldError {}
+
 /**
  * The static scope of a module that DEFINES composites — everything
  * interpreting one of its factory bodies needs, computed once per module per
@@ -1969,7 +1999,18 @@ async function resolveInterpretableFactory(
   // Rule 1 — project files only. A text check; no resolution performed for a
   // bare specifier, so this costs nothing for the (common) lexicon case.
   if (!isProjectFileSpecifier(binding.specifier)) return undefined;
-  if (ctx.interpretDepth >= MAX_INTERPRETATION_DEPTH) return undefined;
+  // Not `undefined`: that answer means "not interpretable" and would invoke
+  // the factory while still reporting the file folded. Giving up is a
+  // different fact and falls the file back to run, naming the bound (#2370).
+  if (ctx.interpretDepth >= MAX_INTERPRETATION_DEPTH) {
+    throw new InterpretationDepthError(
+      `interpretation depth exceeded ${MAX_INTERPRETATION_DEPTH} at "${binding.imported}" — a composite ` +
+        "chain this deep is almost certainly recursive. Falling back to run rather than invoking the " +
+        "factory, which would have reported this file as folded while evaluating it a different way.",
+      0,
+      0,
+    );
+  }
 
   let modulePath: string;
   try {
@@ -2346,7 +2387,12 @@ async function interpretCompositeFactory(
     const instance = definition();
     executionCounts.factoryInterpretations += 1;
     return { value: instance };
-  } catch {
+  } catch (err) {
+    // Every other failure here means "this body did not interpret" and the
+    // caller invokes instead. Exhausting the depth bound means "we stopped
+    // looking", which has to reach the file's fold verdict rather than be
+    // answered with an invocation (#2370).
+    if (err instanceof InterpretationDepthError) throw err;
     return undefined;
   }
 }

package/src/fold/fold.test.ts

@@ -66,6 +66,59 @@ describe("fold — template interpolation", () => {
   });
 });
 
+describe("fold — a symbolic value in a plain template (#2349)", () => {
+  // The bug this replaces: both paths produced "[object Object]" and agreed,
+  // so the differential harness — the thing that catches everything else —
+  // saw agreement and said nothing.
+  test("an attribute reference is refused, located, and names the entity", () => {
+    const src = `
+      const bucket = new S3Bucket({ name: "my-bucket" });
+      const x = \`\${bucket.arn}-suffix\`;
+    `;
+    expect(() => foldConst(src, "x")).toThrow(FoldError);
+    try {
+      foldConst(src, "x");
+    } catch (e) {
+      const err = e as FoldError;
+      expect(err.message).toContain("bucket.arn");
+      expect(err.message).toContain("[object Object]");
+      // The remedy, not just the complaint.
+      expect(err.message).toMatch(/Sub|intrinsic/);
+      // Located on the span, so an editor can point at it.
+      expect(err.line).toBeGreaterThan(0);
+      expect(err.column).toBeGreaterThan(0);
+    }
+  });
+
+  test("the run path refuses the same program rather than producing the wrong string", () => {
+    // The other half of #2349: a file that falls back to run must not quietly
+    // succeed where fold refused. `AttrRef.toString` throws, so the two paths
+    // now refuse together instead of agreeing on a wrong value.
+    const Bucket = createResource("S3Bucket", "aws", { arn: "arn" });
+    const bucket = new Bucket({ name: "my-bucket" }) as unknown as Declarable & { arn: AttrRef };
+    expect(() => `${bucket.arn}-suffix`).toThrow(/no string form/);
+    expect(() => "prefix" + (bucket.arn as unknown as string)).toThrow(/no string form/);
+  });
+
+  test("an ordinary value in a template still interpolates", () => {
+    const src = `
+      const region = "us-east-1";
+      const x = \`bucket-\${region}\`;
+    `;
+    expect(foldConst(src, "x")).toBe("bucket-us-east-1");
+  });
+
+  test("a tagged template is untouched — that is the documented idiom", () => {
+    // The refusal is about *plain* templates. The intrinsic form handles
+    // envelopes in its interior and must keep doing so.
+    const src = `
+      const bucket = new S3Bucket({ name: "my-bucket" });
+      const x = Sub\`\${bucket.arn}-suffix\`;
+    `;
+    expect(() => foldConst(src, "x")).not.toThrow(/no string form/);
+  });
+});
+
 describe("fold — objects and spread", () => {
   test("object literal with property and shorthand assignment", () => {
     const src = `

package/src/fold/fold.ts

@@ -151,6 +151,31 @@ export type FoldedValue =
  * invented shape: it's the existing envelope, produced without running the
  * module that would otherwise construct the real `AttrRef`.
  */
+/**
+ * Which symbolic envelope a folded value is, in words a message can use — or
+ * `undefined` for a value that has an honest string form.
+ *
+ * These are the shapes `fold()` produces for things the build resolves later:
+ * a resource attribute, a lexicon intrinsic in either of its two forms, and a
+ * registered authoring helper. None of them can be concatenated into a string
+ * here, because what they stand for is not known until the build runs.
+ */
+export function symbolicEnvelopeKind(value: unknown): string | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const v = value as Record<string, unknown>;
+  if ("__attrRef" in v) {
+    const ref = v.__attrRef as { entity?: unknown; attribute?: unknown } | undefined;
+    const named =
+      typeof ref?.entity === "string" && typeof ref?.attribute === "string"
+        ? ` (${ref.entity}.${ref.attribute})`
+        : "";
+    return `a resource attribute reference${named}`;
+  }
+  if ("__intrinsic" in v && typeof v.__intrinsic === "string") return `the intrinsic \`${v.__intrinsic}\``;
+  if ("__helper" in v && typeof v.__helper === "string") return `the helper \`${v.__helper}\``;
+  return undefined;
+}
+
 export interface AttrRefValue {
   __attrRef: { entity: string; attribute: string };
 }
@@ -1028,7 +1053,24 @@ export function fold(
   if (ts.isTemplateExpression(node)) {
     let out = node.head.text;
     for (const span of node.templateSpans) {
-      out += String(fold(span.expression, consts, intrinsics, externals)) + span.literal.text;
+      const value = fold(span.expression, consts, intrinsics, externals);
+      // A symbolic envelope has no string form. `String({__attrRef: …})` is
+      // `"[object Object]"`, and so is `String(attrRef)` on the run path,
+      // because `../attrref.ts` defines no `toString` — so the two paths
+      // agreed on a wrong answer and the differential saw nothing (#2349).
+      // Refused here rather than stringified, for the same reason the
+      // eager-intrinsic branch refuses a deferred envelope (#1966).
+      const symbolic = symbolicEnvelopeKind(value);
+      if (symbolic) {
+        throw foldError(
+          span.expression,
+          `${symbolic} interpolated into a plain template literal, which would stringify it as ` +
+            '"[object Object]". A symbolic value has no string form until the build resolves it, so a ' +
+            "plain template cannot carry one. Use the lexicon's own intrinsic, whose interior handles " +
+            "envelopes — `Sub`${…}`` for CloudFormation — or move the reference out of the template.",
+        );
+      }
+      out += String(value) + span.literal.text;
     }
     return out;
   }

package/src/lint/rules/evl011-symbolic-in-template.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, expect } from "vitest";
+import * as ts from "typescript";
+import { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
+import type { LintContext } from "../rule";
+
+function createContext(code: string, filePath = "test.ts"): LintContext {
+  const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+  return { sourceFile, entities: [], filePath, lexicon: undefined };
+}
+
+describe("EVL011: a symbolic reference in a plain template", () => {
+  test("rule metadata", () => {
+    expect(evl011SymbolicInTemplateRule.id).toBe("EVL011");
+    expect(evl011SymbolicInTemplateRule.severity).toBe("error");
+    expect(evl011SymbolicInTemplateRule.category).toBe("correctness");
+  });
+
+  test("flags a resource attribute in a plain template, at the reference", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = \`\${bucket.arn}-suffix\`;
+    `);
+    const found = evl011SymbolicInTemplateRule.check(ctx);
+    expect(found).toHaveLength(1);
+    expect(found[0].ruleId).toBe("EVL011");
+    expect(found[0].message).toContain("bucket.arn");
+    // The remedy, not just the complaint — the whole reason this rule exists
+    // alongside a refusal that already fails the build.
+    expect(found[0].message).toMatch(/Sub|intrinsic/);
+    expect(found[0].line).toBe(3);
+  });
+
+  test("flags every offending span, not just the first", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const queue = new Queue({ name: "q" });
+      const x = \`\${bucket.arn}/\${queue.url}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(2);
+  });
+
+  test("allows a tagged template — that is the documented remedy", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = Sub\`\${bucket.arn}-suffix\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows an ordinary const in a template", () => {
+    const ctx = createContext(`
+      const region = "us-east-1";
+      const x = \`bucket-\${region}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows a property access on something that is not a resource", () => {
+    // The false positive worth avoiding: this code works, and flagging it
+    // would train people to suppress the rule.
+    const ctx = createContext(`
+      const config = { region: "us-east-1" };
+      const x = \`bucket-\${config.region}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("says nothing about a reference outside a template", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = bucket.arn;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("a missed shape is a cost the refusal already covers", () => {
+    // Reached through an array rather than a plain identifier: lint sees
+    // syntax, not values, so this is not flagged — and `fold()` still refuses
+    // it (#2349). Documented as a deliberate limit rather than left to be
+    // discovered as a gap.
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const all = [bucket];
+      const x = \`\${all[0].arn}-suffix\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+});

package/src/lint/rules/evl011-symbolic-in-template.ts

@@ -0,0 +1,100 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL011: a symbolic reference inside a plain template literal
+ *
+ * `` `${bucket.arn}-suffix` `` cannot be evaluated to a string. A resource
+ * attribute stands for a value the build resolves later, so there is nothing
+ * to interpolate yet, and JavaScript's answer — `"[object Object]"` — is
+ * wrong on both of chant's paths.
+ *
+ * This rule is the friendly half of #2349. The unfriendly half already landed:
+ * `fold()` refuses the span with a located error and `AttrRef.toString` throws,
+ * so the program fails either way. What a rule adds is finding it at lint time
+ * with the remedy attached, rather than at build time with a stack.
+ *
+ * ## Why it is a heuristic, and why that is acceptable here
+ *
+ * Lint sees syntax, not values. `foo.bar` inside a template is a resource
+ * attribute only if `foo` is a resource, which is a fact `fold()` has and this
+ * rule does not — so the check is: a property access whose object is a
+ * plain identifier bound in this file by `new`. That is the shape #2349 was
+ * reported against and the shape a lexicon's own docs show.
+ *
+ * It therefore misses a reference reached some other way (through a parameter,
+ * an array, a helper's return) and does not flag an access on a plain object.
+ * Missing a case costs nothing, because `fold()` still refuses it; flagging a
+ * plain object would be a false positive on code that works, which is the
+ * error worth avoiding. This is the same asymmetry `../../fold/subset.ts`
+ * documents for EVL generally, pointed the other way: there EVL may be
+ * stricter than fold, here it is deliberately looser.
+ */
+
+/** Identifiers bound by `const x = new T(...)` at any depth in this file. */
+function resourceBindings(sourceFile: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isVariableDeclaration(node) &&
+      ts.isIdentifier(node.name) &&
+      node.initializer &&
+      ts.isNewExpression(node.initializer)
+    ) {
+      names.add(node.name.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return names;
+}
+
+function checkNode(
+  node: ts.Node,
+  context: LintContext,
+  bound: Set<string>,
+  diagnostics: LintDiagnostic[],
+): void {
+  // Untagged only: a tagged template is the documented remedy, and its
+  // interior handles envelopes.
+  if (ts.isTemplateExpression(node) && !ts.isTaggedTemplateExpression(node.parent)) {
+    for (const span of node.templateSpans) {
+      const expr = span.expression;
+      if (
+        ts.isPropertyAccessExpression(expr) &&
+        ts.isIdentifier(expr.expression) &&
+        bound.has(expr.expression.text)
+      ) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          expr.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL011",
+          severity: "error",
+          message:
+            `\`${expr.expression.text}.${expr.name.text}\` is a resource attribute and has no string ` +
+            "form until the build resolves it — a plain template would stringify it as " +
+            "\"[object Object]\". Use the lexicon's own intrinsic, whose interior handles references " +
+            "(`Sub`${…}`` for CloudFormation), or move the reference out of the template.",
+        });
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, bound, diagnostics));
+}
+
+export const evl011SymbolicInTemplateRule: LintRule = {
+  id: "EVL011",
+  severity: "error",
+  category: "correctness",
+  description: "A resource attribute cannot be interpolated into a plain template literal",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, resourceBindings(context.sourceFile), diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/index.ts

@@ -23,6 +23,7 @@ export { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
 export { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
 export { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 export { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
+export { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
 export { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 export { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 export { cor021EnvLiteralNameRule } from "./cor021-env-literal-name";
@@ -49,6 +50,7 @@ import { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
 import { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
 import { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 import { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
+import { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
 import { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 import { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 import { cor021EnvLiteralNameRule } from "./cor021-env-literal-name";
@@ -79,6 +81,7 @@ export function loadCoreRules(): LintRule[] {
     evl007InvalidSiblingsRule,
     evl009CompositeNoConstantRule,
     evl010CompositeNoTransformRule,
+    evl011SymbolicInTemplateRule,
     cor017CompositeNameMatchRule,
     cor018CompositePreferLexiconTypeRule,
     cor021EnvLiteralNameRule,

package/src/op/activities/converge.test.ts

@@ -307,12 +307,38 @@ describe("classifyDispatchFailure", () => {
     const raw = JSON.stringify({
       op: "fountain-apply",
       status: "gated",
-      gate: { version: 1, kind: "pending", op: "fountain-apply", gate: "rollout-gate", timestamp: "t", expiresAt: "t2" },
+      gate: { name: "rollout-gate", since: "t2" },
       records: [],
     });
     expect(classifyDispatchFailure(raw)).toEqual({ gateName: "rollout-gate" });
   });
 
+  // chant#2396: a real gated `OpRunRecord` (`../runtime.ts`'s own
+  // `gate?: { name: string; since: string }`) never carries a nested field
+  // literally named `gate` — `parsed.gate?.gate` is always `undefined`, so
+  // this used to fall through to a regex that never matches `--json` output
+  // either, and a `ConvergeOp` tick recorded every gated dispatch as an
+  // ordinary "reported" failure. This is the exact record shape
+  // `TerraformApplyOp`'s own `chant run dev-apply --json` printed while
+  // building `examples/converge-operator` against a live floci.
+  test("reads the gate off a real gated Op run record — gate.name, not gate.gate (#2396)", () => {
+    const raw = JSON.stringify({
+      version: 1,
+      id: "local-abc123",
+      op: "dev-apply",
+      env: "dev",
+      started: "2026-09-11T05:39:16.000Z",
+      ended: "2026-09-11T05:39:16.058Z",
+      status: "gated",
+      labels: {},
+      outcomes: {},
+      phases: [],
+      gate: { name: "approve-dev-apply", since: "2026-09-11T05:39:16.058Z" },
+      approve: "chant approve dev-apply approve-dev-apply",
+    });
+    expect(classifyDispatchFailure(raw)).toEqual({ gateName: "approve-dev-apply" });
+  });
+
   test("falls back to the human summary line, wherever it appears in the output", () => {
     const raw = 'some earlier noise\nOp "prod-apply" is gated on "prod-approval" after 0.3s\n  approve : chant approve prod-apply prod-approval';
     expect(classifyDispatchFailure(raw)).toEqual({ gateName: "prod-approval" });

package/src/op/activities/converge.ts

@@ -153,15 +153,25 @@ const GATED_EXIT_CODE = 3;
  * The gate a gated `chant run` stopped at, read off its JSON result (#2119) —
  * pure, unit-tested directly rather than only through `dispatchOp`'s
  * subprocess plumbing. `undefined` when the output says nothing about a gate.
+ *
+ * Reads `gate.name`, matching a real `OpRunStatus`/`OpRunRecord`
+ * (`../runtime.ts`'s own `gate?: { name: string; since: string }`) — a gated
+ * run's record never carries a nested field literally named `gate`. Checking
+ * `gate.gate` instead (chant#2396) is `typeof undefined === "string"`, always
+ * false, so every gated dispatch fell through to the regex below, which also
+ * never matches a `--json` result: the phrase it looks for belongs to the
+ * human-readable render `--json` mode suppresses. The regex stays as the
+ * fallback for exactly that human-mode case, where the caller's output is
+ * prose rather than JSON.
  */
 export function classifyDispatchFailure(raw: string): { gateName: string } | undefined {
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("{")) continue;
     try {
-      const parsed = JSON.parse(trimmed) as { status?: string; gate?: { gate?: string } };
-      if (parsed.status === "gated" && typeof parsed.gate?.gate === "string") {
-        return { gateName: parsed.gate.gate };
+      const parsed = JSON.parse(trimmed) as { status?: string; gate?: { name?: string } };
+      if (parsed.status === "gated" && typeof parsed.gate?.name === "string") {
+        return { gateName: parsed.gate.name };
       }
     } catch {
       // Not this line's JSON — keep looking.