mandrel 2.0.0 → 2.2.0

package/.agents/scripts/lib/orchestration/plan-review-routing.js

@@ -1,63 +0,0 @@
-/**
- * plan-review-routing.js — resolve Phase 7 review-stop vs auto-proceed.
- *
- * Pure ESM, no I/O. Consumes the shared planningRisk envelope (derived
- * from the planner-authored risk verdict via `deriveRiskEnvelope`) and
- * optional operator overrides to decide whether the plan wrapper should
- * STOP for human review before Phase 8.
- */
-
-/**
- * @typedef {import('./planning-risk.js').PlanningRiskEnvelope} PlanningRiskEnvelope
- * @typedef {'review-required' | 'auto-proceed' | 'operator-override-review'} ReviewRoutingDecision
- */
-
-/**
- * @typedef {Object} ReviewRoutingEnvelope
- * @property {ReviewRoutingDecision} decision
- * @property {boolean} requiresStop
- * @property {boolean} forceReviewApplied
- * @property {string} operatorMessage
- */
-
-const AUTO_PROCEED_MESSAGE =
-  'Planning risk is low — auto-proceeding to Phase 8 decomposition after spec validation. Context tickets remain open until Epic delivery finalizes.';
-
-const REVIEW_REQUIRED_MESSAGE =
-  'Planning risk requires operator review — STOP before Phase 8. Review the Tech Spec sections and the Acceptance Table — both managed sections of the Epic body — on GitHub and confirm in this session before decomposition.';
-
-const FORCE_REVIEW_MESSAGE =
-  'Operator override — forcing review stop before Phase 8 despite low planning risk.';
-
-/**
- * Resolve whether Phase 7 should STOP for operator review before Phase 8.
- *
- * @param {{ planningRisk: PlanningRiskEnvelope, forceReview?: boolean }} input
- * @returns {ReviewRoutingEnvelope}
- */
-export function resolveReviewRouting({ planningRisk, forceReview = false }) {
-  if (forceReview) {
-    return {
-      decision: 'operator-override-review',
-      requiresStop: true,
-      forceReviewApplied: true,
-      operatorMessage: FORCE_REVIEW_MESSAGE,
-    };
-  }
-
-  if (planningRisk.requiresReview) {
-    return {
-      decision: 'review-required',
-      requiresStop: true,
-      forceReviewApplied: false,
-      operatorMessage: REVIEW_REQUIRED_MESSAGE,
-    };
-  }
-
-  return {
-    decision: 'auto-proceed',
-    requiresStop: false,
-    forceReviewApplied: false,
-    operatorMessage: AUTO_PROCEED_MESSAGE,
-  };
-}

package/.agents/scripts/lib/orchestration/planning/risk-verdict.js

@@ -1,104 +0,0 @@
-/**
- * phases/risk-verdict.js — read + schema-validate the planner-authored
- * risk verdict (Epic #3865).
- *
- * The `epic-plan-spec-author` Skill writes `risk-verdict.json` as the
- * fourth planning artifact; the persist half of `epic-plan-spec.js` loads
- * it through this module before deriving the planningRisk envelope. A
- * missing, unparseable, or schema-invalid verdict throws — the spec phase
- * fails closed rather than mis-routing the review gate.
- */
-
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export const RISK_VERDICT_SCHEMA_PATH = path.resolve(
-  __dirname,
-  '..',
-  '..',
-  '..',
-  '..',
-  'schemas',
-  'risk-verdict.schema.json',
-);
-
-/** @type {Map<string, import('ajv').ValidateFunction>} */
-const validatorCache = new Map();
-
-/**
- * Compile (and cache) the Ajv2020 validator for the risk-verdict schema.
- *
- * @param {string} schemaPath
- * @param {{ readFileSync: typeof readFileSync }} io
- * @returns {import('ajv').ValidateFunction}
- */
-function getRiskVerdictValidator(schemaPath, io) {
-  const cached = validatorCache.get(schemaPath);
-  if (cached) return cached;
-  const ajv = new Ajv2020({ allErrors: true, strict: false });
-  addFormats(ajv);
-  const schema = JSON.parse(io.readFileSync(schemaPath, 'utf8'));
-  const validate = ajv.compile(schema);
-  validatorCache.set(schemaPath, validate);
-  return validate;
-}
-
-/**
- * Validate a parsed risk verdict against the schema. Throws with the full
- * Ajv error detail on any violation so the spec phase never routes the
- * review gate off a malformed verdict.
- *
- * @param {unknown} verdict
- * @param {{ schemaPath?: string, io?: { readFileSync: typeof readFileSync } }} [opts]
- * @returns {import('../planning-risk.js').RiskVerdict} The validated verdict (same reference).
- */
-export function validateRiskVerdict(verdict, opts = {}) {
-  const validate = getRiskVerdictValidator(
-    opts.schemaPath ?? RISK_VERDICT_SCHEMA_PATH,
-    opts.io ?? { readFileSync },
-  );
-  if (!validate(verdict)) {
-    const detail = (validate.errors ?? [])
-      .map((e) => `${e.instancePath || '/'} ${e.message}`)
-      .join('; ');
-    throw new Error(
-      `[epic-plan-spec] risk verdict failed schema validation: ${detail}`,
-    );
-  }
-  return /** @type {import('../planning-risk.js').RiskVerdict} */ (verdict);
-}
-
-/**
- * Read, parse, and schema-validate the risk-verdict file the
- * `epic-plan-spec-author` Skill wrote.
- *
- * @param {string} verdictPath
- * @param {{ schemaPath?: string, io?: { readFileSync: typeof readFileSync } }} [opts]
- * @returns {import('../planning-risk.js').RiskVerdict}
- */
-export function loadRiskVerdict(verdictPath, opts = {}) {
-  const io = opts.io ?? { readFileSync };
-  let raw;
-  try {
-    raw = io.readFileSync(verdictPath, 'utf8');
-  } catch (err) {
-    throw new Error(
-      `[epic-plan-spec] cannot read risk verdict at ${verdictPath}: ${err.message}`,
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new Error(
-      `[epic-plan-spec] risk verdict at ${verdictPath} is not valid JSON: ${err.message}`,
-    );
-  }
-  return validateRiskVerdict(parsed, opts);
-}

package/.agents/scripts/lib/orchestration/planning-context-budget.js

@@ -1,213 +0,0 @@
-/**
- * planning-context-budget.js
- *
- * Bounded planning-context budget for the `--emit-context` planning scripts
- * (Epic #817 Story 9). Provides a summary representation of large markdown
- * payloads (project docs, Epic body, Tech Spec body) so the host LLM is not
- * handed multi-100KB envelopes when the underlying material exceeds the
- * configured `maxBytes` budget.
- *
- * Two pure helpers:
- *   - `summarizeDoc(filePath, content, maxBytes)` extracts headings + bounded
- *     excerpts for one document.
- *   - `applyBudget(items, limits, opts)` decides full vs summary for a
- *     collection of `{ path, content }` items based on `summaryMode` and the
- *     total payload size.
- *
- * Both functions are deterministic and have no I/O.
- */
-
-const HEADING_RE = /^(#{2,3})\s+(.+?)\s*$/;
-
-/**
- * Default per-excerpt cap so a single section heading does not consume the
- * entire per-doc byte budget. The bounded sum across excerpts is enforced
- * separately by {@link summarizeDoc}.
- */
-const DEFAULT_PER_EXCERPT_BYTES = 800;
-
-/**
- * Default planning-context limits when callers do not pass through
- * `getLimits(config).planningContext`. Mirrors `LIMITS_DEFAULTS` in
- * `lib/config/limits.js` so this module is usable in standalone tests.
- */
-export const PLANNING_CONTEXT_DEFAULTS = Object.freeze({
-  maxBytes: 50000,
-  summaryMode: 'auto',
-});
-
-function byteLen(s) {
-  if (s == null) return 0;
-  return Buffer.byteLength(String(s), 'utf-8');
-}
-
-function extractHeadings(content) {
-  if (!content) return [];
-  const lines = String(content).split(/\r?\n/);
-  const out = [];
-  for (const line of lines) {
-    const m = HEADING_RE.exec(line);
-    if (m) out.push({ level: m[1].length, text: m[2] });
-  }
-  return out;
-}
-
-/**
- * Split a markdown body into preamble + per-heading sections so excerpts can
- * be emitted with the heading they belong to. Lines preceding the first
- * `## ` / `### ` heading become the `preamble` section (heading: null).
- */
-function splitSections(content) {
-  if (!content) return [];
-  const lines = String(content).split(/\r?\n/);
-  const sections = [{ heading: null, body: [] }];
-  for (const line of lines) {
-    const m = HEADING_RE.exec(line);
-    if (m) {
-      sections.push({ heading: m[2], body: [] });
-    } else {
-      sections[sections.length - 1].body.push(line);
-    }
-  }
-  return sections;
-}
-
-/**
- * Trim a multi-line section to the first non-empty paragraph, capped at
- * `maxBytes` of utf-8. Preserves whitespace inside the kept paragraph but
- * collapses leading/trailing blank lines so excerpts stay compact.
- */
-function firstParagraph(lines, maxBytes) {
-  const text = lines.join('\n').replace(/^\s+|\s+$/g, '');
-  if (!text) return '';
-  // Take up to the first blank-line break (paragraph boundary).
-  const para = text.split(/\n\s*\n/)[0] ?? '';
-  const trimmed = para.trim();
-  if (byteLen(trimmed) <= maxBytes) return trimmed;
-  // Hard truncate at maxBytes utf-8 with an ellipsis marker so callers can
-  // tell the excerpt is bounded rather than corrupt.
-  const buf = Buffer.from(trimmed, 'utf-8').subarray(0, maxBytes);
-  // Avoid splitting a multi-byte codepoint at the boundary.
-  let safe = buf.toString('utf-8');
-  if (safe.length > 1 && safe.charCodeAt(safe.length - 1) === 0xfffd) {
-    safe = safe.slice(0, -1);
-  }
-  return `${safe.replace(/\s+$/, '')}…`;
-}
-
-/**
- * Summarise a single markdown doc. Emits headings + per-section excerpts
- * (preamble first), each bounded so a runaway section never blows the budget.
- *
- * @param {string} filePath repo-relative path used as the `path` field
- * @param {string} content full markdown body
- * @param {number} [maxBytes=50000] total per-doc byte budget for excerpts
- * @returns {{ path: string, headings: string[], excerpts: Array<{heading: string|null, snippet: string}>, byteSize: number }}
- */
-export function summarizeDoc(filePath, content, maxBytes = 50000) {
-  const safeContent = typeof content === 'string' ? content : '';
-  const byteSize = byteLen(safeContent);
-  const headingObjs = extractHeadings(safeContent);
-  const headings = headingObjs.map((h) => h.text);
-
-  const sections = splitSections(safeContent);
-  const perExcerptCap = Math.min(
-    DEFAULT_PER_EXCERPT_BYTES,
-    Math.max(120, Math.floor(maxBytes / Math.max(1, sections.length))),
-  );
-
-  const excerpts = [];
-  let used = 0;
-  for (const sec of sections) {
-    if (used >= maxBytes) break;
-    const remaining = Math.max(0, maxBytes - used);
-    const cap = Math.min(perExcerptCap, remaining);
-    const snippet = firstParagraph(sec.body, cap);
-    if (!snippet) continue;
-    excerpts.push({ heading: sec.heading, snippet });
-    used += byteLen(snippet);
-  }
-
-  return {
-    path: filePath,
-    headings,
-    excerpts,
-    byteSize,
-  };
-}
-
-function normalizeItems(items) {
-  if (!Array.isArray(items)) return [];
-  return items
-    .filter((it) => it && typeof it === 'object')
-    .map((it) => ({
-      path: it.path ?? it.name ?? '',
-      content: typeof it.content === 'string' ? it.content : '',
-    }));
-}
-
-function totalBytes(items) {
-  let n = 0;
-  for (const it of items) n += byteLen(it.content);
-  return n;
-}
-
-function buildFullItems(items) {
-  return items.map((it) => ({
-    path: it.path,
-    content: it.content,
-    byteSize: byteLen(it.content),
-  }));
-}
-
-function buildSummaryItems(items, maxBytes) {
-  // Distribute the byte budget across docs proportional to their size, with
-  // a per-doc floor so even tiny docs get a heading + tiny excerpt.
-  const total = totalBytes(items) || 1;
-  const floor = Math.max(512, Math.floor(maxBytes / Math.max(1, items.length)));
-  return items.map((it) => {
-    const share = Math.max(
-      floor,
-      Math.floor((byteLen(it.content) / total) * maxBytes),
-    );
-    return summarizeDoc(it.path, it.content, share);
-  });
-}
-
-/**
- * Apply the planning-context budget to a collection of doc-shaped items.
- *
- * @param {Array<{path?: string, name?: string, content: string}>} items
- * @param {{ maxBytes?: number, summaryMode?: 'auto'|'always'|'never' }} [limits]
- * @param {{ fullContext?: boolean }} [opts] — `fullContext: true` forces full
- *   mode regardless of `summaryMode` (mirrors the `--full-context` CLI flag).
- * @returns {{ mode: 'full'|'summary', items: Array<object>, totalBytes: number }}
- */
-export function applyBudget(items, limits = {}, opts = {}) {
-  const merged = { ...PLANNING_CONTEXT_DEFAULTS, ...(limits || {}) };
-  const { maxBytes, summaryMode } = merged;
-  const { fullContext = false } = opts;
-
-  const norm = normalizeItems(items);
-  const total = totalBytes(norm);
-
-  if (fullContext || summaryMode === 'never') {
-    return { mode: 'full', items: buildFullItems(norm), totalBytes: total };
-  }
-  if (summaryMode === 'always') {
-    return {
-      mode: 'summary',
-      items: buildSummaryItems(norm, maxBytes),
-      totalBytes: total,
-    };
-  }
-  // auto — summarise iff payload exceeds the budget.
-  if (total > maxBytes) {
-    return {
-      mode: 'summary',
-      items: buildSummaryItems(norm, maxBytes),
-      totalBytes: total,
-    };
-  }
-  return { mode: 'full', items: buildFullItems(norm), totalBytes: total };
-}

package/.agents/scripts/lib/orchestration/planning-risk.js

@@ -1,194 +0,0 @@
-/**
- * planning-risk.js — derive the Epic planning-risk envelope from a
- * planner-authored risk verdict.
- *
- * Pure ESM, no I/O. The planner (the `epic-plan-spec-author` Skill) judges
- * the Epic it just specced and supplies a verdict of shape
- * `{ axes: [{ axis, level, rationale }], summary }`, validated against
- * `.agents/schemas/risk-verdict.schema.json` before it reaches this module.
- * This module owns the deterministic control-flow outputs — overall level,
- * review requirement, acceptance disposition, and gate decision — so the
- * model supplies the *judgment input* while the harness owns the *gate
- * decision* (Epic #3865 hard cutover from the retired keyword-regex
- * classifier; see `docs/roadmap.md` Part 1).
- */
-
-/** @typedef {'low' | 'medium' | 'high'} RiskLevel */
-/** @typedef {'required' | 'recommended' | 'not-applicable'} AcceptanceDisposition */
-/** @typedef {'review-required' | 'auto-proceed'} GateDecision */
-
-/**
- * @typedef {Object} PlanningRiskAxis
- * @property {string} axis
- * @property {RiskLevel} level
- * @property {string} rationale
- */
-
-/**
- * @typedef {Object} RiskVerdict
- * @property {PlanningRiskAxis[]} axes
- * @property {string} summary
- */
-
-/**
- * @typedef {Object} PlanningRiskEnvelope
- * @property {PlanningRiskAxis[]} axes
- * @property {RiskLevel} overallLevel
- * @property {boolean} requiresReview
- * @property {AcceptanceDisposition} acceptanceDisposition
- * @property {GateDecision} gateDecision
- * @property {string} [acceptanceWaivedReason] Present only when the
- *   acceptance disposition was forced to `not-applicable` by a non-axis
- *   signal (currently: no BDD runner detected). An operator-visible
- *   rationale so the override is never silent (Story #4145).
- */
-
-/**
- * @typedef {Object} BddRunnerProbe
- * @property {string|null} runner
- * @property {boolean} fallback `true` when no supported BDD runner was
- *   detected in the project (`verifyBddRunnerPendingTag`).
- * @property {string} [reason]
- */
-
-const LEVEL_RANK = Object.freeze({ low: 0, medium: 1, high: 2 });
-
-/**
- * Axes whose presence forces a `required` acceptance disposition. Mirrored
- * by the `axis` enum in `.agents/schemas/risk-verdict.schema.json` — keep
- * the two lists in sync.
- */
-export const REQUIRED_AXES = new Set([
-  'visible-behavior',
-  'public-api',
-  'security',
-  'data-migration',
-  'billing',
-  'destructive-mutation',
-  'critical-workflow',
-]);
-
-/**
- * Axes that, when they are the only signals present, waive the acceptance
- * spec (`not-applicable`). Mirrored by the `axis` enum in
- * `.agents/schemas/risk-verdict.schema.json` — keep the two lists in sync.
- */
-export const NOT_APPLICABLE_AXES = new Set([
-  'docs-only',
-  'test-harness',
-  'internal-refactor',
-]);
-
-/**
- * @param {PlanningRiskAxis[]} axes
- * @returns {RiskLevel}
- */
-function resolveOverallLevel(axes) {
-  if (axes.length === 0) return 'low';
-  return axes.reduce(
-    (highest, entry) =>
-      LEVEL_RANK[entry.level] > LEVEL_RANK[highest] ? entry.level : highest,
-    'low',
-  );
-}
-
-/**
- * @param {PlanningRiskAxis[]} axes
- * @param {RiskLevel} overallLevel
- * @returns {AcceptanceDisposition}
- */
-function resolveAcceptanceDisposition(axes, overallLevel) {
-  const requiredAxes = axes.filter((entry) => REQUIRED_AXES.has(entry.axis));
-  if (requiredAxes.length > 0) {
-    return 'required';
-  }
-  if (
-    overallLevel === 'medium' ||
-    axes.some((entry) => entry.level === 'medium')
-  ) {
-    return 'recommended';
-  }
-  if (
-    axes.length > 0 &&
-    axes.every((entry) => NOT_APPLICABLE_AXES.has(entry.axis))
-  ) {
-    return 'not-applicable';
-  }
-  if (overallLevel === 'low') return 'not-applicable';
-  return 'recommended';
-}
-
-/**
- * @param {RiskLevel} overallLevel
- * @param {PlanningRiskAxis[]} axes
- * @returns {boolean}
- */
-function resolveRequiresReview(overallLevel, axes) {
-  if (overallLevel === 'high') return true;
-  if (overallLevel === 'medium') {
-    return axes.some(
-      (entry) =>
-        entry.level === 'medium' &&
-        (REQUIRED_AXES.has(entry.axis) || entry.axis === 'visible-behavior'),
-    );
-  }
-  return false;
-}
-
-/**
- * Derive the stable planningRisk envelope from a schema-validated planner
- * verdict. Pure derivation — schema validation happens at the read boundary
- * (`plan-persist.js` via `loadRiskVerdict`), never here, so a malformed verdict fails closed
- * before this function runs.
- *
- * **No-BDD-runner waiver (Story #4145).** The acceptance disposition the risk
- * axes derive presumes a BDD runner exists to satisfy an authored AC table.
- * When `opts.bddRunner.fallback === true` (no supported runner detected — e.g.
- * a `node:test` repo with no `tests/features/**`), an authored AC table can
- * never be reconciled by `@epic-<id>-ac-*` feature tags, so `/deliver`
- * finalize would abort. In that case the disposition is **forced** to
- * `not-applicable` regardless of the risk axes, and `acceptanceWaivedReason`
- * records the override so it is operator-visible, not silent. The
- * `requiresReview` / `gateDecision` outputs are unaffected — a high-risk
- * Epic still routes to review; only the acceptance-spec requirement is
- * waived. Repos that ship a BDD runner (`fallback !== true`) are unaffected.
- *
- * @param {RiskVerdict} [verdict]
- * @param {{ bddRunner?: BddRunnerProbe|null }} [opts]
- * @returns {PlanningRiskEnvelope}
- */
-export function deriveRiskEnvelope(verdict = {}, { bddRunner = null } = {}) {
-  const axes = (Array.isArray(verdict.axes) ? verdict.axes : []).map(
-    ({ axis, level, rationale }) => ({ axis, level, rationale }),
-  );
-
-  const overallLevel = resolveOverallLevel(axes);
-  const axisDisposition = resolveAcceptanceDisposition(axes, overallLevel);
-  const requiresReview = resolveRequiresReview(overallLevel, axes);
-  const gateDecision = requiresReview ? 'review-required' : 'auto-proceed';
-
-  const noBddRunner = bddRunner?.fallback === true;
-  // Force the waiver only when the axes would otherwise have required (or
-  // recommended) an AC table; if the disposition is already not-applicable
-  // there is nothing to override and no waiver rationale to surface.
-  const forceWaiver = noBddRunner && axisDisposition !== 'not-applicable';
-  const acceptanceDisposition = forceWaiver
-    ? 'not-applicable'
-    : axisDisposition;
-
-  /** @type {PlanningRiskEnvelope} */
-  const envelope = {
-    axes,
-    overallLevel,
-    requiresReview,
-    acceptanceDisposition,
-    gateDecision,
-  };
-  if (forceWaiver) {
-    envelope.acceptanceWaivedReason =
-      `no BDD runner detected (${bddRunner?.reason ?? 'no-bdd-runner-detected'}) — ` +
-      `an authored acceptance-spec AC table cannot be reconciled by feature tags, ` +
-      `so the acceptance disposition is waived to not-applicable (was ${axisDisposition}).`;
-  }
-  return envelope;
-}

package/.agents/scripts/lib/orchestration/post-merge/phases/branch-cleanup.js

@@ -1,56 +0,0 @@
-/**
- * phases/branch-cleanup.js — post-merge Story branch deletion phase.
- *
- * Delegates the "delete this branch from local + remote, treat not-found
- * as success" idempotency contract to `lib/git-branch-cleanup.js` so the
- * deletion rules live in one place. A local delete failure is logged
- * loudly (operators usually need to investigate a stale worktree),
- * while a remote not-found is treated as a no-op.
- */
-
-import { deleteBranchEverywhere } from '../../../git-branch-cleanup.js';
-
-function reapPhaseLogger(progress) {
-  return progress ?? (() => {});
-}
-
-export async function branchCleanupPhase(ctx, state = {}) {
-  const {
-    storyBranch,
-    repoRoot,
-    progress,
-    logger,
-    branchCleanup = deleteBranchEverywhere,
-  } = ctx;
-  const log = reapPhaseLogger(progress);
-  log('CLEANUP', `Deleting story branch: ${storyBranch}`);
-
-  const result = branchCleanup(storyBranch, {
-    cwd: repoRoot,
-    noVerify: true,
-  });
-
-  if (!result.local.deleted) {
-    const stderr = (result.local.stderr || '').trim();
-    const reapStatus = state.worktreeReap?.status;
-    logger.error(
-      `  Local branch ${storyBranch} delete failed: ${stderr || 'unknown'}. ` +
-        `Check for stale worktrees (git worktree list).` +
-        (reapStatus ? ` worktreeReap=${reapStatus}.` : ''),
-    );
-  }
-  if (result.remote.deleted) {
-    if (result.remote.reason === 'not-found') {
-      log('CLEANUP', `Remote branch ${storyBranch} not found — skipped`);
-    } else {
-      log('CLEANUP', `✅ Remote branch ${storyBranch} deleted`);
-    }
-  }
-
-  return {
-    localDeleted: result.local.deleted,
-    remoteDeleted: result.remote.deleted,
-    localReason: result.local.reason,
-    remoteReason: result.remote.reason,
-  };
-}

package/.agents/scripts/lib/orchestration/post-merge/phases/dashboard-refresh.js

@@ -1,21 +0,0 @@
-/**
- * phases/dashboard-refresh.js — retired dispatch-manifest refresh seam.
- *
- * The Stage 5 hard cutover deletes the dispatcher/manifest surface; keep this
- * phase as a no-op so any still-wired post-merge pipeline can drain safely.
- */
-
-function reapPhaseLogger(progress) {
-  return progress ?? (() => {});
-}
-
-export async function dashboardRefreshPhase(ctx) {
-  const { skipDashboard, progress } = ctx;
-  const log = reapPhaseLogger(progress);
-  if (skipDashboard) {
-    log('DASHBOARD', 'Skipping dashboard refresh (--skip-dashboard flag set)');
-    return false;
-  }
-  log('DASHBOARD', 'Dispatch manifest refresh retired; no dashboard updated.');
-  return false;
-}