mandrel 2.50.0 → 2.52.0

package/.agents/audit-checklists/accessibility.md

@@ -12,6 +12,7 @@ Self-check your change against this lens's concerns before you ship:
 
 - [ ] `audit-accessibility` (this lens)
 - [ ] `audit-ux-ui`
+- [ ] `audit-mobile`
 - [ ] Renderable surface
 - [ ] Static a11y tooling already in the repo
 - [ ] Design tokens

package/.agents/audit-checklists/mobile.md

@@ -0,0 +1,35 @@
+<!-- GENERATED FILE — do not edit by hand.
+     Source of truth: .agents/workflows/audit-mobile.md
+     Regenerate: node .agents/scripts/generate-lens-checklists.js
+     Drift is gated by: npm run docs:check
+-->
+
+# Mobile & Tablet UX Audit — authoring checklist
+
+> Audit mobile and tablet UX — layout and viewport correctness, touch ergonomics, responsive assets, and whether anything actually verifies them at a small viewport (static-first, with an optional runtime viewport pass)
+
+Self-check your change against this lens's concerns before you ship:
+
+- [ ] Breakpoint scale
+- [ ] Viewport contract
+- [ ] Declared device matrix
+- [ ] Runtime target (optional)
+- [ ] Viewport meta
+- [ ] Fixed dimensions
+- [ ] Viewport-height units
+- [ ] Horizontal overflow
+- [ ] Safe-area insets
+- [ ] Hover-only interaction
+- [ ] Control size and spacing
+- [ ] Input ergonomics
+- [ ] Gesture conflicts
+- [ ] Images
+- [ ] Media and embeds
+- [ ] Typography and spacing
+- [ ] Coverage — is anything exercised at a non-desktop viewport?
+- [ ] Effectiveness — does that exercise assert anything mobile-specific?
+- [ ] Resolve the target from config — never a hardcoded URL.
+- [ ] Sample routes from the navigability SSOT.
+- [ ] Drive two form factors per route.
+- [ ] Median-of-3 or provisional.
+- [ ] Leave the viewport as you found it.

package/.agents/audit-checklists/ux-ui.md

@@ -21,5 +21,4 @@ Self-check your change against this lens's concerns before you ship:
 - [ ] Information Hierarchy
 - [ ] Error States
 - [ ] Loading States
-- [ ] Responsiveness
 - [ ] Accessibility (UX-focused)

package/.agents/docs/workflows.md

@@ -32,7 +32,7 @@ by `node .agents/scripts/generate-workflows-doc.js`; `npm run docs:check`
 fails when it drifts from the on-disk workflow set. To change a command’s
 description, edit the workflow file’s front-matter and regenerate.
 
-## Commands (28)
+## Commands (29)
 
 | Command | Description |
 | --- | --- |
@@ -45,6 +45,7 @@ description, edit the workflow file’s front-matter and regenerate.
 | `/audit-dependencies` | Audit `package.json` for unused, outdated, and major-version-stale dependencies; surface Node-engine drift and propose upgrade batches. |
 | `/audit-devops` | Audit CI/CD workflows, container images, infrastructure-as-code, and deployment pipelines; surface failure modes and hardening gaps. |
 | `/audit-documentation` | Audit the repository's main documentation for staleness, semantic drift, and completeness; emit a structured High/Medium/Low findings report. |
+| `/audit-mobile` | Audit mobile and tablet UX — layout and viewport correctness, touch ergonomics, responsive assets, and whether anything actually verifies them at a small viewport (static-first, with an optional runtime viewport pass) |
 | `/audit-navigability` | Audit the whole route tree against the consumer's nav-registry SSOT — every route has a persona nav door and no nav href is dead. A deliberately-global lens exempt from the cross-epic-leak guard and routed onto route-adding change sets. |
 | `/audit-performance` | Audit performance by measuring first — profile hot paths, I/O, memory, and payload against the repo's own numbers — and audit interleaving/partial-failure correctness (TOCTOU, unawaited promises, non-atomic writes) as a first-class dimension. |
 | `/audit-privacy` | Audit logs, telemetry, and persistence paths for PII leakage and retention violations; surface secrets exposure and consent gaps. |

package/.agents/schemas/audit-rules.json

@@ -299,6 +299,36 @@
       "scope": "local",
       "substitutionKeys": []
     },
+    "audit-mobile": {
+      "triggers": {
+        "gates": ["gate2", "gate3"],
+        "keywords": [
+          "mobile",
+          "tablet",
+          "responsive",
+          "breakpoint",
+          "viewport",
+          "touch"
+        ],
+        "filePatterns": [
+          "**/*.html",
+          "**/*.astro",
+          "**/*.css",
+          "**/*.{scss,sass,less}",
+          "**/styles/**",
+          "**/components/**/*.{js,jsx,ts,tsx,vue,svelte}",
+          "**/app/**/{page,layout,route,head,default,template,loading,error,not-found}.{js,jsx,ts,tsx}",
+          "**/pages/**/*.{js,jsx,ts,tsx,vue}",
+          "**/routes/**/*.{jsx,tsx,vue,svelte}",
+          "**/tailwind.config.{js,ts,cjs,mjs}",
+          "**/playwright.config.{js,ts,cjs,mjs}",
+          "**/cypress.config.{js,ts,cjs,mjs}"
+        ]
+      },
+      "target": "web",
+      "scope": "local",
+      "substitutionKeys": []
+    },
     "audit-navigability": {
       "triggers": {
         "gates": ["gate2", "gate3"],

package/.agents/scripts/lib/audit-to-stories/audit-lenses.js

@@ -33,6 +33,7 @@ export const AUDIT_LENSES = Object.freeze([
   'dependencies',
   'devops',
   'documentation',
+  'mobile',
   'navigability',
   'performance',
   'privacy',

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

@@ -95,6 +95,40 @@ export const RUNTIME_FRICTION_CATEGORIES = Object.freeze({
   REVIEW_BLOCK_OVERRIDDEN: 'review-block-overridden',
 });
 
+/**
+ * The friction category one light-path refusal files under.
+ *
+ * `LIGHT_SCOPE_REJECTED` alone used to be the category for every refusal, and
+ * the retro composer aggregates, de-duplicates and labels on the category
+ * string ALONE — so an empty-diff refusal and a `public-api` sensitive-path
+ * refusal landed in one bucket and filed one "recurred 2 times across 2
+ * Stories" follow-up whose two occurrences had nothing in common but the
+ * category (issue #5237; consumer Beestera/swarm-os#2408). The roll-up's shape
+ * fingerprint could not separate them either: it hashes detail KEYS, and every
+ * refusal carries an identical key set.
+ *
+ * Encoding the refusal class in the category is what splits them, and it
+ * splits them in every consumer at once — bucket aggregation, the graduator's
+ * idempotency marker and the `friction::<category>` label all read this one
+ * string. N refusals of the SAME class still coalesce, which is the recurrence
+ * evidence the light ceilings are recalibrated from. New categories need no
+ * seeding: the graduator mints missing `friction::*` labels before filing.
+ *
+ * A class-less refusal keeps the bare category unchanged — that is the
+ * suitability gate, which refuses a prompt before any diff exists and so has
+ * no diff-derived class to carry.
+ *
+ * @param {string|null} [refusalClass] A
+ *   {@link module:lib/orchestration/light-suitability.LIGHT_REFUSAL_CLASSES}
+ *   value, or nullish for the unclassified refusal.
+ * @returns {string}
+ */
+export function lightScopeRejectedCategory(refusalClass) {
+  const suffix = typeof refusalClass === 'string' ? refusalClass.trim() : '';
+  const base = RUNTIME_FRICTION_CATEGORIES.LIGHT_SCOPE_REJECTED;
+  return suffix === '' ? base : `${base}-${suffix}`;
+}
+
 /** Cap on free-form reason text copied into a signal's `details`. */
 const REASON_PREVIEW_LIMIT = 500;
 

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

@@ -18,16 +18,26 @@
  *     other consumer are looking at the same change set.
  *   - `--numstat` gives per-file line counts, the only surface carrying them.
  *
+ * Both read committed state, which is why a third read exists
+ * ({@link module:lib/orchestration/worktree-dirty.hasUncommittedWork}): an
+ * empty diff is ambiguous between "no work" and "work not committed yet", and
+ * only one of those is about scope.
+ *
  * @module lib/orchestration/light-backstop
  */
 
+import { gitSpawn } from '../git-utils.js';
 import { computeChangeSet } from './change-set.js';
 import { readNumstatRows, summarizeDiffMagnitude } from './diff-magnitude.js';
 import {
   handleBlockedBackstop,
   preserveRefusedWork,
 } from './light-escalation.js';
-import { checkLightDiffBackstop } from './light-suitability.js';
+import {
+  checkLightDiffBackstop,
+  LIGHT_REFUSAL_CLASSES,
+} from './light-suitability.js';
+import { hasUncommittedWork } from './worktree-dirty.js';
 
 /** Exit code when the diff backstop blocked the land. */
 const EXIT_BACKSTOP_BLOCKED = 3;
@@ -41,6 +51,8 @@ const EXIT_BACKSTOP_BLOCKED = 3;
  *   cwd?: string,
  *   computeFn?: typeof computeChangeSet,
  *   readRowsFn?: typeof readNumstatRows,
+ *   dirtyProbeFn?: typeof hasUncommittedWork,
+ *   gitFn?: typeof gitSpawn,
  *   injectedRules?: object,
  * }} args
  * @returns {ReturnType<typeof checkLightDiffBackstop>}
@@ -51,6 +63,8 @@ function runDiffBackstop({
   cwd = process.cwd(),
   computeFn = computeChangeSet,
   readRowsFn = readNumstatRows,
+  dirtyProbeFn = hasUncommittedWork,
+  gitFn = gitSpawn,
   injectedRules,
 } = {}) {
   const headRef = `story-${storyId}`;
@@ -61,9 +75,49 @@ function runDiffBackstop({
     changedFiles: files,
     magnitude,
     injectedRules,
+    storyBranch: headRef,
+    // Only an ENUMERATED-empty diff can be explained by uncommitted work, so
+    // the probe's two git calls are spent only where they can change what the
+    // refusal tells the agent to do.
+    uncommittedWork:
+      Array.isArray(files) && files.length === 0
+        ? dirtyProbeFn({ branch: headRef, cwd, gitFn })
+        : false,
   });
 }
 
+/**
+ * Is this refusal the one that is NOT about scope?
+ *
+ * @param {{ refusalClass?: string|null }} result
+ * @returns {boolean}
+ */
+function isUncommittedRefusal(result) {
+  return result.refusalClass === LIGHT_REFUSAL_CLASSES.UNCOMMITTED_WORK;
+}
+
+/**
+ * Close the refusal log line: what became of the work, and what to run next.
+ *
+ * A `null` preservation is the uncommitted-work refusal by construction — that
+ * is the one path that does not push, because there is nothing a push could
+ * preserve: it would publish a branch at its base and then report uncommitted
+ * work as safe on `origin`, which is the opposite of true.
+ *
+ * @param {{
+ *   storyId: number,
+ *   preservation: { detail: string }|null,
+ *   nextCommand: string,
+ * }} args
+ * @returns {string}
+ */
+function describeBlockedTail({ storyId, preservation, nextCommand }) {
+  return preservation === null
+    ? `nothing is committed yet, so there is no work to preserve; ` +
+        `commit on story-${storyId}, then re-run: "${nextCommand}"`
+    : `${preservation.detail}; recycle the receipt with "${nextCommand}"`;
+}
+
 /**
  * Resolve the backstop pass into everything the CLI needs to print and exit
  * with: the verdict, the recycle command on a refusal (`null` when clean), the
@@ -82,8 +136,8 @@ function runDiffBackstop({
  *   handleBlockedFn?: typeof handleBlockedBackstop,
  *   preserveFn?: typeof preserveRefusedWork,
  * }} args Any further keys (`baseRef`, `cwd`, `computeFn`, `readRowsFn`,
- *   `injectedRules`) forward to the backstop run, so the git-surface join is
- *   drivable through this one entry point.
+ *   `dirtyProbeFn`, `gitFn`, `injectedRules`) forward to the backstop run, so
+ *   the git-surface join is drivable through this one entry point.
  * @returns {Promise<{
  *   result: ReturnType<typeof checkLightDiffBackstop>,
  *   nextCommand: string|null,
@@ -109,7 +163,9 @@ export async function resolveBackstopOutcome({
       message: `[deliver-light] diff backstop clean for Story #${storyId}.`,
     };
   }
-  const preservation = preserveFn({ storyId, cwd: seams.cwd });
+  const preservation = isUncommittedRefusal(result)
+    ? null
+    : preserveFn({ storyId, cwd: seams.cwd });
   const nextCommand = await handleBlockedFn({ storyId, result, preservation });
   return {
     result,
@@ -118,7 +174,7 @@ export async function resolveBackstopOutcome({
     exitCode: EXIT_BACKSTOP_BLOCKED,
     message:
       `[deliver-light] diff backstop BLOCKED Story #${storyId}: ` +
-      `${result.reasons.join('; ')} — ${preservation.detail}; ` +
-      `recycle the receipt with "${nextCommand}"`,
+      `${result.reasons.join('; ')} — ` +
+      describeBlockedTail({ storyId, preservation, nextCommand }),
   };
 }

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

@@ -41,8 +41,10 @@
 import { getStoryBranch, gitSpawn } from '../git-utils.js';
 import {
   emitRuntimeFriction,
+  lightScopeRejectedCategory,
   RUNTIME_FRICTION_CATEGORIES,
 } from '../observability/runtime-friction.js';
+import { LIGHT_REFUSAL_CLASSES } from './light-suitability.js';
 
 /**
  * The `/mandrel-plan` invocation that owns a Story the light path could not land.
@@ -54,6 +56,21 @@ function buildRecycleCommand(storyId) {
   return `/mandrel-plan ${storyId}`;
 }
 
+/**
+ * The command that re-runs the backstop once the work is committed.
+ *
+ * The one refusal that is NOT about scope gets its own next step: an empty diff
+ * over a dirty worktree means the backstop ran before the commit, and handing
+ * that run to `/mandrel-plan` recycles a receipt whose implementation is fine
+ * — the wrong door, dressed as an escalation (issue #5237).
+ *
+ * @param {number} storyId
+ * @returns {string}
+ */
+function buildRerunBackstopCommand(storyId) {
+  return `node .agents/scripts/deliver-light.js --backstop --story ${storyId}`;
+}
+
 /**
  * Coerce an `--amends` argument (`#123` or `123`) into a positive integer issue
  * number, or `null` when absent/malformed.
@@ -127,10 +144,12 @@ export async function handleBlockedBackstop({
   emitFn,
   recordFrictionFn = recordScopeFriction,
 } = {}) {
+  const refusalClass = result?.refusalClass ?? null;
   await recordFrictionFn({
     emitFn,
     storyId,
     surface: 'diff-backstop',
+    category: lightScopeRejectedCategory(refusalClass),
     reasons: result?.reasons ?? [],
     details: {
       fileCount: result?.fileCount ?? null,
@@ -142,9 +161,12 @@ export async function handleBlockedBackstop({
       // than one whose branch reached origin — the roll-up must be able to
       // tell them apart.
       preserved: preservation?.preserved ?? null,
+      refusalClass,
     },
   });
-  return buildRecycleCommand(storyId);
+  return refusalClass === LIGHT_REFUSAL_CLASSES.UNCOMMITTED_WORK
+    ? buildRerunBackstopCommand(storyId)
+    : buildRecycleCommand(storyId);
 }
 
 /**
@@ -221,15 +243,19 @@ export function preserveRefusedWork({
  * @param {{
  *   storyId?: number|null,
  *   surface: string,
+ *   category?: string,
  *   reasons?: string[],
  *   details?: object,
  *   emitFn?: typeof emitRuntimeFriction,
- * }} args
+ * }} args `category` defaults to the unclassified light-refusal bucket, which
+ *   is what the suitability gate emits: it refuses a prompt before any diff
+ *   exists, so it carries no refusal class to encode.
  * @returns {Promise<boolean>}
  */
 async function recordScopeFriction({
   storyId,
   surface,
+  category = RUNTIME_FRICTION_CATEGORIES.LIGHT_SCOPE_REJECTED,
   reasons = [],
   details = {},
   emitFn,
@@ -238,7 +264,7 @@ async function recordScopeFriction({
   try {
     return await emit({
       storyId,
-      category: RUNTIME_FRICTION_CATEGORIES.LIGHT_SCOPE_REJECTED,
+      category,
       tool: 'deliver-light',
       details: { surface, reasons, ...details },
     });

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

@@ -524,6 +524,52 @@ export function resolveLightGateOutcome({
   };
 }
 
+/**
+ * The refusal classes a blocked diff backstop can carry — the machine-readable
+ * half of a verdict whose `reasons[]` are prose (Story #5238).
+ *
+ * One value per blocked verdict, and the reason it exists is downstream: the
+ * refusal's friction category is derived from it
+ * ({@link module:lib/observability/runtime-friction.lightScopeRejectedCategory}),
+ * and the category is the ONLY key the retro composer separates buckets on.
+ * Under one bare category an empty-diff refusal and a `public-api` refusal
+ * aggregated into a single "recurred 2 times" follow-up with nothing in common
+ * (issue #5237) — the roll-up's shape fingerprint could not tell them apart
+ * either, because it hashes detail keys and every refusal carries the same set.
+ *
+ * Kept coarse on purpose: a class must be stable enough that N refusals of one
+ * cause still coalesce into the recurrence evidence the ceilings are
+ * recalibrated from.
+ *
+ * @typedef {{ reason: string, refusalClass: string }} Objection
+ */
+export const LIGHT_REFUSAL_CLASSES = Object.freeze({
+  /** The diff could not be enumerated, or enumerated to nothing. */
+  CHANGE_SET_UNKNOWN: 'change-set-unknown',
+  /** Enumerated-empty, but the worktree carries uncommitted changes. */
+  UNCOMMITTED_WORK: 'uncommitted-work',
+  /** The change set intersects a registered sensitive-path class. */
+  SENSITIVE_PATH: 'sensitive-path',
+  /** Sensitivity could not be classified, so non-sensitivity is unproven. */
+  SENSITIVITY_UNKNOWN: 'sensitivity-unknown',
+  /** The implementation magnitude could not be measured. */
+  MAGNITUDE_UNKNOWN: 'magnitude-unknown',
+  /** Measured magnitude exceeded a light ceiling. */
+  OVER_CEILING: 'over-ceiling',
+});
+
+/**
+ * Name the branch a commit-first refusal tells the agent to commit on, with a
+ * generic stand-in when the caller supplied none. Pure.
+ *
+ * @param {unknown} storyBranch
+ * @returns {string}
+ */
+function describeStoryBranch(storyBranch) {
+  const name = typeof storyBranch === 'string' ? storyBranch.trim() : '';
+  return name === '' ? 'the Story branch' : name;
+}
+
 /**
  * Diff-derived backstop (Story #4740 AC-4, re-based on magnitude by Story
  * #4856): re-check the **actual** change set after implementation, because the
@@ -555,7 +601,14 @@ export function resolveLightGateOutcome({
  *   ceilings?: { maxImplLines?: number, maxImplFiles?: number },
  *   injectedRules?: object,
  *   selectSensitivePathClassesFn?: Function,
- * }} [args]
+ *   storyBranch?: string,
+ *   uncommittedWork?: boolean,
+ * }} [args] `uncommittedWork` is the caller's dirty-worktree probe result: the
+ *   backstop reads COMMITTED state, so an implemented-but-uncommitted run
+ *   measures an empty diff, and the door for that is `git commit` — not an
+ *   escalation. It only ever refines an enumerated-empty verdict's guidance;
+ *   the verdict itself still blocks. `storyBranch` names the branch that
+ *   guidance points at.
  * @returns {{
  *   blocked: boolean,
  *   level: 'low'|'high'|null,
@@ -563,8 +616,10 @@ export function resolveLightGateOutcome({
  *   fileCount: number|null,
  *   magnitude: { implFiles: number, implLines: number }|null,
  *   ceilings: { maxImplLines: number, maxImplFiles: number },
+ *   refusalClass: string|null,
  *   reasons: string[],
- * }}
+ * }} `refusalClass` is `null` on a clean verdict and exactly one
+ *   {@link LIGHT_REFUSAL_CLASSES} value on every blocked one.
  */
 export function checkLightDiffBackstop({
   changedFiles,
@@ -572,6 +627,8 @@ export function checkLightDiffBackstop({
   ceilings,
   injectedRules,
   selectSensitivePathClassesFn,
+  storyBranch,
+  uncommittedWork = false,
 } = {}) {
   const resolved = resolveDiffCeilings(ceilings);
   const files = Array.isArray(changedFiles)
@@ -579,6 +636,12 @@ export function checkLightDiffBackstop({
     : null;
 
   if (files === null || files.length === 0) {
+    // An ENUMERATED-empty diff over a dirty worktree is a different event from
+    // an unverifiable one, and blocking is right for both — but only one of
+    // them is about scope. The caller's probe distinguishes them; `files ===
+    // null` never can, because a `git diff` that failed outright is exactly
+    // the case where nothing about the change is known.
+    const uncommitted = files !== null && uncommittedWork === true;
     return {
       blocked: true,
       level: null,
@@ -586,8 +649,13 @@ export function checkLightDiffBackstop({
       fileCount: files === null ? null : 0,
       magnitude: null,
       ceilings: resolved,
+      refusalClass: uncommitted
+        ? LIGHT_REFUSAL_CLASSES.UNCOMMITTED_WORK
+        : LIGHT_REFUSAL_CLASSES.CHANGE_SET_UNKNOWN,
       reasons: [
-        'actual change set is unknown or empty — cannot verify the diff is light; escalate to /mandrel-plan',
+        uncommitted
+          ? `the change set is empty but the worktree has uncommitted changes — commit them on ${describeStoryBranch(storyBranch)}, then re-run the backstop; nothing here is over-scope, so do NOT escalate to /mandrel-plan`
+          : 'actual change set is unknown or empty — cannot verify the diff is light; escalate to /mandrel-plan',
       ],
     };
   }
@@ -599,12 +667,12 @@ export function checkLightDiffBackstop({
   });
   const measured = normalizeMagnitude(magnitude);
 
-  const reasons = [
+  const objections = [
     ...describeSensitivity({ level, classes }),
     ...describeMagnitude(measured, resolved),
   ];
 
-  const blocked = reasons.length > 0;
+  const blocked = objections.length > 0;
   return {
     blocked,
     level,
@@ -612,8 +680,13 @@ export function checkLightDiffBackstop({
     fileCount: files.length,
     magnitude: measured,
     ceilings: resolved,
+    // Objection ORDER is the class precedence: sensitivity is derived before
+    // magnitude, so a diff that is both sensitive and over-ceiling files as a
+    // sensitive-path refusal. That is the right way round — the ceiling is
+    // recalibratable, the sensitive path is not.
+    refusalClass: blocked ? objections[0].refusalClass : null,
     reasons: blocked
-      ? reasons
+      ? objections.map((objection) => objection.reason)
       : [
           `diff is light: ${measured.implLines} implementation line(s) ≤ ${resolved.maxImplLines} ` +
             `across ${measured.implFiles} implementation file(s) ≤ ${resolved.maxImplFiles} ` +
@@ -641,17 +714,24 @@ function normalizeMagnitude(magnitude) {
  * Sensitivity objections, over the **full** change set. Pure.
  *
  * @param {{ level: 'low'|'high'|null, classes: string[] }} derived
- * @returns {string[]}
+ * @returns {Objection[]}
  */
 function describeSensitivity({ level, classes }) {
   if (classes.length > 0) {
     return [
-      `diff intersects sensitive-path class(es) ${classes.join(', ')} — escalate to /mandrel-plan (do not land light)`,
+      {
+        refusalClass: LIGHT_REFUSAL_CLASSES.SENSITIVE_PATH,
+        reason: `diff intersects sensitive-path class(es) ${classes.join(', ')} — escalate to /mandrel-plan (do not land light)`,
+      },
     ];
   }
   if (level !== 'low') {
     return [
-      'sensitive-path classification unavailable — cannot verify the diff is non-sensitive; escalate to /mandrel-plan',
+      {
+        refusalClass: LIGHT_REFUSAL_CLASSES.SENSITIVITY_UNKNOWN,
+        reason:
+          'sensitive-path classification unavailable — cannot verify the diff is non-sensitive; escalate to /mandrel-plan',
+      },
     ];
   }
   return [];
@@ -662,26 +742,32 @@ function describeSensitivity({ level, classes }) {
  *
  * @param {{ implFiles: number, implLines: number }|null} measured
  * @param {{ maxImplLines: number, maxImplFiles: number }} ceilings
- * @returns {string[]}
+ * @returns {Objection[]}
  */
 function describeMagnitude(measured, ceilings) {
   if (measured === null) {
     return [
-      'change magnitude could not be measured (unreadable or unparseable numstat) — cannot verify the diff is light; escalate to /mandrel-plan',
+      {
+        refusalClass: LIGHT_REFUSAL_CLASSES.MAGNITUDE_UNKNOWN,
+        reason:
+          'change magnitude could not be measured (unreadable or unparseable numstat) — cannot verify the diff is light; escalate to /mandrel-plan',
+      },
     ];
   }
-  const reasons = [];
+  const objections = [];
   if (measured.implLines > ceilings.maxImplLines) {
-    reasons.push(
-      `diff changes ${measured.implLines} implementation line(s) (> maxImplLines ${ceilings.maxImplLines}) — escalate to /mandrel-plan (do not land light)`,
-    );
+    objections.push({
+      refusalClass: LIGHT_REFUSAL_CLASSES.OVER_CEILING,
+      reason: `diff changes ${measured.implLines} implementation line(s) (> maxImplLines ${ceilings.maxImplLines}) — escalate to /mandrel-plan (do not land light)`,
+    });
   }
   if (measured.implFiles > ceilings.maxImplFiles) {
-    reasons.push(
-      `diff spans ${measured.implFiles} implementation file(s) (> maxImplFiles ${ceilings.maxImplFiles}) — escalate to /mandrel-plan (do not land light)`,
-    );
+    objections.push({
+      refusalClass: LIGHT_REFUSAL_CLASSES.OVER_CEILING,
+      reason: `diff spans ${measured.implFiles} implementation file(s) (> maxImplFiles ${ceilings.maxImplFiles}) — escalate to /mandrel-plan (do not land light)`,
+    });
   }
-  return reasons;
+  return objections;
 }
 
 /** Cap on a receipt slug's length — keep the branch/id readable. */

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

@@ -305,6 +305,39 @@ function fingerprintBucket(category, tools, detailKeys) {
     .slice(0, 8);
 }
 
+/**
+ * Every reason text one signal's `details` carries, read from BOTH shapes the
+ * emitters actually write.
+ *
+ * Two keys because two emitter conventions, and the divergence was silent: the
+ * degradation emitters write a singular `details.reason` string, while the
+ * light path's refusal emitter (`light-escalation.recordScopeFriction`) writes
+ * `details.reasons` — an **array**, because one backstop verdict can object on
+ * sensitivity and magnitude in the same pass. Reading only the singular key is
+ * why every `light-scope-rejected` follow-up rendered with no `Reason:` line
+ * at all (issue #5237), which defeated Story #4837's whole intent for that
+ * emitter: the filed issue named a count and a category, and the refusal text
+ * that would have told a reader which ceiling fired stayed in the ledger.
+ *
+ * Non-string members are skipped rather than coerced — `String(value)` would
+ * put `[object Object]` in a live issue body.
+ *
+ * @param {object} details
+ * @returns {string[]}
+ */
+function collectReasons(details) {
+  const out = [];
+  const single = asString(details.reason);
+  if (single.length > 0) out.push(single);
+  if (Array.isArray(details.reasons)) {
+    for (const raw of details.reasons) {
+      const text = asString(raw);
+      if (text.length > 0) out.push(text);
+    }
+  }
+  return out;
+}
+
 /**
  * Widen a bucket's first-to-last window to include one instant. A row with no
  * usable `ts` widens nothing — it is counted in `total` but cannot date the
@@ -391,8 +424,9 @@ function aggregateByCategory(signals) {
       // over keys, deliberately) is untouched by them.
       const surface = asString(sig.details.surface);
       if (surface.length > 0) entry.surfaces.add(surface);
-      const reason = asString(sig.details.reason);
-      if (reason.length > 0) entry.reasons.add(reason);
+      for (const reason of collectReasons(sig.details)) {
+        entry.reasons.add(reason);
+      }
     }
     // An id that cannot be resolved to a real issue is tracked separately
     // rather than dropped: it must never be counted or printed as recurrence

package/.agents/scripts/lib/orchestration/worktree-dirty.js

@@ -0,0 +1,80 @@
+/**
+ * lib/orchestration/worktree-dirty.js — "does this branch's checkout carry
+ * uncommitted changes?" (Story #5238).
+ *
+ * Its own module because the light path's diff backstop is otherwise a pure
+ * join over two committed-state git reads, and this is the one question there
+ * that needs a third read of a *working tree*. Keeping it here leaves
+ * {@link module:lib/orchestration/light-backstop} the thin join it claims to
+ * be, and gives the probe its own place to be tested against every way a git
+ * read can fail.
+ *
+ * @module lib/orchestration/worktree-dirty
+ */
+
+import { gitSpawn } from '../git-utils.js';
+import { parseWorktreePorcelain } from '../worktree/inspector.js';
+
+/**
+ * The stdout of a successful git read, or `null` when it cannot be trusted.
+ *
+ * @param {{ status?: number, stdout?: unknown }|null|undefined} result
+ * @returns {string|null}
+ */
+function readableStdout(result) {
+  if (result?.status !== 0) return null;
+  return typeof result.stdout === 'string' ? result.stdout : null;
+}
+
+/**
+ * Locate the checkout that has `branch` checked out, or `null` when no
+ * checkout does.
+ *
+ * `git worktree list --porcelain` enumerates **every** checkout including the
+ * main one, so a repository working on the branch directly (no separate
+ * worktree) is found by this same lookup rather than by a second fallback path.
+ *
+ * @param {{ branch: string, cwd: string, gitFn: typeof gitSpawn }} args
+ * @returns {string|null}
+ */
+function resolveBranchCheckout({ branch, cwd, gitFn }) {
+  const listed = readableStdout(gitFn(cwd, 'worktree', 'list', '--porcelain'));
+  if (listed === null) return null;
+  const match = parseWorktreePorcelain(listed).find(
+    (record) => record.branch === branch,
+  );
+  return match ? match.path : null;
+}
+
+/**
+ * Does the checkout holding `branch` have uncommitted changes?
+ *
+ * **Why the light path asks.** Its diff backstop measures `base...head`, which
+ * is committed state, so a run that implemented and did not commit measures an
+ * empty change set — and the refusal then told the agent its scope was
+ * unverifiable and to escalate, when the actual fix was `git commit`. Measured
+ * in the consumer: the refusal signal is stamped 12:14:06Z and the branch's
+ * only commit 12:15:19Z (issue #5237).
+ *
+ * Total, and deliberately asymmetric: every unreadable surface — a failed
+ * `worktree list`, a branch no checkout holds, a failed `status`, a throwing
+ * git — answers `false`. A probe that cannot see the tree must not be able to
+ * talk a refusal into friendlier guidance than the evidence supports.
+ *
+ * @param {{ branch: string, cwd?: string, gitFn?: typeof gitSpawn }} args
+ * @returns {boolean}
+ */
+export function hasUncommittedWork({
+  branch,
+  cwd = process.cwd(),
+  gitFn = gitSpawn,
+} = {}) {
+  try {
+    const checkout = resolveBranchCheckout({ branch, cwd, gitFn });
+    if (checkout === null) return false;
+    const status = readableStdout(gitFn(checkout, 'status', '--porcelain'));
+    return status !== null && status.trim() !== '';
+  } catch {
+    return false;
+  }
+}

package/.agents/workflows/audit-accessibility.md

@@ -31,9 +31,9 @@ on a project with no rendered frontend, since there are no components, templates
 or routes to hold to WCAG. See the `target` key's schema description for how
 applicability is probed from the consumer's checkout.
 
-## Boundary with `audit-ux-ui`
+## Boundaries with the neighbouring web lenses
 
-These two web lenses share a border and must not double-report:
+These lenses share a border with this one and must not double-report:
 
 - **`audit-accessibility` (this lens)** owns **WCAG conformance** — the
   standards question: does an assistive-technology user perceive, operate, and
@@ -41,11 +41,17 @@ These two web lenses share a border and must not double-report:
   controls, text alternatives, and contrast against the WCAG ratio thresholds.
 - **`audit-ux-ui`** owns **design-system adherence** — the consistency
   question: do components and tokens match the project's own design system?
-
-Contrast is the one axis both can touch: **accessibility owns the WCAG ratio
-verdict** (4.5:1 body / 3:1 large text / 3:1 non-text), while ux-ui owns whether
-the colour came from a sanctioned token. When a contrast defect is in scope for
-both, report the WCAG failure here and leave the token-adherence note to ux-ui.
+- **`audit-mobile`** owns **small-screen and touch behaviour** — layout at a
+  phone or tablet viewport, touch ergonomics, responsive assets, and mobile
+  test coverage. It may measure a control's rendered size as ergonomic
+  evidence, but the `2.5.8 Target Size (Minimum)` verdict on an undersized
+  target is reported here.
+
+Contrast is the one axis accessibility and ux-ui both touch: **accessibility
+owns the WCAG ratio verdict** (4.5:1 body / 3:1 large text / 3:1 non-text),
+while ux-ui owns whether the colour came from a sanctioned token. When a
+contrast defect is in scope for both, report the WCAG failure here and leave
+the token-adherence note to ux-ui.
 
 ## Scope
 

package/.agents/workflows/audit-mobile.md

@@ -0,0 +1,242 @@
+---
+description: Audit mobile and tablet UX — layout and viewport correctness, touch ergonomics, responsive assets, and whether anything actually verifies them at a small viewport (static-first, with an optional runtime viewport pass)
+---
+
+# Mobile & Tablet UX Audit
+
+You are a Senior Mobile Web Engineer holding the frontend to its **small-screen
+and touch contract**: does every surface lay out, scroll, and answer a finger on
+a phone and a tablet — and does anything in the suite actually verify that it
+does? Default to **static** detection over source; escalate to a **runtime**
+viewport pass only when a live target is configured. The shared lens machinery —
+read-only constraint, scope interpretation, report envelope + finding-block
+skeleton, severity scale, self-cross-check, and execution strategy — lives in
+[`helpers/audit-lens-core.md`](helpers/audit-lens-core.md). Write the report to
+`{{auditOutputDir}}/audit-mobile-results.md`. Dimension values:
+`Layout & Viewport | Touch Ergonomics | Responsive Assets | Mobile Verification`.
+Extra finding field: **Evidence:** (`measured | static` + the observable;
+single-run runtime numbers are tagged `provisional`).
+The report adds a **Runtime Viewport Pass** section.
+
+> **An emulated viewport is not a device.** Viewport emulation resizes and
+> re-flows the page; it does not reproduce a real device's browser engine,
+> input latency, font rendering, or OS chrome. Report what the emulator
+> observed, never "verified on iPhone".
+
+## Applicability
+
+**Web targets only.** Registered with `target: "web"` in
+[`audit-rules.json`](../schemas/audit-rules.json): the selector skips this lens
+on a project with no rendered frontend, since there is no layout to re-flow and
+no control to touch. See the `target` key's schema description for how
+applicability is probed from the consumer's checkout.
+
+## Boundaries with the neighbouring lenses
+
+Four lenses border this one. Report a finding **here** only when it is a
+small-screen or touch defect; defer the rest so the suite never double-reports:
+
+- [`/audit-accessibility`](audit-accessibility.md) owns every **WCAG
+  success-criterion verdict**, including `2.5.8 Target Size (Minimum)`. This
+  lens may **measure** a control's rendered size as ergonomic evidence, but the
+  conformance verdict on an undersized target belongs there.
+- [`/audit-ux-ui`](audit-ux-ui.md) owns **design-system adherence** — whether a
+  value came from a sanctioned token and whether a raw element should have
+  deferred to a design-system component. This lens asks only whether the result
+  works at a small viewport, whatever its provenance.
+- [`/audit-performance`](audit-performance.md) owns **Core Web Vitals, bundle
+  weight, and network cost**, mobile ones included. An oversized hero image is
+  reported here only as a missing `srcset`/`sizes` **contract**, never as a
+  payload-weight verdict.
+- [`/audit-quality`](audit-quality.md) owns the **generic** test verdicts —
+  pyramid balance, flake, and coverage gaps. This lens owns exactly one test
+  question: is any of it exercised at a non-desktop viewport, and does that
+  exercise assert something mobile-specific (Step 2).
+
+## Scope
+
+Interpret this lens's change-set fence per the core's Scope interpretation:
+
+```text
+{{changedFiles}}
+```
+
+## Execution strategy
+
+Run this lens as a single `subagent_type: auditor` dispatch returning the report
+path + Executive Summary; sequential inline execution is the fallback (see the
+core's Execution strategy).
+
+## Step 0: Discover the responsive baseline (run first)
+
+**You cannot audit responsiveness against a generic ideal — a 640px fixed width
+is a defect only relative to the breakpoints the project actually claims to
+support.** Before any detection, locate this lens's own sources of truth (they
+are *not* ux-ui's design system, though they often live beside it) and record
+what they declare:
+
+- **Breakpoint scale:** the `screens` map in `tailwind.config.{js,ts}`, CSS
+  custom media / container queries, a `breakpoints` token file, or a
+  CSS-in-JS theme's media helpers. Census the `@media` / `container` queries
+  actually used in the stylesheets and note the narrowest one — that is the
+  smallest width the project has any evidence of supporting.
+- **Viewport contract:** the `<meta name="viewport">` tag (or the framework
+  `viewport` export) and whether it sets `width=device-width` and leaves user
+  scaling enabled.
+- **Declared device matrix:** any non-desktop viewport already configured in the
+  consumer's test tooling — Playwright `projects[]` using `devices[...]` or an
+  explicit `viewport`, a Cypress `viewportWidth`/`viewportHeight`, a
+  visual-regression viewport list. This is the project's own statement of which
+  form factors it holds itself to.
+- **Runtime target (optional):** the `qa.environments` map (see
+  [*Runtime viewport pass*](#step-3-runtime-viewport-pass-optional-corroboration))
+  and the navigability route SSOT.
+
+Record the breakpoints, the viewport contract, and the device matrix. Every
+finding downstream is measured against *this discovered baseline*. If the
+project declares **no** breakpoint scale and no device matrix, say so and
+downgrade findings to "no responsive baseline declared — recommend establishing
+a breakpoint scale and a phone/tablet test viewport first" rather than scoring
+the tree against an invented one.
+
+## Step 1: Static detection, then triage
+
+Run the **mechanical detectors first** (cheap, deterministic greps over the
+in-scope styles and components), then apply **LLM triage** to each candidate
+against the Step 0 baseline — a mechanical hit is a *candidate*, not
+automatically a finding.
+
+### Layout & Viewport
+
+- **Viewport meta:** absent `<meta name="viewport">`, a missing
+  `width=device-width`, or `user-scalable=no` / `maximum-scale=1` pinning the
+  page against pinch-zoom.
+- **Fixed dimensions:** `width`/`min-width`/`height` px literals wider than the
+  narrowest declared breakpoint, outside token and container-query files — the
+  classic source of a page that cannot shrink.
+- **Viewport-height units:** `100vh` (or `vh` arithmetic) with no `dvh`/`svh`
+  fallback, which cuts content off under a mobile browser's collapsing toolbar.
+- **Horizontal overflow:** unconstrained wide content — tables, `<pre>` blocks,
+  code fences, flex rows with no `min-width: 0`, absolutely-positioned elements
+  extending past the viewport — and any `overflow-x: visible` on a container
+  holding them. A page whose body scrolls sideways on a phone is a defect
+  regardless of its cause.
+- **Safe-area insets:** `position: fixed`/`sticky` elements pinned to a screen
+  edge (bottom bars, floating actions, drawers, modals) with no
+  `env(safe-area-inset-*)` allowance, so a notch or home indicator overlaps
+  them.
+
+### Touch Ergonomics
+
+- **Hover-only interaction:** a `:hover`/`hover:` state that reveals content or
+  is the only affordance for an action, with no touch-reachable equivalent
+  (a click/tap handler, a focus state, or an always-visible control). On a
+  touch device that interaction does not exist.
+- **Control size and spacing:** interactive controls whose rendered box is
+  visibly under ~44×44 CSS px, or adjacent tap targets with no separating
+  spacing. Report the **measurement** as ergonomic evidence and leave the
+  WCAG `2.5.8` verdict to the accessibility lens.
+- **Input ergonomics:** form inputs with a font-size under 16px (iOS Safari
+  zooms the whole page on focus), a missing or wrong `inputmode`/`type` for the
+  expected keyboard (numeric, email, tel), and `autocomplete` omitted on
+  identity or address fields where a small-screen user most needs it.
+- **Gesture conflicts:** custom swipe/drag handlers that call
+  `preventDefault()` on `touchstart`/`touchmove` across a scrollable region, or
+  scroll containers nested inside a horizontal pager, which strand the user's
+  scroll.
+
+### Responsive Assets
+
+- **Images:** `<img>` with no `srcset`/`sizes` (or a framework image component
+  bypassed for a raw tag) where the same file serves every width; a missing
+  intrinsic `width`/`height` or `aspect-ratio`, which shifts the layout as
+  images land.
+- **Media and embeds:** `<video>`, `<iframe>`, and map/chart embeds with fixed
+  pixel dimensions or no responsive container.
+- **Typography and spacing:** a type or spacing scale with no small-viewport
+  step, so a desktop-tuned heading dominates a phone screen.
+
+> **Detector output is candidates.** Triage each against the Step 0 baseline
+> before promoting it to a finding — a fixed width inside a design-system
+> primitive that its container query already re-flows, a `100vh` on a
+> deliberately desktop-only admin surface, or a raw `<img>` for a fixed-size
+> icon, is expected, not a defect.
+
+## Step 2: Mobile verification coverage & effectiveness
+
+A responsive surface with nothing holding it responsive regresses on the next
+change. This lens owns that one test question, in two parts — report them as
+separate findings, because the fixes differ:
+
+1. **Coverage — is anything exercised at a non-desktop viewport?** Reconcile the
+   Step 0 device matrix against the suites that exist: an e2e config with only a
+   desktop project, a visual-regression suite with a single wide snapshot width,
+   or Gherkin features with no phone/tablet variant all mean the responsive
+   behaviour is unverified. Name the specific surfaces in scope that no
+   non-desktop run touches.
+2. **Effectiveness — does that exercise assert anything mobile-specific?** A
+   suite that merely replays its desktop assertions at 390px wide proves the
+   page renders, not that it works. Look for assertions that could only pass on
+   a small viewport: the drawer or hamburger nav opening in place of the desktop
+   bar, the absence of horizontal document scroll, a bottom bar clearing the
+   safe area, an orientation change, a swipe or long-press gesture, a
+   viewport-conditional element being hidden or shown. A mobile project whose
+   assertions are viewport-agnostic is a **false-confidence** finding: it is
+   reported even though the suite is green, and it is usually more valuable than
+   a missing-coverage finding, because the project believes it is covered.
+
+Keep the generic test verdicts out of this step — pyramid balance, flake, and
+overall coverage gaps belong to [`/audit-quality`](audit-quality.md). Where a
+fix is a new test, name the viewport and the assertion it should make, not just
+"add mobile tests".
+
+## Step 3: Runtime viewport pass (optional corroboration)
+
+Static detection is the default and always runs. The runtime pass is
+**conditional** — it runs only when a live target is configured; its absence
+never blocks the static report.
+
+1. **Resolve the target from config — never a hardcoded URL.** Resolve the
+   target through the consumer's `qa.environments.<env>.baseUrl` (via
+   [`resolveQaEnvironment`](../scripts/lib/qa/resolve-qa-contract.js), the same
+   resolver `/qa-run` uses): an `<env>` argument resolves by exact name or
+   origin match; with no argument, enumerate `name → baseUrl` and let the
+   operator pick. If **no** `qa.environments` target is configured, **skip this
+   step** and note in the report that runtime corroboration was unavailable —
+   do not invent a URL and do not start an arbitrary dev server.
+2. **Sample routes from the navigability SSOT.** Draw the routes to exercise
+   from the consumer's route/nav registry (`planning.navigation.navRegistry` /
+   `routeGlobs` — the same SSOT [`/audit-navigability`](audit-navigability.md)
+   reads), sampling a representative set (key personas' landing routes plus any
+   route in the change-set scope) rather than a single hardcoded page.
+3. **Drive two form factors per route.** Emulate a **phone** and a **tablet**
+   viewport — `mcp__chrome-devtools__emulate` for a device profile, or
+   `resize_page` for an explicit width/height — then, per route and viewport:
+   take a screenshot, and evaluate the two observables static analysis cannot
+   resolve — whether `document.scrollingElement.scrollWidth` exceeds the
+   viewport width (horizontal overflow), and the rendered box of the
+   interactive controls Step 1 flagged as candidates. Reload after switching
+   form factor so load-time device gates re-run.
+4. **Median-of-3 or provisional.** Any runtime measurement is subject to
+   run-to-run variance: capture a **median-of-3** (three runs per route, report
+   the median) before treating a number as authoritative. A single-run value is
+   reported **provisional** and never drives a Critical/High verdict on its own.
+5. **Leave the viewport as you found it.** Reset the emulation before finishing
+   so a following lens or QA run does not inherit a phone viewport.
+
+Corroborate static findings against the runtime observations (a statically
+flagged fixed width confirmed by a real horizontal overflow graduates from
+provisional to confirmed), and surface runtime-only defects the static pass
+could not see — an element clipped only once the toolbar collapses, a drawer
+that opens off-screen.
+
+## Report additions
+
+Beyond the shared skeleton, the Executive Summary states the runtime mode's
+status (ran against `<env>` / skipped — no target configured) and names the
+narrowest breakpoint the project declares, so a reader can tell what "mobile"
+meant for this run. The report ends with a **Runtime Viewport Pass** section:
+per-route, per-form-factor observations when the runtime mode ran, or
+"*Runtime corroboration unavailable — no `qa.environments` target configured.*"
+Drop every claimed finding that names no concrete element, style rule, or test
+file.

package/.agents/workflows/audit-ux-ui.md

@@ -89,12 +89,17 @@ baseline — a mechanical hit is a *candidate*, not automatically a finding.
 2. **Error States:** Are form errors clear and helpful, or generic and
    frustrating?
 3. **Loading States:** Are there skeletons or spinners for async operations?
-4. **Responsiveness:** Check layouts at mobile, tablet, and desktop breakpoints.
-5. **Accessibility (UX-focused):** Focus on tab order, touch-target sizes, and
-   whether interaction colours come from a sanctioned token. **WCAG conformance
-   is out of scope here** — semantic structure, ARIA correctness,
-   keyboard/focus operability, form labelling, media alternatives, and the WCAG
-   contrast-ratio verdict are owned by [`/audit-accessibility`](audit-accessibility.md).
+4. **Accessibility (UX-focused):** Focus on tab order and whether interaction
+   colours come from a sanctioned token. **WCAG conformance is out of scope
+   here** — semantic structure, ARIA correctness, keyboard/focus operability,
+   form labelling, media alternatives, and the WCAG contrast-ratio verdict are
+   owned by [`/audit-accessibility`](audit-accessibility.md).
    This lens keeps token/component design-system adherence; defer every WCAG
    success-criterion judgement to the accessibility lens so the two never
    double-report.
+
+> **Small-screen behaviour is out of scope here too.** Layout at a phone or
+> tablet viewport, touch-target ergonomics, responsive assets, and whether any
+> suite exercises a non-desktop viewport belong to [`/audit-mobile`](audit-mobile.md).
+> This lens keeps the token/component question at whatever viewport the surface
+> renders.

package/.agents/workflows/helpers/deliver-light.md

@@ -153,13 +153,19 @@ answer).
    number that then rejects the change. They are **not** exempt from
    sensitive-path matching, which runs over the full change set.
 
-   Exit `3` (`blocked: true`) means the diff exceeds a light ceiling or touches a
-   sensitive-path class. STOP, flip `agent::blocked`, and **recycle the receipt**
-   through the envelope's `nextCommand` (`/mandrel-plan <storyId>`) — tickets mode
-   rewrites it into properly-planned Stories and closes it as superseded. Do not
-   land, and do not leave the receipt open with no successor: it already carries
-   the branch, the worktree, and the implementation, all of which are evidence
-   the plan should read.
+   **Commit before you run it.** The backstop measures **committed** state, so
+   a run that implemented but has not committed measures an empty diff and is
+   refused for a scope it never had. That refusal names the real fix — commit
+   on `story-<id>`, then re-run the backstop — and its `nextCommand` is that
+   re-run, not an escalation.
+
+   Exit `3` (`blocked: true`) otherwise means the diff exceeds a light ceiling or
+   touches a sensitive-path class. STOP, flip `agent::blocked`, and **recycle the
+   receipt** through the envelope's `nextCommand` (`/mandrel-plan <storyId>`) —
+   tickets mode rewrites it into properly-planned Stories and closes it as
+   superseded. Do not land, and do not leave the receipt open with no successor:
+   it already carries the branch, the worktree, and the implementation, all of
+   which are evidence the plan should read.
 
 5. **Close and land (same engine).** Exactly [`/mandrel-deliver`](../mandrel-deliver.md)'s close:
 

package/docs/CHANGELOG.md

@@ -15,6 +15,20 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.52.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.51.0...mandrel-v2.52.0) (2026-09-08)
+
+
+### Fixed
+
+* render deliver-light refusal reasons in retro follow-ups and file each backstop refusal class as its own friction category ([#5238](https://github.com/dsj1984/mandrel/issues/5238)) ([#5239](https://github.com/dsj1984/mandrel/issues/5239)) ([65ff0ff](https://github.com/dsj1984/mandrel/commit/65ff0ff4252ddc4fe34d4d8453159a80afae6223))
+
+## [2.51.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.50.0...mandrel-v2.51.0) (2026-09-08)
+
+
+### Added
+
+* **audit:** add the /audit-mobile lens for mobile and tablet UX (refs [#5233](https://github.com/dsj1984/mandrel/issues/5233)) ([#5234](https://github.com/dsj1984/mandrel/issues/5234)) ([eccd505](https://github.com/dsj1984/mandrel/commit/eccd50527f04a25e02d50f57e1c6d760345bc9e8))
+
 ## [2.50.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.49.0...mandrel-v2.50.0) (2026-09-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "2.50.0",
+  "version": "2.52.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, skills, rules, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",