mandrel 1.94.0 → 2.1.0

package/.agents/scripts/plan-persist.js

@@ -1,97 +1,68 @@
 #!/usr/bin/env node
 
 /**
- * plan-persist.js — single GitHub-write surface for the collapsed /plan
- * flow (Epic #4474, PR3 — design §1 Step 3).
+ * plan-persist.js — flat Story GitHub-write surface for v2 `/plan`
+ * (Stage 3 — `docs/roadmap.md`).
  *
- * Supersedes the retired 12-phase pipeline's separate persist halves
- * (Epic #4474 PR7 — the delegate CLIs are import shims now, deleted next
- * release). Given the author-written planning artifacts
- * (Tech Spec, optional Acceptance Table, risk verdict, tickets JSON), this
- * CLI performs every GitHub mutation of the plan flow in one ordered,
- * fail-closed pass:
+ * Given the author-written planning artifacts (`stories.json`, optional shared
+ * Tech Spec), this CLI validates and creates Story issue(s) directly:
  *
- *   section gate → risk-verdict + mode-coherence → ticket validator /
- *   file-assumption gate / DAG / budget → (ideation: open the Epic) →
- *   Epic lease → managed sections + risk comment + freshness advisory →
- *   story creation (structural reconciler) → inline healthcheck →
- *   single terminal `agent::ready` flip (no intermediate
- *   `agent::review-spec`) → checkpoint v2 + `plan-summary` comment with
- *   the dry-run wave table → temp cleanup at terminal success only.
+ *   ticket validator / DAG / capacity → reachability →
+ *   split-policy partition → fold/spill Spec into each Story body →
+ *   createIssue(s) with type::story, resumably by plan fingerprint (NOT
+ *   agent::ready) → story-plan-state on every Story;
+ *   plan-summary on the primary → flip every Story to agent::ready →
+ *   comment + close superseded source tickets → temp cleanup + stale reap.
  *
- * Modes:
- *   --epic <id>          Persist against an existing Epic. Artifact paths
- *                        default to the per-Epic temp tree
- *                        (`temp/epic-<id>/techspec.md`, `risk-verdict.json`,
- *                        `tickets.json`, and `acceptance-spec.md` when
- *                        present).
- *   --one-pager <path>   Ideation mode: render + open the Epic from a
- *                        sharpened one-pager first (folds the former
- *                        Phase 3/4 steps in). Artifact paths must be
- *                        explicit (there is no Epic id to derive them from).
+ * Story #4542 retired the authored risk verdict: persist neither requires nor
+ * accepts one, and no plan-time step produces one. Review depth and the
+ * acceptance-critic mode are derived from the diff at close time
+ * (`review-depth.js#deriveChangeLevel`). `--force-review` is the only review
+ * gate the planner still carries, and it is an explicit operator flag.
  *
- * Modes (Epic #4474 PR4, design §2 mode matrix): the risk verdict's
- * optional `deliveryShape` field selects between the full fan-out persist
- * (default; requires tickets) and the spec-only single-delivery variant
- * (`deliveryShape: "single"`; NO tickets — the ticket validator + DAG are
- * skipped, fenced by construction, and the `delivery::single` routing
- * marker is applied instead of a Story tree; inert until #4475 lands the
- * deliver-side reader). `--amend` selects the change-request delta path:
- * tickets carry `op: add|modify|keep|close` and the persist maps the ops
- * onto the existing tree.
- *
- * Flags:
- *   --force              Deliberate re-persist: overwrite managed sections,
- *                        close + recreate the story tree (reconciler
- *                        --explicit-delete). Reuses on-disk artifacts —
- *                        cleanup is deferred to terminal success, so a
- *                        failed run leaves them in place.
- *   --resume             Continue a partial persist after a crash
- *                        (rate-limit, network): sections short-circuit
- *                        idempotently, the reconciler creates only the
- *                        missing slugs from its per-slug state ledger.
- *   --amend              Change-request delta persist: every ticket carries
- *                        `op: add|modify|keep|close`; close-and-recreate is
- *                        scoped to modify/close slugs only, keeps are
- *                        untouched, and the DAG is validated over the
- *                        merged set.
- *   --explicit-delete    Confirm the close ops of an --amend plan (mirrors
- *                        epic-reconcile.js). Without it, an amend carrying
- *                        close ops prints the dry-run diff and exits 2.
- *   --steal              Force-transfer a live foreign Epic-lease claim.
- *   --force-review       Operator-forced review routing (recorded in the
- *                        checkpoint's reviewRouting envelope).
+ * CLI:
+ *   --stories <file>          Required Story ticket array (default length 1)
+ *   --tech-spec <file>        Optional shared Tech Spec folded into each Story
+ *   --plan-dir <dir>          Optional temp dir deleted at terminal success.
+ *                             Also where the `plan-context.json` envelope is
+ *                             auto-discovered from (see --plan-context)
+ *   --plan-context <file>     Optional explicit path to the `plan-context.js`
+ *                             envelope. Its `sourceTickets[]` is what makes
+ *                             `--tickets` superseding work without a flag
+ *   --plan-acceptance <file>  Optional JSON string[] for partition coverage
+ *   --source-tickets <ids>    Explicit OVERRIDE of the envelope-derived source
+ *                             ids, for hand-driven runs. Each id must be
+ *                             claimed by exactly one Story's `supersedes[]`;
+ *                             they are commented on and closed as superseded
+ *   --no-close-superseded     Keep the source tickets open (no comment, no
+ *                             close) — for a genuinely partial supersede
+ *   --dry-run                 Assemble + validate without GitHub writes
+ *   --force-review            Operator-forced review stop before persist lands
  *   --allow-over-budget / --allow-large-fan-out
- *                        Same overrides as the retired split persist.
  *
- * Exit codes: 0 — persist complete, Epic is `agent::ready`; 1 — fatal
- * error (see stderr); 2 — amend close ops require --explicit-delete (the
- * dry-run diff is printed; nothing was mutated); 3 — reachability orphans
- * (Epic #4474 PR6 named soft failure: the deterministic route-glob vs
- * `planning.navigation.navRegistry` scan found route-adding draft stories
- * with no navigation owner — the orphan-surface list is printed, nothing
- * was mutated; apply one targeted amend and re-run the persist once). The
- * Epic lease is released on every exit path.
+ * Run `--dry-run` first. It exercises every gate — validator, DAG, capacity,
+ * budget, reachability, split/supersede partition, Spec fold — write-free, so
+ * an authoring mistake surfaces before a single issue exists.
+ *
+ * stdout is reserved for the JSON result (Story #2278 discipline, extended to
+ * this CLI by Story #4541): `routeAllOutputToStderr()` runs before any
+ * pipeline code so a headless driver can `JSON.parse` stdout unconditionally.
+ * Human-readable log lines go to stderr, matching the sibling `plan-context`.
+ *
+ * Exit codes: 0 success; 1 fatal; 3 reachability orphans (nothing mutated).
  */
 
-// Fail-fast if the framework's runtime deps are not installed — must be the
-// first import so the check runs before any third-party-importing sibling
-// module is evaluated (Story #3432).
 import './lib/runtime-deps/ensure-installed.js';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { parseArgs } from 'node:util';
 
 import { runAsCli } from './lib/cli-utils.js';
-import { epicArtifactPath } from './lib/config/temp-paths.js';
 import {
-  PROJECT_ROOT,
   resolveConfig,
   validateOrchestrationConfig,
 } from './lib/config-resolver.js';
-import { Logger } from './lib/Logger.js';
-import { drainPendingCleanupAtBoot } from './lib/orchestration/epic-plan-spec/phases/drain.js';
-import { loadRiskVerdict } from './lib/orchestration/epic-plan-spec/phases/risk-verdict.js';
+import { Logger, routeAllOutputToStderr } from './lib/Logger.js';
 import {
   readPlanMetrics,
   recordPlanInvocation,
@@ -99,7 +70,10 @@ import {
   summarizePlanMetrics,
 } from './lib/orchestration/plan-metrics.js';
 import {
-  resolveDeliveryMode,
+  loadPlanContextEnvelope,
+  resolvePlanContextPath,
+} from './lib/orchestration/plan-persist/plan-context-source.js';
+import {
   runPlanPersist,
   writeCheckpointV2,
 } from './lib/orchestration/plan-persist/run-plan-persist.js';
@@ -108,128 +82,220 @@ import {
   buildWaveTable,
   PLAN_SUMMARY_COMMENT_TYPE,
 } from './lib/orchestration/plan-persist/summary.js';
+import { resolveSourceTicketIds } from './lib/orchestration/plan-persist/supersede-ops.js';
 import { createProvider } from './lib/provider-factory.js';
 
-// Re-exports for the stable public API (tests import through the CLI
-// module, mirroring the plan-context.js CLI-shell shape).
 export {
   buildPlanSummaryCommentBody,
   buildWaveTable,
   PLAN_SUMMARY_COMMENT_TYPE,
-  resolveDeliveryMode,
   runPlanPersist,
   writeCheckpointV2,
 };
 
-export const EPIC_FROM_IDEA_TEMPLATE_PATH = path.resolve(
-  PROJECT_ROOT,
-  '.agents',
-  'templates',
-  'epic-from-idea.md',
-);
-
 const CLI_OPTIONS = {
-  epic: { type: 'string' },
-  'one-pager': { type: 'string' },
+  stories: { type: 'string' },
   'tech-spec': { type: 'string' },
-  'acceptance-table': { type: 'string' },
-  'risk-verdict': { type: 'string' },
-  tickets: { type: 'string' },
-  force: { type: 'boolean', default: false },
-  resume: { type: 'boolean', default: false },
-  steal: { type: 'boolean', default: false },
+  'plan-dir': { type: 'string' },
+  'plan-context': { type: 'string' },
+  'plan-acceptance': { type: 'string' },
+  'source-tickets': { type: 'string' },
+  'close-superseded': { type: 'boolean', default: true },
+  'no-close-superseded': { type: 'boolean', default: false },
+  'dry-run': { type: 'boolean', default: false },
   'force-review': { type: 'boolean', default: false },
   'allow-over-budget': { type: 'boolean', default: false },
   'allow-large-fan-out': { type: 'boolean', default: false },
-  amend: { type: 'boolean', default: false },
-  'explicit-delete': { type: 'boolean', default: false },
 };
 
 const USAGE =
-  'Usage: plan-persist.js (--epic <EpicId> | --one-pager <file>) ' +
-  '[--tech-spec <file>] [--acceptance-table <file>] [--risk-verdict <file>] ' +
-  '[--tickets <file>] [--force | --resume | --amend [--explicit-delete]] ' +
-  '[--steal] [--force-review] [--allow-over-budget] [--allow-large-fan-out]';
+  'Usage: plan-persist.js --stories <file> ' +
+  '[--tech-spec <file>] [--plan-dir <dir>] [--plan-context <file>] ' +
+  '[--plan-acceptance <file>] ' +
+  '[--source-tickets <ids>] [--no-close-superseded] ' +
+  '[--dry-run] [--force-review] ' +
+  '[--allow-over-budget] [--allow-large-fan-out]';
 
-/**
- * Parse `--epic`; returns null when absent (ideation mode).
- */
-function parseEpicId(rawEpic) {
-  if (rawEpic === undefined) return null;
-  const epicId = Number.parseInt(rawEpic, 10);
-  if (Number.isNaN(epicId)) {
+async function readOptional(filePath, { required }) {
+  try {
+    return await readFile(filePath, 'utf8');
+  } catch (err) {
+    if (!required && err?.code === 'ENOENT') return null;
+    throw new Error(`Cannot read ${filePath}: ${err.message}`);
+  }
+}
+
+async function readJsonFile(filePath, label) {
+  const raw = await readOptional(filePath, { required: true });
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
     throw new Error(
-      `Invalid epic ID: "${rawEpic}" — must be a number.\n${USAGE}`,
+      `Failed to parse ${label} file "${filePath}" as JSON: ${err.message}`,
     );
   }
-  return epicId;
 }
 
 /**
- * Resolve the artifact file paths. Existing-Epic mode defaults each path to
- * the per-Epic temp tree — the same locations the authoring skill writes to
- * — so a `--force`/`--resume` re-persist reuses the on-disk artifacts with
- * no re-typing (they survive until terminal success now that cleanup is
- * deferred). Ideation mode has no Epic id to derive from, so the paths must
- * be explicit.
+ * Resolve every input path the CLI accepts, including where the
+ * `plan-context.js` envelope is discovered from. Exported for tests.
+ *
+ * @param {object} values Parsed `parseArgs` values.
  */
-function resolveArtifactPaths({ epicId, values, config }) {
-  const fallback = (basename) =>
-    epicId === null ? undefined : epicArtifactPath(epicId, basename, config);
-  const techSpecPath = values['tech-spec'] ?? fallback('techspec.md');
-  const riskVerdictPath =
-    values['risk-verdict'] ?? fallback('risk-verdict.json');
-  const ticketsPath = values.tickets ?? fallback('tickets.json');
-  const acceptancePath =
-    values['acceptance-table'] ?? fallback('acceptance-spec.md');
-  if (!techSpecPath || !riskVerdictPath) {
-    throw new Error(
-      `Missing artifact path(s): ideation mode requires explicit --tech-spec and --risk-verdict.\n${USAGE}`,
-    );
-  }
+export function resolveInputPaths(values) {
+  const planDir = values['plan-dir'] ? path.resolve(values['plan-dir']) : null;
   return {
-    techSpecPath,
-    riskVerdictPath,
-    ticketsPath,
-    acceptancePath,
-    acceptanceExplicit: values['acceptance-table'] !== undefined,
-    ticketsExplicit: values.tickets !== undefined,
+    storiesPath: path.resolve(values.stories),
+    techSpecPath: values['tech-spec']
+      ? path.resolve(values['tech-spec'])
+      : null,
+    planAcceptancePath: values['plan-acceptance']
+      ? path.resolve(values['plan-acceptance'])
+      : null,
+    planDir,
+    planContextPath: resolvePlanContextPath(values['plan-context'], planDir),
   };
 }
 
-async function readOptional(filePath, { required }) {
+async function loadArtifacts(paths) {
+  const stories = await readJsonFile(paths.storiesPath, 'stories');
+  const techSpecContent = paths.techSpecPath
+    ? await readOptional(paths.techSpecPath, { required: true })
+    : null;
+  const planAcceptance = paths.planAcceptancePath
+    ? await readJsonFile(paths.planAcceptancePath, 'plan-acceptance')
+    : null;
+  const planContextEnvelope = await loadPlanContextEnvelope(
+    paths.planContextPath,
+  );
+
+  return {
+    stories,
+    techSpecContent,
+    planAcceptance,
+    planContextEnvelope,
+  };
+}
+
+/**
+ * Assemble the `runPlanPersist` opts bag from parsed CLI values.
+ *
+ * Exported for tests: this is the join where the envelope-derived source ids
+ * meet the persist engine, so a regression here silently un-wires
+ * `/plan --tickets` superseding (Story #4554).
+ *
+ * @param {object} values Parsed `parseArgs` values.
+ * @param {ReturnType<typeof resolveInputPaths>} paths
+ * @param {object|null} planContextEnvelope
+ * @returns {object} opts for `runPlanPersist`.
+ */
+export function buildPersistOptions(values, paths, planContextEnvelope) {
+  const source = resolveSourceTicketIds({
+    explicitIds: values['source-tickets'],
+    envelope: planContextEnvelope,
+  });
+
+  return {
+    forceReview: values['force-review'],
+    allowOverBudget: values['allow-over-budget'],
+    allowLargeFanOut: values['allow-large-fan-out'],
+    dryRun: values['dry-run'],
+    planDir: paths.planDir,
+    skipCleanup: values['dry-run'],
+    sourceTicketIds: source.ids,
+    sourceTicketOrigin: source.origin,
+    // Default-on: `--no-close-superseded` is the explicit escape and always
+    // wins over the (default `true`) `--close-superseded`.
+    closeSuperseded:
+      values['no-close-superseded'] === true
+        ? false
+        : values['close-superseded'] !== false,
+  };
+}
+
+async function runPersistInvocation({
+  values,
+  config,
+  provider,
+  artifacts,
+  metricsSince,
+}) {
+  const paths = resolveInputPaths(values);
+  const settings = {
+    baseBranch: config.project?.baseBranch,
+    paths: config.project?.paths,
+    planning: config.planning,
+    docsContextFiles: config.project?.docsContextFiles,
+  };
+
+  return recordPlanInvocation(
+    {
+      cli: 'plan-persist',
+      mode: values['dry-run'] ? 'dry-run' : 'persist',
+      config,
+    },
+    () =>
+      runPlanPersist({
+        provider,
+        artifacts,
+        config,
+        settings,
+        opts: {
+          ...buildPersistOptions(values, paths, artifacts.planContextEnvelope),
+          metricsSince,
+        },
+      }),
+  );
+}
+
+/**
+ * Attach the plan-metrics roll-up for **this** invocation.
+ *
+ * Two Story #4541 fixes meet here. `readPlanMetrics` is declared
+ * `(epicId, config)` but was called with `config` first, so it threw its
+ * `epicId` guard on every run and the catch below turned that into a
+ * silently missing summary — v2 persist is always Epic-less, hence the
+ * explicit `null`. And the Epic-less ledger is shared across every plan the
+ * repo has ever run, so `since` scopes the counts to the current invocation
+ * instead of reporting lifetime totals under an invocation-shaped line.
+ *
+ * This runs *after* `recordPlanInvocation` has appended this run's own
+ * record, so the summary always has at least that one entry to report.
+ *
+ * @param {object} result Mutated in place with `planMetrics`.
+ * @param {object} config
+ * @param {string} since ISO-8601 instant this invocation started.
+ */
+async function attachPlanMetrics(result, config, since) {
   try {
-    return await readFile(filePath, 'utf8');
+    const summary = summarizePlanMetrics(await readPlanMetrics(null, config), {
+      since,
+    });
+    if (summary) {
+      result.planMetrics = summary;
+      Logger.info(`[plan-persist] ${renderPlanMetricsSummaryLine(summary)}`);
+    }
   } catch (err) {
-    if (!required && err?.code === 'ENOENT') return null;
-    throw new Error(`Cannot read ${filePath}: ${err.message}`);
+    Logger.warn(`[plan-persist] plan-metrics summary skipped: ${err.message}`);
   }
 }
 
 async function main() {
   const { values } = parseArgs({ options: CLI_OPTIONS });
 
-  if (values.force && values.resume) {
-    throw new Error('--force and --resume are mutually exclusive.');
-  }
-  if (values.amend && (values.force || values.resume)) {
-    throw new Error(
-      '--amend is mutually exclusive with --force/--resume — the amend ' +
-        'delta is already an incremental re-persist.',
-    );
-  }
-
-  const epicId = parseEpicId(values.epic);
-  const onePagerPath = values['one-pager'];
-  if (epicId === null && !onePagerPath) {
+  if (!values.stories) {
     throw new Error(USAGE);
   }
-  if (epicId !== null && onePagerPath) {
-    throw new Error(
-      '--epic and --one-pager are mutually exclusive (ideation mode opens ' +
-        `the Epic itself).\n${USAGE}`,
-    );
-  }
+
+  // stdout is reserved for the JSON result: flip every Logger sink that could
+  // land on stdout to stderr BEFORE any pipeline code runs (Story #2278
+  // discipline, extended here by Story #4541 — this CLI interleaved Logger
+  // lines with its own JSON, so a headless driver could not parse stdout).
+  routeAllOutputToStderr();
+
+  // Boundary for this invocation's plan-metrics roll-up — stamped before any
+  // ledger-writing work so every record this run appends falls inside it.
+  const metricsSince = new Date().toISOString();
 
   let config;
   try {
@@ -238,123 +304,20 @@ async function main() {
   } catch (err) {
     throw new Error(`Config schema validation failed:\n${err.message}`);
   }
-  const settings = {
-    baseBranch: config.project?.baseBranch,
-    paths: config.project?.paths,
-    planning: config.planning,
-    docsContextFiles: config.project?.docsContextFiles,
-  };
   const provider = createProvider(config);
+  const paths = resolveInputPaths(values);
+  const artifacts = await loadArtifacts(paths);
 
+  let result;
   try {
-    await drainPendingCleanupAtBoot({
-      repoRoot: PROJECT_ROOT,
+    result = await runPersistInvocation({
+      values,
       config,
       provider,
+      artifacts,
+      metricsSince,
     });
   } catch (err) {
-    Logger.warn(`[plan-persist] pending-cleanup drain skipped: ${err.message}`);
-  }
-
-  const {
-    techSpecPath,
-    riskVerdictPath,
-    ticketsPath,
-    acceptancePath,
-    acceptanceExplicit,
-    ticketsExplicit,
-  } = resolveArtifactPaths({ epicId, values, config });
-
-  // Deterministic local reads + validation before any GitHub call. A
-  // malformed risk verdict fails closed here (Epic #3865); the section
-  // gate itself runs first inside runPlanPersist.
-  const techSpecContent = await readOptional(techSpecPath, { required: true });
-  const riskVerdict = loadRiskVerdict(riskVerdictPath);
-  // Tickets are mode-dependent (#4474 PR4): required when explicitly
-  // passed or in --amend mode; otherwise best-effort — a single-delivery
-  // plan authors no tickets file at all, and the mode-coherence gate
-  // (`resolveDeliveryMode`) hard-errors on every contradictory combination
-  // (including a stale tickets.json next to a `deliveryShape: "single"`
-  // verdict).
-  const ticketsRequired = ticketsExplicit || values.amend;
-  const ticketsRaw = ticketsPath
-    ? await readOptional(ticketsPath, { required: ticketsRequired })
-    : null;
-  let tickets = null;
-  if (ticketsRaw !== null) {
-    try {
-      tickets = JSON.parse(ticketsRaw);
-    } catch (err) {
-      throw new Error(
-        `Failed to parse tickets file "${ticketsPath}" as JSON: ${err.message}`,
-      );
-    }
-  }
-  // Acceptance table: explicit path is required to exist; the per-Epic
-  // default is best-effort (absent file → no acceptance section, matching
-  // the waived/none dispositions).
-  const acceptanceSpecContent = acceptancePath
-    ? await readOptional(acceptancePath, { required: acceptanceExplicit })
-    : null;
-  const onePagerContent = onePagerPath
-    ? await readOptional(onePagerPath, { required: true })
-    : null;
-  const templateContent = onePagerContent
-    ? await readOptional(EPIC_FROM_IDEA_TEMPLATE_PATH, { required: true })
-    : null;
-
-  // Plan-metrics ledger (#4474 PR1): stamp entry/exit + mode. Ideation runs
-  // have no Epic id at entry, so they stamp on the standalone stream.
-  const mode = values.amend
-    ? 'amend'
-    : values.resume
-      ? 'resume'
-      : values.force
-        ? 'force'
-        : 'persist';
-  let result;
-  try {
-    result = await recordPlanInvocation(
-      { cli: 'plan-persist', mode, epicId, config },
-      () =>
-        runPlanPersist({
-          epicId,
-          provider,
-          artifacts: {
-            techSpecContent,
-            acceptanceSpecContent,
-            riskVerdict,
-            tickets,
-            onePagerContent,
-            templateContent,
-          },
-          config,
-          settings,
-          opts: {
-            force: values.force,
-            resume: values.resume,
-            amend: values.amend,
-            explicitDelete: values['explicit-delete'],
-            steal: values.steal,
-            forceReview: values['force-review'],
-            allowOverBudget: values['allow-over-budget'],
-            allowLargeFanOut: values['allow-large-fan-out'],
-          },
-        }),
-    );
-  } catch (err) {
-    // Amend close-op confirmation gate (exit 2, mirroring the
-    // epic-reconcile.js contract): print the dry-run diff so the operator
-    // reviews exactly what would close, mutate nothing, and exit 2 so
-    // non-interactive callers can branch on the code.
-    if (err?.code === 'PLAN_AMEND_EXPLICIT_DELETE_REQUIRED') {
-      process.stdout.write(`${err.diff}\n\n${err.message}\n`);
-      process.exitCode = 2;
-      return;
-    }
-    // Reachability soft failure (#4474 PR6): the orphan-surface list is the
-    // message; nothing was mutated (the check runs before any provider
-    // call). Exit 3 so non-interactive callers can branch on the code.
     if (err?.code === 'PLAN_REACHABILITY_ORPHANS') {
       process.stdout.write(`${err.message}\n`);
       process.exitCode = 3;
@@ -363,19 +326,7 @@ async function main() {
     throw err;
   }
 
-  // Surface the whole plan run's invocation ledger in the persist summary
-  // (#4474 PR1). Additive and best-effort.
-  try {
-    const summary = summarizePlanMetrics(
-      await readPlanMetrics(result.epicId, config),
-    );
-    if (summary) {
-      result.planMetrics = summary;
-      Logger.info(`[plan-persist] ${renderPlanMetricsSummaryLine(summary)}`);
-    }
-  } catch (err) {
-    Logger.warn(`[plan-persist] plan-metrics summary skipped: ${err.message}`);
-  }
+  await attachPlanMetrics(result, config, metricsSince);
 
   process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 }