executable-stories-formatters 0.7.7 → 0.7.9

package/dist/cli.js

@@ -596,8 +596,8 @@ function generateRunId(startedAtMs, projectRoot) {
   const input = `${startedAtMs}::${projectRoot}`;
   return createHash("sha1").update(input).digest("hex").slice(0, 16);
 }
-function slugify(text) {
-  return text.toLowerCase().replace(/[/\\]+/g, "-").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+function slugify(text2) {
+  return text2.toLowerCase().replace(/[/\\]+/g, "-").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
 }
 function generateFeatureId(uri) {
   const pathWithoutExt = uri.replace(/\.[^.]+$/, "");
@@ -13696,7 +13696,7 @@ function renderDocEntry(entry, deps) {
 // src/formatters/html/renderers/steps.ts
 var CONTINUATION_KEYWORDS = ["And", "But", "*"];
 function renderStep(step, stepResult, index, deps) {
-  const statusIcon = stepResult ? deps.getStatusIcon(stepResult.status) : "\u25CB";
+  const statusIcon2 = stepResult ? deps.getStatusIcon(stepResult.status) : "\u25CB";
   const statusClass = stepResult ? `status-${stepResult.status}` : "";
   const duration = stepResult && stepResult.durationMs > 0 ? `${stepResult.durationMs}ms` : "";
   const keywordTrimmed = step.keyword.trim();
@@ -13705,7 +13705,7 @@ function renderStep(step, stepResult, index, deps) {
   const stepDocs = deps.renderDocs(step.docs, "step-docs");
   const textHtml = deps.highlightStepParams ? deps.highlightStepParams(step.text) : deps.escapeHtml(step.text);
   return `<div class="${stepClass}" data-keyword="${deps.escapeHtml(keywordTrimmed)}" data-text="${deps.escapeHtml(step.text)}">
-  <span class="step-status ${statusClass}">${statusIcon}</span>
+  <span class="step-status ${statusClass}">${statusIcon2}</span>
   <span class="step-keyword">${deps.escapeHtml(step.keyword)}</span>
   <span class="step-text">${textHtml}</span>
   <span class="step-duration">${duration}</span>
@@ -13721,10 +13721,10 @@ function renderSteps(args, deps) {
 
 // src/formatters/html/renderers/step-params.ts
 var STEP_PARAM_PATTERN = /"[^"]*"|(?<![\w.\-])\d+(?:\.\d+)?(?![\w.\-])/g;
-function highlightStepParams(text, deps) {
-  const matches = Array.from(text.matchAll(STEP_PARAM_PATTERN));
+function highlightStepParams(text2, deps) {
+  const matches = Array.from(text2.matchAll(STEP_PARAM_PATTERN));
   if (matches.length === 0) {
-    return deps.escapeHtml(text);
+    return deps.escapeHtml(text2);
   }
   let result = "";
   let lastIndex = 0;
@@ -13732,13 +13732,13 @@ function highlightStepParams(text, deps) {
     const matchStart = match.index;
     const matchEnd = matchStart + match[0].length;
     if (matchStart > lastIndex) {
-      result += deps.escapeHtml(text.slice(lastIndex, matchStart));
+      result += deps.escapeHtml(text2.slice(lastIndex, matchStart));
     }
     result += `<span class="step-param">${deps.escapeHtml(match[0])}</span>`;
     lastIndex = matchEnd;
   }
-  if (lastIndex < text.length) {
-    result += deps.escapeHtml(text.slice(lastIndex));
+  if (lastIndex < text2.length) {
+    result += deps.escapeHtml(text2.slice(lastIndex));
   }
   return result;
 }
@@ -13756,7 +13756,7 @@ function renderTicket(ticket, template, escapeHtml3) {
 }
 function renderScenario(args, deps) {
   const { tc } = args;
-  const statusIcon = deps.getStatusIcon(tc.status);
+  const statusIcon2 = deps.getStatusIcon(tc.status);
   const statusClass = `status-${tc.status}`;
   const duration = tc.durationMs > 0 ? `${(tc.durationMs / 1e3).toFixed(2)}s` : "";
   const tags = tc.tags.map((t) => `<span class="tag">${deps.escapeHtml(t)}</span>`).join("");
@@ -13825,7 +13825,7 @@ function renderScenario(args, deps) {
   <div class="scenario-header" role="button" tabindex="0" aria-expanded="${ariaExpanded}">
     <div class="scenario-info">
       <div class="scenario-title">
-        <span class="status-icon ${statusClass}">${statusIcon}</span>
+        <span class="status-icon ${statusClass}">${statusIcon2}</span>
         <span class="scenario-name">${deps.escapeHtml(tc.story.scenario)}</span>
       </div>
       <div class="scenario-meta">${tags}${tickets}${sourceLink}${traceBadge}${metricBadges}</div>
@@ -13964,11 +13964,11 @@ function buildTooltip(span, escapeHtml3) {
       parts.push(`${key}=${formatted}`);
     }
   }
-  let text = parts.join("\n");
-  if (text.length > TOOLTIP_MAX_LENGTH) {
-    text = text.slice(0, TOOLTIP_MAX_LENGTH - 3) + "...";
+  let text2 = parts.join("\n");
+  if (text2.length > TOOLTIP_MAX_LENGTH) {
+    text2 = text2.slice(0, TOOLTIP_MAX_LENGTH - 3) + "...";
   }
-  return escapeHtml3(text);
+  return escapeHtml3(text2);
 }
 function renderTraceView(args, deps) {
   if (!args.spans || args.spans.length === 0) return "";
@@ -14191,11 +14191,11 @@ function renderToc(args, deps) {
     const featureName = suitePaths.length > 0 && suitePaths[0].length > 0 ? suitePaths[0][0] : file.split("/").pop()?.replace(/\.[^.]+$/, "") ?? file;
     const featureSlug = `feature-${slugify(file)}`;
     const scenarios = testCases.map((tc) => {
-      const statusIcon = deps.getStatusIcon(tc.status);
+      const statusIcon2 = deps.getStatusIcon(tc.status);
       const statusClass = `status-${tc.status}`;
       const failedClass = tc.status === "failed" ? " toc-failed" : "";
       return `<a class="toc-scenario${failedClass}" href="#scenario-${tc.id}">
-          <span class="toc-status ${statusClass}">${statusIcon}</span>
+          <span class="toc-status ${statusClass}">${statusIcon2}</span>
           ${deps.escapeHtml(tc.story.scenario)}
         </a>`;
     }).join("\n");
@@ -14253,7 +14253,7 @@ function createHtmlFormatter(options = {}) {
     escapeHtml,
     getStatusIcon,
     renderDocs,
-    highlightStepParams: (text) => highlightStepParams(text, { escapeHtml })
+    highlightStepParams: (text2) => highlightStepParams(text2, { escapeHtml })
   };
   const scenarioDeps = {
     escapeHtml,
@@ -15188,7 +15188,7 @@ function deterministicId(kind, salt, ...parts) {
 
 // src/formatters/cucumber-messages/build-gherkin-document.ts
 function buildGherkinDocumentEnvelopes(uri, testCases, synthesized, salt) {
-  const { lineMap, featureName, featureTags, text } = synthesized;
+  const { lineMap, featureName, featureTags, text: text2 } = synthesized;
   const featureTagNodes = featureTags.map((tag, i) => ({
     location: {
       line: lineMap.featureTagLine ?? 1,
@@ -15257,7 +15257,7 @@ function buildGherkinDocumentEnvelopes(uri, testCases, synthesized, salt) {
     sourceEnvelope: {
       source: {
         uri,
-        data: text,
+        data: text2,
         mediaType: "text/x.cucumber.gherkin+plain"
       }
     },
@@ -15268,8 +15268,8 @@ function buildStepArguments(step, stepLine) {
   if (!step.docs || step.docs.length === 0) return {};
   const tableDocs = step.docs.filter((d) => d.kind === "table");
   if (tableDocs.length > 0) {
-    const table = tableDocs[0];
-    return { dataTable: buildDataTable(table, stepLine + 1) };
+    const table2 = tableDocs[0];
+    return { dataTable: buildDataTable(table2, stepLine + 1) };
   }
   for (const doc of step.docs) {
     const ds = docEntryToDocString(doc, stepLine + 1);
@@ -15340,21 +15340,21 @@ function docEntryToDocString(doc, line) {
       return void 0;
   }
 }
-function buildDataTable(table, line) {
+function buildDataTable(table2, line) {
   const rows = [];
   rows.push({
     location: { line },
-    cells: table.columns.map((col) => ({
+    cells: table2.columns.map((col) => ({
       location: { line },
       value: col
     })),
     id: ""
   });
-  for (let r = 0; r < table.rows.length; r++) {
+  for (let r = 0; r < table2.rows.length; r++) {
     const rowLine = line + 1 + r;
     rows.push({
       location: { line: rowLine },
-      cells: table.rows[r].map((cell) => ({
+      cells: table2.rows[r].map((cell) => ({
         location: { line: rowLine },
         value: cell
       })),
@@ -15445,12 +15445,12 @@ function docEntryToPickleDocString(doc) {
       return void 0;
   }
 }
-function buildPickleTable(table) {
+function buildPickleTable(table2) {
   const rows = [];
   rows.push({
-    cells: table.columns.map((col) => ({ value: col }))
+    cells: table2.columns.map((col) => ({ value: col }))
   });
-  for (const row of table.rows) {
+  for (const row of table2.rows) {
     rows.push({
       cells: row.map((cell) => ({ value: cell }))
     });
@@ -15813,11 +15813,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve7) => htmlStream.once("drain", resolve7));
+        await new Promise((resolve8) => htmlStream.once("drain", resolve8));
       }
     }
-    await new Promise((resolve7, reject) => {
-      collector.on("finish", resolve7);
+    await new Promise((resolve8, reject) => {
+      collector.on("finish", resolve8);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -16896,6 +16896,414 @@ ${body}`;
   }
 };
 
+// src/formatters/confluence.ts
+var ConfluenceFormatter = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      title: options.title ?? "User Stories",
+      includeStatusIcons: options.includeStatusIcons ?? true,
+      includeMetadata: options.includeMetadata ?? true,
+      includeSummaryTable: options.includeSummaryTable ?? true,
+      includeErrors: options.includeErrors ?? true,
+      scenarioHeadingLevel: options.scenarioHeadingLevel ?? 3,
+      groupBy: options.groupBy ?? "file",
+      sortScenarios: options.sortScenarios ?? "source",
+      pretty: options.pretty ?? true,
+      permalinkBaseUrl: options.permalinkBaseUrl,
+      ticketUrlTemplate: options.ticketUrlTemplate
+    };
+  }
+  /** Build the ADF document tree. Returns the JS object (not stringified). */
+  formatToAdf(run) {
+    const content = [];
+    content.push(heading(1, [text(this.options.title)]));
+    if (this.options.includeMetadata) {
+      const metaTable = this.renderMetadataTable(run);
+      if (metaTable) content.push(metaTable);
+    }
+    if (this.options.includeSummaryTable) {
+      content.push(this.renderSummaryTable(run));
+    }
+    switch (this.options.groupBy) {
+      case "none":
+        this.renderFlat(content, run.testCases);
+        break;
+      case "suite":
+        this.renderBySuite(content, run.testCases);
+        break;
+      case "file":
+      default:
+        this.renderByFile(content, run.testCases);
+        break;
+    }
+    return { version: 1, type: "doc", content };
+  }
+  /** Format a test run as an ADF JSON string. */
+  format(run) {
+    const adf = this.formatToAdf(run);
+    return this.options.pretty ? JSON.stringify(adf, null, 2) : JSON.stringify(adf);
+  }
+  // --------------------------------------------------------------------------
+  // Metadata / summary tables
+  // --------------------------------------------------------------------------
+  renderMetadataTable(run) {
+    const rows = [];
+    rows.push(["Date", new Date(run.startedAtMs).toISOString()]);
+    if (run.packageVersion) rows.push(["Version", run.packageVersion]);
+    if (run.gitSha) {
+      const shortSha = run.gitSha.length > 7 ? run.gitSha.slice(0, 7) : run.gitSha;
+      rows.push(["Git SHA", shortSha]);
+    }
+    if (rows.length === 0) return null;
+    return table([
+      tableRow([tableHeader("Key"), tableHeader("Value")]),
+      ...rows.map(([k, v]) => tableRow([tableCell(k), tableCell(v)]))
+    ]);
+  }
+  renderSummaryTable(run) {
+    const total = run.testCases.length;
+    const steps = run.testCases.reduce(
+      (acc, tc) => acc + tc.story.steps.length,
+      0
+    );
+    const passed = run.testCases.filter((tc) => tc.status === "passed").length;
+    const failed = run.testCases.filter((tc) => tc.status === "failed").length;
+    const skipped = run.testCases.filter((tc) => tc.status === "skipped").length;
+    const pending = run.testCases.filter((tc) => tc.status === "pending").length;
+    return table([
+      tableRow([
+        tableHeader("Scenarios"),
+        tableHeader("Steps"),
+        tableHeader("Passed"),
+        tableHeader("Failed"),
+        tableHeader("Skipped"),
+        tableHeader("Pending"),
+        tableHeader("Duration")
+      ]),
+      tableRow([
+        tableCell(String(total)),
+        tableCell(String(steps)),
+        tableCell(String(passed)),
+        tableCell(String(failed)),
+        tableCell(String(skipped)),
+        tableCell(String(pending)),
+        tableCell(formatDuration2(run.durationMs))
+      ])
+    ]);
+  }
+  // --------------------------------------------------------------------------
+  // Grouping
+  // --------------------------------------------------------------------------
+  renderByFile(content, testCases) {
+    const byFile = groupBy7(testCases, (tc) => tc.sourceFile);
+    for (const [file, fileCases] of byFile) {
+      content.push(heading(2, [codeInline(file)]));
+      this.renderSuiteGroups(content, fileCases, 3);
+    }
+  }
+  renderBySuite(content, testCases) {
+    this.renderSuiteGroups(content, testCases, 2);
+  }
+  renderFlat(content, testCases) {
+    const sorted = this.sortCases(testCases);
+    for (const tc of sorted) this.renderScenario(content, tc);
+  }
+  renderSuiteGroups(content, testCases, baseLevel) {
+    const bySuite = groupBy7(testCases, (tc) => tc.titlePath.join(" - "));
+    const entries = this.sortSuiteGroups([...bySuite.entries()]);
+    for (const [suitePath, cases] of entries) {
+      if (suitePath) {
+        content.push(
+          heading(clampHeadingLevel(baseLevel), [text(suitePath)])
+        );
+      }
+      for (const tc of this.sortCases(cases)) {
+        this.renderScenario(content, tc);
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Scenario
+  // --------------------------------------------------------------------------
+  renderScenario(content, tc) {
+    const level = clampHeadingLevel(this.options.scenarioHeadingLevel);
+    const headingNodes = [];
+    if (this.options.includeStatusIcons) {
+      headingNodes.push(text(`${statusIcon(tc.status)} `));
+    }
+    headingNodes.push(text(tc.story.scenario));
+    content.push(heading(level, headingNodes));
+    const metaChildren = [];
+    if (tc.tags.length > 0) {
+      metaChildren.push(text("Tags: ", strong()));
+      tc.tags.forEach((t, i) => {
+        if (i > 0) metaChildren.push(text(", "));
+        metaChildren.push(codeInline(t));
+      });
+    }
+    if (tc.story.tickets && tc.story.tickets.length > 0) {
+      if (metaChildren.length > 0) metaChildren.push(text(" | "));
+      metaChildren.push(text("Tickets: ", strong()));
+      tc.story.tickets.forEach((ticket, i) => {
+        if (i > 0) metaChildren.push(text(", "));
+        const url = ticket.url ?? (this.options.ticketUrlTemplate ? this.options.ticketUrlTemplate.replace("{ticket}", ticket.id) : void 0);
+        metaChildren.push(
+          url ? link(ticket.id, url) : codeInline(ticket.id)
+        );
+      });
+    }
+    if (this.options.permalinkBaseUrl && tc.sourceFile !== "unknown" && tc.sourceFile) {
+      if (metaChildren.length > 0) metaChildren.push(text(" | "));
+      metaChildren.push(text("Source: ", strong()));
+      const base = this.options.permalinkBaseUrl.replace(/\/$/, "");
+      const url = `${base}/${tc.sourceFile}${tc.sourceLine > 0 ? `#L${tc.sourceLine}` : ""}`;
+      metaChildren.push(link(tc.sourceFile, url));
+    }
+    if (metaChildren.length > 0) {
+      content.push(paragraph(metaChildren));
+    }
+    if (tc.story.docs && tc.story.docs.length > 0) {
+      for (const doc of tc.story.docs) this.renderDocEntry(content, doc);
+    }
+    if (tc.story.steps.length > 0) {
+      content.push(this.renderStepsList(tc.story.steps));
+      for (const step of tc.story.steps) {
+        if (step.docs && step.docs.length > 0) {
+          for (const doc of step.docs) this.renderDocEntry(content, doc);
+        }
+      }
+    }
+    if (tc.status === "failed" && tc.errorMessage && this.options.includeErrors) {
+      const errorContent = (tc.errorMessage ?? "") + (tc.errorStack ? `
+
+${tc.errorStack}` : "");
+      content.push(
+        panel("warning", [paragraph([text("Failure", strong())])])
+      );
+      content.push(codeBlock(errorContent, "text"));
+    }
+  }
+  renderStepsList(steps) {
+    return {
+      type: "bulletList",
+      content: steps.map((step) => {
+        const children = [text(`${step.keyword} `, strong()), text(step.text)];
+        if (step.mode && step.mode !== "normal") {
+          children.push(text(` (${step.mode})`, em()));
+        }
+        return {
+          type: "listItem",
+          content: [paragraph(children)]
+        };
+      })
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Doc entries
+  // --------------------------------------------------------------------------
+  renderDocEntry(content, entry) {
+    switch (entry.kind) {
+      case "note":
+        content.push(panel("info", [paragraph([text(entry.text)])]));
+        break;
+      case "tag": {
+        const kids = [];
+        entry.names.forEach((name, i) => {
+          if (i > 0) kids.push(text(" "));
+          kids.push(codeInline(name));
+        });
+        if (kids.length > 0) content.push(paragraph(kids));
+        break;
+      }
+      case "kv": {
+        const val = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
+        content.push(
+          paragraph([text(`${entry.label}: `, strong()), codeInline(val)])
+        );
+        break;
+      }
+      case "code":
+        if (entry.label) {
+          content.push(paragraph([text(entry.label, strong())]));
+        }
+        content.push(codeBlock(entry.content ?? "", entry.lang));
+        break;
+      case "table":
+        if (entry.label) {
+          content.push(paragraph([text(entry.label, strong())]));
+        }
+        content.push(
+          table([
+            tableRow(entry.columns.map((c) => tableHeader(c))),
+            ...entry.rows.map(
+              (row) => tableRow(row.map((cell) => tableCell(cell)))
+            )
+          ])
+        );
+        break;
+      case "link":
+        content.push(paragraph([link(entry.label, entry.url)]));
+        break;
+      case "section":
+        if (entry.title) {
+          content.push(paragraph([text(entry.title, strong())]));
+        }
+        if (entry.markdown) {
+          for (const para of entry.markdown.split(/\n{2,}/)) {
+            const trimmed = para.trim();
+            if (trimmed) content.push(paragraph([text(trimmed)]));
+          }
+        }
+        break;
+      case "mermaid":
+        if (entry.title) {
+          content.push(paragraph([text(entry.title, strong())]));
+        }
+        content.push(codeBlock(entry.code ?? "", "mermaid"));
+        break;
+      case "screenshot":
+        content.push(
+          paragraph([
+            text(entry.alt ?? "Screenshot", strong()),
+            text(": "),
+            link(entry.path, entry.path)
+          ])
+        );
+        break;
+      case "custom":
+        content.push(paragraph([text(`[${entry.type}]`, strong())]));
+        content.push(codeBlock(JSON.stringify(entry.data ?? null, null, 2), "json"));
+        break;
+    }
+    if (entry.children && entry.children.length > 0) {
+      for (const child of entry.children) {
+        this.renderDocEntry(content, child);
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Sorting
+  // --------------------------------------------------------------------------
+  sortCases(cases) {
+    if (this.options.sortScenarios === "alpha") {
+      return [...cases].sort(
+        (a, b) => a.story.scenario.localeCompare(b.story.scenario)
+      );
+    }
+    if (this.options.sortScenarios === "source") {
+      return [...cases].sort(
+        (a, b) => (a.story.sourceOrder ?? 0) - (b.story.sourceOrder ?? 0)
+      );
+    }
+    return cases;
+  }
+  sortSuiteGroups(entries) {
+    if (this.options.sortScenarios === "alpha") {
+      return entries.sort(([a], [b]) => a.localeCompare(b));
+    }
+    if (this.options.sortScenarios === "source") {
+      return entries.sort(([, a], [, b]) => {
+        const minA = Math.min(...a.map((s) => s.story.sourceOrder ?? Infinity));
+        const minB = Math.min(...b.map((s) => s.story.sourceOrder ?? Infinity));
+        return minA - minB;
+      });
+    }
+    return entries;
+  }
+};
+function text(value, mark) {
+  const node = { type: "text", text: value };
+  if (mark) {
+    node.marks = Array.isArray(mark) ? mark : [mark];
+  }
+  return node;
+}
+function strong() {
+  return { type: "strong" };
+}
+function em() {
+  return { type: "em" };
+}
+function codeMark() {
+  return { type: "code" };
+}
+function codeInline(value) {
+  return text(value, codeMark());
+}
+function link(label, href) {
+  return text(label, { type: "link", attrs: { href } });
+}
+function paragraph(content) {
+  return { type: "paragraph", content };
+}
+function heading(level, content) {
+  return {
+    type: "heading",
+    attrs: { level: clampHeadingLevel(level) },
+    content
+  };
+}
+function codeBlock(content, lang) {
+  return {
+    type: "codeBlock",
+    attrs: lang ? { language: lang } : {},
+    content: content ? [{ type: "text", text: content }] : []
+  };
+}
+function panel(panelType, content) {
+  return { type: "panel", attrs: { panelType }, content };
+}
+function table(rows) {
+  return {
+    type: "table",
+    attrs: { isNumberColumnEnabled: false, layout: "default" },
+    content: rows
+  };
+}
+function tableRow(cells) {
+  return { type: "tableRow", content: cells };
+}
+function tableHeader(value) {
+  return { type: "tableHeader", content: [paragraph([text(value)])] };
+}
+function tableCell(value) {
+  return { type: "tableCell", content: [paragraph([text(value)])] };
+}
+function clampHeadingLevel(level) {
+  if (level < 1) return 1;
+  if (level > 6) return 6;
+  return level;
+}
+function statusIcon(status) {
+  switch (status) {
+    case "passed":
+      return "\u2705";
+    case "failed":
+      return "\u274C";
+    case "skipped":
+      return "\u23E9";
+    case "pending":
+      return "\u{1F4DD}";
+    default:
+      return "\u26A0\uFE0F";
+  }
+}
+function formatDuration2(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function groupBy7(items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = map.get(key);
+    if (existing) existing.push(item);
+    else map.set(key, [item]);
+  }
+  return map;
+}
+
 // src/formatters/astro-assets.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
@@ -17020,6 +17428,235 @@ function copyMarkdownAssets(options) {
   };
 }
 
+// src/publishers/confluence.ts
+function parseAdf(adf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(adf);
+  } catch (err) {
+    throw new Error(
+      `ADF payload is not valid JSON: ${err.message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.type !== "doc" || !Array.isArray(parsed.content)) {
+    throw new Error(
+      `ADF payload must be an object with { version, type: "doc", content: [...] }`
+    );
+  }
+  return parsed;
+}
+function basicAuthHeader(auth) {
+  const raw = `${auth.email}:${auth.token}`;
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(raw, "utf8").toString("base64") : btoa(raw);
+  return `Basic ${encoded}`;
+}
+async function parseErrorBody(response) {
+  try {
+    const body = await response.text();
+    return body ? body.slice(0, 800) : "";
+  } catch {
+    return "";
+  }
+}
+async function publishConfluencePage(args, deps) {
+  parseAdf(args.adf);
+  if (!args.pageId && !args.spaceId) {
+    throw new Error(
+      "publishConfluencePage requires either pageId (update) or spaceId (create)"
+    );
+  }
+  if (!args.pageId && !args.title) {
+    throw new Error("Creating a new page requires a title");
+  }
+  const base = args.baseUrl.replace(/\/$/, "");
+  const fetchFn = deps.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new Error("No fetch implementation available (Node >= 22 expected)");
+  }
+  const headers = {
+    Authorization: basicAuthHeader(deps.auth),
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  if (args.pageId) {
+    return updatePage(args, base, headers, fetchFn);
+  }
+  return createPage(args, base, headers, fetchFn);
+}
+async function updatePage(args, base, headers, fetchFn) {
+  const getUrl = `${base}/api/v2/pages/${encodeURIComponent(args.pageId)}`;
+  const getResp = await fetchFn(getUrl, { method: "GET", headers });
+  if (!getResp.ok) {
+    const body = await parseErrorBody(getResp);
+    throw new Error(
+      `GET ${getUrl} failed with ${getResp.status} ${getResp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const current = await getResp.json();
+  const nextVersion = current.version.number + 1;
+  const title = args.title ?? current.title;
+  const putUrl = `${base}/api/v2/pages/${encodeURIComponent(args.pageId)}`;
+  const putResp = await fetchFn(putUrl, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({
+      id: args.pageId,
+      status: "current",
+      title,
+      body: {
+        representation: "atlas_doc_format",
+        value: args.adf
+      },
+      version: { number: nextVersion }
+    })
+  });
+  if (!putResp.ok) {
+    const body = await parseErrorBody(putResp);
+    throw new Error(
+      `PUT ${putUrl} failed with ${putResp.status} ${putResp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const updated = await putResp.json();
+  return {
+    id: updated.id,
+    title: updated.title,
+    version: updated.version.number,
+    url: buildPageUrl(base, updated._links?.webui, updated.id),
+    action: "updated"
+  };
+}
+async function createPage(args, base, headers, fetchFn) {
+  const body = {
+    spaceId: args.spaceId,
+    status: "current",
+    title: args.title,
+    body: {
+      representation: "atlas_doc_format",
+      value: args.adf
+    }
+  };
+  if (args.parentId) body.parentId = args.parentId;
+  const postUrl = `${base}/api/v2/pages`;
+  const resp = await fetchFn(postUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    const errBody = await parseErrorBody(resp);
+    throw new Error(
+      `POST ${postUrl} failed with ${resp.status} ${resp.statusText}${errBody ? `: ${errBody}` : ""}`
+    );
+  }
+  const created = await resp.json();
+  return {
+    id: created.id,
+    title: created.title,
+    version: created.version.number,
+    url: buildPageUrl(base, created._links?.webui, created.id),
+    action: "created"
+  };
+}
+function buildPageUrl(base, webui, id) {
+  if (webui) {
+    return webui.startsWith("http") ? webui : `${base}${webui}`;
+  }
+  return `${base}/pages/${id}`;
+}
+
+// src/publishers/jira.ts
+function parseAdf2(adf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(adf);
+  } catch (err) {
+    throw new Error(
+      `ADF payload is not valid JSON: ${err.message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.type !== "doc" || !Array.isArray(parsed.content)) {
+    throw new Error(
+      `ADF payload must be an object with { version, type: "doc", content: [...] }`
+    );
+  }
+  return parsed;
+}
+function basicAuthHeader2(auth) {
+  const raw = `${auth.email}:${auth.token}`;
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(raw, "utf8").toString("base64") : btoa(raw);
+  return `Basic ${encoded}`;
+}
+async function parseErrorBody2(resp) {
+  try {
+    const body = await resp.text();
+    return body ? body.slice(0, 800) : "";
+  } catch {
+    return "";
+  }
+}
+async function publishJiraIssue(args, deps) {
+  const adfObject = parseAdf2(args.adf);
+  if (!args.issueKey) {
+    throw new Error("publishJiraIssue requires an issueKey, e.g. PROJ-123");
+  }
+  const base = args.baseUrl.replace(/\/$/, "");
+  const fetchFn = deps.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new Error("No fetch implementation available (Node >= 22 expected)");
+  }
+  const headers = {
+    Authorization: basicAuthHeader2(deps.auth),
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  const mode = args.mode ?? "comment";
+  if (mode === "description") {
+    return updateDescription(args.issueKey, base, adfObject, headers, fetchFn);
+  }
+  return addComment(args.issueKey, base, adfObject, headers, fetchFn);
+}
+async function addComment(issueKey, base, adf, headers, fetchFn) {
+  const url = `${base}/rest/api/3/issue/${encodeURIComponent(issueKey)}/comment`;
+  const resp = await fetchFn(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ body: adf })
+  });
+  if (!resp.ok) {
+    const body = await parseErrorBody2(resp);
+    throw new Error(
+      `POST ${url} failed with ${resp.status} ${resp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const comment = await resp.json();
+  const issueUrl = `${base}/browse/${encodeURIComponent(issueKey)}`;
+  return {
+    issueKey,
+    action: "comment-added",
+    url: `${issueUrl}?focusedCommentId=${encodeURIComponent(comment.id)}`,
+    commentId: comment.id
+  };
+}
+async function updateDescription(issueKey, base, adf, headers, fetchFn) {
+  const url = `${base}/rest/api/3/issue/${encodeURIComponent(issueKey)}`;
+  const resp = await fetchFn(url, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ fields: { description: adf } })
+  });
+  if (!resp.ok) {
+    const body = await parseErrorBody2(resp);
+    throw new Error(
+      `PUT ${url} failed with ${resp.status} ${resp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  return {
+    issueKey,
+    action: "description-updated",
+    url: `${base}/browse/${encodeURIComponent(issueKey)}`
+  };
+}
+
 // src/converters/ndjson-parser.ts
 function parseNdjson(ndjson) {
   const lines = ndjson.trim().split("\n").filter(Boolean);
@@ -17320,10 +17957,10 @@ function pickleStepArgumentToDocs(ps) {
   const docs = [];
   const phase = "static";
   if (ps.argument.dataTable) {
-    const table = ps.argument.dataTable;
-    if (table.rows.length > 0) {
-      const columns = table.rows[0].cells.map((c) => c.value);
-      const rows = table.rows.slice(1).map((r) => r.cells.map((c) => c.value));
+    const table2 = ps.argument.dataTable;
+    if (table2.rows.length > 0) {
+      const columns = table2.rows[0].cells.map((c) => c.value);
+      const rows = table2.rows.slice(1).map((r) => r.cells.map((c) => c.value));
       docs.push({
         kind: "table",
         label: "",
@@ -17386,16 +18023,16 @@ function pickleStepArgumentToDocs(ps) {
 }
 
 // src/notifiers/ansi-strip.ts
-function stripAnsi(text) {
-  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+function stripAnsi(text2) {
+  return text2.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
 }
 
 // src/notifiers/slack.ts
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
+function truncate(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen - 3) + "...";
 }
-function formatDuration2(ms) {
+function formatDuration3(ms) {
   const seconds = ms / 1e3;
   if (seconds < 60) return `${seconds.toFixed(1)}s`;
   const minutes = Math.floor(seconds / 60);
@@ -17422,7 +18059,7 @@ function buildSlackPayload(summary, maxFailedTests) {
       { type: "mrkdwn", text: `*Passed:* ${summary.passed}` },
       { type: "mrkdwn", text: `*Failed:* ${summary.failed}` },
       { type: "mrkdwn", text: `*Skipped:* ${summary.skipped}` },
-      { type: "mrkdwn", text: `*Duration:* ${formatDuration2(summary.durationMs)}` },
+      { type: "mrkdwn", text: `*Duration:* ${formatDuration3(summary.durationMs)}` },
       { type: "mrkdwn", text: `*Status:* ${statusText}` }
     ]
   });
@@ -17437,9 +18074,9 @@ function buildSlackPayload(summary, maxFailedTests) {
       }
       return `*${name}*`;
     });
-    let text = lines.join("\n\n");
+    let text2 = lines.join("\n\n");
     if (summary.failedTests.length > maxFailedTests) {
-      text += `
+      text2 += `
 
 _...and ${summary.failedTests.length - maxFailedTests} more_`;
     }
@@ -17447,7 +18084,7 @@ _...and ${summary.failedTests.length - maxFailedTests} more_`;
       type: "section",
       text: {
         type: "mrkdwn",
-        text
+        text: text2
       }
     });
   }
@@ -17524,11 +18161,11 @@ async function sendSlackNotification(args, deps) {
 }
 
 // src/notifiers/teams.ts
-function truncate2(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
+function truncate2(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen - 3) + "...";
 }
-function formatDuration3(ms) {
+function formatDuration4(ms) {
   const seconds = ms / 1e3;
   if (seconds < 60) return `${seconds.toFixed(1)}s`;
   const minutes = Math.floor(seconds / 60);
@@ -17554,7 +18191,7 @@ function buildTeamsPayload(summary, maxFailedTests) {
       { title: "Passed", value: String(summary.passed) },
       { title: "Failed", value: String(summary.failed) },
       { title: "Skipped", value: String(summary.skipped) },
-      { title: "Duration", value: formatDuration3(summary.durationMs) }
+      { title: "Duration", value: formatDuration4(summary.durationMs) }
     ]
   });
   if (summary.failedTests.length > 0) {
@@ -17973,6 +18610,37 @@ function listScenarios(args, _deps) {
     }));
     return JSON.stringify(items, null, 2);
   }
+  if (format === "csv") {
+    const header = "id,scenario,status,sourceFile,sourceLine,tags";
+    const rows = testCases.map((tc) => {
+      const fields = [
+        tc.id,
+        tc.story.scenario,
+        tc.status,
+        tc.sourceFile,
+        String(tc.sourceLine),
+        tc.tags.join(" ")
+      ];
+      return fields.map((f) => {
+        if (f.includes(",") || f.includes('"') || f.includes("\n")) {
+          return `"${f.replace(/"/g, '""')}"`;
+        }
+        return f;
+      }).join(",");
+    });
+    return [header, ...rows].join("\n");
+  }
+  if (format === "markdown-table") {
+    const header = "| Status | Scenario | Location | Tags |";
+    const divider = "|--------|----------|----------|------|";
+    const rows = testCases.map((tc) => {
+      const icon = STATUS_ICONS[tc.status] ?? "?";
+      const location = `${tc.sourceFile}:${tc.sourceLine}`;
+      const tags = tc.tags.map((t) => `@${t}`).join(" ");
+      return `| ${icon} | ${tc.story.scenario} | ${location} | ${tags} |`;
+    });
+    return [header, divider, ...rows].join("\n");
+  }
   if (testCases.length === 0) {
     return "No scenarios found.";
   }
@@ -18020,7 +18688,8 @@ var FORMAT_EXTENSIONS = {
   "cucumber-html": ".cucumber.html",
   junit: ".junit.xml",
   "cucumber-json": ".cucumber.json",
-  "cucumber-messages": ".ndjson"
+  "cucumber-messages": ".ndjson",
+  confluence: ".adf.json"
 };
 var TEST_EXTENSIONS = [
   ".test.ts",
@@ -18188,6 +18857,19 @@ var ReportGenerator = class {
         includeSourceLinks: options.markdown?.includeSourceLinks ?? true,
         customRenderers: options.markdown?.customRenderers
       },
+      confluence: {
+        title: options.confluence?.title ?? "User Stories",
+        includeStatusIcons: options.confluence?.includeStatusIcons ?? true,
+        includeMetadata: options.confluence?.includeMetadata ?? true,
+        includeSummaryTable: options.confluence?.includeSummaryTable ?? true,
+        includeErrors: options.confluence?.includeErrors ?? true,
+        scenarioHeadingLevel: options.confluence?.scenarioHeadingLevel ?? 3,
+        groupBy: options.confluence?.groupBy ?? "file",
+        sortScenarios: options.confluence?.sortScenarios ?? "source",
+        pretty: options.confluence?.pretty ?? true,
+        permalinkBaseUrl: options.confluence?.permalinkBaseUrl,
+        ticketUrlTemplate: options.confluence?.ticketUrlTemplate
+      },
       astro: {
         assetsDir: options.astro?.assetsDir ?? "public/stories/assets",
         assetsBaseUrl: options.astro?.assetsBaseUrl ?? "/stories/assets",
@@ -18363,6 +19045,22 @@ var ReportGenerator = class {
         });
         return formatter.format(run);
       }
+      case "confluence": {
+        const formatter = new ConfluenceFormatter({
+          title: this.options.confluence.title,
+          includeStatusIcons: this.options.confluence.includeStatusIcons,
+          includeMetadata: this.options.confluence.includeMetadata,
+          includeSummaryTable: this.options.confluence.includeSummaryTable,
+          includeErrors: this.options.confluence.includeErrors,
+          scenarioHeadingLevel: this.options.confluence.scenarioHeadingLevel,
+          groupBy: this.options.confluence.groupBy,
+          sortScenarios: this.options.confluence.sortScenarios,
+          pretty: this.options.confluence.pretty,
+          permalinkBaseUrl: this.options.confluence.permalinkBaseUrl,
+          ticketUrlTemplate: this.options.confluence.ticketUrlTemplate
+        });
+        return formatter.format(run);
+      }
       case "markdown": {
         const formatter = new MarkdownFormatter({
           title: this.options.markdown.title,
@@ -18444,6 +19142,22 @@ function copyDirRecursive(src, dest) {
   }
 }
 
+// src/config.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
+async function loadConfig(configPath) {
+  const resolved = configPath ? resolve6(configPath) : resolve6(process.cwd(), "executable-stories.config.js");
+  if (!existsSync6(resolved)) return {};
+  const mod = await import(resolved);
+  const config = mod.default;
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(
+      `Config file at ${resolved} must export a default object. Got: ${typeof config}`
+    );
+  }
+  return config;
+}
+
 // src/cli.ts
 var EXIT_SUCCESS = 0;
 var EXIT_SCHEMA_VALIDATION = 1;
@@ -18461,23 +19175,29 @@ USAGE
   executable-stories validate <file>
   executable-stories validate --stdin
   executable-stories init-astro [directory]
+  executable-stories publish-confluence <file.adf.json> [options]
+  executable-stories publish-jira <file.adf.json> [options]
 
 SUBCOMMANDS
-  format     Read raw test results and generate reports
-  compare    Compare two runs and generate a diff report
-  list       List scenarios from a test run (text table or JSON)
-  validate   Validate a JSON file against the schema (no output generated)
-  init-astro Scaffold an Astro Starlight docs site for story output
+  format             Read raw test results and generate reports
+  compare            Compare two runs and generate a diff report
+  list               List scenarios from a test run (text table or JSON)
+  validate           Validate a JSON file against the schema (no output generated)
+  init-astro         Scaffold an Astro docs site for story output (Starlight with themed CSS)
+  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)
 
 OPTIONS
-  --format <formats>            Comma-separated formats (default: html)
-                                  astro             Starlight-compatible Markdown (for Astro docs sites)
+  --format <formats>            Comma-separated formats: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, astro, confluence, 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
                                   html              Custom HTML report (accessible, dark mode, mermaid)
                                   cucumber-html     Official Cucumber HTML report
                                   markdown          Markdown documentation
                                   junit             JUnit XML
                                   cucumber-json     Cucumber JSON
                                   cucumber-messages Raw NDJSON (Cucumber Messages)
+  --config <path>               Path to executable-stories.config.js (default: ./executable-stories.config.js)
   --input-type <type>           Input type: raw, canonical, or ndjson (default: raw)
   --output-dir <dir>            Output directory (default: reports)
   --output-name <name>          Base filename (default: index)
@@ -18501,7 +19221,8 @@ OPTIONS
   --asset-mode <mode>         Asset bundling: "none" (default) or "copy"
   --allow-missing-assets      Warn on missing assets instead of failing
   --stdin                       Read JSON from stdin instead of file
-  --json-summary                Print machine-parsable JSON summary
+  --list-format <format>        list output format: text (default), json, csv, markdown-table
+  --json-summary                Deprecated alias for --list-format json
   --baseline <path|auto>        Compare baseline file, or auto-pick a prior run for compare
   --baseline-dir <dir>          Directory to scan when --baseline auto is used
   --pr-summary                  Print a PR-friendly markdown summary after compare
@@ -18510,7 +19231,8 @@ OPTIONS
   --help                        Show this help message
 
 LIST
-  list prints one scenario per line (text by default, JSON with --json-summary)
+  list prints one scenario per line (--list-format text by default)
+  list --list-format json outputs machine-parsable JSON (--json-summary is a deprecated alias)
   list supports --include-tags, --exclude-tags for filtering
   list supports --input-type and --stdin
 
@@ -18522,6 +19244,26 @@ INIT-ASTRO
   executable-stories init-astro [directory]   Scaffold into directory (default: ./story-docs)
   --force                                      Overwrite existing directory
 
+PUBLISH-CONFLUENCE
+  executable-stories publish-confluence <file.adf.json> [options]
+  --page-id <id>               Update an existing page (alternative to --space-id)
+  --space-id <id>              Create a new page (requires --title)
+  --parent-id <id>             Parent page ID (for new pages)
+  --title <title>              Page title
+  --base-url <url>             Confluence base URL (env: CONFLUENCE_BASE_URL)
+  --email <email>              Atlassian email (env: CONFLUENCE_EMAIL)
+  --token <token>              API token (env: CONFLUENCE_TOKEN)
+  --dry-run                    Validate and print request plan, don't POST
+
+PUBLISH-JIRA
+  executable-stories publish-jira <file.adf.json> [options]
+  --issue <KEY>                Issue key, e.g. PROJ-123 (required)
+  --mode <mode>                "comment" (default) or "description"
+  --base-url <url>             Jira base URL (env: JIRA_BASE_URL)
+  --email <email>              Atlassian email (env: JIRA_EMAIL)
+  --token <token>              API token (env: JIRA_TOKEN)
+  --dry-run                    Validate and print request plan, don't POST
+
 NOTIFICATIONS
   --slack-webhook <url>         Slack incoming webhook URL (fallback: SLACK_WEBHOOK_URL env var)
   --teams-webhook <url>         Teams incoming webhook URL (fallback: TEAMS_WEBHOOK_URL env var)
@@ -18549,24 +19291,45 @@ EXIT CODES
   3  Formatter/generation failure
   4  Bad arguments / usage error
 `.trim();
-function parseCliArgs(argv) {
+async function parseCliArgs(argv) {
   const args = argv.slice(2);
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
     console.log(HELP_TEXT);
     process.exit(EXIT_SUCCESS);
   }
   const subcommand = args[0];
-  if (subcommand !== "format" && subcommand !== "compare" && subcommand !== "list" && subcommand !== "validate" && subcommand !== "init-astro") {
-    console.error(`Unknown subcommand: "${subcommand}". Use "format", "compare", "list", "validate", or "init-astro".`);
+  if (subcommand !== "format" && subcommand !== "compare" && subcommand !== "list" && subcommand !== "validate" && subcommand !== "init-astro" && subcommand !== "publish-confluence" && subcommand !== "publish-jira") {
+    console.error(
+      `Unknown subcommand: "${subcommand}". Use "format", "compare", "list", "validate", "init-astro", "publish-confluence", or "publish-jira".`
+    );
     process.exit(EXIT_USAGE);
   }
+  if (subcommand === "publish-confluence") {
+    await runPublishConfluence(args.slice(1));
+    process.exit(EXIT_SUCCESS);
+  }
+  if (subcommand === "publish-jira") {
+    await runPublishJira(args.slice(1));
+    process.exit(EXIT_SUCCESS);
+  }
   if (subcommand === "init-astro") {
     const initArgs = args.slice(1);
     const targetDir = initArgs.find((a) => !a.startsWith("--")) ?? "./story-docs";
     const force = initArgs.includes("--force");
     try {
       const result = initAstro({ targetDir, force });
-      console.log(`Scaffolded Astro Starlight project at ${result.targetDir}`);
+      console.log(`Scaffolded Astro docs site at ${result.targetDir}`);
+      console.log("");
+      console.log("Themes available in src/styles/themes/:");
+      console.log("  default.css   IBM Plex Sans, cucumber green (default)");
+      console.log("  corporate.css  DM Sans, navy accent");
+      console.log("  terminal.css   JetBrains Mono, green-on-dark");
+      console.log("  minimal.css    DM Sans, warm teal");
+      console.log("  dashboard.css  DM Sans, blue accent");
+      console.log("  playful.css    Source Sans, coral pastels");
+      console.log("");
+      console.log("To change theme, edit astro.config.mjs customCss array.");
+      console.log("");
       console.log("");
       console.log("Next steps:");
       console.log(`  cd ${result.targetDir}`);
@@ -18609,6 +19372,7 @@ function parseCliArgs(argv) {
       "html-theme-picker": { type: "boolean", default: false },
       stdin: { type: "boolean", default: false },
       "json-summary": { type: "boolean", default: false },
+      "list-format": { type: "string", default: "text" },
       "emit-canonical": { type: "string" },
       "slack-webhook": { type: "string" },
       "teams-webhook": { type: "string" },
@@ -18627,6 +19391,7 @@ function parseCliArgs(argv) {
       "allow-missing-assets": { type: "boolean", default: false },
       "pr-summary": { type: "boolean", default: false },
       "pr-summary-file": { type: "string" },
+      "config": { type: "string" },
       help: { type: "boolean", default: false }
     },
     allowPositionals: true,
@@ -18664,15 +19429,20 @@ function parseCliArgs(argv) {
     console.error(`Error: --input-type must be "raw", "canonical", or "ndjson", got "${inputType}".`);
     process.exit(EXIT_USAGE);
   }
-  const validFormats = /* @__PURE__ */ new Set(["astro", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html"]);
+  const pluginConfig = await loadConfig(values["config"]);
+  const customFormatterNames = new Set(Object.keys(pluginConfig.formatters ?? {}));
+  const builtInFormats = /* @__PURE__ */ new Set(["astro", "confluence", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html"]);
   const formatStr = values.format;
-  const formats = formatStr.split(",").map((f) => f.trim());
-  for (const f of formats) {
-    if (!validFormats.has(f)) {
-      console.error(`Error: Unknown format "${f}". Valid: astro, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html.`);
-      process.exit(EXIT_USAGE);
-    }
+  const allRequestedFormats = formatStr.split(",").map((f) => f.trim());
+  const builtInRequested = allRequestedFormats.filter((f) => builtInFormats.has(f));
+  const customRequested = allRequestedFormats.filter((f) => customFormatterNames.has(f));
+  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, confluence, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html${knownCustom}.`);
+    process.exit(EXIT_USAGE);
   }
+  const formats = builtInRequested;
   const htmlTheme = values["html-theme"];
   const validThemes = /* @__PURE__ */ new Set(["default", "corporate", "terminal", "minimal", "dashboard", "playful"]);
   if (!validThemes.has(htmlTheme)) {
@@ -18740,7 +19510,7 @@ function parseCliArgs(argv) {
     console.error(`Error: --asset-mode must be "none" or "copy", got "${assetModeRaw}".`);
     process.exit(EXIT_USAGE);
   }
-  return {
+  const cliArgs = {
     subcommand,
     inputFile,
     baselineFile,
@@ -18769,6 +19539,7 @@ function parseCliArgs(argv) {
     htmlNoToc: values["html-no-toc"],
     htmlThemePicker: values["html-theme-picker"],
     jsonSummary: values["json-summary"],
+    listFormat: values["list-format"],
     emitCanonical: values["emit-canonical"],
     slackWebhook,
     teamsWebhook,
@@ -18786,8 +19557,10 @@ function parseCliArgs(argv) {
     assetMode: assetModeRaw,
     allowMissingAssets: values["allow-missing-assets"],
     prSummary: values["pr-summary"],
-    prSummaryFile: values["pr-summary-file"]
+    prSummaryFile: values["pr-summary-file"],
+    config: values["config"]
   };
+  return { args: cliArgs, pluginConfig, customRequested };
 }
 async function readInput(args) {
   if (args.stdin) {
@@ -18809,26 +19582,26 @@ function readFileInput(filePath) {
   return fs7.readFileSync(resolved, "utf8");
 }
 function readStdin() {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve7(chunks.join("")));
+    process.stdin.on("end", () => resolve8(chunks.join("")));
     process.stdin.on("error", reject);
   });
 }
-function parseJson(text) {
+function parseJson(text2) {
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`Error: Invalid JSON \u2014 ${msg}`);
     process.exit(EXIT_USAGE);
   }
 }
-function tryParseJson(text) {
+function tryParseJson(text2) {
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch {
     return void 0;
   }
@@ -18878,17 +19651,17 @@ ${msg}`);
   }
   return { run: canonical, droppedMissingStory };
 }
-function normalizeRunFromText(text, args) {
+function normalizeRunFromText(text2, args) {
   if (args.inputType === "ndjson") {
     try {
-      return { run: parseNdjson(text), droppedMissingStory: 0 };
+      return { run: parseNdjson(text2), droppedMissingStory: 0 };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`NDJSON parse failed: ${msg}`);
       process.exit(EXIT_SCHEMA_VALIDATION);
     }
   }
-  return normalizeRunFromJsonData(parseJson(text), args);
+  return normalizeRunFromJsonData(parseJson(text2), args);
 }
 function applySelection(run, args) {
   const testCases = selectTestCases(
@@ -18904,15 +19677,15 @@ function applySelection(run, args) {
   );
   return { ...run, testCases };
 }
-function tryNormalizeRunFromText(text, args) {
+function tryNormalizeRunFromText(text2, args) {
   if (args.inputType === "ndjson") {
     try {
-      return parseNdjson(text);
+      return parseNdjson(text2);
     } catch {
       return void 0;
     }
   }
-  const data = tryParseJson(text);
+  const data = tryParseJson(text2);
   if (data === void 0) return void 0;
   if (args.inputType === "canonical") {
     try {
@@ -18973,7 +19746,7 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   return picked.file;
 }
 async function main() {
-  const args = parseCliArgs(process.argv);
+  const { args, pluginConfig, customRequested } = await parseCliArgs(process.argv);
   const startMs = Date.now();
   if (args.subcommand === "compare") {
     const currentText = readFileInput(args.currentFile);
@@ -18992,17 +19765,25 @@ async function main() {
     }
   }
   if (args.subcommand === "list") {
-    const text2 = await readInput(args);
-    const run = applySelection(normalizeRunFromText(text2, args).run, args);
-    const outputFormat = args.jsonSummary ? "json" : "text";
-    const output = listScenarios({ testCases: run.testCases, format: outputFormat }, {});
+    const text3 = await readInput(args);
+    const run = applySelection(normalizeRunFromText(text3, args).run, args);
+    const resolvedFormat = args.jsonSummary ? "json" : args.listFormat;
+    const validListFormats = /* @__PURE__ */ new Set(["text", "json", "csv", "markdown-table"]);
+    if (!validListFormats.has(resolvedFormat)) {
+      console.error(`Error: Unknown list format "${resolvedFormat}". Valid: text, json, csv, markdown-table.`);
+      process.exit(EXIT_USAGE);
+    }
+    const output = listScenarios(
+      { testCases: run.testCases, format: resolvedFormat },
+      {}
+    );
     console.log(output);
     process.exit(EXIT_SUCCESS);
   }
-  const text = await readInput(args);
+  const text2 = await readInput(args);
   if (args.inputType === "ndjson") {
     if (args.subcommand === "validate") {
-      const lines = text.trim().split("\n").filter(Boolean);
+      const lines = text2.trim().split("\n").filter(Boolean);
       const validKeys = /* @__PURE__ */ new Set([
         "meta",
         "source",
@@ -19035,7 +19816,7 @@ async function main() {
     }
     let run;
     try {
-      run = parseNdjson(text);
+      run = parseNdjson(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`NDJSON parse failed: ${msg}`);
@@ -19048,6 +19829,7 @@ async function main() {
     }
     try {
       const result = await generateReports(run, args);
+      runCustomFormatters(run, customRequested, pluginConfig.formatters ?? {}, args);
       await dispatchNotifications(run, args);
       runHistoryPipeline(run, args);
       printResult(result, args, startMs);
@@ -19058,7 +19840,7 @@ async function main() {
       process.exit(EXIT_GENERATION);
     }
   }
-  const data = parseJson(text);
+  const data = parseJson(text2);
   if (args.subcommand === "validate") {
     if (args.inputType === "canonical") {
       try {
@@ -19106,6 +19888,7 @@ ${msg}`);
     }
     try {
       const result = await generateReports(run, args);
+      runCustomFormatters(run, customRequested, pluginConfig.formatters ?? {}, args);
       await dispatchNotifications(run, args);
       runHistoryPipeline(run, args);
       printResult(result, args, startMs);
@@ -19163,6 +19946,7 @@ ${msg}`);
   }
   try {
     const result = await generateReports(canonical, args, droppedMissingStory);
+    runCustomFormatters(canonical, customRequested, pluginConfig.formatters ?? {}, args);
     await dispatchNotifications(canonical, args);
     runHistoryPipeline(canonical, args);
     printResult(result, args, startMs, droppedMissingStory);
@@ -19173,6 +19957,25 @@ ${msg}`);
     process.exit(EXIT_GENERATION);
   }
 }
+function runCustomFormatters(run, customRequested, formatters, args) {
+  if (customRequested.length === 0) return;
+  const outputDir = args.outputDir ?? ".";
+  for (const formatName of customRequested) {
+    const formatter = formatters[formatName];
+    try {
+      const content = formatter.format(run);
+      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 = path7.join(outputDir, filename);
+      fs7.mkdirSync(outputDir, { recursive: true });
+      fs7.writeFileSync(filepath, content, "utf8");
+      console.log(`Generated: ${filepath}`);
+    } catch (err) {
+      console.error(`Error running custom formatter "${formatName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
 async function dispatchNotifications(run, args) {
   const webhooks = args.webhookUrls.map((url) => {
     const opts = { url };
@@ -19366,6 +20169,225 @@ function printCompareResult(result, args, startMs) {
     console.log(result.prSummary);
   }
 }
+async function runPublishConfluence(rawArgs) {
+  const { values, positionals } = parseArgs({
+    args: rawArgs,
+    options: {
+      "page-id": { type: "string" },
+      "space-id": { type: "string" },
+      "parent-id": { type: "string" },
+      title: { type: "string" },
+      "base-url": { type: "string" },
+      email: { type: "string" },
+      token: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      help: { type: "boolean", default: false }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help) {
+    console.log(`Usage: executable-stories publish-confluence <file.adf.json> [options]
+
+Publishes an ADF JSON document to a Confluence Cloud page.
+
+Required (one of):
+  --page-id <id>           Update an existing page in place
+  --space-id <id>          Create a new page in a space (also requires --title)
+
+Optional:
+  --parent-id <id>         Parent page ID (new pages only)
+  --title <title>          Page title (required for create; overrides current title on update)
+  --base-url <url>         Confluence base URL, e.g. https://acme.atlassian.net/wiki
+                           (env: CONFLUENCE_BASE_URL)
+  --email <email>          Atlassian account email (env: CONFLUENCE_EMAIL)
+  --token <token>          Atlassian API token (env: CONFLUENCE_TOKEN)
+  --dry-run                Validate inputs and print the request plan, don't POST
+  --help                   Show this help
+
+Generate an API token at https://id.atlassian.com/manage-profile/security/api-tokens`);
+    process.exit(EXIT_SUCCESS);
+  }
+  const inputFile = positionals[0];
+  if (!inputFile) {
+    console.error("Error: missing ADF file argument. Run with --help for usage.");
+    process.exit(EXIT_USAGE);
+  }
+  if (!fs7.existsSync(inputFile)) {
+    console.error(`Error: file not found: ${inputFile}`);
+    process.exit(EXIT_USAGE);
+  }
+  const baseUrl = values["base-url"] ?? process.env.CONFLUENCE_BASE_URL;
+  const email = values.email ?? process.env.CONFLUENCE_EMAIL;
+  const token = values.token ?? process.env.CONFLUENCE_TOKEN;
+  const pageId = values["page-id"];
+  const spaceId = values["space-id"];
+  const parentId = values["parent-id"];
+  const title = values.title;
+  const dryRun = values["dry-run"];
+  if (!baseUrl) {
+    console.error(
+      "Error: --base-url or CONFLUENCE_BASE_URL is required (e.g. https://acme.atlassian.net/wiki)"
+    );
+    process.exit(EXIT_USAGE);
+  }
+  if (!pageId && !spaceId) {
+    console.error(
+      "Error: specify either --page-id (to update) or --space-id (to create)"
+    );
+    process.exit(EXIT_USAGE);
+  }
+  if (!pageId && !title) {
+    console.error("Error: --title is required when creating a new page");
+    process.exit(EXIT_USAGE);
+  }
+  const adf = fs7.readFileSync(path7.resolve(inputFile), "utf8");
+  if (dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          action: pageId ? "update" : "create",
+          baseUrl,
+          pageId,
+          spaceId,
+          parentId,
+          title,
+          adfBytes: adf.length
+        },
+        null,
+        2
+      )
+    );
+    process.exit(EXIT_SUCCESS);
+  }
+  if (!email || !token) {
+    console.error(
+      "Error: --email/CONFLUENCE_EMAIL and --token/CONFLUENCE_TOKEN are required unless --dry-run is set"
+    );
+    process.exit(EXIT_USAGE);
+  }
+  try {
+    const result = await publishConfluencePage(
+      { adf, pageId, spaceId, parentId, title, baseUrl },
+      { auth: { email, token } }
+    );
+    console.log(
+      `${result.action === "created" ? "Created" : "Updated"} "${result.title}" (v${result.version}) \u2192 ${result.url}`
+    );
+    process.exit(EXIT_SUCCESS);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(EXIT_GENERATION);
+  }
+}
+async function runPublishJira(rawArgs) {
+  const { values, positionals } = parseArgs({
+    args: rawArgs,
+    options: {
+      issue: { type: "string" },
+      mode: { type: "string", default: "comment" },
+      "base-url": { type: "string" },
+      email: { type: "string" },
+      token: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      help: { type: "boolean", default: false }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help) {
+    console.log(`Usage: executable-stories publish-jira <file.adf.json> [options]
+
+Publishes an ADF JSON document to a Jira Cloud issue.
+
+Required:
+  --issue <KEY>            Issue key, e.g. PROJ-123
+
+Optional:
+  --mode <mode>            "comment" (default, append-only) or "description" (replaces field)
+  --base-url <url>         Jira base URL, e.g. https://acme.atlassian.net
+                           (env: JIRA_BASE_URL)
+  --email <email>          Atlassian account email (env: JIRA_EMAIL)
+  --token <token>          Atlassian API token (env: JIRA_TOKEN)
+  --dry-run                Validate inputs and print the request plan, don't POST
+  --help                   Show this help
+
+Generate an API token at https://id.atlassian.com/manage-profile/security/api-tokens`);
+    process.exit(EXIT_SUCCESS);
+  }
+  const inputFile = positionals[0];
+  if (!inputFile) {
+    console.error("Error: missing ADF file argument. Run with --help for usage.");
+    process.exit(EXIT_USAGE);
+  }
+  if (!fs7.existsSync(inputFile)) {
+    console.error(`Error: file not found: ${inputFile}`);
+    process.exit(EXIT_USAGE);
+  }
+  const baseUrl = values["base-url"] ?? process.env.JIRA_BASE_URL;
+  const email = values.email ?? process.env.JIRA_EMAIL;
+  const token = values.token ?? process.env.JIRA_TOKEN;
+  const issueKey = values.issue;
+  const modeRaw = values.mode;
+  const dryRun = values["dry-run"];
+  if (!baseUrl) {
+    console.error(
+      "Error: --base-url or JIRA_BASE_URL is required (e.g. https://acme.atlassian.net)"
+    );
+    process.exit(EXIT_USAGE);
+  }
+  if (!issueKey) {
+    console.error("Error: --issue <KEY> is required (e.g. --issue PROJ-123)");
+    process.exit(EXIT_USAGE);
+  }
+  if (modeRaw !== "comment" && modeRaw !== "description") {
+    console.error(
+      `Error: --mode must be "comment" or "description" (got "${modeRaw}")`
+    );
+    process.exit(EXIT_USAGE);
+  }
+  const mode = modeRaw;
+  const adf = fs7.readFileSync(path7.resolve(inputFile), "utf8");
+  if (dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          action: mode === "description" ? "description-updated" : "comment-added",
+          baseUrl,
+          issueKey,
+          mode,
+          adfBytes: adf.length
+        },
+        null,
+        2
+      )
+    );
+    process.exit(EXIT_SUCCESS);
+  }
+  if (!email || !token) {
+    console.error(
+      "Error: --email/JIRA_EMAIL and --token/JIRA_TOKEN are required unless --dry-run is set"
+    );
+    process.exit(EXIT_USAGE);
+  }
+  try {
+    const result = await publishJiraIssue(
+      { adf, issueKey, baseUrl, mode },
+      { auth: { email, token } }
+    );
+    if (result.action === "comment-added") {
+      console.log(
+        `Added comment to ${result.issueKey} (comment ${result.commentId}) \u2192 ${result.url}`
+      );
+    } else {
+      console.log(`Updated description for ${result.issueKey} \u2192 ${result.url}`);
+    }
+    process.exit(EXIT_SUCCESS);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(EXIT_GENERATION);
+  }
+}
 main().catch((err) => {
   console.error(err);
   process.exit(EXIT_USAGE);