@intentius/chant 0.23.0 → 0.24.0

package/dist/cli/commands/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAoB/C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,2JAA2J;IAC3J,WAAW,CAAC,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;CACjE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAgV9E;AAiDD;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAIlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAItD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACxC,MAAM,IAAI,CAmCZ"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAoB/C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,2JAA2J;IAC3J,WAAW,CAAC,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;CACjE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAuW9E;AAiDD;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAIlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAItD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACxC,MAAM,IAAI,CAmCZ"}

package/dist/cli/handlers/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/build.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA2ElD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6EnE"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/build.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAgFlD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6EnE"}

package/dist/cli/handlers/run.d.ts

@@ -32,6 +32,14 @@ export declare function runOpCancel(ctx: CommandContext): Promise<number>;
  * (`../../components/driver.ts`) rather than a `*.op.ts` Op. Checked first,
  * mirroring `runGraph`'s `if (ctx.args.components) return
  * runComponentGraph(ctx)` branch (../handlers/graph.ts).
+ *
+ * chant #1116 — `--report` with `--components` is checked and hard-errored
+ * before that dispatch. There is no preview/dry-run mode for the component
+ * driver: unlike the Op path (where `--report` reads a past Temporal run),
+ * `runOpComponents` has never read `ctx.args.report` at all, so the flag was
+ * silently ignored and the command fell through to a real dispatch — observed
+ * live reaching an actual cloud shell-out. Erroring here is the safe minimum
+ * called out on the issue; a real preview is future work.
  */
 export declare function runOp(ctx: CommandContext): Promise<number>;
 /**

package/dist/cli/handlers/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/run.ts"],"names":[],"mappings":"AAIA,OAAO,EAA+C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAO7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA4ClD,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM;;;;GAO5F;AA8BD,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEpE;AAoFD,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAuCtE;AA0CD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CnE;AA2DD;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkCtE;AAID,2LAA2L;AAC3L,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BtE;AAmCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAchE;AA6ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsF1E;AA+OD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiFrE;AAuLD,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAMjE"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/run.ts"],"names":[],"mappings":"AAIA,OAAO,EAA+C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAO7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA4ClD,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM;;;;GAO5F;AA8BD,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEpE;AAoFD,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAuCtE;AA0CD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CnE;AA2DD;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkCtE;AAID,2LAA2L;AAC3L,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BtE;AAmCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqBhE;AA6ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsF1E;AA+OD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiFrE;AAuLD,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAMjE"}

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAsB9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAqNpD;AAsZD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAsB9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA+NpD;AA0ZD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}

package/dist/cli/plugins.d.ts

@@ -32,6 +32,14 @@ export declare function loadPlugins(lexiconNames: string[]): Promise<LexiconPlug
  * that never needed live module exports to begin with. This is strictly
  * better than routing the detection through the sandbox: it removes the
  * execution entirely rather than containing it, at no bundling/spawn cost.
+ *
+ * chant #1117 — walks up from `projectPath` to the project root
+ * (`loadChantConfigUpward`) rather than reading `projectPath` alone: `chant
+ * build src/<stack>` calls this with the stack's own subdirectory, and a
+ * project that declares `lexicons` only in its root `chant.config.ts` (never
+ * detectable by `detectLexicons()`'s import scan alone, e.g. a lexicon that's
+ * loaded but never imported by name in that particular stack's files) would
+ * otherwise silently miss it.
  */
 export declare function resolveProjectLexicons(projectPath: string): Promise<string[]>;
 //# sourceMappingURL=plugins.d.ts.map

package/dist/cli/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/cli/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAKjE;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA6B5E;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA6BlF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnF"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/cli/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAKjE;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA6B5E;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA6BlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnF"}

package/dist/config.d.ts

@@ -280,6 +280,24 @@ export declare const DEFAULT_CHANT_CONFIG: ChantConfig;
  * Returns default config if neither exists.
  */
 export declare function loadChantConfig(dir: string): Promise<ResolvedConfig>;
+/**
+ * Load project configuration by walking up from `startDir` to the project
+ * root (chant #1117), instead of trying only `startDir` itself.
+ *
+ * `chant build src/<stack>` (and anything else invoked with a subdirectory —
+ * `lint.policies`' `evaluateProjectPolicies`, `--components --generate`)
+ * builds scoped to that subdirectory, but `chant.config.ts` almost always
+ * lives at the project root, one or more levels up. Before this, callers
+ * either read `startDir` alone or bolted on a single `dirname()` fallback —
+ * fine for a one-level-deep stack, silently blind to anything deeper
+ * (loomster's `src/<stack>` layout is exactly one level too deep: `buildParams`'
+ * declared `env:` mappings never resolved, so `LOOM_TIER`/`LOOM_ENV` were inert
+ * under every `npm run synth:*` for two releases — loomster#162). Uses the
+ * same walk `chant lint`/`chant graph` already used ({@link findProjectConfig},
+ * shared with `./lint/config.ts`'s `findProjectRoot`) — one config-discovery
+ * contract for the whole CLI.
+ */
+export declare function loadChantConfigUpward(startDir: string): Promise<ResolvedConfig>;
 /**
  * Resolve the ownership marker to stamp from project config, or undefined when
  * ownership marking is off (no `stack`, or `enabled: false`).

package/dist/config.d.ts.map

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

package/dist/lint/config.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { Severity, RuleConfig } from "./rule.js";
+export { findProjectRoot } from "../project-root.js";
 export declare const LintConfigSchema: z.ZodObject<{
     rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
         error: "error";
@@ -75,18 +76,6 @@ export declare function parseRuleConfig(value: RuleConfig): ParsedRuleConfig;
  * Default configuration with all rules enabled at strict preset severities
  */
 export declare const DEFAULT_CONFIG: LintConfig;
-/**
- * Walk up from `startDir` to the nearest ancestor holding a chant project
- * config (`chant.config.ts` or `chant.config.json`). Returns that directory, or
- * `startDir` unchanged when none is found before the filesystem root.
- *
- * Linting a subpath (`chant graph src --format ir`, `chant lint src/lib`) must
- * still see the project-root config: its `lint.overrides` globs are written
- * project-root-relative (`src/lib/**`), and a rule set scoped only to the lint
- * arg would silently drop them. Config discovery therefore anchors on the
- * project root, not the path being linted.
- */
-export declare function findProjectRoot(startDir: string): string;
 /**
  * Load lint configuration from a directory.
  *

package/dist/lint/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lint/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAmBnD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS3B,CAAC;AAkGH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gDAAgD;IAChD,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,CAsBnE;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAG5B,CAAC;AA0HF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAoClD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAkBpG"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lint/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AASnD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAiBlD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS3B,CAAC;AAkGH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gDAAgD;IAChD,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,CAsBnE;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAG5B,CAAC;AA0HF;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAoClD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAkBpG"}

package/dist/project-root.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared upward config-discovery walk (chant #1117).
+ *
+ * Before this, `chant build <subdir>` and `lint.policies`
+ * (`./lint/policy.ts`'s `evaluateProjectPolicies`) each searched only the
+ * build directory and its immediate parent for `chant.config.ts`/`.json`,
+ * while `chant lint`/`chant graph` (`./lint/config.ts`'s old, file-local
+ * `findProjectRoot`) already walked all the way up. A project with a deeper
+ * `src/<stack>` layout — `chant build src/<stack>` two or more levels below
+ * the project root — silently never found the root config: `buildParams`'
+ * declared `env:` mappings went inert, `ownership`/`lint.policies`/etc quietly
+ * fell back to defaults, and nothing warned (loomster#162: `LOOM_TIER`/
+ * `LOOM_ENV` inert under every `npm run synth:*` for two releases).
+ *
+ * `findProjectConfig` is the one walk every config-discovery call site now
+ * shares. It stops at the first of:
+ *
+ * 1. A directory holding `chant.config.ts` or `chant.config.json` — found.
+ * 2. A directory holding `.git` or `package.json` with no chant config of its
+ *    own — the project boundary. Discovery must never wander past the actual
+ *    project into an unrelated ancestor directory just because this project
+ *    happens not to declare a config (a stray `chant.config.ts` two levels
+ *    above an unrelated git repo must never be picked up).
+ * 3. `startDir` itself, unchanged, if the walk reaches the filesystem root
+ *    without ever finding a config OR a boundary marker. This is not just a
+ *    "give up gracefully" nicety — several callers (`resolveProjectLexicons`
+ *    -> `findInfraFiles`) scope a real directory walk off this function's
+ *    result; if a rootless/marker-less start dir (a bare tmpdir, as chant's
+ *    own test suites use) resolved all the way to `/`, that downstream walk
+ *    would scan the entire filesystem instead of failing fast. Falling back
+ *    to `startDir` keeps every caller's blast radius local no matter how far
+ *    up the walk had to look.
+ */
+export interface ProjectConfigSearch {
+    /** The resolved project root: the config's directory, the boundary directory, or the (resolved) `startDir` when neither was found. */
+    dir: string;
+    /** Absolute path to the discovered `chant.config.ts`/`.json`, if any. */
+    configPath?: string;
+}
+/** Walk up from `startDir` (inclusive) to the nearest chant config or project boundary. See {@link ProjectConfigSearch}. */
+export declare function findProjectConfig(startDir: string): ProjectConfigSearch;
+/**
+ * Walk up from `startDir` to the nearest ancestor holding a chant project
+ * config (`chant.config.ts` or `chant.config.json`), the `.git`/`package.json`
+ * project boundary, or `startDir` itself when neither is found. Thin wrapper
+ * over {@link findProjectConfig} for callers that only need the directory
+ * (e.g. `chant lint`'s rule/plugin resolution, which just needs *a* stable
+ * root to resolve relative paths against).
+ */
+export declare function findProjectRoot(startDir: string): string;
+//# sourceMappingURL=project-root.d.ts.map

package/dist/project-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root.d.ts","sourceRoot":"","sources":["../src/project-root.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,mBAAmB;IAClC,sIAAsI;IACtI,GAAG,EAAE,MAAM,CAAC;IACZ,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,4HAA4H;AAC5H,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAqBvE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/package.json

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

package/src/cli/commands/build.ts

@@ -1,5 +1,5 @@
 import { build } from "../../build";
-import { loadChantConfig, resolveOwnershipMarker, resolveFoldEnabled, resolveSandboxEnabled } from "../../config";
+import { loadChantConfigUpward, resolveOwnershipMarker, resolveFoldEnabled, resolveSandboxEnabled } from "../../config";
 import { resolveCliBuildParams } from "../build-params-cli";
 import type { Serializer, SerializerResult } from "../../serializer";
 import type { LexiconPlugin } from "../../lexicon";
@@ -128,11 +128,14 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   // Resolve the path
   const infraPath = resolve(options.path);
 
-  // Resolve opt-in ownership marking from project config (search the infra dir
-  // and its parent, where chant.config.* usually lives).
-  const loaded = await loadChantConfig(infraPath).then((r) =>
-    r.configPath ? r : loadChantConfig(dirname(infraPath)),
-  );
+  // Resolve opt-in ownership marking from project config. chant #1117 — walks
+  // up from the infra dir to the project root (`loadChantConfigUpward`), not
+  // just the infra dir's immediate parent: a project whose stacks live two or
+  // more levels below `chant.config.ts` (loomster's `src/<stack>` layout)
+  // otherwise never finds the root config at all, and every declared
+  // `buildParams`/`ownership`/`lint.policies` setting silently falls back to
+  // its default.
+  const loaded = await loadChantConfigUpward(infraPath);
   const config = loaded.config;
   const ownership = resolveOwnershipMarker(config);
 
@@ -174,6 +177,26 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
     return { success: false, resourceCount: 0, fileCount: 0, errors, warnings };
   }
 
+  // chant #1117 — a project that declares buildParams but resolves NONE of
+  // them for this build is the exact shape that let loomster#162 live for two
+  // releases: the discovered config wasn't the one the project author
+  // expected (a stale --path, a workspace boundary that stopped the walk
+  // short), or every declared parameter's `env:` var went unset, and either
+  // way every `params.<name>` read silently falls back to `undefined` — with
+  // no error (an all-`required: false` declaration resolves successfully to
+  // an empty set). Warn, naming the config path this build actually
+  // discovered, so a mismatch is visible instead of silent.
+  if (
+    Object.keys(config.buildParams ?? {}).length > 0 &&
+    paramsResolution.provenance.length === 0
+  ) {
+    warnings.push(
+      formatWarning({
+        message: `chant.config.ts declares buildParams${loaded.configPath ? ` (${loaded.configPath})` : ""}, but none resolved for this build — every params.<name> read will be undefined. Pass --param/--params-file, or check that this is the config you expect.`,
+      }),
+    );
+  }
+
   // #1039 — thread each loaded plugin's registered intrinsics (e.g. AWS's
   // `Sub`) through to the fold path, so a file using a registered intrinsic
   // tagged template folds instead of unconditionally falling back to run.

package/src/cli/handlers/build.test.ts

@@ -8,8 +8,10 @@
  * run --components` (see ../handlers/run.test.ts's "build-time parameters"
  * describe block for the equivalent local/`--temporal` coverage).
  *
- * Mocks `generateComponentsPipeline` and `loadChantConfig` and exercises the
- * public `runBuild` dispatcher (`runGenerateComponents` itself isn't
+ * Mocks `generateComponentsPipeline` and `loadChantConfigUpward` (chant
+ * #1117 — `runGenerateComponents` walks up to the project root now, same as
+ * `chant build` proper, instead of reading `args.path` alone) and exercises
+ * the public `runBuild` dispatcher (`runGenerateComponents` itself isn't
  * exported), mirroring `run.test.ts`'s style of driving the handler through
  * its `CommandContext` entrypoint rather than reaching into private helpers.
  */
@@ -17,14 +19,14 @@ import { describe, test, expect, vi, beforeEach } from "vitest";
 import type { ParsedArgs } from "../registry";
 
 const generateComponentsPipelineMock = vi.fn();
-const loadChantConfigMock = vi.fn();
+const loadChantConfigUpwardMock = vi.fn();
 
 vi.mock("../../components/cli-support", () => ({
   generateComponentsPipeline: (...args: unknown[]) => generateComponentsPipelineMock(...args),
 }));
 vi.mock("../../config", async () => {
   const actual = await vi.importActual<typeof import("../../config")>("../../config");
-  return { ...actual, loadChantConfig: (...args: unknown[]) => loadChantConfigMock(...args) };
+  return { ...actual, loadChantConfigUpward: (...args: unknown[]) => loadChantConfigUpwardMock(...args) };
 });
 
 const { runBuild } = await import("./build");
@@ -54,7 +56,7 @@ function makeStderrSpy() {
 describe("runBuild --components --generate (chant #1108 build-time parameters)", () => {
   beforeEach(() => {
     generateComponentsPipelineMock.mockReset();
-    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
+    loadChantConfigUpwardMock.mockReset().mockResolvedValue({ config: {} });
   });
 
   test("no declared buildParams → generateComponentsPipeline is called with an empty provenance array", async () => {
@@ -69,7 +71,7 @@ describe("runBuild --components --generate (chant #1108 build-time parameters)",
   });
 
   test("chant.config.ts's declared buildParams resolve, log, and are forwarded to generateComponentsPipeline", async () => {
-    loadChantConfigMock.mockResolvedValue({
+    loadChantConfigUpwardMock.mockResolvedValue({
       config: { buildParams: { tier: { type: "string", default: "light" } } },
     });
     generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
@@ -91,7 +93,7 @@ describe("runBuild --components --generate (chant #1108 build-time parameters)",
   });
 
   test("--param overrides a declared default", async () => {
-    loadChantConfigMock.mockResolvedValue({
+    loadChantConfigUpwardMock.mockResolvedValue({
       config: { buildParams: { tier: { type: "string", default: "light" } } },
     });
     generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
@@ -115,7 +117,7 @@ describe("runBuild --components --generate (chant #1108 build-time parameters)",
   });
 
   test("an unresolved required build-time parameter → exit 1, never reaches generateComponentsPipeline", async () => {
-    loadChantConfigMock.mockResolvedValue({
+    loadChantConfigUpwardMock.mockResolvedValue({
       config: { buildParams: { tier: { type: "string" } } },
     });
     const stderr = makeStderrSpy();
@@ -128,7 +130,7 @@ describe("runBuild --components --generate (chant #1108 build-time parameters)",
   });
 
   test("an enum violation on --param → exit 1, never reaches generateComponentsPipeline", async () => {
-    loadChantConfigMock.mockResolvedValue({
+    loadChantConfigUpwardMock.mockResolvedValue({
       config: { buildParams: { tier: { type: "string", enum: ["light", "production"] } } },
     });
     const stderr = makeStderrSpy();

package/src/cli/handlers/build.ts

@@ -4,7 +4,7 @@ import { buildCommand, buildCommandWatch, printErrors, printWarnings, resolveBui
 import { formatError, formatInfo, formatSuccess, formatBold } from "../format";
 import type { CommandContext } from "../registry";
 import { generateComponentsPipeline } from "../../components/cli-support";
-import { loadChantConfig, type ChantConfig } from "../../config";
+import { loadChantConfigUpward, type ChantConfig } from "../../config";
 import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
 
 /**
@@ -23,12 +23,17 @@ import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
  * Before this, `params.*` (`@intentius/chant/params`) was always `{}` under
  * this command too — generate mode shares `discoverComponents` with `chant
  * run --components`, so it had the identical gap.
+ *
+ * chant #1117 — loads config by walking up from `args.path` to the project
+ * root (`loadChantConfigUpward`), same as `chant build` proper, instead of
+ * `args.path` alone: a components-only project built from a subdirectory
+ * otherwise never sees the root `chant.config.ts`'s `buildParams` either.
  */
 async function runGenerateComponents(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
   const lexicon = args.generate as string;
 
-  const { config } = await loadChantConfig(resolve(args.path)).catch(() => ({ config: {} as ChantConfig }));
+  const { config } = await loadChantConfigUpward(resolve(args.path)).catch(() => ({ config: {} as ChantConfig }));
   const paramsResolution = resolveCliBuildParams(config.buildParams, {
     cli: parseParamFlags(args.param),
     paramsFile: args.paramsFile,

package/src/cli/handlers/run.test.ts

@@ -882,6 +882,37 @@ describe("runOp dispatcher: --components routes to runOpComponents", () => {
     expect(discoverOpsMock).not.toHaveBeenCalled();
     vi.restoreAllMocks();
   });
+
+  // chant #1116 — --report is Op/Temporal-only (reads a past workflow run);
+  // the component driver never checked it, so it was silently ignored and the
+  // command fell through to a real dispatch. Hard-error instead, before
+  // runComponents is ever reached.
+  test("--report combined with --components → exit 1 before any dispatch, no fall-through (#1116)", async () => {
+    discoverOpsMock.mockReset();
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "svc", components: true, report: true, temporal: false }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("not supported with --components");
+    expect(stderr.join("\n")).toContain("#1116");
+    expect(discoverOpsMock).not.toHaveBeenCalled();
+    expect(runComponentsMock).not.toHaveBeenCalled();
+  });
+
+  // Plain --components (no --report) must be unaffected: it still reaches a
+  // real dispatch through runComponents — mocked here, never a real cloud call.
+  test("plain --components (no --report) still dispatches to runComponents (#1116 regression guard)", async () => {
+    discoverOpsMock.mockReset();
+    runComponentsMock.mockResolvedValue({ success: true, selected: ["svc"], run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, records: [] }], ok: true } });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+    const exit = await runOp({ args: makeArgs({ path: "svc", components: true, report: false, temporal: false }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(runComponentsMock).toHaveBeenCalled();
+    vi.restoreAllMocks();
+  });
 });
 
 describe("runOpComponents", () => {

package/src/cli/handlers/run.ts

@@ -548,8 +548,23 @@ function renderProgress(opName: string, history: WorkflowHistoryRaw): void {
  * (`../../components/driver.ts`) rather than a `*.op.ts` Op. Checked first,
  * mirroring `runGraph`'s `if (ctx.args.components) return
  * runComponentGraph(ctx)` branch (../handlers/graph.ts).
+ *
+ * chant #1116 — `--report` with `--components` is checked and hard-errored
+ * before that dispatch. There is no preview/dry-run mode for the component
+ * driver: unlike the Op path (where `--report` reads a past Temporal run),
+ * `runOpComponents` has never read `ctx.args.report` at all, so the flag was
+ * silently ignored and the command fell through to a real dispatch — observed
+ * live reaching an actual cloud shell-out. Erroring here is the safe minimum
+ * called out on the issue; a real preview is future work.
  */
 export async function runOp(ctx: CommandContext): Promise<number> {
+  if (ctx.args.components && ctx.args.report) {
+    console.error(formatError({
+      message: "--report is not supported with --components",
+      hint: "No preview/dry-run mode exists yet for the component driver (see chant#1116). Omit --report.",
+    }));
+    return 1;
+  }
   if (ctx.args.components) return runOpComponents(ctx);
   if (ctx.args.local && ctx.args.temporal) {
     console.error(formatError({

package/src/cli/main.test.ts

@@ -270,6 +270,29 @@ describe("parseArgs", () => {
     const result = parseArgs(["build", "src", "--params-file", "./params.json"]);
     expect(result.paramsFile).toBe("./params.json");
   });
+
+  // ── --param=name=value hard error (chant #1118) ──────────────────────────
+  // The joined `--flag=value` form is not supported anywhere in this parser
+  // (see "ignores unknown flags" above) — a dropped --param can silently
+  // change what a build measures/deploys, so this form is rejected loudly
+  // instead of silently accepted as a no-op.
+
+  test("--param=name=value throws instead of silently dropping", () => {
+    expect(() => parseArgs(["build", "src", "--param=tier=production"])).toThrow(/--param=tier=production/);
+  });
+
+  test("--param=name=value error names the working form", () => {
+    expect(() => parseArgs(["build", "src", "--param=tier=production"])).toThrow(/--param name=value/);
+  });
+
+  test("--param= (empty value) also throws", () => {
+    expect(() => parseArgs(["build", "src", "--param="])).toThrow(/--param=/);
+  });
+
+  test("plain --param name=value is unaffected", () => {
+    const result = parseArgs(["build", "src", "--param", "tier=production"]);
+    expect(result.param).toEqual(["tier=production"]);
+  });
 });
 
 // ── resolveCommand tests ──────────────────────────────────────────

package/src/cli/main.ts

@@ -5,7 +5,7 @@ import { isEntryPoint } from "./is-entry-point";
 import { formatSuccess, formatError } from "./format";
 import { loadPlugins, resolveProjectLexicons } from "./plugins";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
-import { loadChantConfig } from "../config";
+import { loadChantConfigUpward } from "../config";
 import { ENV_VAR, unknownEnvError } from "../env";
 import { initRuntime } from "../runtime-adapter";
 import { runBuild } from "./handlers/build";
@@ -224,6 +224,16 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.sandbox = true;
     } else if (arg === "--param") {
       (result.param ??= []).push(args[++i]);
+    } else if (arg.startsWith("--param=")) {
+      // chant #1118 — this parser never supports an `--flag=value` joined
+      // form for any value-taking flag (every branch above is an exact `===`
+      // match, so a joined token falls through unrecognized and is silently
+      // dropped — see the "ignores unknown flags" case below). `--param
+      // name=value` (space-separated) is the only accepted form. Rather than
+      // teach the parser joined forms generally, `--param=name=value` is
+      // called out as a hard error instead of a silent no-op: a dropped
+      // `--param` can silently change what a build measures/deploys.
+      throw new Error(`${arg} is not supported. Use --param name=value (space-separated) instead.`);
     } else if (arg === "--params-file") {
       result.paramsFile = args[++i];
     } else if (!arg.startsWith("-")) {
@@ -588,11 +598,15 @@ async function main(): Promise<void> {
   // chant.config itself may branch on the env. (#505)
   if (args.env) process.env[ENV_VAR] = args.env;
 
-  // Initialize runtime adapter early — before plugins or commands run
+  // Initialize runtime adapter early — before plugins or commands run.
+  // chant #1117 — walks up from `args.path` to the project root: for a
+  // subdirectory build/command (`chant build src/<stack> --env prod`) the
+  // declared `environments` almost always live in the root `chant.config.ts`,
+  // not `args.path` itself.
   const projectPath0 = resolve(args.path === "." ? "." : args.path);
   let loadedConfig;
   try {
-    loadedConfig = await loadChantConfig(projectPath0);
+    loadedConfig = await loadChantConfigUpward(projectPath0);
     initRuntime();
   } catch {
     // Config may not exist yet (e.g. `chant init`)

package/src/cli/plugins.ts

@@ -1,5 +1,5 @@
 import { isLexiconPlugin, type LexiconPlugin } from "../lexicon";
-import { loadChantConfig } from "../config";
+import { loadChantConfigUpward } from "../config";
 import { findInfraFiles, detectLexicons } from "../index";
 import { checkConflicts } from "./conflict-check";
 
@@ -96,9 +96,17 @@ export async function loadPlugins(lexiconNames: string[]): Promise<LexiconPlugin
  * that never needed live module exports to begin with. This is strictly
  * better than routing the detection through the sandbox: it removes the
  * execution entirely rather than containing it, at no bundling/spawn cost.
+ *
+ * chant #1117 — walks up from `projectPath` to the project root
+ * (`loadChantConfigUpward`) rather than reading `projectPath` alone: `chant
+ * build src/<stack>` calls this with the stack's own subdirectory, and a
+ * project that declares `lexicons` only in its root `chant.config.ts` (never
+ * detectable by `detectLexicons()`'s import scan alone, e.g. a lexicon that's
+ * loaded but never imported by name in that particular stack's files) would
+ * otherwise silently miss it.
  */
 export async function resolveProjectLexicons(projectPath: string): Promise<string[]> {
-  const { config } = await loadChantConfig(projectPath);
+  const { config } = await loadChantConfigUpward(projectPath);
 
   if (config.lexicons && config.lexicons.length > 0) {
     return config.lexicons;

package/src/config.ts

@@ -7,6 +7,7 @@ import { DEFAULT_SBOM_FORMAT, type SbomFormat } from "./components/verbs/sbom-ge
 import type { Severity } from "./components/verbs/vuln-scan";
 import type { VulnPolicy } from "./components/verbs/vuln-gate";
 import type { BuildParamsConfig } from "./build-params";
+import { findProjectConfig } from "./project-root";
 
 /**
  * Zod schema for ChantConfig validation.
@@ -297,6 +298,28 @@ export async function loadChantConfig(dir: string): Promise<ResolvedConfig> {
   return { config: DEFAULT_CHANT_CONFIG };
 }
 
+/**
+ * Load project configuration by walking up from `startDir` to the project
+ * root (chant #1117), instead of trying only `startDir` itself.
+ *
+ * `chant build src/<stack>` (and anything else invoked with a subdirectory —
+ * `lint.policies`' `evaluateProjectPolicies`, `--components --generate`)
+ * builds scoped to that subdirectory, but `chant.config.ts` almost always
+ * lives at the project root, one or more levels up. Before this, callers
+ * either read `startDir` alone or bolted on a single `dirname()` fallback —
+ * fine for a one-level-deep stack, silently blind to anything deeper
+ * (loomster's `src/<stack>` layout is exactly one level too deep: `buildParams`'
+ * declared `env:` mappings never resolved, so `LOOM_TIER`/`LOOM_ENV` were inert
+ * under every `npm run synth:*` for two releases — loomster#162). Uses the
+ * same walk `chant lint`/`chant graph` already used ({@link findProjectConfig},
+ * shared with `./lint/config.ts`'s `findProjectRoot`) — one config-discovery
+ * contract for the whole CLI.
+ */
+export async function loadChantConfigUpward(startDir: string): Promise<ResolvedConfig> {
+  const { dir } = findProjectConfig(startDir);
+  return loadChantConfig(dir);
+}
+
 /**
  * Resolve the ownership marker to stamp from project config, or undefined when
  * ownership marking is off (no `stack`, or `enabled: false`).

package/src/lint/config.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { loadConfig, DEFAULT_CONFIG, findProjectRoot } from "./config";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
-import { join } from "path";
+import { join, resolve } from "path";
 
 const TEST_DIR = join(import.meta.dirname, "__test_config__");
 
@@ -705,10 +705,15 @@ describe("findProjectRoot", () => {
     expect(findProjectRoot(sub)).toBe(TEST_DIR);
   });
 
-  test("falls back to the start dir when no config is found", () => {
+  test("stops at the nearest .git/package.json boundary when no config is found (#1117)", () => {
     const sub = join(TEST_DIR, "nowhere");
     mkdirSync(sub, { recursive: true });
-    // No chant.config anywhere under TEST_DIR — returns the (resolved) start dir.
-    expect(findProjectRoot(sub)).toBe(sub);
+    // No chant.config anywhere under TEST_DIR — walking up from this real
+    // repo location reaches `packages/core`'s own package.json before the
+    // filesystem root, so that's the returned boundary, not `sub` itself
+    // (chant #1117 — discovery must never wander past the project just
+    // because it declares no config).
+    const packageRoot = resolve(import.meta.dirname, "..", "..");
+    expect(findProjectRoot(sub)).toBe(packageRoot);
   });
 });

package/src/lint/config.ts

@@ -6,6 +6,13 @@ import type { Severity, RuleConfig } from "./rule";
 import { moduleDir, getRuntime } from "../runtime-adapter";
 import strictPreset from "./presets/strict.json";
 
+// chant #1117 — the upward config-discovery walk moved to a shared module
+// (`../project-root`) so `chant build`/`lint.policies` use the identical walk
+// `chant lint`/`chant graph` already did. Re-exported here since this is
+// still where every existing call site (`./config.test.ts`, `../cli/commands/lint.ts`)
+// imports it from.
+export { findProjectRoot } from "../project-root";
+
 /** Mapping of built-in preset names to their file paths */
 const BUILTIN_PRESETS: Record<string, string> = {
   "@intentius/chant/lint/presets/strict": resolve(moduleDir(import.meta.url), "presets/strict.json"),
@@ -323,29 +330,6 @@ function loadConfigFile(configPath: string, visited: Set<string> = new Set()): L
   return mergedConfig;
 }
 
-/**
- * Walk up from `startDir` to the nearest ancestor holding a chant project
- * config (`chant.config.ts` or `chant.config.json`). Returns that directory, or
- * `startDir` unchanged when none is found before the filesystem root.
- *
- * Linting a subpath (`chant graph src --format ir`, `chant lint src/lib`) must
- * still see the project-root config: its `lint.overrides` globs are written
- * project-root-relative (`src/lib/**`), and a rule set scoped only to the lint
- * arg would silently drop them. Config discovery therefore anchors on the
- * project root, not the path being linted.
- */
-export function findProjectRoot(startDir: string): string {
-  let dir = resolve(startDir);
-  for (;;) {
-    if (existsSync(join(dir, "chant.config.ts")) || existsSync(join(dir, "chant.config.json"))) {
-      return dir;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return resolve(startDir);
-    dir = parent;
-  }
-}
-
 /**
  * Load lint configuration from a directory.
  *

package/src/lint/policy.ts

@@ -4,7 +4,7 @@
  * `policyGate` Op step runs this to gate an apply on the same checks.
  */
 import { resolve, dirname } from "node:path";
-import { loadChantConfig } from "../config";
+import { loadChantConfigUpward } from "../config";
 import { resolveProjectLexicons, loadPlugins } from "../cli/plugins";
 import { build } from "../build";
 import { runPostSynthChecks, isPostSynthCheck } from "./post-synth";
@@ -55,10 +55,10 @@ export async function evaluateProjectPolicies(opts: {
   const plugins = await loadPlugins(lexiconNames);
   const serializers = plugins.map((p) => p.serializer);
 
-  // Config can live in the build dir or its parent (the project root).
-  const loaded = await loadChantConfig(buildPath).then((r) =>
-    r.configPath ? r : loadChantConfig(dirname(buildPath)),
-  );
+  // chant #1117 — walks up from the build dir to the project root, same as
+  // `chant build` (`../cli/commands/build.ts`'s `loadChantConfigUpward`), not
+  // just the build dir's immediate parent.
+  const loaded = await loadChantConfigUpward(buildPath);
   const config = loaded.config;
   const configDir = loaded.configPath ? dirname(loaded.configPath) : buildPath;
   const env = opts.env ?? config.ownership?.env;

package/src/project-root.test.ts

@@ -0,0 +1,105 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { findProjectConfig, findProjectRoot } from "./project-root";
+
+// Every test builds its own isolated directory tree under a fresh tmpdir —
+// never reused across tests, and never anywhere near the real repo's own
+// .git/package.json — so the boundary-stop behavior is exercised
+// deterministically instead of depending on where this file happens to sit
+// in the real chant checkout.
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "chant-project-root-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("findProjectConfig / findProjectRoot (chant #1117)", () => {
+  test("found at root — chant.config.ts in the start dir itself", () => {
+    writeFileSync(join(root, "chant.config.ts"), "export default {};");
+
+    const result = findProjectConfig(root);
+
+    expect(result.dir).toBe(root);
+    expect(result.configPath).toBe(join(root, "chant.config.ts"));
+    expect(findProjectRoot(root)).toBe(root);
+  });
+
+  test("found at an intermediate ancestor — several levels below the config", () => {
+    writeFileSync(join(root, "chant.config.json"), "{}");
+    const stackDir = join(root, "src", "stacks", "shared-foundation");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(root);
+    expect(result.configPath).toBe(join(root, "chant.config.json"));
+    expect(findProjectRoot(stackDir)).toBe(root);
+  });
+
+  test("not found — no chant.config, no .git, no package.json anywhere above start dir: falls back to start dir, not the filesystem root", () => {
+    const deep = join(root, "a", "b", "c");
+    mkdirSync(deep, { recursive: true });
+
+    const result = findProjectConfig(deep);
+
+    // Nothing between `deep` and the real filesystem root declares a chant
+    // config or a boundary marker (this mkdtemp tree carries none). Rather
+    // than adopting "/" as the project root — which would make a downstream
+    // caller that scopes a directory walk off this result (e.g.
+    // `resolveProjectLexicons` -> `findInfraFiles`) scan the entire disk —
+    // the walk gives up and returns `deep` itself unchanged.
+    expect(result.configPath).toBeUndefined();
+    expect(result.dir).toBe(deep);
+    expect(findProjectRoot(deep)).toBe(deep);
+  });
+
+  test("boundary stop — a .git/package.json ancestor halts the walk before an outer chant.config.ts", () => {
+    // An unrelated chant.config.ts two levels above this project's own git
+    // root must never be picked up — the boundary marker (.git here) stops
+    // the walk at the project's own root first.
+    writeFileSync(join(root, "chant.config.ts"), "export default { unrelated: true };");
+    const projectRoot = join(root, "project");
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBeUndefined();
+    expect(findProjectRoot(stackDir)).toBe(projectRoot);
+  });
+
+  test("boundary stop — package.json (no .git) halts the walk the same way", () => {
+    writeFileSync(join(root, "chant.config.json"), "{}");
+    const projectRoot = join(root, "project");
+    mkdirSync(projectRoot, { recursive: true });
+    writeFileSync(join(projectRoot, "package.json"), "{}");
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBeUndefined();
+  });
+
+  test("a config living exactly at the boundary dir is still found — boundary check never wins over a real config", () => {
+    const projectRoot = join(root, "project");
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    writeFileSync(join(projectRoot, "chant.config.ts"), "export default {};");
+    const stackDir = join(projectRoot, "src", "stack");
+    mkdirSync(stackDir, { recursive: true });
+
+    const result = findProjectConfig(stackDir);
+
+    expect(result.dir).toBe(projectRoot);
+    expect(result.configPath).toBe(join(projectRoot, "chant.config.ts"));
+  });
+});

package/src/project-root.ts

@@ -0,0 +1,78 @@
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+/**
+ * Shared upward config-discovery walk (chant #1117).
+ *
+ * Before this, `chant build <subdir>` and `lint.policies`
+ * (`./lint/policy.ts`'s `evaluateProjectPolicies`) each searched only the
+ * build directory and its immediate parent for `chant.config.ts`/`.json`,
+ * while `chant lint`/`chant graph` (`./lint/config.ts`'s old, file-local
+ * `findProjectRoot`) already walked all the way up. A project with a deeper
+ * `src/<stack>` layout — `chant build src/<stack>` two or more levels below
+ * the project root — silently never found the root config: `buildParams`'
+ * declared `env:` mappings went inert, `ownership`/`lint.policies`/etc quietly
+ * fell back to defaults, and nothing warned (loomster#162: `LOOM_TIER`/
+ * `LOOM_ENV` inert under every `npm run synth:*` for two releases).
+ *
+ * `findProjectConfig` is the one walk every config-discovery call site now
+ * shares. It stops at the first of:
+ *
+ * 1. A directory holding `chant.config.ts` or `chant.config.json` — found.
+ * 2. A directory holding `.git` or `package.json` with no chant config of its
+ *    own — the project boundary. Discovery must never wander past the actual
+ *    project into an unrelated ancestor directory just because this project
+ *    happens not to declare a config (a stray `chant.config.ts` two levels
+ *    above an unrelated git repo must never be picked up).
+ * 3. `startDir` itself, unchanged, if the walk reaches the filesystem root
+ *    without ever finding a config OR a boundary marker. This is not just a
+ *    "give up gracefully" nicety — several callers (`resolveProjectLexicons`
+ *    -> `findInfraFiles`) scope a real directory walk off this function's
+ *    result; if a rootless/marker-less start dir (a bare tmpdir, as chant's
+ *    own test suites use) resolved all the way to `/`, that downstream walk
+ *    would scan the entire filesystem instead of failing fast. Falling back
+ *    to `startDir` keeps every caller's blast radius local no matter how far
+ *    up the walk had to look.
+ */
+export interface ProjectConfigSearch {
+  /** The resolved project root: the config's directory, the boundary directory, or the (resolved) `startDir` when neither was found. */
+  dir: string;
+  /** Absolute path to the discovered `chant.config.ts`/`.json`, if any. */
+  configPath?: string;
+}
+
+/** Walk up from `startDir` (inclusive) to the nearest chant config or project boundary. See {@link ProjectConfigSearch}. */
+export function findProjectConfig(startDir: string): ProjectConfigSearch {
+  const resolvedStart = resolve(startDir);
+  let dir = resolvedStart;
+  for (;;) {
+    const tsPath = join(dir, "chant.config.ts");
+    if (existsSync(tsPath)) return { dir, configPath: tsPath };
+    const jsonPath = join(dir, "chant.config.json");
+    if (existsSync(jsonPath)) return { dir, configPath: jsonPath };
+
+    if (existsSync(join(dir, ".git")) || existsSync(join(dir, "package.json"))) {
+      return { dir };
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) {
+      // Filesystem root, no config, no boundary ever seen — give up rather
+      // than adopting "/" as the project root (see the module doc above).
+      return { dir: resolvedStart };
+    }
+    dir = parent;
+  }
+}
+
+/**
+ * Walk up from `startDir` to the nearest ancestor holding a chant project
+ * config (`chant.config.ts` or `chant.config.json`), the `.git`/`package.json`
+ * project boundary, or `startDir` itself when neither is found. Thin wrapper
+ * over {@link findProjectConfig} for callers that only need the directory
+ * (e.g. `chant lint`'s rule/plugin resolution, which just needs *a* stable
+ * root to resolve relative paths against).
+ */
+export function findProjectRoot(startDir: string): string {
+  return findProjectConfig(startDir).dir;
+}