mandrel 1.58.0 → 1.60.0

package/.agents/scripts/lib/orchestration/story-close/format-autofix-scoped.js

@@ -1,221 +0,0 @@
-/**
- * format-autofix-scoped.js — Story #2533: scoped biome-format auto-apply
- * inside story-close's pre-merge gate chain.
- *
- * Background. The whole-tree `runFormatAutofix` (sibling module) heals
- * drift across `.` before the gate chain runs. That step is intentionally
- * broad because it covers files (JSON / YAML / config) that lint-staged
- * does not glob. This module is the narrower companion: it scopes
- * `biome format --write` to the **changed-file set** between the Epic
- * branch and the Story branch and folds any auto-fixed paths into a
- * dedicated commit on the Story branch *before* `biome ci` runs in the
- * gate chain.
- *
- * Why scoped + warn-level. The Tech Spec (Epic #2527, Story 5) calls out
- * that format diffs introduced by Story commits should never surface to
- * Phase 3 close-validation. The whole-tree autofix already covers that,
- * but emits `info` so operators routinely miss it. This module emits
- * `Logger.warn` naming the auto-fixed files so the signal is visible in
- * the close transcript and downstream ledger.
- *
- * Dependencies are injected so unit tests pin behaviour without spawning
- * git or biome.
- */
-
-import { execFileSync } from 'node:child_process';
-
-import { diffNameOnly } from '../../changed-files.js';
-import { Logger as DefaultLogger } from '../../Logger.js';
-import {
-  commitDirtyPaths,
-  currentBranch,
-  listDirtyPaths,
-  resolveFormatterCmd,
-} from './format-autofix-shared.js';
-
-const TAG = '[format-autofix-scoped]';
-
-/**
- * List the files changed between `epicBranch` and `storyBranch` using the
- * three-dot merge-base diff. Delegates parsing to `diffNameOnly` from
- * `changed-files.js` so the stdout → path-list conversion lives in one place.
- *
- * The `git` parameter uses the caller's local interface:
- * `(args: string[], opts: object) => string`. A bridge adapter wraps it into
- * the `gitSpawn(cwd, ...args)` shape that `diffNameOnly` expects.
- *
- * @param {{ cwd: string, epicBranch: string, storyBranch: string, git: Function }} opts
- * @returns {string[]}
- */
-function listChangedFiles({ cwd, epicBranch, storyBranch, git }) {
-  // Bridge the (args, opts) → string interface into gitSpawn(cwd, ...args).
-  const gitSpawn = (_cwd, ...args) => {
-    try {
-      const stdout = git(args, {
-        cwd: _cwd,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-      });
-      return { status: 0, stdout: stdout ?? '', stderr: '' };
-    } catch (err) {
-      return {
-        status: err.status ?? 1,
-        stdout: err.stdout ?? '',
-        stderr: err.stderr ?? err.message,
-      };
-    }
-  };
-  return diffNameOnly({
-    range: `${epicBranch}...${storyBranch}`,
-    cwd,
-    gitSpawn,
-  });
-}
-
-/**
- * Run `biome format --write <changedFiles>` on the Epic→Story diff. If
- * any file is modified, stage and commit the changes on the Story branch
- * with a conventional `fix(story-close):` subject and emit a
- * `Logger.warn` naming the auto-fixed files. Returns a structured
- * envelope so callers can log a single line.
- *
- * No-op envelopes:
- *   - `{ ran: false, reason: 'no-changed-files' }`        — empty diff.
- *   - `{ ran: false, reason: 'dirty-tree' }`              — refused to
- *     absorb pre-existing edits.
- *   - `{ ran: true, committed: false }`                   — formatter
- *     was clean.
- *
- * **Worktree scope (Story #3907).** All git + formatter operations run in
- * `worktreePath` (the Story worktree where `story-<id>` is checked out), not
- * `cwd` (the main checkout). The earlier implementation ran every step
- * against `cwd`, so the `git add -u` + `git commit` could land an unreviewed
- * `fix(story-close):` commit on whatever branch the main checkout happened to
- * have out — including `main`. Before committing, the worktree's checked-out
- * branch is asserted to equal `storyBranch`; a mismatch refuses to commit and
- * returns `{ ran: true, committed: false, reason: 'wrong-branch' }` so a
- * stale-state checkout can never absorb the autofix into the wrong history.
- * `worktreePath` defaults to `cwd` for the resume/legacy callers that have no
- * separate worktree.
- *
- * @param {{
- *   cwd: string,
- *   worktreePath?: string,
- *   storyId: number|string,
- *   epicBranch: string,
- *   storyBranch: string,
- *   config?: object,
- *   logger?: object,
- *   spawnSync?: typeof execFileSync,
- *   gitSync?: (args: string[], opts: object) => string,
- * }} opts
- * @returns {{
- *   ran: boolean,
- *   committed: boolean,
- *   sha?: string,
- *   modifiedPaths?: string[],
- *   reason?: string,
- * }}
- */
-export function runScopedFormatAutofix({
-  cwd,
-  worktreePath,
-  storyId,
-  epicBranch,
-  storyBranch,
-  config,
-  logger = DefaultLogger,
-  spawnSync = execFileSync,
-  gitSync,
-} = {}) {
-  if (!cwd) throw new Error('runScopedFormatAutofix: cwd is required');
-  if (!epicBranch)
-    throw new Error('runScopedFormatAutofix: epicBranch is required');
-  if (!storyBranch)
-    throw new Error('runScopedFormatAutofix: storyBranch is required');
-
-  // Story #3907 — the formatter writes + the commit must land in the Story
-  // worktree, never the main checkout. Fall back to `cwd` only for callers
-  // that do not run under worktree isolation.
-  const workTree = worktreePath || cwd;
-
-  const git = gitSync ?? ((args, opts) => spawnSync('git', args, opts));
-
-  // Resolve the formatter base command (e.g. `npx biome format --write`).
-  // We drop a trailing `.` so we can append the changed-file set explicitly.
-  const { writeCmdString, writeCmd, writeArgs } = resolveFormatterCmd({
-    commands: config?.project?.commands,
-    dropTrailingDot: true,
-  });
-
-  const changed = listChangedFiles({
-    cwd: workTree,
-    epicBranch,
-    storyBranch,
-    git,
-  });
-  if (changed.length === 0) {
-    logger.info?.(
-      `${TAG} skipped — no changed files between ${epicBranch} and ${storyBranch}.`,
-    );
-    return { ran: false, committed: false, reason: 'no-changed-files' };
-  }
-
-  const dirtyBefore = listDirtyPaths(workTree, git);
-  if (dirtyBefore.length) {
-    logger.info?.(
-      `${TAG} skipped — working tree dirty before scoped autofix (${dirtyBefore.length} paths).`,
-    );
-    return { ran: false, committed: false, reason: 'dirty-tree' };
-  }
-
-  // Run the formatter against the changed-file set. We tolerate non-zero
-  // exit because the downstream check gate is the source of truth for
-  // "did formatting succeed".
-  try {
-    spawnSync(writeCmd, [...writeArgs, ...changed], {
-      cwd: workTree,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      encoding: 'utf8',
-    });
-  } catch (err) {
-    logger.warn?.(
-      `${TAG} \`${writeCmdString}\` on ${changed.length} changed file(s) exited non-zero (${err?.status ?? 'unknown'}); falling through to the format check gate.`,
-    );
-  }
-
-  const dirtyAfter = listDirtyPaths(workTree, git);
-  if (!dirtyAfter.length) {
-    logger.info?.(
-      `${TAG} no format drift on ${changed.length} changed file(s).`,
-    );
-    return { ran: true, committed: false };
-  }
-
-  // Story #3907 — assert the worktree is actually on `storyBranch` before we
-  // stage + commit. Without this guard a stale-state checkout (or a
-  // mis-wired `cwd`) could absorb the autofix onto the wrong branch (incl.
-  // `main`). A mismatch refuses to commit and leaves the format drift for the
-  // downstream check gate to surface.
-  const onBranch = currentBranch(workTree, git);
-  if (onBranch !== storyBranch) {
-    logger.warn?.(
-      `${TAG} refusing to commit — worktree ${workTree} is on "${onBranch ?? 'unknown'}", expected "${storyBranch}". ` +
-        `${dirtyAfter.length} format-drift path(s) left for the check gate.`,
-    );
-    return { ran: true, committed: false, reason: 'wrong-branch' };
-  }
-
-  // Stage every modified path and commit. Hooks must run; do not pass
-  // --no-verify (project policy: never skip git hooks).
-  const subject = `fix(story-close): auto-apply biome format in scoped lint (story #${storyId})`;
-  const sha = commitDirtyPaths({ cwd: workTree, git, subject });
-
-  // The warn-level emission is the Tech Spec contract — operators read
-  // this line in the close transcript to know auto-fix landed in the
-  // close commit, and downstream ledger inspectors filter on it.
-  logger.warn?.(
-    `${TAG} auto-applied biome format to ${dirtyAfter.length} path(s) on story #${storyId}: ${dirtyAfter.join(', ')}; committed as ${sha}.`,
-  );
-  return { ran: true, committed: true, sha, modifiedPaths: dirtyAfter };
-}

package/.agents/scripts/lib/orchestration/story-close/format-autofix-shared.js

@@ -1,123 +0,0 @@
-/**
- * format-autofix-shared.js — Story #3332 (Epic #3316): single-source the
- * git/formatter plumbing shared by the two format-autofix forks.
- *
- * `format-autofix.js` (whole-tree heal) and `format-autofix-scoped.js`
- * (Epic→Story changed-file heal) historically each carried their own copy
- * of the porcelain-status parse, the formatter-command resolution, and the
- * stage→commit→rev-parse sequence. The three forked helpers are
- * byte-for-byte equivalent apart from cosmetics, so a fix to (say) the
- * porcelain-line slice had to land twice. This module is the single home
- * for all three; the two forks now differ only in file-scope, commit
- * subject, and log level.
- *
- * Every helper takes an injected `git` runner (`(args, opts) => string`) so
- * unit tests pin behaviour without spawning git.
- */
-
-import { resolveFormatWriteCommand } from '../../close-validation.js';
-
-/**
- * Run `git status --porcelain` and return the list of changed paths.
- *
- * Porcelain lines are `XY <path>` — exactly two status chars, one space,
- * then the path. Leading whitespace inside the status pair is significant
- * (e.g. ` M file` for unstaged-modified) so we slice a fixed 3 chars off
- * the front rather than trimming.
- *
- * @param {string} cwd
- * @param {(args: string[], opts: object) => string} git
- * @returns {string[]}
- */
-export function listDirtyPaths(cwd, git) {
-  const out = git(['status', '--porcelain'], {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  return out
-    .split('\n')
-    .filter((line) => line.length >= 4)
-    .map((line) => line.slice(3));
-}
-
-/**
- * Resolve the formatter write command from `project.commands.formatWrite`
- * (falling back to the historical `npx biome format --write .`) and split
- * it into an executable + argv pair ready for `execFileSync`.
- *
- * The whole-tree fork runs the command verbatim (keeping the trailing `.`
- * so biome formats the entire tree). The scoped fork appends an explicit
- * changed-file set, so it passes `dropTrailingDot: true` to strip the `.`
- * before its file list.
- *
- * @param {{
- *   commands?: object,
- *   dropTrailingDot?: boolean,
- * }} [opts]
- * @returns {{ writeCmdString: string, writeCmd: string, writeArgs: string[] }}
- */
-export function resolveFormatterCmd({
-  commands,
-  dropTrailingDot = false,
-} = {}) {
-  // `resolveFormatWriteCommand` reads `config.project.commands`; wrap the
-  // caller-supplied `commands` map into that canonical shape.
-  const writeCmdString = resolveFormatWriteCommand({ project: { commands } });
-  const parts = writeCmdString.split(/\s+/).filter(Boolean);
-  if (dropTrailingDot && parts[parts.length - 1] === '.') parts.pop();
-  const [writeCmd, ...writeArgs] = parts;
-  return { writeCmdString, writeCmd, writeArgs };
-}
-
-/**
- * Resolve the branch currently checked out at `cwd` via
- * `git rev-parse --abbrev-ref HEAD`. Returns the trimmed branch name, or
- * `null` when the call fails or the tree is in a detached-HEAD state
- * (`HEAD`). Used as the commit-target guard before
- * {@link commitDirtyPaths} writes a scoped-autofix commit, so the commit
- * can never land on the wrong branch (e.g. the main checkout's `main`).
- *
- * @param {string} cwd
- * @param {(args: string[], opts: object) => string} git
- * @returns {string|null}
- */
-export function currentBranch(cwd, git) {
-  try {
-    const out = git(['rev-parse', '--abbrev-ref', 'HEAD'], {
-      cwd,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const branch = (out ?? '').toString().trim();
-    if (!branch || branch === 'HEAD') return null;
-    return branch;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Stage every modified path (`git add -u`), commit with the caller-supplied
- * `subject`, and return the short HEAD SHA. Hooks must run; we never pass
- * `--no-verify` (project policy: never skip git hooks).
- *
- * @param {{
- *   cwd: string,
- *   git: (args: string[], opts: object) => string,
- *   subject: string,
- * }} opts
- * @returns {string} short HEAD SHA of the new commit
- */
-export function commitDirtyPaths({ cwd, git, subject }) {
-  git(['add', '-u'], { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-  git(['commit', '-m', subject], {
-    cwd,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  return git(['rev-parse', '--short', 'HEAD'], {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-  }).trim();
-}

package/.agents/scripts/lib/task-utils.js

@@ -1,26 +0,0 @@
-/**
- * task-utils.js
- *
- * Shared utilities for inspecting task objects throughout the pipeline.
- * Centralises the bookend-detection predicate so that any future addition of a
- * new bookend type only requires a change in one place.
- */
-
-/**
- * Returns true when the given task is a bookend (lifecycle-management) task.
- *
- * Bookend tasks are distinguished from regular development tasks by one of the
- * following flags being truthy:
- *   - isQA           — automated testing phase
- *   - isCodeReview   — architectural review phase
- *   - isRetro        — retrospective phase
- *   - isCloseSprint  — sprint close-out + tagging phase
- *
- * @param {object} task - A task object from the sprint manifest.
- * @returns {boolean}
- */
-export function isBookendTask(task) {
-  return Boolean(
-    task.isQA || task.isCodeReview || task.isRetro || task.isCloseSprint,
-  );
-}

package/.agents/scripts/story-deliver-prepare.js

@@ -1,267 +0,0 @@
-#!/usr/bin/env node
-/* node:coverage ignore file */
-
-/**
- * story-deliver-prepare.js — post-init / pre-implementation prep step.
- *
- * After `story-init.js` has prepared the worktree and the operator (or
- * sub-agent) has `cd`'d into the workCwd, this CLI consolidates the three
- * things `/story-deliver` Step 0.5/0.6 used to express in English prose:
- *
- *   1. Read the `story-init` structured comment off the Story ticket via
- *      `findStructuredComment`. The comment carries `workCwd`, the install
- *      tri-state, and the canonical task list — re-derived here so a
- *      resumed run doesn't have to retain `story-init` stdout.
- *
- *   2. Apply the `dependenciesInstalled` tri-state truth table:
- *        - `'true'`     → install already succeeded; skip.
- *        - `'false'`    → install was attempted and failed; run the install
- *                         command (default `npm ci`; `project.commands`
- *                         doesn't carry a dedicated `install` key today —
- *                         the `commands.test` adjacency is the spec hook for
- *                         a future override).
- *        - `'skipped'`  → no per-worktree install was performed (single-tree
- *                         or symlink/pnpm-store strategy); trust the strategy.
- *
- *   3. Render the initial Story-phase snapshot with every Story phase
- *      (init/implement/validate/close) pinned to `pending` and
- *      `phase: 'init'` via `upsertStoryRunProgress`. Story #3909 — this is
- *      render-only: no `story-run-progress` comment is posted (that redundant
- *      mid-flight surface was deleted).
- *
- * Stdout: a single JSON envelope `{ workCwd, dependenciesInstalled,
- * installAction, snapshot, renderedBody }` so the caller can decide what to
- * do next. `renderedBody` is the markdown body for the initial Story-phase
- * table — `/story-deliver` relays it as a chat message at the start of each
- * Story so operators see it before the first commit lands.
- */
-
-import { parseArgs } from 'node:util';
-
-import { runAsCli } from './lib/cli-utils.js';
-import { resolveConfig } from './lib/config-resolver.js';
-import { runInstallCommand } from './lib/install-cmd-parser.js';
-import {
-  defaultStoryPhases,
-  STORY_RUN_PROGRESS_TYPE,
-  upsertStoryRunProgress,
-} from './lib/orchestration/epic-runner/story-run-progress-writer.js';
-import { parseFencedJsonComment } from './lib/orchestration/structured-comment-parser.js';
-import { findStructuredComment } from './lib/orchestration/ticketing.js';
-import { createProvider } from './lib/provider-factory.js';
-import { notify } from './notify.js';
-
-const HELP = `Usage: node .agents/scripts/story-deliver-prepare.js \\
-  --story <id> [--cwd <workCwd>] [--skip-install] [--install-cmd "<cmd>"]
-
-Reads the story-init structured comment off Story #<id>, runs the install
-command when dependenciesInstalled === 'false', then renders the initial
-Story-phase snapshot (phase=init, every Story phase pending) for chat relay.
-No story-run-progress comment is posted (Story #3909).
-`;
-
-const VALID_INSTALLED_STATES = new Set(['true', 'false', 'skipped']);
-
-/**
- * Apply the dependenciesInstalled tri-state to derive the next install action.
- * Pure helper — exposes the Step 0.5 truth table as data so tests can pin
- * each branch without spinning up a child process.
- *
- * @param {'true' | 'false' | 'skipped'} dependenciesInstalled
- * @param {{ skipInstall?: boolean }} [options]
- * @returns {'skip' | 'install'}
- */
-export function deriveInstallAction(dependenciesInstalled, options = {}) {
-  if (!VALID_INSTALLED_STATES.has(dependenciesInstalled)) {
-    throw new RangeError(
-      `deriveInstallAction: dependenciesInstalled "${dependenciesInstalled}" must be one of: ${[...VALID_INSTALLED_STATES].join(', ')}`,
-    );
-  }
-  if (options.skipInstall) return 'skip';
-  return dependenciesInstalled === 'false' ? 'install' : 'skip';
-}
-
-/**
- * Resolve the install command to run when `dependenciesInstalled === 'false'`.
- * `project.commands` does not currently carry a dedicated install key,
- * so this defaults to `npm ci`. Operators can override per-invocation via
- * `--install-cmd` (mirrors the spec note about a `commands.test`-adjacent
- * future override).
- *
- * @param {{ override?: string }} [options]
- * @returns {string}
- */
-export function resolveInstallCommand(options = {}) {
-  const trimmed = options.override?.trim();
-  if (trimmed) {
-    return trimmed;
-  }
-  return 'npm ci';
-}
-
-/**
- * Hydrate the `story-init` payload off the Story ticket. Returns `null` when
- * the comment can't be located (the operator must run `story-init` first).
- *
- * @param {{ provider: object, storyId: number }} args
- * @returns {Promise<object | null>}
- */
-export async function readStoryInitComment({ provider, storyId }) {
-  const comment = await findStructuredComment(provider, storyId, 'story-init');
-  if (!comment) return null;
-  const payload = parseFencedJsonComment(comment);
-  if (!payload || typeof payload !== 'object') return null;
-  return payload;
-}
-
-/**
- * End-to-end prepare. DI-friendly: tests pass `provider`, `runner`, and
- * skip the real network/child-process side effects.
- *
- * @param {{
- *   storyId: number,
- *   cwd?: string,
- *   skipInstall?: boolean,
- *   installCmd?: string,
- *   provider?: object,
- *   runInstall?: (cmd: string, cwd: string) => { status: number, stderr?: string },
- * }} args
- * @returns {Promise<{
- *   storyId: number,
- *   workCwd: string,
- *   dependenciesInstalled: string,
- *   installAction: 'skip' | 'install',
- *   installCmd: string | null,
- *   installResult: { status: number, stderr?: string } | null,
- *   snapshot: object,
- *   renderedBody: string,
- * }>}
- */
-export async function runStoryDeliverPrepare(args) {
-  const {
-    storyId,
-    cwd: cwdOverride,
-    skipInstall = false,
-    installCmd: installCmdOverride,
-    provider: providerOverride,
-    runInstall: runInstallOverride,
-  } = args ?? {};
-
-  if (!Number.isInteger(storyId) || storyId <= 0) {
-    throw new TypeError(
-      'runStoryDeliverPrepare: --story must be a positive integer',
-    );
-  }
-
-  const config = providerOverride ? null : resolveConfig();
-  const provider = providerOverride ?? createProvider(config);
-  const notifyFn = providerOverride
-    ? null
-    : (ticketId, payload, opts = {}) =>
-        notify(ticketId, payload, {
-          config,
-          provider,
-          ...opts,
-        });
-
-  // 1. Hydrate the story-init payload off the Story ticket.
-  const initPayload = await readStoryInitComment({ provider, storyId });
-  if (!initPayload) {
-    throw new Error(
-      `runStoryDeliverPrepare: no story-init comment found on #${storyId}; ` +
-        `run \`node .agents/scripts/story-init.js --story ${storyId}\` first.`,
-    );
-  }
-  const dependenciesInstalled = String(
-    initPayload.dependenciesInstalled ?? 'skipped',
-  );
-  const workCwd = String(initPayload.workCwd ?? cwdOverride ?? process.cwd());
-
-  // 2. Apply the install tri-state.
-  const installAction = deriveInstallAction(dependenciesInstalled, {
-    skipInstall,
-  });
-  let installCmd = null;
-  let installResult = null;
-  if (installAction === 'install') {
-    installCmd = resolveInstallCommand({ override: installCmdOverride });
-    installResult = (runInstallOverride ?? runInstallCommand)(
-      installCmd,
-      workCwd,
-    );
-    if (installResult.status !== 0) {
-      throw new Error(
-        `runStoryDeliverPrepare: install command \`${installCmd}\` failed with status ${installResult.status}: ${installResult.stderr ?? ''}`,
-      );
-    }
-  }
-
-  // 3. Render the initial Story-phase snapshot (render-only; Story #3909
-  //    deleted the redundant story-run-progress comment).
-  //
-  //    Under the 3-tier hierarchy (Epic → Feature → Story) the
-  //    inline-acceptance Story is the only ticket shape: Stories have no
-  //    child Tasks, so the snapshot is always the Story-phase `phases[]`
-  //    shape (init/implement/validate/close pinned to `pending`).
-  const hierarchy = String(initPayload.hierarchy ?? '3-tier');
-  const branch = String(initPayload.storyBranch ?? `story-${storyId}`);
-
-  const phases = defaultStoryPhases();
-  const { body: renderedBody, payload: snapshot } =
-    await upsertStoryRunProgress({
-      provider,
-      storyId,
-      branch,
-      phase: 'init',
-      phases,
-      notify: notifyFn,
-    });
-
-  return {
-    storyId,
-    workCwd,
-    dependenciesInstalled,
-    installAction,
-    installCmd,
-    installResult,
-    hierarchy,
-    snapshot,
-    renderedBody,
-  };
-}
-
-export function parseArgv(argv) {
-  const { values } = parseArgs({
-    args: argv,
-    options: {
-      story: { type: 'string' },
-      cwd: { type: 'string' },
-      'skip-install': { type: 'boolean' },
-      'install-cmd': { type: 'string' },
-      help: { type: 'boolean' },
-    },
-    strict: false,
-  });
-  return {
-    help: Boolean(values.help),
-    storyId: Number.parseInt(values.story ?? '', 10),
-    cwd: values.cwd,
-    skipInstall: Boolean(values['skip-install']),
-    installCmd: values['install-cmd'],
-  };
-}
-
-export async function main(argv = process.argv.slice(2)) {
-  const parsed = parseArgv(argv);
-  if (parsed.help) {
-    process.stdout.write(HELP);
-    return;
-  }
-  const envelope = await runStoryDeliverPrepare(parsed);
-  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
-}
-
-// Re-export for symmetry with the other prepare-suite CLIs.
-export { STORY_RUN_PROGRESS_TYPE };
-
-runAsCli(import.meta.url, main, { source: 'story-deliver-prepare' });