mandrel 1.94.0 → 2.1.0

package/.agents/scripts/providers/github/tickets.js

@@ -8,13 +8,16 @@
  *
  * The gateway is constructed with a `{ gh, owner, repo, hooks }` object so
  * cross-gateway concerns can be threaded in without bloating the constructor
- * signature. Today the only hooks the ticket surface reaches for are
- * `addSubIssue` (from the future SubIssueGateway, used by `createTicket` to
- * link a freshly-created child as a native sub-issue) and `addItemToProject`
- * (from the projects-v2 shim, used by `createTicket` to add the new issue
- * to the configured Project V2).
+ * signature. The `addItemToProject` hook (from the projects-v2 shim) adds a
+ * newly-created issue to the configured Project V2.
  *
- * Public surface: `GitHubProvider.createTicket / createIssue / getTicket /
+ * Story #4545 deleted `createTicket` and its `composeStoryBody` helper — the
+ * Epic-hierarchy write surface. It composed the exact `Epic: #N` footer that
+ * `pr-base-guard.js` hard-refuses at delivery, so the framework retained the
+ * ability to generate work it would then reject; it had no production caller
+ * (`/plan` persists through the bare `createIssue` below).
+ *
+ * Public surface: `GitHubProvider.createIssue / getTicket /
  * getTickets / updateTicket / getTicketDependencies / primeTicketCache /
  * invalidateTicket` all delegate to the same-named methods on this class.
  *
@@ -22,9 +25,7 @@
  */
 
 import { parseBlockedBy, parseBlocks } from '../../lib/dependency-parser.js';
-import { stampFrameworkVersion } from '../../lib/framework-version.js';
 import { Logger } from '../../lib/Logger.js';
-import { TYPE_LABELS } from '../../lib/label-constants.js';
 import { addIssueToBoard } from './board-add.js';
 import { createInlineTicketCache } from './cache.js';
 import { withTransientRetry } from './errors.js';
@@ -43,70 +44,6 @@ import {
  */
 const SEARCH_PAGE_CAP = 10;
 
-/**
- * Compose the final markdown body for a created ticket. Under the 2-tier
- * hierarchy (Epic → Story), `body` is always a string supplied
- * by the caller (the decomposer, the spec planner, or the reconciler-apply
- * engine). This helper appends the canonical orchestrator footer
- * (`parent: #<n>` / `Epic: #<m>` / `blocked by #<x>`) byte-stable with the
- * format consumers (manifest, close-gate, dispatcher) parse.
- *
- * Story #3186 — inlined here when the Task-tier body-renderer helpers
- * were retired. The structured-body (object) path is gone: Stories carry
- * inline `acceptance[]` / `verify[]`
- * arrays on the Story body authored by the decomposer; there is no
- * server-side rendering of a four-section payload at create time.
- *
- * Story #4382 — this is also where a Story body is stamped, once, with the
- * running Mandrel framework version and authoring date (hidden `mandrel_version`
- * / `authored_at` meta field + a visible `> 🏷️ Authored with Mandrel …`
- * marker) via {@link stampFrameworkVersion}. The stamp is immutable: a body
- * that already carries a version (e.g. a reconciler re-create) is preserved
- * verbatim. The `stamp` override exists for deterministic tests; production
- * callers omit it so the running version and today's date are used.
- *
- * @param {{
- *   body: string,
- *   parentId: number,
- *   epicId?: number,
- *   dependencies?: number[],
- *   stamp?: { version?: string, authoredAt?: string } | false,
- * }} opts
- * @returns {string}
- *
- * Story #3958 — this is the single owner of the `blocked by #N` footer.
- * Callers (the reconciler-apply create path, the spec planner) pass
- * resolved dependency issue numbers via `dependencies` and supply a body
- * WITHOUT any pre-appended footer. A caller that also appends a
- * `blocked by` block to `body` would double every dependency line.
- */
-export function composeStoryBody({
-  body,
-  parentId,
-  epicId,
-  dependencies = [],
-  stamp,
-}) {
-  const rawHead = typeof body === 'string' ? body : '';
-  // `stamp === false` → footer-only recomposition: the caller (the reconciler
-  // UPDATE/diff path) owns stamp preservation itself and must NOT introduce a
-  // fresh authoring stamp, which would churn or bump the version on every
-  // reconcile. Every other call is a create — stamp once (immutably).
-  const head =
-    stamp === false ? rawHead : stampFrameworkVersion(rawHead, stamp ?? {});
-  const lines = ['---', `parent: #${parentId}`];
-  if (epicId !== undefined && epicId !== null) {
-    lines.push(`Epic: #${epicId}`);
-  }
-  if (dependencies.length > 0) {
-    lines.push('');
-    for (const dep of dependencies) {
-      lines.push(`blocked by #${dep}`);
-    }
-  }
-  return `${head}\n\n${lines.join('\n')}`;
-}
-
 export class TicketGateway {
   /**
    * @param {{
@@ -114,7 +51,6 @@ export class TicketGateway {
    *   owner: string,
    *   repo: string,
    *   hooks?: {
-   *     addSubIssue?: (parentNumber: number, childNodeId: string) => Promise<unknown>,
    *     addItemToProject?: (nodeId: string) => Promise<unknown>,
    *     getProjectNumber?: () => number|null,
    *   },
@@ -314,84 +250,10 @@ export class TicketGateway {
   // ---------------------------------------------------------------------------
 
   /**
-   * Create a new issue. Renders the body via the inline `composeStoryBody`
-   * helper so the `parent: #N` / `Epic: #M` / `blocked by #X` footer is
-   * consistent across creators.
-   *
-   * After the POST, opportunistically link the child as a native sub-issue
-   * (via the `addSubIssue` hook — retried internally on the sub-issue
-   * gateway) and add it to the configured Project V2 (best-effort —
-   * failures warn but do not fail the create).
-   *
-   * @field-manifest POST /repos/{owner}/{repo}/issues: number, id, node_id,
-   *                 html_url
-   */
-  /* node:coverage ignore next */
-  async createTicket(parentId, ticketData) {
-    const epicId = ticketData.epicId || parentId;
-    const renderedBody = composeStoryBody({
-      body: ticketData.body ?? '',
-      parentId,
-      epicId,
-      dependencies: ticketData.dependencies ?? [],
-    });
-
-    // Mirror the Epic create path (issues.js:160 → `labels: TYPE_LABELS.EPIC`):
-    // inject TYPE_LABELS.STORY so a spec that omits the labels array cannot
-    // produce an unlabeled, undispatchable Story. Dedupe to avoid duplicates
-    // when the caller already carries the label. (Story #4324 retired the
-    // `context::*` ticket classes, so every ticket created through this
-    // factory is a Story.)
-    const callerLabels = ticketData.labels ?? [];
-    const labels = callerLabels.includes(TYPE_LABELS.STORY)
-      ? callerLabels
-      : [TYPE_LABELS.STORY, ...callerLabels];
-    const result = await this._gh.api({
-      method: 'POST',
-      endpoint: `/repos/${this.owner}/${this.repo}/issues`,
-      body: {
-        title: ticketData.title,
-        body: renderedBody,
-        labels,
-      },
-    });
-    const issue = parseApiJson(result);
-    this._listCache.clear();
-
-    let subIssueLinked = false;
-    let subIssueError = null;
-    try {
-      if (typeof this._hooks.addSubIssue === 'function') {
-        await this._hooks.addSubIssue(parentId, issue.node_id);
-        subIssueLinked = true;
-      }
-    } catch (err) {
-      subIssueError = err;
-    }
-
-    await addIssueToBoard({
-      nodeId: issue.node_id,
-      issueNumber: issue.number,
-      getProjectNumber: this._hooks.getProjectNumber,
-      addItemToProject: this._hooks.addItemToProject,
-    });
-
-    return {
-      id: issue.number,
-      internalId: issue.id,
-      nodeId: issue.node_id,
-      url: issue.html_url,
-      subIssueLinked,
-      subIssueError,
-    };
-  }
-
-  /**
-   * Create a **bare** issue — no `parent: #N` footer composition and no
-   * sub-issue link. Serves the standalone create paths that bypass
-   * `createTicket`'s Story-shaped body rendering: the `/plan`
-   * persist step and the `/plan` Phase 4 Epic open
-   * (`openEpicFromOnePager`'s `createIssue` port).
+   * Create a **bare** issue — no footer composition and no sub-issue link.
+   * Since Story #4545 this is the *only* create path: `/plan` persist and the
+   * `/plan` Phase 4 Epic open (`openEpicFromOnePager`'s `createIssue` port)
+   * both route through it.
    *
    * After the POST, the new issue is added to the configured Project V2
    * board via the shared `addIssueToBoard` helper (Story #3822) —
@@ -399,6 +261,17 @@ export class TicketGateway {
    * so board membership never depends on GitHub's "Auto-add to project"
    * built-in workflow.
    *
+   * The POST is wrapped in `withTransientRetry` (Story #4541) so it absorbs
+   * the same 502/429/ECONNRESET blips the read surfaces already do. It used
+   * to post bare, which made a single transient failure at story *k* of *N*
+   * abort `/plan` persist with `1..k-1` already live on the tracker.
+   *
+   * Retry alone is not sufficient for that failure mode — a POST whose
+   * response is lost would double-create on the retry — so the caller
+   * (`plan-persist`'s `createStoryIssues`) carries the idempotency half via
+   * a plan fingerprint it looks up before creating. Retry narrows the
+   * window; the fingerprint closes it.
+   *
    * @field-manifest POST /repos/{owner}/{repo}/issues: number, id, node_id,
    *                 html_url
    *
@@ -413,11 +286,15 @@ export class TicketGateway {
    * }>}
    */
   async createIssue({ title, body, labels = [] }) {
-    const result = await this._gh.api({
-      method: 'POST',
-      endpoint: `/repos/${this.owner}/${this.repo}/issues`,
-      body: { title, body, labels },
-    });
+    const result = await withTransientRetry(
+      () =>
+        this._gh.api({
+          method: 'POST',
+          endpoint: `/repos/${this.owner}/${this.repo}/issues`,
+          body: { title, body, labels },
+        }),
+      { label: `createIssue "${title}"`, onRetry: defaultRetryWarn },
+    );
     const issue = parseApiJson(result);
     this._listCache.clear();
 

package/.agents/scripts/providers/github.js

@@ -80,9 +80,23 @@ export class GitHubProvider extends ITicketingProvider {
     return this._memoizedToken;
   }
 
-  /* node:coverage ignore next */
-  async listIssues(filters = {}) {
-    return this.getEpics(filters);
+  /**
+   * The identifiers a native dependency-edge writer needs, handed over as an
+   * explicit interface (Story #4544).
+   *
+   * `providers/github/blocked-by-add.js` talks to the dependencies REST API
+   * directly, so it needs the `gh` facade plus `owner`/`repo` — none of which
+   * the `ITicketingProvider` surface exposes. Its caller lives in the
+   * orchestration layer (`plan-persist/story-ops.js`), and the alternative was
+   * for that caller to reach through `provider._gh` — a private-by-convention
+   * field — from outside this module. Naming the hand-off here keeps the
+   * coupling declared and greppable instead of incidental: the provider
+   * decides what it lends out, and the field stays private.
+   *
+   * @returns {{ gh: object, owner: string, repo: string }}
+   */
+  getDependencyWriteContext() {
+    return { gh: this._gh, owner: this.owner, repo: this.repo };
   }
 
   static isInsufficientScopes(err) {
@@ -100,7 +114,6 @@ const DELEGATIONS = [
   ['graphql', 'issues.ghGraphql'],
   ['searchIssues', 'issues.searchIssues'],
   ['listIssuesByLabel', 'issues.listIssuesByLabel'],
-  ['getEpics', 'issues.getEpics'],
   ['getEpic', 'issues.getEpic'],
   ['branchExists', 'issues.branchExists'],
   ['getSubTickets', 'issues.getSubTickets'],
@@ -108,12 +121,10 @@ const DELEGATIONS = [
   ['getTickets', 'tickets.getTickets'],
   ['getTicket', 'tickets.getTicket'],
   ['getTicketDependencies', 'tickets.getTicketDependencies'],
-  ['createTicket', 'tickets.createTicket'],
   ['createIssue', 'tickets.createIssue'],
   ['updateTicket', 'tickets.updateTicket'],
   ['_applyLabelMutations', 'tickets._applyLabelMutations'],
   ['_getNativeSubIssues', 'subIssues.getNativeSubIssues'],
-  ['_getNativeParent', 'subIssues.getNativeParent'],
   ['addSubIssue', 'subIssues.addSubIssue'],
   ['removeSubIssue', 'subIssues.removeSubIssue'],
   ['reconcileSubIssueLinks', 'subIssues.reconcileSubIssueLinks'],

package/.agents/scripts/resolve-stories.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+/**
+ * resolve-stories.js — resolve a list of Story ids into the
+ * `{ stories, dag, done }` envelope `/deliver` sequences from.
+ *
+ * This is the ONE resolution step for multi-Story delivery. `/deliver` takes
+ * only Story ids; the graph is discovered here, from live state, rather than
+ * hand-transcribed by the host or implied by a batch label.
+ *
+ * What it resolves, per Story:
+ *   - the issue itself, fetched with **state=all** so an already-landed
+ *     sibling is present rather than silently dropped;
+ *   - its dependency edges: the union of body-parsed `blocked by #N` /
+ *     `depends on #N` and native GitHub `blocked_by` edges;
+ *   - its declared file footprint, as plain path strings, so the scheduler's
+ *     co-dispatch overlap guard has something to work with.
+ *
+ * And across the set: every dependency id — inside the requested set or
+ * foreign to it — is checked against live issue state, and a blocker that is
+ * closed or `agent::done` lands in `done[]`. That is what makes "deliver
+ * Stories across plan runs and over time" work: a Story whose blocker merged
+ * weeks ago in a different run is simply ready.
+ *
+ * Usage:
+ *   node .agents/scripts/resolve-stories.js --ids 101,102
+ *   node .agents/scripts/resolve-stories.js --ids 101,102 --pretty
+ *   node .agents/scripts/resolve-stories.js --ids 101 --no-native   # skip the dependencies API
+ *
+ * Exit codes: 0 ok, 1 usage/resolution error.
+ */
+
+import { parseArgs } from 'node:util';
+
+import { runAsCli } from './lib/cli-utils.js';
+import { resolveConfig } from './lib/config-resolver.js';
+import { Logger, routeAllOutputToStderr } from './lib/Logger.js';
+import {
+  buildStoriesEnvelope,
+  isSatisfiedBlocker,
+  parseIds,
+  readNativeBlockedBy,
+  toStoryRecord,
+} from './lib/orchestration/resolve-stories.js';
+import { createProvider } from './lib/provider-factory.js';
+import { concurrentMap } from './lib/util/concurrent-map.js';
+import { parseApiJson } from './providers/github/request-helpers.js';
+
+export { buildStoriesEnvelope, parseIds, readNativeBlockedBy, toStoryRecord };
+
+/**
+ * Bounded concurrency for the per-issue round-trips. Matches the edge-writer's
+ * cap: modest enough for GitHub's secondary rate limits, while collapsing
+ * wall-clock from sum(round-trips) toward sum/concurrency.
+ */
+const FETCH_CONCURRENCY = 5;
+
+const HELP = `\
+Usage:
+  resolve-stories.js --ids <n,n,...> [--pretty] [--no-native]
+
+Resolve Story ids into the { stories, dag, done } envelope /deliver sequences
+from. Dependencies are discovered from live state: body edges union native
+blocked_by edges, with every blocker (in-set or foreign) resolved against its
+real issue state.
+
+Options:
+  --ids <csv>    Comma-separated Story issue numbers. Required.
+  --pretty       Pretty-print the JSON envelope.
+  --no-native    Skip the native blocked_by read (body edges only).
+  --help         Show this help.
+`;
+
+/**
+ * @param {object} [deps]
+ * @returns {{ provider: object, config: object }}
+ */
+export function resolveStoriesProvider({
+  resolveConfigFn = resolveConfig,
+  createProviderFn = createProvider,
+} = {}) {
+  const config = resolveConfigFn();
+  return { provider: createProviderFn(config), config };
+}
+
+/**
+ * Fetch every requested id and map it to a Story record, failing on the first
+ * id that is not a deliverable Story.
+ *
+ * @param {object} provider
+ * @param {number[]} ids
+ * @returns {Promise<object[]>}
+ */
+export async function fetchStories(provider, ids) {
+  return concurrentMap(
+    ids,
+    async (id) => {
+      const issue = await provider.getTicket(id);
+      if (!issue) {
+        throw new Error(`[resolve-stories] Issue #${id} was not found.`);
+      }
+      return toStoryRecord(issue, id);
+    },
+    { concurrency: FETCH_CONCURRENCY },
+  );
+}
+
+/**
+ * Read native blocked_by edges for every Story in the set.
+ *
+ * @returns {Promise<Map<number, number[]>>}
+ */
+export async function readNativeEdges({ provider, stories, owner, repo }) {
+  const entries = await concurrentMap(
+    stories,
+    async (story) => [
+      story.id,
+      await readNativeBlockedBy({
+        gh: provider._gh,
+        owner,
+        repo,
+        issueNumber: story.id,
+        parseJson: parseApiJson,
+      }),
+    ],
+    { concurrency: FETCH_CONCURRENCY },
+  );
+  return new Map(entries);
+}
+
+/**
+ * Resolve dependency ids that are NOT in the requested set against live issue
+ * state. A foreign blocker that already landed must enter `done[]`, or the
+ * scheduler withholds its dependent forever — the exact wedge that made
+ * cross-run delivery impossible.
+ *
+ * A foreign id that cannot be read is left OUT of `done[]`: unknown means
+ * "still gating", which withholds the dependent rather than dispatching it
+ * against a possibly-unlanded blocker.
+ *
+ * @returns {Promise<number[]>}
+ */
+export async function resolveForeignDone({ provider, dag, inSetIds }) {
+  const foreign = [
+    ...new Set(
+      dag.flatMap((node) => node.dependsOn).filter((dep) => !inSetIds.has(dep)),
+    ),
+  ];
+  if (foreign.length === 0) return [];
+  const resolved = await concurrentMap(
+    foreign,
+    async (id) => {
+      try {
+        const issue = await provider.getTicket(id);
+        return isSatisfiedBlocker(issue) ? id : null;
+      } catch (err) {
+        Logger.warn(
+          `[resolve-stories] Could not read foreign blocker #${id} (${err?.message ?? err}) — ` +
+            `treating it as still gating.`,
+        );
+        return null;
+      }
+    },
+    { concurrency: FETCH_CONCURRENCY },
+  );
+  return resolved.filter((id) => id !== null);
+}
+
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      ids: { type: 'string' },
+      pretty: { type: 'boolean', default: false },
+      native: { type: 'boolean', default: true },
+      help: { type: 'boolean', default: false },
+    },
+    // The documented opt-out is `--no-native`; without allowNegative,
+    // parseArgs rejects it as an unknown option and the CLI has no working
+    // way to skip the dependencies API.
+    allowNegative: true,
+    allowPositionals: false,
+  });
+
+  if (values.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (!values.ids) {
+    process.stderr.write(HELP);
+    throw new Error('[resolve-stories] --ids <n,n,...> is required');
+  }
+
+  // stdout is a JSON stream — keep human-readable output on stderr so a
+  // headless caller can pipe this straight into stories-wave-tick.js.
+  routeAllOutputToStderr();
+
+  const ids = parseIds(values.ids);
+  const { provider, config } = resolveStoriesProvider();
+  const owner = config.github?.owner;
+  const repo = config.github?.repo;
+
+  const stories = await fetchStories(provider, ids);
+  const nativeEdges = values.native
+    ? await readNativeEdges({ provider, stories, owner, repo })
+    : new Map();
+
+  const inSetIds = new Set(stories.map((s) => s.id));
+  const provisional = buildStoriesEnvelope({
+    stories,
+    nativeEdges,
+    warn: (m) => Logger.warn(m),
+  });
+  const foreignDone = await resolveForeignDone({
+    provider,
+    dag: provisional.dag,
+    inSetIds,
+  });
+  const envelope = buildStoriesEnvelope({
+    stories,
+    nativeEdges,
+    foreignDone,
+    warn: () => {},
+  });
+
+  process.stdout.write(
+    values.pretty
+      ? `${JSON.stringify(envelope, null, 2)}\n`
+      : `${JSON.stringify(envelope)}\n`,
+  );
+  return 0;
+}
+
+runAsCli(import.meta.url, main, {
+  source: 'resolve-stories',
+  propagateExitCode: true,
+});

package/.agents/scripts/run-coverage.js

@@ -45,6 +45,7 @@ import { fileURLToPath } from 'node:url';
 
 import { cleanupRepoTestTempArtifacts } from './cleanup-repo-test-temp.js';
 import { C8_CLI } from './lib/c8-cli-path.js';
+import { buildWebhookSafeTestEnv } from './lib/test-env.js';
 import { TEST_RUNNER_FLAGS } from './run-tests.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -89,7 +90,9 @@ function runCoveragePipeline() {
   const testRun = spawnSync(process.execPath, buildCoverageTestArgs(), {
     cwd: ROOT,
     stdio: 'inherit',
-    env: { ...process.env, NODE_V8_COVERAGE: V8_TMP },
+    // GIT_*-scrubbed: under a husky pre-push from a linked worktree the
+    // inherited GIT_DIR poisons fixture `git init` runs (#4580).
+    env: { ...buildWebhookSafeTestEnv(process.env), NODE_V8_COVERAGE: V8_TMP },
   });
 
   cleanupRepoTestTempArtifacts({ repoRoot: ROOT });

package/.agents/scripts/run-lint.js

@@ -73,8 +73,8 @@ const tasks = [
     // spans for axis-shaped tokens (`type/epic`, etc.) and asserts
     // only the canonical `<axis>::<value>` separator from
     // `lib/label-constants.js` appears. Closes the drift gap that
-    // let the original `type/epic` typo land at
-    // `.agents/workflows/helpers/plan-epic.md:49`.
+    // let the original `type/epic` typo land in a since-retired
+    // planning workflow helper.
     name: 'label-vocabulary',
     cmd: 'node',
     args: ['.agents/scripts/lint-label-vocabulary.js'],

package/.agents/scripts/run-verify.js

@@ -5,14 +5,28 @@
  * Local full verification — a true CI mirror for the gates that CAN be proven
  * locally, without epic-scoped MI projection or push semantics.
  *
- * Order: audit (SCA) → lint (includes docs:check) → full test suite →
- * unified baselines.
+ * Order: audit (SCA) → lint (includes docs:check + the arch-cycles ratchet) →
+ * full test suite → unified baselines → the dead-exports and context-budget
+ * ratchets.
  *
  * The `audit` step runs `npm audit --audit-level=high`, matching CI's
  * "Dependency Vulnerability Audit (SCA)" gate so a local green no longer hides
  * a high-severity advisory that CI would fail on. It is independent of the
  * pre-push `PREPUSH_AUDIT` opt-in, which stays unchanged.
  *
+ * The trailing ratchets complete the mirror of CI's "Architecture Cycle Check"
+ * step in the `baselines` job (Story #4549). That step runs three checks;
+ * `check-arch-cycles.js` is deliberately absent from STEPS because the `lint`
+ * step above already runs it (see run-lint.js) — re-running it here would
+ * double-pay a gate verify already covers. `check-dead-exports.js` and
+ * `check-context-budget.js` had no such cover: they were reachable locally only
+ * via the diff-scoped `npm run quality:preview` or a direct invocation, so a
+ * clean `verify` could still hide a CI-red — the failure Story #4531 / PR #4548
+ * paid for with a full push → CI → fix → push round-trip. Both are pure-Node
+ * and baseline-aware, adding ~15s on a cold cache (dominated by knip's
+ * full-tree scan in check-dead-exports.js) to a command that already carries
+ * the full test suite.
+ *
  * A handful of CI gates cannot be reproduced by this command (action pinning,
  * TruffleHog secret scan, the BASELINE_SCOPE=full push-scoped maintainability
  * run) — those are catalogued in docs/ci-contract.md.
@@ -34,6 +48,21 @@ const STEPS = [
     cmd: 'node',
     args: ['.agents/scripts/check-baselines.js'],
   },
+  {
+    label: 'dead-exports',
+    cmd: 'node',
+    args: ['.agents/scripts/check-dead-exports.js'],
+  },
+  {
+    label: 'dead-exports-production',
+    cmd: 'node',
+    args: ['.agents/scripts/check-dead-exports.js', '--production'],
+  },
+  {
+    label: 'context-budget',
+    cmd: 'node',
+    args: ['.agents/scripts/check-context-budget.js'],
+  },
 ];
 
 export function runVerifySteps({