@intentius/chant 0.21.0 → 0.23.0

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

@@ -0,0 +1,147 @@
+/**
+ * Tests for `chant build --components --generate <lexicon>` (generate mode,
+ * #563) — specifically its chant #1108 build-time-parameter resolution,
+ * which was entirely missing before this fix: `generateComponentsPipeline`'s
+ * `discoverComponents` call never resolved `chant.config.ts`'s declared
+ * `buildParams`, so a `*.component.ts` file reading `params.<name>` always
+ * saw `{}` under `chant build --components --generate`, exactly like `chant
+ * 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
+ * exported), mirroring `run.test.ts`'s style of driving the handler through
+ * its `CommandContext` entrypoint rather than reaching into private helpers.
+ */
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import type { ParsedArgs } from "../registry";
+
+const generateComponentsPipelineMock = vi.fn();
+const loadChantConfigMock = 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) };
+});
+
+const { runBuild } = await import("./build");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "build",
+    path: ".",
+    format: "",
+    fix: false,
+    watch: false,
+    verbose: false,
+    help: false,
+    live: false,
+    components: true,
+    generate: "gitlab",
+    ...overrides,
+  };
+}
+
+function makeStderrSpy() {
+  const buf: string[] = [];
+  vi.spyOn(console, "error").mockImplementation((s: string) => { buf.push(s); });
+  return buf;
+}
+
+describe("runBuild --components --generate (chant #1108 build-time parameters)", () => {
+  beforeEach(() => {
+    generateComponentsPipelineMock.mockReset();
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
+  });
+
+  test("no declared buildParams → generateComponentsPipeline is called with an empty provenance array", async () => {
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(".", "gitlab", { env: undefined }, undefined, []);
+    vi.restoreAllMocks();
+  });
+
+  test("chant.config.ts's declared buildParams resolve, log, and are forwarded to generateComponentsPipeline", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", default: "light" } } },
+    });
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(
+      ".",
+      "gitlab",
+      { env: undefined },
+      undefined,
+      [{ name: "tier", value: "light", source: "default" }],
+    );
+    expect(stderr.join("\n")).toContain("[param] tier");
+    vi.restoreAllMocks();
+  });
+
+  test("--param overrides a declared default", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", default: "light" } } },
+    });
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const exit = await runBuild({
+      args: makeArgs({ param: ["tier=production"] }),
+      plugins: [],
+      serializers: [],
+    });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(
+      ".",
+      "gitlab",
+      { env: undefined },
+      undefined,
+      [{ name: "tier", value: "production", source: "cli" }],
+    );
+    vi.restoreAllMocks();
+  });
+
+  test("an unresolved required build-time parameter → exit 1, never reaches generateComponentsPipeline", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string" } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(generateComponentsPipelineMock).not.toHaveBeenCalled();
+  });
+
+  test("an enum violation on --param → exit 1, never reaches generateComponentsPipeline", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", enum: ["light", "production"] } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({
+      args: makeArgs({ param: ["tier=bogus"] }),
+      plugins: [],
+      serializers: [],
+    });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(stderr.join("\n")).toMatch(/bogus/);
+    expect(generateComponentsPipelineMock).not.toHaveBeenCalled();
+  });
+});

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 [];