@intentius/chant 0.124.31 → 0.124.33

package/dist/cli/handlers/build.js

@@ -2,6 +2,7 @@ import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { buildCommand, buildCommandWatch, printErrors, printWarnings, resolveBuildFormat } from "../commands/build.js";
 import { formatError, formatInfo, formatSuccess, formatBold } from "../format.js";
+import { reportUninstalledDependencies } from "../dependencies.js";
 import { generateComponentsPipeline } from "../../components/cli-support.js";
 import { loadChantConfigUpward } from "../../config.js";
 import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli.js";
@@ -12,15 +13,23 @@ import { resolvePromotionSource } from "../../components/promote-order.js";
  * and the branch, and with `--events-json` and `--report-url` (#4007) the
  * flags the generated jobs pass to pr-plan and pr-apply. `--pr-build` and
  * `--pr-build-command` (#4088) add the build and lint steps before both.
+ * `reportUrl` is `--report-url`, else the workspace's `ci.reportUrl` (#4160).
+ * `requireReview` is `--require-review`, or a workspace that opts into the
+ * `review-rules` security group (#4168); off otherwise. `requireRunnerStart`
+ * is `--require-runner-start`, or the `isolated-runners` group. `--apply-on-merge`
+ * (#4168) writes the apply job on merge in place of the record job.
  */
-function prLoopOption(args) {
+function prLoopOption(args, reportUrl, requireReview = false, requireRunnerStart = false) {
     return {
         ...(args.gate ? { gate: args.gate } : {}),
         ...(args.branch ? { branch: args.branch } : {}),
         ...(args.eventsJson ? { events: true } : {}),
-        ...(args.reportUrl ? { reportUrl: args.reportUrl } : {}),
+        ...(reportUrl ? { reportUrl } : {}),
         ...(args.prBuild ? { build: true } : {}),
         ...(args.prBuildCommand ? { buildCommand: args.prBuildCommand } : {}),
+        ...(args.requireReview === true || requireReview ? { requireReview: true } : {}),
+        ...(args.requireRunnerStart === true || requireRunnerStart ? { requireRunnerStart: true } : {}),
+        ...(args.applyOnMerge ? { applyOnMerge: true } : {}),
     };
 }
 /**
@@ -84,6 +93,25 @@ async function runGenerateComponents(ctx) {
     const found = findWorkspaceRoot(resolve(args.path));
     let plan;
     let memberPipeline;
+    // #4160: without --report-url, the declaration's ci.reportUrl. Read only inside a workspace.
+    let reportUrl = args.reportUrl;
+    if (found && args.prLoop && !reportUrl) {
+        try {
+            reportUrl = await (await import("../../workspace/ci-report-url.js")).declaredReportUrl(resolve(args.path));
+        }
+        catch (err) {
+            console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+            return 1;
+        }
+    }
+    // #4168: the review-rules group turns on --require-review in the generated apply. Read only inside a workspace.
+    let reviewRules = false;
+    let isolatedRunners = false;
+    if (found && args.prLoop) {
+        const groups = (await import("../../workspace/security.js")).securityGroupsAt(resolve(args.path));
+        reviewRules = groups.has("review-rules");
+        isolatedRunners = groups.has("isolated-runners");
+    }
     if (found) {
         memberPipeline = await import("../../workspace/member-pipeline.js");
         try {
@@ -98,7 +126,7 @@ async function runGenerateComponents(ctx) {
                 params: args.param,
                 paramsFile: args.paramsFile,
                 ...(args.waveGate ? { waveGate: { gate: args.waveGate, ...(args.canary?.length ? { canary: args.canary } : {}), ...(args.base ? { base: args.base } : {}) } } : {}),
-                ...(args.prLoop ? { prLoop: prLoopOption(args) } : {}),
+                ...(args.prLoop ? { prLoop: prLoopOption(args, reportUrl, reviewRules, isolatedRunners) } : {}),
                 ...(args.image ? { image: args.image } : {}),
                 ...(args.beforeScript?.length ? { beforeScript: args.beforeScript } : {}),
             });
@@ -125,7 +153,7 @@ async function runGenerateComponents(ctx) {
             ? { gatedWaves: { gate: args.waveGate, ...(args.canary?.length ? { canary: args.canary } : {}), ...(args.base ? { base: args.base } : {}) } }
             : {}),
         // #3183: a plan job per pull request and an apply job per merge.
-        ...(args.prLoop ? { prLoop: prLoopOption(args) } : {}),
+        ...(args.prLoop ? { prLoop: prLoopOption(args, reportUrl, reviewRules, isolatedRunners) } : {}),
         // #4002: the job image and the lines that install what it lacks, chant itself included.
         ...(args.image ? { image: args.image } : {}),
         ...(args.beforeScript?.length ? { beforeScript: args.beforeScript } : {}),
@@ -257,6 +285,9 @@ export async function runBuild(ctx) {
             for (const w of own)
                 seenWarnings.add(w);
             printWarnings(own);
+            // #4116: once, before the first failing group's errors.
+            if (!result.success && !failed)
+                reportUninstalledDependencies(result.errors, resolve(args.path));
             printErrors(result.errors);
             if (!result.success)
                 failed = true;
@@ -304,6 +335,9 @@ export async function runBuild(ctx) {
         warnings = warnings.filter((w) => !w.includes('No serializer found for lexicon'));
     }
     printWarnings(warnings);
+    // #4116: errors that are imports of uninstalled packages are led by the dependencies message.
+    if (!result.success)
+        reportUninstalledDependencies(result.errors, resolve(args.path));
     printErrors(result.errors);
     return result.success ? 0 : 1;
 }

package/dist/cli/handlers/fan-out.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fan-out.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/fan-out.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH,OAAO,EAA+C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAe7F,OAAO,EAAmB,KAAK,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAQnG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,WAAW,EACnB,IAAI,GAAE;IACJ,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,UAAU,CAAC,EAAE,OAAO,CAAC;CACjB,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA+ErE;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAmV9E"}
+{"version":3,"file":"fan-out.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/fan-out.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH,OAAO,EAA+C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAe7F,OAAO,EAAmB,KAAK,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AASnG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,WAAW,EACnB,IAAI,GAAE;IACJ,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,UAAU,CAAC,EAAE,OAAO,CAAC;CACjB,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA+ErE;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyV9E"}

package/dist/cli/handlers/fan-out.js

@@ -67,9 +67,10 @@ import { approveCommand, gateIsSealed } from "../../op/gate.js";
 import { getHeadCommit } from "../../lifecycle/git.js";
 import { remainingFanOut } from "../../components/fan-out.js";
 import { readDeployedOutputs } from "../../components/wave-plan.js";
-import { deployContext } from "../../components/driver.js";
+import { deployContext, failedRunExitCode } from "../../components/driver.js";
 import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli.js";
 import { formatError, formatInfo, formatWarning } from "../format.js";
+import { reportUninstalledDependencies } from "../dependencies.js";
 import { FAN_OUT_GATE_OP } from "../../op/gate-name.js";
 import { resolveBuildRoot } from "./lifecycle.js";
 import { GATED_EXIT_CODE, autoReleaseRun, recordAutoReleasesForRun } from "./run.js";
@@ -220,10 +221,15 @@ export async function runComponentsFanOut(ctx) {
     catch (err) {
         // A cycle or an unknown `dependsOn` refuses here, over the whole graph and
         // before anything is selected (#2417). The message names the members.
-        console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        const message = err instanceof Error ? err.message : String(err);
+        reportUninstalledDependencies([message], projectPath); // #4116
+        console.error(formatError({ message }));
         return 1;
     }
     if (!derived.success) {
+        // #4116: component files that import packages the project has not installed.
+        if (derived.error)
+            reportUninstalledDependencies([derived.error], projectPath);
         console.error(formatError({ message: derived.error ?? "Could not discover components" }));
         return 1;
     }
@@ -486,7 +492,9 @@ export async function runComponentsFanOut(ctx) {
             ...(await summaryLedgerPrefix()),
             ...(pending.environment ? { environment: pending.environment } : {}),
         });
-        return result.status === "gated" ? GATED_EXIT_CODE : 1;
+        return result.status === "gated" ? GATED_EXIT_CODE : failedRunExitCode(result.results);
     }
-    return result.status === "ok" ? 0 : 1;
+    // A step that refused the wave's plan because its target moved since the
+    // approval exits 3, the code of a wave whose plan changed (#3997).
+    return result.status === "ok" ? 0 : failedRunExitCode(result.results);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/graph.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,aAAa,CAAC;AA+H9D;;;;;;;;;GASG;AACH;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7D"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/graph.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,aAAa,CAAC;AA+H9D;;;;;;;;;GASG;AACH;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7D"}

package/dist/cli/handlers/graph.js

@@ -19,6 +19,7 @@ import { toMermaid } from "../../graph-mermaid.js";
 import { toDot } from "../../graph-dot.js";
 import { getLayoutEngine, toLayoutInput } from "../../graph-layout.js";
 import { lintCommand } from "../commands/lint.js";
+import { reportUninstalledDependencies } from "../dependencies.js";
 import { loadPlugins, resolveProjectLexicons, collectBuildRootContributors } from "../plugins.js";
 import { isNoLexiconDetected } from "../../detectLexicon.js";
 import { readFileSync } from "node:fs";
@@ -526,6 +527,19 @@ async function runComponentGraph(ctx) {
     }
     return 0;
 }
+/**
+ * The lint gate's refusal. When the lint errors are imports of packages the
+ * project has not installed (#4116), the dependencies message leads, and it
+ * stands alone when every error is one: the source is not what is wrong.
+ */
+function refuseLintGate(lint, projectPath) {
+    const errors = (lint.diagnostics ?? []).filter((d) => d.severity === "error").map((d) => d.message);
+    if (reportUninstalledDependencies(errors, projectPath) === "all")
+        return;
+    console.error(formatError({
+        message: "Refusing to emit graph: source has lint errors. Run `chant lint` and fix them first.",
+    }));
+}
 /**
  * `chant graph --components --format ir|mermaid|dot|layout` — the component DAG
  * projected into the renderable IR (nodes = components, `groups.byWave` = the
@@ -563,9 +577,7 @@ async function runComponentGraphView(ctx, format) {
         buildParams: componentParams,
     });
     if (!lint.success) {
-        console.error(formatError({
-            message: "Refusing to emit graph: source has lint errors. Run `chant lint` and fix them first.",
-        }));
+        refuseLintGate(lint, projectPath);
         return 1;
     }
     const graph = await computeComponentGraph(projectPath, ctx.args.sandbox, componentParams);
@@ -813,9 +825,7 @@ async function runGraphView(ctx, format) {
         buildParams,
     });
     if (!lint.success) {
-        console.error(formatError({
-            message: "Refusing to emit graph: source has lint errors. Run `chant lint` and fix them first.",
-        }));
+        refuseLintGate(lint, projectPath);
         return 1;
     }
     const result = await discover(projectPath, { buildParams });

package/dist/cli/handlers/lifecycle-health.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `chant lifecycle health <env> [lexicon] [--json]` (#4177): whether each
+ * declared resource that has a health read is up, separate from drift.
+ *
+ * It builds the project as `lifecycle diff` does, so the entity names are the
+ * graph's node ids, then asks each lexicon with a health read about the
+ * entities whose types it names. An environment's declared endpoint is applied
+ * for the read, as on the other live reads (#1166).
+ *
+ * The JSON is the {@link HEALTH_SCHEMA} shape. A single-stack project prints
+ * `lexicons` at the top level; a multi-stack one nests them under `stacks`,
+ * the same split `lifecycle diff --live --json` makes.
+ */
+import type { CommandContext } from "../registry.js";
+export declare function runLifecycleHealth(ctx: CommandContext): Promise<number>;
+//# sourceMappingURL=lifecycle-health.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-health.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lifecycle-health.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiH7E"}

package/dist/cli/handlers/lifecycle-health.js

@@ -0,0 +1,150 @@
+/**
+ * `chant lifecycle health <env> [lexicon] [--json]` (#4177): whether each
+ * declared resource that has a health read is up, separate from drift.
+ *
+ * It builds the project as `lifecycle diff` does, so the entity names are the
+ * graph's node ids, then asks each lexicon with a health read about the
+ * entities whose types it names. An environment's declared endpoint is applied
+ * for the read, as on the other live reads (#1166).
+ *
+ * The JSON is the {@link HEALTH_SCHEMA} shape. A single-stack project prints
+ * `lexicons` at the top level; a multi-stack one nests them under `stacks`,
+ * the same split `lifecycle diff --live --json` makes.
+ */
+import { resolve } from "node:path";
+import { build } from "../../build.js";
+import { loadChantConfig } from "../../config.js";
+import { isObservableDeclarable } from "../../declarable.js";
+import { HEALTH_SCHEMA, healthApplicable, observeHealthFor, summarizeHealth } from "../../health.js";
+import { applyLiveEndpoint } from "../../live-endpoint.js";
+import { CHANT_VERSION } from "../version.js";
+import { commandBuildParams } from "../build-params-cli.js";
+import { resolveBuildModes, resolveProjectBuildOptions } from "../build-options.js";
+import { formatBold, formatError, formatWarning } from "../format.js";
+import { resolveStackTargets } from "./lifecycle.js";
+export async function runLifecycleHealth(ctx) {
+    const { args, plugins } = ctx;
+    const environment = args.extraPositional;
+    const lexiconFilter = args.extraPositional2;
+    if (!environment) {
+        console.error(formatError({ message: "Environment is required: chant lifecycle health <environment> [lexicon]" }));
+        return 1;
+    }
+    const readers = plugins.filter((p) => p.observeHealth && (p.healthTypes?.length ?? 0) > 0 && (!lexiconFilter || p.name === lexiconFilter));
+    if (readers.length === 0) {
+        console.error(formatWarning({
+            message: lexiconFilter
+                ? `${lexiconFilter}: no health read in this lexicon`
+                : "No configured lexicon has a health read (aws, azure and gcp do)",
+        }));
+        return 1;
+    }
+    const projectRoot = resolve(".");
+    const { config } = await loadChantConfig(projectRoot);
+    const declaredParams = await commandBuildParams(config.buildParams, args);
+    if (!declaredParams)
+        return 1;
+    const targets = resolveStackTargets(args, config);
+    const buildOptions = resolveProjectBuildOptions({
+        config,
+        configDir: projectRoot,
+        plugins,
+        modes: resolveBuildModes(config, { fold: args.fold, sandbox: args.sandbox }),
+        buildParams: declaredParams,
+    });
+    const serializers = readers.map((p) => p.serializer);
+    const endpoint = applyLiveEndpoint(config.environments, environment, readers);
+    if (endpoint.notice)
+        console.error(formatWarning({ message: endpoint.notice }));
+    const perStack = {};
+    let single;
+    let anyBuildError = false;
+    const observedAt = new Date().toISOString();
+    try {
+        for (const target of targets) {
+            const buildResult = await build(target.root, serializers, undefined, buildOptions);
+            if (buildResult.errors.length > 0) {
+                console.error(formatError({
+                    message: `Build failed for ${target.stack ? `stack "${target.stack}"` : "project"}; fix errors before reading health`,
+                }));
+                anyBuildError = true;
+                continue;
+            }
+            const byLexicon = {};
+            for (const plugin of readers) {
+                const declared = new Map();
+                for (const [name, entity] of buildResult.entities) {
+                    if (entity.lexicon === plugin.name && isObservableDeclarable(entity)) {
+                        declared.set(name, {
+                            entityType: entity.entityType,
+                            props: (entity.props != null ? entity.props : {}),
+                        });
+                    }
+                }
+                const entities = healthApplicable(plugin, declared);
+                if (entities.size === 0)
+                    continue;
+                const raw = buildResult.outputs.get(plugin.name);
+                const buildOutput = raw === undefined ? "" : typeof raw === "string" ? raw : raw.primary;
+                byLexicon[plugin.name] = await observeHealthFor(plugin, {
+                    environment,
+                    buildOutput,
+                    entities,
+                    ...(target.stack ? { stack: target.stack } : {}),
+                    ...(target.region ? { region: target.region } : {}),
+                });
+            }
+            if (target.stack)
+                perStack[target.stack] = byLexicon;
+            else
+                single = byLexicon;
+        }
+    }
+    finally {
+        endpoint.restore();
+    }
+    const all = single ? [single] : Object.values(perStack);
+    const summary = summarizeHealth(all.flatMap((b) => Object.values(b)));
+    if (args.json) {
+        console.log(JSON.stringify({
+            schema: HEALTH_SCHEMA,
+            chantVersion: CHANT_VERSION,
+            environment,
+            observedAt,
+            ...(single ? { lexicons: single } : { stacks: perStack }),
+            summary,
+        }));
+    }
+    else {
+        if (single)
+            renderHealth(single);
+        else
+            for (const [stack, byLexicon] of Object.entries(perStack)) {
+                console.log(`\n${formatBold(`■ stack ${stack}`)}`);
+                renderHealth(byLexicon);
+            }
+        const total = summary.healthy + summary.unhealthy + summary.unknown + summary.unobserved + summary.absent;
+        if (total === 0) {
+            console.error(formatWarning({ message: "No declared resource has a health read" }));
+        }
+        else {
+            console.error(`${summary.healthy} healthy, ${summary.unhealthy} unhealthy, ${summary.unknown} unknown` +
+                (summary.unobserved > 0 ? `, ${summary.unobserved} not observed` : "") +
+                (summary.absent > 0 ? `, ${summary.absent} not deployed` : ""));
+        }
+    }
+    return anyBuildError ? 1 : 0;
+}
+function renderHealth(byLexicon) {
+    for (const [lexicon, result] of Object.entries(byLexicon)) {
+        console.log(formatBold(lexicon));
+        for (const [name, entry] of Object.entries(result.entities)) {
+            console.log(`  ${entry.state.padEnd(9)} ${name} (${entry.type}): ${entry.detail}`);
+        }
+        for (const [name, hole] of Object.entries(result.unobserved)) {
+            console.log(`  ${"not read".padEnd(9)} ${name}${hole.type ? ` (${hole.type})` : ""}: ${hole.reason}${hole.detail ? `, ${hole.detail}` : ""}`);
+        }
+        for (const name of result.absent)
+            console.log(`  ${"absent".padEnd(9)} ${name}: not deployed`);
+    }
+}

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

@@ -10,6 +10,31 @@ import type { ChantConfig } from "../../config.js";
  * so their build digests stay consistent.
  */
 export declare function resolveBuildRoot(args: ParsedArgs, config: ChantConfig): string;
+/** One stack a lifecycle command operates on: its build root and, for a
+ * multi-stack project, the deployed CloudFormation stack name it observes
+ * against. */
+interface StackTarget {
+    /** The deployed stack name to observe (undefined ⇒ single-stack convention:
+     * the stack named after the environment). */
+    stack?: string;
+    /** Build root to synthesize this stack from, scoped so its logical ids match
+     * what the stack actually deploys. */
+    root: string;
+    /** Region the stack is deployed in, from `stacks[].region` (#1261). Without
+     * it every stack is observed against the ambient region, so a multi-region
+     * estate snapshots only the stacks that happen to share it and reports the
+     * rest as "no valid resources or artifacts returned". */
+    region?: string;
+}
+/**
+ * The stacks a lifecycle command (`snapshot`/`diff`) iterates. A multi-stack
+ * project declares them via `stacks` in chant.config (#932) — each built from
+ * its own `src` and observed against its own live stack `name`. A single-stack
+ * project (no `stacks`) resolves to one target built from `sourceDir`/root and
+ * observed as the stack named after the environment (unchanged behavior). An
+ * explicit `--src` always wins and forces a single scoped target.
+ */
+export declare function resolveStackTargets(args: ParsedArgs, config: ChantConfig): StackTarget[];
 /**
  * chant lifecycle snapshot <environment> [lexicon]
  */
@@ -93,4 +118,5 @@ export declare function runLifecycleUnknown(ctx: CommandContext): Promise<number
  * an empty list as if it meant "nothing downstream".
  */
 export declare function runLifecycleAffected(ctx: CommandContext): Promise<number>;
+export {};
 //# sourceMappingURL=lifecycle.d.ts.map

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":"AA+CA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAE9E;AAmCD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyH/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,CA+L3E;AA+sBD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwR3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA2L/E;AAsBD;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB1E;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAmE7E;AAiCD;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9E;AAkBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8D/E"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lifecycle.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAE9E;AAED;;cAEc;AACd,UAAU,WAAW;IACnB;iDAC6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;0CACsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb;;;6DAGyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE,CAMxF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyH/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,CA+L3E;AA+sBD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwR3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA2L/E;AAsBD;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB1E;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAmE7E;AAiCD;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9E;AAkBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8D/E"}

package/dist/cli/handlers/lifecycle.js

@@ -48,7 +48,7 @@ export function resolveBuildRoot(args, config) {
  * observed as the stack named after the environment (unchanged behavior). An
  * explicit `--src` always wins and forces a single scoped target.
  */
-function resolveStackTargets(args, config) {
+export function resolveStackTargets(args, config) {
     if (args.src)
         return [{ root: resolve(args.src) }];
     if (config.stacks && config.stacks.length > 0) {

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

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA0BlD,wBAAsB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsClE"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lint.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA0BlD,wBAAsB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA2ClE"}

package/dist/cli/handlers/lint.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { lintCommand, lintCommandWatch, printLintResult } from "../commands/lint.js";
 import { formatError, formatInfo } from "../format.js";
+import { reportUninstalledDependencies } from "../dependencies.js";
 import { commandBuildParams } from "../build-params-cli.js";
 import { loadChantConfigUpward } from "../../config.js";
 /**
@@ -57,6 +58,11 @@ export async function runLint(ctx) {
         sandbox: args.sandbox,
         buildParams,
     });
+    // #4116: errors that are imports of uninstalled packages are led by the dependencies message.
+    if (!result.success) {
+        const errors = result.diagnostics.filter((d) => d.severity === "error").map((d) => d.message);
+        reportUninstalledDependencies(errors, resolve(args.path));
+    }
     printLintResult(result);
     return result.success ? 0 : 1;
 }

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

@@ -19,8 +19,8 @@ export declare function runOperator(ctx: CommandContext): Promise<number>;
  *
  * Refuses, before ticking anything:
  * - an environment whose form is `fountain`, because there the composite's
- *   Agent and Teammate are the steward and this process would be a second
- *   writer beside them;
+ *   Agent and its conversation are the steward and this process would be a
+ *   second writer beside them;
  * - a steward whose lease another live process holds (a second local
  *   operator for it).
  */

package/dist/cli/handlers/operator.js

@@ -190,8 +190,8 @@ export async function runOperator(ctx) {
  *
  * Refuses, before ticking anything:
  * - an environment whose form is `fountain`, because there the composite's
- *   Agent and Teammate are the steward and this process would be a second
- *   writer beside them;
+ *   Agent and its conversation are the steward and this process would be a
+ *   second writer beside them;
  * - a steward whose lease another live process holds (a second local
  *   operator for it).
  */
@@ -212,7 +212,7 @@ export async function runStewardOperator(ctx) {
     if (form !== "local") {
         console.error(formatError({
             message: `steward "${steward.name}" runs on ${form} in environment "${env}", so a local operator for it would be a second writer`,
-            hint: `Its turns run on the fountain teammate "${steward.name}". Run this in an environment the declaration's form makes local, or change the form.`,
+            hint: `Its turns run in the fountain steward "${steward.name}"'s conversation. Run this in an environment the declaration's form makes local, or change the form.`,
         }));
         return 1;
     }

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

@@ -6,6 +6,7 @@
  * chant components pr-plan  --base <ref> --pr <n> --env <env> [--forge github|gitlab|forgejo]
  * chant approve pr-<n> pr-apply --plan <digest> --approver github:<login> --sign
  * chant components pr-apply --base <ref> --env <env> [--pr <n>] [--forge <kind>] [--require-review] [--resume <file>]
+ *                           [--wave-gate <gate> [--wave <k>]]
  * ```
  *
  * Both measure the change from the merge base of `--base` and `HEAD`, select
@@ -27,6 +28,13 @@
  * approval still stands, applies the rest without a fresh approval. When
  * they are not covered it says why and runs as it would without a record.
  *
+ * `--wave-gate <gate>` (#4003) applies the approved set a wave at a time,
+ * each wave planned after the one before it applied (`prApplyWaves`). A
+ * wave whose plan the approved change set covers applies under the pull
+ * request's approval; one whose plan moved waits at `<gate>-wave-<k>` under
+ * the pull request's op (exit 3). `--wave <k>` runs one wave, reading the
+ * approved set and the waves that applied from the `--resume` record.
+ *
  * Every run writes `pr-plan.json` or `pr-apply.json` (`pr-report.schema.json`),
  * `change-set.json` and `pr-note.md` under `--output` (default `.chant/pr`). *
  * `--events-json` (#4041, #4007) streams the stage's run events to stdout,
@@ -48,6 +56,12 @@
  * recorded under `pr-<n>-<member>`, and the note and the statuses carry the
  * member's name, so each member's loop on one pull request stands apart.
  * The name must be the member that owns the current directory.
+ *
+ * `--no-status` (#4161) posts neither the stage's status nor its note: the
+ * report and the note are written under `--output` only. `chant ci run
+ * --local` passes it. pr-plan then builds no forge client, since posting is
+ * all it uses one for; pr-apply still reads the pull request and its reviews
+ * through `--forge`.
  */
 import type { CommandContext } from "../registry.js";
 /** Where the reports land unless `--output` says. */
@@ -56,4 +70,6 @@ export declare const PR_REPORT_DIR = ".chant/pr";
 export declare function runComponentsPrPlan(ctx: CommandContext): Promise<number>;
 /** chant components pr-apply --base <ref> [--pr <n>] [--env <env>] [--gate <name>] [--forge <kind>] [--require-review] [--output <dir>] [--json] [--events-json] [--report-url <url>] */
 export declare function runComponentsPrApply(ctx: CommandContext): Promise<number>;
+/** chant components pr-record --base <ref> [--pr <n>] [--env <env>] [--gate <name>] [--forge <kind>] [--output <dir>] [--json] [--events-json] [--report-url <url>] */
+export declare function runComponentsPrRecord(ctx: CommandContext): Promise<number>;
 //# sourceMappingURL=pr.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AA8CH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qDAAqD;AACrD,eAAO,MAAM,aAAa,cAAc,CAAC;AA6RzC,mKAAmK;AACnK,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxE;AAwDD,yLAAyL;AACzL,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE"}
+{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAuDH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qDAAqD;AACrD,eAAO,MAAM,aAAa,cAAc,CAAC;AAqSzC,mKAAmK;AACnK,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxE;AAyDD,yLAAyL;AACzL,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE;AAuPD,uKAAuK;AACvK,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAG1E"}