@intentius/chant 0.22.0 → 0.23.0

package/src/cli/handlers/build.ts

@@ -4,6 +4,8 @@ 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 { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
 
 /**
  * `chant build --components --generate <lexicon>` — generate mode (#563,
@@ -12,11 +14,30 @@ import { generateComponentsPipeline } from "../../components/cli-support";
  * normal lexicon build: no entity discovery, no serializers, no post-synth
  * checks — those apply to lexicon resources, which is a different input to
  * a different command path (`chant build` without `--components`).
+ *
+ * chant #1108 — resolves this invocation's declared build-time parameters
+ * (`chant.config.ts`'s `buildParams`, against `--param`/`--params-file`/a
+ * declared `env` mapping) the exact same way `chant build` does
+ * (`resolveCliBuildParams`, shared with `buildCommand`), BEFORE
+ * `generateComponentsPipeline` discovers/imports any `*.component.ts` file.
+ * 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.
  */
 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 paramsResolution = resolveCliBuildParams(config.buildParams, {
+    cli: parseParamFlags(args.param),
+    paramsFile: args.paramsFile,
+  });
+  if (!paramsResolution.success) {
+    for (const message of paramsResolution.errors) console.error(message);
+    return 1;
+  }
+
   // Which lexicons support generate mode is a property of the loaded lexicon
   // plugins (those implementing `generateComponentPipeline`, #688), not a
   // hard-coded core list — `generateComponentsPipeline` returns a descriptive
@@ -26,6 +47,7 @@ async function runGenerateComponents(ctx: CommandContext): Promise<number> {
     lexicon,
     { env: args.env },
     args.sandbox,
+    paramsResolution.provenance,
   );
 
   if (!result.success) {
@@ -87,14 +109,7 @@ export async function runBuild(ctx: CommandContext): Promise<number> {
   }
 
   // #1064 — `--param name=value`, repeated, into a flat { name: value } record.
-  const params = args.param?.length
-    ? Object.fromEntries(
-        args.param.map((entry) => {
-          const eq = entry.indexOf("=");
-          return eq === -1 ? [entry, ""] : [entry.slice(0, eq), entry.slice(eq + 1)];
-        }),
-      )
-    : undefined;
+  const params = parseParamFlags(args.param);
 
   if (args.watch) {
     const cleanup = buildCommandWatch({

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

@@ -878,7 +878,7 @@ describe("runOp dispatcher: --components routes to runOpComponents", () => {
     const exit = await runOp({ args: makeArgs({ path: "svc", components: true, temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {}, buildParams: [] });
     expect(discoverOpsMock).not.toHaveBeenCalled();
     vi.restoreAllMocks();
   });
@@ -900,6 +900,87 @@ describe("runOpComponents", () => {
     expect(runComponentsMock).not.toHaveBeenCalled();
   });
 
+  // ── build-time parameters (chant #1108) — resolved BEFORE dispatch ────────
+
+  describe("build-time parameters", () => {
+    test("chant.config.ts's declared buildParams resolve and log before dispatching to runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", default: "light" } } },
+      });
+      runComponentsMock.mockResolvedValue({
+        success: true,
+        selected: ["svc"],
+        run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, records: [] }], ok: true },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
+
+      expect(exit).toBe(0);
+      expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", expect.objectContaining({
+        buildParams: [{ name: "tier", value: "light", source: "default" }],
+      }));
+      expect(stderr.join("\n")).toContain("[param] tier");
+    });
+
+    test("--param overrides a declared default and is threaded through to runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", default: "light" } } },
+      });
+      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 stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({
+        args: makeArgs({ path: "svc", temporal: false, param: ["tier=production"] }),
+        plugins: [],
+        serializers: [],
+      });
+
+      expect(exit).toBe(0);
+      expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", expect.objectContaining({
+        buildParams: [{ name: "tier", value: "production", source: "cli" }],
+      }));
+      expect(stderr.join("\n")).toContain("[param] tier");
+      vi.restoreAllMocks();
+    });
+
+    test("an unresolved required build-time parameter → exit 1 with a formatted error naming it, never reaches runComponents (the previously-{} probe, now a hard stop instead)", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string" } } },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
+
+      expect(exit).toBe(1);
+      expect(stderr.join("\n")).toMatch(/"tier"/);
+      expect(runComponentsMock).not.toHaveBeenCalled();
+    });
+
+    test("an enum violation on --param → exit 1 with a formatted error, never reaches runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", enum: ["light", "production"] } } },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({
+        args: makeArgs({ path: "svc", temporal: false, param: ["tier=bogus"] }),
+        plugins: [],
+        serializers: [],
+      });
+
+      expect(exit).toBe(1);
+      expect(stderr.join("\n")).toMatch(/"tier"/);
+      expect(stderr.join("\n")).toMatch(/bogus/);
+      expect(runComponentsMock).not.toHaveBeenCalled();
+    });
+  });
+
   test("happy path: single component, human output, exit 0", async () => {
     runComponentsMock.mockResolvedValue({
       success: true,
@@ -916,7 +997,7 @@ describe("runOpComponents", () => {
     const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {}, buildParams: [] });
     const printed = stderrWrite.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("interpret run completed");
     vi.restoreAllMocks();
@@ -928,7 +1009,7 @@ describe("runOpComponents", () => {
 
     await runOpComponents({ args: makeArgs({ path: "svc", env: "staging", temporal: false }), plugins: [], serializers: [] });
 
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: "staging", componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: "staging", componentOutputs: {}, buildParams: [] });
     vi.restoreAllMocks();
   });
 
@@ -994,6 +1075,7 @@ describe("runOpComponents", () => {
       env: undefined,
       componentOutputs: {},
       onProgress: undefined,
+      buildParams: [],
     });
     expect(stdoutWrite).not.toHaveBeenCalled();
     vi.restoreAllMocks();
@@ -1018,7 +1100,7 @@ describe("runOpComponents", () => {
     const exit = await runOpComponents({ args: makeArgs({ path: "all", temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "all", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "all", { env: undefined, componentOutputs: {}, buildParams: [] });
     const printed = stderrWrite.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("shared-alb");
     expect(printed).toContain("search-service");
@@ -1269,7 +1351,13 @@ describe("runOpComponents: --temporal routes to the durable path", () => {
     resolveComponentTargetsMock.mockReset();
     findComponentGateMock.mockReset();
     loadComponentTemporalCodegenMock.mockReset();
-    loadChantConfigMock.mockReset();
+    // chant #1108 — runOpComponents now resolves build-time parameters (which
+    // needs chant.config.ts's declared `buildParams`) BEFORE dispatching to
+    // either the local or --temporal path, so every test in this block hits
+    // loadChantConfig at least once now, even ones that never reach the rest
+    // of the durable path (e.g. "unknown component"). Individual tests below
+    // still override this where they care about a specific config shape.
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
     resolveProfileMock.mockReset();
     loadTemporalClientMock.mockReset();
     spawnChildMock.mockReset();
@@ -1297,6 +1385,73 @@ describe("runOpComponents: --temporal routes to the durable path", () => {
     expect(stderr.join("\n")).toContain('Component "missing" not found');
   });
 
+  // ── build-time parameters (chant #1108) — resolved before discovery here too ─
+
+  test("resolved build-time parameters are forwarded into resolveComponentTargets on the --temporal path", async () => {
+    process.env.LOOM_ENV = "staging";
+    resolveComponentTargetsMock.mockResolvedValue({
+      success: true,
+      targets: [{ name: "gated-svc", dependsOn: [], deploy: [] }],
+    });
+    resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+    loadComponentTemporalCodegenMock.mockResolvedValue({
+      serializeComponent: () => ({ "components/gated-svc/worker.ts": "// worker" }),
+      componentWorkflowFnName: (name: string) => `${name}ComponentWorkflow`,
+    });
+    const mockClient = createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-component-gated-svc": {
+          workflowId: "chant-component-gated-svc", runId: "r1",
+          status: { name: "COMPLETED" }, startTime: new Date(),
+          taskQueue: "gated-svc", type: { name: "gatedSvcComponentWorkflow" },
+        },
+      },
+      historyByWorkflowId: { "chant-component-gated-svc": [] },
+    });
+    // setupTemporalClient sets its own default loadChantConfigMock resolved
+    // value, so the test's own (buildParams-declaring) config must be set
+    // AFTER calling it, not before.
+    setupTemporalClient(mockClient);
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { env: { type: "string", env: "LOOM_ENV", default: "dev" } } },
+    });
+    const { proc } = makeFakeChildProcess();
+    spawnChildMock.mockReturnValue(proc);
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+    try {
+      vi.useFakeTimers();
+      const promise = runOpComponents({ args: makeArgs({ path: "gated-svc", temporal: true }), plugins: [], serializers: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+      const exit = await promise;
+
+      expect(exit).toBe(0);
+      expect(resolveComponentTargetsMock).toHaveBeenCalledWith(
+        expect.any(String),
+        "gated-svc",
+        undefined,
+        [{ name: "env", value: "staging", source: "env" }],
+      );
+    } finally {
+      vi.useRealTimers();
+      vi.restoreAllMocks();
+      delete process.env.LOOM_ENV;
+    }
+  });
+
+  test("an unresolved required build-time parameter → exit 1, never reaches resolveComponentTargets", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string" } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runOpComponents({ args: makeArgs({ path: "gated-svc", temporal: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(resolveComponentTargetsMock).not.toHaveBeenCalled();
+  });
+
   test("compiles the component, spawns the worker, submits the workflow, polls to COMPLETED", async () => {
     vi.useFakeTimers();
     try {

package/src/cli/handlers/run.ts

@@ -2,12 +2,13 @@ import { resolve, join, dirname } from "node:path";
 import { existsSync, writeFileSync, mkdirSync, readFileSync } from "node:fs";
 import { createConnection } from "node:net";
 import { spawn as spawnChild, type ChildProcess } from "node:child_process";
-import { loadChantConfig, resolveAutoReleaseDisabled } from "../../config";
+import { loadChantConfig, resolveAutoReleaseDisabled, type ChantConfig } from "../../config";
 import { discoverOps } from "../../op/discover";
 import { loadActivities, loadProfiles } from "../../op/activity-registry";
 import { runOpLocally, findGate, LocalGateUnsupportedError, OpRunFailure } from "../../op/local-executor";
 import { renderHuman, renderJson } from "../../op/local-output";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
+import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
 import type { CommandContext } from "../registry";
 import {
   loadTemporalClient,
@@ -27,6 +28,7 @@ import { applyConfigDefaults } from "../../components/config-defaults";
 import { maybeRecordAutoRelease, extractRunDigestFromPhaseOutputs } from "../../components/auto-release";
 import { maybePersistBuildManifest, extractRunManifestFromPhaseOutputs } from "../../components/manifest-persistence";
 import type { DriverComponentResult } from "../../components/driver";
+import type { BuildParamProvenance } from "../../provenance";
 
 function kebabToCamel(s: string): string {
   return s.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
@@ -669,6 +671,18 @@ async function recordAutoReleasesForRun(
  * Opt out with `--no-release-record` or `chant.config.ts`'s
  * `release.autoRecord: false`; the default is ON. A failed run never reaches
  * this step, so it writes nothing.
+ *
+ * chant #1108 — resolves this invocation's declared build-time parameters
+ * (`chant.config.ts`'s `buildParams`, against `--param`/`--params-file`/a
+ * declared `env` mapping) the exact same way `chant build` does
+ * (`resolveCliBuildParams`, shared with `buildCommand`), BEFORE either the
+ * local or `--temporal` path discovers/imports any `*.component.ts` file.
+ * Before this, `params.*` (`@intentius/chant/params`) was always `{}` under
+ * this command, no matter what a component's `chant.config.ts` declared or a
+ * CI job's environment supplied — see chant #1108. `chant.config.ts` is
+ * loaded once here (with the same defensive fallback the post-run
+ * auto-release check below used to apply itself) and reused for that check,
+ * rather than loaded a second time.
  */
 export async function runOpComponents(ctx: CommandContext): Promise<number> {
   const selector = ctx.args.path;
@@ -680,7 +694,18 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
     return 1;
   }
 
-  if (ctx.args.temporal) return runComponentTemporal(ctx, selector);
+  const projectPath = resolve(".");
+  const { config } = await loadChantConfig(projectPath).catch(() => ({ config: {} as ChantConfig }));
+  const paramsResolution = resolveCliBuildParams(config.buildParams, {
+    cli: parseParamFlags(ctx.args.param),
+    paramsFile: ctx.args.paramsFile,
+  });
+  if (!paramsResolution.success) {
+    for (const message of paramsResolution.errors) console.error(message);
+    return 1;
+  }
+
+  if (ctx.args.temporal) return runComponentTemporal(ctx, selector, config, paramsResolution.provenance);
 
   const env = ctx.args.env ?? "local";
   // Seed cross-component/cross-stack outputs from upstream jobs' dumped files
@@ -704,11 +729,12 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
   // `undefined` and every `onProgress?.(...)` call in the driver is a no-op —
   // behavior is byte-for-byte unchanged from before this flag existed.
   const onProgress = ctx.args.progressJson ? ndjsonProgressSink() : undefined;
-  const result = await runComponents(resolve("."), selector, {
+  const result = await runComponents(projectPath, selector, {
     env: ctx.args.env,
     componentOutputs: seededOutputs,
     onProgress,
     sandbox: ctx.args.sandbox,
+    buildParams: paramsResolution.provenance,
   });
 
   // Dump the accumulated outputs for a downstream job to seed from. Written
@@ -739,7 +765,6 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
   }
 
   if (result.success && result.run) {
-    const { config } = await loadChantConfig(resolve(".")).catch(() => ({ config: {} }));
     const disabled = resolveAutoReleaseDisabled(config, ctx.args.noReleaseRecord);
     await recordAutoReleasesForRun(result.run.results, env, `local-${Date.now()}`, disabled);
   }
@@ -771,8 +796,19 @@ function componentWorkflowId(componentName: string): string {
  * crash and clearable via `chant run signal <name> <signal> --components
  * --temporal` (`runOpSignal` above, extended for components alongside this
  * issue).
+ *
+ * `config`/`buildParams` are resolved once by the caller (`runOpComponents`,
+ * chant #1108) BEFORE this function runs, so `resolveComponentTargets`
+ * below — which discovers/imports the target `*.component.ts` file — sees
+ * `params.*` (`@intentius/chant/params`) already populated, the same
+ * guarantee the local executor path gets.
  */
-async function runComponentTemporal(ctx: CommandContext, selector: string): Promise<number> {
+async function runComponentTemporal(
+  ctx: CommandContext,
+  selector: string,
+  config: ChantConfig,
+  buildParams: BuildParamProvenance[],
+): Promise<number> {
   if (selector === "all") {
     console.error(formatError({
       message: "`chant run --components all --temporal` is not supported",
@@ -782,15 +818,17 @@ async function runComponentTemporal(ctx: CommandContext, selector: string): Prom
   }
 
   const projectPath = resolve(".");
-  const resolved = await resolveComponentTargets(projectPath, selector, ctx.args.sandbox);
+  const resolved = await resolveComponentTargets(projectPath, selector, ctx.args.sandbox, buildParams);
   if (!resolved.success || resolved.targets.length === 0) {
     console.error(formatError({ message: resolved.error ?? `Component "${selector}" not found` }));
     return 1;
   }
   const component = resolved.targets[0];
 
-  // Load config + profile (mirrors runOpTemporal).
-  const { config: chantConfig } = await loadChantConfig(projectPath);
+  // Config + profile (mirrors runOpTemporal). `config` was already loaded by
+  // the caller to resolve build-time parameters (chant #1108); reused here
+  // rather than loading chant.config.ts a second time.
+  const chantConfig = config;
   let profile;
   try {
     profile = resolveProfile(chantConfig as Record<string, unknown>, ctx.args.profile);

package/src/cli/lsp/server.ts

@@ -1,4 +1,4 @@
-import type { LexiconPlugin } from "../../lexicon";
+import type { LexiconPlugin, IntrinsicDef } from "../../lexicon";
 import type { CompletionContext, HoverContext, CodeActionContext } from "../../lsp/types";
 import { computeCapabilities } from "./capabilities";
 import { toLspDiagnostics } from "./diagnostics";
@@ -356,13 +356,18 @@ export class LspServer {
     try {
       const { runLint } = await import("../../lint/engine");
       const rules = [];
+      // chant #1106 — the same active plugins' registered intrinsics, so
+      // EVL001 answers exactly like `fold()` does for a registered,
+      // opted-in call instead of flagging every call as a violation.
+      const intrinsics: IntrinsicDef[] = [];
       for (const plugin of this.plugins) {
         rules.push(...(plugin.lintRules?.() ?? []));
+        intrinsics.push(...(plugin.intrinsics?.() ?? []));
       }
 
       if (rules.length === 0) return [];
 
-      const { diagnostics } = await runLint([filePath], rules);
+      const { diagnostics } = await runLint([filePath], rules, undefined, intrinsics);
       return toLspDiagnostics(diagnostics);
     } catch {
       return [];

package/src/components/cli-support.test.ts

@@ -8,16 +8,45 @@
  * rather than going through the CLI arg-parsing/handler dispatch layer.
  */
 
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdir, writeFile, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { join, dirname, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
 import Ajv2020 from "ajv/dist/2020";
 import componentSchema from "./component.schema.json";
-import { listComponents, describeComponent, computeComponentGraph, runComponents, findComponentGate } from "./cli-support";
+import {
+  listComponents,
+  describeComponent,
+  computeComponentGraph,
+  runComponents,
+  findComponentGate,
+  resolveComponentTargets,
+  generateComponentsPipeline,
+} from "./cli-support";
 import { CapabilityRegistry, type DeployContext } from "./capability";
 import type { DriverComponent, RunProgressEvent } from "./driver";
 
+// A minimal stand-in for the real gitlab lexicon plugin, satisfying
+// `isLexiconPlugin` (../lexicon.ts) — used only by the `generateComponentsPipeline`
+// buildParams test below, so that test doesn't depend on how `@intentius/
+// chant-lexicon-gitlab`'s own real module resolves under the test runner.
+vi.mock("@intentius/chant-lexicon-gitlab", () => ({
+  gitlab: {
+    name: "gitlab",
+    serializer: { name: "gitlab", rulePrefix: "GL", serialize: () => "" },
+    generate: () => {},
+    validate: () => [],
+    coverage: () => ({ total: 0, covered: 0 }),
+    package: () => "gitlab",
+    generateComponentPipeline: (components: DriverComponent[]) => ({
+      yaml: components.map((c) => c.name).join(","),
+      stages: ["wave-1"],
+      jobs: components.map((c) => ({ jobName: c.name, component: c.name, stage: "wave-1", needs: [] })),
+    }),
+  },
+}));
+
 describe("listComponents", () => {
   let testDir: string;
 
@@ -578,6 +607,195 @@ describe("runComponents", () => {
   });
 });
 
+// ── build-time parameters (chant #1108) ──────────────────────────────────────
+//
+// Before #1108, `discoverComponents`'s callers here never resolved
+// `chant.config.ts`'s declared `buildParams` at all, so a `*.component.ts`
+// file reading `params.<name>` (`@intentius/chant/params`) always saw `{}` —
+// the exact probe from chant#1108's reproduction. These tests lock in that
+// `runComponents`/`resolveComponentTargets`/`generateComponentsPipeline` now
+// forward an already-resolved `buildParams` into discovery, so a component's
+// `params.<name>` read reflects it before any step dispatches.
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const paramsModulePath = resolvePath(thisDir, "../params");
+
+describe("runComponents — buildParams (chant #1108)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-run-components-buildparams-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("the previously-{} case: a component's params.<name> read resolves when buildParams is passed", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `
+        import { params } from ${JSON.stringify(paramsModulePath)};
+        export const svc = {
+          name: "svc",
+          dependsOn: [],
+          deploy: [{ phase: "Apply", steps: [{ kind: "deploy-thing", tier: params.tier }] }],
+        };
+      `,
+    );
+
+    const capability = fakeCapability("deploy-thing");
+    const registry = new CapabilityRegistry();
+    registry.register(capability);
+
+    const result = await runComponents(testDir, "svc", {
+      registry,
+      buildParams: [{ name: "tier", value: "production", source: "cli" }],
+    });
+
+    expect(result.success).toBe(true);
+    expect(capability.calls[0]?.input).toMatchObject({ tier: "production" });
+  });
+
+  test("without buildParams, params.<name> is undefined (the bug this issue fixes, still true for a caller that resolves none)", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `
+        import { params } from ${JSON.stringify(paramsModulePath)};
+        export const svc = {
+          name: "svc",
+          dependsOn: [],
+          deploy: [{ phase: "Apply", steps: [{ kind: "deploy-thing", tier: params.tier ?? "unset" }] }],
+        };
+      `,
+    );
+
+    const capability = fakeCapability("deploy-thing");
+    const registry = new CapabilityRegistry();
+    registry.register(capability);
+
+    const result = await runComponents(testDir, "svc", { registry });
+
+    expect(result.success).toBe(true);
+    expect(capability.calls[0]?.input).toMatchObject({ tier: "unset" });
+  });
+
+  test("RunComponentsResult.buildParams echoes back the resolved provenance that was passed in", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `export const svc = { name: "svc", dependsOn: [], deploy: [{ phase: "Apply", steps: [{ kind: "deploy-thing" }] }] };`,
+    );
+
+    const registry = fakeRegistry();
+    const result = await runComponents(testDir, "svc", {
+      registry,
+      buildParams: [{ name: "tier", value: "production", source: "cli" }],
+    });
+
+    expect(result.buildParams).toEqual([{ name: "tier", value: "production", source: "cli" }]);
+  });
+
+  test("selector 'all' also forwards buildParams into discovery", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `
+        import { params } from ${JSON.stringify(paramsModulePath)};
+        export const svc = { name: "svc", dependsOn: [], deploy: [{ phase: "Apply", steps: [{ kind: "deploy-thing", tier: params.tier }] }] };
+      `,
+    );
+
+    const capability = fakeCapability("deploy-thing");
+    const registry = new CapabilityRegistry();
+    registry.register(capability);
+
+    const result = await runComponents(testDir, "all", {
+      registry,
+      buildParams: [{ name: "tier", value: "staging", source: "env" }],
+    });
+
+    expect(result.success).toBe(true);
+    expect(capability.calls[0]?.input).toMatchObject({ tier: "staging" });
+  });
+});
+
+describe("resolveComponentTargets — buildParams (chant #1108)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-resolve-targets-buildparams-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("forwards buildParams into discovery — the durable (--temporal) path's entrypoint", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `
+        import { params } from ${JSON.stringify(paramsModulePath)};
+        export const svc = {
+          name: "svc",
+          dependsOn: [],
+          deploy: [{ phase: "Apply", steps: [{ kind: "cfn-deploy", stack: params.env }] }],
+        };
+      `,
+    );
+
+    const result = await resolveComponentTargets(testDir, "svc", undefined, [
+      { name: "env", value: "prod-a", source: "env" },
+    ]);
+
+    expect(result.success).toBe(true);
+    expect((result.targets[0].deploy[0].steps[0] as { stack?: unknown }).stack).toBe("prod-a");
+  });
+});
+
+describe("generateComponentsPipeline — buildParams (chant #1108)", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-generate-components-buildparams-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("forwards buildParams into discovery before synthesizing the pipeline", async () => {
+    await writeFile(
+      join(testDir, "svc.component.ts"),
+      `
+        import { params } from ${JSON.stringify(paramsModulePath)};
+        export const svc = {
+          name: String(params.name),
+          dependsOn: [],
+          deploy: [{ phase: "Apply", steps: [{ kind: "shell" }] }],
+        };
+      `,
+    );
+
+    // Uses the mocked "gitlab" plugin above (see the `vi.mock` at the top of
+    // this file) — proves the component name `discoverComponents` resolved
+    // (via `params.name`) made it all the way through to the synthesized
+    // pipeline, not just to `discover()`'s own return value.
+    const result = await generateComponentsPipeline(
+      testDir,
+      "gitlab",
+      undefined,
+      undefined,
+      [{ name: "name", value: "named-from-params", source: "cli" }],
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.jobs?.map((j) => j.component)).toEqual(["named-from-params"]);
+    expect(result.buildParams).toEqual([{ name: "name", value: "named-from-params", source: "cli" }]);
+  });
+});
+
 describe("runComponents — onProgress (--progress-json wiring, M3)", () => {
   let testDir: string;