@intentius/chant 0.53.0 → 0.54.0

package/src/cli/commands/carve-status.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { carveStatus, carveStatusJson, formatCarveStatus } from "./carve-status";
+import { writeCarveManifest, type CarveManifest } from "../../terraform/manifest";
+import type { CarveReport } from "../../terraform/carve";
+
+function report(target: string): CarveReport {
+  return {
+    target,
+    carveSet: [{ address: target, type: target.split(".")[0] }],
+    peelability: 90,
+    inbound: [],
+    outbound: [],
+    reversible: true,
+    diagnostics: [],
+  };
+}
+
+function manifest(target: string): CarveManifest {
+  return { version: 1, target, from: "/estate", boundary: report(target) };
+}
+
+function withDir<T>(fn: (dir: string) => T): T {
+  const dir = mkdtempSync(join(tmpdir(), "chant-carve-status-"));
+  try {
+    return fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe("carve status", () => {
+  test("walks the tree at any depth and reports target, stage, and root-relative path", () => {
+    withDir((dir) => {
+      // Flat under a named output dir…
+      writeCarveManifest(join(dir, "carveout"), manifest("aws_s3_bucket.assets"));
+      // …and nested deeper than the two levels a walker would guess at.
+      const deep = { ...manifest("aws_sqs_queue.jobs"), tfType: "aws_sqs_queue" };
+      deep.emit = { source: "tfstate" as const, files: ["src/jobs.ts"], at: "2026-08-30T00:00:00Z" };
+      writeCarveManifest(join(dir, "stacks", "queues", "carveout"), deep);
+
+      const res = carveStatus({ from: dir });
+      expect(res.ok).toBe(true);
+      expect(res.from).toBe(dir);
+      expect(res.carves).toHaveLength(2);
+
+      const [flat, nested] = res.carves!;
+      expect(flat.path).toBe(join("carveout", "aws_s3_bucket-assets.carve.json"));
+      expect(flat.target).toBe("aws_s3_bucket.assets");
+      expect(flat.stage).toBe("planned"); // boundary only, no recorded step
+      expect(flat.at).toEqual({});
+
+      expect(nested.path).toBe(join("stacks", "queues", "carveout", "aws_sqs_queue-jobs.carve.json"));
+      expect(nested.target).toBe("aws_sqs_queue.jobs");
+      expect(nested.tfType).toBe("aws_sqs_queue");
+      expect(nested.stage).toBe("emitted");
+      expect(nested.at).toEqual({ emit: "2026-08-30T00:00:00Z" });
+      expect(nested.emittedFiles).toEqual(["src/jobs.ts"]);
+    });
+  });
+
+  test("stage is the highest recorded step: emitted < bridged < applied", () => {
+    withDir((dir) => {
+      const m = manifest("aws_s3_bucket.assets");
+      m.emit = { source: "tfstate", files: ["src/assets.ts"], at: "t1" };
+      m.bridge = { written: ["runbook.md"], appliedInPlace: false, at: "t2" };
+      m.apply = { marker: { stack: "assets", env: "prod" }, ownershipTags: {}, at: "t3" };
+      writeCarveManifest(dir, m);
+
+      const res = carveStatus({ from: dir });
+      expect(res.carves![0].stage).toBe("applied");
+      expect(res.carves![0].at).toEqual({ emit: "t1", bridge: "t2", apply: "t3" });
+    });
+  });
+
+  test("reports unreadable manifest files instead of failing or silently dropping them", () => {
+    withDir((dir) => {
+      writeCarveManifest(dir, manifest("aws_s3_bucket.assets"));
+      writeFileSync(join(dir, "bad.carve.json"), "not json");
+
+      const res = carveStatus({ from: dir });
+      expect(res.ok).toBe(true);
+      expect(res.carves).toHaveLength(1);
+      expect(res.unreadable).toEqual(["bad.carve.json"]);
+      expect(formatCarveStatus(res)).toContain("bad.carve.json");
+    });
+  });
+
+  test("skips node_modules and .git", () => {
+    withDir((dir) => {
+      mkdirSync(join(dir, "node_modules", "dep"), { recursive: true });
+      writeCarveManifest(join(dir, "node_modules", "dep"), manifest("aws_s3_bucket.vendored"));
+      const res = carveStatus({ from: dir });
+      expect(res.carves).toHaveLength(0);
+      expect(formatCarveStatus(res)).toContain("No carve manifests");
+    });
+  });
+
+  test("errors on a non-directory root", () => {
+    const res = carveStatus({ from: "/definitely/not/a/dir" });
+    expect(res.ok).toBe(false);
+    expect(res.error).toContain("Not a directory");
+  });
+
+  test("--json payload carries from, carves, and unreadable only when present", () => {
+    withDir((dir) => {
+      writeCarveManifest(dir, manifest("aws_s3_bucket.assets"));
+      const res = carveStatus({ from: dir });
+      const json = carveStatusJson(res);
+      expect(Object.keys(json)).toEqual(["from", "carves"]);
+      expect((json.carves as unknown[]).length).toBe(1);
+    });
+  });
+});

package/src/cli/commands/carve-status.ts

@@ -0,0 +1,163 @@
+/**
+ * `chant carve status` — the read over a tree of carve manifests (#2038).
+ *
+ * emit → bridge → apply each persist their step into `<target>.carve.json`
+ * (./../../terraform/manifest.ts), but until now nothing read that state back
+ * over more than one output dir at a time: a renderer wanting "what carves
+ * exist under this project, and how far along is each" had to walk the tree
+ * itself and guess at depth. This makes the walk a contract: recurse from
+ * `--from` (default: cwd), read every manifest the way bridge/apply's own
+ * `resolveCarveManifest` reads one, and answer with each manifest's target,
+ * stage, and path. Read-only — it writes nothing and touches no live resource.
+ */
+
+import { existsSync, readdirSync, statSync } from "fs";
+import { join, relative, resolve } from "path";
+import {
+  CARVE_MANIFEST_SUFFIX,
+  readCarveManifest,
+  type CarveManifest,
+} from "../../terraform/manifest";
+
+/**
+ * How far along a carve is — the highest recorded step. `planned` is a
+ * manifest holding only the boundary classification (written, but `carve
+ * emit` recorded no emit section — e.g. a hand-seeded or partially-run
+ * carve).
+ */
+export type CarveStage = "planned" | "emitted" | "bridged" | "applied";
+
+export interface CarveStatusRow {
+  /** Manifest path, relative to the walk root. */
+  path: string;
+  /** Terraform address of the carved resource. */
+  target: string;
+  /** Terraform resource type, when the manifest recorded one. */
+  tfType?: string;
+  /** The highest recorded step. */
+  stage: CarveStage;
+  /** ISO-8601 timestamp of each recorded step. */
+  at: { emit?: string; bridge?: string; apply?: string };
+  /** Emitted chant source file path(s), exactly as the manifest records them. */
+  emittedFiles?: string[];
+}
+
+export interface CarveStatusOptions {
+  /** Root of the walk (`--from`). Default: the current directory. */
+  from?: string;
+}
+
+export interface CarveStatusResult {
+  ok: boolean;
+  error?: string;
+  /** The resolved walk root. */
+  from?: string;
+  /** One row per readable manifest, sorted by path. */
+  carves?: CarveStatusRow[];
+  /** Manifest-suffixed files that did not read as a manifest (wrong version, malformed). */
+  unreadable?: string[];
+}
+
+/**
+ * Directories that never hold a carve output dir and make the walk expensive
+ * or wrong: dependency trees, VCS internals, build output.
+ */
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".chant"]);
+
+/** Every `*.carve.json` under `root`, found by a bounded recursive walk. */
+function findManifests(root: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string): void => {
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return; // unreadable dir — skip rather than fail the whole status
+    }
+    for (const entry of entries.sort()) {
+      if (SKIP_DIRS.has(entry)) continue;
+      const path = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(path);
+      } catch {
+        continue; // dangling symlink
+      }
+      if (stat.isDirectory()) walk(path);
+      else if (entry.endsWith(CARVE_MANIFEST_SUFFIX)) found.push(path);
+    }
+  };
+  walk(root);
+  return found;
+}
+
+function stageOf(manifest: CarveManifest): CarveStage {
+  if (manifest.apply) return "applied";
+  if (manifest.bridge) return "bridged";
+  if (manifest.emit) return "emitted";
+  return "planned";
+}
+
+export function carveStatus(opts: CarveStatusOptions = {}): CarveStatusResult {
+  const root = resolve(opts.from ?? process.cwd());
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    return { ok: false, error: `Not a directory: ${root}` };
+  }
+
+  const carves: CarveStatusRow[] = [];
+  const unreadable: string[] = [];
+  for (const path of findManifests(root)) {
+    const rel = relative(root, path);
+    const manifest = readCarveManifest(path);
+    if (!manifest) {
+      unreadable.push(rel);
+      continue;
+    }
+    carves.push({
+      path: rel,
+      target: manifest.target,
+      ...(manifest.tfType ? { tfType: manifest.tfType } : {}),
+      stage: stageOf(manifest),
+      at: {
+        ...(manifest.emit?.at ? { emit: manifest.emit.at } : {}),
+        ...(manifest.bridge?.at ? { bridge: manifest.bridge.at } : {}),
+        ...(manifest.apply?.at ? { apply: manifest.apply.at } : {}),
+      },
+      ...(manifest.emit ? { emittedFiles: manifest.emit.files } : {}),
+    });
+  }
+
+  return { ok: true, from: root, carves, ...(unreadable.length > 0 ? { unreadable } : {}) };
+}
+
+/** The JSON payload `--json` emits — everything but `ok`. */
+export function carveStatusJson(result: CarveStatusResult): Record<string, unknown> {
+  return {
+    from: result.from,
+    carves: result.carves ?? [],
+    ...(result.unreadable ? { unreadable: result.unreadable } : {}),
+  };
+}
+
+export function formatCarveStatus(result: CarveStatusResult): string {
+  const carves = result.carves ?? [];
+  if (carves.length === 0) {
+    return `No carve manifests under ${result.from} — run \`chant carve emit\` first.`;
+  }
+  const L: string[] = [];
+  L.push(`${carves.length} carve${carves.length === 1 ? "" : "s"} under ${result.from}`);
+  L.push("");
+  for (const row of carves) {
+    const when = row.at.apply ?? row.at.bridge ?? row.at.emit;
+    L.push(`  ${row.target}  [${row.stage}${when ? ` @ ${when}` : ""}]`);
+    L.push(`    manifest: ${row.path}`);
+    if (row.emittedFiles && row.emittedFiles.length > 0) {
+      L.push(`    emitted:  ${row.emittedFiles.join(", ")}`);
+    }
+  }
+  if (result.unreadable && result.unreadable.length > 0) {
+    L.push("");
+    L.push(`  Unreadable (malformed or unknown version): ${result.unreadable.join(", ")}`);
+  }
+  return L.join("\n");
+}

package/src/cli/handlers/carve-status.ts

@@ -0,0 +1,30 @@
+import { carveStatus, carveStatusJson, formatCarveStatus } from "../commands/carve-status";
+import { formatError } from "../format";
+import type { CommandContext } from "../registry";
+
+/**
+ * `chant carve status [--from <dir>] [--json]` — the read-only status read
+ * over a tree of carve manifests (#2038). Walks from `--from` (default: cwd),
+ * reports every manifest's target, stage (planned/emitted/bridged/applied)
+ * and path. No plugins, no project, no cloud call.
+ */
+export async function runCarveStatus(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+
+  const result = carveStatus({ from: args.migrateFrom /* `--from <dir>` */ });
+
+  if (!result.ok) {
+    console.error(formatError({
+      message: result.error ?? "carve status failed",
+      hint: "chant carve status --from ./tf --json",
+    }));
+    return 1;
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify(carveStatusJson(result), null, 2));
+  } else {
+    console.log(formatCarveStatus(result));
+  }
+  return 0;
+}

package/src/cli/handlers/components.ts

@@ -34,6 +34,7 @@ import {
   readReleaseLedger,
   listReleaseEnvironments,
   latestPerComponent,
+  resolveRunId,
   InvalidReleaseRecordError,
 } from "../../lifecycle/release-ledger";
 import { reconcileStatus, liveEvidenceFromChangeSet, compareAcrossEnvironments, mergeLiveEvidence, type LiveComponentEvidence } from "../../lifecycle/status";
@@ -94,7 +95,9 @@ export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<n
   }
 
   const gitSha = args.gitSha ?? (await getHeadCommit().catch(() => undefined));
-  const runId = args.runId ?? process.env.GITHUB_RUN_ID ?? process.env.CI_PIPELINE_ID ?? `local-${Date.now()}`;
+  // Id + origin resolved together from the same environment (#2045), so the
+  // recorded runId always says which id space it lives in and how to reach it.
+  const { runId, runOrigin } = resolveRunId(args.runId);
   const actor = args.actor ?? process.env.GITHUB_ACTOR ?? process.env.GITLAB_USER_LOGIN ?? process.env.USER;
   // Who approved a gated change (#1035). Optional — omitted for an ungated
   // change, and never defaulted to `actor`, since recording the approver as the
@@ -122,6 +125,7 @@ export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<n
       digest,
       gitSha,
       runId,
+      ...(runOrigin ? { runOrigin } : {}),
       timestamp,
       actor,
       ...(approver ? { approver } : {}),

package/src/cli/handlers/graph.ts

@@ -635,6 +635,9 @@ async function buildPipelineProjection(
     success: true,
     pipeline: {
       provider: lexicon,
+      // The environment the projected pipeline deploys (#2046) — the
+      // generator's own resolution, carried rather than re-derived.
+      ...(result.env ? { env: result.env } : {}),
       stages: result.stages ?? [],
       nodes: jobs.map((j) => ({ id: j.jobName, kind: "CIJob" as const, component: j.component, stage: j.stage })),
       edges: jobs.flatMap((j) => j.needs.map((dep) => ({ from: j.jobName, to: dep, kind: "needs" as const }))),

package/src/cli/handlers/op-progress.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect } from "vitest";
-import { extractStepRecords, countActivities, queryGateState } from "./op-progress";
+import { extractStepRecords, extractIndexedStepRecords, stepRecordEmitter, countActivities, queryGateState } from "./op-progress";
+import type { StepRecord } from "../../op/local-executor";
 import type { OpConfig } from "../../op/types";
 import type { EffectReceiptRef } from "../../op/receipt-store";
 import type { WorkflowHistoryRaw, HistoryEvent } from "./run-client";
@@ -171,6 +172,71 @@ describe("extractStepRecords", () => {
   });
 });
 
+describe("stepRecordEmitter", () => {
+  // chant #2032. Declared order is main phases then `onFailure` reversed, so an
+  // unreached main phase sits *before* an `onFailure` phase that ran. The live
+  // poll therefore returns [Main(fail), Comp(ok)] and the terminal `final: true`
+  // pass returns [Main(fail), Never(skipped), Comp(ok)] — an insertion, not an
+  // append. The old emitted-count watermark sliced at 2 and re-shipped Comp
+  // while dropping Never entirely. The #1676 coverage above misses this because
+  // in those configs the skipped record lands last, where insert and append are
+  // the same operation.
+  const config: OpConfig = {
+    name: "op", overview: "o",
+    phases: [
+      { name: "Main", steps: [{ kind: "activity", fn: "boom" }] },
+      { name: "Never", steps: [{ kind: "activity", fn: "never" }] },
+    ],
+    onFailure: [{ name: "Comp", steps: [{ kind: "activity", fn: "comp" }] }],
+  };
+  // Main fails, Never is never reached, compensation runs and succeeds.
+  const history: WorkflowHistoryRaw = {
+    events: [
+      scheduled("1", "boom", sec(0)),
+      failed("1", sec(1), "boom"),
+      scheduled("2", "comp", sec(2)),
+      completed("2", sec(3)),
+    ],
+  };
+
+  const MAIN: StepRecord = { phase: "Main", fn: "boom", status: "fail", durationMs: 1000, error: "boom" };
+  const NEVER: StepRecord = { phase: "Never", fn: "never", status: "skipped", durationMs: 0 };
+  const COMP: StepRecord = { phase: "Comp", fn: "comp", status: "ok", durationMs: 1000 };
+
+  test("the final pass inserts rather than appends, so list position is not an identity", () => {
+    expect(extractIndexedStepRecords(config, history)).toEqual([
+      { index: 0, record: MAIN },
+      { index: 2, record: COMP },
+    ]);
+    expect(extractIndexedStepRecords(config, history, { final: true })).toEqual([
+      { index: 0, record: MAIN },
+      { index: 1, record: NEVER },
+      { index: 2, record: COMP },
+    ]);
+  });
+
+  test("each record ships exactly once across the poll passes and the final pass", () => {
+    const emitted: StepRecord[] = [];
+    const emit = stepRecordEmitter((r) => emitted.push(r));
+
+    emit(extractIndexedStepRecords(config, history)); // a poll while the workflow closes
+    emit(extractIndexedStepRecords(config, history)); // an identical re-poll adds nothing
+    emit(extractIndexedStepRecords(config, history, { final: true }));
+
+    expect(emitted).toEqual([MAIN, COMP, NEVER]);
+  });
+
+  test("an empty first poll does not shift what a later pass ships", () => {
+    const emitted: StepRecord[] = [];
+    const emit = stepRecordEmitter((r) => emitted.push(r));
+
+    emit(extractIndexedStepRecords(config, { events: [] }));
+    expect(emitted).toEqual([]);
+    emit(extractIndexedStepRecords(config, history, { final: true }));
+    expect(emitted).toEqual([MAIN, NEVER, COMP]);
+  });
+});
+
 describe("countActivities", () => {
   test("counts scheduled and completed events", () => {
     const history: WorkflowHistoryRaw = {

package/src/cli/handlers/op-progress.ts

@@ -113,34 +113,55 @@ function terminalOutcomes(events: HistoryEvent[]): Map<string, TerminalOutcome>
   return out;
 }
 
+/**
+ * A step record paired with the position of the declared step it came from.
+ *
+ * `index` is an offset into `declaredStepOrder(config)`, which depends only
+ * on the Op config — not on the history — so it is the record's identity
+ * and is stable across polls. The record *list* is not: a mid-run poll omits
+ * every step that hasn't settled yet, and the terminal `final: true` pass
+ * inserts a `"skipped"` record at each such step's declared position, which
+ * shifts every later record's list offset (chant #2032). Anything tracking
+ * what it has already seen must key on `index`, never on how many records
+ * the previous call returned.
+ */
+export interface IndexedStepRecord {
+  index: number;
+  record: StepRecord;
+}
+
 /**
  * Reconstruct per-step progress records from a workflow's history, in
- * declared order. Only settled steps (matched to a scheduled event that has
- * since completed or failed) produce a record — a step that hasn't been
- * scheduled yet simply isn't in the result, so a live poll only ever
- * appends. Pass `final: true` once the workflow has reached a terminal
+ * declared order, each tagged with its declared-step `index`. Only settled
+ * steps (matched to a scheduled event that has since completed or failed)
+ * produce a record — a step that hasn't been scheduled yet simply isn't in
+ * the result. Pass `final: true` once the workflow has reached a terminal
  * status to also emit a `"skipped"` record for every declared step that
  * never got a matching scheduled event (an untaken effect branch, or an
  * `onFailure` phase on a run that succeeded) — never before, or a
  * still-running Op would show its not-yet-reached steps as skipped.
  */
-export function extractStepRecords(
+export function extractIndexedStepRecords(
   config: OpConfig,
   history: WorkflowHistoryRaw,
   opts: { final?: boolean } = {},
-): StepRecord[] {
+): IndexedStepRecord[] {
   const events = history.events ?? [];
   const queues = scheduledQueues(events);
   const terminals = terminalOutcomes(events);
   const nextIndex = new Map<string, number>();
 
-  const records: StepRecord[] = [];
-  for (const step of declaredStepOrder(config)) {
+  const records: IndexedStepRecord[] = [];
+  const declared = declaredStepOrder(config);
+  for (let index = 0; index < declared.length; index++) {
+    const step = declared[index];
     const queue = queues.get(step.fn);
     const idx = nextIndex.get(step.fn) ?? 0;
     const entry = queue?.[idx];
     if (!entry) {
-      if (opts.final) records.push({ phase: step.phase, fn: step.fn, status: "skipped", durationMs: 0 });
+      if (opts.final) {
+        records.push({ index, record: { phase: step.phase, fn: step.fn, status: "skipped", durationMs: 0 } });
+      }
       continue;
     }
     nextIndex.set(step.fn, idx + 1);
@@ -151,16 +172,51 @@ export function extractStepRecords(
     const durationMs =
       entry.scheduledAt && terminal.at ? terminal.at.getTime() - entry.scheduledAt.getTime() : 0;
     records.push({
-      phase: step.phase,
-      fn: step.fn,
-      status: terminal.status,
-      durationMs,
-      ...(terminal.error ? { error: terminal.error } : {}),
+      index,
+      record: {
+        phase: step.phase,
+        fn: step.fn,
+        status: terminal.status,
+        durationMs,
+        ...(terminal.error ? { error: terminal.error } : {}),
+      },
     });
   }
   return records;
 }
 
+/** `extractIndexedStepRecords` without the indices — the plain declared-order record list. */
+export function extractStepRecords(
+  config: OpConfig,
+  history: WorkflowHistoryRaw,
+  opts: { final?: boolean } = {},
+): StepRecord[] {
+  return extractIndexedStepRecords(config, history, opts).map((r) => r.record);
+}
+
+/**
+ * A sink that forwards each declared step's record exactly once, however many
+ * times the poll loop re-derives the list.
+ *
+ * `--progress-json` calls this per poll with the whole list so far, plus once
+ * more with the terminal `final: true` list. Deduplicating by declared-step
+ * `index` is what makes that safe: an emitted-count watermark assumed the list
+ * was append-only, and the `final` pass's inserted `"skipped"` records break
+ * that assumption — with an unreached phase declared before an `onFailure`
+ * phase that ran, the insertion shifted the tail, so the last record shipped
+ * twice and the skipped one never shipped at all (chant #2032).
+ */
+export function stepRecordEmitter(emit: (record: StepRecord) => void): (records: IndexedStepRecord[]) => void {
+  const seen = new Set<number>();
+  return (records) => {
+    for (const { index, record } of records) {
+      if (seen.has(index)) continue;
+      seen.add(index);
+      emit(record);
+    }
+  };
+}
+
 /** `{completed, scheduled}` activity counts for the summary line `chant run status`/`op-status` show alongside the full record list. */
 export function countActivities(history: WorkflowHistoryRaw): { completed: number; scheduled: number } {
   const events = history.events ?? [];