mandrel 1.93.0 → 2.0.0

package/.agents/scripts/lib/spec/state.js

@@ -1,208 +0,0 @@
-/**
- * lib/spec/state.js — state-file shape helpers.
- *
- * Owns the canonical content-hashing and the
- * `<epic-id>.state.json` mapping projection used by the reconciler
- * (Wave 1) to decide what changed between two reconciliations.
- *
- * Tech Spec #1483 §"`.agents/epics/<epic-id>.state.json`" pins the
- * file shape:
- *
- *   ```json
- *   {
- *     "epicId": 1182,
- *     "lastReconciledAt": "2026-05-12T12:34:56Z",
- *     "mapping": {
- *       "<slug>": {
- *         "issueNumber": 1190,
- *         "contentHash": "sha256:...",
- *         "lastObservedAgentState": "agent::ready"
- *       }
- *     }
- *   }
- *   ```
- *
- * The hashing contract:
- *
- *   • `canonicalStringify(value)` produces a deterministic string for
- *     `value` by recursively sorting object keys. This guarantees that
- *     two objects with the same logical content but different in-memory
- *     key order hash to the same digest, which is the foundation of the
- *     reconciler's "did this entry change?" check.
- *   • `hashSpecEntry(entry)` returns `sha256:<hex>` over the
- *     canonical-stringified entry. The `sha256:` prefix makes the hash
- *     algorithm self-describing in the on-disk state file (so future
- *     migrations can multiplex algorithms without a schema bump).
- *
- * The mapping-projection contract (`projectMapping`):
- *
- *   • Given a `spec` and a `prior` state, project a fresh `mapping`
- *     entry per slug found in the spec, preserving the prior
- *     `issueNumber` + `lastObservedAgentState` where present and
- *     re-hashing the entry's structural content. Slugs absent from the
- *     spec are dropped (a spec→state projection — execution-drift
- *     handling lives in the reconciler, not here).
- *
- *   • The projection is pure: it does not read or write disk, and it
- *     does not call `Date.now()`. Callers compose it with
- *     `writeState(epicId, { ...projected, lastReconciledAt: now() })`.
- *
- * The whole module is import-light and side-effect-free so the
- * reconciler diff path can unit-test it in isolation.
- */
-
-import { createHash } from 'node:crypto';
-
-/**
- * Recursively sort object keys so two equivalent objects produce the
- * same canonical serialisation. Arrays preserve their order (array
- * order is semantically meaningful in the spec — feature order, task
- * order, dependsOn order).
- *
- * Exported because the loader's `sortKeysDeep` lives in `loader.js` and
- * we want a single canonicalisation entry point for the hash path. Both
- * implementations agree on object-key sort; only this one is the
- * documented hashing-input contract.
- *
- * @param {unknown} value
- * @returns {unknown}
- */
-export function canonicalise(value) {
-  if (Array.isArray(value)) {
-    return value.map(canonicalise);
-  }
-  if (value && typeof value === 'object') {
-    const out = {};
-    for (const key of Object.keys(value).sort()) {
-      out[key] = canonicalise(value[key]);
-    }
-    return out;
-  }
-  return value;
-}
-
-/**
- * Stringify `value` deterministically. Two objects with the same
- * logical content always produce the same string regardless of how
- * their keys are inserted in memory.
- *
- * Used as the hashing input for `hashSpecEntry`; also exported so the
- * reconciler can log diffs in canonical form.
- *
- * @param {unknown} value
- * @returns {string}
- */
-export function canonicalStringify(value) {
-  return JSON.stringify(canonicalise(value));
-}
-
-/**
- * SHA-256 over `input`, hex-encoded, prefixed with `sha256:` so the
- * algorithm is self-describing in the state file.
- *
- * @param {string} input
- * @returns {string}
- */
-export function sha256Hex(input) {
-  return `sha256:${createHash('sha256').update(input).digest('hex')}`;
-}
-
-/**
- * Hash a spec entry (a Story object) deterministically.
- * The entry is canonicalised (recursive key-sort), serialised, and
- * sha256'd. Equivalent entries (any key order, equivalent nested order
- * for the object-valued fields) hash to the same digest.
- *
- * The reconciler stores the resulting hash in `mapping[slug].contentHash`
- * so the next reconciliation can decide whether a `Update` operation is
- * needed without comparing the entries property-by-property.
- *
- * @param {object} entry
- * @returns {string} `sha256:<hex>`
- */
-export function hashSpecEntry(entry) {
-  return sha256Hex(canonicalStringify(entry));
-}
-
-/**
- * Iterate every slug-bearing entity in the spec. Yields tuples of
- * `[slug, entry]` where `entry` is the raw Story object as authored in
- * the spec. Order follows `spec.stories[]` — the natural read order,
- * useful for deterministic mapping iteration.
- *
- * Exported for tests; the reconciler diff path uses `projectMapping`
- * (below) rather than this generator directly.
- *
- * @param {object} spec
- * @returns {Generator<[string, object]>}
- */
-export function* iterSpecEntries(spec) {
-  if (!spec || !Array.isArray(spec.stories)) return;
-  for (const story of spec.stories) {
-    if (story?.slug) yield [story.slug, story];
-  }
-}
-
-/**
- * Project a fresh `mapping` over `spec`, carrying forward whatever the
- * `prior` state already knows for each slug (`issueNumber` and
- * `lastObservedAgentState`) and re-hashing the entry's structural
- * content via `hashSpecEntry`.
- *
- * Pure function — does not read or write disk, does not touch
- * `Date.now()`. Callers fold the result into `writeState` along with a
- * caller-supplied `lastReconciledAt`.
- *
- * Entries newly added in the spec start with `issueNumber: null` and
- * `lastObservedAgentState: null`. Entries dropped from the spec are
- * absent from the returned mapping (the reconciler decides separately
- * whether to retain a tombstone — that lives in Wave 1's diff layer).
- *
- * @param {object} spec
- * @param {{mapping?: Record<string,object>}} [prior]
- * @returns {Record<string,{issueNumber:number|null,contentHash:string,lastObservedAgentState:string|null}>}
- */
-export function projectMapping(spec, prior = {}) {
-  const priorMapping =
-    prior && typeof prior.mapping === 'object' && prior.mapping !== null
-      ? prior.mapping
-      : {};
-  const next = {};
-  for (const [slug, entry] of iterSpecEntries(spec)) {
-    const previous = priorMapping[slug] ?? {};
-    next[slug] = {
-      issueNumber:
-        typeof previous.issueNumber === 'number' ? previous.issueNumber : null,
-      contentHash: hashSpecEntry(entry),
-      lastObservedAgentState:
-        typeof previous.lastObservedAgentState === 'string'
-          ? previous.lastObservedAgentState
-          : null,
-    };
-  }
-  return next;
-}
-
-/**
- * Build a complete state object from a spec, a prior state, and an
- * optional `now` timestamp (defaults to the current UTC ISO string).
- *
- * This is the canonical convenience wrapper the reconciler calls right
- * before `writeState`. Tests can pass `now: '2026-05-12T00:00:00Z'` to
- * make the resulting state byte-stable.
- *
- * @param {object} spec
- * @param {{mapping?: object}} [prior]
- * @param {{now?: string}} [opts]
- * @returns {{epicId: number, lastReconciledAt: string, mapping: object}}
- */
-export function buildState(spec, prior = {}, opts = {}) {
-  const epicId =
-    typeof spec?.epic?.id === 'number' ? spec.epic.id : Number(prior?.epicId);
-  const lastReconciledAt = opts.now ?? new Date().toISOString();
-  return {
-    epicId,
-    lastReconciledAt,
-    mapping: projectMapping(spec, prior),
-  };
-}

package/.agents/scripts/lib/story-init/blocker-validator.js

@@ -1,68 +0,0 @@
-/**
- * blocker-validator.js — Stage 3 of the story-init pipeline.
- *
- * Parses `blocked by #N` references from the Story body and verifies each
- * one is resolved (labelled `agent::done` or GitHub state `closed`).
- * Verification failures are treated as blocking so agents never proceed
- * past a dependency whose state is unknown.
- */
-
-import { parseBlockedBy } from '../dependency-parser.js';
-import { STATE_LABELS } from '../orchestration/ticketing.js';
-
-/**
- * @param {object} deps
- * @param {object} deps.provider
- * @param {object} [deps.logger]
- * @param {object} deps.input
- * @param {string} deps.input.body        Story body to parse.
- * @returns {Promise<{ openBlockers: Array<{id:number,title:string,state:string,fetchError?:boolean}> }>}
- */
-export async function validateBlockers({ provider, logger, input }) {
-  const { body } = input;
-  const progress = logger?.progress ?? (() => {});
-
-  const blockedBy = parseBlockedBy(body);
-  if (blockedBy.length === 0) return { openBlockers: [] };
-
-  progress(
-    'BLOCKERS',
-    `Checking ${blockedBy.length} dependency/dependencies...`,
-  );
-
-  const results = await Promise.all(
-    blockedBy.map(async (depId) => {
-      try {
-        const dep = await provider.getTicket(depId);
-        const isDone =
-          dep.labels.includes(STATE_LABELS.DONE) || dep.state === 'closed';
-        if (!isDone) {
-          const currentState =
-            dep.labels.find((l) => l.startsWith('agent::')) ??
-            'no agent:: label';
-          return { id: depId, title: dep.title, state: currentState };
-        }
-        return null;
-      } catch (err) {
-        return {
-          id: depId,
-          title: '(fetch failed)',
-          state: err.message,
-          fetchError: true,
-        };
-      }
-    }),
-  );
-
-  const openBlockers = results.filter((b) => b !== null);
-
-  const fetchErrors = openBlockers.filter((b) => b.fetchError);
-  if (fetchErrors.length > 0) {
-    progress(
-      'BLOCKERS',
-      `⚠️ Could not verify ${fetchErrors.length} blocker(s) (network/API error): ${fetchErrors.map((b) => `#${b.id}`).join(', ')}. Treating as blocking until verified.`,
-    );
-  }
-
-  return { openBlockers };
-}

package/.agents/scripts/lib/story-init/branch-initializer.js

@@ -1,408 +0,0 @@
-/* node:coverage ignore file -- worktree provisioning over live git + filesystem; testing requires standing up real worktrees (integration) or asserting only the mock structure */
-
-/**
- * branch-initializer.js — Stage 5 of the story-init pipeline.
- *
- * Materialises the Story branch either in the main checkout (single-tree
- * mode) or behind a dedicated git worktree (isolated mode). Both paths
- * leave the agent with a working directory on the `story-<id>` branch and a
- * clean index.
- *
- * The legacy `bootstrapBranch` and `bootstrapWorktree` helpers are preserved
- * verbatim and exported alongside the canonical `initializeBranch` stage
- * entry point so existing callers / tests can reach them directly.
- * Surviving callers (Epic #990 Story #1006 triage):
- *   - tests/lib/story-init/branch-initializer-pure.test.js
- *   - tests/story-off-branch-e2e.test.js
- */
-
-import nodeFs from 'node:fs';
-import nodePath from 'node:path';
-import { resolveWorkingPath } from '../config-resolver.js';
-import { cachedGitFetch } from '../git/cached-fetch.js';
-import {
-  branchExistsLocally,
-  branchExistsViaTrackingRef,
-  checkoutStoryBranch,
-  classifyBranchSeed,
-  ensureEpicBranch,
-  ensureEpicBranchRef,
-  seedStoryBranchRef,
-} from '../git-branch-lifecycle.js';
-import { gitSpawn } from '../git-utils.js';
-import { Logger } from '../Logger.js';
-import {
-  resolveWorkspaceFiles,
-  verify as verifyWorkspace,
-} from '../workspace-provisioner.js';
-import { WorktreeManager } from '../worktree-manager.js';
-import { ensureDonorPrimed } from './donor-precheck.js';
-
-function defaultProgress() {
-  return () => {};
-}
-
-/**
- * Idempotently apply `core.longpaths=true` at the repo level on Windows.
- *
- * On the worktree-off branch the agent works directly in the main checkout,
- * so the per-worktree `git config --local core.longpaths` set in
- * `WorktreeManager.ensure` is never reached. Without this, deep
- * `node_modules/.../<long-name>` paths under the main checkout fail on
- * Windows with `Filename too long`.
- *
- * Skipped on every non-Windows platform (Linux web runtime included).
- * Skipped when the repo-local config is already `true` so the function is a
- * single read after the first invocation.
- *
- * Exported for testing.
- *
- * @param {object} opts
- * @param {string} opts.cwd
- * @param {NodeJS.Platform} [opts.platform]
- * @param {(level: string, msg: string) => void} [opts.progress]
- * @returns {{ applied: boolean, reason: string }}
- */
-export function ensureRepoCoreLongpathsOnWindows({
-  cwd,
-  platform = process.platform,
-  progress = defaultProgress(),
-  git = { gitSpawn },
-} = {}) {
-  if (platform !== 'win32') {
-    return { applied: false, reason: 'not-windows' };
-  }
-  const current = git.gitSpawn(
-    cwd,
-    'config',
-    '--local',
-    '--get',
-    'core.longpaths',
-  );
-  // Exit 0 means the value was found; stdout holds it. Exit 1 means unset.
-  if (current.status === 0 && (current.stdout ?? '').trim() === 'true') {
-    return { applied: false, reason: 'already-set' };
-  }
-  const set = git.gitSpawn(cwd, 'config', '--local', 'core.longpaths', 'true');
-  if (set.status !== 0) {
-    progress(
-      'GIT',
-      `⚠️ Failed to set core.longpaths on ${cwd}: ${set.stderr || 'unknown'} (continuing)`,
-    );
-    return { applied: false, reason: 'set-failed' };
-  }
-  progress('GIT', '✅ Applied core.longpaths=true (repo-level, Windows)');
-  return { applied: true, reason: 'set' };
-}
-
-function assertWorkingTreeClean(cwd) {
-  const status = gitSpawn(cwd, 'status', '--porcelain');
-  if (status.status !== 0) {
-    throw new Error(
-      `Failed to read git status: ${status.stderr || '(no stderr)'}`,
-    );
-  }
-  if (status.stdout.length > 0) {
-    throw new Error(
-      `Working tree is dirty. Refusing to switch branches — uncommitted/untracked files may belong to another agent.\nRun \`git status\` and resolve before retrying.\n--- dirty entries ---\n${status.stdout}`,
-    );
-  }
-}
-
-export async function bootstrapBranch({
-  epicBranch,
-  storyBranch,
-  baseBranch,
-  cwd,
-  progress = defaultProgress(),
-}) {
-  // First-use Windows guard: ensure deep paths under node_modules/ etc. don't
-  // blow up the main checkout when worktree isolation is off. Skipped on Linux
-  // (web runtime) and when already set.
-  ensureRepoCoreLongpathsOnWindows({ cwd, progress });
-
-  progress('GIT', 'Fetching remote refs...');
-  const fetchResult = await cachedGitFetch(cwd, 'origin');
-  if (fetchResult.cached) {
-    progress('GIT', 'Fetch served from (cwd, ref) cache — skipped network.');
-  } else if (fetchResult.attempts > 1) {
-    progress(
-      'GIT',
-      `Fetch completed after ${fetchResult.attempts} attempt(s) — packed-refs contention.`,
-    );
-  }
-
-  assertWorkingTreeClean(cwd);
-
-  await ensureEpicBranch(epicBranch, baseBranch, cwd, { progress });
-  await checkoutStoryBranch(storyBranch, epicBranch, cwd, { progress });
-
-  const currentBranch = gitSpawn(cwd, 'branch', '--show-current');
-  if (currentBranch.stdout !== storyBranch) {
-    throw new Error(
-      `Branch verification failed. Expected: ${storyBranch}, Got: ${currentBranch.stdout}.`,
-    );
-  }
-  progress('GIT', `✅ On branch: ${currentBranch.stdout}`);
-}
-
-/**
- * Pure: classify whether a story branch needs to be fetched from origin or
- * created from the epic branch. Returns the action keyword. Exported so the
- * decision is testable without git side-effects.
- *
- * Delegates the (local, remote) decision to the shared `classifyBranchSeed`
- * classifier (Story #3513) so this Epic-attached path and the standalone
- * `single-story-init.js#decideStoryBranchSeed` share one decision tree. The
- * shared classifier returns `'local'` for the local-present case; this path
- * names that outcome `'none'` (no re-seed).
- *
- * @returns {'none'|'fetch'|'create'}
- */
-export function planStoryBranchSeed({ localHas, remoteHas }) {
-  const action = classifyBranchSeed({ localHas, remoteHas });
-  return action === 'local' ? 'none' : action;
-}
-
-/**
- * Ensure the `story-<id>` ref exists locally, seeding it from the Epic branch
- * (or fetching it from origin) only when it does not already exist. A
- * pre-existing ref — local or created concurrently between the probe and the
- * `git branch` call — is treated as **reuse**, never an error (Story #3482).
- *
- * Exported with injectable git seams so the reuse / race-swallow behaviour is
- * unit-testable without standing up a real repo.
- *
- * @param {object} args
- * @param {string} args.storyBranch
- * @param {string} args.epicBranch
- * @param {string} args.mainCwd
- * @param {(level: string, msg: string) => void} [args.progress]
- * @param {object} [args.git]   Injected `{ spawn, existsLocally, existsRemotely }`.
- */
-export function ensureStoryBranchSeed({
-  storyBranch,
-  epicBranch,
-  mainCwd,
-  progress = defaultProgress(),
-  git,
-}) {
-  const spawn =
-    git?.spawn != null
-      ? (args) => git.spawn(...args)
-      : (args) => gitSpawn(mainCwd, ...args);
-  const existsLocally =
-    git?.existsLocally ?? ((b) => branchExistsLocally(b, mainCwd));
-  // `ensureStoryBranchSeed` is always called after `fetchMainRefs` in
-  // `bootstrapWorktree`, so remote-tracking refs are authoritative. Use a
-  // local tracking-ref check rather than a network `ls-remote` round-trip.
-  const existsRemotely =
-    git?.existsRemotely ?? ((b) => branchExistsViaTrackingRef(b, mainCwd));
-
-  // The seed-action switch shell is single-homed in `seedStoryBranchRef`
-  // (Story #4255). The Epic path runs under concurrent wave dispatch, so it
-  // opts into `swallowCreateRace: true` to treat a lost probe→create race
-  // (`git branch` exits "already exists") as reuse (Story #3482) — the ref
-  // exists, which is exactly the post-condition this function guarantees.
-  // No `fetchError` is supplied: the fetch exit status is intentionally not
-  // inspected here (the worktree bootstrap re-checks the ref downstream).
-  seedStoryBranchRef({
-    storyBranch,
-    baseRef: epicBranch,
-    swallowCreateRace: true,
-    spawn,
-    existsLocally,
-    existsRemotely,
-    progress,
-    messages: {
-      reuse: (b) => `Reusing existing story branch ref: ${b} (no re-seed)`,
-      fetch: (b) => `Fetching remote story branch: ${b}`,
-      create: (b, ref) => `Creating story branch ref: ${b} from ${ref}`,
-      createRace: (b) =>
-        `Story branch ref ${b} already exists (created concurrently) — reusing.`,
-      createError: (b, ref, stderr) =>
-        `ensureStoryBranchSeed: failed to create ${b} from ${ref}: ${stderr}`,
-    },
-  });
-}
-
-function verifyWorkspaceSafe({
-  ensured,
-  mainCwd,
-  wtConfig,
-  fs,
-  path,
-  progress,
-}) {
-  try {
-    const workspaceFiles = resolveWorkspaceFiles(wtConfig);
-    const presentAtSource = workspaceFiles.filter((rel) =>
-      fs.existsSync(path.join(mainCwd, rel)),
-    );
-    if (presentAtSource.length > 0) {
-      verifyWorkspace({
-        worktree: ensured.path,
-        files: presentAtSource,
-        sourceRoot: mainCwd,
-      });
-    }
-  } catch (err) {
-    progress('WORKTREE', `⚠️ ${err.message}`);
-    throw err;
-  }
-}
-
-function reportEnsureWarnings(ensured, progress) {
-  if (ensured.installStatus?.status === 'failed') {
-    progress(
-      'WORKTREE',
-      `⚠️ Dependency install failed (${ensured.installStatus.reason}). Agent must run package-manager install in the worktree before proceeding.`,
-    );
-  }
-  if (ensured.windowsPathWarning) {
-    const { path: p, length, threshold } = ensured.windowsPathWarning;
-    progress(
-      'WORKTREE',
-      `⚠️ Windows long-path: ${p} (${length} >= ${threshold}). Consider relocating orchestration.worktreeIsolation.root.`,
-    );
-  }
-}
-
-async function fetchMainRefs({ mainCwd, progress }) {
-  progress('GIT', 'Fetching remote refs (main checkout)...');
-  const fetchResult = await cachedGitFetch(mainCwd, 'origin');
-  if (fetchResult.cached) {
-    progress('GIT', 'Fetch served from (cwd, ref) cache — skipped network.');
-    return;
-  }
-  if (fetchResult.attempts > 1) {
-    progress(
-      'GIT',
-      `Fetch completed after ${fetchResult.attempts} attempt(s) — packed-refs contention.`,
-    );
-  }
-}
-
-export async function bootstrapWorktree({
-  epicBranch,
-  storyBranch,
-  storyId,
-  baseBranch,
-  mainCwd,
-  wtConfig,
-  progress = defaultProgress(),
-  fs = nodeFs,
-  path = nodePath,
-  onPhase,
-}) {
-  await fetchMainRefs({ mainCwd, progress });
-  ensureEpicBranchRef(epicBranch, baseBranch, mainCwd, { progress });
-  ensureStoryBranchSeed({ storyBranch, epicBranch, mainCwd, progress });
-
-  // Symlink-strategy fast path: verify the donor has node_modules before
-  // creating the worktree. A missing donor would otherwise produce a
-  // dangling junction/symlink. Idempotent across concurrent wave
-  // dispatches via a filesystem lock at the donor path.
-  ensureDonorPrimed({
-    strategy: wtConfig?.nodeModulesStrategy,
-    primeFromPath: wtConfig?.primeFromPath,
-    repoRoot: mainCwd,
-    logger: { progress },
-  });
-
-  const wm = new WorktreeManager({
-    repoRoot: mainCwd,
-    config: wtConfig,
-    logger: {
-      info: (m) => progress('WORKTREE', m),
-      warn: (m) => progress('WORKTREE', `⚠️ ${m}`),
-      error: (m) => Logger.error(`[story-init] ${m}`),
-    },
-    onPhase,
-  });
-
-  const ensured = await wm.ensure(storyId, storyBranch);
-  progress(
-    'WORKTREE',
-    `${ensured.created ? '✨ Created' : '♻️  Reusing'} worktree: ${ensured.path}`,
-  );
-
-  verifyWorkspaceSafe({ ensured, mainCwd, wtConfig, fs, path, progress });
-  reportEnsureWarnings(ensured, progress);
-
-  return {
-    worktreePath: ensured.path,
-    created: ensured.created,
-    installStatus: ensured.installStatus ?? {
-      status: 'skipped',
-      reason: 'unknown',
-    },
-  };
-}
-
-/**
- * Canonical stage entry point. Routes to worktree-isolated or single-tree
- * bootstrap based on `input.worktreeEnabled`.
- *
- * @param {object} deps
- * @param {object} [deps.logger]
- * @param {object} [deps.fs]
- * @param {object} deps.input
- * @param {number} deps.input.storyId
- * @param {string} deps.input.epicBranch
- * @param {string} deps.input.storyBranch
- * @param {string} deps.input.baseBranch
- * @param {string} deps.input.cwd
- * @param {boolean} deps.input.worktreeEnabled
- * @param {object|undefined} deps.input.wtConfig
- * @returns {Promise<{
- *   workCwd: string,
- *   worktreeCreated: boolean,
- *   installStatus: { status: 'installed' | 'failed' | 'skipped', reason?: string },
- * }>}
- */
-export async function initializeBranch({ logger, fs = nodeFs, input }) {
-  const {
-    storyId,
-    epicBranch,
-    storyBranch,
-    baseBranch,
-    cwd,
-    worktreeEnabled,
-    wtConfig,
-    onPhase,
-  } = input;
-  const progress = logger?.progress ?? defaultProgress();
-
-  if (worktreeEnabled) {
-    const wtResult = await bootstrapWorktree({
-      epicBranch,
-      storyBranch,
-      storyId,
-      baseBranch,
-      mainCwd: cwd,
-      wtConfig,
-      progress,
-      fs,
-      onPhase,
-    });
-    return {
-      workCwd: wtResult.worktreePath,
-      worktreeCreated: wtResult.created,
-      installStatus: wtResult.installStatus,
-    };
-  }
-
-  await bootstrapBranch({
-    epicBranch,
-    storyBranch,
-    baseBranch,
-    cwd,
-    progress,
-  });
-  return {
-    workCwd: resolveWorkingPath({ worktreeEnabled: false, repoRoot: cwd }),
-    worktreeCreated: false,
-    installStatus: { status: 'skipped', reason: 'single-tree-mode' },
-  };
-}