@1agh/maude 0.45.2 → 0.46.0

package/apps/studio/print/marks.ts

@@ -0,0 +1,113 @@
+// feature-2-print-artboards T1/T5 — pure crop/registration-mark geometry.
+//
+// Consumed by the pdf-lib post-pass (T5) to draw vector marks, and reusable
+// by a future on-canvas marks preview (T3 left that optional — see the plan).
+// Coordinates are PDF POINTS in the BLEED-BOX-origin space: x ∈ [0, pageWidthPt],
+// y ∈ [0, pageHeightPt] is the rendered page itself (Chromium's page.pdf()
+// output, unchanged); marks live OUTSIDE that box, at negative coordinates or
+// beyond pageWidthPt/pageHeightPt. The pdf-lib post-pass enlarges MediaBox
+// with a negative origin to make room for them without moving page content.
+
+import { MARK_LENGTH_MM, MARK_STROKE_MM, mmToPt } from './units.ts';
+
+export interface LineSegment {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+
+export interface Circle {
+  cx: number;
+  cy: number;
+  r: number;
+}
+
+export interface RegistrationMark {
+  circle: Circle;
+  crosshair: LineSegment[];
+}
+
+export interface MarksGeometry {
+  cropMarks: LineSegment[];
+  registrationMarks: RegistrationMark[];
+}
+
+const REG_RADIUS_MM = 1.5;
+const REG_GAP_MM = 1;
+
+/**
+ * The extra margin MediaBox must extend beyond the bleed box on every side to
+ * fit the requested marks without clipping. Callers ask for this BEFORE
+ * calling computeMarksGeometry, to size the enlarged MediaBox first.
+ */
+export function requiredSlugPt(args: { crop?: boolean; registration?: boolean }): number {
+  const markLen = mmToPt(MARK_LENGTH_MM);
+  let slug = 0;
+  if (args.crop) slug = Math.max(slug, markLen);
+  if (args.registration) {
+    slug = Math.max(slug, markLen + mmToPt(REG_GAP_MM) + 2 * mmToPt(REG_RADIUS_MM));
+  }
+  return slug;
+}
+
+/**
+ * Compute crop-mark (8 segments, 2 per corner) and registration-mark (4,
+ * side-midpoints) geometry for a page of the given size + bleed. Crop marks
+ * are aligned to the TRIM line but drawn starting exactly at the bleed-box
+ * edge (T1's "offset = bleed"), extending outward by `MARK_LENGTH_MM`.
+ * Registration marks sit just beyond the crop marks' reach.
+ */
+export function computeMarksGeometry(args: {
+  pageWidthPt: number;
+  pageHeightPt: number;
+  bleedPt: number;
+  crop?: boolean;
+  registration?: boolean;
+}): MarksGeometry {
+  const { pageWidthPt, pageHeightPt, bleedPt } = args;
+  const markLen = mmToPt(MARK_LENGTH_MM);
+  const trimX0 = bleedPt;
+  const trimY0 = bleedPt;
+  const trimX1 = pageWidthPt - bleedPt;
+  const trimY1 = pageHeightPt - bleedPt;
+
+  const cropMarks: LineSegment[] = [];
+  if (args.crop) {
+    // Bottom-left
+    cropMarks.push({ x1: trimX0, y1: 0, x2: trimX0, y2: -markLen });
+    cropMarks.push({ x1: 0, y1: trimY0, x2: -markLen, y2: trimY0 });
+    // Bottom-right
+    cropMarks.push({ x1: trimX1, y1: 0, x2: trimX1, y2: -markLen });
+    cropMarks.push({ x1: pageWidthPt, y1: trimY0, x2: pageWidthPt + markLen, y2: trimY0 });
+    // Top-left
+    cropMarks.push({ x1: trimX0, y1: pageHeightPt, x2: trimX0, y2: pageHeightPt + markLen });
+    cropMarks.push({ x1: 0, y1: trimY1, x2: -markLen, y2: trimY1 });
+    // Top-right
+    cropMarks.push({ x1: trimX1, y1: pageHeightPt, x2: trimX1, y2: pageHeightPt + markLen });
+    cropMarks.push({ x1: pageWidthPt, y1: trimY1, x2: pageWidthPt + markLen, y2: trimY1 });
+  }
+
+  const registrationMarks: RegistrationMark[] = [];
+  if (args.registration) {
+    const regR = mmToPt(REG_RADIUS_MM);
+    const offset = markLen + mmToPt(REG_GAP_MM) + regR;
+    const mk = (cx: number, cy: number): RegistrationMark => ({
+      circle: { cx, cy, r: regR },
+      crosshair: [
+        { x1: cx - regR, y1: cy, x2: cx + regR, y2: cy },
+        { x1: cx, y1: cy - regR, x2: cx, y2: cy + regR },
+      ],
+    });
+    registrationMarks.push(
+      mk(pageWidthPt / 2, pageHeightPt + offset), // top-center
+      mk(pageWidthPt / 2, -offset), // bottom-center
+      mk(-offset, pageHeightPt / 2), // left-center
+      mk(pageWidthPt + offset, pageHeightPt / 2) // right-center
+    );
+  }
+
+  return { cropMarks, registrationMarks };
+}
+
+export const MARK_STROKE_PT = mmToPt(MARK_STROKE_MM);

package/apps/studio/print/units.ts

@@ -0,0 +1,269 @@
+// feature-2-print-artboards T1 — the single source for print unit conversion
+// + paper presets.
+//
+// Authoring stays at CSS px @96dpi (DDR-027 — mm never enters JSX geometry).
+// This module is the ONLY place mm/in ↔ px conversion happens: the on-canvas
+// overlay (T3), the Inspector print knobs (T2), and both exporters (T4/T5)
+// all import from here. Two mm→px sites would let the on-canvas bleed
+// silently desync from the exported PDF — see the plan's T1 gotcha.
+
+export const CSS_DPI = 96;
+export const MM_PER_INCH = 25.4;
+export const PT_PER_INCH = 72;
+
+export function mmToPx(mm: number, dpi: number = CSS_DPI): number {
+  return (mm * dpi) / MM_PER_INCH;
+}
+
+export function inToPx(inches: number, dpi: number = CSS_DPI): number {
+  return inches * dpi;
+}
+
+export function pxToMm(px: number, dpi: number = CSS_DPI): number {
+  return (px * MM_PER_INCH) / dpi;
+}
+
+export function pxToIn(px: number, dpi: number = CSS_DPI): number {
+  return px / dpi;
+}
+
+/** px → pt (1pt = 1/72in) — the unit pdf-lib's PDFPage boxes expect. */
+export function pxToPt(px: number, dpi: number = CSS_DPI): number {
+  return (px / dpi) * PT_PER_INCH;
+}
+
+export function mmToPt(mm: number): number {
+  return (mm / MM_PER_INCH) * PT_PER_INCH;
+}
+
+export type PaperUnit = 'mm' | 'in';
+export type PaperCategory = 'iso' | 'us' | 'envelope' | 'card' | 'poster';
+
+export interface PaperPreset {
+  id: string;
+  label: string;
+  category: PaperCategory;
+  unit: PaperUnit;
+  /** Portrait width × height, in `unit`. */
+  width: number;
+  height: number;
+}
+
+export const PAPER_PRESETS: readonly PaperPreset[] = [
+  // ISO A series (mm)
+  { id: 'a6', label: 'A6', category: 'iso', unit: 'mm', width: 105, height: 148 },
+  { id: 'a5', label: 'A5', category: 'iso', unit: 'mm', width: 148, height: 210 },
+  { id: 'a4', label: 'A4', category: 'iso', unit: 'mm', width: 210, height: 297 },
+  { id: 'a3', label: 'A3', category: 'iso', unit: 'mm', width: 297, height: 420 },
+  { id: 'a2', label: 'A2', category: 'iso', unit: 'mm', width: 420, height: 594 },
+  { id: 'a1', label: 'A1', category: 'iso', unit: 'mm', width: 594, height: 841 },
+  { id: 'a0', label: 'A0', category: 'iso', unit: 'mm', width: 841, height: 1189 },
+  // US (in)
+  { id: 'letter', label: 'Letter', category: 'us', unit: 'in', width: 8.5, height: 11 },
+  { id: 'legal', label: 'Legal', category: 'us', unit: 'in', width: 8.5, height: 14 },
+  { id: 'tabloid', label: 'Tabloid', category: 'us', unit: 'in', width: 11, height: 17 },
+  // Envelopes
+  { id: 'dl', label: 'DL envelope', category: 'envelope', unit: 'mm', width: 110, height: 220 },
+  { id: 'c5', label: 'C5 envelope', category: 'envelope', unit: 'mm', width: 162, height: 229 },
+  // Business cards
+  {
+    id: 'card-eu',
+    label: 'Business card (EU)',
+    category: 'card',
+    unit: 'mm',
+    width: 85,
+    height: 55,
+  },
+  {
+    id: 'card-us',
+    label: 'Business card (US)',
+    category: 'card',
+    unit: 'in',
+    width: 3.5,
+    height: 2,
+  },
+  // Posters
+  {
+    id: 'poster-18x24',
+    label: 'Poster 18×24"',
+    category: 'poster',
+    unit: 'in',
+    width: 18,
+    height: 24,
+  },
+  {
+    id: 'poster-24x36',
+    label: 'Poster 24×36"',
+    category: 'poster',
+    unit: 'in',
+    width: 24,
+    height: 36,
+  },
+];
+
+export function getPaperPreset(id: string): PaperPreset | undefined {
+  return PAPER_PRESETS.find((p) => p.id === id);
+}
+
+export type Orientation = 'portrait' | 'landscape';
+
+/** Trim size in mm, orientation-applied (swap width/height for landscape). */
+export function trimSizeMm(
+  preset: PaperPreset,
+  orientation: Orientation
+): { widthMm: number; heightMm: number } {
+  const wMm = preset.unit === 'mm' ? preset.width : preset.width * MM_PER_INCH;
+  const hMm = preset.unit === 'mm' ? preset.height : preset.height * MM_PER_INCH;
+  return orientation === 'landscape'
+    ? { widthMm: hMm, heightMm: wMm }
+    : { widthMm: wMm, heightMm: hMm };
+}
+
+/** Default bleed (mm) by preset's unit family — 3mm EU (mm-unit presets), 0.125in (in-unit presets). */
+export function defaultBleedMm(preset: PaperPreset): number {
+  return preset.unit === 'mm' ? 3 : 0.125 * MM_PER_INCH;
+}
+
+export const DEFAULT_SAFE_MARGIN_MM = 5;
+
+/** Generous but finite bound on bleed/margin mm values — guards a
+ *  malicious/broken value (a hand-edited or hub-synced `print` prop is
+ *  DDR-054 untrusted canvas content) from producing a negative trim box
+ *  (rect.w - 2×bleedPx) or a degenerate PDF geometry. Enforced at WRITE
+ *  time by `setArtboardPrintOp` (api.ts) AND at READ time by
+ *  `resolveBleedMm`/`resolveMarginsMm` below — a `print` prop can also
+ *  reach the exporter via disk/hub-sync without ever passing through the
+ *  write-time validator, so the read side needs its own clamp. */
+export const MAX_PRINT_MM = 200;
+
+function clampMm(v: number): number {
+  if (!Number.isFinite(v)) return 0;
+  return Math.min(Math.max(v, 0), MAX_PRINT_MM);
+}
+
+/** Crop/registration mark geometry — length ~3.5mm, stroke offset from trim = bleed. */
+export const MARK_LENGTH_MM = 3.5;
+export const MARK_STROKE_MM = 0.25;
+
+export interface PrintMargins {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+
+/**
+ * The `print` JSX prop on `DCArtboard` (T2) — authoring-time intent, kept
+ * alongside the resolved px `width`/`height` DDR-027 already requires (this
+ * prop does NOT re-derive geometry at render time; the paper picker writes
+ * both this prop and the resolved px size together, see resolvePrintArtboard).
+ * Consumed by the Inspector's print picker (T2), the on-canvas overlay (T3),
+ * and both exporters (T4/T5) — all via THIS module, never a local copy.
+ */
+export interface ArtboardPrintProp {
+  /** Paper preset id — one of PAPER_PRESETS. */
+  paper: string;
+  orientation?: Orientation;
+  /** Bleed extension, mm. Omitted ⇒ defaultBleedMm(preset). */
+  bleedMm?: number;
+  marginsMm?: Partial<PrintMargins>;
+}
+
+export interface ResolvedPrintArtboard {
+  paper: string;
+  orientation: Orientation;
+  /** Trim (final cut) size, in mm. */
+  trimWidthMm: number;
+  trimHeightMm: number;
+  /** Bleed extension, in mm (uniform on all 4 sides). */
+  bleedMm: number;
+  /** Artboard px size = trim + 2×bleed — the artboard IS the bleed box (Design Decision 1). */
+  widthPx: number;
+  heightPx: number;
+  /** Trim box, in px, inset from the artboard edges by bleedPx on every side. */
+  trimWidthPx: number;
+  trimHeightPx: number;
+  bleedPx: number;
+  marginsMm: PrintMargins;
+}
+
+/**
+ * Resolve a possibly-partial `marginsMm` override against the 5mm default —
+ * the SAME resolution `resolvePrintArtboard` applies, factored out so the
+ * on-canvas overlay (T3) and the PDF post-pass (T5) apply identical defaults
+ * without re-deriving them from a full `resolvePrintArtboard` call (which
+ * needs a paper size neither of those call sites actually has to hand — both
+ * work from the artboard's own already-resolved px rect instead, per
+ * DDR-027).
+ */
+export function resolveMarginsMm(marginsMm?: Partial<PrintMargins>): PrintMargins {
+  const m = marginsMm ?? {};
+  return {
+    top: typeof m.top === 'number' ? clampMm(m.top) : DEFAULT_SAFE_MARGIN_MM,
+    right: typeof m.right === 'number' ? clampMm(m.right) : DEFAULT_SAFE_MARGIN_MM,
+    bottom: typeof m.bottom === 'number' ? clampMm(m.bottom) : DEFAULT_SAFE_MARGIN_MM,
+    left: typeof m.left === 'number' ? clampMm(m.left) : DEFAULT_SAFE_MARGIN_MM,
+  };
+}
+
+/**
+ * Resolve an `ArtboardPrintProp`'s bleed to a concrete mm value — explicit
+ * `bleedMm` wins, else the paper preset's unit-family default (3mm EU /
+ * 0.125in US). Unknown paper id with no explicit bleedMm falls back to 3mm
+ * rather than throwing — the overlay/exporter must never hard-fail a render
+ * over a bad paper id (resolvePrintArtboard is the strict, throwing entry
+ * point used at WRITE time; this one is the lenient, read-time counterpart).
+ */
+export function resolveBleedMm(print: { paper: string; bleedMm?: number }): number {
+  if (typeof print.bleedMm === 'number') return clampMm(print.bleedMm);
+  const preset = getPaperPreset(print.paper);
+  return preset ? defaultBleedMm(preset) : 3;
+}
+
+/** mm → whole px, rounded — the ONE rounding rule bleed/trim/margin geometry
+ *  uses everywhere (overlay, exporter, resolvePrintArtboard). */
+export function resolveMmPx(mm: number, dpi: number = CSS_DPI): number {
+  return Math.round(mmToPx(mm, dpi));
+}
+
+/**
+ * Resolve a `print` prop's paper/orientation/bleed into concrete px geometry.
+ * The artboard IS the bleed box: bleed lives INSIDE the artboard bounds so
+ * background content can reach the cut edge under today's clip-at-artboard
+ * -bounds rendering model (the alternative — artboard=trim, bleed outside —
+ * can't render bleeding content at all).
+ *
+ * px values are rounded to the nearest integer (CSS `width`/`height` must be
+ * whole px); overlay + exporter both re-derive px from the same mm fields
+ * on this result rather than re-rounding independently, so trim/bleed/margin
+ * geometry stays pixel-identical between what's drawn and what's exported.
+ */
+export function resolvePrintArtboard(args: {
+  paper: string;
+  orientation?: Orientation;
+  bleedMm?: number;
+  marginsMm?: Partial<PrintMargins>;
+}): ResolvedPrintArtboard {
+  const preset = getPaperPreset(args.paper);
+  if (!preset) throw new Error(`unknown paper preset: ${args.paper}`);
+  const orientation = args.orientation ?? 'portrait';
+  const { widthMm: trimWidthMm, heightMm: trimHeightMm } = trimSizeMm(preset, orientation);
+  const bleedMm = args.bleedMm ?? defaultBleedMm(preset);
+  const marginsMm = resolveMarginsMm(args.marginsMm);
+  const bleedPx = resolveMmPx(bleedMm);
+  const trimWidthPx = resolveMmPx(trimWidthMm);
+  const trimHeightPx = resolveMmPx(trimHeightMm);
+  return {
+    paper: preset.id,
+    orientation,
+    trimWidthMm,
+    trimHeightMm,
+    bleedMm,
+    widthPx: trimWidthPx + 2 * bleedPx,
+    heightPx: trimHeightPx + 2 * bleedPx,
+    trimWidthPx,
+    trimHeightPx,
+    bleedPx,
+    marginsMm,
+  };
+}

package/apps/studio/print-overlay-content.tsx

@@ -0,0 +1,132 @@
+/**
+ * @file       print-overlay-content.tsx — feature-2-print-artboards T3.
+ * @scope      apps/studio/print-overlay-content.tsx
+ * @purpose    Registers the 'print' kind's on-canvas guide chrome into the
+ *             foundation's kindOverlayRegistry (artboard-guides-overlay.tsx):
+ *             bleed zone (red tint), trim line (solid), safe-margin line
+ *             (magenta dashed) — the Adobe-convention colors Design
+ *             Decision 3 specifies. Decorative — aria-hidden, pointer-events
+ *             none, flat divs/borders only (no filters/blends — WKWebView
+ *             doesn't GPU-accelerate those; same constraint the foundation
+ *             overlay itself documents).
+ *
+ *             Geometry reads print/units.ts ONLY (never a local mm→px copy —
+ *             the T1 single-source invariant: bleedPx here must match the
+ *             PDF post-pass's bleedPx (T5) exactly, or the on-canvas guide
+ *             and the exported TrimBox visibly disagree).
+ */
+
+import { type KindOverlayRenderFn, registerKindOverlay } from './artboard-guides-overlay.tsx';
+import { resolveBleedMm, resolveMarginsMm, resolveMmPx } from './print/units.ts';
+
+// Adobe print-tool convention (Design Decision 3): bleed = red, trim = solid
+// dark line, margins/safe-area = magenta dashed. Chrome-engine constants, not
+// DS tokens — guides are never part of exported artboard content, same
+// reasoning as the foundation's own COLUMN_FILL/GRID_LINE constants.
+const BLEED_TINT = 'color-mix(in oklab, oklch(55% 0.22 25) 14%, transparent)';
+const TRIM_LINE = 'oklch(25% 0 0)';
+const MARGIN_LINE = 'oklch(58% 0.24 340)';
+
+const PrintOverlayContent: KindOverlayRenderFn = ({ rect, print, visibility }) => {
+  if (visibility.print !== true || !print) return null;
+
+  const bleedMm = resolveBleedMm(print);
+  const bleedPx = resolveMmPx(bleedMm);
+  const margins = resolveMarginsMm(print.marginsMm);
+  const marginPx = {
+    top: resolveMmPx(margins.top),
+    right: resolveMmPx(margins.right),
+    bottom: resolveMmPx(margins.bottom),
+    left: resolveMmPx(margins.left),
+  };
+
+  // Trim box — inset from the artboard (= bleed box, Design Decision 1) by
+  // bleedPx on every side.
+  const trimW = Math.max(0, rect.w - 2 * bleedPx);
+  const trimH = Math.max(0, rect.h - 2 * bleedPx);
+  // Safe/margin box — inset further from the trim box by marginPx per side.
+  const marginW = Math.max(0, trimW - marginPx.left - marginPx.right);
+  const marginH = Math.max(0, trimH - marginPx.top - marginPx.bottom);
+
+  return (
+    <>
+      {bleedPx > 0 ? (
+        <>
+          {/* Bleed zone — the annulus between the artboard edge and the trim
+              line, drawn as 4 tinted strips (never a single translucent box
+              over the whole artboard, which would also tint the live content
+              inside the trim box). */}
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              top: 0,
+              width: rect.w,
+              height: bleedPx,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              bottom: 0,
+              width: rect.w,
+              height: bleedPx,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              top: bleedPx,
+              width: bleedPx,
+              height: trimH,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              right: 0,
+              top: bleedPx,
+              width: bleedPx,
+              height: trimH,
+              background: BLEED_TINT,
+            }}
+          />
+        </>
+      ) : null}
+      {/* Trim line — the final cut edge, solid. */}
+      <div
+        style={{
+          position: 'absolute',
+          left: bleedPx,
+          top: bleedPx,
+          width: trimW,
+          height: trimH,
+          border: `1px solid ${TRIM_LINE}`,
+          boxSizing: 'border-box',
+        }}
+      />
+      {/* Safe-area / margin line — inset from trim, dashed. */}
+      {marginW > 0 && marginH > 0 ? (
+        <div
+          style={{
+            position: 'absolute',
+            left: bleedPx + marginPx.left,
+            top: bleedPx + marginPx.top,
+            width: marginW,
+            height: marginH,
+            border: `1px dashed ${MARGIN_LINE}`,
+            boxSizing: 'border-box',
+          }}
+        />
+      ) : null}
+    </>
+  );
+};
+PrintOverlayContent.displayName = 'PrintOverlayContent';
+
+registerKindOverlay('print', PrintOverlayContent);

package/apps/studio/test/acp-mode-banner.test.ts

@@ -0,0 +1,45 @@
+// DDR-184 #3 — the predicate behind ChatPanel's loud "you can't edit" ModeBanner.
+// Pure unit test (the banner itself is a thin render of this). Keyed off the mode
+// ID, never a label, so it stays truthful as the adapter's roster evolves.
+
+import { describe, expect, test } from 'bun:test';
+
+import { modeBlocksEdits, NO_EDIT_MODE_IDS } from '../client/panels/acp-capabilities.js';
+
+const rosterWith = (currentModeId: string) => ({
+  currentModeId,
+  availableModes: [
+    { id: 'default', name: 'Manual' },
+    { id: 'acceptEdits', name: 'Accept Edits' },
+    { id: 'plan', name: 'Plan Mode' },
+    { id: 'dontAsk', name: "Don't Ask" },
+    { id: 'bypassPermissions', name: 'Bypass Permissions' },
+  ],
+});
+
+describe('modeBlocksEdits', () => {
+  test('blocks in Plan Mode (no tool execution)', () => {
+    expect(modeBlocksEdits(rosterWith('plan'))).toBe(true);
+  });
+
+  test("blocks in Don't-Ask (denies anything without a standing approval)", () => {
+    expect(modeBlocksEdits(rosterWith('dontAsk'))).toBe(true);
+  });
+
+  test('does NOT block in the editing modes (Manual / Accept-Edits / Bypass)', () => {
+    expect(modeBlocksEdits(rosterWith('default'))).toBe(false);
+    expect(modeBlocksEdits(rosterWith('acceptEdits'))).toBe(false);
+    expect(modeBlocksEdits(rosterWith('bypassPermissions'))).toBe(false);
+  });
+
+  test('false when the roster is empty / not yet loaded (no premature alarm)', () => {
+    expect(modeBlocksEdits(null)).toBe(false);
+    expect(modeBlocksEdits(undefined)).toBe(false);
+    expect(modeBlocksEdits({ availableModes: [] })).toBe(false);
+    expect(modeBlocksEdits({ currentModeId: '' })).toBe(false);
+  });
+
+  test('NO_EDIT_MODE_IDS is exactly {plan, dontAsk}', () => {
+    expect([...NO_EDIT_MODE_IDS].sort()).toEqual(['dontAsk', 'plan']);
+  });
+});

package/apps/studio/test/acp-session-allowed-tools.test.ts

@@ -0,0 +1,91 @@
+// DDR-184 — the curated tool allow-list the bridge auto-approves so the design
+// workflow never stalls on a per-edit / per-`maude` permission prompt (the
+// "Manual mode blocks every edit" complaint). Two things under test:
+//
+//   (1) WIRE contract — the list lands on `_meta.claudeCode.options.allowedTools`
+//       (SDK `allowedTools`, sdk.d.ts:1331), coexisting with the DDR-144
+//       `settingSources` narrowing and the DDR-143 `plugins` carrier. Same
+//       adapter/SDK-INTERNAL `_meta` path as acp-session-plugins.test.ts — a
+//       bump that stops forwarding it must fail HERE, not silently re-prompt.
+//   (2) SOURCE-OF-TRUTH guard — the single `Bash(maude:*)` rule only covers the
+//       whole design-helper surface because DDR-062 routes every helper through
+//       `maude design <verb>`. If that stops being true, or someone widens the
+//       Bash scope, this test fails loudly.
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { MAUDE_DEFAULT_ALLOWED_TOOLS, newSessionParams } from '../acp/bridge.ts';
+import type { SdkPluginConfig } from '../acp/plugin-bootstrap.ts';
+
+type Meta = {
+  systemPrompt?: { append?: string };
+  claudeCode?: {
+    options?: {
+      allowedTools?: string[];
+      plugins?: SdkPluginConfig[];
+      settingSources?: string[];
+    };
+  };
+};
+
+const PLUGINS: SdkPluginConfig[] = [
+  { type: 'local', path: '/bundle/plugins/design', skipMcpDiscovery: true },
+];
+
+describe('newSessionParams — allowedTools carrier shape (DDR-184)', () => {
+  test('the allow-list rides _meta.claudeCode.options.allowedTools', () => {
+    const opts = (newSessionParams('/repo', undefined)._meta as Meta).claudeCode?.options;
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+
+  test('allowedTools is a COPY, not the shared module constant (no accidental mutation)', () => {
+    const opts = (newSessionParams('/repo')._meta as Meta).claudeCode?.options;
+    expect(opts?.allowedTools).not.toBe(MAUDE_DEFAULT_ALLOWED_TOOLS);
+  });
+
+  test('coexists with settingSources (DDR-144) and plugins (DDR-143) under one options', () => {
+    const opts = (newSessionParams('/repo', 'BRIEF', PLUGINS)._meta as Meta).claudeCode?.options;
+    expect(opts?.settingSources).toEqual(['user']);
+    expect(opts?.plugins).toEqual(PLUGINS);
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+
+  test('present even with no plugins (npm / web / power-user path)', () => {
+    const opts = (newSessionParams('/repo', 'BRIEF', [])._meta as Meta).claudeCode?.options;
+    expect(opts?.plugins).toBeUndefined();
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+});
+
+describe('MAUDE_DEFAULT_ALLOWED_TOOLS — source-of-truth guard (DDR-184 / DDR-062)', () => {
+  const bashRules = MAUDE_DEFAULT_ALLOWED_TOOLS.filter((t) => t.startsWith('Bash'));
+
+  test('the canvas-editing file tools are all present', () => {
+    for (const t of ['Read', 'Edit', 'Write', 'Glob', 'Grep', 'NotebookEdit']) {
+      expect(MAUDE_DEFAULT_ALLOWED_TOOLS).toContain(t);
+    }
+  });
+
+  test('the ONLY Bash rule is prefix-scoped to `maude` — never a bare/un-scoped Bash', () => {
+    // A bare `Bash` (or `Bash(*)`) would auto-approve arbitrary command execution
+    // — exactly the blanket surface DDR-179 kept behind the prompt. Guard against
+    // anyone widening it: the list may auto-approve `maude` and nothing else.
+    expect(bashRules).toEqual(['Bash(maude:*)']);
+  });
+
+  test('the single Bash rule is load-bearing on DDR-062: every design helper is a `maude design <verb>`', () => {
+    // Resolve cli/commands/design.mjs relative to this test file's real path
+    // (mirrors acp-session-plugins.test.ts's realpath dance for compiled roots).
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const designCli = join(here, '..', '..', '..', 'cli', 'commands', 'design.mjs');
+    expect(existsSync(designCli)).toBe(true);
+    const src = readFileSync(designCli, 'utf8');
+    // The dispatch table the `Bash(maude:*)` scope rests on — helpers reached via
+    // `maude design <verb>`, not raw `bash <path>.sh` (DDR-062). If this marker
+    // disappears, the one-rule assumption needs re-checking.
+    expect(src).toContain('BIN_VERBS');
+    expect(src).toMatch(/maude design <verb>/);
+  });
+});