mandrel 1.57.0

package/.agents/scripts/lib/orchestration/retro-runner.js

@@ -0,0 +1,171 @@
+/**
+ * lib/orchestration/retro-runner.js — In-process Retro module (sequencer).
+ *
+ * Story #1155 (Epic #1142, 5.40.0) — extracts the helper-driven
+ * `epic-retro` invocation into a callable module so the
+ * `/epic-deliver` runner can fire Phase E without a separate LLM
+ * helper turn. (Story #2259, Epic #2172: the legacy deliver-runner
+ * CLI was retired once delivery moved entirely into the slash
+ * command.) The retro fires before `/epic-deliver`'s finalize step
+ * opens the PR — the operator's PR-merge is the final human gate, not
+ * the retro itself.
+ *
+ * Story #3001 — the runner body was decomposed into `./retro/phases/`
+ * (one file per functional unit) following the established pattern at
+ * `./git-cleanup/phases/`, `./story-close/phases/`, and
+ * `./post-merge/phases/`. This file is now a thin sequencer that owns
+ * the `runRetro` entry point and re-exports the phase-level helpers so
+ * existing import sites stay unchanged.
+ *
+ * Public API:
+ *   - `runRetro({ epicId, provider, logger })` → `{ posted, compact, scorecard, body }`.
+ *   - `composeRetroBody(input)` (pure, exported for tests).
+ *   - `gatherRetroSignals({ epicId, provider })` (exported for tests).
+ *   - `appendChecksSection(body, findings)` (pure, exported for tests).
+ *
+ * Behaviour:
+ *   - Reads child Stories' `story-perf-summary` comments to aggregate
+ *     `frictionByCategory` totals (Story #1046 unified-summary path).
+ *   - Reads child Stories' label sets to count HITL pause events
+ *     (`agent::blocked`).
+ *   - Reads the Epic's `parked-follow-ons` structured comment for the
+ *     parked + recut counts (with a fallback to per-Story body grep on the
+ *     `<!-- recut-of: #N -->` marker).
+ *   - Selects the compact (clean-manifest) or full retro shape via
+ *     `isCleanManifest`.
+ *   - Posts the composed markdown as a `retro` structured comment on the
+ *     Epic, terminated with the `retro-complete: <ISO>` HTML marker.
+ *   - **Never** routes through `notify.js` — GitHub is the sole retro
+ *     archive; the webhook must not see the retro body.
+ */
+
+import nodeFs from 'node:fs';
+
+import { runChecks } from '../checks/index.js';
+import { assembleState } from '../checks/state.js';
+import { composeRetroBody } from './retro/phases/compose-body.js';
+import { gatherRetroSignals } from './retro/phases/gather-signals.js';
+import { composeAndPostRetro } from './retro/phases/post-and-mirror.js';
+import { upsertStructuredComment } from './ticketing.js';
+
+// Re-export phase-level helpers so existing import sites stay unchanged.
+export { appendChecksSection } from './retro/phases/checks.js';
+export { composeRetroBody } from './retro/phases/compose-body.js';
+export { gatherRetroSignals } from './retro/phases/gather-signals.js';
+
+/**
+ * Public: compose and post the retro structured comment on the Epic.
+ *
+ * Story #1290 (Epic #1143) — at /epic-deliver Phase 5, the runner invokes
+ * the self-healing checks registry with `scope: 'retro'` and
+ * `autoFix: false`. The retro is **read-only by construction**: the
+ * registry runner enforces the invariant by throwing if any caller flips
+ * `autoFix: true` under `scope: 'retro'`. Findings are appended to the
+ * retro body via `appendChecksSection`, which suppresses the section when
+ * findings are empty so the compact "🟢 Clean sprint" shape is preserved.
+ *
+ * Story #2252 — when `opts.bus` is supplied the runner emits
+ * `retro.start` immediately on entry and `retro.end` immediately before
+ * returning the envelope. On throw the helper emits `retro.end` with
+ * `posted: false` before re-throwing so the ledger always carries the
+ * closing boundary.
+ *
+ * @param {{
+ *   epicId: number,
+ *   provider: object,
+ *   logger?: { info?: Function, warn?: Function },
+ *   forceFull?: boolean,
+ *   timestamp?: string,
+ *   bus?: object|null,
+ *   now?: () => number,
+ *   manualInterventions?: number,
+ *   gatherFn?: typeof gatherRetroSignals,
+ *   composeFn?: typeof composeRetroBody,
+ *   upsertFn?: typeof upsertStructuredComment,
+ *   runChecksFn?: typeof runChecks,
+ *   assembleStateFn?: typeof assembleState,
+ *   cwd?: string,
+ * }} opts
+ * @returns {Promise<{
+ *   posted: boolean,
+ *   compact: boolean,
+ *   scorecard: object,
+ *   body: string,
+ *   findings: object[],
+ *   commentId?: number,
+ * }>}
+ */
+export async function runRetro(opts = {}) {
+  const {
+    epicId,
+    provider,
+    logger,
+    forceFull = false,
+    timestamp,
+    bus,
+    now = Date.now,
+    manualInterventions = 0,
+    gatherFn = gatherRetroSignals,
+    composeFn = composeRetroBody,
+    upsertFn = upsertStructuredComment,
+    runChecksFn = runChecks,
+    assembleStateFn = assembleState,
+    cwd,
+    fsImpl = nodeFs,
+    perfThresholds = null,
+  } = opts;
+
+  if (!Number.isInteger(epicId) || epicId <= 0) {
+    throw new TypeError('runRetro: epicId is required (positive integer).');
+  }
+  if (!provider) {
+    throw new TypeError('runRetro: provider is required.');
+  }
+  // Epic #2646 Story C (Task #2700) — `bus` is now a hard input. The
+  // previous guarded `emitLifecycleSafe` helper that tolerated a null
+  // bus is gone.
+  if (!bus || typeof bus.emit !== 'function') {
+    throw new TypeError('runRetro: bus is required (object with emit()).');
+  }
+
+  logger?.info?.(`[retro-runner] Composing retro for Epic #${epicId}...`);
+  const startedAt = typeof now === 'function' ? now() : Date.now();
+  await bus.emit('retro.start', { epicId });
+  let retroPathWritten = null;
+  try {
+    return await composeAndPostRetro({
+      epicId,
+      provider,
+      logger,
+      forceFull,
+      timestamp,
+      bus,
+      now,
+      manualInterventions,
+      gatherFn,
+      composeFn,
+      upsertFn,
+      runChecksFn,
+      assembleStateFn,
+      cwd,
+      fsImpl,
+      startedAt,
+      perfThresholds,
+      onMirrorWritten: (p) => {
+        retroPathWritten = p;
+      },
+    });
+  } catch (err) {
+    // Surface the closing boundary even on throw — the ledger must
+    // always show a matched start/end pair.
+    const endedAt = typeof now === 'function' ? now() : Date.now();
+    const payload = {
+      epicId,
+      posted: false,
+      durationMs: Math.max(0, Math.floor(endedAt - startedAt)),
+    };
+    if (retroPathWritten) payload.retroPath = retroPathWritten;
+    await bus.emit('retro.end', payload);
+    throw err;
+  }
+}

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

@@ -0,0 +1,93 @@
+/**
+ * lib/orchestration/review-depth.js — Shared review-depth resolver combining
+ * judged risk and mechanical diff width (Story #3938).
+ *
+ * The single depth authority for the code-review pipeline. It folds the two
+ * signals the framework already computes — the planner-judged risk
+ * (`planningRisk.overallLevel`) and the mechanical changed-file count of the
+ * diff under review — into one tier (`light` / `standard` / `deep`) without
+ * inventing a new complexity score or any new config knob.
+ *
+ * Tier rules:
+ *   - `deep`     — `overallLevel === 'high'` OR the changed-file count exceeds
+ *                  the wide-change scale (`sizing.hardFiles`). A wide-footprint
+ *                  Epic whose risk was judged low (or never judged) still earns
+ *                  a deep pass on size alone.
+ *   - `light`    — `overallLevel === 'low'` AND the changed-file count is at or
+ *                  below the small-change scale (`sizing.softFiles`). An
+ *                  *unknown* count does NOT block `light`: a missing diff width
+ *                  is treated as "not wide", so a low-risk Epic with no count
+ *                  still resolves to `light` (preserves the #3937 producer
+ *                  contract where depth is resolved from risk before any diff
+ *                  is enumerated).
+ *   - `standard` — everything else, including absent/malformed risk envelopes
+ *                  and a `medium` level. Fail toward the middle, never toward
+ *                  `light`: an Epic that skipped `/epic-plan` has no risk
+ *                  verdict, and treating it as `light` would under-review
+ *                  unjudged work while `standard` preserves today's behaviour.
+ *
+ * Pure and total: inputs in, tier out. No I/O, no throws. `null` / `undefined`
+ * / malformed inputs all degrade to `standard` (or `deep`/`light` only when the
+ * width signal unambiguously says so). Callers (e.g. `runCodeReview`) enumerate
+ * the changed-file count from the diff they already run and supply it here, and
+ * pass the operator's `planning.taskSizing` override as `sizing` so retuning
+ * sizing retunes the depth thresholds in lockstep with the ticket validator.
+ *
+ * @typedef {'light'|'standard'|'deep'} ReviewDepth
+ */
+
+import { DEFAULT_TASK_SIZING } from './ticket-validator-sizing.js';
+
+/**
+ * Coerce an arbitrary input into a non-negative integer changed-file count, or
+ * `null` when the count is unknown / unusable. A `null` count is the neutral
+ * "width unknown" signal: it neither triggers `deep` nor blocks `light`.
+ *
+ * @param {unknown} value
+ * @returns {number|null}
+ */
+function normalizeChangedFileCount(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  return Math.floor(value);
+}
+
+/**
+ * Resolve the review depth for a change set from its judged risk and diff
+ * width. See the module header for the tier rules.
+ *
+ * @param {{
+ *   overallLevel?: ('low'|'medium'|'high'|string|null|undefined),
+ *   changedFileCount?: (number|null|undefined),
+ *   sizing?: { softFiles?: number, hardFiles?: number }|null,
+ * }} [input]
+ * @returns {ReviewDepth}
+ */
+export function resolveDepth(input = {}) {
+  const overallLevel =
+    input && typeof input === 'object' ? input.overallLevel : undefined;
+  const changedFileCount =
+    input && typeof input === 'object'
+      ? normalizeChangedFileCount(input.changedFileCount)
+      : null;
+
+  const mergedSizing = {
+    ...DEFAULT_TASK_SIZING,
+    ...(input && typeof input === 'object' && input.sizing ? input.sizing : {}),
+  };
+  const { softFiles, hardFiles } = mergedSizing;
+
+  // A known count strictly above the wide-change scale is wide.
+  const isWide = changedFileCount !== null && changedFileCount > hardFiles;
+  // An unknown count is treated as "not wide" — it does not block `light`.
+  const isSmall = changedFileCount === null || changedFileCount <= softFiles;
+
+  // deep — high judged risk OR a wide diff.
+  if (overallLevel === 'high' || isWide) return 'deep';
+  // light — low judged risk AND a (known-or-unknown-but-not-wide) small diff.
+  if (overallLevel === 'low' && isSmall) return 'light';
+  // standard — everything else (medium, absent/malformed level, or a low-risk
+  // diff whose width is between softFiles and hardFiles).
+  return 'standard';
+}

package/.agents/scripts/lib/orchestration/review-providers/codex.js

@@ -0,0 +1,363 @@
+/**
+ * review-providers/codex.js — Codex ReviewProvider adapter.
+ *
+ * Story #2830 (Epic #2815) — wires the
+ * [`openai/codex-plugin-cc`](https://github.com/openai/codex-plugin-cc)
+ * Claude Code plugin's `/codex:review` slash command into the
+ * pluggable ReviewProvider contract.
+ *
+ * Two halves shipped under one Story:
+ *   - Task #2834 — schema enum + factory registration + hard-fail
+ *     probe (this file's `createCodexProvider` + `*ForRegistry`).
+ *   - Task #2836 — `runReview()` invokes `/codex:review --base <ref>
+ *     --wait` through an injectable runner and parses the response
+ *     into `Finding[]`, mapping the Codex severity vocabulary onto
+ *     the canonical `critical|high|medium|suggestion` enum.
+ *
+ * The factory NEVER silently falls back to the native provider when
+ * `provider: codex` is configured. Operators who want native MUST set
+ * `provider: native` explicitly; the probe is the only thing that
+ * routes between "configured backend present" and "configured backend
+ * missing". The adapter never consults a GitHub provider — the
+ * orchestrator owns posting/upserting and the lifecycle bus.
+ *
+ * @typedef {import('./types.js').Finding} Finding
+ * @typedef {import('./types.js').ReviewInput} ReviewInput
+ * @typedef {import('./types.js').ReviewProvider} ReviewProvider
+ * @typedef {import('./types.js').Severity} Severity
+ */
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { renderDepthDirective } from './review-depth.js';
+
+/**
+ * Canonical install/remediation guidance baked into every probe failure.
+ * Exported so tests (and any future error-renderer) can assert against
+ * the exact remediations rather than free-text matching.
+ */
+export const CODEX_REMEDIATIONS = Object.freeze({
+  install:
+    'Install the Codex plugin (https://github.com/openai/codex-plugin-cc) ' +
+    'so the host registers the `/codex:review` slash command.',
+  fallback:
+    'Or set `codeReview.provider` to "native" in .agentrc.json to use the ' +
+    'in-process maintainability/lint provider instead.',
+});
+
+/**
+ * Default Codex plugin marker locations searched by the probe. The
+ * Claude Code plugin manager (and its `claude plugin install` flow)
+ * unpacks plugins under one of these roots; presence of the
+ * `codex-plugin-cc` directory is treated as "the slash command is
+ * registered on the host".
+ *
+ * Exported so tests can extend the list without monkey-patching `os`.
+ */
+export const DEFAULT_PLUGIN_MARKERS = Object.freeze([
+  path.join(os.homedir(), '.claude', 'plugins', 'codex-plugin-cc'),
+  path.join(os.homedir(), '.claude', 'plugins', 'openai', 'codex-plugin-cc'),
+]);
+
+/**
+ * Default probe: returns true when any marker path exists on disk.
+ *
+ * The probe is intentionally cheap and synchronous — the factory runs
+ * it at construction time and the worst case (plugin absent) MUST
+ * surface immediately so the operator sees the remediation, not a
+ * deferred runtime failure during the first review run.
+ *
+ * @param {{ markers?: readonly string[], existsFn?: (p: string) => boolean }} [opts]
+ * @returns {boolean}
+ */
+export function defaultProbeCodexCommand(opts = {}) {
+  const markers = opts.markers ?? DEFAULT_PLUGIN_MARKERS;
+  const existsFn = opts.existsFn ?? fs.existsSync;
+  for (const marker of markers) {
+    try {
+      if (existsFn(marker)) return true;
+    } catch (_err) {
+      // Treat I/O errors as "absent" — the factory throws with the
+      // remediation message, and the operator can inspect the path.
+    }
+  }
+  return false;
+}
+
+/**
+ * Build the hard-fail Error thrown when the probe reports the
+ * `/codex:review` command is absent. Exported so the registry entry
+ * and tests use the same message shape.
+ *
+ * @returns {Error}
+ */
+export function buildCodexUnavailableError() {
+  return new Error(
+    '[ReviewProviderFactory] codeReview.provider is set to "codex" but the ' +
+      '`/codex:review` slash command is not registered on this host. ' +
+      `${CODEX_REMEDIATIONS.install} ${CODEX_REMEDIATIONS.fallback}`,
+  );
+}
+
+/**
+ * Canonical severity table. Maps every Codex severity vocabulary
+ * token (case-insensitive) onto the canonical ReviewProvider
+ * `Severity` enum. The table is intentionally explicit — drop-through
+ * to `'suggestion'` is reserved for tokens the table does NOT name.
+ *
+ * Exported so unit tests can drive a table-driven assertion across
+ * every documented Codex severity without re-listing the mapping
+ * inside the test file.
+ *
+ * @type {Readonly<Record<string, Severity>>}
+ */
+export const CODEX_SEVERITY_MAP = Object.freeze({
+  // Codex "blocker" terminology → canonical critical (halts the
+  // review with an unresolved-finding gate).
+  blocker: 'critical',
+  critical: 'critical',
+  fatal: 'critical',
+  // Codex "major" terminology → canonical high (lint-error
+  // equivalent; non-halting but must be addressed before merge).
+  major: 'high',
+  high: 'high',
+  error: 'high',
+  // Codex "minor" terminology → canonical medium (size/volume
+  // warning equivalent; flagged but not gating).
+  minor: 'medium',
+  medium: 'medium',
+  warning: 'medium',
+  // Codex "info" / "nit" / "style" → canonical suggestion
+  // (advisory only, no gate).
+  info: 'suggestion',
+  nit: 'suggestion',
+  style: 'suggestion',
+  suggestion: 'suggestion',
+  note: 'suggestion',
+});
+
+/**
+ * Map a single Codex severity string onto the canonical enum.
+ *
+ * @param {unknown} raw
+ * @returns {Severity}
+ */
+export function mapCodexSeverity(raw) {
+  if (typeof raw !== 'string') return 'suggestion';
+  const key = raw.trim().toLowerCase();
+  return CODEX_SEVERITY_MAP[key] ?? 'suggestion';
+}
+
+/**
+ * Parse the raw `/codex:review` stdout into `Finding[]`.
+ *
+ * The plugin emits JSON; the adapter is liberal in what it accepts:
+ *   - A bare array of finding objects.
+ *   - An object with a `findings` array.
+ *   - Either shape wrapped in an outer envelope with a `result` or
+ *     `data` key (covers minor wire-format drift across plugin
+ *     versions without re-shimming).
+ *
+ * Each entry's severity is funnelled through `mapCodexSeverity` so
+ * the canonical enum is the only thing that reaches the renderer.
+ * Entries without a `title` or `body` are skipped — the orchestrator
+ * cannot post an empty finding, and silently dropping the entry is
+ * safer than fabricating one.
+ *
+ * Exported for testing.
+ *
+ * @param {string} rawStdout
+ * @returns {Finding[]}
+ * @throws {Error} when stdout is not parseable JSON.
+ */
+export function parseCodexFindings(rawStdout) {
+  const text = (rawStdout ?? '').trim();
+  if (text.length === 0) return [];
+
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    throw new Error(
+      `[codex-review] Failed to parse /codex:review stdout as JSON: ${
+        err?.message ?? err
+      }`,
+    );
+  }
+
+  // Unwrap a single layer of envelope when present.
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    if (Array.isArray(parsed.findings)) parsed = parsed.findings;
+    else if (parsed.result !== undefined) parsed = parsed.result;
+    else if (parsed.data !== undefined) parsed = parsed.data;
+  }
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    if (Array.isArray(parsed.findings)) parsed = parsed.findings;
+  }
+
+  if (!Array.isArray(parsed)) return [];
+
+  /** @type {Finding[]} */
+  const findings = [];
+  for (const entry of parsed) {
+    if (!entry || typeof entry !== 'object') continue;
+    const title =
+      typeof entry.title === 'string' && entry.title.trim().length > 0
+        ? entry.title.trim()
+        : null;
+    const body =
+      typeof entry.body === 'string' && entry.body.trim().length > 0
+        ? entry.body
+        : typeof entry.message === 'string' && entry.message.trim().length > 0
+          ? entry.message
+          : null;
+    if (!title || !body) continue;
+
+    /** @type {Finding} */
+    const finding = {
+      severity: mapCodexSeverity(entry.severity),
+      title,
+      body,
+    };
+    if (typeof entry.file === 'string' && entry.file.length > 0) {
+      finding.file = entry.file;
+    }
+    if (Number.isInteger(entry.line) && entry.line > 0) {
+      finding.line = entry.line;
+    }
+    if (typeof entry.category === 'string' && entry.category.length > 0) {
+      finding.category = entry.category;
+    }
+    findings.push(finding);
+  }
+  return findings;
+}
+
+/**
+ * Build the `claude --print` prompt that invokes the `/codex:review` slash
+ * command for a review input. The risk-derived `depth` lever (Story #3937) is
+ * appended via `renderDepthDirective` so a high-risk Epic instructs Codex
+ * toward a deeper second-pass review while a low-risk one keeps it light; an
+ * absent depth renders the `standard` directive. The `/codex:review` slash
+ * command and its `--wait` flag are unchanged — the directive rides as
+ * trailing prompt prose the plugin's wrapping model reads.
+ *
+ * Pure. Exported for testing.
+ *
+ * @param {{ baseRef: string, headRef: string, depth?: import('./types.js').ReviewDepth }} args
+ * @returns {string}
+ */
+export function buildCodexReviewPrompt({ baseRef, headRef, depth }) {
+  return (
+    `/codex:review --base ${baseRef} --head ${headRef} --wait ` +
+    `${renderDepthDirective(depth)}`
+  );
+}
+
+/**
+ * Default invoker: shell out to the host's `claude` CLI to run the
+ * `/codex:review` slash command. The plugin is expected to print a
+ * JSON document to stdout when `--wait` is passed; non-zero exits
+ * propagate as an Error so the orchestrator records the run as
+ * `status=invalid` rather than burying the failure.
+ *
+ * Exported for testing — the production adapter accepts an
+ * `invokeFn` override so tests never spawn a real process.
+ *
+ * @param {{ baseRef: string, headRef: string, depth?: import('./types.js').ReviewDepth }} args
+ * @returns {{ status: number, stdout: string, stderr: string }}
+ */
+export function defaultInvokeCodexReview({ baseRef, headRef, depth }) {
+  const cliArgs = [
+    '--print',
+    buildCodexReviewPrompt({ baseRef, headRef, depth }),
+  ];
+  const result = spawnSync('claude', cliArgs, {
+    encoding: 'utf-8',
+    shell: process.platform === 'win32',
+  });
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}
+
+/**
+ * Build a `ReviewProvider` instance backed by the Codex plugin.
+ *
+ * The `deps` overload is the test seam — production callers (the
+ * factory) invoke `createCodexProvider()` with no arguments and get
+ * the default dependency chain (probe via plugin marker, invoker via
+ * the `claude` CLI). Tests inject `probeFn` (to bypass the marker
+ * check) and `invokeFn` (to return canned stdout).
+ *
+ * @param {{
+ *   probeFn?: () => boolean,
+ *   invokeFn?: (args: { baseRef: string, headRef: string, scope: string, ticketId: number, depth?: import('./types.js').ReviewDepth }) => { status: number, stdout: string, stderr: string },
+ *   logger?: { info?: Function, warn?: Function, error?: Function },
+ * }} [deps]
+ * @returns {ReviewProvider}
+ */
+export function createCodexProvider(deps = {}) {
+  const probeFn = deps.probeFn ?? defaultProbeCodexCommand;
+  if (!probeFn()) {
+    throw buildCodexUnavailableError();
+  }
+
+  const invokeFn = deps.invokeFn ?? defaultInvokeCodexReview;
+  const logger = deps.logger;
+
+  return {
+    /**
+     * @param {ReviewInput} input
+     * @returns {Promise<Finding[]>}
+     */
+    async runReview(input) {
+      const { scope, ticketId, baseRef, headRef, depth } = input ?? {};
+      if (!baseRef || !headRef) {
+        throw new TypeError(
+          '[codex-review] runReview requires baseRef and headRef.',
+        );
+      }
+      if (!Number.isInteger(ticketId) || ticketId <= 0) {
+        throw new TypeError(
+          '[codex-review] runReview requires a positive integer ticketId.',
+        );
+      }
+
+      logger?.info?.(
+        `[codex-review] Invoking /codex:review --base ${baseRef} --head ${headRef} ` +
+          `for ${scope} #${ticketId}...`,
+      );
+
+      const result = invokeFn({ baseRef, headRef, scope, ticketId, depth });
+      if (result.status !== 0) {
+        throw new Error(
+          `[codex-review] /codex:review exited with status ${result.status}: ${
+            result.stderr || result.stdout || '<no output>'
+          }`,
+        );
+      }
+
+      const findings = parseCodexFindings(result.stdout);
+      logger?.info?.(
+        `[codex-review] Parsed ${findings.length} finding(s) from /codex:review.`,
+      );
+      return findings;
+    },
+  };
+}
+
+/**
+ * Zero-arg factory entry point used by the `review-provider-factory`
+ * registry. Mirrors `createNativeProviderForRegistry` so the registry
+ * signature stays `() => ReviewProvider`.
+ *
+ * @returns {ReviewProvider}
+ */
+export function createCodexProviderForRegistry() {
+  return createCodexProvider();
+}