@intentius/chant 0.41.0 → 0.41.1

package/dist/cli/build-params-cli.d.ts

@@ -52,4 +52,28 @@ export interface CliBuildParamsResolution {
  * the same way #1022's fold decisions are.
  */
 export declare function resolveCliBuildParams(buildParamsConfig: BuildParamsConfig | undefined, args: CliBuildParamsArgs): CliBuildParamsResolution;
+/**
+ * Resolve a command's declared build-time parameters, the same way `chant
+ * build` does, so a `build()`/`discover()` on the declared side sees the values
+ * the source will actually read.
+ *
+ * Every command that reads declared source needs this and only `chant build`
+ * had it. `chant graph` was fixed in #1483; the lifecycle family — `diff`,
+ * `snapshot`, `plan`, and `components status --live` — built the declared side
+ * on parameter *defaults* while the live side was whatever is really deployed.
+ *
+ * For a project whose parameters choose which resources *exist* that is not a
+ * near miss. `chant lifecycle diff dev --live` on kubemicrovm-ops returned
+ * byte-identical output at `KMV_TIER=minimal` and `KMV_TIER=prod-ha`, and
+ * reported the tier label itself as drift — `minimal → prod-ha`, declared
+ * against live — which is the comparison announcing it is against the wrong
+ * declaration.
+ *
+ * Returns `undefined` when resolution failed, having printed why: the caller
+ * should stop rather than compare against source that will not build.
+ */
+export declare function commandBuildParams(buildParamsConfig: BuildParamsConfig | undefined, args: {
+    param?: string[];
+    paramsFile?: string;
+}): Promise<BuildParamProvenance[] | undefined>;
 //# sourceMappingURL=build-params-cli.d.ts.map

package/dist/cli/build-params-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-params-cli.d.ts","sourceRoot":"","sources":["../../src/cli/build-params-cli.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAG1D;;;;;;;;;;;;;;;GAeG;AAEH,4SAA4S;AAC5S,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAQtF;AAED,qOAAqO;AACrO,MAAM,WAAW,kBAAkB;IACjC,mNAAmN;IACnN,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,gGAAgG;IAChG,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,iHAAiH;IACjH,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,4FAA4F;IAC5F,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,EAChD,IAAI,EAAE,kBAAkB,GACvB,wBAAwB,CAkC1B"}
+{"version":3,"file":"build-params-cli.d.ts","sourceRoot":"","sources":["../../src/cli/build-params-cli.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAG1D;;;;;;;;;;;;;;;GAeG;AAEH,4SAA4S;AAC5S,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAQtF;AAED,qOAAqO;AACrO,MAAM,WAAW,kBAAkB;IACjC,mNAAmN;IACnN,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,gGAAgG;IAChG,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,iHAAiH;IACjH,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,4FAA4F;IAC5F,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,EAChD,IAAI,EAAE,kBAAkB,GACvB,wBAAwB,CAkC1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,kBAAkB,CACtC,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,EAChD,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,OAAO,CAAC,oBAAoB,EAAE,GAAG,SAAS,CAAC,CAU7C"}

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

@@ -1 +1 @@
-{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/components.ts"],"names":[],"mappings":"AA8CA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,4BAA4B,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4ErF;AA4DD;;;;;;;;;;;;;;;GAeG;AACH;;;;;;;;6EAQ6E;AAC7E,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,CAiBzD;AAqDD,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqR9E;AAED,kEAAkE;AAClE,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM/E"}
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/components.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,4BAA4B,CAAC;AAGnE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4ErF;AA4DD;;;;;;;;;;;;;;;GAeG;AACH;;;;;;;;6EAQ6E;AAC7E,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,CAMzD;AA4DD,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA6R9E;AAED,kEAAkE;AAClE,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM/E"}

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

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lifecycle.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAqDlD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAoH/E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4C3E;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8B/E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAuJ3E;AAoiBD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAoJ3E;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB1E;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9E;AAkBD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA+C/E"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lifecycle.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAqDlD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwH/E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4C3E;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8B/E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA2J3E;AAoiBD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA0J3E;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB1E;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9E;AAkBD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA+C/E"}

package/dist/components/deploy-units.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Deploy units — which live unit(s) a component's composition targets (#1495).
+ *
+ * `chant components status --live` (and `chant graph --live`) need to know
+ * what a component deployed in order to observe it. That answer used to be a
+ * string literal in the walk — `kind === "cfn-deploy"` — which made the whole
+ * chain CloudFormation-shaped: a component whose deploy phase is a server-side
+ * apply or a Helm upgrade contributed nothing and was skipped, not
+ * "unobserved", simply absent from the result.
+ *
+ * This module is the seam that fixes the walk (piece 1 of #1495's
+ * decomposition): a registry mapping a deploy-family step `kind` to the field
+ * naming its unit and the lexicon whose `describeStackStatus` can observe it.
+ * The registry is data, not a rule about what steps look like — a kind not
+ * listed here contributes no unit, exactly as before.
+ */
+import type { Phase } from "./component.js";
+/** A deploy-family step kind that names a live unit, and who observes it. */
+export interface DeployUnitRule {
+    /** The step `kind` (the capability's registered name). */
+    kind: string;
+    /** The step field carrying the unit's name (`stack`, `release`). */
+    field: string;
+    /** The lexicon whose `describeStackStatus` reads this kind of unit. */
+    lexicon: string;
+}
+/**
+ * The deploy-family kinds that name a unit. cfn-deploy's unit is its stack;
+ * kubectl-apply's is the ownership stack its labels carry (#1495 piece 2);
+ * helm-upgrade's is its release (#1495 piece 4). Listing a kind here is safe
+ * before its lexicon implements `describeStackStatus` — units whose lexicon
+ * has no observer are skipped by the caller, the same absent-observer path as
+ * before.
+ */
+export declare const DEPLOY_UNIT_RULES: readonly DeployUnitRule[];
+/** One resolved unit a component's deploy composition targets. */
+export interface DeployUnit {
+    /** The unit's name — a stack, a release. */
+    unit: string;
+    /** The lexicon that observes this kind of unit. */
+    lexicon: string;
+}
+/**
+ * Every distinct deploy unit a component's phases target, in declaration
+ * order. A step may itself be a nested `Phase`, so the walk recurses; a
+ * resolved component carries the unit as a concrete string. Pure.
+ */
+export declare function deployUnits(deploy: Phase[]): DeployUnit[];
+//# sourceMappingURL=deploy-units.d.ts.map

package/dist/components/deploy-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-units.d.ts","sourceRoot":"","sources":["../../src/components/deploy-units.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAItD,CAAC;AAEF,kEAAkE;AAClE,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,EAAE,CA0BzD"}

package/dist/config.d.ts

@@ -350,6 +350,16 @@ export declare function loadChantConfig(dir: string): Promise<ResolvedConfig>;
  * 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.
+ *
+ * chant #1502 — a lint-scoping fragment does not end the walk. The convention
+ * of a `src/chant.config.json` holding only `extends`/`rules` (cc-aws-canonical
+ * and most of examples/) sits BETWEEN the build directory and the real
+ * `chant.config.ts`, and stopping there re-introduced the exact silent
+ * fallback this walk exists to prevent: `chant build src` resolved the
+ * fragment, found no `ownership`, and built unstamped manifests that every
+ * owned-scoped live read then withheld. A fragment is skipped, not merged —
+ * lint resolution keeps its own nearest-wins walk untouched, and a JSON
+ * config declaring any project-level key still wins where it stands.
  */
 export declare function loadChantConfigUpward(startDir: string): Promise<ResolvedConfig>;
 /**

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/package.json

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

package/src/cli/build-params-cli.ts

@@ -105,3 +105,38 @@ export function resolveCliBuildParams(
 
   return { success: true, provenance: resolution.provenance, errors: [] };
 }
+
+/**
+ * Resolve a command's declared build-time parameters, the same way `chant
+ * build` does, so a `build()`/`discover()` on the declared side sees the values
+ * the source will actually read.
+ *
+ * Every command that reads declared source needs this and only `chant build`
+ * had it. `chant graph` was fixed in #1483; the lifecycle family — `diff`,
+ * `snapshot`, `plan`, and `components status --live` — built the declared side
+ * on parameter *defaults* while the live side was whatever is really deployed.
+ *
+ * For a project whose parameters choose which resources *exist* that is not a
+ * near miss. `chant lifecycle diff dev --live` on kubemicrovm-ops returned
+ * byte-identical output at `KMV_TIER=minimal` and `KMV_TIER=prod-ha`, and
+ * reported the tier label itself as drift — `minimal → prod-ha`, declared
+ * against live — which is the comparison announcing it is against the wrong
+ * declaration.
+ *
+ * Returns `undefined` when resolution failed, having printed why: the caller
+ * should stop rather than compare against source that will not build.
+ */
+export async function commandBuildParams(
+  buildParamsConfig: BuildParamsConfig | undefined,
+  args: { param?: string[]; paramsFile?: string },
+): Promise<BuildParamProvenance[] | undefined> {
+  const resolution = resolveCliBuildParams(buildParamsConfig, {
+    cli: parseParamFlags(args.param),
+    paramsFile: args.paramsFile,
+  });
+  if (!resolution.success) {
+    for (const message of resolution.errors) console.error(message);
+    return undefined;
+  }
+  return resolution.provenance;
+}

package/src/cli/handlers/components.ts

@@ -35,6 +35,7 @@ import {
   InvalidReleaseRecordError,
 } from "../../lifecycle/release-ledger";
 import { reconcileStatus, liveEvidenceFromChangeSet, compareAcrossEnvironments, mergeLiveEvidence, type LiveComponentEvidence } from "../../lifecycle/status";
+import { commandBuildParams } from "../build-params-cli";
 import { buildChangeSet } from "../../lifecycle/change-set";
 import { buildLedgerEntries, componentBomSummary, type BuildLedgerEntry } from "../../lifecycle/build-ledger";
 import { findBuildManifestByArtifactDigest } from "../../lifecycle/build-ledger-store";
@@ -48,6 +49,7 @@ import type { CommandContext } from "../registry";
 import type { LexiconPlugin } from "../../lexicon";
 import { normalizeObservation, mergeObservations, unobservedAll, type NormalizedObservation } from "../../observation";
 import type { Phase, Component } from "../../components/component";
+import { deployUnits } from "../../components/deploy-units";
 
 /**
  * chant components release <env> --component <name> --digest <sha256:...>
@@ -228,22 +230,11 @@ interface StatusJsonRow {
  * observe on a multi-stack, per-component project (`describeResources`'s
  * single-stack-named-after-the-environment convention never matches one). */
 export function cfnDeployStacks(deploy: Phase[]): string[] {
-  const stacks = new Set<string>();
-  const walkSteps = (steps: Phase["steps"]): void => {
-    for (const step of steps) {
-      // A step may itself be a nested Phase (it carries its own `steps`). Step is
-      // open-typed (capability inputs), so discriminate structurally on `steps`.
-      const nested = (step as { steps?: unknown }).steps;
-      if (Array.isArray(nested)) {
-        walkSteps(nested as Phase["steps"]);
-        continue;
-      }
-      const s = step as { kind?: string; stack?: unknown };
-      if (s.kind === "cfn-deploy" && typeof s.stack === "string") stacks.add(s.stack);
-    }
-  };
-  for (const phase of deploy) walkSteps(phase.steps);
-  return [...stacks];
+  // The CloudFormation slice of the generic deploy-unit walk (#1495) — kept
+  // because `chant graph --live`'s stack enrichment is genuinely CFN-shaped.
+  return deployUnits(deploy)
+    .filter((u) => u.lexicon === "aws")
+    .map((u) => u.unit);
 }
 
 /**
@@ -258,15 +249,22 @@ export function cfnDeployStacks(deploy: Phase[]): string[] {
  */
 async function observeComponentStacks(
   components: Map<string, { component: Component }>,
-  observer: LexiconPlugin,
+  plugins: LexiconPlugin[],
   environment: string,
 ): Promise<Map<string, LiveComponentEvidence>> {
+  // Observer per unit's own lexicon (#1495): a component's kubectl-apply unit
+  // is read by the k8s lexicon, its cfn-deploy stack by aws. A unit whose
+  // lexicon ships no describeStackStatus is skipped — the same absent-observer
+  // degradation as before, per unit instead of per project.
+  const observerFor = (lexicon: string) =>
+    plugins.find((p) => p.name === lexicon && p.describeStackStatus);
   const evidence = new Map<string, LiveComponentEvidence>();
   for (const [name, { component }] of components) {
-    const stacks = cfnDeployStacks(component.deploy);
+    const units = deployUnits(component.deploy).filter((u) => observerFor(u.lexicon));
+    const stacks = units.map((u) => u.unit);
     if (stacks.length === 0) continue;
     const observed = await Promise.all(
-      stacks.map((stack) => observer.describeStackStatus!({ environment, stack }).catch(() => null)),
+      units.map((u) => observerFor(u.lexicon)!.describeStackStatus!({ environment, stack: u.unit }).catch(() => null)),
     );
     const determinate = observed.filter((o): o is NonNullable<typeof o> => o !== null);
     if (determinate.length === 0) {
@@ -355,7 +353,15 @@ export async function runComponentsStatus(ctx: CommandContext): Promise<number>
       if (endpointResult.notice) console.error(formatWarning({ message: endpointResult.notice }));
       try {
         const targetSerializers = serializers;
-        const buildResult = await build(resolve(args.src ?? config.sourceDir ?? "."), targetSerializers);
+        // With this invocation's parameters (#1483). Built on defaults, the
+        // declared half of the comparison is a different estate from the one
+        // deployed, and every resource the real parameter declares reads as
+        // absent.
+        const statusParams = await commandBuildParams(config.buildParams, args);
+        if (!statusParams) return 1;
+        const buildResult = await build(resolve(args.src ?? config.sourceDir ?? "."), targetSerializers, undefined, {
+          buildParams: statusParams,
+        });
         // Which deployed stack(s) to read the change set from (behold#100).
         //
         // `describeResources` defaults to the single-stack convention — the
@@ -431,9 +437,9 @@ export async function runComponentsStatus(ctx: CommandContext): Promise<number>
         // invisible to the entity-keyed, single-stack `describeResources` above —
         // observe each component's own cfn-deploy stack directly and overlay it as
         // the authoritative presence signal (#57).
-        const stackObserver = plugins.find((p) => p.describeStackStatus);
-        if (stackObserver) {
-          const stackEvidence = await observeComponentStacks(discovery.components, stackObserver, environment);
+        const anyObserver = plugins.some((p) => p.describeStackStatus);
+        if (anyObserver) {
+          const stackEvidence = await observeComponentStacks(discovery.components, plugins, environment);
           liveEvidence = mergeLiveEvidence(liveEvidence, stackEvidence);
         }
       } finally {

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

@@ -85,8 +85,15 @@ vi.mock("../../config", async () => {
     loadChantConfigUpward: (...a: unknown[]) => loadChantConfigUpwardMock(...a),
   };
 });
+const buildMock = vi.fn();
 vi.mock("../../build", () => ({
-  build: () => Promise.resolve({ errors: [] }),
+  // Forwards its arguments so a test can assert what the live path passed —
+  // `buildParams` in particular (#1483), the same reason `discover` above
+  // forwards for #1359.
+  build: (...a: unknown[]) => {
+    buildMock(...a);
+    return Promise.resolve({ errors: [] });
+  },
   partitionByLexicon: () => ({}),
   computeStackGraph: () => ({}),
 }));
@@ -136,6 +143,7 @@ describe("runGraph", () => {
     // Default: no components — the single-stack --live path most tests exercise.
     discoverComponentsMock.mockResolvedValue({ components: new Map(), sourceFiles: [], errors: [] });
     observeMock.mockReset();
+    buildMock.mockReset();
     loadPluginsMock.mockReset();
     resolveLexMock.mockReset();
     loadChantConfigMock.mockReset();
@@ -480,6 +488,48 @@ describe("runGraph", () => {
   });
 
   describe("live graph (--live)", () => {
+    // #1483 — the live path builds the source to learn which entities to
+    // observe, and did so on default parameters while the declared overlay
+    // resolved the caller's. For a project whose parameters choose *which
+    // resources exist* — a tier, a size, a profile — that observed one estate
+    // and compared it against another, so every resource the real parameter
+    // declares read as absent and every resource the default declares read as
+    // pending. A confidently wrong overlay, not an empty one.
+    describe("build-time parameters reach the observed build (#1483)", () => {
+      const liveWithTier = async (param?: string[]) => {
+        loadChantConfigUpwardMock.mockResolvedValue({
+          config: { buildParams: { tier: { type: "string", enum: ["light", "prod"], default: "light" } } },
+        });
+        resolveLexMock.mockResolvedValue(["aws"]);
+        loadPluginsMock.mockResolvedValue([
+          { name: "aws", serializer: {}, emulator: awsEmulatorStub, describeResources: () => Promise.resolve({}) },
+        ]);
+        observeMock.mockResolvedValue({ observations: [], errors: [], warnings: [] });
+        return runGraph({
+          args: makeArgs({ format: "ir", live: true, env: "prod", ...(param ? { param } : {}) }),
+          plugins: [],
+          serializers: [],
+        });
+      };
+
+      const paramsOf = (call: unknown[]) =>
+        (call[3] as { buildParams?: Array<{ name: string; value: unknown }> } | undefined)?.buildParams;
+
+      test("--param reaches the build the observation is scoped from", async () => {
+        expect(await liveWithTier(["tier=prod"])).toBe(0);
+        expect(paramsOf(buildMock.mock.calls[0]!)).toContainEqual(
+          expect.objectContaining({ name: "tier", value: "prod" }),
+        );
+      });
+
+      test("a declared default reaches it too, rather than nothing at all", async () => {
+        expect(await liveWithTier()).toBe(0);
+        expect(paramsOf(buildMock.mock.calls[0]!)).toContainEqual(
+          expect.objectContaining({ name: "tier", value: "light" }),
+        );
+      });
+    });
+
     // Regression: `graph` is not `requiresPlugins`, so `ctx.plugins` is empty. The
     // live path must load the project's plugins itself — otherwise it wrongly
     // reports "No lexicons implement describeResources" and observes nothing.

package/src/cli/handlers/graph.ts

@@ -144,7 +144,22 @@ async function runGraphLive(
 
   // Build to get each lexicon's entity names + output (the scope
   // describeResources needs), mirroring `chant lifecycle snapshot`.
-  const buildResult = await build(resolve(args.src ?? config.sourceDir ?? "."), plugins.map((p) => p.serializer));
+  //
+  // With the same build params the source graph resolves (#1483). Without
+  // them this build ran on defaults while the declared overlay below ran on
+  // the caller's, so a project whose parameters choose *which resources
+  // exist* — a tier, a size, a profile — observed one estate and compared it
+  // against another. Every resource the real parameter declares read as
+  // absent and every resource the default declares read as pending, which is
+  // a confidently wrong overlay rather than an empty one.
+  const liveBuildParams = await graphBuildParams(ctx, projectPath);
+  if (!liveBuildParams) return 1;
+  const buildResult = await build(
+    resolve(args.src ?? config.sourceDir ?? "."),
+    plugins.map((p) => p.serializer),
+    undefined,
+    { buildParams: liveBuildParams },
+  );
   if (buildResult.errors.length > 0) {
     console.error(formatError({ message: "Build failed — fix errors before graphing live state" }));
     return 1;

package/src/cli/handlers/lifecycle.ts

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { commandBuildParams } from "../build-params-cli";
 import { build } from "../../build";
 import { takeSnapshot } from "../../lifecycle/snapshot";
 import { readSnapshot, readSnapshotAt, readEnvironmentSnapshots, listSnapshots, fetchLifecycle, pushLifecycle, snapshotStorageKey, StaleLifecycleBranchError } from "../../lifecycle/git";
@@ -101,6 +102,10 @@ export async function runLifecycleSnapshot(ctx: CommandContext): Promise<number>
   // Validate environment against config
   const projectPath = resolve(".");
   const { config } = await loadChantConfig(projectPath);
+  // This invocation's parameters, so the declared side of the comparison is the estate
+  // the caller asked for rather than the parameter defaults (#1483).
+  const declaredParams = await commandBuildParams(config.buildParams, args);
+  if (!declaredParams) return 1;
   const declaredEnvNames = environmentNames(config.environments);
   if (declaredEnvNames && !declaredEnvNames.includes(environment)) {
     console.error(formatError({
@@ -146,7 +151,7 @@ export async function runLifecycleSnapshot(ctx: CommandContext): Promise<number>
   const built: Array<{ target: (typeof targets)[number]; buildResult: Awaited<ReturnType<typeof build>> }> = [];
   for (const target of targets) {
     const label = target.stack ? `stack "${target.stack}"` : "project";
-    const buildResult = await build(target.root, targetSerializers);
+    const buildResult = await build(target.root, targetSerializers, undefined, { buildParams: declaredParams });
     if (buildResult.errors.length > 0) {
       console.error(formatError({ message: `Build failed for ${label} — fix errors before taking a snapshot` }));
       anyHardError = true;
@@ -326,6 +331,10 @@ export async function runLifecycleDiff(ctx: CommandContext): Promise<number> {
 
   // Fetch previous snapshots once (all stacks share the orphan branch).
   const { config } = await loadChantConfig(resolve("."));
+  // This invocation's parameters, so the declared side of the comparison is the estate
+  // the caller asked for rather than the parameter defaults (#1483).
+  const declaredParams = await commandBuildParams(config.buildParams, args);
+  if (!declaredParams) return 1;
   await fetchLifecycle();
 
   // One target per stack (single-stack projects: exactly one), each built from
@@ -355,7 +364,7 @@ export async function runLifecycleDiff(ctx: CommandContext): Promise<number> {
 
   try {
     for (const target of targets) {
-      const buildResult = await build(target.root, targetSerializers);
+      const buildResult = await build(target.root, targetSerializers, undefined, { buildParams: declaredParams });
       if (buildResult.errors.length > 0) {
         const label = target.stack ? `stack "${target.stack}"` : "project";
         console.error(formatError({ message: `Build failed for ${label} — fix errors before diffing` }));
@@ -1021,7 +1030,13 @@ export async function runLifecyclePlan(ctx: CommandContext): Promise<number> {
     : serializers;
 
   const { config } = await loadChantConfig(resolve("."));
-  const buildResult = await build(resolveBuildRoot(args, config), targetSerializers);
+  // This invocation's parameters, so the declared side of the comparison is the estate
+  // the caller asked for rather than the parameter defaults (#1483).
+  const declaredParams = await commandBuildParams(config.buildParams, args);
+  if (!declaredParams) return 1;
+  const buildResult = await build(resolveBuildRoot(args, config), targetSerializers, undefined, {
+    buildParams: declaredParams,
+  });
   if (buildResult.errors.length > 0) {
     console.error(formatError({ message: "Build failed — fix errors before planning" }));
     return 1;

package/src/components/deploy-units.test.ts

@@ -0,0 +1,42 @@
+import { describe, test, expect } from "vitest";
+import { deployUnits } from "./deploy-units";
+import type { Phase } from "./component";
+
+const phase = (name: string, steps: Phase["steps"]): Phase => ({ phase: name, steps });
+
+describe("deployUnits (#1495 piece 1)", () => {
+  test("resolves a cfn-deploy step to its stack, keyed to the aws observer", () => {
+    const deploy = [phase("Apply", [{ kind: "cfn-deploy", stack: "cc-canonical", template: "t.json" }])];
+    expect(deployUnits(deploy)).toEqual([{ unit: "cc-canonical", lexicon: "aws" }]);
+  });
+
+  test("resolves kubectl-apply and helm-upgrade units once their steps exist", () => {
+    const deploy = [
+      phase("Apply", [
+        { kind: "kubectl-apply", stack: "kubemicrovm-ops" },
+        { kind: "helm-upgrade", release: "operator" },
+      ]),
+    ];
+    expect(deployUnits(deploy)).toEqual([
+      { unit: "kubemicrovm-ops", lexicon: "k8s" },
+      { unit: "operator", lexicon: "helm" },
+    ]);
+  });
+
+  test("walks nested phases, dedupes per lexicon, and skips unitless steps", () => {
+    const deploy = [
+      phase("Outer", [
+        phase("Inner", [{ kind: "cfn-deploy", stack: "web" }]) as never,
+        { kind: "cfn-deploy", stack: "web" },
+        { kind: "shell", cmd: "echo", reason: "no capability yet" },
+        { kind: "cfn-deploy" }, // no stack named — contributes nothing
+      ]),
+    ];
+    expect(deployUnits(deploy)).toEqual([{ unit: "web", lexicon: "aws" }]);
+  });
+
+  test("an unlisted kind contributes no unit — the registry is the rule", () => {
+    const deploy = [phase("Apply", [{ kind: "gcloud-deploy", stack: "x" }])];
+    expect(deployUnits(deploy)).toEqual([]);
+  });
+});

package/src/components/deploy-units.ts

@@ -0,0 +1,82 @@
+/**
+ * Deploy units — which live unit(s) a component's composition targets (#1495).
+ *
+ * `chant components status --live` (and `chant graph --live`) need to know
+ * what a component deployed in order to observe it. That answer used to be a
+ * string literal in the walk — `kind === "cfn-deploy"` — which made the whole
+ * chain CloudFormation-shaped: a component whose deploy phase is a server-side
+ * apply or a Helm upgrade contributed nothing and was skipped, not
+ * "unobserved", simply absent from the result.
+ *
+ * This module is the seam that fixes the walk (piece 1 of #1495's
+ * decomposition): a registry mapping a deploy-family step `kind` to the field
+ * naming its unit and the lexicon whose `describeStackStatus` can observe it.
+ * The registry is data, not a rule about what steps look like — a kind not
+ * listed here contributes no unit, exactly as before.
+ */
+import type { Phase } from "./component";
+
+/** A deploy-family step kind that names a live unit, and who observes it. */
+export interface DeployUnitRule {
+  /** The step `kind` (the capability's registered name). */
+  kind: string;
+  /** The step field carrying the unit's name (`stack`, `release`). */
+  field: string;
+  /** The lexicon whose `describeStackStatus` reads this kind of unit. */
+  lexicon: string;
+}
+
+/**
+ * The deploy-family kinds that name a unit. cfn-deploy's unit is its stack;
+ * kubectl-apply's is the ownership stack its labels carry (#1495 piece 2);
+ * helm-upgrade's is its release (#1495 piece 4). Listing a kind here is safe
+ * before its lexicon implements `describeStackStatus` — units whose lexicon
+ * has no observer are skipped by the caller, the same absent-observer path as
+ * before.
+ */
+export const DEPLOY_UNIT_RULES: readonly DeployUnitRule[] = [
+  { kind: "cfn-deploy", field: "stack", lexicon: "aws" },
+  { kind: "kubectl-apply", field: "stack", lexicon: "k8s" },
+  { kind: "helm-upgrade", field: "release", lexicon: "helm" },
+];
+
+/** One resolved unit a component's deploy composition targets. */
+export interface DeployUnit {
+  /** The unit's name — a stack, a release. */
+  unit: string;
+  /** The lexicon that observes this kind of unit. */
+  lexicon: string;
+}
+
+/**
+ * Every distinct deploy unit a component's phases target, in declaration
+ * order. A step may itself be a nested `Phase`, so the walk recurses; a
+ * resolved component carries the unit as a concrete string. Pure.
+ */
+export function deployUnits(deploy: Phase[]): DeployUnit[] {
+  const byKind = new Map(DEPLOY_UNIT_RULES.map((r) => [r.kind, r]));
+  const seen = new Set<string>();
+  const units: DeployUnit[] = [];
+  const walkSteps = (steps: Phase["steps"]): void => {
+    for (const step of steps) {
+      // A step may itself be a nested Phase (it carries its own `steps`). Step
+      // is open-typed (capability inputs), so discriminate structurally.
+      const nested = (step as { steps?: unknown }).steps;
+      if (Array.isArray(nested)) {
+        walkSteps(nested as Phase["steps"]);
+        continue;
+      }
+      const s = step as { kind?: string } & Record<string, unknown>;
+      const rule = s.kind ? byKind.get(s.kind) : undefined;
+      if (!rule) continue;
+      const unit = s[rule.field];
+      if (typeof unit !== "string" || unit.length === 0) continue;
+      const key = `${rule.lexicon}\0${unit}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      units.push({ unit, lexicon: rule.lexicon });
+    }
+  };
+  for (const phase of deploy) walkSteps(phase.steps);
+  return units;
+}

package/src/config.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import {
   loadChantConfig,
+  loadChantConfigUpward,
   DEFAULT_CHANT_CONFIG,
   resolveAutoReleaseDisabled,
   resolveFoldEnabled,
@@ -137,6 +138,58 @@ describe("loadChantConfig", () => {
   });
 });
 
+// #1502 — the upward walk skips lint-scoping fragments. A `src/chant.config.json`
+// holding only `extends`/`rules` (the examples/ convention) must not shadow the
+// project config above it, or `chant build src` silently loses `ownership`/
+// `buildParams` — the exact fallback #1117's walk exists to prevent.
+describe("loadChantConfigUpward (#1502 — lint fragments do not end the walk)", () => {
+  const SRC = join(TEST_DIR, "src");
+
+  test("walks past a lint-only src/chant.config.json to the project config", async () => {
+    mkdirSync(SRC, { recursive: true });
+    writeFileSync(
+      join(SRC, "chant.config.json"),
+      JSON.stringify({ extends: ["@intentius/chant/lint/presets/strict"], rules: { COR001: "off" } }),
+    );
+    writeFileSync(
+      join(TEST_DIR, "chant.config.json"),
+      JSON.stringify({ ownership: { stack: "billing", env: "prod" } }),
+    );
+
+    const result = await loadChantConfigUpward(SRC);
+    expect(result.config.ownership).toEqual({ stack: "billing", env: "prod" });
+    expect(result.configPath).toBe(join(TEST_DIR, "chant.config.json"));
+  });
+
+  test("a src/chant.config.json declaring any project-level key still wins in place", async () => {
+    mkdirSync(SRC, { recursive: true });
+    writeFileSync(
+      join(SRC, "chant.config.json"),
+      JSON.stringify({ ownership: { stack: "nested" }, rules: { COR001: "off" } }),
+    );
+    writeFileSync(
+      join(TEST_DIR, "chant.config.json"),
+      JSON.stringify({ ownership: { stack: "root" } }),
+    );
+
+    const result = await loadChantConfigUpward(SRC);
+    expect(result.config.ownership?.stack).toBe("nested");
+  });
+
+  test("a fragment-only project resolves to the default config at the boundary", async () => {
+    mkdirSync(SRC, { recursive: true });
+    writeFileSync(join(TEST_DIR, "package.json"), JSON.stringify({ name: "boundary" }));
+    writeFileSync(
+      join(SRC, "chant.config.json"),
+      JSON.stringify({ extends: ["@intentius/chant/lint/presets/strict"] }),
+    );
+
+    const result = await loadChantConfigUpward(SRC);
+    expect(result.config).toEqual(DEFAULT_CHANT_CONFIG);
+    expect(result.configPath).toBeUndefined();
+  });
+});
+
 // #1166 — `environments` accepts either a bare name (unchanged) or
 // `{ name, endpoint }`, so a declared environment can be self-sufficient for
 // `--live` reads without an ambient AWS_ENDPOINT_URL export.

package/src/config.ts

@@ -1,5 +1,5 @@
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
 import { z } from "zod";
 import type { LintConfig } from "./lint/config";
 import type { OwnershipMarker } from "./ownership";
@@ -384,12 +384,50 @@ export async function loadChantConfig(dir: string): Promise<ResolvedConfig> {
  * 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.
+ *
+ * chant #1502 — a lint-scoping fragment does not end the walk. The convention
+ * of a `src/chant.config.json` holding only `extends`/`rules` (cc-aws-canonical
+ * and most of examples/) sits BETWEEN the build directory and the real
+ * `chant.config.ts`, and stopping there re-introduced the exact silent
+ * fallback this walk exists to prevent: `chant build src` resolved the
+ * fragment, found no `ownership`, and built unstamped manifests that every
+ * owned-scoped live read then withheld. A fragment is skipped, not merged —
+ * lint resolution keeps its own nearest-wins walk untouched, and a JSON
+ * config declaring any project-level key still wins where it stands.
  */
 export async function loadChantConfigUpward(startDir: string): Promise<ResolvedConfig> {
-  const { dir } = findProjectConfig(startDir);
+  let { dir, configPath } = findProjectConfig(startDir);
+  while (configPath && isLintOnlyFragment(configPath)) {
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    ({ dir, configPath } = findProjectConfig(parent));
+  }
   return loadChantConfig(dir);
 }
 
+/**
+ * The top-level keys of `./lint/config.ts`'s `LintConfigSchema` (plus the
+ * `$schema` editor convention). A `chant.config.json` whose keys all come from
+ * this set is a lint-scoping fragment, not a project config — see
+ * {@link loadChantConfigUpward}. `chant.config.ts` is never a fragment: it is
+ * project-authored code, and inspecting it would mean evaluating it.
+ */
+const LINT_FRAGMENT_KEYS = new Set(["$schema", "extends", "rules", "overrides", "plugins", "policies"]);
+
+function isLintOnlyFragment(configPath: string): boolean {
+  if (!configPath.endsWith("chant.config.json")) return false;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as unknown;
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+    const keys = Object.keys(parsed);
+    return keys.length > 0 && keys.every((k) => LINT_FRAGMENT_KEYS.has(k));
+  } catch {
+    // Unreadable/unparseable JSON: let loadChantConfig surface the real error
+    // in place rather than silently walking past it.
+    return false;
+  }
+}
+
 /**
  * Resolve the ownership marker to stamp from project config, or undefined when
  * ownership marking is off (no `stack`, or `enabled: false`).