mandrel 2.58.0 → 2.60.0

package/.agents/scripts/lib/orchestration/light-suitability.js

@@ -16,35 +16,29 @@
  *
  * ## Four invariants keep it proportional, not a planning bypass
  *
- *   1. **Suitability gate ({@link deriveLightSuitability}).** The prompt's
- *      predicted footprint is judged by the **shared shape machinery**
+ *   1. **Risk gate ({@link deriveLightSuitability}).** The prompt's predicted
+ *      footprint is judged for **risk** by the shared machinery
  *      ({@link module:lib/orchestration/complexity-gate.deriveStoryShape} over
- *      {@link module:lib/orchestration/complexity-gate.STORY_SHAPE_CEILINGS})
- *      **and** a ledgered model verdict carrying a recorded reason
- *      ({@link resolveLedgeredVerdict}). Both must agree on `lite`; either
- *      falling short fails closed to `full`. The shape axes are effort and
- *      risk — distinct change kinds, a coarse magnitude bucket, uncertainty,
- *      and epic-scope span — never artifact counts (Story #4764), so this gate
- *      is deliberately **coarse**: it rejects clearly-epic work, and invariant
- *      3 below does the real enforcement against ground truth.
- *   2. **The predicted shape is a warning, not a gate ({@link
- *      resolveLightGateOutcome}, Story #5313).** An over-ceiling prediction
- *      proceeds light with a `warnings[]` entry naming the exceeded axis — the
- *      prediction is a guess, and invariant 3 bounds the real change set. Only
- *      the two things no re-slicing can fix still refuse: an un-ledgered
- *      verdict and an un-waivable risk rule (a sensitive-path class or a
- *      migration span), which route `full` through an `escalated` terminal.
- *      The former `ask-operator` outcome and its `--operator-proceed-light`
- *      answer are gone with the gate they answered.
+ *      the `audit-rules.json` sensitive-path classes and the
+ *      migration-with-consumers span) **and** a ledgered verdict carrying a
+ *      recorded reason ({@link resolveLedgeredVerdict}). A tripped risk rule
+ *      or an unrecorded reason fails closed to `full`.
+ *   2. **Nothing the caller declares about its own size decides (Story
+ *      #5344).** The predicted-shape ceilings — declared change kinds, a
+ *      magnitude bucket, an uncertainty bucket, a deployable span — are gone,
+ *      along with the `warnings[]` Story #5313 had already demoted them to.
+ *      They were self-declared by the agent asking to proceed, and once they
+ *      only warned they decided nothing at all. What is left reads evidence:
+ *      the predicted PATHS at the gate, and the actual diff at invariant 3.
  *   3. **Diff-derived backstop ({@link checkLightDiffBackstop}).** After
  *      implementation the **actual** change set is re-checked with
  *      {@link module:lib/orchestration/review-depth.deriveChangeLevel} plus the
  *      implementation-only magnitude ceilings of {@link LIGHT_DIFF_CEILINGS} —
- *      the diff is the real scope signal — and an over-ceiling diff is blocked
- *      rather than landed silently. Story #4856 moved this from a `maxFiles: 4`
+ *      the diff is the real scope signal, and since Story #5344 it is the ONLY
+ *      size block on the path. Story #4856 moved it from a `maxFiles: 4`
  *      cardinality ceiling to changed lines over implementation files, and made
- *      a block **recycle** its receipt Story through `/mandrel-plan` tickets mode
- *      instead of orphaning it.
+ *      a block **recycle** its receipt Story through `/mandrel-plan` tickets
+ *      mode instead of orphaning it.
  *   4. **Minimal receipt Story ({@link buildReceiptStoryTicket}).** A
  *      `type::story` ticket is authored inline so `refs #`, history, telemetry,
  *      and the `agent::executing -> agent::done` state machine survive.
@@ -56,11 +50,7 @@
  * @module lib/orchestration/light-suitability
  */
 
-import {
-  deriveStoryShape,
-  SHAPE_CODES,
-  STORY_SHAPE_CEILINGS,
-} from './complexity-gate.js';
+import { deriveStoryShape, SHAPE_CODES } from './complexity-gate.js';
 import { deriveChangeLevel } from './review-depth.js';
 
 /**
@@ -71,17 +61,16 @@ import { deriveChangeLevel } from './review-depth.js';
  * No re-slicing, shrinking, or operator answer satisfies one: a footprint
  * intersecting a sensitive-path class routes `full` however small the change,
  * and the diff backstop refuses the same footprint again at the end. But
- * {@link deriveStoryShape} reports only the **first** rule a shape trips and
- * evaluates the ceiling rules first, so a prompt tripping both `change-kinds`
- * and `sensitive-path` is reported as a size objection — which reads as
- * appealable, is waivable by an attended operator, and sends the work all the
- * way to an implementation the backstop then refuses.
+ * {@link deriveStoryShape} reports only the **first** rule a footprint trips,
+ * and it can reject on an unknown footprint (a glob, an absent acceptance
+ * list) before either risk rule is reached — so the recorded `code` is not a
+ * reliable answer to "is this risk or is this something I can fix?".
  *
- * The recovery is that the shape decision attaches the built effort shape to
+ * The recovery is that the shape decision attaches the built risk shape to
  * every footprint it can judge at all, and that shape carries the risk facts
- * (`sensitiveClasses`, `migrationSpan`) whether or not a risk rule fired.
- * Reading them here surfaces the objection first-hit reporting hides — the
- * difference between a wasted session and a redirected one.
+ * (`sensitiveClasses`, `migrationSpan`) whether or not a risk rule was the
+ * recorded one. Reading them here surfaces the objection first-hit reporting
+ * hides — the difference between a wasted session and a redirected one.
  *
  * Pure and total.
  *
@@ -193,96 +182,87 @@ function resolveDiffCeilings(ceilings) {
 }
 
 /**
- * Resolve the model's trivial-vs-standard verdict, held to a ledgering
- * contract: a `lite` route counts **only** with a non-empty recorded reason. A lite claim
- * without a recorded reason, or any non-`lite` route, fails closed to `full` —
- * an unaudited "trust me, it's small" never buys the light path.
+ * Resolve the model's ledgered light verdict: the **recorded reason** is the
+ * whole of it. A prompt arriving with no reason fails closed to `full` — an
+ * unaudited "trust me, it's small" never buys the light path.
+ *
+ * Story #5344 removed the `--route lite|full` half. It was a second
+ * self-declaration on top of the reason, and it carried no information the
+ * reason did not: a caller writing a reason is claiming `lite`, and one that
+ * meant `full` would not be invoking this gate. What survives is the part that
+ * leaves a record a human can read afterwards.
+ *
+ * Story #5366 removed the `route` field this used to carry beside `recorded`.
+ * It was a second spelling of the same boolean — `recorded === false` IS the
+ * fail-closed route — and two fields that must agree are a chance for them
+ * not to.
  *
  * Pure and total.
  *
- * @param {{ route?: unknown, reason?: unknown }} [verdict]
+ * @param {{ reason?: unknown }} [verdict]
  * @returns {{
- *   route: 'lite'|'full',
  *   reason: string|null,
  *   recorded: boolean,
  *   note: string,
  * }}
  */
-export function resolveLedgeredVerdict({ route, reason } = {}) {
+export function resolveLedgeredVerdict({ reason } = {}) {
   const recordedReason = typeof reason === 'string' ? reason.trim() : '';
-  if (route !== 'lite') {
-    return {
-      route: 'full',
-      reason: recordedReason || null,
-      recorded: recordedReason !== '',
-      note: 'model verdict is not lite — standard /mandrel-plan route',
-    };
-  }
   if (recordedReason === '') {
     return {
-      route: 'full',
       reason: null,
       recorded: false,
-      note: 'lite claim without a recorded reason — fails closed to full (the verdict must be ledgered)',
+      note: 'no recorded reason — fails closed to full (the light verdict must be ledgered)',
     };
   }
   return {
-    route: 'lite',
     reason: recordedReason,
     recorded: true,
-    note: `model verdict: lite (recorded reason): ${recordedReason}`,
+    note: `light verdict (recorded reason): ${recordedReason}`,
   };
 }
 
 /**
  * Judge whether an operator prompt's predicted footprint is suitable for the
- * light path. The deterministic effort/risk derivation and the ledgered model
- * verdict must **both** agree on `lite`; anything else — clearly-epic work, a
- * sensitive-path footprint, an unledgered verdict — resolves to `full` (the
- * conservative default that routes the operator to `/mandrel-plan`).
- *
- * The predicted axes are declared by the caller: `predictedKinds` (the distinct
- * kinds of change; absent, each entry's `assumption` is its kind, so N
- * instances of one mechanical edit count once), `predictedMagnitude`
- * (`trivial` | `moderate` | `substantial`), and `predictedUncertainty`
- * (`determined` | `needs-design`). A malformed bucket fails closed; an absent
- * one carries no signal, because a marginal footprint must not be rejected on
- * counts the diff backstop is the right place to enforce.
+ * light path. Two things can refuse, and both are checks the caller cannot
+ * satisfy by re-describing its own request: an **un-waivable risk rule** read
+ * off the predicted paths (a sensitive-path class, a migration paired with its
+ * consumers) and an **un-ledgered verdict** (no recorded reason). Everything
+ * else proceeds light and is bounded for real by
+ * {@link checkLightDiffBackstop} against the actual diff.
+ *
+ * Story #5344 removed the declared effort axes — `predictedKinds`,
+ * `predictedMagnitude`, `predictedUncertainty` — and the `warnings[]` Story
+ * #5313 had demoted them to. A bucket the caller picks about its own request
+ * is not a measurement, and once it only warned it was not even a gate.
+ * Story #5366 removed `predictedAcceptance` for the same reason from the
+ * other end: its zero-check was the only thing that read it, and the
+ * `--acceptance` flag that fed it clamped to a floor of one.
+ *
+ * The result reports `suitable` and nothing that restates it. The `route`
+ * field it used to carry was a second spelling of that same boolean, and no
+ * caller read it — {@link resolveLightGateOutcome} branches on `suitable`.
  *
  * Pure and total: never throws, never mutates its inputs.
  *
  * @param {{
  *   predictedChanges?: unknown,
- *   predictedAcceptance?: unknown,
- *   predictedKinds?: unknown,
- *   predictedMagnitude?: unknown,
- *   predictedUncertainty?: unknown,
- *   verdict?: { route?: unknown, reason?: unknown },
+ *   verdict?: { reason?: unknown },
  *   injectedRules?: object,
  *   selectSensitivePathClassesFn?: Function,
  * }} [args]
  * @returns {{
  *   suitable: boolean,
- *   route: 'lite'|'full',
  *   shape: ReturnType<typeof deriveStoryShape>,
  *   ledger: ReturnType<typeof resolveLedgeredVerdict>,
  *   unwaivable: ReturnType<typeof deriveUnwaivableRisk>,
- *   ceilings: typeof STORY_SHAPE_CEILINGS,
  *   reasons: string[],
- *   warnings: string[],
  * }} `unwaivable` names an absolute risk rule the predicted footprint trips
- *   even when the recorded `shape.code` is a size prediction (Story #4875), so
+ *   even when the recorded `shape.code` is something else (Story #4875), so
  *   the operator learns at prediction time that no re-slicing can help.
- *   `warnings` carries the predicted-shape objection when the shape is past a
- *   light ceiling (Story #5313): it names the exceeded axis, and it never
- *   decides `suitable` — the diff backstop bounds the real change set.
  */
 export function deriveLightSuitability({
   predictedChanges,
-  predictedAcceptance,
-  predictedKinds,
-  predictedMagnitude,
-  predictedUncertainty,
   verdict,
   injectedRules,
   selectSensitivePathClassesFn,
@@ -290,59 +270,22 @@ export function deriveLightSuitability({
   const ledger = resolveLedgeredVerdict(verdict ?? {});
   const shape = deriveStoryShape({
     changes: predictedChanges,
-    acceptance: predictedAcceptance,
-    kinds: predictedKinds,
-    magnitude: predictedMagnitude,
-    uncertainty: predictedUncertainty,
     injectedRules,
     selectSensitivePathClassesFn,
   });
   const unwaivable = deriveUnwaivableRisk(shape);
-  // Story #5313: the predicted shape no longer decides. A tripped risk rule is
-  // decisive on its own — a sensitive footprint can never be lite — and the
-  // ledgered verdict must still be lite; everything the shape ceilings say is
-  // carried as a warning for the operator and bounded for real by the backstop.
-  const suitable = ledger.route === 'lite' && !unwaivable.present;
+  const suitable = ledger.recorded && !unwaivable.present;
   const reasons = [`shape: ${shape.reasons[0]}`];
   if (unwaivable.present) reasons.push(unwaivable.reason);
   reasons.push(`verdict: ${ledger.note}`);
-  return {
-    suitable,
-    route: suitable ? 'lite' : 'full',
-    shape,
-    ledger,
-    unwaivable,
-    ceilings: STORY_SHAPE_CEILINGS,
-    reasons,
-    warnings: shapeWarnings(shape),
-  };
-}
-
-/**
- * The predicted-shape objection as a warning (Story #5313): one entry naming
- * the exceeded axis (`shape.code`) and the shape's own reason, or none when
- * the prediction is within every light ceiling.
- *
- * @param {ReturnType<typeof deriveStoryShape>} shape
- * @returns {string[]}
- */
-function shapeWarnings(shape) {
-  if (shape?.route === 'lite') return [];
-  const axis = shape?.code ?? 'unknown';
-  const reason = shape?.reasons?.[0] ?? 'no reason recorded';
-  return [
-    `predicted shape exceeds a light ceiling on "${axis}": ${reason} — ` +
-      'proceeding light; the diff backstop bounds the actual change set',
-  ];
+  return { suitable, shape, ledger, unwaivable, reasons };
 }
 
 /**
  * Resolve what the light gate does with a suitability decision (Story #4740
- * AC-3; Story #5313).
+ * AC-3; Story #5313; Story #5344).
  *
- *   - suitable        → `proceed-light`, carrying the predicted-shape
- *                       `warnings[]` (possibly empty) so an over-ceiling
- *                       prediction is stated, never silent.
+ *   - suitable        → `proceed-light`.
  *   - not suitable    → `escalate-plan` — only an un-ledgered verdict or an
  *                       un-waivable risk rule gets here, and neither has an
  *                       answer an operator could give, so there is no
@@ -351,11 +294,10 @@ function shapeWarnings(shape) {
  * Pure and total.
  *
  * @param {{
- *   suitability?: { suitable?: boolean, reasons?: string[], warnings?: string[] },
+ *   suitability?: { suitable?: boolean, reasons?: string[] },
  * }} [args]
  * @returns {{
  *   action: 'proceed-light'|'escalate-plan',
- *   warnings: string[],
  *   reasons: string[],
  * }}
  */
@@ -363,29 +305,22 @@ export function resolveLightGateOutcome({ suitability } = {}) {
   const reasons = Array.isArray(suitability?.reasons)
     ? [...suitability.reasons]
     : [];
-  const warnings = Array.isArray(suitability?.warnings)
-    ? [...suitability.warnings]
-    : [];
 
   if (suitability?.suitable === true) {
     return {
       action: 'proceed-light',
-      warnings,
       reasons: [
         ...reasons,
-        warnings.length > 0
-          ? 'ledgered verdict lite and no un-waivable risk — proceeding light with a predicted-shape warning'
-          : 'predicted shape and ledgered verdict both lite — proceed light',
+        'ledgered verdict recorded and no un-waivable risk rule fired — proceed light; the diff backstop bounds the actual change set',
       ],
     };
   }
 
   return {
     action: 'escalate-plan',
-    warnings,
     reasons: [
       ...reasons,
-      'the ledgered verdict is not lite or an un-waivable risk rule fired — fails closed to /mandrel-plan (never silently proceeds light)',
+      'the verdict is un-ledgered or an un-waivable risk rule fired — fails closed to /mandrel-plan (never silently proceeds light)',
     ],
   };
 }

package/.agents/scripts/lib/orchestration/plan-context.js

@@ -31,10 +31,6 @@ import {
   renderStorySplitRules,
   ticketsModePromptField,
 } from '../templates/decomposer-prompts.js';
-import {
-  renderAcceptanceSpecSystemPrompt,
-  renderTechSpecSystemPrompt,
-} from '../templates/spec-author-prompts.js';
 import { concurrentMap, FANOUT_CONCURRENCY } from '../util/concurrent-map.js';
 import { buildComplexitySignals } from './complexity-gate.js';
 import { findDependencyCandidates } from './dependency-candidates.js';
@@ -260,18 +256,17 @@ export const STORIES_TEMPLATE_FILENAME = 'stories.template.json';
 
 /**
  * Build the template's `changes[]` entries from the envelope's advisory
- * complexity signals (Story #4723). Each seed-predicted path is
- * pre-resolved to its creates-vs-refactors assumption against the repo
- * snapshot the signals already probed: a path present in the repo is a
- * `refactors-existing`, a missing one is a `creates`. Order follows
+ * complexity signals (Story #4723). Each seed-predicted path is emitted as a
+ * **bare path string** — the default authored form since Story #5342. The
+ * template used to pre-resolve each one to a creates-vs-refactors assumption
+ * against the repo snapshot; persist re-derives it against the base-branch
+ * ref, which is the authoritative probe, so the skeleton no longer carries a
+ * second answer for the author to keep in sync. Order follows
  * `predictedPaths` (first appearance in the seed). Falls back to the
  * single instructive placeholder entry when the seed predicted no paths.
  *
- * @param {{
- *   predictedPaths?: string[],
- *   repoState?: { existingPaths?: string[], missingPaths?: string[] },
- * }|null|undefined} complexitySignals
- * @returns {Array<{ path: string, assumption: string }>}
+ * @param {{ predictedPaths?: string[] }|null|undefined} complexitySignals
+ * @returns {string[]}
  */
 function buildTemplateChanges(complexitySignals) {
   const predicted = Array.isArray(complexitySignals?.predictedPaths)
@@ -279,18 +274,7 @@ function buildTemplateChanges(complexitySignals) {
         (p) => typeof p === 'string' && p.length > 0,
       )
     : [];
-  if (predicted.length === 0) {
-    return [{ path: 'path/to/file.ext', assumption: 'refactors-existing' }];
-  }
-  const existing = new Set(
-    Array.isArray(complexitySignals?.repoState?.existingPaths)
-      ? complexitySignals.repoState.existingPaths
-      : [],
-  );
-  return predicted.map((path) => ({
-    path,
-    assumption: existing.has(path) ? 'refactors-existing' : 'creates',
-  }));
+  return predicted.length === 0 ? ['path/to/file.ext'] : predicted;
 }
 
 /**
@@ -309,10 +293,10 @@ function buildTemplateChanges(complexitySignals) {
  *
  * Correct-by-construction skeleton (Story #4723): when the envelope's
  * `complexitySignals` predicted a footprint the `changes[]` entries arrive
- * pre-resolved to creates-vs-refactors against the repo snapshot — a
- * faithfully-filled skeleton passes the persist ticket validators without a
- * mechanical round-trip. The persist gates stay
- * authoritative (they probe the base branch ref, not the working tree).
+ * already filled in, as the bare paths Story #5342 made the default form —
+ * a faithfully-filled skeleton passes the persist ticket validators without a
+ * mechanical round-trip. Persist derives each assumption by probing the base
+ * branch ref and reports the derivation.
  *
  * Pure and deterministic; the output is valid JSON (parseable as-is), with
  * instructive placeholder values rather than comments.
@@ -329,6 +313,17 @@ export function renderStoriesTemplate({ complexitySignals = null } = {}) {
       title: 'Fill: short descriptive title',
       body: {
         goal: 'Fill: one sentence stating why this Story exists.',
+        // A filled, multi-checkpoint example rather than a placeholder
+        // (Story #5332): `## Slicing` is how one cohesive sweep stays one
+        // Story, so the skeleton has to show an author what a checkpoint
+        // list looks like. Each line is a stage of the work — a commit
+        // boundary inside one session — never a restatement of an
+        // acceptance item, which states what is true once the Story lands.
+        slicing:
+          '1. Re-anchor the shared constant and its consumers.\n' +
+          '2. Move the gate ahead of the first write and arm the refusal.\n' +
+          '3. Delete the superseded module, its test and its flag.\n' +
+          '4. Regenerate the affected baselines; run the full gate chain.',
         spec:
           'Optional — contract and invariants only: interfaces, status ' +
           'codes, security invariants, and load-bearing constraints with ' +
@@ -340,7 +335,7 @@ export function renderStoriesTemplate({ complexitySignals = null } = {}) {
         non_goals: [],
       },
       acceptance: [
-        'Fill: an outcome a PR reviewer can confirm from the diff and the verify output (three to six items)',
+        'Fill: an outcome a PR reviewer can confirm from the diff and the verify output — as many as the capability has, no target and no ceiling',
       ],
       verify: [
         'Fill: exact command or test path — the mechanical check the acceptance item rests on',
@@ -367,25 +362,23 @@ function countEnumeratedItems(text) {
 }
 
 /**
- * Delta-shaped change-request verbs — the `core/scope-triage` skill's
- * change-request rubric routes these to `story` by default when the
- * footprint stays inside Story width.
+ * Delta-shaped change-request verbs — a change request naming one of these
+ * stays a Story by default when the footprint stays inside Story width.
  */
 const DELTA_VERB_RE =
   /\b(fix(?:es)?|tweak(?:s)?|extend(?:s)?|update(?:s)?|adjust(?:s)?|rename(?:s)?|correct(?:s)?|patch(?:es)?|bug|regression|flaky)\b/i;
 
 /**
- * Deterministic, CLI-applied scope-triage verdict over a raw `--seed` text
- * (#4496 fix 6). Embedding the verdict in the `--seed` envelope removes the
- * two skill Reads (`core/scope-triage` + the gate fragment's rubric pass)
- * from the headless path; the attended path keeps the skill-based judgment.
+ * Deterministic, CLI-applied scope signal over a raw `--seed` text
+ * (#4496 fix 6). Embedding it in the `--seed` envelope keeps the headless
+ * path from needing a judgment pass of its own.
  *
- * The heuristics anchor to the same granularity SSOT the skill anchors to —
+ * The heuristics anchor to the granularity SSOT —
  * `DELIVERABLE_GRANULARITY_GUIDANCE` in `ticket-validator-sizing.js` (one
  * Story = one coherent capability slice; multiple independent capabilities =
- * an Epic) — and to the skill's change-request delta rubric. Like the skill,
- * the verdict is **advisory**: being wrong in the `epic` direction is cheap,
- * and `borderline` is a first-class output, not a forced call.
+ * an Epic) — and to the change-request delta rubric above. The verdict is
+ * **advisory**: being wrong in the `epic` direction is cheap, and
+ * `borderline` is a first-class output, not a forced call.
  *
  * @param {{ seedText?: string }} args
  * @returns {{ verdict: 'epic'|'story'|'borderline', reasons: string[], advisory: true, appliedBy: 'cli' }}
@@ -634,12 +627,15 @@ function withAdvisorySignals(complexitySignals, { config, cwd } = {}) {
 
 /**
  * Render the authoring system prompts the collapsed pipeline's single
- * authoring pass consumes. The spec/acceptance prompts render from
- * `lib/templates/spec-author-prompts.js` (the M3/M8 handshake — envelope
- * authoritative from day one); the story prompt is the N=1 core from
- * `lib/templates/decomposer-prompts.js`, with the schedule and partition
- * rules a planner reads only when the default-single split policy clears
- * carried separately as `storySplitRules` (Story #5312).
+ * authoring pass consumes: the N=1 core from
+ * `lib/templates/decomposer-prompts.js`, with the schedule rules and the
+ * collision refusal a planner reads only when the default-single split policy
+ * clears carried separately as `storySplitRules` (Story #5312).
+ *
+ * Story #5332 deleted the `spec` / `acceptance` fields with the module that
+ * rendered them: nothing read either, and both contradicted the current
+ * contract — one asserting Spec budgets that no longer exist, the other
+ * demanding the verify tier suffixes tickets mode now strips.
  *
  * `storyTicketsRules` is the one mode-conditional field (Story #5323): it
  * only means anything when the seed is an existing ticket, and an envelope
@@ -647,12 +643,10 @@ function withAdvisorySignals(complexitySignals, { config, cwd } = {}) {
  * ticket that a `--seed` run does not have.
  *
  * @param {{ mode?: string }} [args]
- * @returns {{ spec: string, acceptance: string, story: string, storySplitRules: string, storyTicketsRules?: string }}
+ * @returns {{ story: string, storySplitRules: string, storyTicketsRules?: string }}
  */
 export function buildSystemPrompts({ mode } = {}) {
   return {
-    spec: renderTechSpecSystemPrompt(),
-    acceptance: renderAcceptanceSpecSystemPrompt(),
     story: renderStoryAuthorCore(),
     storySplitRules: renderStorySplitRules(),
     ...ticketsModePromptField(mode),

package/.agents/scripts/lib/orchestration/plan-persist/changes-repair.js

@@ -36,6 +36,7 @@
  * @module lib/orchestration/plan-persist/changes-repair
  */
 
+import { matchBarePathToken } from '../../story-body/body-format-lints.js';
 import { FILE_ASSUMPTION_VALUES } from '../file-assumption-enum.js';
 
 /** The `## Changes` heading (either level the parser accepts). */
@@ -50,11 +51,6 @@ const TRAILING_PARENTHETICAL_RE = /\s*\([^)]*\)\s*$/;
 /** The humanized canonical bullet: `` `path` — assumption ``. */
 const HUMANIZED_RE = /^`([^`]+)`\s+—\s+(\S+)$/;
 
-// A token that looks like a file path / glob / module id: it carries a `/` or a
-// `.`-separated segment. Deliberately loose — a false positive only produces a
-// `{ path, assumption }` entry the base-branch probes then judge.
-const PATH_LIKE_RE = /^[\w@*-]*[/.][\w@./*-]+$/;
-
 /**
  * Strip a trailing parenthetical from a path token, reporting whether one
  * was present.
@@ -73,6 +69,12 @@ function stripParenthetical(raw) {
  * backticks, strip a trailing parenthetical. Returns `null` when nothing
  * path-shaped survives.
  *
+ * What counts as path-shaped is `matchBarePathToken` — the same grammar the
+ * story-body parser admits a bare bullet under, imported rather than
+ * restated (Story #5361). The repair pass scoring a narrower class than the
+ * parser is what let a route-segment path be repaired on one surface and
+ * refused on the other.
+ *
  * @param {string} raw
  * @returns {string|null}
  */
@@ -87,7 +89,7 @@ function salvagePath(raw) {
     .replace(/[`'"]+$/, '')
     .trim();
   s = stripParenthetical(s).path;
-  return s !== '' && PATH_LIKE_RE.test(s) ? s : null;
+  return matchBarePathToken(s);
 }
 
 /**