mandrel 2.55.0 → 2.57.0

package/.agents/scripts/lib/crap-engine.js

@@ -14,9 +14,35 @@ import {
   crapFormula,
 } from './crap-coordinates.js';
 import { deriveMethodIdentities } from './crap-method-identity.js';
+import { install as installAstCompat } from './escomplex-ast-compat.js';
 
 export { COORDINATE_ORIGINAL, COORDINATE_TRANSPILED, crapFormula };
 
+/**
+ * Sentinel returned by {@link calculateCrapForSource} for a source the kernel
+ * cannot parse. Deliberately **not** `[]`: a caller receiving an empty array
+ * cannot tell an unscorable file from one with no methods, which is how a
+ * parse failure used to reach the baseline as a silent zero (Story #5311).
+ */
+export const UNSCORABLE = null;
+
+// The kernel's code generator predates the Babel AST its own parser emits, so
+// ordinary modern syntax (`?.`, `await` or a regex in a loop head, object
+// spread in a default parameter) aborts `analyzeModule` for the WHOLE file —
+// see `escomplex-ast-compat.js` for the defect and the upstream status.
+//
+// Story #5311: the install belongs here, at the scoring kernel, because this
+// is where both CRAP scorers converge — `calculateCrapForSource` (the worker
+// path) and `crap-utils.js#analyzeOnce` (the serial path, which reaches this
+// module for `methodRowsFromReport`). It used to be reached only as a side
+// effect of `maintainability-engine.js` sitting somewhere in the serial path's
+// import graph, which the worker's graph never included: 362 methods across
+// 21 files scored zero via workers and scored fine serially, and
+// `POOL_SERIAL_THRESHOLD` makes the worker path the only one a real repo
+// takes. Anchoring it at the kernel makes the next worker entrypoint correct
+// by construction rather than by an import nobody would guess is load-bearing.
+installAstCompat();
+
 /**
  * Derive the raw per-method CRAP rows from an escomplex report.
  *
@@ -199,8 +225,12 @@ export { finalizeMethodRowsWithBaseline } from './crap-baseline-join.js';
  *     produce `coverage: null` and `crap: null`. Callers apply their own
  *     `requireCoverage` policy at the scanner level (`finalizeMethodRows`);
  *     this kernel never decides to skip.
- *   - A parse error returns an empty array — the file is unscorable, not
- *     zero-complexity.
+ *   - A parse error returns {@link UNSCORABLE} (`null`) — the file could not
+ *     be scored at all, which is a different fact from "it has no methods"
+ *     (`[]`). Story #5311: returning `[]` for both collapsed them, and every
+ *     caller's drop path for an unscorable file became unreachable — the
+ *     whole parse-failure class landed in the baseline as a clean zero.
+ *     Callers MUST branch on `rows === null` before iterating.
  *
  * @param {string} source JavaScript source text (possibly transpiled).
  * @param {object|null} coverageForFile The inner value from a
@@ -216,7 +246,8 @@ export { finalizeMethodRowsWithBaseline } from './crap-baseline-join.js';
  *   coverage: number|null,
  *   crap: number|null,
  *   coordinateSystem: 'original'|'transpiled',
- * }>}
+ * }>|null} The method rows, or {@link UNSCORABLE} when the source did not
+ *   parse.
  */
 export function calculateCrapForSource(
   source,
@@ -227,7 +258,7 @@ export function calculateCrapForSource(
   try {
     report = escomplex.analyzeModule(source);
   } catch {
-    return [];
+    return UNSCORABLE;
   }
   return methodRowsFromReport(report, coverageForFile, mapLine);
 }

package/.agents/scripts/lib/crap-utils.js

@@ -348,6 +348,12 @@ function projectScanRow(relPath, mr) {
  * skipped from the returned rows so the baseline never contains
  * partially-scored entries. Both counters surface for reporting.
  *
+ * A file neither path could score at all — unreadable, untranspilable, or one
+ * the kernel could not parse — is dropped and counted in `unscorableFiles`
+ * (Story #5311). Unscorable is not scored-as-nothing: without this counter a
+ * dropped file is indistinguishable from a file with no methods, which is what
+ * let a whole parse-failure class leave the baseline silently.
+ *
  * When `scopeFiles` is provided (the `--changed-since` code path) files
  * discovered via directory walking are filtered against that set before any
  * I/O or scoring happens — so pre-push / PR-CI runs never pay the
@@ -385,6 +391,7 @@ function projectScanRow(relPath, mr) {
  *   scannedFiles: number,
  *   skippedFilesNoCoverage: number,
  *   skippedMethodsNoCoverage: number,
+ *   unscorableFiles: number,
  * }}
  */
 export async function scanAndScore({
@@ -442,9 +449,16 @@ export async function scanAndScore({
   const rows = [];
   let skippedFilesNoCoverage = 0;
   let skippedMethodsNoCoverage = 0;
+  let unscorableFiles = 0;
   const resolution = newResolutionAccumulator();
   for (const { item, result } of perFile) {
-    if (!result) continue; // unrecoverable per-file failure: drop silently to match pre-pool semantics
+    if (!result) {
+      // Unrecoverable per-file failure (a pool-level error the worker never
+      // answered). Dropped like any other unscorable file, and counted — the
+      // point of the counter is that no drop is silent.
+      unscorableFiles += 1;
+      continue;
+    }
     if (result.skippedFileNoCoverage) {
       skippedFilesNoCoverage += 1;
       continue;
@@ -453,6 +467,7 @@ export async function scanAndScore({
       // read/transpile/parse failure: drop and move on, but if the worker
       // attached an error message (calculateCrapForSource throw) surface it
       // so the run isn't silent on the ops side.
+      unscorableFiles += 1;
       if (result.error) {
         Logger.warn(
           `[crap-utils] failed to score ${item.relPath}: ${result.error}`,
@@ -479,6 +494,7 @@ export async function scanAndScore({
     scannedFiles,
     skippedFilesNoCoverage,
     skippedMethodsNoCoverage,
+    unscorableFiles,
     resolution: summarizeResolution(resolution),
   };
 }

package/.agents/scripts/lib/cyclomatic-ceiling.js

@@ -1,6 +1,6 @@
 /**
- * cyclomatic-ceiling.js — the enforcing core behind
- * `delivery.quality.codingGuardrails.cyclomaticMustFix` (Story #4923).
+ * cyclomatic-ceiling.js — the enforcing core behind the cyclomatic ceiling
+ * ratchet (Story #4923; fixed ceiling since Story #5313).
  *
  * The two `codingGuardrails` cyclomatic knobs shipped schema-validated,
  * bootstrap-defaulted and resolver-resolved, and were then read by nothing:
@@ -9,6 +9,12 @@
  * nothing enforces is worse than no ceiling, because the workflow docs promise
  * the merge will be refused.
  *
+ * Story #5313 retired the `cyclomaticMustFix` config key: the ratchet's
+ * ceiling is the fixed {@link CYCLOMATIC_CEILING} (12), so a consumer cannot
+ * bound this gate by tuning a number, and `cyclomaticFlag` is the one
+ * advisory knob — `quality-preview.js` reports over-flag methods and exits 0
+ * on them.
+ *
  * This module is that enforcement, shaped as a **ratchet** rather than a
  * cliff. The repository already carries dozens of functions above the
  * must-fix ceiling; failing every one of them at once would have made the
@@ -37,6 +43,13 @@ import { scanDirectory } from './maintainability-utils.js';
 /** Default location of the committed breach baseline. */
 export const DEFAULT_CYCLOMATIC_BASELINE = 'baselines/cyclomatic.json';
 
+/**
+ * The per-function cyclomatic ceiling the ratchet enforces. Fixed — not a
+ * config key — since Story #5313.
+ * @type {number}
+ */
+export const CYCLOMATIC_CEILING = 12;
+
 /** Baseline `$schema` marker, matching the sibling ratchet baselines. */
 const CYCLOMATIC_BASELINE_SCHEMA =
   'https://mandrel.dev/baselines/cyclomatic.schema.json';
@@ -44,10 +57,9 @@ const CYCLOMATIC_BASELINE_SCHEMA =
 /**
  * Resolve the enforcement policy from a resolved `delivery.quality` block.
  *
- * `mustFix` and `flag` come straight from `resolveCodingGuardrails`, so a
- * consumer that tunes either knob tunes this gate — which is the whole point
- * of the Story. `targetDirs` / `ignoreGlobs` are borrowed from the
- * maintainability gate (see the module note).
+ * `mustFix` is the fixed {@link CYCLOMATIC_CEILING}; `flag` comes from
+ * `resolveCodingGuardrails` (advisory only). `targetDirs` / `ignoreGlobs`
+ * are borrowed from the maintainability gate (see the module note).
  *
  * @param {object | null | undefined} quality resolved `delivery.quality`
  * @returns {{ mustFix: number, flag: number, targetDirs: string[], ignoreGlobs: string[] }}
@@ -56,7 +68,7 @@ export function resolveCyclomaticPolicy(quality) {
   const guardrails = quality?.codingGuardrails ?? {};
   const mi = quality?.maintainability ?? {};
   return {
-    mustFix: Number(guardrails.cyclomaticMustFix ?? 12),
+    mustFix: CYCLOMATIC_CEILING,
     flag: Number(guardrails.cyclomaticFlag ?? 8),
     targetDirs: Array.isArray(mi.targetDirs) ? mi.targetDirs : [],
     ignoreGlobs: Array.isArray(mi.ignoreGlobs) ? mi.ignoreGlobs : [],

package/.agents/scripts/lib/feedback-loop/graduator-core.js

@@ -45,12 +45,18 @@
  *   - **Durable cross-repo deferral.** Cross-repo-deferred findings are
  *     upserted into a structured comment on the Epic instead of only a
  *     log line.
+ *   - **Routed, never re-pointed.** Ownership routing is delegated to
+ *     `github/framework-repo.js#routeOwnership`; an unroutable bucket is
+ *     skipped `unroutable` and named in that same durable comment. The
+ *     predecessor resolved an absent framework slug to the consumer's own
+ *     repo, which silently mis-filed framework-owned work.
  */
 
 import { spawn as defaultSpawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 
 import { inNodeTestContext } from '../config/temp-paths.js';
+import { routeOwnership } from '../github/framework-repo.js';
 import { LABEL_COLORS } from '../label-constants.js';
 import { classifyPathSource as defaultClassifier } from '../observability/source-classifier.js';
 import { upsertStructuredComment } from '../orchestration/ticketing.js';
@@ -531,7 +537,7 @@ async function findExistingFollowUp({
  *
  * @returns {Promise<{ url: string|null, error: string|null }>}
  */
-async function updateFollowUpIssue({
+export async function updateFollowUpIssue({
   owner,
   repo,
   number,
@@ -675,7 +681,7 @@ async function readLiveLabelNames({
  * @param {number} [opts.timeoutMs]
  * @returns {Promise<{ created: string[], missing: string[], errors: string[] }>}
  */
-async function ensureIssueLabels({
+export async function ensureIssueLabels({
   owner,
   repo,
   labels,
@@ -947,7 +953,7 @@ async function processGraduateFinding({
   decorate,
   epicId,
   currentRepo,
-  frameworkRepo,
+  repos,
   classifier,
   gitRef,
   ghPath,
@@ -994,12 +1000,26 @@ async function processGraduateFinding({
   }
 
   const source = classifier(finding.path, null);
-  const routedRepo =
-    source === 'framework' && frameworkRepo ? frameworkRepo : currentRepo;
-  const isCrossRepo =
-    routedRepo.owner !== currentRepo.owner ||
-    routedRepo.repo !== currentRepo.repo;
-  if (isCrossRepo) {
+  // Ownership routing is the shared SSOT's call, and an unroutable bucket is
+  // an outcome rather than a fallback: the predecessor resolved an absent
+  // framework slug to the CONSUMER's repo, silently filing framework-owned
+  // work in the wrong place (see `github/framework-repo.js`). Unroutable
+  // findings are deferred and named, never re-pointed.
+  const routing = routeOwnership({ bucket: source, repos, currentRepo });
+  if (!routing.routable) {
+    const logLine = `[${spec.fnName}] unroutable ${source} finding (${routing.missingKey} is unset) — not filed: ${finding.title ?? finding.path ?? `finding ${finding.index}`}`;
+    logger?.warn?.(logLine);
+    crossRepoDeferred.push({
+      finding,
+      routedRepo: null,
+      source,
+      logLine,
+      missingKey: routing.missingKey,
+    });
+    return skip('unroutable');
+  }
+  const routedRepo = routing.routedRepo;
+  if (routing.crossRepo) {
     const logLine = spec.buildCrossRepoLog({ finding, routedRepo, source });
     logger?.info?.(logLine);
     crossRepoDeferred.push({ finding, routedRepo, source, logLine });
@@ -1165,13 +1185,18 @@ function renderCrossRepoDeferredBody(deferred, spec) {
   const header =
     spec.crossRepoCommentHeader ??
     '### Cross-repo-deferred findings\n\nThese findings route to a different repository and were **not** filed here. They are recorded for a cross-repo follow-up pass.';
-  const rows = deferred.map(({ finding, routedRepo, logLine }) => {
+  const rows = deferred.map(({ finding, routedRepo, logLine, missingKey }) => {
     const path =
       typeof finding.path === 'string' && finding.path.length > 0
         ? `\`${finding.path}\``
         : '_(no path)_';
+    // An unroutable finding has no destination to name — say which config
+    // key would give it one instead of inventing a repo for the row.
+    const destination = routedRepo
+      ? `${routedRepo.owner}/${routedRepo.repo}`
+      : `**unroutable** (\`${missingKey}\` is unset)`;
     return [
-      `- ${path} (severity: ${finding.severity ?? 'n/a'}) → ${routedRepo.owner}/${routedRepo.repo}`,
+      `- ${path} (severity: ${finding.severity ?? 'n/a'}) → ${destination}`,
       `  - ${logLine}`,
     ].join('\n');
   });
@@ -1244,7 +1269,12 @@ async function persistCrossRepoDeferred({
  *   the durable cross-repo-deferred persistence
  * @param {object} [opts.config]
  * @param {{owner: string, repo: string}} opts.currentRepo
- * @param {{owner: string, repo: string}} [opts.frameworkRepo]
+ * @param {{owner: string, repo: string}} [opts.frameworkRepo] — the
+ *   `framework` ownership bucket. Absent means **unroutable**, never the
+ *   consumer's repo: a framework-classified finding is then deferred and
+ *   named rather than filed in the wrong tracker.
+ * @param {{owner: string, repo: string}} [opts.platformRepo] — the shared
+ *   platform/infra bucket, for a caller whose classifier can reach it.
  * @param {string} [opts.gitRef='HEAD']
  * @param {Function} [opts.classifier=classifyPathSource]
  * @param {string} [opts.ghPath='gh']
@@ -1279,6 +1309,7 @@ export async function graduate({
   config,
   currentRepo,
   frameworkRepo,
+  platformRepo,
   gitRef = 'HEAD',
   classifier = defaultClassifier,
   ghPath = 'gh',
@@ -1347,6 +1378,15 @@ export async function graduate({
     return envelope;
   }
 
+  // The ownership map the routing SSOT resolves against. `platform` is
+  // absent for both graduators today (their classifier is binary) and is
+  // threaded so a caller that does know a shared-infra repo routes there
+  // rather than into the nearest plausible tracker.
+  const repos = {
+    consumer: currentRepo,
+    framework: frameworkRepo ?? null,
+    platform: platformRepo ?? null,
+  };
   const crossRepoDeferred = [];
   for (const finding of findings) {
     await processGraduateFinding({
@@ -1355,7 +1395,7 @@ export async function graduate({
       decorate,
       epicId,
       currentRepo,
-      frameworkRepo,
+      repos,
       classifier,
       gitRef,
       ghPath,

package/.agents/scripts/lib/feedback-loop/prior-feedback-fetcher.js

@@ -25,6 +25,7 @@
  */
 
 import { META_LABELS } from '../label-constants.js';
+import { CI_GAP_INTAKE_MARKER } from '../orchestration/ci-gap-intake.js';
 import { runChild } from './graduator-core.js';
 
 const DEFAULT_LIMIT = 50;
@@ -135,8 +136,15 @@ function formatGhError(label, { code, stderr, spawnError }) {
  * already-budgeted envelope, and trimming early avoids any ambient assumption
  * that downstream consumers can rely on extra fields.
  *
+ * `intake` is the one field derived rather than copied: an issue whose body
+ * carries the CI-gap intake marker is a filing awaiting graduation, not a
+ * finished report, and `/mandrel-plan` offers those a `/mandrel-plan <id>`
+ * rewrite. The body itself is NOT carried onto the envelope — the marker
+ * check is the whole reason it was fetched, and a planner payload does not
+ * need every intake issue's full text.
+ *
  * @param {object} raw
- * @returns {{ number: number, title: string, url: string, labels: string[] }|null}
+ * @returns {{ number: number, title: string, url: string, labels: string[], intake: boolean }|null}
  */
 function normalizeIssue(raw) {
   if (!raw || typeof raw !== 'object') return null;
@@ -144,12 +152,23 @@ function normalizeIssue(raw) {
   if (number === null) return null;
   const title = typeof raw.title === 'string' ? raw.title : '';
   const url = typeof raw.url === 'string' ? raw.url : '';
-  const labels = Array.isArray(raw.labels)
-    ? raw.labels
-        .map((l) => (l && typeof l === 'object' ? l.name : l))
-        .filter((name) => typeof name === 'string')
-    : [];
-  return { number, title, url, labels };
+  const intake =
+    typeof raw.body === 'string' && raw.body.includes(CI_GAP_INTAKE_MARKER);
+  return { number, title, url, labels: normalizeLabels(raw.labels), intake };
+}
+
+/**
+ * Flatten `gh issue list --json labels` into plain names. `gh` returns label
+ * objects; a hand-built fixture may return strings. Pure.
+ *
+ * @param {unknown} raw
+ * @returns {string[]}
+ */
+function normalizeLabels(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .map((l) => (l && typeof l === 'object' ? l.name : l))
+    .filter((name) => typeof name === 'string');
 }
 
 /**
@@ -176,7 +195,7 @@ async function fetchByLabel({ owner, repo, label, ghPath, limit, spawnImpl }) {
     '--label',
     label,
     '--json',
-    'number,title,labels,url',
+    'number,title,labels,url,body',
     '--limit',
     String(limit),
   ];
@@ -209,10 +228,32 @@ async function fetchByLabel({ owner, repo, label, ghPath, limit, spawnImpl }) {
 }
 
 /**
- * Fetch the union of open issues carrying either `meta::framework-gap` or
- * `meta::consumer-improvement` and split them into two arrays. Issues that
- * carry **both** labels appear in `frameworkGaps` only — dedupe-by-number
- * runs across both arrays so the planner sees each issue exactly once.
+ * Append every not-yet-seen issue to one bucket, marking it seen.
+ *
+ * An issue carrying more than one meta label must reach the planner exactly
+ * once, so the `seen` set spans all three buckets and the first bucket to
+ * claim a number keeps it. Mutates both arguments — one walk, three buckets.
+ *
+ * @param {object[]} bucket
+ * @param {object[]} issues
+ * @param {Set<number>} seen
+ * @returns {void}
+ */
+function dedupeInto(bucket, issues, seen) {
+  for (const issue of issues) {
+    if (seen.has(issue.number)) continue;
+    seen.add(issue.number);
+    bucket.push(issue);
+  }
+}
+
+/**
+ * Fetch the union of open issues carrying `meta::framework-gap`,
+ * `meta::consumer-improvement` or `meta::platform-gap` and split them into
+ * three arrays — one per ownership bucket in `github/framework-repo.js`, so
+ * a filing's bucket survives all the way to the planner. An issue carrying
+ * more than one label appears once, in that precedence order; dedupe-by-number
+ * runs across all three arrays so the planner sees each issue exactly once.
  *
  * The returned envelope is best-effort: every failure mode (gh missing, repo
  * not found, non-zero exit, malformed JSON) is captured as a string in
@@ -227,6 +268,7 @@ async function fetchByLabel({ owner, repo, label, ghPath, limit, spawnImpl }) {
  * @returns {Promise<{
  *   frameworkGaps: object[],
  *   consumerImprovements: object[],
+ *   platformGaps: object[],
  *   recurringDefectClasses: Array<{ class: string, count: number, issues: number[] }>,
  *   fetchedAt: string,
  *   errors: string[],
@@ -251,6 +293,7 @@ export async function fetchPriorFeedback({
   const envelope = {
     frameworkGaps: [],
     consumerImprovements: [],
+    platformGaps: [],
     recurringDefectClasses: [],
     fetchedAt: new Date().toISOString(),
     errors,
@@ -258,7 +301,7 @@ export async function fetchPriorFeedback({
 
   if (errors.length > 0) return envelope;
 
-  const [gapsResult, improvementsResult] = await Promise.all([
+  const [gapsResult, improvementsResult, platformResult] = await Promise.all([
     fetchByLabel({
       owner,
       repo,
@@ -275,25 +318,27 @@ export async function fetchPriorFeedback({
       limit,
       spawnImpl,
     }),
+    fetchByLabel({
+      owner,
+      repo,
+      label: META_LABELS.PLATFORM_GAP,
+      ghPath,
+      limit,
+      spawnImpl,
+    }),
   ]);
 
-  if (gapsResult.error) errors.push(gapsResult.error);
-  if (improvementsResult.error) errors.push(improvementsResult.error);
+  for (const { error } of [gapsResult, improvementsResult, platformResult]) {
+    if (error) errors.push(error);
+  }
 
   // Dedupe by issue number across both arrays. Issues that carry both labels
   // land in frameworkGaps first (deterministic) and are filtered out of
   // consumerImprovements.
   const seen = new Set();
-  for (const issue of gapsResult.issues) {
-    if (seen.has(issue.number)) continue;
-    seen.add(issue.number);
-    envelope.frameworkGaps.push(issue);
-  }
-  for (const issue of improvementsResult.issues) {
-    if (seen.has(issue.number)) continue;
-    seen.add(issue.number);
-    envelope.consumerImprovements.push(issue);
-  }
+  dedupeInto(envelope.frameworkGaps, gapsResult.issues, seen);
+  dedupeInto(envelope.consumerImprovements, improvementsResult.issues, seen);
+  dedupeInto(envelope.platformGaps, platformResult.issues, seen);
 
   // Story #4135 (Epic #4131, F11) — close the retro→planner loop: derive the
   // recurring defect classes from the `friction::<class>` labels carried by
@@ -303,6 +348,7 @@ export async function fetchPriorFeedback({
   envelope.recurringDefectClasses = extractRecurringDefectClasses([
     ...envelope.frameworkGaps,
     ...envelope.consumerImprovements,
+    ...envelope.platformGaps,
   ]);
 
   return envelope;

package/.agents/scripts/lib/feedback-loop/retro-proposals-graduator.js

@@ -22,7 +22,10 @@
  * Routing correctness: a routed item already knows its source
  * (`framework` / `consumer`), so we file each source bucket with its own
  * constant classifier and thread the graduator's per-run filing cap across
- * the two buckets. The `meta::<framework-gap|consumer-improvement>` +
+ * the two buckets. Which repository a source routes to is decided once, in
+ * `github/framework-repo.js` — the silent consumer-repo fallback that used
+ * to live here (and mis-filed framework work into the consumer's tracker)
+ * is gone from the whole path, not just from this module. The `meta::<framework-gap|consumer-improvement>` +
  * `friction::<category>` labels are lifted verbatim from the routed item.
  *
  * Behind the `delivery.feedbackLoop.retroProposals` toggle (default ON,
@@ -30,7 +33,10 @@
  * failure path is captured in `errors[]`.
  */
 
-import { DEFAULT_FRAMEWORK_REPO } from '../github/framework-repo.js';
+import {
+  DEFAULT_FRAMEWORK_REPO,
+  parseRepoSlug,
+} from '../github/framework-repo.js';
 import { META_LABELS } from '../label-constants.js';
 import {
   contentFingerprint,
@@ -218,6 +224,8 @@ function toFinding(item, source, index) {
  * @param {{owner: string, repo: string}} opts.currentRepo — the repo the
  *   retro is running inside (the consumer's own repo); the cross-repo guard's
  *   anchor.
+ * @param {{owner: string, repo: string}} [opts.platformRepo] — the shared
+ *   platform/infra bucket, forwarded to the walk's routing SSOT.
  * @param {{owner: string, repo: string}} [opts.frameworkRepo] — where
  *   framework-tagged proposals route.
  * @param {{ framework?: object[], consumer?: object[] }} [opts.routedProposals]
@@ -239,6 +247,7 @@ export async function graduateRetroProposals({
   config,
   currentRepo,
   frameworkRepo,
+  platformRepo,
   routedProposals,
   ghPath,
   spawnImpl,
@@ -294,6 +303,7 @@ export async function graduateRetroProposals({
       config,
       currentRepo,
       frameworkRepo,
+      platformRepo,
       // Each bucket's source is known — a constant classifier routes the
       // whole bucket to the correct repo and stamps the correct label.
       classifier: () => source,
@@ -380,22 +390,6 @@ export function enrichRoutedProposalsWithFilings(routedProposals, filed) {
   };
 }
 
-/**
- * Parse an `"<owner>/<repo>"` slug into `{ owner, repo }`, or `null` when
- * the slug is empty / malformed.
- *
- * @param {string|null|undefined} slug
- * @returns {{ owner: string, repo: string } | null}
- */
-function parseRepoSlug(slug) {
-  if (typeof slug !== 'string') return null;
-  const parts = slug.split('/');
-  if (parts.length !== 2) return null;
-  const [owner, repo] = parts;
-  if (!owner || !repo) return null;
-  return { owner, repo };
-}
-
 /**
  * Orchestrating seam invoked by the retro post-and-mirror phase: gate the
  * toggle, file the routed proposals, and return the routed proposals
@@ -452,13 +446,12 @@ export async function fileRetroProposals({
     );
     return passthrough('no-current-repo');
   }
-  // Framework-repo fallback parity with `gatherRetroSignals`
-  // (gather-signals.js): an unconfigured `github.frameworkRepo` falls
-  // back to the Mandrel mirror constant, NEVER to the consumer's own
-  // repo — the prior `?? currentRepo` fallback silently auto-filed
-  // framework-tagged proposals into the consumer's repo while the retro
-  // body rendered them under "framework repo" (masked in this repo only
-  // because consumer === framework here).
+  // An unconfigured framework slug falls back to the Mandrel mirror
+  // constant, NEVER to the consumer's own repo: the retired consumer-repo
+  // fallback silently auto-filed framework-tagged proposals into the
+  // consumer's tracker while the retro body rendered them under "framework
+  // repo" (masked in this repo only because consumer === framework here).
+  // `github/framework-repo.js` is the SSOT for that rule now.
   const frameworkRepoObj =
     parseRepoSlug(frameworkRepo) ?? parseRepoSlug(DEFAULT_FRAMEWORK_REPO);