mandrel 2.31.0 → 2.32.0

package/.agents/scripts/lib/bdd-step-index.js

@@ -0,0 +1,326 @@
+/**
+ * bdd-step-index.js — scoped discovery and matching for BDD step definitions.
+ *
+ * `check-gherkin-corpus.js` answers one question per Gherkin step: does a step
+ * definition **under this step's own scope** claim it? That question has two
+ * halves, and this module owns both so the corpus gate never re-implements
+ * either inline:
+ *
+ *   1. **Discovery** — which files under a scope's `stepRoots` hold step
+ *      definitions, and which `.feature` files sit under its `featureRoots`.
+ *      Feature discovery is delegated to `listFeatureFiles` in
+ *      `bdd-scenario-scanner.js` rather than copied: /plan's scenario index and
+ *      this gate must agree on what counts as a feature file, and two walkers
+ *      would eventually disagree.
+ *   2. **Matching** — turn each definition's Cucumber expression or regular
+ *      expression into one `RegExp`, and test a step's text against the index.
+ *
+ * ## Heuristic index, exact parser
+ *
+ * The parser half of the gate is exact: `@cucumber/gherkin` decides what
+ * compiles. This half is deliberately **not**. Reading step definitions
+ * without executing them means a regex scan over source text, and a scan
+ * cannot see a definition assembled at runtime, registered through a wrapper,
+ * or parameterised by a custom `defineParameterType`. That asymmetry is why
+ * the gate ships a step-waiver list: a false "unbound" must always have an
+ * escape that does not require switching the whole gate off.
+ *
+ * Supported Cucumber-expression constructs are the ones the built-in parameter
+ * types and the optional/alternation syntax cover — `{int}`, `{float}`,
+ * `{word}`, `{string}`, an anonymous `{}`, `text(s)` optionals, and `a/an`
+ * word alternation. An unrecognised `{custom}` degrades to `(.*)` rather than
+ * failing to match, because over-matching produces a missed finding while
+ * under-matching produces a false one, and a false one blocks a delivery.
+ *
+ * Nothing here reads configuration or exits a process; the CLI owns both.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+import { listFeatureFiles } from './bdd-scenario-scanner.js';
+
+export { listFeatureFiles };
+
+/** Extensions a step-definition module may carry. */
+const STEP_FILE_EXTENSIONS = Object.freeze([
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.ts',
+  '.mts',
+  '.cts',
+  '.tsx',
+]);
+
+/** Directory names never walked when looking for step definitions. */
+const SKIPPED_DIRECTORIES = Object.freeze(
+  new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage']),
+);
+
+/**
+ * Regular expressions for the built-in Cucumber parameter types, keyed by the
+ * name inside the braces. The empty key is the anonymous `{}` parameter and
+ * doubles as the fallback for a custom type this scan cannot resolve.
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+const PARAMETER_PATTERNS = Object.freeze({
+  '': '(.*)',
+  int: '(-?\\d+)',
+  float: '(-?\\d*\\.?\\d+)',
+  word: '([^\\s]+)',
+  string: '("[^"]*"|\'[^\']*\')',
+});
+
+/**
+ * Step-registration call sites this scan recognises. `Step` and `defineStep`
+ * cover the generic registrars playwright-bdd and cucumber-js both expose.
+ *
+ * Group 2/3 capture a quoted expression, group 4/5 a regular-expression
+ * literal with its flags.
+ */
+const STEP_CALL_PATTERN =
+  /\b(Given|When|Then|And|But|Step|defineStep)\s*\(\s*(?:(['"`])((?:\\.|(?!\2)[^\\])*)\2|\/((?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\\[])+)\/([dgimsuvy]*))/g;
+
+/** Escape one character for literal use inside a regular expression. */
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Render one alternation-free segment of a Cucumber expression: parameter
+ * placeholders become capture groups, `(optional)` runs become optional
+ * groups, and everything else is escaped literal text.
+ *
+ * @param {string} segment
+ * @returns {string}
+ */
+function renderSegment(segment) {
+  let out = '';
+  let i = 0;
+  while (i < segment.length) {
+    const ch = segment[i];
+    if (ch === '\\' && i + 1 < segment.length) {
+      out += escapeRegExp(segment[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (ch === '{') {
+      const end = segment.indexOf('}', i);
+      if (end !== -1) {
+        const name = segment.slice(i + 1, end);
+        out += PARAMETER_PATTERNS[name] ?? PARAMETER_PATTERNS[''];
+        i = end + 1;
+        continue;
+      }
+    }
+    if (ch === '(') {
+      const end = segment.indexOf(')', i);
+      if (end !== -1) {
+        out += `(?:${renderSegment(segment.slice(i + 1, end))})?`;
+        i = end + 1;
+        continue;
+      }
+    }
+    out += escapeRegExp(ch);
+    i += 1;
+  }
+  return out;
+}
+
+/**
+ * Split a word on unescaped `/` so `a/an` becomes two alternatives. Escaped
+ * `\/` stays literal.
+ *
+ * @param {string} word
+ * @returns {string[]}
+ */
+function splitAlternation(word) {
+  const parts = [];
+  let current = '';
+  for (let i = 0; i < word.length; i += 1) {
+    const ch = word[i];
+    if (ch === '\\' && i + 1 < word.length) {
+      current += ch + word[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === '/') {
+      parts.push(current);
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts;
+}
+
+/**
+ * Compile a Cucumber expression into an anchored `RegExp`.
+ *
+ * Alternation is resolved per whitespace-separated word, which is what the
+ * real expression grammar does. Resolving it across the whole string instead
+ * would turn `I have a/an apple` into `^I have a|an apple$` — two anchored
+ * alternatives, neither of them the intended step.
+ *
+ * @param {string} expression
+ * @returns {RegExp}
+ */
+function expressionToRegExp(expression) {
+  const tokens = String(expression).split(/(\s+)/);
+  const body = tokens
+    .map((token) => {
+      if (token.length === 0) return '';
+      if (/^\s+$/.test(token)) return escapeRegExp(token);
+      const alternatives = splitAlternation(token);
+      const rendered = alternatives.map(renderSegment);
+      return rendered.length > 1 ? `(?:${rendered.join('|')})` : rendered[0];
+    })
+    .join('');
+  return new RegExp(`^${body}$`);
+}
+
+/**
+ * Recursively list step-definition source files under the given roots.
+ *
+ * Deliberately not `walkFilesByExtension` from `fs-walk.js`, which is the
+ * shared walker for the lint surfaces. That one matches a single extension and
+ * walks everything below the root, so reusing it here would mean seven passes
+ * — one per accepted extension — each of them descending into a `node_modules`
+ * a consumer's step root may well contain. It also rethrows every non-ENOENT
+ * `readdir` failure, where this walker must skip an unreadable directory: an
+ * unreadable *scope* has to surface as "zero step definitions", the gate's
+ * fail-closed path, which names the scope and its step roots.
+ *
+ * @param {string[]} roots absolute or cwd-relative directories
+ * @returns {string[]} absolute paths, sorted
+ */
+export function listStepFiles(roots) {
+  const found = [];
+  for (const root of roots ?? []) {
+    walkStepDir(path.resolve(root), found);
+  }
+  return found.sort();
+}
+
+function walkStepDir(dir, acc) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    // `withFileTypes` reports a symlink as neither file nor directory, so
+    // fall back to a stat for those rather than dropping them silently.
+    const isDir =
+      entry.isDirectory() || (entry.isSymbolicLink() && isDirAt(full));
+    if (isDir) {
+      if (!SKIPPED_DIRECTORIES.has(entry.name)) walkStepDir(full, acc);
+      continue;
+    }
+    if (STEP_FILE_EXTENSIONS.includes(path.extname(entry.name))) acc.push(full);
+  }
+}
+
+function isDirAt(target) {
+  try {
+    return statSync(target).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract every step registration in one source file.
+ *
+ * @param {string} source file contents
+ * @param {string} file absolute path, recorded on each entry
+ * @returns {Array<{ file: string, line: number, source: string, regex: RegExp }>}
+ */
+function parseStepDefinitions(source, file) {
+  const entries = [];
+  STEP_CALL_PATTERN.lastIndex = 0;
+  let match = STEP_CALL_PATTERN.exec(source);
+  while (match !== null) {
+    const [, , , quoted, pattern, flags] = match;
+    const line = source.slice(0, match.index).split('\n').length;
+    const regex = compileMatcher({ quoted, pattern, flags });
+    if (regex) entries.push({ file, line, source: quoted ?? pattern, regex });
+    match = STEP_CALL_PATTERN.exec(source);
+  }
+  return entries;
+}
+
+/**
+ * Build one matcher from a captured registration. A malformed regular
+ * expression yields `null` — the definition is skipped rather than crashing
+ * the scan, and the steps it would have claimed surface as unbound, which is
+ * the safe direction.
+ */
+function compileMatcher({ quoted, pattern, flags }) {
+  if (typeof quoted === 'string') {
+    try {
+      return expressionToRegExp(quoted);
+    } catch {
+      return null;
+    }
+  }
+  try {
+    // `g` and `y` are stateful across `.test()` calls; strip them so the index
+    // cannot depend on how many times it has been consulted.
+    return new RegExp(pattern, (flags ?? '').replace(/[gy]/g, ''));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the step index for one scope.
+ *
+ * @param {{ files: string[], readFile?: (p: string) => string }} params
+ * @returns {{ entries: Array<{ file: string, line: number, source: string, regex: RegExp }>, files: string[] }}
+ */
+export function buildStepIndex({ files, readFile }) {
+  const read = readFile ?? ((p) => readFileSync(p, 'utf8'));
+  const entries = [];
+  for (const file of files ?? []) {
+    let source;
+    try {
+      source = read(file);
+    } catch {
+      continue;
+    }
+    entries.push(...parseStepDefinitions(source, file));
+  }
+  return { entries, files: [...(files ?? [])] };
+}
+
+/**
+ * Find the first definition in the index claiming `text`.
+ *
+ * @param {{ entries: Array<{ regex: RegExp }> }} index
+ * @param {string} text the step text, keyword already stripped by the parser
+ * @returns {object | null} the matching entry, or `null` when nothing claims it
+ */
+export function matchStep(index, text) {
+  for (const entry of index?.entries ?? []) {
+    if (entry.regex.test(text)) return entry;
+  }
+  return null;
+}
+
+/**
+ * Module-private helpers the suite drives directly. Bundled rather than
+ * exported individually — the same seam `knip-entry-sync.js` and
+ * `source-classifier.js` use — so test-only symbols cost one production
+ * dead-export row instead of one each, and so private helpers do not read as
+ * API.
+ */
+export const __testing = Object.freeze({
+  expressionToRegExp,
+  parseStepDefinitions,
+});

package/.agents/scripts/lib/bootstrap/install-ledger.js

@@ -105,9 +105,11 @@ export function ledgerPath(projectRoot) {
  *
  * @param {object} args
  * @param {import('./manifest.js').MutationManifestEntry[]} args.entries
- *   — the APPROVED subset of the mutation manifest that was applied.
- * @param {string[]} args.approvedGroups — the phase groups the operator
- *   approved (sorted for stable output).
+ *   — the subset of the mutation manifest that was applied.
+ * @param {string[]} args.approvedGroups — the phase groups whose mutations
+ *   landed (sorted for stable output). Field name predates Story #5007's
+ *   removal of the phased-approval gate; the ledger record shape is a
+ *   consumer contract read back by `mandrel uninstall`, so it is unchanged.
  * @param {{ owner?: string, repo?: string }} [args.answers]
  * @param {string} [args.appliedAt] — ISO-8601 timestamp (default: now).
  * @param {Record<string, { action?: string }>} [args.report] — the live

package/.agents/scripts/lib/bootstrap/issue-forms-template.js

@@ -15,8 +15,7 @@
  * `HUMAN_INTENT_FIELDS` table here, and each field's heading is the exact
  * section name the parser maps (`goal` → `## Goal`, etc.). The CI
  * conformance lint (`lint-issue-body.js`) runs the real `parse()` against
- * human-opened issues so the form and the parser cannot silently drift —
- * the same model `ci-workflow-template.js` follows for `ci.yml`.
+ * human-opened issues so the form and the parser cannot silently drift.
  *
  * ## Form fields ⊆ body schema
  *
@@ -70,9 +69,8 @@ export const STORY_FORM_RELATIVE_PATH = `${ISSUE_TEMPLATE_RELATIVE_DIR}/story.ym
  * generated YAML uses it verbatim as the field `label` so GitHub's
  * `### {label}` render produces a heading the parser recognises.
  *
- * Machine-managed body fields (`wide`, `reason_to_exist`,
- * `estimated_test_files`, `depends_on` meta) are intentionally absent —
- * the runtime fills those. `depends_on` is exposed as a free-text input
+ * Machine-managed body fields (`wide`, `reason_to_exist`, `depends_on`
+ * meta) are intentionally absent — the runtime fills those. `depends_on` is exposed as a free-text input
  * that serializes to the `blocked by #N` footer `parse()` already reads.
  *
  * @type {Array<{
@@ -367,7 +365,7 @@ jobs:
 
 /**
  * Write (or refresh) the Story issue form into a project checkout. Idempotent at
- * the byte level — mirrors {@link ensureCiWorkflow}'s contract:
+ * the byte level:
  *
  * - file absent → `created`
  * - byte-identical → `unchanged`

package/.agents/scripts/lib/bootstrap/manifest.js

@@ -1,14 +1,13 @@
 /**
- * bootstrap/manifest — single mutation-manifest source for the
- * consent-first phased install (Story #3521, Feature #3515, Epic #3438).
+ * bootstrap/manifest — single mutation-manifest source for the install
+ * ledger (Story #3521, Feature #3515, Epic #3438).
  *
  * `buildMutationManifest(ctx)` enumerates every mutation the bootstrap
- * pipeline can perform as a flat, declarative array. Each entry carries the
- * five fields the consent-first install screen needs to preview a change
- * before any write lands:
+ * pipeline can perform as a flat, declarative array. Each entry carries five
+ * fields:
  *
- *   - `phaseGroup` — one of the four independently-approvable groups
- *     (`ide-wiring`, `repo-config`, `github-admin`, `quality-gates`).
+ *   - `phaseGroup` — one of the four groups (`ide-wiring`, `repo-config`,
+ *     `github-admin`, `quality-gates`).
  *   - `target`     — the file path or remote resource the mutation touches.
  *   - `action`     — the verb describing the mutation (`create`, `merge`,
  *     `update`, `run`, `configure`).
@@ -17,16 +16,18 @@
  *     (e.g. delete a created file) vs. a remote-admin mutation that is not
  *     a simple local revert.
  *
- * The manifest is the SINGLE source of truth: `applyProjectBootstrap`'s
- * no-write preview is derived from `buildMutationManifest` so the preview
- * the operator approves and the execution that follows enumerate the exact
- * same set of mutations. There is no second, drift-prone list.
+ * Story #3690 replaced the consent-first phased-approval install screen with
+ * a plain summary+confirm loop, and Story #5007 removed the vestigial
+ * machinery it left behind (the no-write `previewMutationManifest` renderer
+ * and the `approvedGroups` set-threading). What survives is load-bearing:
+ * `recordLedger` filters these entries into the install ledger, and
+ * `mandrel uninstall` walks them — the `phaseGroup` string is the ledger's
+ * grouping key, not an approval gate.
  *
  * The manifest describes *intended* mutations deterministically from the
  * project root; it does not read or mutate any file. Whether a given
  * mutation is a no-op on a particular clone (the file already carries the
- * wiring) is decided at execution time by the idempotent `ensure*` steps —
- * the manifest always lists the full surface so the preview is complete.
+ * wiring) is decided at execution time by the idempotent `ensure*` steps.
  *
  * @module bootstrap/manifest
  */
@@ -34,9 +35,9 @@
 import path from 'node:path';
 
 /**
- * The four independently-approvable phase groups. The consent-first install
- * flow gates each group behind its own opt-in, so every manifest entry MUST
- * carry exactly one of these values.
+ * The four phase groups. Ledger/uninstall metadata only (Story #5007): every
+ * manifest entry MUST carry exactly one of these values so the install ledger
+ * can group and the uninstaller can select what a run actually landed.
  *
  * @type {Readonly<{ IDE_WIRING: 'ide-wiring', REPO_CONFIG: 'repo-config',
  *   GITHUB_ADMIN: 'github-admin', QUALITY_GATES: 'quality-gates' }>}
@@ -271,27 +272,3 @@ export function buildMutationManifest(ctx = {}) {
 
   return entries;
 }
-
-/**
- * Render the manifest as a no-write preview report grouped by phase group.
- * Pure helper — derives entirely from {@link buildMutationManifest}, so the
- * preview and the executing pipeline enumerate one identical source.
- *
- * The returned shape is `{ preview: true, groups: { <phaseGroup>: entry[] },
- * entries: entry[] }`: callers that want the flat list read `entries`, and
- * the consent-first screen reads `groups` to render one approvable section
- * per phase group (only groups with at least one entry appear).
- *
- * @param {object} [ctx] — same context as {@link buildMutationManifest}.
- * @returns {{ preview: true, groups: Record<string, MutationManifestEntry[]>,
- *   entries: MutationManifestEntry[] }}
- */
-export function previewMutationManifest(ctx = {}) {
-  const entries = buildMutationManifest(ctx);
-  const groups = {};
-  for (const entry of entries) {
-    if (!groups[entry.phaseGroup]) groups[entry.phaseGroup] = [];
-    groups[entry.phaseGroup].push(entry);
-  }
-  return { preview: true, groups, entries };
-}

package/.agents/scripts/lib/bootstrap/project-bootstrap.js

@@ -20,7 +20,7 @@ import { isCommandExcluded } from '../command-header.js';
 import { detectPackageManager as detectPm } from '../detect-package-manager.js';
 import { LEDGER_RELATIVE_PATH } from './install-ledger.js';
 import { ensureIssueForms } from './issue-forms-template.js';
-import { PHASE_GROUPS, previewMutationManifest } from './manifest.js';
+import { PHASE_GROUPS } from './manifest.js';
 import { applyQualityBootstrap } from './quality-bootstrap.js';
 
 export const SYNC_COMMAND = 'node .agents/scripts/sync-claude-commands.js';
@@ -436,8 +436,7 @@ export function ensureGitignore(ctx) {
  * project (Story #4227). Derived from the Story-body SSOT so a human-filed
  * ticket round-trips through `story-body.parse()`. Idempotent and additive,
  * mirroring `ensureGitignore`: byte-identical forms are `unchanged`,
- * operator-edited forms are preserved (`custom-skip`). Honours `ctx.preview`
- * (no writes) like the other phases.
+ * operator-edited forms are preserved (`custom-skip`).
  *
  * Returns the per-form action envelope keyed by ticket type.
  *
@@ -446,13 +445,9 @@ export function ensureGitignore(ctx) {
  *
  * @param {object} ctx
  * @param {string} ctx.projectRoot
- * @param {boolean} [ctx.preview]
  */
 function ensureIssueFormsPhase(ctx) {
-  const { forms } = ensureIssueForms({
-    projectRoot: ctx.projectRoot,
-    write: !ctx.preview,
-  });
+  const { forms } = ensureIssueForms({ projectRoot: ctx.projectRoot });
   const outcomes = {};
   for (const form of forms) {
     outcomes[form.type] = { action: form.action, path: form.path };
@@ -691,12 +686,11 @@ const fatalParity = (result) =>
  * bootstrap.
  *
  * Each project-side mutation phase carries a `phaseGroup` matching one of
- * the consent-first {@link PHASE_GROUPS}. When a phased-approval gate is
- * supplied via `ctx.approvedGroups`, a phase whose `phaseGroup` is not in
- * the approved set is skipped (recorded as a `phase-group-declined` no-op)
- * — declining one group never short-circuits the others (Story #3524).
- * Phases with no `phaseGroup` (the Node-version precondition and the
- * dependency install) are always-run infrastructure, never gated.
+ * the {@link PHASE_GROUPS}. Since Story #5007 that string is pure
+ * ledger/uninstall metadata — every phase runs on every install, and the
+ * ledger decides after the fact which groups actually landed. Phases with no
+ * `phaseGroup` (the Node-version precondition and the dependency install)
+ * are always-run infrastructure.
  */
 export const BOOTSTRAP_PHASES = Object.freeze([
   {
@@ -770,24 +764,6 @@ export const BOOTSTRAP_PHASES = Object.freeze([
   },
 ]);
 
-/**
- * Decide whether a phase should run given the approved-phase-group gate.
- * An always-run infrastructure phase (no `phaseGroup`) runs unconditionally.
- * A grouped phase runs only when no gate is supplied (`approvedGroups`
- * absent — the un-gated legacy path) or when its group is in the gate.
- *
- * Exported for unit testing.
- *
- * @param {BootstrapPhase} phase
- * @param {Set<string>|undefined} approvedGroups
- * @returns {boolean}
- */
-export function isPhaseApproved(phase, approvedGroups) {
-  if (!phase.phaseGroup) return true;
-  if (!approvedGroups) return true;
-  return approvedGroups.has(phase.phaseGroup);
-}
-
 /**
  * Throw with the formatted message when the phase is marked fatal and
  * the result indicates an abort. Pure helper so the driver stays a
@@ -809,12 +785,6 @@ export function throwIfFatal(phase, result) {
  * the result on `report[phase.name]`, then route fatal phases through
  * `throwIfFatal`. Returns the accumulated report.
  *
- * When `ctx.approvedGroups` is a `Set`, a grouped phase whose `phaseGroup`
- * is not approved is skipped and recorded as
- * `{ skipped: true, reason: 'phase-group-declined', phaseGroup }` — it never
- * runs, never throws (so a declined `ide-wiring` group also skips its
- * fatal `parity` check), and never short-circuits the remaining phases.
- *
  * Exported for tests so phase ordering and fatal behaviour can be
  * asserted without spawning a full bootstrap.
  *
@@ -825,14 +795,6 @@ export function throwIfFatal(phase, result) {
 export async function runPhases(phases, ctx) {
   const report = {};
   for (const phase of phases) {
-    if (!isPhaseApproved(phase, ctx.approvedGroups)) {
-      report[phase.name] = {
-        skipped: true,
-        reason: 'phase-group-declined',
-        phaseGroup: phase.phaseGroup,
-      };
-      continue;
-    }
     const result = await phase.run(ctx, report);
     report[phase.name] = result;
     throwIfFatal(phase, result);
@@ -844,24 +806,16 @@ export async function runPhases(phases, ctx) {
  * Compose every step in order. Each returned key is the outcome of one
  * step so the CLI can render a structured summary.
  *
- * When `ctx.preview` is truthy, the function performs **no writes and no
- * network I/O**. Instead it derives the operator-facing change list from
- * the single mutation-manifest source ({@link previewMutationManifest}) and
- * returns `{ preview: true, groups, entries }` — the exact same source the
- * consent-first install screen renders. Deriving the preview from
- * `buildMutationManifest` (rather than from a parallel hand-maintained list)
- * guarantees the preview the operator approves and the execution that
- * follows enumerate one identical set of mutations (Story #3521).
+ * Story #5007 removed the no-write `ctx.preview` branch: it had zero
+ * production callers (bootstrap's own `--dry-run` renders a hand-rolled text
+ * plan instead) and it survived only to serve the consent-first install
+ * screen Story #3690 replaced with a plain summary+confirm loop.
  *
  * @param {object} ctx
  * @param {string} ctx.projectRoot
  * @param {string} [ctx.agentRoot]
  * @param {{ owner: string, repo: string, baseBranch: string,
  *           operatorHandle: string|null }} ctx.answers
- * @param {boolean} [ctx.preview]   — no-write preview from the manifest.
- * @param {Set<string>} [ctx.approvedGroups] — when present, only phases
- *   whose `phaseGroup` is in this set execute (the consent-first gate from
- *   Story #3524); always-run infrastructure phases ignore it.
  * @param {boolean} [ctx.withQuality]
  * @param {boolean} [ctx.skipGithub]
  * @param {boolean} [ctx.skipInstall]
@@ -871,6 +825,5 @@ export async function runPhases(phases, ctx) {
  * @returns {Promise<object>}
  */
 export async function applyProjectBootstrap(ctx) {
-  if (ctx.preview) return previewMutationManifest(ctx);
   return runPhases(BOOTSTRAP_PHASES, ctx);
 }