mandrel 2.56.0 → 2.58.0

package/.agents/scripts/lib/observability/runtime-friction.js

@@ -76,7 +76,7 @@ export const RUNTIME_FRICTION_CATEGORIES = Object.freeze({
    */
   TOOL_DEGRADED: 'tool-degraded',
   /**
-   * The light delivery path refused a scope — a suitability-gate `ask-operator`
+   * The light delivery path refused a scope — a suitability-gate escalation
    * or a blocked diff backstop. Story #4856 added it because neither rejection
    * emitted anything, so an over-tight ceiling could only reach the framework
    * as anecdote; the roll-up aggregating these by category is what makes the

package/.agents/scripts/lib/observability/source-classifier.js

@@ -107,6 +107,7 @@ const FRAMEWORK_SCRIPT_BASENAMES = Object.freeze([
   'check-workflow-citations.js',
   'check-workflow-cli-lint.js',
   'check-workflow-timeouts.js',
+  'ceremony-derive.js',
   'cleanup-repo-test-temp.js',
   'coverage-capture.js',
   'deliver-light.js',

package/.agents/scripts/lib/orchestration/acceptance-eval-decision.js

@@ -43,11 +43,12 @@
  *                  The Story escalates to `agent::blocked`; it never
  *                  silently proceeds to close.
  *
- * ## The undisableable cap
+ * ## The cap
  *
- * `maxRounds` arrives already clamped by `lib/config/acceptance-eval.js`
- * into `[1, ceiling]`, but this reducer defends the invariant a second
- * time: a non-positive or non-integer cap is coerced to 1, so there is no
+ * `maxRounds` arrives normalized by `lib/config/acceptance-eval.js` as a
+ * non-negative integer (Story #5313: `0` means "score once, no redraft").
+ * This reducer maps that onto an effective cap of scored rounds: a cap of
+ * `0`, a negative value or a non-integer is coerced to 1, so there is no
  * input — config or verdict — that yields an unbounded `redraft` chain.
  * When `round >= effectiveCap` and criteria remain unmet, the only
  * possible action is `block`.

package/.agents/scripts/lib/orchestration/ceremony-routing.js

@@ -19,10 +19,10 @@
  *
  * ## Ceremony profiles (`delivery.routing.ceremonyProfile`)
  *
- *   - `minimal`  — always `inline` (skip fresh critic + sampling floor).
+ *   - `minimal`  — always `inline` (no fresh critic spawn).
  *                  Use for tiny N=1 Stories the operator trusts.
- *   - `standard` — level-routed (default). Low → inline (+ sampling floor);
- *                  high → fresh.
+ *   - `standard` — level-routed (default). Low → inline; high or
+ *                  underivable → fresh.
  *   - `strict`   — always `fresh` regardless of the derived level.
  *
  * ## The load-bearing invariant (M4-B acceptance floor — DO NOT VIOLATE)
@@ -51,9 +51,7 @@
  *
  *   - `high` level       → `fresh`   (a sensitive path was touched — a
  *                                     fresh-context maker-blind spawn).
- *   - `low` level        → `inline`  (the contract-identical inline critic),
- *                                     UNLESS the maker-checker sampling floor
- *                                     selects this cluster → `fresh`.
+ *   - `low` level        → `inline`  (the contract-identical inline critic).
  *   - missing / unknown  → `fresh`   (fail-safe: the diff could not be
  *                                     enumerated, so there is no evidence the
  *                                     change is unremarkable; treat it as
@@ -61,15 +59,14 @@
  *                                     exactly as `resolveDepth` degrades to
  *                                     `standard` on the same signal).
  *
- * ## Maker-checker sampling floor
+ * ## No sampling floor (Story #5313)
  *
- * Even at a `low` derived level under `standard`, a fraction of clusters
- * (`freshCriticSampleRate`, default 0.2) is forced `fresh` so a low level never
- * means zero independent checking. The selection is **deterministic** in the
- * cluster index (a fixed stride), so it is stable across re-runs and —
- * critically — never changes the cluster count: it only re-labels which of
- * the fixed set of clusters run fresh. Profiles `minimal` and `strict`
- * ignore the sampling floor.
+ * The maker-checker sampling floor (`delivery.routing.freshCriticSampleRate`,
+ * `sampledFresh`) bounded independent checking by a cluster-index stride —
+ * a count, not a risk signal — and was retired with the delivery diet. The
+ * standard profile now routes purely off the derived level, so the decision
+ * carries no `sampled` field and `clusterIndex` is accepted only for call-site
+ * compatibility (it never changes the outcome).
  *
  * Pure and total: inputs in, decision out. No I/O, no throws. `null` /
  * `undefined` / malformed inputs degrade to `fresh` + `full` ceremony.
@@ -119,49 +116,19 @@ function normalizeCeremonyProfile(value) {
 }
 
 /**
- * Decide whether the sampling floor forces this low-risk cluster fresh.
- *
- * Deterministic in the cluster index: with rate `r` (0 < r ≤ 1) the stride is
- * `round(1 / r)` and every `stride`-th cluster (0-based indices 0, stride,
- * 2·stride, …) is forced fresh, yielding ≈`r` of clusters fresh. `r <= 0`
- * disables the floor (no cluster forced); `r >= 1` forces every cluster.
- *
- * @param {number} clusterIndex  Zero-based cluster position (from the
- *   caller-owned fan-out — an INPUT, never mutated here).
- * @param {number} rate          Sampling rate, already clamped into [0, 1] by
- *   `getDeliveryRouting`.
- * @returns {boolean} `true` when the floor forces this cluster fresh.
- */
-export function sampledFresh(clusterIndex, rate) {
-  if (typeof rate !== 'number' || !Number.isFinite(rate) || rate <= 0) {
-    return false;
-  }
-  if (rate >= 1) return true;
-  const idx =
-    typeof clusterIndex === 'number' &&
-    Number.isInteger(clusterIndex) &&
-    clusterIndex >= 0
-      ? clusterIndex
-      : 0;
-  const stride = Math.max(1, Math.round(1 / rate));
-  return idx % stride === 0;
-}
-
-/**
- * Resolve the acceptance ceremony for one cluster from the ceremony profile,
- * the derived change level, and the maker-checker sampling floor. See the
- * module header for the tier rules and the untouchable cluster-count invariant.
+ * Resolve the acceptance ceremony for one cluster from the ceremony profile
+ * and the derived change level. See the module header for the tier rules and
+ * the untouchable cluster-count invariant.
  *
  * @param {{
  *   derivedLevel?: (ChangeLevel|string|null|undefined),
  *   clusterIndex?: (number|null|undefined),
- *   freshCriticSampleRate?: (number|null|undefined),
  *   ceremonyProfile?: (CeremonyProfile|string|null|undefined),
- * }} [input]
+ * }} [input] `clusterIndex` is accepted for call-site compatibility only
+ *   (Story #5313 retired the sampling floor that read it).
  * @returns {{
  *   mode: CeremonyMode,
  *   reason: string,
- *   sampled: boolean,
  *   profile: CeremonyProfile,
  *   verdictOwner: VerdictOwner,
  * }}
@@ -172,27 +139,20 @@ export function resolveCeremonyForRisk(input = {}) {
 }
 
 /**
- * Internal mode/reason resolution — the tier rules and sampling floor.
- * `resolveCeremonyForRisk` decorates the result with the single
- * `verdictOwner` derived from the mode (Story #4723).
+ * Internal mode/reason resolution — the tier rules. `resolveCeremonyForRisk`
+ * decorates the result with the single `verdictOwner` derived from the mode
+ * (Story #4723).
  *
  * @param {Parameters<typeof resolveCeremonyForRisk>[0]} [input]
  * @returns {{
  *   mode: CeremonyMode,
  *   reason: string,
- *   sampled: boolean,
  *   profile: CeremonyProfile,
  * }}
  */
 function resolveCeremonyDecision(input = {}) {
   const derivedLevel =
     input && typeof input === 'object' ? input.derivedLevel : undefined;
-  const clusterIndex =
-    input && typeof input === 'object' ? input.clusterIndex : undefined;
-  const rate =
-    input && typeof input === 'object'
-      ? input.freshCriticSampleRate
-      : undefined;
   const profile = normalizeCeremonyProfile(
     input && typeof input === 'object' ? input.ceremonyProfile : undefined,
   );
@@ -201,7 +161,6 @@ function resolveCeremonyDecision(input = {}) {
     return {
       mode: 'inline',
       reason: 'ceremonyProfile=minimal: inline critic (no fresh spawn)',
-      sampled: false,
       profile,
     };
   }
@@ -209,7 +168,6 @@ function resolveCeremonyDecision(input = {}) {
     return {
       mode: 'fresh',
       reason: 'ceremonyProfile=strict: fresh-context critic',
-      sampled: false,
       profile,
     };
   }
@@ -218,24 +176,13 @@ function resolveCeremonyDecision(input = {}) {
     return {
       mode: 'fresh',
       reason: 'sensitive path touched: fresh-context critic',
-      sampled: false,
       profile,
     };
   }
   if (derivedLevel === 'low') {
-    if (sampledFresh(clusterIndex, rate)) {
-      return {
-        mode: 'fresh',
-        reason:
-          'low-level cluster forced fresh by the maker-checker sampling floor',
-        sampled: true,
-        profile,
-      };
-    }
     return {
       mode: 'inline',
       reason: 'no sensitive path touched: contract-identical inline critic',
-      sampled: false,
       profile,
     };
   }
@@ -245,7 +192,6 @@ function resolveCeremonyDecision(input = {}) {
     mode: 'fresh',
     reason:
       'change level underivable: fail-safe fresh-context critic + full ceremony',
-    sampled: false,
     profile,
   };
 }

package/.agents/scripts/lib/orchestration/code-review.js

@@ -42,6 +42,7 @@
 import { hasSurvivingCritical } from '../audit-suite/findings.js';
 import { resolveConfig } from '../config-resolver.js';
 import { computeChangeSet } from './change-set.js';
+import { remoteBaseRef } from './review-base-ref.js';
 import { deriveChangeLevel, resolveDepth } from './review-depth.js';
 import {
   collectProviderDegradations,
@@ -70,11 +71,14 @@ import { upsertStructuredComment } from './ticketing.js';
  */
 
 /**
- * Resolve the project base branch fallback used when a caller omits
- * `baseRef`.
+ * Resolve the base ref used when a caller omits `baseRef`. Remote-qualified,
+ * never the bare branch name — a caller that does not name a base must not
+ * silently inherit the local ref's drift (Story #5325). An unfetched remote
+ * then yields an unenumerable diff, which every downstream consumer already
+ * fails safe on, instead of a confidently-wrong wide one.
  */
 function resolveConfigBase(config) {
-  return config?.project?.baseBranch ?? 'main';
+  return remoteBaseRef(config?.project?.baseBranch ?? 'main');
 }
 
 /** Positive-integer override, else the supplied default. */

package/.agents/scripts/lib/orchestration/complexity-gate.js

@@ -1,76 +1,46 @@
 /**
- * lib/orchestration/complexity-gate.js — shape-derived complexity routing
- * (Story #4722, superseding the word-count gate of Stories #4683/#4707).
- *
- * ## Route on the work, not the words
- *
- * The original gate routed a planning seed on its **word count**
- * (`maxSeedWords`), which is the wrong proxy in both directions: a detailed
- * prompt can describe trivial work, a terse one complex work. The bench
- * cohort (mandrel-bench 2.10.0) observed both failure modes — a lite verdict
- * fired at plan time and was then lost (a swallowed label write) or ignored
- * (deliver spawned a full story-worker anyway). This module now routes on the
- * **objective shape of the authored work**, staged across the pipeline:
- *
- *   1. **Plan time — signals, not routing.** {@link buildComplexitySignals}
- *      emits advisory complexity *signals* (enumerated-artifact count,
- *      risk-heuristic hits, repo state of predicted paths, sensitive-path
- *      classes) carrying **no routing authority**. There is no word ceiling.
- *   2. **Planner judgment, ledgered.** The planner owns the
- *      trivial-vs-standard verdict ({@link resolvePlannerRouteVerdict}) —
- *      `lite` only with a recorded reason, persisted on plan state. This
- *      generalizes the former one-way `applyPlannerDowngrade` seam into the
- *      authored verdict itself; the conservative default without a recorded
- *      reason is `full`.
- *   3. **Deterministic backstop at persist.** After authoring, the work has
- *      measurable shape: {@link deriveStoryShape} reads the Story's own
- *      effort and risk — distinct change kinds, declared magnitude,
- *      uncertainty, deployable/migration span, and sensitive-path classes —
- *      against {@link STORY_SHAPE_CEILINGS}. A `lite` claim whose work exceeds
- *      them **fails closed to `full`** (`run-plan-persist.js`). Artifact
- *      cardinality is deliberately not an axis (Story #4764).
- *   4. **Deliver dispatches on topology alone.** The dispatch *mode*
- *      ({@link resolveStoryDispatchMode}) answers a different question from
- *      the route: may the engine run in the router's own session? Only a
- *      **single-Story run** may (Story #4736) — sub-agent isolation buys
- *      nothing when there is no concurrent sibling to isolate from. Shape
- *      cannot grant that session (Story #4829): a lite body makes work cheap,
- *      it does not conjure a second session for a sibling to run in. Story
- *      #5006 removed the shape derivation that survived there for reporting,
- *      since no consumer read it. The `route::lite` label is a
- *      **human-visible hint only**, never the control signal. Either way every
- *      `single-story-close.js` gate runs unchanged.
+ * lib/orchestration/complexity-gate.js — shape-derived Story routing for the
+ * deliver side (Story #4722; plan-side lite claim deleted by Story #5312).
+ *
+ * Three surfaces survive, all read at delivery time:
+ *
+ *   1. **Seed signals ({@link buildComplexitySignals}).** `/mandrel-plan`'s
+ *      context envelope carries the paths a seed predicts, their repo state
+ *      (existing paths predict refactors; missing ones predict creates) and
+ *      the `audit-rules.json` sensitive-path classes the footprint intersects.
+ *      They ground the authoring template's `changes[]` skeleton and the
+ *      `/prototype` offer; they route nothing.
+ *   2. **Story shape ({@link deriveStoryShape}).** The light path
+ *      (`deliver-light`) reads a predicted footprint's effort and risk —
+ *      distinct change kinds, declared magnitude, uncertainty,
+ *      deployable/migration span, sensitive-path classes — against
+ *      {@link STORY_SHAPE_CEILINGS} to decide whether a prompt may skip the
+ *      Story-authoring ceremony. Artifact cardinality is deliberately not an
+ *      axis (Story #4764).
+ *   3. **Dispatch mode ({@link resolveStoryDispatchMode}).** `/mandrel-deliver`
+ *      answers a different question from the route: may the engine run in the
+ *      router's own session? Only a **single-Story run** may (Story #4736).
+ *
+ * Story #5312 deleted the plan-side half: the planner's authored lite claim
+ * (`--route-downgrade-reason`), the persist-time shape backstop that
+ * validated it, the `route::lite` hint label, and the
+ * `planning.complexityGate` knobs. Persist no longer routes; every Story
+ * lands through the same engine and the same close gates, and the shape
+ * ceilings below are read only where a shape is actually decided on.
  *
  * The shape taxonomy is deliberately the one `review-depth.js` already
  * applies to the landed diff at close (`deriveChangeLevel` over the
  * `audit-rules.json` sensitive-path classes): **predicted shape at dispatch,
- * actual diff at close** — one taxonomy, two read points. And sensitivity
- * always wins: a small change whose footprint intersects a sensitive-path
- * class routes `full`, which keeps its fresh acceptance critic
- * (`ceremony-routing.js` routes a high derived level to a fresh spawn).
- *
- * ## What "lite" changes and — critically — what it never changes
- *
- * The lite route collapses the **advisory ceremony** only: the story-worker
- * sub-agent boot and the fresh acceptance-critic spawn. It **never** relaxes
- * a non-negotiable. {@link LITE_PATH_INVARIANTS} is the machine-readable
- * contract that the lite path still produces a Story ticket, still lands via
- * a PR to `main`, still runs every repo quality gate, and still honours
+ * actual diff at close** — one taxonomy, two read points. Sensitivity always
+ * wins: a small change whose footprint intersects a sensitive-path class
+ * routes `full`, which keeps its fresh acceptance critic.
+ *
+ * {@link LITE_PATH_INVARIANTS} is the machine-readable contract that the
+ * light path still produces a Story ticket, still lands via a PR to `main`,
+ * still runs every repo quality gate, and still honours
  * `rules/security-baseline.md`. Those gates run in `single-story-close.js`
  * regardless of route; the router cannot and does not switch them off.
  *
- * ## Configuration
- *
- * Operators tune the surface via `planning.complexityGate` in `.agentrc.json`:
- *
- *   - `enabled`      (default `true`) — `false` disables lite routing
- *     everywhere: persist refuses lite claims and dispatch always takes the
- *     sub-agent path.
- *   - `maxArtifacts` (default `1`)    — enumerated-artifact signal threshold;
- *     an **input signal** for the planner, no longer a deterministic router.
- *
- * `maxSeedWords` is **removed** (hard cutover): word count routes nothing.
- *
  * @typedef {'lite'|'full'} ComplexityRoute
  */
 
@@ -79,27 +49,6 @@ import path from 'node:path';
 import { extractChangePaths } from '../story-body/story-body.js';
 import { deriveChangeLevel } from './review-depth.js';
 
-/**
- * Framework defaults for the complexity-routing surface. The SSOT the config
- * schema mirror and the configuration reference both cite. `maxSeedWords` is
- * gone: seed word count carries no routing authority (Story #4722).
- */
-const DEFAULT_COMPLEXITY_GATE = Object.freeze({
-  enabled: true,
-  maxArtifacts: 1,
-});
-
-/**
- * The persisted route marker for a lite-routed Story.
- *
- * **A human-visible hint only (Story #4722)** — never the control signal.
- * Persist applies it so a lite cohort is filterable in the GitHub UI, and
- * `deliver-light` reads the Story's own shape ({@link deriveStoryShape}) when
- * it needs one. Nothing routes on the label: a lost label or an unread marker
- * cannot misroute delivery.
- */
-export const LITE_ROUTE_LABEL = 'route::lite';
-
 /**
  * Effort/risk ceilings a Story's work must fit for the `lite` route
  * ({@link deriveStoryShape}). Framework constants, not operator knobs — a
@@ -378,54 +327,6 @@ const LITE_PATH_INVARIANTS = Object.freeze({
   securityBaseline: true,
 });
 
-/**
- * Coerce a candidate ceiling into a non-negative integer, falling back to the
- * framework default for anything malformed — a stray `-1` or `NaN` must never
- * widen the lite path (fail conservative).
- *
- * @param {unknown} value
- * @param {number} fallback
- * @returns {number}
- */
-function normalizeCeiling(value, fallback) {
-  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-    return fallback;
-  }
-  return Math.floor(value);
-}
-
-/**
- * Resolve the effective complexity-gate config, shallow-overlaying an
- * operator `planning.complexityGate` block onto
- * {@link DEFAULT_COMPLEXITY_GATE}. Accepts the full resolved config, the bare
- * `planning` bag, or the bare `complexityGate` bag, mirroring the tolerant
- * unwrap the other routing accessors use.
- *
- * Exported for persist (`run-plan-persist.js#resolveEffectiveRoute`), which
- * consults `enabled` to refuse a planner lite claim when the gate is off —
- * the schema's documented contract. It is the only read point: Story #5006
- * removed the second one in {@link resolveStoryDispatchMode}, where the switch
- * gated a shape derivation whose result no consumer read.
- *
- * @param {object | null | undefined} config
- * @returns {{ enabled: boolean, maxArtifacts: number }}
- */
-export function resolveComplexityGate(config) {
-  const raw =
-    config?.planning?.complexityGate ?? config?.complexityGate ?? config ?? {};
-  const bag = raw && typeof raw === 'object' ? raw : {};
-  return {
-    enabled:
-      typeof bag.enabled === 'boolean'
-        ? bag.enabled
-        : DEFAULT_COMPLEXITY_GATE.enabled,
-    maxArtifacts: normalizeCeiling(
-      bag.maxArtifacts,
-      DEFAULT_COMPLEXITY_GATE.maxArtifacts,
-    ),
-  };
-}
-
 /**
  * Count top-level enumerated items (`- `, `* `, `1. `) in a free-form seed —
  * each enumerated line is one predicted artifact.
@@ -464,20 +365,17 @@ function extractPredictedPaths(text) {
 }
 
 /**
- * Build the advisory complexity **signals** for a planning seed
- * (Story #4722 AC-2). Signals, not routing: the result carries
- * `routingAuthority: false` and no `route` field — the planner reads these
- * alongside its own judgment ({@link resolvePlannerRouteVerdict}) and the
- * deterministic shape backstop validates the authored Story at persist.
- *
- *   - `artifactCount`         — enumerated items in the seed, with the
- *                               configured `maxArtifacts` threshold beside it
- *                               as one input signal.
- *   - `riskHeuristicHits`     — `planning.riskHeuristics` phrases present in
- *                               the seed (same substring matcher the
- *                               pre-mortem critic uses).
- *   - `predictedPaths` / `repoState` — path-like tokens in the seed and
- *                               which of them exist in the repo (existing
+ * Build the advisory complexity **signals** for a planning seed. Signals,
+ * not routing: the result carries `routingAuthority: false` and no `route`
+ * field — they ground the authoring template's pre-resolved `changes[]` and
+ * the `/prototype` offer, nothing else (Story #5312 deleted the risk-heuristic
+ * hits and the `planning.complexityGate` echo that used to ride alongside).
+ *
+ *   - `artifactCount`         — enumerated items in the seed, a rough width
+ *                               signal for the operator's eye only.
+ *   - `predictedPaths`        — path-like tokens the seed names, in order of
+ *                               first appearance (capped).
+ *   - `repoState`             — which predicted paths exist in the repo (existing
  *                               paths predict refactors; missing predict
  *                               creates).
  *   - `sensitivePathClasses`  — `audit-rules.json` sensitive-path classes the
@@ -489,8 +387,6 @@ function extractPredictedPaths(text) {
  *
  * @param {{
  *   seedText?: string,
- *   config?: object,
- *   riskHeuristics?: string[],
  *   cwd?: string,
  *   pathExistsFn?: (absPath: string) => boolean,
  *   injectedRules?: object,
@@ -498,37 +394,21 @@ function extractPredictedPaths(text) {
  * }} [args]
  * @returns {{
  *   artifactCount: number,
- *   maxArtifacts: number,
- *   riskHeuristicHits: string[],
  *   predictedPaths: string[],
  *   repoState: { existingPaths: string[], missingPaths: string[] },
  *   sensitivePathClasses: string[],
- *   gate: { enabled: boolean },
  *   advisory: true,
  *   routingAuthority: false,
  * }}
  */
 export function buildComplexitySignals({
   seedText = '',
-  config,
-  riskHeuristics = [],
   cwd,
   pathExistsFn = existsSync,
   injectedRules,
   selectSensitivePathClassesFn,
 } = {}) {
-  const gate = resolveComplexityGate(config);
   const text = typeof seedText === 'string' ? seedText : '';
-  const haystack = text.toLowerCase();
-
-  const riskHeuristicHits = (
-    Array.isArray(riskHeuristics) ? riskHeuristics : []
-  ).filter(
-    (phrase) =>
-      typeof phrase === 'string' &&
-      phrase.trim().length > 0 &&
-      haystack.includes(phrase.trim().toLowerCase()),
-  );
 
   const predictedPaths = extractPredictedPaths(text);
   const root = typeof cwd === 'string' && cwd !== '' ? cwd : process.cwd();
@@ -552,60 +432,14 @@ export function buildComplexitySignals({
 
   return {
     artifactCount: countSeedArtifacts(text),
-    maxArtifacts: gate.maxArtifacts,
-    riskHeuristicHits,
     predictedPaths,
     repoState: { existingPaths, missingPaths },
     sensitivePathClasses: classes,
-    gate: { enabled: gate.enabled },
     advisory: /** @type {const} */ (true),
     routingAuthority: /** @type {const} */ (false),
   };
 }
 
-/**
- * Resolve the planner's authored trivial-vs-standard verdict
- * (Story #4722 AC-2, generalizing the former one-way `applyPlannerDowngrade`
- * seam into the verdict itself).
- *
- * The planner — not a word count — owns the judgment, and the contract keeps
- * it auditable: `lite` **only** with a non-empty recorded reason (carried on
- * `authored` and ledgered on every created Story's `story-plan-state`
- * checkpoint by persist). Absent a recorded reason the conservative default
- * stands: `full`, with `authored: null`. Pure and total.
- *
- * The verdict is a **claim**, not the decision — persist validates it against
- * the authored Story's shape ({@link deriveStoryShape}) and fails closed to
- * `full` when the shape exceeds the ceilings.
- *
- * @param {{ reason?: unknown }} [args]
- * @returns {{
- *   route: ComplexityRoute,
- *   reasons: string[],
- *   authored: Readonly<{ route: 'lite', reason: string }>|null,
- *   preserves: typeof LITE_PATH_INVARIANTS,
- * }}
- */
-export function resolvePlannerRouteVerdict({ reason } = {}) {
-  const recorded = typeof reason === 'string' ? reason.trim() : '';
-  if (recorded === '') {
-    return {
-      route: 'full',
-      reasons: [
-        'no authored lite verdict (no recorded reason) — standard full route',
-      ],
-      authored: null,
-      preserves: LITE_PATH_INVARIANTS,
-    };
-  }
-  return {
-    route: 'lite',
-    reasons: [`planner verdict: lite (recorded reason): ${recorded}`],
-    authored: Object.freeze({ route: 'lite', reason: recorded }),
-    preserves: LITE_PATH_INVARIANTS,
-  };
-}
-
 /**
  * Assemble the effort/risk shape of a footprint — the evidence
  * {@link deriveStoryShape} decides on and carries on its result.