executable-stories-formatters 0.11.0 → 0.11.2

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { parseArgs } from "util";
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 
 // src/validation/schema-validator.ts
 import Ajv from "ajv/dist/2020.js";
@@ -558,17 +558,17 @@ function validateRawRun(data) {
     return { valid: true, errors: [] };
   }
   const errors = (validate.errors ?? []).map((err) => {
-    const path15 = err.instancePath || "/";
+    const path16 = err.instancePath || "/";
     const message = err.message ?? "unknown error";
     if (err.keyword === "additionalProperties") {
       const extra = err.params.additionalProperty;
-      return `${path15}: ${message} \u2014 '${extra}'`;
+      return `${path16}: ${message} \u2014 '${extra}'`;
     }
     if (err.keyword === "enum") {
       const allowed = err.params.allowedValues;
-      return `${path15}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
+      return `${path16}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
     }
-    return `${path15}: ${message}`;
+    return `${path16}: ${message}`;
   });
   return { valid: false, errors };
 }
@@ -1043,7 +1043,7 @@ ${result.errors.join("\n")}`);
 
 // src/index.ts
 import "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/lines.ts
@@ -1631,23 +1631,23 @@ function buildFeature(relSourceFile, group) {
 function ensureUniqueFeatureIds(features) {
   const seen = /* @__PURE__ */ new Map();
   for (const f of features) {
-    const count = seen.get(f.id) ?? 0;
-    if (count > 0) f.id = `${f.id}-${count + 1}`;
-    seen.set(f.id, count + 1);
+    const count2 = seen.get(f.id) ?? 0;
+    if (count2 > 0) f.id = `${f.id}-${count2 + 1}`;
+    seen.set(f.id, count2 + 1);
   }
 }
 function ensureUniqueScenarioIds(feature) {
   const seen = /* @__PURE__ */ new Map();
   for (const s of feature.scenarios) {
-    const count = seen.get(s.id) ?? 0;
-    if (count > 0) {
-      const newId = `${s.id}-${count + 1}`;
+    const count2 = seen.get(s.id) ?? 0;
+    if (count2 > 0) {
+      const newId = `${s.id}-${count2 + 1}`;
       for (const step of s.steps) {
         step.id = step.id.replace(s.id, newId);
       }
       s.id = newId;
     }
-    seen.set(s.id, count + 1);
+    seen.set(s.id, count2 + 1);
   }
 }
 function toStoryReport(run) {
@@ -16145,6 +16145,88 @@ function groupBy6(items, keyFn) {
   return map;
 }
 
+// src/formatters/release-manifest.ts
+import { createHash as createHash2 } from "crypto";
+var ReleaseManifestFormatter = class {
+  format(run) {
+    const manifest = toReleaseManifest(run);
+    const lines = [];
+    lines.push("# Release Manifest");
+    lines.push("");
+    lines.push(`Generated: ${manifest.generatedAt}`);
+    lines.push(`Run: ${manifest.run.startedAt} to ${manifest.run.finishedAt}`);
+    if (manifest.run.branch) lines.push(`Branch: ${manifest.run.branch}`);
+    if (manifest.run.gitSha) lines.push(`Commit: ${manifest.run.gitSha}`);
+    lines.push(`Tested-together hash: \`${manifest.testedTogetherHash}\``);
+    lines.push("");
+    lines.push("| Scenarios | Passed | Failed | Skipped | Pending |");
+    lines.push("| ---: | ---: | ---: | ---: | ---: |");
+    lines.push(`| ${manifest.run.total} | ${manifest.run.passed} | ${manifest.run.failed} | ${manifest.run.skipped} | ${manifest.run.pending} |`);
+    lines.push("");
+    lines.push("## Scenarios");
+    lines.push("");
+    lines.push("| Status | Scenario | Source | Tags |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const scenario of manifest.scenarios) {
+      const source = `${scenario.sourceFile}:${scenario.sourceLine}`;
+      const tags = scenario.tags.length > 0 ? scenario.tags.map((tag) => `\`${tag}\``).join(", ") : "";
+      lines.push(`| ${renderStatus(scenario.status)} | ${escapePipe(scenario.title)} | \`${source}\` | ${tags} |`);
+    }
+    return lines.join("\n");
+  }
+};
+function toReleaseManifest(run) {
+  const scenarios = [...run.testCases].sort((a, b) => a.id.localeCompare(b.id)).map((tc) => ({
+    id: tc.id,
+    title: tc.story.scenario,
+    status: tc.status,
+    sourceFile: tc.sourceFile,
+    sourceLine: tc.sourceLine,
+    tags: tc.tags
+  }));
+  const fingerprint = scenarios.map((scenario) => `${scenario.id}:${scenario.status}`).join("\n");
+  return {
+    schemaVersion: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    run: {
+      startedAt: new Date(run.startedAtMs).toISOString(),
+      finishedAt: new Date(run.finishedAtMs).toISOString(),
+      gitSha: run.gitSha,
+      branch: getBranch(run),
+      total: run.testCases.length,
+      passed: count(run.testCases, "passed"),
+      failed: count(run.testCases, "failed"),
+      skipped: count(run.testCases, "skipped"),
+      pending: count(run.testCases, "pending")
+    },
+    testedTogetherHash: createHash2("sha256").update(fingerprint).digest("hex"),
+    scenarios
+  };
+}
+function getBranch(run) {
+  return run.ci?.branch;
+}
+function count(testCases, status) {
+  return testCases.filter((tc) => tc.status === status).length;
+}
+function renderStatus(status) {
+  switch (status) {
+    case "passed":
+      return "passed";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    case "pending":
+      return "pending";
+    default:
+      return status;
+  }
+}
+function escapePipe(value) {
+  return value.replace(/\|/g, "\\|");
+}
+
 // src/formatters/cucumber-messages/synthesize-feature.ts
 function extractFeatureName(testCases, uri) {
   for (const tc of testCases) {
@@ -16211,7 +16293,7 @@ function synthesizeFeature(uri, testCases) {
 }
 
 // src/utils/cucumber-messages.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function msToTimestamp(ms) {
   const seconds = Math.floor(ms / 1e3);
   const nanos = Math.round(ms % 1e3 * 1e6);
@@ -16277,7 +16359,7 @@ function statusToCucumberStatus(status) {
 }
 function deterministicId(kind, salt, ...parts) {
   const input = [salt, kind, ...parts].join("::");
-  return createHash2("sha1").update(input).digest("hex").slice(0, 36);
+  return createHash3("sha1").update(input).digest("hex").slice(0, 36);
 }
 
 // src/formatters/cucumber-messages/build-gherkin-document.ts
@@ -16765,8 +16847,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path15) {
-  const lower = path15.toLowerCase();
+function guessMediaType(path16) {
+  const lower = path16.toLowerCase();
   if (lower.endsWith(".png")) return "image/png";
   if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
   if (lower.endsWith(".gif")) return "image/gif";
@@ -16907,11 +16989,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve11) => htmlStream.once("drain", resolve11));
+        await new Promise((resolve12) => htmlStream.once("drain", resolve12));
       }
     }
-    await new Promise((resolve11, reject) => {
-      collector.on("finish", resolve11);
+    await new Promise((resolve12, reject) => {
+      collector.on("finish", resolve12);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -17005,15 +17087,15 @@ function createPrCommentSummary(diff, maxScenarios = 10) {
 function getCommit(run) {
   return run.ci?.commitSha ?? run.gitSha;
 }
-function getBranch(run) {
+function getBranch2(run) {
   return run.ci?.branch;
 }
 function pickAutoBaseline(currentRun, candidates) {
-  const currentBranch = getBranch(currentRun);
+  const currentBranch = getBranch2(currentRun);
   const currentCommit = getCommit(currentRun);
   return [...candidates].sort((a, b) => {
-    const aSameBranch = Boolean(currentBranch && getBranch(a.run) && currentBranch === getBranch(a.run));
-    const bSameBranch = Boolean(currentBranch && getBranch(b.run) && currentBranch === getBranch(b.run));
+    const aSameBranch = Boolean(currentBranch && getBranch2(a.run) && currentBranch === getBranch2(a.run));
+    const bSameBranch = Boolean(currentBranch && getBranch2(b.run) && currentBranch === getBranch2(b.run));
     if (aSameBranch !== bSameBranch) {
       return Number(bSameBranch) - Number(aSameBranch);
     }
@@ -18005,8 +18087,8 @@ ${body}`;
   }
   buildFrontmatter(run) {
     const badge = _AstroFormatter.computeBadge(run.testCases);
-    const count = run.testCases.length;
-    const description = `${count} scenario${count !== 1 ? "s" : ""} \u2014 ${badge.text.toLowerCase()}`;
+    const count2 = run.testCases.length;
+    const description = `${count2} scenario${count2 !== 1 ? "s" : ""} \u2014 ${badge.text.toLowerCase()}`;
     const lines = [
       "---",
       `title: ${yamlScalar(this.deriveTitle(run))}`,
@@ -19988,18 +20070,18 @@ function deriveChangeType(tags) {
   }
   return "unknown";
 }
-function extensionOf(path15) {
-  const base = path15.split("/").pop() ?? path15;
+function extensionOf(path16) {
+  const base = path16.split("/").pop() ?? path16;
   const dot = base.lastIndexOf(".");
   return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
 }
-function isTestFile(path15) {
-  return TEST_INFIX.test(path15);
+function isTestFile(path16) {
+  return TEST_INFIX.test(path16);
 }
-function isReviewableSource(path15) {
-  if (isTestFile(path15)) return false;
-  if (path15.endsWith(".d.ts")) return false;
-  return CODE_EXTENSIONS.has(extensionOf(path15));
+function isReviewableSource(path16) {
+  if (isTestFile(path16)) return false;
+  if (path16.endsWith(".d.ts")) return false;
+  return CODE_EXTENSIONS.has(extensionOf(path16));
 }
 function testBaseKey(testFile) {
   return testFile.replace(TEST_INFIX, "");
@@ -20103,7 +20185,7 @@ function toClaim(testCase, changedSourcePaths) {
   const { strength, reasons } = gradeEvidence(testCase, audience);
   const key = testBaseKey(testCase.sourceFile);
   const coversFiles = changedSourcePaths.filter(
-    (path15) => sourceBaseKey(path15) === key
+    (path16) => sourceBaseKey(path16) === key
   );
   return {
     id: testCase.id,
@@ -20633,11 +20715,116 @@ applyTheme(getEffectiveTheme());` : "";
   }
 };
 
+// src/deploy/ledger.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+function createEmptyLedger() {
+  return {
+    deployments: [],
+    schemaVersion: 1
+  };
+}
+function loadLedger(ledgerPath) {
+  const resolved = path8.resolve(ledgerPath);
+  if (!fs7.existsSync(resolved)) {
+    return createEmptyLedger();
+  }
+  try {
+    const raw = JSON.parse(fs7.readFileSync(resolved, "utf8"));
+    if (raw.schemaVersion !== 1) {
+      throw new Error(`Unsupported ledger schemaVersion: ${raw.schemaVersion}`);
+    }
+    return raw;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load deployment ledger at ${resolved}: ${msg}`);
+  }
+}
+function saveLedger(ledger, ledgerPath) {
+  const resolved = path8.resolve(ledgerPath);
+  const dir = path8.dirname(resolved);
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
+}
+function getLatestDeployment(ledger, environment) {
+  return [...ledger.deployments].reverse().find((d) => d.environment === environment);
+}
+
+// src/deploy/index.ts
+function recordDeployment(args) {
+  const ledger = loadLedger(args.ledgerPath);
+  const previous = getLatestDeployment(ledger, args.environment);
+  const entry = {
+    environment: args.environment,
+    tag: args.tag,
+    sha: args.run.gitSha,
+    runFile: args.runFilePath,
+    scenarioIds: args.run.testCases.map((tc) => tc.id),
+    scenarioStatuses: Object.fromEntries(args.run.testCases.map((tc) => [tc.id, tc.status])),
+    timestamp: new Date(args.run.finishedAtMs).toISOString(),
+    summary: countStatuses(args.run)
+  };
+  ledger.deployments.push(entry);
+  if (previous) {
+    const previousIds = new Set(previous.scenarioIds);
+    const added = entry.scenarioIds.filter((id) => !previousIds.has(id)).length;
+    const removed = previous.scenarioIds.filter((id) => !entry.scenarioIds.includes(id)).length;
+    if (added > 0 || removed > 0) {
+    }
+  }
+  saveLedger(ledger, args.ledgerPath);
+  return { entry, ledgerPath: args.ledgerPath };
+}
+function getDeploymentStatus(ledgerPath) {
+  const ledger = loadLedger(ledgerPath);
+  const environments = {};
+  for (const entry of ledger.deployments) {
+    environments[entry.environment] = {
+      latest: entry,
+      previousDeployment: environments[entry.environment]?.latest
+    };
+  }
+  return { environments, ledgerPath };
+}
+function getEnvironmentDrift(ledgerPath, envA, envB) {
+  const ledger = loadLedger(ledgerPath);
+  const aEntry = getLatestDeployment(ledger, envA);
+  const bEntry = getLatestDeployment(ledger, envB);
+  if (!aEntry) {
+    throw new Error(`No deployment found for environment "${envA}"`);
+  }
+  if (!bEntry) {
+    throw new Error(`No deployment found for environment "${envB}"`);
+  }
+  const aIds = new Set(aEntry.scenarioIds);
+  const bIds = new Set(bEntry.scenarioIds);
+  const onlyInA = aEntry.scenarioIds.filter((id) => !bIds.has(id));
+  const onlyInB = bEntry.scenarioIds.filter((id) => !aIds.has(id));
+  const inBoth = aEntry.scenarioIds.filter((id) => bIds.has(id));
+  const statusChanged = inBoth.map((id) => ({
+    id,
+    statusA: aEntry.scenarioStatuses?.[id] ?? "unknown",
+    statusB: bEntry.scenarioStatuses?.[id] ?? "unknown"
+  })).filter((item) => item.statusA !== item.statusB);
+  return { environmentA: envA, environmentB: envB, onlyInA, onlyInB, inBoth, statusChanged, aEntry, bEntry };
+}
+function countStatuses(run) {
+  const summary = { total: 0, passed: 0, failed: 0, skipped: 0, pending: 0 };
+  for (const tc of run.testCases) {
+    summary.total++;
+    if (tc.status in summary) {
+      summary[tc.status]++;
+    }
+  }
+  return summary;
+}
+
 // src/index.ts
 var FORMAT_EXTENSIONS = {
   astro: ".md",
   "behavior-manifest-json": ".behavior-manifest.json",
   markdown: ".md",
+  "release-manifest": ".release-manifest.md",
   html: ".html",
   "cucumber-html": ".cucumber.html",
   junit: ".junit.xml",
@@ -20676,11 +20863,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path8.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
+    return toPosix(path9.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path8.posix.dirname(normalizedSource);
-  let baseName = path8.posix.basename(normalizedSource);
+  const dirOfSource = path9.posix.dirname(normalizedSource);
+  let baseName = path9.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -20689,12 +20876,12 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path8.posix.join(dirOfSource, fileName));
+    return toPosix(path9.posix.join(dirOfSource, fileName));
   }
   if (colocatedStyle === "flat") {
-    return toPosix(path8.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
+    return toPosix(path9.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
   }
-  return toPosix(path8.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path9.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -20901,8 +21088,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path8.dirname(mdPath);
-          const assetsDir = path8.resolve(this.options.astro.assetsDir);
+          const mdDir = path9.dirname(mdPath);
+          const assetsDir = path9.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -20933,9 +21120,9 @@ var ReportGenerator = class {
     if (groups.size === 0 && this.options.output.mode === "aggregated") {
       const ext = FORMAT_EXTENSIONS[format];
       const effectiveName = this.options.outputName + (outputNameSuffix ?? "");
-      const outputPath = toPosix(path8.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
+      const outputPath = toPosix(path9.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
       const content = await this.formatContent(run, format);
-      const dir = path8.dirname(outputPath);
+      const dir = path9.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -20947,7 +21134,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path8.dirname(outputPath);
+      const dir = path9.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -21056,6 +21243,10 @@ var ReportGenerator = class {
         });
         return formatter.format(run);
       }
+      case "release-manifest": {
+        const formatter = new ReleaseManifestFormatter();
+        return formatter.format(run);
+      }
       case "story-report-json": {
         const formatter = new StoryReportJsonFormatter({
           pretty: this.options.storyReportJson.pretty
@@ -21087,7 +21278,7 @@ async function generateRunComparison(args) {
   await fsPromises.mkdir(outputDir, { recursive: true });
   for (const format of args.formats) {
     const ext = format === "html" ? ".html" : ".md";
-    const outputPath = toPosix(path8.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path9.join(outputDir, `${outputName}${ext}`));
     const content = format === "html" ? new RunDiffHtmlFormatter({ title: args.title }).format(diff) : new RunDiffMarkdownFormatter({ title: args.title }).format(diff);
     await fsPromises.writeFile(outputPath, content, "utf8");
     files.push(outputPath);
@@ -21096,18 +21287,18 @@ async function generateRunComparison(args) {
 }
 
 // src/init-astro.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path9.dirname(fileURLToPath(import.meta.url));
+var __dirname = path10.dirname(fileURLToPath(import.meta.url));
 var FRAMEWORK_DIRS = ["src/components", "src/lib", "src/styles", "src/pages"];
 var FRAMEWORK_FILES = ["tsconfig.json"];
 function initAstro(options = {}) {
   const targetDir = options.targetDir ?? "./story-docs";
   const force = options.force ?? false;
   const update = options.update ?? false;
-  const templateDir = path9.resolve(__dirname, "..", "templates", "astro-starlight");
-  if (!fs8.existsSync(templateDir)) {
+  const templateDir = path10.resolve(__dirname, "..", "templates", "astro-starlight");
+  if (!fs9.existsSync(templateDir)) {
     throw new Error(
       `Template directory not found at ${templateDir}. Ensure the package is installed correctly.`
     );
@@ -21115,8 +21306,8 @@ function initAstro(options = {}) {
   if (update) {
     return updateFrameworkFiles(templateDir, targetDir);
   }
-  if (fs8.existsSync(targetDir)) {
-    const entries = fs8.readdirSync(targetDir);
+  if (fs9.existsSync(targetDir)) {
+    const entries = fs9.readdirSync(targetDir);
     if (entries.length > 0 && !force) {
       throw new Error(
         `Directory "${targetDir}" already exists and is not empty. Use --force to overwrite, or --update to refresh framework files only.`
@@ -21127,32 +21318,32 @@ function initAstro(options = {}) {
   return { targetDir };
 }
 function updateFrameworkFiles(templateDir, targetDir) {
-  if (!fs8.existsSync(targetDir) || !fs8.existsSync(path9.join(targetDir, "astro.config.mjs"))) {
+  if (!fs9.existsSync(targetDir) || !fs9.existsSync(path10.join(targetDir, "astro.config.mjs"))) {
     throw new Error(
       `"${targetDir}" does not look like a scaffolded docs site. Run init-astro (without --update) first.`
     );
   }
   const updated = [];
   for (const dir of FRAMEWORK_DIRS) {
-    const src = path9.join(templateDir, dir);
-    if (!fs8.existsSync(src)) continue;
-    copyDirRecursive(src, path9.join(targetDir, dir), (rel) => updated.push(path9.join(dir, rel)));
+    const src = path10.join(templateDir, dir);
+    if (!fs9.existsSync(src)) continue;
+    copyDirRecursive(src, path10.join(targetDir, dir), (rel) => updated.push(path10.join(dir, rel)));
   }
   for (const file of FRAMEWORK_FILES) {
-    const src = path9.join(templateDir, file);
-    if (!fs8.existsSync(src)) continue;
-    fs8.copyFileSync(src, path9.join(targetDir, file));
+    const src = path10.join(templateDir, file);
+    if (!fs9.existsSync(src)) continue;
+    fs9.copyFileSync(src, path10.join(targetDir, file));
     updated.push(file);
   }
   if (mergeDependencies(templateDir, targetDir)) updated.push("package.json (deps)");
   return { targetDir, updatedFiles: updated };
 }
 function mergeDependencies(templateDir, targetDir) {
-  const tmplPkgPath = path9.join(templateDir, "package.json");
-  const userPkgPath = path9.join(targetDir, "package.json");
-  if (!fs8.existsSync(tmplPkgPath) || !fs8.existsSync(userPkgPath)) return false;
-  const tmpl = JSON.parse(fs8.readFileSync(tmplPkgPath, "utf8"));
-  const user = JSON.parse(fs8.readFileSync(userPkgPath, "utf8"));
+  const tmplPkgPath = path10.join(templateDir, "package.json");
+  const userPkgPath = path10.join(targetDir, "package.json");
+  if (!fs9.existsSync(tmplPkgPath) || !fs9.existsSync(userPkgPath)) return false;
+  const tmpl = JSON.parse(fs9.readFileSync(tmplPkgPath, "utf8"));
+  const user = JSON.parse(fs9.readFileSync(userPkgPath, "utf8"));
   user.dependencies = user.dependencies ?? {};
   let changed = false;
   for (const [name, version] of Object.entries(tmpl.dependencies ?? {})) {
@@ -21162,29 +21353,29 @@ function mergeDependencies(templateDir, targetDir) {
     }
   }
   if (changed) {
-    fs8.writeFileSync(userPkgPath, `${JSON.stringify(user, null, 2)}
+    fs9.writeFileSync(userPkgPath, `${JSON.stringify(user, null, 2)}
 `, "utf8");
   }
   return changed;
 }
 function copyDirRecursive(src, dest, onFile, baseSrc = src) {
-  fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path9.join(src, entry.name);
-    const destPath = path9.join(dest, entry.name);
+    const srcPath = path10.join(src, entry.name);
+    const destPath = path10.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath, onFile, baseSrc);
     } else {
-      fs8.copyFileSync(srcPath, destPath);
-      onFile?.(path9.relative(baseSrc, srcPath));
+      fs9.copyFileSync(srcPath, destPath);
+      onFile?.(path10.relative(baseSrc, srcPath));
     }
   }
 }
 
 // src/scaffold-doc.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 var TEMPLATES = ["adr", "runbook", "decision-log", "incident"];
 function slugify3(input) {
   return input.toLowerCase().trim().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
@@ -21195,7 +21386,7 @@ function isoDate(today) {
 function nextSeq(dir) {
   let max = 0;
   try {
-    for (const entry of fs9.readdirSync(dir)) {
+    for (const entry of fs10.readdirSync(dir)) {
       const match = /^(\d{1,4})-/.exec(entry);
       if (match) max = Math.max(max, Number.parseInt(match[1], 10));
     }
@@ -21328,11 +21519,11 @@ function scaffoldDoc(options) {
     );
   }
   const spec = TEMPLATE_SPECS[template];
-  const baseDir = options.baseDir ?? path10.join("src", "content", "docs");
+  const baseDir = options.baseDir ?? path11.join("src", "content", "docs");
   const today = options.today ?? /* @__PURE__ */ new Date();
   const name = (options.name ?? "").trim() || defaultName(template);
   const slug2 = slugify3(name);
-  const dir = path10.join(baseDir, spec.subdir);
+  const dir = path11.join(baseDir, spec.subdir);
   const ctx = {
     name,
     slug: slug2,
@@ -21340,14 +21531,14 @@ function scaffoldDoc(options) {
     seq: nextSeq(dir)
   };
   const filename = `${spec.filename(slug2, ctx)}.mdx`;
-  const filePath = path10.join(dir, filename);
-  if (fs9.existsSync(filePath) && !options.force) {
+  const filePath = path11.join(dir, filename);
+  if (fs10.existsSync(filePath) && !options.force) {
     throw new Error(
       `File "${filePath}" already exists. Use --force to overwrite.`
     );
   }
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(filePath, spec.content(ctx), "utf8");
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(filePath, spec.content(ctx), "utf8");
   return { template, path: filePath, title: titleFor2(template, ctx) };
 }
 function defaultName(template) {
@@ -21376,8 +21567,8 @@ function titleFor2(template, ctx) {
 }
 
 // src/check-links.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 function stripCode(markdown) {
   let out = markdown.replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]*\1\s*$/gm, "");
   out = out.replace(/(`+)(?:(?!\1).)+\1/g, "");
@@ -21407,27 +21598,27 @@ function classifyLink(link2) {
 function resolutionCandidates(fromFile, link2) {
   const withoutAnchor = link2.split("#")[0];
   if (!withoutAnchor) return [];
-  const base = path11.resolve(path11.dirname(fromFile), withoutAnchor);
+  const base = path12.resolve(path12.dirname(fromFile), withoutAnchor);
   const candidates = [base];
-  if (!path11.extname(base)) {
+  if (!path12.extname(base)) {
     candidates.push(`${base}.md`, `${base}.mdx`);
-    candidates.push(path11.join(base, "index.md"), path11.join(base, "index.mdx"));
+    candidates.push(path12.join(base, "index.md"), path12.join(base, "index.mdx"));
   }
   return candidates;
 }
 function resolvesOnDisk(fromFile, link2) {
   return resolutionCandidates(fromFile, link2).some(
-    (candidate) => fs10.existsSync(candidate) && fs10.statSync(candidate).isFile()
+    (candidate) => fs11.existsSync(candidate) && fs11.statSync(candidate).isFile()
   );
 }
 function collectDocFiles(target) {
-  const stat = fs10.statSync(target);
+  const stat = fs11.statSync(target);
   if (stat.isFile()) return [target];
   const out = [];
   const walk = (dir) => {
-    for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = path11.join(dir, entry.name);
+      const full = path12.join(dir, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (/\.mdx?$/.test(entry.name)) out.push(full);
     }
@@ -21458,7 +21649,7 @@ async function isExternalAlive(url, timeoutMs) {
 }
 async function checkLinks(options) {
   const { target, checkExternal = false, externalTimeoutMs = 8e3 } = options;
-  if (!fs10.existsSync(target)) {
+  if (!fs11.existsSync(target)) {
     throw new Error(`Path not found: ${target}`);
   }
   const files = collectDocFiles(target);
@@ -21468,7 +21659,7 @@ async function checkLinks(options) {
   let skipped = 0;
   const externalCache = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const content = fs10.readFileSync(file, "utf8");
+    const content = fs11.readFileSync(file, "utf8");
     for (const link2 of extractLinks(content)) {
       const kind = classifyLink(link2);
       if (kind === "anchor" || kind === "mail" || kind === "root") {
@@ -21524,8 +21715,8 @@ function formatLinkReport(report) {
 }
 
 // src/import-openapi.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as path13 from "path";
 import { parse as parseYamlString } from "yaml";
 var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head"];
 function parseYaml(raw, specPath) {
@@ -21538,9 +21729,9 @@ function parseYaml(raw, specPath) {
   }
 }
 function parseSpec(specPath) {
-  if (!fs11.existsSync(specPath)) throw new Error(`Spec not found: ${specPath}`);
-  const raw = fs11.readFileSync(specPath, "utf8");
-  const ext = path12.extname(specPath).toLowerCase();
+  if (!fs12.existsSync(specPath)) throw new Error(`Spec not found: ${specPath}`);
+  const raw = fs12.readFileSync(specPath, "utf8");
+  const ext = path13.extname(specPath).toLowerCase();
   if (ext === ".json") return JSON.parse(raw);
   if (ext === ".yaml" || ext === ".yml") return parseYaml(raw, specPath);
   try {
@@ -21571,8 +21762,8 @@ function extractEndpoints(spec) {
 }
 function loadScenarios(runFile) {
   if (!runFile) return [];
-  if (!fs11.existsSync(runFile)) throw new Error(`Run file not found: ${runFile}`);
-  const report = JSON.parse(fs11.readFileSync(runFile, "utf8"));
+  if (!fs12.existsSync(runFile)) throw new Error(`Run file not found: ${runFile}`);
+  const report = JSON.parse(fs12.readFileSync(runFile, "utf8"));
   return (report.features ?? []).flatMap((f) => f.scenarios ?? []);
 }
 function endpointRefs(endpoint) {
@@ -21679,25 +21870,25 @@ async function importOpenApi(options) {
     list.push(item);
     groups.set(item.endpoint.tag, list);
   }
-  const outputDir = options.outputDir ?? path12.join("src", "content", "docs", "api");
-  if (fs11.existsSync(outputDir) && !options.force) {
-    const entries = fs11.readdirSync(outputDir);
+  const outputDir = options.outputDir ?? path13.join("src", "content", "docs", "api");
+  if (fs12.existsSync(outputDir) && !options.force) {
+    const entries = fs12.readdirSync(outputDir);
     if (entries.length > 0) {
       throw new Error(`Output directory "${outputDir}" is not empty. Use --force to overwrite.`);
     }
   }
-  fs11.mkdirSync(outputDir, { recursive: true });
+  fs12.mkdirSync(outputDir, { recursive: true });
   const coveredCount = coverage.filter((c) => c.status === "covered").length;
   const uncoveredCount = coverage.filter((c) => c.status === "uncovered").length;
-  fs11.writeFileSync(
-    path12.join(outputDir, "index.mdx"),
+  fs12.writeFileSync(
+    path13.join(outputDir, "index.mdx"),
     renderIndex(groups, hasRun, { endpointCount: endpoints.length, coveredCount, uncoveredCount }),
     "utf8"
   );
   for (const [tag, rows] of groups) {
-    const dir = path12.join(outputDir, slug(tag));
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(path12.join(dir, "index.mdx"), renderTagPage(tag, rows, hasRun), "utf8");
+    const dir = path13.join(outputDir, slug(tag));
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(path13.join(dir, "index.mdx"), renderTagPage(tag, rows, hasRun), "utf8");
   }
   return {
     outputDir,
@@ -21709,8 +21900,8 @@ async function importOpenApi(options) {
 }
 
 // src/build-docs.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 var BuildDocsError = class extends Error {
   constructor(message, kind) {
     super(message);
@@ -21720,22 +21911,22 @@ var BuildDocsError = class extends Error {
 };
 var isRemote = (p) => /^(?:https?:|data:)/i.test(p);
 function bundleExplorerAssets(reportPath, assetsDir, baseUrl = "/stories/assets") {
-  if (!fs12.existsSync(reportPath)) return 0;
-  const report = JSON.parse(fs12.readFileSync(reportPath, "utf8"));
+  if (!fs13.existsSync(reportPath)) return 0;
+  const report = JSON.parse(fs13.readFileSync(reportPath, "utf8"));
   let copied = 0;
   const bundle = (value) => {
-    const rel = copyAsset(path13.resolve(value), assetsDir);
+    const rel = copyAsset(path14.resolve(value), assetsDir);
     copied++;
-    return `${baseUrl}/${path13.basename(rel)}`;
+    return `${baseUrl}/${path14.basename(rel)}`;
   };
   const visit = (entries) => {
     for (const entry of entries ?? []) {
       const e = entry;
       if (e.kind === "screenshot" || e.kind === "video") {
-        if (typeof e.path === "string" && !isRemote(e.path) && fs12.existsSync(e.path)) {
+        if (typeof e.path === "string" && !isRemote(e.path) && fs13.existsSync(e.path)) {
           e.path = bundle(e.path);
         }
-        if (typeof e.poster === "string" && !isRemote(e.poster) && fs12.existsSync(e.poster)) {
+        if (typeof e.poster === "string" && !isRemote(e.poster) && fs13.existsSync(e.poster)) {
           e.poster = bundle(e.poster);
         }
       }
@@ -21748,25 +21939,25 @@ function bundleExplorerAssets(reportPath, assetsDir, baseUrl = "/stories/assets"
     }
   }
   if (copied > 0) {
-    fs12.writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf8");
+    fs13.writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf8");
   }
   return copied;
 }
 function clearGeneratedPages(dir) {
-  if (!fs12.existsSync(dir)) return;
-  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-    const full = path13.join(dir, entry.name);
+  if (!fs13.existsSync(dir)) return;
+  for (const entry of fs13.readdirSync(dir, { withFileTypes: true })) {
+    const full = path14.join(dir, entry.name);
     if (entry.isDirectory()) {
       clearGeneratedPages(full);
-      if (fs12.readdirSync(full).length === 0) fs12.rmdirSync(full);
+      if (fs13.readdirSync(full).length === 0) fs13.rmdirSync(full);
     } else if (/\.mdx?$/.test(entry.name)) {
-      fs12.rmSync(full);
+      fs13.rmSync(full);
     }
   }
 }
 function loadCanonicalRun(rawRunPath, synthesize) {
   try {
-    const data = JSON.parse(fs12.readFileSync(path13.resolve(rawRunPath), "utf8"));
+    const data = JSON.parse(fs13.readFileSync(path14.resolve(rawRunPath), "utf8"));
     if (data.schemaVersion !== 1) {
       throw new BuildDocsError(`Unsupported schemaVersion ${data.schemaVersion}. Supported: 1.`, "schema");
     }
@@ -21789,12 +21980,12 @@ ${schemaResult.errors.map((e) => `  ${e}`).join("\n")}`,
   }
 }
 async function buildDocs(options) {
-  const siteDir = path13.resolve(options.siteDir);
-  const storiesPublicDir = path13.join(siteDir, "public", "stories");
-  const assetsDir = path13.join(storiesPublicDir, "assets");
-  const storyPagesDir = path13.join(siteDir, "src", "content", "docs", "stories");
-  const apiDir = path13.join(siteDir, "src", "content", "docs", "api");
-  const reportPath = path13.join(storiesPublicDir, "story-report.json");
+  const siteDir = path14.resolve(options.siteDir);
+  const storiesPublicDir = path14.join(siteDir, "public", "stories");
+  const assetsDir = path14.join(storiesPublicDir, "assets");
+  const storyPagesDir = path14.join(siteDir, "src", "content", "docs", "stories");
+  const apiDir = path14.join(siteDir, "src", "content", "docs", "api");
+  const reportPath = path14.join(storiesPublicDir, "story-report.json");
   const canonical = loadCanonicalRun(options.rawRunPath, options.synthesizeStories ?? true);
   try {
     await new ReportGenerator({
@@ -21815,7 +22006,7 @@ async function buildDocs(options) {
     let apiPages = 0;
     if (options.openapiPath) {
       const res = await importOpenApi({
-        specPath: path13.resolve(options.openapiPath),
+        specPath: path14.resolve(options.openapiPath),
         outputDir: apiDir,
         runFile: reportPath,
         force: true
@@ -21830,11 +22021,11 @@ async function buildDocs(options) {
 }
 
 // src/config.ts
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve10 } from "path";
 async function loadConfig(configPath) {
-  const resolved = configPath ? resolve9(configPath) : resolve9(process.cwd(), "executable-stories.config.js");
-  if (!existsSync11(resolved)) return {};
+  const resolved = configPath ? resolve10(configPath) : resolve10(process.cwd(), "executable-stories.config.js");
+  if (!existsSync12(resolved)) return {};
   const mod = await import(resolved);
   const config = mod.default;
   if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -21853,6 +22044,7 @@ var EXIT_GENERATION = 3;
 var EXIT_USAGE = 4;
 var EXIT_COMPARE_GATE = 5;
 var EXIT_REVIEW_GATE = 5;
+var EXIT_RELEASE_GATE = 6;
 var HELP_TEXT = `
 executable-stories \u2014 Generate reports from test results JSON.
 
@@ -21860,6 +22052,7 @@ USAGE
   executable-stories format <file> [options]
   executable-stories format --stdin [options]
   executable-stories compare <baseline-file> <current-file> [options]
+  executable-stories gate-release <dev-run.json> <rc-run.json> [options]
   executable-stories review <file> --changed-files <path> [options]
   executable-stories list <file> [options]
   executable-stories validate <file>
@@ -21870,11 +22063,15 @@ USAGE
   executable-stories import-openapi <spec> [options]
   executable-stories publish-confluence <file.adf.json> [options]
   executable-stories publish-jira <file.adf.json> [options]
+  executable-stories deploy record <file> --env <env> [--tag <tag>] [options]
+  executable-stories deploy status [options]
+  executable-stories deploy diff <env-a> <env-b> [options]
 
 SUBCOMMANDS
   format             Read raw test results and generate reports
   watch              Regenerate reports whenever the raw-run file changes (live agent index)
   compare            Compare two runs and generate a diff report
+  gate-release       Verify a release candidate against the dev test baseline (RC gate)
   review             Generate an Evidence Review of AI-authored changes (correlate a run to the diff)
   list               List scenarios from a test run (text table or JSON)
   validate           Validate a JSON file against the schema (no output generated)
@@ -21884,9 +22081,10 @@ SUBCOMMANDS
   import-openapi     Generate API doc pages from an OpenAPI spec, linked to verifying stories
   publish-confluence Publish an ADF JSON file to a Confluence page via REST API
   publish-jira       Publish an ADF JSON file to a Jira issue (as comment or description)
+  deploy             Record deployments, show environment status, detect drift
 
 OPTIONS
-  --format <formats>            Comma-separated formats: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, astro, confluence, story-report-json, scenario-index-json, behavior-manifest-json, or custom names from config (default: html)
+  --format <formats>            Comma-separated formats: html, markdown, release-manifest, junit, cucumber-json, cucumber-messages, cucumber-html, astro, confluence, story-report-json, scenario-index-json, behavior-manifest-json, or custom names from config (default: html)
                                   astro             Themed Markdown (for Astro docs sites with matching CSS)
                                   confluence        Atlassian Document Format (ADF) JSON for Confluence / Jira
                                   behavior-manifest-json Agent-readable behavior manifest and debugger warnings
@@ -21930,7 +22128,10 @@ OPTIONS
   --pr-summary-file <path>      Write the PR-friendly markdown summary to a file
   --fail-on-regression          Exit non-zero when any regression is detected in compare
   --fail-on-added-failures      Exit non-zero when newly added scenarios are failing
+  --fail-on-removal             Exit non-zero when scenarios are removed from the baseline
+  --fail-on-new                 Exit non-zero when new scenarios appear that weren't in the baseline
   --max-regressions <n>         Exit non-zero when regressions exceed threshold
+  --release-policy <path>       (gate-release) Path to JSON policy file with allowed exceptions
   --changed-files <path>        (review) Changed files: JSON (ChangedFile[] or {changedFiles,baseRef,headRef}) or "git diff --name-status" text
   --base-ref <ref>              (review) Base ref label shown in the report (informational)
   --head-ref <ref>              (review) Head ref label shown in the report (informational)
@@ -21949,6 +22150,24 @@ COMPARE
   compare supports --format html,markdown
   compare uses the same --input-type for both baseline and current files
 
+GATE-RELEASE
+  gate-release compares a dev environment test run (baseline) against a
+  release candidate test run to verify the RC matches what was tested in dev.
+  By default, fails if scenarios are omitted or regressed.
+  --fail-on-regression and --fail-on-removal are enabled by default.
+  Supports --release-policy for exception lists.
+
+DEPLOY
+  executable-stories deploy record <file> --env <env> [--tag <tag>]
+    Record a deployment of a test run to an environment (e.g. dev, staging, prod).
+    The deployment ledger is at .executable-stories/deployments.json by default.
+
+  executable-stories deploy status [--ledger <path>]
+    Show the latest deployment for each environment.
+
+  executable-stories deploy diff <env-a> <env-b> [--ledger <path>]
+    Show scenario drift between two environments (what's in one but not the other).
+
 INIT-ASTRO
   executable-stories init-astro [directory]   Scaffold into directory (default: ./story-docs)
   --force                                      Overwrite existing directory
@@ -22000,6 +22219,7 @@ EXIT CODES
   3  Formatter/generation failure
   4  Bad arguments / usage error
   5  Compare gate failed
+  6  Release gate failed
 `.trim();
 async function parseCliArgs(argv) {
   const args = argv.slice(2);
@@ -22008,9 +22228,9 @@ async function parseCliArgs(argv) {
     process.exit(EXIT_SUCCESS);
   }
   const subcommand = args[0];
-  if (subcommand !== "format" && subcommand !== "watch" && subcommand !== "compare" && subcommand !== "review" && subcommand !== "list" && subcommand !== "validate" && subcommand !== "init-astro" && subcommand !== "build-docs" && subcommand !== "new" && subcommand !== "check-links" && subcommand !== "import-openapi" && subcommand !== "publish-confluence" && subcommand !== "publish-jira") {
+  if (subcommand !== "format" && subcommand !== "watch" && subcommand !== "compare" && subcommand !== "gate-release" && subcommand !== "deploy" && subcommand !== "review" && subcommand !== "list" && subcommand !== "validate" && subcommand !== "init-astro" && subcommand !== "build-docs" && subcommand !== "new" && subcommand !== "check-links" && subcommand !== "import-openapi" && subcommand !== "publish-confluence" && subcommand !== "publish-jira") {
     console.error(
-      `Unknown subcommand: "${subcommand}". Use "format", "watch", "compare", "review", "list", "validate", "init-astro", "build-docs", "new", "check-links", "import-openapi", "publish-confluence", or "publish-jira".`
+      `Unknown subcommand: "${subcommand}". Use "format", "watch", "compare", "gate-release", "deploy", "review", "list", "validate", "init-astro", "build-docs", "new", "check-links", "import-openapi", "publish-confluence", or "publish-jira".`
     );
     process.exit(EXIT_USAGE);
   }
@@ -22022,6 +22242,9 @@ async function parseCliArgs(argv) {
     await runPublishJira(args.slice(1));
     process.exit(EXIT_SUCCESS);
   }
+  if (subcommand === "deploy") {
+    process.exit(await runDeploy(args.slice(1)));
+  }
   if (subcommand === "init-astro") {
     const initArgs = args.slice(1);
     const targetDir = initArgs.find((a) => !a.startsWith("--")) ?? "./story-docs";
@@ -22115,7 +22338,10 @@ async function parseCliArgs(argv) {
       "pr-summary-file": { type: "string" },
       "fail-on-regression": { type: "boolean", default: false },
       "fail-on-added-failures": { type: "boolean", default: false },
+      "fail-on-removal": { type: "boolean", default: false },
+      "fail-on-new": { type: "boolean", default: false },
       "max-regressions": { type: "string" },
+      "release-policy": { type: "string" },
       "changed-files": { type: "string" },
       "base-ref": { type: "string" },
       "head-ref": { type: "string" },
@@ -22134,20 +22360,21 @@ async function parseCliArgs(argv) {
   const useStdin = values.stdin;
   const baselineValue = values.baseline;
   const baselineMode = baselineValue === "auto" ? "auto" : "explicit";
-  const inputFile = subcommand === "compare" ? void 0 : positionals[0];
-  const baselineFile = subcommand === "compare" ? baselineMode === "auto" ? baselineValue && baselineValue !== "auto" ? baselineValue : positionals.length > 1 ? positionals[0] : void 0 : baselineValue && baselineValue !== "auto" ? baselineValue : positionals.length > 1 ? positionals[0] : void 0 : void 0;
-  const currentFile = subcommand === "compare" ? positionals.length > 1 ? positionals[1] : positionals[0] : void 0;
-  if (subcommand === "compare") {
+  const isCompareLike = subcommand === "compare" || subcommand === "gate-release";
+  const inputFile = isCompareLike ? void 0 : positionals[0];
+  const baselineFile = isCompareLike ? baselineMode === "auto" ? baselineValue && baselineValue !== "auto" ? baselineValue : positionals.length > 1 ? positionals[0] : void 0 : baselineValue && baselineValue !== "auto" ? baselineValue : positionals.length > 1 ? positionals[0] : void 0 : void 0;
+  const currentFile = isCompareLike ? positionals.length > 1 ? positionals[1] : positionals[0] : void 0;
+  if (isCompareLike) {
     if (useStdin) {
-      console.error("Error: compare does not support --stdin. Pass baseline and current files.");
+      console.error(`Error: ${subcommand} does not support --stdin. Pass baseline and current files.`);
       process.exit(EXIT_USAGE);
     }
     if (!currentFile) {
-      console.error("Error: compare requires <current-file>, and either <baseline-file> or --baseline auto.");
+      console.error(`Error: ${subcommand} requires <current-file>, and either <baseline-file> or --baseline auto.`);
       process.exit(EXIT_USAGE);
     }
     if (baselineMode === "explicit" && !baselineFile) {
-      console.error("Error: compare requires <baseline-file> and <current-file>, or use --baseline auto.");
+      console.error(`Error: ${subcommand} requires <baseline-file> and <current-file>, or use --baseline auto.`);
       process.exit(EXIT_USAGE);
     }
   } else if (!useStdin && !inputFile) {
@@ -22161,7 +22388,7 @@ async function parseCliArgs(argv) {
   }
   const pluginConfig = await loadConfig(values["config"]);
   const customFormatterNames = new Set(Object.keys(pluginConfig.formatters ?? {}));
-  const builtInFormats = /* @__PURE__ */ new Set(["astro", "behavior-manifest-json", "confluence", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html", "scenario-index-json", "story-report-json"]);
+  const builtInFormats = /* @__PURE__ */ new Set(["astro", "behavior-manifest-json", "confluence", "html", "markdown", "release-manifest", "junit", "cucumber-json", "cucumber-messages", "cucumber-html", "scenario-index-json", "story-report-json"]);
   const formatStr = values.format;
   const allRequestedFormats = formatStr.split(",").map((f) => f.trim());
   const builtInRequested = allRequestedFormats.filter((f) => builtInFormats.has(f));
@@ -22169,7 +22396,7 @@ async function parseCliArgs(argv) {
   const unknownFormats = allRequestedFormats.filter((f) => !builtInFormats.has(f) && !customFormatterNames.has(f));
   if (unknownFormats.length > 0) {
     const knownCustom = customFormatterNames.size > 0 ? `, ${[...customFormatterNames].join(", ")}` : "";
-    console.error(`Error: Unknown format(s): ${unknownFormats.join(", ")}. Valid built-in: astro, behavior-manifest-json, confluence, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, scenario-index-json, story-report-json${knownCustom}.`);
+    console.error(`Error: Unknown format(s): ${unknownFormats.join(", ")}. Valid built-in: astro, behavior-manifest-json, confluence, html, markdown, release-manifest, junit, cucumber-json, cucumber-messages, cucumber-html, scenario-index-json, story-report-json${knownCustom}.`);
     process.exit(EXIT_USAGE);
   }
   const formats = builtInRequested;
@@ -22307,7 +22534,10 @@ async function parseCliArgs(argv) {
     prSummaryFile: values["pr-summary-file"],
     failOnRegression: values["fail-on-regression"],
     failOnAddedFailures: values["fail-on-added-failures"],
+    failOnRemoval: values["fail-on-removal"],
+    failOnNew: values["fail-on-new"],
     maxRegressions,
+    releasePolicy: values["release-policy"],
     changedFilesPath: values["changed-files"],
     baseRef: values["base-ref"],
     headRef: values["head-ref"],
@@ -22321,27 +22551,27 @@ async function readInput(args) {
   if (args.stdin) {
     return readStdin();
   }
-  const filePath = path14.resolve(args.inputFile);
-  if (!fs13.existsSync(filePath)) {
+  const filePath = path15.resolve(args.inputFile);
+  if (!fs14.existsSync(filePath)) {
     console.error(`Error: File not found: ${filePath}`);
     process.exit(EXIT_USAGE);
   }
-  return fs13.readFileSync(filePath, "utf8");
+  return fs14.readFileSync(filePath, "utf8");
 }
 function readFileInput(filePath) {
-  const resolved = path14.resolve(filePath);
-  if (!fs13.existsSync(resolved)) {
+  const resolved = path15.resolve(filePath);
+  if (!fs14.existsSync(resolved)) {
     console.error(`Error: File not found: ${resolved}`);
     process.exit(EXIT_USAGE);
   }
-  return fs13.readFileSync(resolved, "utf8");
+  return fs14.readFileSync(resolved, "utf8");
 }
 function readStdin() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const chunks = [];
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve11(chunks.join("")));
+    process.stdin.on("end", () => resolve12(chunks.join("")));
     process.stdin.on("error", reject);
   });
 }
@@ -22467,14 +22697,14 @@ function tryNormalizeRunFromText(text2, args) {
   }
 }
 function listBaselineCandidates(currentFile, args) {
-  const baselineDir = path14.resolve(args.baselineDir ?? path14.dirname(currentFile));
-  const currentResolved = path14.resolve(currentFile);
-  if (!fs13.existsSync(baselineDir)) {
+  const baselineDir = path15.resolve(args.baselineDir ?? path15.dirname(currentFile));
+  const currentResolved = path15.resolve(currentFile);
+  if (!fs14.existsSync(baselineDir)) {
     console.error(`Error: baseline directory not found: ${baselineDir}`);
     process.exit(EXIT_USAGE);
   }
-  const entries = fs13.readdirSync(baselineDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile()).map((entry) => path14.join(baselineDir, entry.name)).filter((candidate) => path14.resolve(candidate) !== currentResolved).filter(
+  const entries = fs14.readdirSync(baselineDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile()).map((entry) => path15.join(baselineDir, entry.name)).filter((candidate) => path15.resolve(candidate) !== currentResolved).filter(
     (candidate) => args.inputType === "ndjson" ? candidate.endsWith(".ndjson") : candidate.endsWith(".json")
   );
 }
@@ -22482,14 +22712,14 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   const candidates = listBaselineCandidates(currentFile, args);
   const comparable = [];
   for (const candidate of candidates) {
-    const run = tryNormalizeRunFromText(fs13.readFileSync(candidate, "utf8"), args);
+    const run = tryNormalizeRunFromText(fs14.readFileSync(candidate, "utf8"), args);
     if (run) {
       comparable.push({ file: candidate, run });
     }
   }
   if (comparable.length === 0) {
     console.error(
-      `Error: no compatible baseline files found in ${path14.resolve(args.baselineDir ?? path14.dirname(currentFile))}.`
+      `Error: no compatible baseline files found in ${path15.resolve(args.baselineDir ?? path15.dirname(currentFile))}.`
     );
     process.exit(EXIT_USAGE);
   }
@@ -22526,6 +22756,50 @@ async function main() {
       process.exit(EXIT_GENERATION);
     }
   }
+  if (args.subcommand === "gate-release") {
+    const gatedArgs = {
+      ...args,
+      failOnRegression: true,
+      failOnRemoval: true
+      // failOnNew is opt-in via --fail-on-new flag
+    };
+    let policy;
+    if (args.releasePolicy) {
+      policy = loadReleasePolicy(args.releasePolicy);
+    }
+    const currentText = readFileInput(gatedArgs.currentFile);
+    const current = applySelection(normalizeRunFromText(currentText, gatedArgs).run, gatedArgs);
+    const baselineFile = gatedArgs.baselineMode === "auto" ? resolveBaselineAuto(gatedArgs.currentFile, current, gatedArgs) : gatedArgs.baselineFile;
+    const baselineText = readFileInput(baselineFile);
+    const baseline = applySelection(normalizeRunFromText(baselineText, gatedArgs).run, gatedArgs);
+    try {
+      const result = await generateCompareReports(baseline, current, baselineFile, gatedArgs);
+      const effectiveResult = policy ? applyReleasePolicy(result, policy) : result;
+      printCompareResult(effectiveResult, gatedArgs, startMs);
+      const gateFailures = evaluateCompareGate(effectiveResult, gatedArgs);
+      if (gateFailures.length > 0) {
+        for (const failure of gateFailures) {
+          console.error(`Release gate failed: ${failure}`);
+        }
+        if (policy) {
+          console.error(`Release policy: ${args.releasePolicy}`);
+          if (policy.allowedOmissions && policy.allowedOmissions.length > 0) {
+            console.error(`  Allowed omissions: ${policy.allowedOmissions.join(", ")}`);
+          }
+          if (policy.allowedRegressions && policy.allowedRegressions.length > 0) {
+            console.error(`  Allowed regressions: ${policy.allowedRegressions.join(", ")}`);
+          }
+        }
+        process.exit(EXIT_RELEASE_GATE);
+      }
+      console.error("Release gate passed: RC matches dev baseline.");
+      process.exit(EXIT_SUCCESS);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Release gate check failed: ${msg}`);
+      process.exit(EXIT_GENERATION);
+    }
+  }
   if (args.subcommand === "review") {
     const text3 = await readInput(args);
     const run = applySelection(normalizeRunFromText(text3, args).run, args);
@@ -22627,9 +22901,9 @@ async function main() {
       process.exit(EXIT_SCHEMA_VALIDATION);
     }
     if (args.emitCanonical) {
-      const outPath = path14.resolve(args.emitCanonical);
-      fs13.mkdirSync(path14.dirname(outPath), { recursive: true });
-      fs13.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path15.resolve(args.emitCanonical);
+      fs14.mkdirSync(path15.dirname(outPath), { recursive: true });
+      fs14.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
@@ -22686,9 +22960,9 @@ ${msg}`);
     }
     const run = data;
     if (args.emitCanonical) {
-      const outPath = path14.resolve(args.emitCanonical);
-      fs13.mkdirSync(path14.dirname(outPath), { recursive: true });
-      fs13.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path15.resolve(args.emitCanonical);
+      fs14.mkdirSync(path15.dirname(outPath), { recursive: true });
+      fs14.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
@@ -22744,9 +23018,9 @@ ${msg}`);
     process.exit(EXIT_CANONICAL_VALIDATION);
   }
   if (args.emitCanonical) {
-    const outPath = path14.resolve(args.emitCanonical);
-    fs13.mkdirSync(path14.dirname(outPath), { recursive: true });
-    fs13.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
+    const outPath = path15.resolve(args.emitCanonical);
+    fs14.mkdirSync(path15.dirname(outPath), { recursive: true });
+    fs14.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
   }
   try {
     const result = await generateReports(canonical, args, droppedMissingStory);
@@ -22771,9 +23045,9 @@ function runCustomFormatters(run, customRequested, formatters, args) {
       const ext = formatter.fileExtension ?? formatName;
       const baseName = args.outputName ?? "report";
       const filename = args.outputNameTimestamp ? `${baseName}-${Math.floor(run.startedAtMs / 1e3)}.${ext}` : `${baseName}.${ext}`;
-      const filepath = path14.join(outputDir, filename);
-      fs13.mkdirSync(outputDir, { recursive: true });
-      fs13.writeFileSync(filepath, content, "utf8");
+      const filepath = path15.join(outputDir, filename);
+      fs14.mkdirSync(outputDir, { recursive: true });
+      fs14.writeFileSync(filepath, content, "utf8");
       console.log(`Generated: ${filepath}`);
     } catch (err) {
       console.error(`Error running custom formatter "${formatName}": ${err instanceof Error ? err.message : String(err)}`);
@@ -22823,13 +23097,13 @@ async function dispatchNotifications(run, args) {
 }
 function runHistoryPipeline(run, args) {
   if (!args.historyFile) return;
-  const historyPath = path14.resolve(args.historyFile);
+  const historyPath = path15.resolve(args.historyFile);
   const store = loadHistory(
     { filePath: historyPath },
     {
       readFile: (p) => {
         try {
-          return fs13.readFileSync(p, "utf8");
+          return fs14.readFileSync(p, "utf8");
         } catch {
           return void 0;
         }
@@ -22842,11 +23116,11 @@ function runHistoryPipeline(run, args) {
     run,
     maxRuns: args.maxHistoryRuns
   });
-  const dir = path14.dirname(historyPath);
-  fs13.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(historyPath);
+  fs14.mkdirSync(dir, { recursive: true });
   saveHistory(
     { filePath: historyPath, store: updated },
-    { writeFile: (p, content) => fs13.writeFileSync(p, content, "utf8") }
+    { writeFile: (p, content) => fs14.writeFileSync(p, content, "utf8") }
   );
   let metricsCount = 0;
   for (const testId of Object.keys(updated.tests)) {
@@ -22923,6 +23197,7 @@ async function generateCompareReports(baseline, current, baselineFile, args) {
       (scenario) => scenario.kind === "added" && scenario.current?.status === "failed"
     ).length,
     summary: result.diff.summary,
+    scenarios: result.diff.scenarios,
     prSummary: args.prSummary || args.prSummaryFile ? createPrCommentSummary(result.diff) : void 0
   };
 }
@@ -22993,11 +23268,11 @@ function writeReviewReport(review, args) {
   const outputDir = args.outputDir ?? "reports";
   const baseName = args.outputName ?? "evidence-review";
   const suffix = args.outputNameTimestamp ? `-${Math.floor(review.run.startedAtMs / 1e3)}` : "";
-  fs13.mkdirSync(outputDir, { recursive: true });
-  const mdPath = path14.join(outputDir, `${baseName}${suffix}.md`);
-  const htmlPath = path14.join(outputDir, `${baseName}${suffix}.html`);
-  fs13.writeFileSync(mdPath, markdown, "utf8");
-  fs13.writeFileSync(htmlPath, html, "utf8");
+  fs14.mkdirSync(outputDir, { recursive: true });
+  const mdPath = path15.join(outputDir, `${baseName}${suffix}.md`);
+  const htmlPath = path15.join(outputDir, `${baseName}${suffix}.html`);
+  fs14.writeFileSync(mdPath, markdown, "utf8");
+  fs14.writeFileSync(htmlPath, html, "utf8");
   return [mdPath, htmlPath];
 }
 function evaluateReviewGate(review, args) {
@@ -23043,9 +23318,9 @@ function printResult(result, args, startMs, droppedMissingStory = 0) {
 function printCompareResult(result, args, startMs) {
   const durationMs = Date.now() - startMs;
   if (result.prSummary && args.prSummaryFile) {
-    const outputPath = path14.resolve(args.prSummaryFile);
-    fs13.mkdirSync(path14.dirname(outputPath), { recursive: true });
-    fs13.writeFileSync(outputPath, result.prSummary, "utf8");
+    const outputPath = path15.resolve(args.prSummaryFile);
+    fs14.mkdirSync(path15.dirname(outputPath), { recursive: true });
+    fs14.writeFileSync(outputPath, result.prSummary, "utf8");
   }
   if (args.jsonSummary) {
     console.log(
@@ -23073,6 +23348,44 @@ function printCompareResult(result, args, startMs) {
     console.log(result.prSummary);
   }
 }
+function loadReleasePolicy(policyPath) {
+  const resolved = path15.resolve(policyPath);
+  if (!fs14.existsSync(resolved)) {
+    console.error(`Error: release policy file not found: ${resolved}`);
+    process.exit(EXIT_USAGE);
+  }
+  try {
+    const raw = JSON.parse(fs14.readFileSync(resolved, "utf8"));
+    return {
+      allowedOmissions: Array.isArray(raw.allowedOmissions) ? raw.allowedOmissions : [],
+      allowedRegressions: Array.isArray(raw.allowedRegressions) ? raw.allowedRegressions : [],
+      allowNewScenarios: Boolean(raw.allowNewScenarios)
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error reading release policy: ${msg}`);
+    process.exit(EXIT_USAGE);
+  }
+}
+function applyReleasePolicy(result, policy) {
+  const allowedOmissionSet = new Set(policy.allowedOmissions ?? []);
+  const allowedRegressionSet = new Set(policy.allowedRegressions ?? []);
+  const adjustedOmissions = result.scenarios.filter(
+    (scenario) => scenario.kind === "removed" && !allowedOmissionSet.has(scenario.id)
+  ).length;
+  const adjustedRegressions = result.scenarios.filter(
+    (scenario) => scenario.kind === "regressed" && !allowedRegressionSet.has(scenario.id)
+  ).length;
+  const adjustedSummary = {
+    ...result.summary,
+    removed: adjustedOmissions,
+    regressed: adjustedRegressions
+  };
+  return {
+    ...result,
+    summary: adjustedSummary
+  };
+}
 function evaluateCompareGate(result, args) {
   const failures = [];
   if (args.failOnRegression && result.summary.regressed > 0) {
@@ -23085,6 +23398,16 @@ function evaluateCompareGate(result, args) {
       `new failing scenarios detected (${result.addedFailures}) with --fail-on-added-failures`
     );
   }
+  if (args.failOnRemoval && result.summary.removed > 0) {
+    failures.push(
+      `removed scenarios detected (${result.summary.removed}) with --fail-on-removal`
+    );
+  }
+  if (args.failOnNew && result.summary.added > 0) {
+    failures.push(
+      `new scenarios detected (${result.summary.added}) with --fail-on-new`
+    );
+  }
   if (args.maxRegressions !== void 0 && result.summary.regressed > args.maxRegressions) {
     failures.push(
       `regressions ${result.summary.regressed} exceed --max-regressions ${args.maxRegressions}`
@@ -23136,7 +23459,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: missing ADF file argument. Run with --help for usage.");
     process.exit(EXIT_USAGE);
   }
-  if (!fs13.existsSync(inputFile)) {
+  if (!fs14.existsSync(inputFile)) {
     console.error(`Error: file not found: ${inputFile}`);
     process.exit(EXIT_USAGE);
   }
@@ -23164,7 +23487,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: --title is required when creating a new page");
     process.exit(EXIT_USAGE);
   }
-  const adf = fs13.readFileSync(path14.resolve(inputFile), "utf8");
+  const adf = fs14.readFileSync(path15.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(
@@ -23243,7 +23566,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: missing ADF file argument. Run with --help for usage.");
     process.exit(EXIT_USAGE);
   }
-  if (!fs13.existsSync(inputFile)) {
+  if (!fs14.existsSync(inputFile)) {
     console.error(`Error: file not found: ${inputFile}`);
     process.exit(EXIT_USAGE);
   }
@@ -23270,7 +23593,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     process.exit(EXIT_USAGE);
   }
   const mode = modeRaw;
-  const adf = fs13.readFileSync(path14.resolve(inputFile), "utf8");
+  const adf = fs14.readFileSync(path15.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(
@@ -23432,7 +23755,7 @@ async function runBuildDocs(rawArgs) {
     if (result.apiPages > 0) {
       console.log(`  \u2022 API pages       \u2192 src/content/docs/api (${result.apiPages})`);
     }
-    const rel = path14.relative(process.cwd(), result.siteDir) || ".";
+    const rel = path15.relative(process.cwd(), result.siteDir) || ".";
     console.log(`
 Preview: cd ${rel} && npm run dev`);
     return EXIT_SUCCESS;
@@ -23447,6 +23770,212 @@ Preview: cd ${rel} && npm run dev`);
     return EXIT_USAGE;
   }
 }
+async function runDeploy(rawArgs) {
+  const mode = rawArgs[0];
+  if (!mode || !["record", "status", "diff"].includes(mode)) {
+    console.error("Usage: executable-stories deploy <record|status|diff> [options]");
+    console.error("  deploy record <file> --env <env> [--tag <tag>] [--ledger <path>]");
+    console.error("  deploy status [--ledger <path>] [--json]");
+    console.error("  deploy diff <env-a> <env-b> [--ledger <path>] [--json]");
+    return EXIT_USAGE;
+  }
+  const { values, positionals } = parseArgs({
+    args: rawArgs.slice(1),
+    options: {
+      env: { type: "string" },
+      tag: { type: "string" },
+      ledger: { type: "string", default: ".executable-stories/deployments.json" },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", default: false }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help) {
+    console.log(`executable-stories deploy \u2014 Track deployments across environments.
+
+USAGE
+  executable-stories deploy record <file> --env <env> [--tag <tag>] [--ledger <path>]
+  executable-stories deploy status [--ledger <path>] [--json]
+  executable-stories deploy diff <env-a> <env-b> [--ledger <path>] [--json]
+
+OPTIONS
+  --env <env>       Environment name (e.g. dev, staging, production)
+  --tag <tag>       Optional Git tag for this deployment (e.g. v1.2.3)
+  --ledger <path>   Path to deployment ledger JSON (default: .executable-stories/deployments.json)
+  --json            Output as JSON instead of text`);
+    return EXIT_SUCCESS;
+  }
+  const ledgerPath = values.ledger;
+  if (mode === "record") {
+    const inputFile = positionals[0];
+    if (!inputFile) {
+      console.error("Error: deploy record requires an input file.");
+      return EXIT_USAGE;
+    }
+    const env = values.env;
+    if (!env) {
+      console.error("Error: deploy record requires --env <environment>.");
+      return EXIT_USAGE;
+    }
+    const text2 = readFileInput(inputFile);
+    const { run } = normalizeRunFromText(text2, {
+      ...createDefaultCliArgs(),
+      inputType: "raw",
+      inputFile
+    });
+    const applied = applySelection(run, createDefaultCliArgs());
+    const result = recordDeployment({
+      run: applied,
+      environment: env,
+      tag: values.tag,
+      ledgerPath,
+      runFilePath: inputFile
+    });
+    console.error(
+      `Recorded deployment to "${result.entry.environment}" at ${result.entry.timestamp}`
+    );
+    console.error(
+      `  Scenarios: ${result.entry.summary.total} (${result.entry.summary.passed} passed, ${result.entry.summary.failed} failed)`
+    );
+    if (result.entry.tag) {
+      console.error(`  Tag: ${result.entry.tag}`);
+    }
+    console.error(`  Ledger: ${result.ledgerPath}`);
+    return EXIT_SUCCESS;
+  }
+  if (mode === "status") {
+    const status = getDeploymentStatus(ledgerPath);
+    const envs = Object.keys(status.environments);
+    if (envs.length === 0) {
+      console.error("No deployments recorded yet.");
+      return EXIT_SUCCESS;
+    }
+    if (values.json) {
+      console.log(JSON.stringify(status, null, 2));
+    } else {
+      for (const envName of envs) {
+        const env = status.environments[envName];
+        if (!env) continue;
+        const e = env.latest;
+        console.log(`${envName}:`);
+        console.log(`  Deployed: ${e.timestamp}`);
+        console.log(`  SHA: ${e.sha ?? "unknown"}`);
+        console.log(`  Tag: ${e.tag ?? "none"}`);
+        console.log(`  Scenarios: ${e.summary.total} (${e.summary.passed} passed, ${e.summary.failed} failed, ${e.summary.skipped} skipped, ${e.summary.pending} pending)`);
+        if (env.previousDeployment) {
+          const prev = env.previousDeployment;
+          const added = e.scenarioIds.filter((id) => !new Set(prev.scenarioIds).has(id)).length;
+          const removed = prev.scenarioIds.filter((id) => !new Set(e.scenarioIds).has(id)).length;
+          if (added > 0 || removed > 0) {
+            console.log(`  Drift from previous: +${added} added, -${removed} removed`);
+          }
+        }
+        console.log();
+      }
+      console.log(`Ledger: ${ledgerPath}`);
+    }
+    return EXIT_SUCCESS;
+  }
+  if (mode === "diff") {
+    const envA = positionals[0];
+    const envB = positionals[1];
+    if (!envA || !envB) {
+      console.error("Error: deploy diff requires two environment names.");
+      return EXIT_USAGE;
+    }
+    try {
+      const drift = getEnvironmentDrift(ledgerPath, envA, envB);
+      if (values.json) {
+        console.log(JSON.stringify(drift, null, 2));
+      } else {
+        console.log(`Environment drift: ${envA} \u2194 ${envB}`);
+        console.log(`  ${envA}: ${drift.aEntry.summary.total} scenarios (${drift.aEntry.timestamp})`);
+        console.log(`  ${envB}: ${drift.bEntry.summary.total} scenarios (${drift.bEntry.timestamp})`);
+        console.log(`  In both: ${drift.inBoth.length}`);
+        console.log(`  Only in ${envA}: ${drift.onlyInA.length}`);
+        console.log(`  Only in ${envB}: ${drift.onlyInB.length}`);
+        console.log(`  Status changed: ${drift.statusChanged.length}`);
+        if (drift.onlyInA.length > 0) {
+          console.log(`
+  Only in ${envA}:`);
+          for (const id of drift.onlyInA.slice(0, 20)) {
+            console.log(`    - ${id}`);
+          }
+          if (drift.onlyInA.length > 20) {
+            console.log(`    ... and ${drift.onlyInA.length - 20} more`);
+          }
+        }
+        if (drift.onlyInB.length > 0) {
+          console.log(`
+  Only in ${envB}:`);
+          for (const id of drift.onlyInB.slice(0, 20)) {
+            console.log(`    - ${id}`);
+          }
+          if (drift.onlyInB.length > 20) {
+            console.log(`    ... and ${drift.onlyInB.length - 20} more`);
+          }
+        }
+        if (drift.statusChanged.length > 0) {
+          console.log("\n  Status changed:");
+          for (const item of drift.statusChanged.slice(0, 20)) {
+            console.log(`    - ${item.id}: ${item.statusA} -> ${item.statusB}`);
+          }
+          if (drift.statusChanged.length > 20) {
+            console.log(`    ... and ${drift.statusChanged.length - 20} more`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      return EXIT_USAGE;
+    }
+    return EXIT_SUCCESS;
+  }
+  return EXIT_USAGE;
+}
+function createDefaultCliArgs() {
+  return {
+    subcommand: "format",
+    stdin: false,
+    formats: [],
+    inputType: "raw",
+    outputDir: "reports",
+    outputName: "index",
+    outputNameTimestamp: false,
+    sortTestCases: "none",
+    include: [],
+    exclude: [],
+    includeTags: [],
+    excludeTags: [],
+    synthesizeStories: true,
+    htmlTitle: "Test Results",
+    htmlTheme: "default",
+    htmlNoSyntaxHighlighting: false,
+    htmlNoMermaid: false,
+    htmlNoMarkdown: false,
+    htmlNoToc: false,
+    htmlThemePicker: false,
+    jsonSummary: false,
+    listFormat: "text",
+    notify: "never",
+    maxFailedTests: 5,
+    maxHistoryRuns: 10,
+    webhookUrls: [],
+    webhookHeaders: {},
+    webhookMethod: "POST",
+    webhookHmacHeader: "X-Signature",
+    webhookHmacTimestamp: false,
+    assetMode: "none",
+    allowMissingAssets: false,
+    prSummary: false,
+    failOnRegression: false,
+    failOnAddedFailures: false,
+    failOnRemoval: false,
+    failOnNew: false,
+    baselineMode: "explicit"
+  };
+}
 main().catch((err) => {
   console.error(err);
   process.exit(EXIT_USAGE);