@intentius/chant 0.124.22 → 0.124.24

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

@@ -61,6 +61,7 @@ vi.mock("node:fs", async () => {
   };
 });
 vi.mock("../../components/cli-support", () => ({
+  isComponentList: (selector: string) => selector.includes(","),
   runComponents: (...args: unknown[]) => runComponentsMock(...args),
   listComponents: (...args: unknown[]) => listComponentsMock(...args),
 }));
@@ -1277,6 +1278,25 @@ describe("runOp dispatcher: --components routes to runOpComponents", () => {
     vi.restoreAllMocks();
   });
 
+  test("a list selector prints the resolved order and the added dependencies before running (#3950)", async () => {
+    discoverOpsMock.mockReset();
+    const stderr = makeStderrSpy();
+    let printedBeforeRun = "";
+    runComponentsMock.mockImplementation(async (_path: string, _selector: string, options: { onPlan?: (plan: unknown) => void }) => {
+      options.onPlan?.({ order: ["db", "api", "web"], waves: [["db"], ["api", "web"]], added: ["db"] });
+      printedBeforeRun = stderr.join("\n");
+      return { success: true, selected: ["db", "api", "web"], run: { order: ["db", "api", "web"], waves: [["db"], ["api", "web"]], results: [], ok: true, status: "ok" } };
+    });
+
+    const exit = await runOp({ args: makeArgs({ path: "api,web", components: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "api,web", expect.objectContaining({ onPlan: expect.any(Function) }));
+    expect(printedBeforeRun).toContain("run order: db, then api + web");
+    expect(printedBeforeRun).toContain("added as dependencies: db");
+    vi.restoreAllMocks();
+  });
+
   // chant #1116 — the component driver never checked --report, so it was
   // silently ignored and the command fell through to a real dispatch.
   // Hard-error instead, before runComponents is ever reached.
@@ -1929,3 +1949,109 @@ describe("runOp: --fail-on-drift (#3675)", () => {
     expect(await runOp({ args: makeArgs({ path: "watch" }), plugins: [], serializers: [] })).toBe(2);
   });
 });
+
+/**
+ * chant #3955 — `--no-record` runs every step and records nothing on
+ * `chant/lifecycle`. The run says so before it starts and after it ends, a
+ * gate fails rather than recording a pending fact nobody could approve, and
+ * a runtime that would record elsewhere is refused.
+ */
+describe("runOp --no-record (#3955)", () => {
+  const START = "not recording (--no-record)";
+  const END = "not recorded (--no-record): nothing went on chant/lifecycle and nothing was pushed";
+
+  beforeEach(() => {
+    discoverOpsMock.mockReset();
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
+    loadPluginsMock.mockReset().mockResolvedValue([]);
+    runComponentsMock.mockReset();
+    maybeRecordAutoReleaseMock.mockReset();
+    maybePersistBuildManifestMock.mockReset().mockResolvedValue({ persisted: false, reason: "no-manifest" });
+    gateLedger = memoryGateLedgerPort();
+    delete process.env.CHANT_NO_RECORD;
+  });
+
+  afterEach(() => {
+    delete process.env.CHANT_NO_RECORD;
+    vi.restoreAllMocks();
+  });
+
+  test("an Op runs, the run says at its start and end that nothing was recorded, and the flag does not outlive it", async () => {
+    let during: string | undefined;
+    discoverOpsMock.mockImplementation(async () => {
+      during = process.env.CHANT_NO_RECORD;
+      return { ops: new Map([localOp("hello", [{ kind: "activity", fn: "shellCmd", profile: "atMostOnce", args: { cmd: "true" } }])]), errors: [] };
+    });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "hello", noRecord: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(during).toBe("1");
+    expect(process.env.CHANT_NO_RECORD).toBeUndefined();
+    expect(stderr[0]).toContain(START);
+    expect(stderr.at(-1)).toContain(END);
+  });
+
+  test("a gate fails the run and leaves no pending fact, and the end line still prints", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([localOp("gated", [{ kind: "gate", gate: "approve-prod" }])]), errors: [] });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "gated", noRecord: true, gatedExit: 0 }), plugins: [], serializers: [] });
+
+    // A failure, not a gated stop: --gated-exit cannot turn it green.
+    expect(exit).toBe(1);
+    expect(gateLedger.appended).toHaveLength(0);
+    expect(stderr.at(-1)).toContain(END);
+  });
+
+  test("CHANT_NO_RECORD does the same without the flag, names itself, and stays set", async () => {
+    process.env.CHANT_NO_RECORD = "1";
+    discoverOpsMock.mockResolvedValue({ ops: new Map([localOp("hello", [])]), errors: [] });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "hello" }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(stderr[0]).toContain("not recording (CHANT_NO_RECORD=1)");
+    expect(process.env.CHANT_NO_RECORD).toBe("1");
+  });
+
+  test("a runtime other than local is refused before the run starts", async () => {
+    const start = vi.fn();
+    loadChantConfigMock.mockResolvedValue({ config: { lexicons: ["stub"] } });
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({
+      args: makeArgs({ path: "hello", on: "stub", noRecord: true }),
+      plugins: [{ name: "stub", opRuntime: { name: "stub", start } } as never], serializers: [],
+    });
+
+    expect(exit).toBe(1);
+    expect(start).not.toHaveBeenCalled();
+    expect(stderr.join("\n")).toContain('--no-record runs on the local runtime; the "stub" runtime records the run where it executes it');
+  });
+
+  test("--components records no release and persists no manifest", async () => {
+    runComponentsMock.mockResolvedValue({
+      success: true,
+      selected: ["svc"],
+      run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, status: "ok", records: [] }], ok: true, status: "ok" },
+    });
+    maybeRecordAutoReleaseMock.mockResolvedValue({ recorded: false, reason: "opted-out" });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    const stderr = makeStderrSpy();
+
+    const exit = await runOpComponents({ args: makeArgs({ path: "svc", noRecord: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(maybeRecordAutoReleaseMock.mock.calls[0][1]).toMatchObject({ disabled: true });
+    expect(maybePersistBuildManifestMock.mock.calls[0][1]).toMatchObject({ disabled: true });
+    expect(stderr[0]).toContain(START);
+    expect(stderr.at(-1)).toContain(END);
+  });
+});

package/src/cli/handlers/run.ts

@@ -23,11 +23,13 @@ import { acquireStewardTurn, STEWARD_TURN_WAIT_MS } from "../../op/operator";
 import { releaseLease, currentHolderId, type AcquireLeaseResult } from "../../lifecycle/lease";
 import { StaleLockError } from "../../lifecycle/git";
 import { LIFECYCLE_LOCAL_NOTE, isLifecycleLocalNote } from "../../lifecycle/local-note";
+import { ledgerRecordingOff, noRecordEndNote, noRecordStartNote, resetNoRecordLedger, NO_RECORD_ENV } from "../../lifecycle/no-record";
 import { renderDriverHuman, renderDriverJson } from "../../components/driver-output";
 import { ndjsonProgressSink } from "../../components/run-progress";
 import { maybeRecordAutoRelease } from "../../components/auto-release";
 import { maybePersistBuildManifest } from "../../components/manifest-persistence";
 import type { DriverComponentResult } from "../../components/driver";
+import { isComponentList, type ComponentRunPlan } from "../../components/cli-support";
 import type { ReleaseRecord } from "../../lifecycle/release-ledger";
 import { runOpGenerate } from "./run-generate";
 
@@ -873,12 +875,13 @@ export async function recordAutoReleasesForRun(
   return recorded;
 }
 
-// ── chant run --components <name|all> ────────────────────────────────────────
+// ── chant run --components <name|all|a,b,c> ──────────────────────────────────
 
 /**
- * `chant run --components <name|all> [--env <env>]` (#585) — the interpret
- * driver's CLI entrypoint, and since #2116 the only component run path there
- * is. `args.path` is the component name (or `all`), matching `chant run
+ * `chant run --components <name|all|a,b,c> [--env <env>]` (#585) — the
+ * interpret driver's CLI entrypoint, and since #2116 the only component run
+ * path there is. `args.path` is the component name (or `all`, or a comma list
+ * that also runs what the named components depend on, #3950), matching `chant run
  * <name>`'s Op-dispatch convention exactly (`args.path` is the Op name there
  * too) rather than a project directory — components are always discovered from
  * the current working directory, the same way Op discovery (`discoverOps()`)
@@ -909,11 +912,52 @@ export async function recordAutoReleasesForRun(
  * 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> {
+export function runOpComponents(ctx: CommandContext): Promise<number> {
+  return withRecordingChoice(ctx, () => runComponentSelection(ctx));
+}
+
+/**
+ * Run `run` with recording off when `--no-record` or `CHANT_NO_RECORD` asks
+ * for it (#3955), and say so before it starts and after it ends, whatever
+ * the outcome. The flag sets `CHANT_NO_RECORD` for the length of the run, so
+ * the ledger seam (`../../lifecycle/git.ts`) and every chant process a step
+ * starts see the same choice. A run with recording on is untouched.
+ */
+async function withRecordingChoice(ctx: CommandContext, run: () => Promise<number>): Promise<number> {
+  const flagged = ctx.args.noRecord === true;
+  if (!flagged && !ledgerRecordingOff()) return run();
+  const source = flagged ? "--no-record" : `${NO_RECORD_ENV}=${process.env[NO_RECORD_ENV]}`;
+  const prior = process.env[NO_RECORD_ENV];
+  if (flagged) process.env[NO_RECORD_ENV] = "1";
+  resetNoRecordLedger();
+  console.error(formatWarning({ message: noRecordStartNote(source) }));
+  try {
+    return await run();
+  } finally {
+    console.error(formatWarning({ message: noRecordEndNote(source) }));
+    resetNoRecordLedger();
+    if (flagged) {
+      if (prior === undefined) delete process.env[NO_RECORD_ENV];
+      else process.env[NO_RECORD_ENV] = prior;
+    }
+  }
+}
+
+/** A run that records nothing stays in this process (#3955): a runtime that runs it elsewhere would record there. */
+function refusesNoRecordOn(runtime: Pick<OpRuntimeProvider, "name">): boolean {
+  if (!ledgerRecordingOff() || runtime.name === "local") return false;
+  console.error(formatError({
+    message: `--no-record runs on the local runtime; the "${runtime.name}" runtime records the run where it executes it`,
+    hint: `Omit --on to run it here without recording, or drop --no-record (and ${NO_RECORD_ENV}).`,
+  }));
+  return true;
+}
+
+async function runComponentSelection(ctx: CommandContext): Promise<number> {
   const selector = ctx.args.path;
   if (!selector || selector === ".") {
     console.error(formatError({
-      message: "Component name is required: chant run --components <name|all>",
+      message: "Component name is required: chant run --components <name|all|a,b,c>",
       hint: "Run `chant list --components` to see available components.",
     }));
     return 1;
@@ -936,6 +980,7 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
 
   const runtime = await resolveOpRuntime(ctx);
   if (!runtime) return 1;
+  if (refusesNoRecordOn(runtime)) return 1;
   if (!runtime.runComponents) {
     console.error(formatError({
       message: `--components is not supported on the "${runtime.name}" runtime`,
@@ -966,12 +1011,22 @@ 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;
+  // A list (#3950) pulls in what its components depend on; say which ones and
+  // in what order before the first one runs. stderr, so --json and
+  // --progress-json keep stdout to themselves.
+  const onPlan = isComponentList(selector)
+    ? (plan: ComponentRunPlan) => {
+        console.error(formatInfo(`run order: ${plan.waves.map((wave) => wave.join(" + ")).join(", then ")}`));
+        if (plan.added.length > 0) console.error(formatInfo(`added as dependencies: ${plan.added.join(", ")}`));
+      }
+    : undefined;
   const result = await runtime.runComponents(projectPath, selector, {
     env: ctx.args.env,
     componentOutputs: seededOutputs,
     onProgress,
     sandbox: ctx.args.sandbox,
     buildParams: paramsResolution.provenance,
+    ...(onPlan ? { onPlan } : {}),
   });
 
   // Dump the accumulated outputs for a downstream job to seed from. Written
@@ -1037,7 +1092,8 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
   }
 
   if (result.success && result.run) {
-    const disabled = resolveAutoReleaseDisabled(config, ctx.args.noReleaseRecord);
+    // #3955: a run that records nothing has no release to report either.
+    const disabled = resolveAutoReleaseDisabled(config, ctx.args.noReleaseRecord) || ledgerRecordingOff();
     const recorded = await recordAutoReleasesForRun(result.run.results, env, `local-${Date.now()}`, disabled);
     // `--digest-file` (#2602): the releases this run recorded, one
     // `<component>=<digest>` line each, the form `chant components promote
@@ -1065,7 +1121,11 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
  * what they were before the seam existed; a runtime that reports only a state
  * gets the terser render instead.
  */
-export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
+export function runOpOnRuntime(ctx: CommandContext): Promise<number> {
+  return withRecordingChoice(ctx, () => runOpOnResolvedRuntime(ctx));
+}
+
+async function runOpOnResolvedRuntime(ctx: CommandContext): Promise<number> {
   const opName = ctx.args.path;
   if (!opName || opName === ".") {
     console.error(formatError({
@@ -1108,7 +1168,7 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
   }
 
   const runtime = await resolveOpRuntime(ctx);
-  if (!runtime) {
+  if (!runtime || refusesNoRecordOn(runtime)) {
     await stewardGate?.release?.();
     return 1;
   }

package/src/cli/main.test.ts

@@ -361,6 +361,22 @@ describe("parseArgs", () => {
 
   // ── --no-release-record (#597) ───────────────────────────────────────────
 
+  test("emulator up --image/--network/--setting/--loopback parse, and a missing value is refused (#3952)", () => {
+    const a = parseArgs([
+      "emulator", "up", "--image", "floci/floci:1.6.0", "--network", "loom",
+      "--setting", "FLOCI_A=1", "--setting", "FLOCI_B=2", "--loopback",
+    ]);
+    expect(a.image).toBe("floci/floci:1.6.0");
+    expect(a.network).toBe("loom");
+    expect(a.setting).toEqual(["FLOCI_A=1", "FLOCI_B=2"]);
+    expect(a.loopback).toBe(true);
+    expect(parseArgs(["emulator", "up", "--setting=FLOCI_A=1"]).setting).toEqual(["FLOCI_A=1"]);
+    expect(() => parseArgs(["emulator", "up", "--image"])).toThrow(/--image needs an image reference/);
+    expect(() => parseArgs(["emulator", "up", "--network", "--json"])).toThrow(/--network needs a Docker network name/);
+    expect(() => parseArgs(["emulator", "up", "--setting"])).toThrow(/--setting needs a value/);
+    expect(() => parseArgs(["emulator", "up", "--loopback=yes"])).toThrow();
+  });
+
   test("--promote-to <env> sets promoteTo, and a missing value is refused (#2575)", () => {
     expect(parseArgs(["build", "--components", "--generate", "github", "--promote-to", "prod"]).promoteTo).toBe("prod");
     expect(() => parseArgs(["build", "--components", "--generate", "github", "--promote-to"])).toThrow(/--promote-to needs an environment/);
@@ -390,6 +406,14 @@ describe("parseArgs", () => {
     expect(result.noReleaseRecord).toBeUndefined();
   });
 
+  test("parses --no-record for run <op> and run --components, apart from --no-release-record (#3955)", () => {
+    expect(parseArgs(["run", "smoke", "--no-record"])).toMatchObject({ path: "smoke", noRecord: true });
+    const components = parseArgs(["run", "--components", "svc", "--no-record"]);
+    expect(components).toMatchObject({ components: true, noRecord: true });
+    expect(components.noReleaseRecord).toBeUndefined();
+    expect(parseArgs(["run", "smoke"]).noRecord).toBeUndefined();
+  });
+
   // ── --progress-json (M3, behold roadmap) ─────────────────────────────────
 
   test("parses --progress-json for run --components", () => {

package/src/cli/main.ts

@@ -253,6 +253,8 @@ Ops:
                         with a work lease runs under, and who holds it
                         --fail-on-drift: exit 2 when the run completes and
                         its Drift outcome is true (WatchOp failOn: "drift")
+                        --no-record: a test run that records nothing on
+                        chant/lifecycle and pushes nothing (local runtime)
   run list              List all Ops with the runtime's state for each
   run status <name>     Show the runtime's state for one Op's latest run
   run approve <op> <gate>  Record a gate's resolution and wake the runtime
@@ -261,7 +263,8 @@ Ops:
   run wave --spec <file> --wave <k>  Plan, gate and apply wave k of an Op
                         waves spec (#3679): the job a generated waves
                         pipeline runs. --decide plans and decides only;
-                        --share <i> applies one share of a decided wave.
+                        --share <i> applies one share of a decided wave;
+                        --group <name> applies one job group's runs.
                         --record-plans (no --wave), in a pull request's
                         pipeline: plan every wave at its head and record the
                         digests a pr-review approval mode compares
@@ -278,8 +281,11 @@ Ops:
                         declares a schedule or from --spec <file.json>.
                         Files go to the forge's own directory unless
                         --output <dir>; --format json prints them instead
-  run --components <name|all>  Run discovered Component(s) through the interpret
-                        driver on the local executor (--env <env>; #585).
+  run --components <name|all|a,b,c>  Run discovered Component(s) through the
+                        interpret driver on the local executor (--env <env>;
+                        #585). A comma list also runs what the named
+                        components depend on, in dependency order, in one
+                        run, and prints that order first (#3950).
                         On success, auto-emits a release-ledger record per
                         component that published a digest (default: on;
                         --no-release-record to opt out; #597)
@@ -807,7 +813,8 @@ Lexicon development:
 Local:
   emulator <up|down|status>  Boot/stop/inspect configured lexicons' local
                            emulators (Floci etc.); --lexicon <name>, --json,
-                           --port; \`chant emulator --help\` lists ports and logins
+                           --port, --image, --network, --setting, --loopback;
+                           \`chant emulator --help\` lists ports and logins
 
 Servers:
   serve lsp             Start the LSP server (stdio)
@@ -880,6 +887,12 @@ Options:
                         successful \`run --components\` deploy (default: on;
                         also settable via chant.config.ts's
                         release.autoRecord: false; #597)
+  --no-record           (run <op>, run --components) Run every step but record
+                        nothing on chant/lifecycle and push nothing: no
+                        release, run record, receipt or gate fact. A gate
+                        step fails. The run says so at its start and end.
+                        CHANT_NO_RECORD=1 does the same for a whole CI job
+                        (#3955)
   --fold                (build) Fold source modules statically instead of
                         running them; folds resource constructors and
                         composite factory calls (#1022/#1023), falling back

package/src/cli/parse-args.ts

@@ -54,6 +54,7 @@ const BOOLEAN_FLAGS = new Set([
   "--check",
   "--bump",
   "--no-release-record",
+  "--no-record",
   "--fold",
   "--no-fold",
   "--no-cache",
@@ -74,6 +75,7 @@ const BOOLEAN_FLAGS = new Set([
   "--generated",
   "--decide",
   "--record-plans",
+  "--loopback",
 ]);
 
 /**
@@ -261,6 +263,18 @@ export function parseArgs(args: string[]): ParsedArgs {
       const value = args[++i];
       if (!value || value.startsWith("-")) throw new Error("--port needs a port: --port <container-port>=<host-port>");
       (result.port ??= []).push(value);
+    } else if (arg === "--image") {
+      result.image = args[++i];
+      if (!result.image || result.image.startsWith("-")) throw new Error("--image needs an image reference: --image <name>:<tag>");
+    } else if (arg === "--network") {
+      result.network = args[++i];
+      if (!result.network || result.network.startsWith("-")) throw new Error("--network needs a Docker network name: --network <name>");
+    } else if (arg === "--setting") {
+      const value = args[++i];
+      if (!value || value.startsWith("-")) throw new Error("--setting needs a value: --setting <KEY>=<VALUE>");
+      (result.setting ??= []).push(value);
+    } else if (arg === "--loopback") {
+      result.loopback = true;
     } else if (arg === "--promote-to") {
       result.promoteTo = args[++i];
       if (!result.promoteTo || result.promoteTo.startsWith("-")) throw new Error("--promote-to needs an environment: --promote-to <env>");
@@ -333,6 +347,10 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.decide = true;
     } else if (arg === "--record-plans") {
       result.recordPlans = true;
+    } else if (arg === "--group") {
+      const raw = args[++i];
+      if (!raw || raw.startsWith("-")) throw new Error("--group needs a job group's name: --group <name>");
+      result.group = raw;
     } else if (arg === "--share") {
       const raw = args[++i];
       const share = Number(raw);
@@ -591,6 +609,9 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.compareTo = args[++i];
     } else if (arg === "--no-release-record") {
       result.noReleaseRecord = true;
+    } else if (arg === "--no-record") {
+      // `chant run <op|--components> --no-record` (#3955): write nothing to chant/lifecycle and push nothing.
+      result.noRecord = true;
     } else if (arg === "--fold") {
       result.fold = true;
     } else if (arg === "--no-cache") {

package/src/cli/registry.ts

@@ -167,6 +167,14 @@ export interface ParsedArgs {
   env?: string;
   /** `chant emulator up --port <container-port>=<host-port>`, repeatable (#3673); a bare `<host-port>` when one emulator is selected. */
   port?: string[];
+  /** `chant emulator up --image <ref>` (#3952): the image to start, when one emulator is selected. */
+  image?: string;
+  /** `chant emulator up --network <name>` (#3952): the Docker network each started container joins. */
+  network?: string;
+  /** `chant emulator up --setting <KEY>=<VALUE>`, repeatable (#3952): an emulator setting such as `FLOCI_<NAME>`, passed as `-e`. */
+  setting?: string[];
+  /** `chant emulator up --loopback` (#3952): publish ports on 127.0.0.1 only. */
+  loopback?: boolean;
   /** `chant build --components --generate <lexicon> --promote-to <env>` (#2575) — add a promote job to the generated pipeline. */
   promoteTo?: string;
   /** `chant graph --stacks` — render the cross-stack apply-ordering graph */
@@ -260,6 +268,8 @@ export interface ParsedArgs {
   recordPlans?: boolean;
   /** `chant run wave --share <i>` (#3679) — apply share `i` of a decided wide wave. */
   share?: number;
+  /** `chant run wave --group <name>` (#3914) — apply one job group's runs of a decided wave. */
+  group?: string;
   /** `chant components fan-out --canary <component>` (#3049), repeatable — components that form wave 1. */
   canary?: string[];
   /**
@@ -547,6 +557,8 @@ export interface ParsedArgs {
   compareTo?: string;
   /** `chant run --components <name> --env <env> --no-release-record` (#597) — opt out of auto-emitting a release-ledger record after a successful component deploy. Default (flag omitted): recording is ON. Also settable project-wide via `chant.config.ts`'s `release.autoRecord: false`. */
   noReleaseRecord?: boolean;
+  /** `chant run <op>` / `chant run --components <name>` `--no-record` (#3955) — run every step but record nothing on `chant/lifecycle` and push nothing; a gate step fails. `CHANT_NO_RECORD=1` does the same for every chant process that inherits it (../../lifecycle/no-record.ts). */
+  noRecord?: boolean;
   /** `chant run --components <name> --dump-outputs <file>` — after the run, write the accumulated cross-component/cross-stack outputs (JSON, keyed by component name) to `<file>`, for a downstream job to `--seed-outputs`. */
   dumpOutputs?: string;
   /** `chant run --components <name> --digest-file <file>` (#2602) — after a successful run, write one `<component>=<digest>` line per release the run recorded to `<file>`, the form `chant components promote --digest` takes, so a generated promote job promotes exactly the release its pipeline run built. Written empty when nothing was recorded. */

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

@@ -601,6 +601,81 @@ describe("runComponents", () => {
     expect(result.error).toMatch(/cycle/i);
   });
 
+  describe("a comma list (#3950)", () => {
+    const comp = (name: string, dependsOn: string[], extra = "") =>
+      `export const c = { name: "${name}", ${extra}dependsOn: ${JSON.stringify(dependsOn)}, deploy: [{ phase: "Apply", steps: [{ kind: "deploy-thing" }] }] };`;
+
+    beforeEach(async () => {
+      await writeFile(join(testDir, "db.component.ts"), comp("db", []));
+      await writeFile(join(testDir, "cache.component.ts"), comp("cache", []));
+      await writeFile(join(testDir, "api.component.ts"), comp("api", ["db"]));
+      await writeFile(join(testDir, "web.component.ts"), comp("web", ["api", "cache"]));
+      await writeFile(join(testDir, "worker.component.ts"), comp("worker", ["db"]));
+    });
+
+    test("runs the named components and their transitive dependencies in one dependency-ordered run", async () => {
+      const plans: unknown[] = [];
+      const result = await runComponents(testDir, "web", { registry: fakeRegistry() });
+      expect(result.selected).toEqual(["web"]);
+
+      const listed = await runComponents(testDir, "web,worker", { registry: fakeRegistry(), onPlan: (p) => plans.push(p) });
+      expect(listed.success).toBe(true);
+      expect([...listed.selected].sort()).toEqual(["api", "cache", "db", "web", "worker"]);
+      expect(listed.run?.waves).toEqual([["cache", "db"], ["api", "worker"], ["web"]].map((w) => expect.arrayContaining(w)));
+      const order = listed.run?.order ?? [];
+      expect(order.indexOf("db")).toBeLessThan(order.indexOf("api"));
+      expect(order.indexOf("api")).toBeLessThan(order.indexOf("web"));
+      expect(plans).toHaveLength(1);
+      expect(plans[0]).toMatchObject({ order: listed.run?.order, waves: listed.run?.waves });
+      expect([...(plans[0] as { added: string[] }).added].sort()).toEqual(["api", "cache", "db"]);
+    });
+
+    test("leaves out components the list does not reach", async () => {
+      const result = await runComponents(testDir, "api, api ,", { registry: fakeRegistry() });
+      expect(result.success).toBe(true);
+      expect(result.run?.order).toEqual(["db", "api"]);
+    });
+
+    test("refuses unknown names, naming every one, before anything runs", async () => {
+      const onPlan = vi.fn();
+      const result = await runComponents(testDir, "api,nope,also-nope", { registry: fakeRegistry(), onPlan });
+      expect(result.success).toBe(false);
+      expect(result.run).toBeUndefined();
+      expect(result.error).toContain('Components "nope", "also-nope" not found');
+      expect(result.error).toContain("Known components: api, cache, db, web, worker");
+      expect(onPlan).not.toHaveBeenCalled();
+    });
+
+    test("refuses a disabled name; a disabled dependency is dropped as \"all\" drops it", async () => {
+      await writeFile(join(testDir, "cache.component.ts"), comp("cache", [], "enabled: false, "));
+      const refused = await runComponents(testDir, "api,cache", { registry: fakeRegistry() });
+      expect(refused.success).toBe(false);
+      expect(refused.run).toBeUndefined();
+      expect(refused.error).toContain('Component "cache" is disabled');
+
+      const result = await runComponents(testDir, "web", { registry: fakeRegistry() });
+      expect(result.success).toBe(true);
+      const listed = await runComponents(testDir, "web,", { registry: fakeRegistry() });
+      expect(listed.success).toBe(true);
+      expect(listed.run?.order).toEqual(["db", "api", "web"]);
+    });
+
+    test("refuses \"all\" inside a list", async () => {
+      const result = await runComponents(testDir, "all,api", { registry: fakeRegistry() });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('"all" cannot be part of a component list');
+    });
+
+    test("a dependency outside the discovered set fails as it does under \"all\"", async () => {
+      await writeFile(join(testDir, "api.component.ts"), comp("api", ["shared-alb"]));
+      const onPlan = vi.fn();
+      const result = await runComponents(testDir, "api,web", { registry: fakeRegistry(), onPlan });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("shared-alb");
+      expect(onPlan).not.toHaveBeenCalled();
+    });
+  });
+
   test("unknown component name → clear error listing known components", async () => {
     await writeFile(
       join(testDir, "svc.component.ts"),