@intentius/chant 0.79.0 → 0.80.0

package/src/cli/path-lexicon-messages.test.ts

@@ -0,0 +1,152 @@
+/**
+ * chant#2578 — init, onboard, audit and import-agents name a lexicon declared
+ * by path (#2520) by that path, and print no install line for it. A lexicon
+ * named by package keeps its package name and `npm i` line.
+ */
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  lexiconPackagesToInstall,
+  lexiconSourceLabel,
+  registerLexiconDeclarations,
+  resetLexiconModules,
+} from "../lexicon-module";
+import { initCommand } from "./commands/init";
+import { onboardCommand } from "./commands/onboard";
+import { installLine } from "./commands/audit";
+import { importAgentsCommand } from "./commands/import-agents";
+import { auditFiles, MissingLexiconError, type AuditInput } from "../audit/core";
+
+let dir: string;
+
+beforeEach(() => {
+  dir = realpathSync(mkdtempSync(join(tmpdir(), "chant-2578-")));
+  resetLexiconModules();
+});
+
+afterEach(() => {
+  resetLexiconModules();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("the shared helpers", () => {
+  test("a path lexicon is labelled by its path and has no package to install", () => {
+    registerLexiconDeclarations(["aws", { name: "site", module: "./lexicon/index.ts" }], dir);
+    expect(lexiconSourceLabel("site", dir)).toBe("./lexicon/index.ts");
+    expect(lexiconSourceLabel("aws", dir)).toBe("@intentius/chant-lexicon-aws");
+    expect(lexiconPackagesToInstall(["aws", "site"])).toEqual(["@intentius/chant-lexicon-aws"]);
+  });
+
+  test("a path outside the directory is shown absolute", () => {
+    registerLexiconDeclarations([{ name: "site", module: "/elsewhere/site.ts" }], dir);
+    expect(lexiconSourceLabel("site", dir)).toBe("/elsewhere/site.ts");
+  });
+});
+
+describe("init", () => {
+  function writeConfig(entry: string): void {
+    writeFileSync(join(dir, "chant.config.ts"), `export default { lexicons: [${entry}] };\n`);
+  }
+
+  test("a lexicon the existing config declares by path gets no dependency and no type stub", async () => {
+    writeConfig(`{ name: "site", module: "./lexicon/index.ts" }`);
+    const result = await initCommand({ path: dir, lexicon: "site", force: true, skipMcp: true, skipInstall: true });
+
+    expect(result.success).toBe(true);
+    expect(result.lexiconModule).toBe("./lexicon/index.ts");
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+    expect(Object.keys(pkg.dependencies)).toEqual(["@intentius/chant"]);
+    expect(existsSync(join(dir, ".chant", "types", "lexicon-site"))).toBe(false);
+  });
+
+  test("a package lexicon is unchanged", async () => {
+    writeConfig(`"aws"`);
+    const result = await initCommand({ path: dir, lexicon: "aws", force: true, skipMcp: true, skipInstall: true });
+
+    expect(result.success).toBe(true);
+    expect(result.lexiconModule).toBeUndefined();
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+    expect(Object.keys(pkg.dependencies)).toEqual(["@intentius/chant", "@intentius/chant-lexicon-aws"]);
+    expect(existsSync(join(dir, ".chant", "types", "lexicon-aws", "package.json"))).toBe(true);
+  });
+});
+
+describe("onboard", () => {
+  test("a lexicon declared by path is named by its path, with nothing patched", () => {
+    registerLexiconDeclarations([{ name: "site", module: "./lexicon/index.ts" }], process.cwd());
+    const result = onboardCommand({ name: "site", root: dir });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("./lexicon/index.ts");
+    expect(result.error).not.toMatch(/npm (i|install)\b/);
+    expect(result.patched).toEqual([]);
+  });
+
+  test("a package lexicon still patches", () => {
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "root", dependencies: {} }));
+    const result = onboardCommand({ name: "site", root: dir });
+
+    expect(result.success).toBe(true);
+    expect(result.patched.some((p) => p.startsWith("package.json"))).toBe(true);
+  });
+});
+
+describe("audit", () => {
+  test("the npx line leaves out a lexicon declared by path", () => {
+    registerLexiconDeclarations([{ name: "github", module: "./gh/index.ts" }], dir);
+    expect(installLine(["github", "gitlab"], ".")).toBe(
+      "npx -p @intentius/chant -p @intentius/chant-lexicon-gitlab chant audit .",
+    );
+  });
+
+  test("a path lexicon that fails to load is named by its path, with no npm line", async () => {
+    registerLexiconDeclarations([{ name: "helm", module: join(dir, "missing.ts") }], dir);
+    const input = { lexicon: "helm", path: "Chart.yaml", content: "" } as AuditInput;
+
+    const error = await auditFiles([input]).then(
+      () => undefined,
+      (err: unknown) => err,
+    );
+    expect(error).toBeInstanceOf(MissingLexiconError);
+    expect((error as Error).message).toContain(join(dir, "missing.ts"));
+    expect((error as Error).message).not.toContain("npm i");
+  });
+});
+
+describe("import-agents", () => {
+  function seedAgentConfig(home: string): void {
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    writeFileSync(join(home, ".claude", "mcp.json"), JSON.stringify({ mcpServers: { a: { command: "x" } } }));
+  }
+
+  test("a path lexicon that fails to load is named by its path, with no npm line", async () => {
+    const home = join(dir, "home");
+    seedAgentConfig(home);
+    registerLexiconDeclarations([{ name: "fountain", module: "./agents/missing.ts" }], dir);
+
+    const result = await importAgentsCommand({ home, platform: "linux", projectRoots: [], output: join(dir, "out") });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("declared by path");
+    expect(result.error).toContain("missing.ts");
+    expect(result.error).not.toContain("npm i");
+  });
+
+  test("a package lexicon still gets its npm line", async () => {
+    const home = join(dir, "home");
+    seedAgentConfig(home);
+
+    const result = await importAgentsCommand({
+      home,
+      platform: "linux",
+      projectRoots: [],
+      output: join(dir, "out"),
+      lexicon: "no-such-lexicon",
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("npm i @intentius/chant-lexicon-no-such-lexicon");
+  });
+});

package/src/cli/plugins.ts

@@ -1,10 +1,30 @@
+import { importLexiconModule, lexiconModulePath, lexiconNames } from "../lexicon-module";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { isLexiconPlugin, type LexiconPlugin } from "../lexicon";
-import { loadChantConfigUpward } from "../config";
+import { loadChantConfig, loadChantConfigUpward } from "../config";
+import { findProjectConfig } from "../project-root";
 import { findInfraFiles, detectLexicons } from "../index";
-import { checkConflicts } from "./conflict-check";
+import { checkConflicts, describeConflict } from "./conflict-check";
+
+/**
+ * chant#2578 — load the chant.config nearest `dir` (walking up) so the
+ * lexicons it declares by path are recorded (../lexicon-module.ts), for a
+ * command that does not otherwise read the config. With no config there is
+ * nothing to record. A config that fails to load records nothing either, and
+ * the command keeps its package behaviour; the commands that need a valid
+ * config report its errors themselves.
+ */
+export async function recordProjectLexicons(dir: string): Promise<void> {
+  const { dir: projectDir, configPath } = findProjectConfig(dir);
+  if (configPath === undefined) return;
+  try {
+    await loadChantConfig(projectDir);
+  } catch {
+    // See above: an unloadable config changes nothing here.
+  }
+}
 
 /**
  * Load a single lexicon plugin by lexicon name.
@@ -13,6 +33,23 @@ import { checkConflicts } from "./conflict-check";
  * LexiconPlugin export. Falls back to wrapping a raw Serializer export.
  */
 export async function loadPlugin(lexiconName: string): Promise<LexiconPlugin> {
+  // chant #2520 — a lexicon declared by module path loads from that module.
+  const modulePath = lexiconModulePath(lexiconName);
+  if (modulePath !== undefined) {
+    const mod = (await importLexiconModule(lexiconName))!;
+    for (const value of Object.values(mod)) {
+      if (isLexiconPlugin(value)) {
+        if (value.name !== lexiconName) {
+          throw new Error(
+            `lexicon "${lexiconName}" is declared with module ${modulePath}, but the plugin it exports is named "${value.name}"`,
+          );
+        }
+        return value;
+      }
+    }
+    throw new Error(`Module ${modulePath} (lexicon "${lexiconName}") does not export a LexiconPlugin`);
+  }
+
   const packageName = `@intentius/chant-lexicon-${lexiconName}`;
   const mod = await import(packageName);
 
@@ -67,6 +104,9 @@ export function resolveLexiconVersions(lexiconNames: readonly string[]): Record<
   const versions: Record<string, string> = {};
 
   for (const name of lexiconNames) {
+    // chant #2520 — a lexicon declared by module path is not an installed
+    // package, so it has no package version to report.
+    if (lexiconModulePath(name) !== undefined) continue;
     const packageName = `@intentius/chant-lexicon-${name}`;
     try {
       let dir = dirname(require_.resolve(packageName));
@@ -177,9 +217,7 @@ export async function loadPlugins(lexiconNames: string[]): Promise<LexiconPlugin
   }
 
   if (report.conflicts.length > 0) {
-    const details = report.conflicts
-      .map((c) => `  ${c.type} "${c.key}" from: ${c.plugins.join(", ")}`)
-      .join("\n");
+    const details = report.conflicts.map(describeConflict).join("\n");
     throw new Error(
       `Cross-lexicon conflicts detected:\n${details}`,
     );
@@ -222,7 +260,7 @@ export async function resolveProjectLexicons(projectPath: string): Promise<strin
   const { config } = await loadChantConfigUpward(projectPath);
 
   if (config.lexicons && config.lexicons.length > 0) {
-    return config.lexicons;
+    return lexiconNames(config.lexicons);
   }
 
   // Fallback: detect from source imports — a pure text scan, no execution.

package/src/cli/registry.ts

@@ -145,6 +145,8 @@ export interface ParsedArgs {
   /** `--env <name>` — active environment: sets CHANT_ENV so env-aware source
    * re-evaluates for that environment (`build` + `graph`), and drives policy. */
   env?: string;
+  /** `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 */
   stacks?: boolean;
   /** `chant graph --live --overlay` — classify the provisioned graph against
@@ -175,8 +177,13 @@ export interface ParsedArgs {
   components?: boolean;
   /** `chant build --components --generate <lexicon>` — generate mode (#563):
    * synthesize CI YAML from discovered components instead of running a normal
-   * lexicon build. Only "gitlab" is implemented for v1. */
+   * lexicon build. Also `chant run --generate <provider>` (#2533): one CI
+   * pipeline file per scheduled Op, through `generateOpsPipeline`. */
   generate?: string;
+  /** `chant run --generate <provider> --spec <file>` (#2533): a JSON file of
+   * `ScheduledOpSpec`s (or `{ ops, options }`) to generate instead of every
+   * discovered Op that declares a `schedule`. */
+  opsSpec?: string;
   /** `chant graph --format ir --detail <0..3>` — graph IR detail tier */
   detail?: number;
   /** `chant graph --lens <kind>:<target>` — focus the graph IR on a slice */
@@ -242,6 +249,8 @@ export interface ParsedArgs {
   allProjects?: boolean;
   /** `chant audit --fail-on merge-worthy|warning|error|none` */
   failOn?: string;
+  /** `chant audit --max-files <n>` (#2528) — files the local walk takes before it stops (default 1000). */
+  maxFiles?: number;
   /** `chant audit --theme <file>` — JSON theme knobs for the HTML report */
   theme?: string;
   /** `chant dev surface-diff --update-snapshot` — write the fresh snapshot as the new baseline */
@@ -270,6 +279,10 @@ export interface ParsedArgs {
    * should win.
    */
   at?: string;
+  /** `chant workspace records --kind <path>` (#2546): the record kind file to read records through. */
+  kind?: string;
+  /** `chant workspace records --current` (#2546): leave out records a closed record supersedes. */
+  current?: boolean;
   /**
    * `chant search "<q>" --ambient --live --env <name>` (#1278) — also report
    * resources of a kind this estate manages that exist in the account without

package/src/components/__fixtures__/alb-ecs-service.json

@@ -39,13 +39,5 @@
         { "kind": "health-gate", "path": "/healthz" }
       ]
     }
-  ],
-  "rollback": [
-    {
-      "phase": "Rollback",
-      "steps": [
-        { "kind": "rollback-previous", "service": "search", "cluster": "$env.cluster" }
-      ]
-    }
   ]
 }

package/src/components/capability-plugin-loader.ts

@@ -22,6 +22,7 @@
  */
 
 import { CapabilityRegistry } from "./capability";
+import { lexiconModulePath } from "../lexicon-module";
 import type { CapabilityPlugin } from "./capability-plugin";
 import { isCapabilityPlugin } from "./capability-plugin";
 import { starterCapabilityPlugin } from "./starter-plugin";
@@ -113,7 +114,8 @@ export async function loadCapabilityPlugins(names: string[]): Promise<Capability
  * where the package's whole reason to exist is the plugin.
  */
 export async function loadCapabilityPluginFromLexicon(name: string): Promise<CapabilityPlugin | null> {
-  const packageName = `@intentius/chant-lexicon-${name}`;
+  // chant #2520 — a lexicon declared by module path is imported from that path.
+  const packageName = lexiconModulePath(name) ?? `@intentius/chant-lexicon-${name}`;
   let mod: Record<string, unknown>;
   try {
     mod = (await import(packageName)) as Record<string, unknown>;

package/src/components/cli-support.ts

@@ -22,6 +22,7 @@
  *    executor, the CLI entrypoint the driver (#556) never had.
  */
 
+import { lexiconModulePath, lexiconNames } from "../lexicon-module";
 import { discoverComponents } from "./discover";
 import type { BuildParamProvenance } from "../provenance";
 import { projectToJson, type Archetype } from "./component";
@@ -237,7 +238,7 @@ export interface GenerateComponentsResult {
 async function loadLexiconPlugin(name: string): Promise<LexiconPlugin | null> {
   let mod: Record<string, unknown>;
   try {
-    mod = (await import(`@intentius/chant-lexicon-${name}`)) as Record<string, unknown>;
+    mod = (await import(lexiconModulePath(name) ?? `@intentius/chant-lexicon-${name}`)) as Record<string, unknown>;
   } catch {
     return null;
   }
@@ -550,7 +551,7 @@ export async function runComponents(
     options.registry ??
     (await buildCapabilityRegistry({
       plugins: options.capabilityPlugins ?? config.capabilities,
-      lexicons: config.lexicons,
+      lexicons: lexiconNames(config.lexicons),
     }));
   const env = options.env ?? "local";
   const selected = targets.map((c) => c.name);

package/src/components/discover.ts

@@ -49,6 +49,9 @@ import { isComponent, type Component } from "./component";
 import type { BuildParamProvenance } from "../provenance";
 import { buildParamValues } from "../build-params";
 import { setBuildParams } from "../params";
+import { compileDiscoveryFilter, hasDiscoveryMarker } from "../discovery/files";
+import { resolveDiscoveryGlobs } from "../config";
+import { warnDiscoveryChanges } from "../discovery/convergence";
 
 /** One discovered component, paired with the file it was exported from. */
 export interface DiscoveredComponent {
@@ -118,11 +121,15 @@ export interface ImportedComponentModule {
  * Recursively find every `*.component.ts` file under `path`, the same
  * child-project boundary rule `findInfraFiles` (`../discovery/files.ts`)
  * uses: a subdirectory with its own `chant.config.ts` is a separate scope
- * once the outer project's own source root has been established.
+ * once the outer project's own source root has been established. The
+ * project's `exclude`/`include` globs and the skip marker apply here as they
+ * do there (#2519).
  */
 async function findComponentFiles(path: string): Promise<string[]> {
   const files: string[] = [];
   let sourceRoot: string | null = null;
+  const skip = compileDiscoveryFilter(await resolveDiscoveryGlobs(path));
+  const skippedChildren: string[] = [];
 
   async function scanDirectory(dir: string): Promise<void> {
     let entries;
@@ -148,6 +155,7 @@ async function findComponentFiles(path: string): Promise<string[]> {
           if (sourceRoot === null) {
             sourceRoot = fullPath;
           } else {
+            skippedChildren.push(fullPath);
             continue;
           }
         }
@@ -156,7 +164,9 @@ async function findComponentFiles(path: string): Promise<string[]> {
         entry.isFile() &&
         entry.name.endsWith(".component.ts") &&
         !entry.name.endsWith(".test.component.ts") &&
-        !entry.name.endsWith(".spec.component.ts")
+        !entry.name.endsWith(".spec.component.ts") &&
+        !skip?.(fullPath) &&
+        !(await hasDiscoveryMarker(fullPath))
       ) {
         files.push(fullPath);
       }
@@ -164,6 +174,20 @@ async function findComponentFiles(path: string): Promise<string[]> {
   }
 
   await scanDirectory(path);
+  // #2527's warning release: the list returned is today's, unchanged.
+  await warnDiscoveryChanges({
+    walker: "components",
+    root: path,
+    files,
+    sourceRoot,
+    skippedChildren,
+    fileOk: async (name, full) =>
+      name.endsWith(".component.ts") &&
+      !name.endsWith(".test.component.ts") &&
+      !name.endsWith(".spec.component.ts") &&
+      !skip?.(full) &&
+      !(await hasDiscoveryMarker(full)),
+  });
   return files;
 }
 

package/src/components/driver.test.ts

@@ -450,7 +450,7 @@ describe("runComponentDeploy — onFailure saga rollback", () => {
     );
   });
 
-  it("runs a component-level rollback (schema `rollback` field) after step rollback, matching the ALB/ECS pilot's explicit compensation", async () => {
+  it("runs a component-level rollback (schema `rollback` field) after step rollback", async () => {
     const registry = new CapabilityRegistry();
     registry.register(fakeCapability("docker-build", { run: () => ({ digest: "sha256:abc" }) }).capability);
     registry.register(
@@ -458,26 +458,29 @@ describe("runComponentDeploy — onFailure saga rollback", () => {
         .capability,
     );
     registry.register(fakeCapability("cfn-deploy", { run: () => ({ stackStatus: "UPDATE_COMPLETE", outputs: {} }) }).capability);
-    // ecs-update-service fails, and (per the pilot's comment) has no native
-    // rollback — the component's own `rollback` phase is what should fire.
+    // ecs-update-service fails; the component's own `rollback` phase is what
+    // should fire after the executed steps unwind.
     registry.register(fakeCapability("ecs-update-service", { failRun: true }).capability);
-    const { capability: rollbackPreviousCap, calls: rollbackPreviousCalls } = fakeCapability("rollback-previous", {
+    const { capability: restoreCap, calls: restoreCalls } = fakeCapability("restore-service", {
       run: () => ({ restored: true }),
     });
-    registry.register(rollbackPreviousCap);
+    registry.register(restoreCap);
     // Verify/rollback phases never reached since Apply fails first, but register
     // stubs anyway so a hypothetical reordering wouldn't crash the test on an
     // unregistered kind.
     registry.register(fakeCapability("wait-steady-state", { run: () => ({ runningCount: 1 }) }).capability);
     registry.register(fakeCapability("health-gate", { run: () => ({ healthy: true }) }).capability);
 
-    const json = projectToJson(searchService) as unknown as DriverComponent;
+    const json: DriverComponent = {
+      ...(projectToJson(searchService) as unknown as DriverComponent),
+      rollback: [{ phase: "Rollback", steps: [{ kind: "restore-service", service: "search" }] }],
+    };
     const result = await runComponentDeploy(json, { env: "dev", component: "search-service" }, registry, {});
 
     expect(result.ok).toBe(false);
-    expect(rollbackPreviousCalls).toHaveLength(1);
-    expect(rollbackPreviousCalls[0]!.input).toMatchObject({ service: "search" });
-    const rollbackRecord = result.records.find((r) => r.phase === "Rollback" && r.kind === "rollback-previous");
+    expect(restoreCalls).toHaveLength(1);
+    expect(restoreCalls[0]!.input).toMatchObject({ service: "search" });
+    const rollbackRecord = result.records.find((r) => r.phase === "Rollback" && r.kind === "restore-service");
     expect(rollbackRecord?.status).toBe("ok");
   });
 });
@@ -630,7 +633,6 @@ describe("runInterpretDriver — end to end", () => {
       "ecs-update-service",
       "wait-steady-state",
       "health-gate",
-      "rollback-previous",
       "wait-for-stack",
       "run-migration",
     ];
@@ -750,7 +752,6 @@ describe("runInterpretDriver — end to end", () => {
       "ecs-update-service",
       "wait-steady-state",
       "health-gate",
-      "rollback-previous",
       "wait-for-stack",
       "run-migration",
       "lambda-deploy",

package/src/components/driver.ts

@@ -49,6 +49,7 @@
 import { topoSort } from "../codegen/topo-sort";
 import { evaluateGate, gitGateLedgerPort, type GateLedgerPort } from "../op/gate";
 import { gateName } from "../op/gate-name";
+import { warnOnUnboundComponentApproval } from "./unbound-gate-approval";
 import type { PendingGateRecord } from "../lifecycle/gate-ledger";
 import type { CapabilityRegistry, DeployContext } from "./capability";
 import type { RunProgressEvent, RunProgressStatus } from "./run-progress";
@@ -479,6 +480,7 @@ async function runPhase(
         }
         throw new GateStop(gateRecords, [], check.pending, check.pushed, check.pushWarning);
       }
+      warnOnUnboundComponentApproval(ctx.component, gateName(gate), ctx.env, check.resolution);
       gateRecords.push({
         ...base,
         status: "ok" as const,

package/src/components/fan-out-support.ts

@@ -13,6 +13,7 @@
  * over.
  */
 
+import { lexiconNames } from "../lexicon-module";
 import { resolveComponentTargets } from "./cli-support";
 import { applyConfigDefaults } from "./config-defaults";
 import { buildCapabilityRegistry } from "./capability-plugin-loader";
@@ -91,5 +92,5 @@ export async function deriveFanOut(options: DeriveFanOutOptions): Promise<Derive
  */
 export async function fanOutRegistry(path: string, config?: ChantConfig): Promise<CapabilityRegistry> {
   const resolved = config ?? (await loadChantConfig(path)).config;
-  return buildCapabilityRegistry({ plugins: resolved.capabilities, lexicons: resolved.lexicons });
+  return buildCapabilityRegistry({ plugins: resolved.capabilities, lexicons: lexiconNames(resolved.lexicons) });
 }

package/src/components/pilots/README.md

@@ -13,7 +13,7 @@ The epic ([#551](https://github.com/INTENTIUS/chant/issues/551)) picked these th
 |---|---|---|---|---|---|---|
 | **Neo4j per-instance fan-out** | [`neo4j-fanout.pilot.ts`](./neo4j-fanout.pilot.ts) / [`neo4j-fanout.json`](../__fixtures__/neo4j-fanout.json) | no-build (`infra`, applies pre-built templates) | **fan-out** — one component composes 3 per-instance mini-compositions (`cfn-deploy` + `code-deploy` + `wait-cluster-healthy`), seed-first then rolling, gated at node 1 | simple apply (no `onReplace`/`stageGsi` — no sticky CFN concerns here) | none (self-contained cluster, no shared-stack imports) | **auto** — `code-deploy` (AWS CodeDeploy) rollback is native/automatic on failure, declared once inside the capability, never scripted per node |
 | **DynamoDB table** | [`dynamodb.pilot.ts`](./dynamodb.pilot.ts) / [`dynamodb-infra.json`](../__fixtures__/dynamodb-infra.json) | no-build (`infra`, applies an existing table template) | single (one `cfn-deploy`, no fan-out) | **sticky** — `onReplace: "block"` refuses a replacing changeset (data loss guard); `stageGsi: true` stages the GSI add→backfill→remove instead of an in-place replace | none | no rollback declared — a blocked replacement is not something to compensate, it is a stop |
-| **ALB/ECS target** | [`alb-ecs.pilot.ts`](./alb-ecs.pilot.ts) / [`alb-ecs-service.json`](../__fixtures__/alb-ecs-service.json) | **build** — `docker-build` → `publish-image` (promote by digest at deploy time) | single (one service, one `cfn-deploy` + `ecs-update-service`) | simple apply (no replacement-sensitive resource here) | **cross-stack** — imports `shared-alb`'s `ListenerArn`/`ClusterArn`/`Subnets` via `stackOutput()`, replacing the `describe-stacks \| jq` glue in [`examples/gitlab-aws-alb-services/src/pipeline.ts`](../../../../../examples/gitlab-aws-alb-services/src/pipeline.ts) | **no** (component-declared) — `ecs-update-service`/`cfn-deploy` have no native automatic rollback for an already-running service swap, so the component supplies an explicit `rollback` phase (`rollback-previous`) rather than relying on capability compensation |
+| **ALB/ECS target** | [`alb-ecs.pilot.ts`](./alb-ecs.pilot.ts) / [`alb-ecs-service.json`](../__fixtures__/alb-ecs-service.json) | **build** — `docker-build` → `publish-image` (promote by digest at deploy time) | single (one service, one `cfn-deploy` + `ecs-update-service`) | simple apply (no replacement-sensitive resource here) | **cross-stack** — imports `shared-alb`'s `ListenerArn`/`ClusterArn`/`Subnets` via `stackOutput()`, replacing the `describe-stacks \| jq` glue in [`examples/gitlab-aws-alb-services/src/pipeline.ts`](../../../../../examples/gitlab-aws-alb-services/src/pipeline.ts) | **no** — the in-run unwind calls `ecs-update-service`'s best-effort re-apply and `cfn-deploy`'s native rollback. The component declares no `rollback` phase (#2576), and an earlier release is restored with `chant components rollback` |
 
 Read together, the three cover every cell at least once: build only shows up for ALB/ECS, fan-out only for Neo4j, sticky-apply only for DynamoDB, cross-stack only for ALB/ECS, and both rollback styles (capability-native vs component-declared) appear once each.
 

package/src/components/pilots/alb-ecs.pilot.ts

@@ -1,7 +1,7 @@
 /**
  * Pilot: ALB/ECS target (#555, epic #551).
  *
- * Exercises the build + cross-stack + auto-rollback axes: `docker-build` →
+ * Exercises the build + cross-stack axes: `docker-build` →
  * `publish-image` (promote by digest, deploy-time) → `cfn-deploy` (importing
  * the shared ALB's listener/cluster/subnets as cross-stack outputs, resolved
  * by `chant graph --stacks` rather than a `describe-stacks | jq` pipeline
@@ -16,6 +16,12 @@
  * capabilities. `service` archetype: build → publish → apply → verify, the
  * fullest of the three archetypes.
  *
+ * It declares no component-level `rollback` phase (#2576). It used to declare
+ * one holding a `rollback-previous` step with only `service` and `cluster`,
+ * which the aws capability turned into an `aws ecs update-service` with no
+ * changes. Taking an environment back to an earlier recorded release is
+ * `chant components rollback` (#2531).
+ *
  * The JSON projection of this pilot is authoritative at
  * ../__fixtures__/alb-ecs-service.json (already schema-validated by
  * component-schema.test.ts) — this module is the real typed `Component`
@@ -54,10 +60,4 @@ export const searchService: Component = {
       { kind: "health-gate", path: "/healthz" },
     ]),
   ],
-  // No native `rollback` on ecs-update-service/cfn-deploy for an already-running
-  // service swap — the component declares an explicit compensation phase
-  // (auto/no-rollback axis: this is the "no automatic capability rollback,
-  // component supplies its own" side, contrasted with code-deploy's native
-  // automatic rollback in the Neo4j pilot).
-  rollback: [phase("Rollback", [{ kind: "rollback-previous", service: "search", cluster: "$env.cluster" }])],
 };

package/src/components/presets/ecs-fargate.ts

@@ -4,10 +4,16 @@
  * The named-composition builder for the ALB/ECS shape
  * (`../pilots/alb-ecs.pilot.ts`): `docker-build` -> `publish-image` ->
  * `cfn-deploy` (importing a shared ALB's cross-stack outputs) ->
- * `ecs-update-service` -> `wait-steady-state` + `health-gate`, with the same
- * component-declared `rollback-previous` compensation phase the pilot uses
- * (no native rollback for an already-running service swap — see
- * ../pilots/alb-ecs.pilot.ts's docstring).
+ * `ecs-update-service` -> `wait-steady-state` + `health-gate`.
+ *
+ * There is no component-level `rollback` phase (#2576). The preset used to
+ * declare one holding a `rollback-previous` step with only `service` and
+ * `cluster`. The aws capability behind that kind rolls a service back to the
+ * `taskDefinition` it is given, and with none given it ran `aws ecs
+ * update-service` with no changes, so the phase restored nothing. The
+ * in-run unwind still calls each executed step's own rollback, and taking an
+ * environment back to an earlier recorded release is `chant components
+ * rollback <env> --component <name>` (#2531).
  *
  * This is Level 2 reuse over Level 1 raw capabilities: a component that looks
  * like this composes `EcsFargateComponent({ ... })` directly; the odd case
@@ -98,6 +104,5 @@ export function EcsFargateComponent(config: EcsFargateComponentConfig): Componen
         { kind: "health-gate", path: config.healthPath },
       ]),
     ],
-    rollback: [phase("Rollback", [{ kind: "rollback-previous", service, cluster }])],
   };
 }