@1agh/maude 0.42.0 → 0.44.0

package/apps/studio/test/photo-filters.test.ts

@@ -0,0 +1,149 @@
+// photo-filters.test.ts — Stage B, Task 4. Unit-tests the PURE pipeline planner
+// (`planPhotoPipeline`) — filter/step COUNT + ORDER + params, never pixel output
+// (pixel realization is browser-only, in pipeline.ts). No pixi import here: the
+// whole point of the planner split is that this suite runs headlessly.
+
+import { describe, expect, test } from 'bun:test';
+
+import type { PhotoPipelineStep } from '../photo/filters.ts';
+import { DUOTONE_FRAG_SOURCE, hexToRgb01, planPhotoPipeline } from '../photo/filters.ts';
+import type { PhotoEdit } from '../photo/schema.ts';
+import { PHOTO_PIPELINE_ORDER } from '../photo/schema.ts';
+
+const stages = (steps: PhotoPipelineStep[]) => steps.map((s) => s.stage);
+
+describe('planPhotoPipeline — neutrality', () => {
+  test('null / empty / all-neutral edits produce no steps', () => {
+    expect(planPhotoPipeline(null)).toEqual([]);
+    expect(planPhotoPipeline(undefined)).toEqual([]);
+    expect(planPhotoPipeline({})).toEqual([]);
+    expect(planPhotoPipeline({ adjustments: { brightness: 0, contrast: 0 } })).toEqual([]);
+    // Disabled sections never emit, regardless of their params.
+    expect(
+      planPhotoPipeline({
+        duotone: { enabled: false, colorA: '#000000', colorB: '#ffffff', intensity: 1 },
+        grain: { enabled: false, amount: 1 },
+        pattern: { enabled: false, opacity: 1 },
+        mask: { preset: 'none', strength: 1 },
+      })
+    ).toEqual([]);
+  });
+});
+
+describe('planPhotoPipeline — ordering', () => {
+  test('a fully-loaded edit emits every stage in PHOTO_PIPELINE_ORDER', () => {
+    const edit: PhotoEdit = {
+      // Deliberately author the object with keys OUT of pipeline order to prove
+      // the planner re-orders rather than echoing insertion order.
+      mask: { preset: 'vignette', strength: 0.5 },
+      pattern: { enabled: true, type: 'grid', scale: 2, opacity: 0.4, blend: 'multiply' },
+      grain: { enabled: true, amount: 0.3, size: 2 },
+      duotone: { enabled: true, colorA: '#1a1a2e', colorB: '#e94560', intensity: 0.8 },
+      adjustments: { contrast: 0.2, brightness: -0.1 },
+    };
+    const steps = planPhotoPipeline(edit);
+    expect(stages(steps)).toEqual([...PHOTO_PIPELINE_ORDER]);
+    // Exactly one step per stage.
+    expect(steps.length).toBe(5);
+  });
+
+  test('partial edits keep relative order and skip absent stages', () => {
+    const steps = planPhotoPipeline({
+      mask: { preset: 'edge-fade', strength: 0.7 },
+      adjustments: { hue: 40 },
+    });
+    expect(stages(steps)).toEqual(['adjustments', 'mask']);
+  });
+});
+
+describe('planPhotoPipeline — adjustments sub-order + params', () => {
+  test('color-matrix ops follow the fixed sub-order and carry normalized values', () => {
+    const steps = planPhotoPipeline({
+      // authored out of order:
+      adjustments: {
+        invert: 1,
+        brightness: 0.5,
+        hue: 90,
+        contrast: -0.3,
+        grayscale: 0.4,
+        saturation: 0.2,
+        sepia: 0.1,
+        exposure: 0.6,
+      },
+    });
+    expect(steps.length).toBe(1);
+    const adj = steps[0];
+    expect(adj.stage).toBe('adjustments');
+    if (adj.stage !== 'adjustments') throw new Error('unreachable');
+    expect(adj.ops.map((o) => o.op)).toEqual([
+      'brightness',
+      'exposure',
+      'contrast',
+      'saturation',
+      'hue',
+      'sepia',
+      'grayscale',
+      'invert',
+    ]);
+    // Values pass through untouched (normalization/mapping is a realizer concern).
+    const byOp = Object.fromEntries(adj.ops.map((o) => [o.op, o.value]));
+    expect(byOp.brightness).toBe(0.5);
+    expect(byOp.hue).toBe(90);
+    expect(byOp.contrast).toBe(-0.3);
+  });
+
+  test('only non-neutral adjustment fields become ops', () => {
+    const steps = planPhotoPipeline({
+      adjustments: { contrast: 0.5, brightness: 0, saturation: 0 },
+    });
+    const adj = steps[0];
+    if (adj.stage !== 'adjustments') throw new Error('expected adjustments');
+    expect(adj.ops.map((o) => o.op)).toEqual(['contrast']);
+  });
+});
+
+describe('planPhotoPipeline — section defaults when enabled-but-unset', () => {
+  test('enabled duotone/grain/pattern fill sensible defaults', () => {
+    const steps = planPhotoPipeline({
+      duotone: { enabled: true },
+      grain: { enabled: true },
+      pattern: { enabled: true },
+    });
+    const duo = steps.find((s) => s.stage === 'duotone');
+    const grain = steps.find((s) => s.stage === 'grain');
+    const pat = steps.find((s) => s.stage === 'pattern');
+    expect(duo).toBeTruthy();
+    expect(grain).toBeTruthy();
+    expect(pat).toBeTruthy();
+    if (duo?.stage === 'duotone') {
+      expect(duo.colorA).toMatch(/^#[0-9a-f]{6}$/);
+      expect(duo.colorB).toMatch(/^#[0-9a-f]{6}$/);
+      expect(duo.intensity).toBeGreaterThan(0);
+    }
+    if (pat?.stage === 'pattern') expect(pat.type).toBe('dots');
+  });
+});
+
+describe('hexToRgb01', () => {
+  test('parses to normalized rgb', () => {
+    expect(hexToRgb01('#000000')).toEqual([0, 0, 0]);
+    expect(hexToRgb01('#ffffff')).toEqual([1, 1, 1]);
+    const [r, g, b] = hexToRgb01('#804020');
+    expect(r).toBeCloseTo(128 / 255, 5);
+    expect(g).toBeCloseTo(64 / 255, 5);
+    expect(b).toBeCloseTo(32 / 255, 5);
+  });
+  test('throws on malformed input', () => {
+    expect(() => hexToRgb01('nope')).toThrow();
+    expect(() => hexToRgb01('#fff')).toThrow();
+  });
+});
+
+describe('duotone shader source', () => {
+  test('is a non-empty GLSL string with the expected uniforms', () => {
+    expect(DUOTONE_FRAG_SOURCE).toContain('uColorA');
+    expect(DUOTONE_FRAG_SOURCE).toContain('uColorB');
+    expect(DUOTONE_FRAG_SOURCE).toContain('uIntensity');
+    expect(DUOTONE_FRAG_SOURCE).toContain('uTexture');
+  });
+});

package/apps/studio/test/photo-pipeline.test.ts

@@ -0,0 +1,106 @@
+// photo-pipeline.test.ts — Stage B, Task 5. Exercises ONLY the pure decision
+// logic in pipeline.ts (`adjustmentCalls`, `resolveSourceUrl`, `needsCompositor`)
+// — no pixi filter is constructed, so this runs headlessly. The actual WebGL
+// render is verified via `maude design screenshot` (Task 6) + desktop dogfood
+// (Task 25). This suite ALSO proves importing pipeline.ts (which statically
+// imports pixi.js) does no construction at load time.
+
+import { describe, expect, test } from 'bun:test';
+
+import type { AdjustmentsStep } from '../photo/filters.ts';
+import { adjustmentCalls, needsCompositor, resolveSourceUrl } from '../photo/pipeline.ts';
+
+const adj = (ops: AdjustmentsStep['ops']): AdjustmentsStep => ({
+  stage: 'adjustments',
+  kind: 'colorMatrix',
+  ops,
+});
+
+describe('adjustmentCalls — normalized → pixi mapping + neutral references', () => {
+  test('brightness delta maps to pixi multiplier (neutral 1)', () => {
+    expect(adjustmentCalls(adj([{ op: 'brightness', value: 0 }]))[0]).toEqual({
+      method: 'brightness',
+      args: [1],
+    });
+    expect(adjustmentCalls(adj([{ op: 'brightness', value: 0.5 }]))[0].args).toEqual([1.5]);
+    expect(adjustmentCalls(adj([{ op: 'brightness', value: -1 }]))[0].args).toEqual([0]);
+  });
+
+  test('exposure maps to a 2^stop brightness', () => {
+    expect(adjustmentCalls(adj([{ op: 'exposure', value: 0 }]))[0]).toEqual({
+      method: 'brightness',
+      args: [1],
+    });
+    expect(adjustmentCalls(adj([{ op: 'exposure', value: 1 }]))[0].args).toEqual([2]);
+  });
+
+  test('contrast maps into pixi 0..1 with 0.5 neutral', () => {
+    expect(adjustmentCalls(adj([{ op: 'contrast', value: 0 }]))[0].args).toEqual([0.5]);
+    expect(adjustmentCalls(adj([{ op: 'contrast', value: 1 }]))[0].args).toEqual([1]);
+    expect(adjustmentCalls(adj([{ op: 'contrast', value: -1 }]))[0].args).toEqual([0]);
+  });
+
+  test('saturation and hue pass through', () => {
+    expect(adjustmentCalls(adj([{ op: 'saturation', value: -0.5 }]))[0]).toEqual({
+      method: 'saturate',
+      args: [-0.5],
+    });
+    expect(adjustmentCalls(adj([{ op: 'hue', value: 120 }]))[0]).toEqual({
+      method: 'hue',
+      args: [120],
+    });
+  });
+
+  test('sepia and invert become isolate-alpha toggles (amount honored)', () => {
+    const sepia = adjustmentCalls(adj([{ op: 'sepia', value: 0.7 }]))[0];
+    expect(sepia.method).toBe('sepia');
+    expect(sepia.args).toEqual([]);
+    expect(sepia.isolateAlpha).toBeCloseTo(0.7, 5);
+    const invert = adjustmentCalls(adj([{ op: 'invert', value: 1 }]))[0];
+    expect(invert.method).toBe('negative');
+    expect(invert.isolateAlpha).toBe(1);
+  });
+
+  test('order is preserved end-to-end', () => {
+    const calls = adjustmentCalls(
+      adj([
+        { op: 'brightness', value: 0.2 },
+        { op: 'contrast', value: 0.1 },
+        { op: 'sepia', value: 0.5 },
+        { op: 'invert', value: 0.3 },
+      ])
+    );
+    expect(calls.map((c) => c.method)).toEqual(['brightness', 'contrast', 'sepia', 'negative']);
+  });
+});
+
+describe('resolveSourceUrl — background-removal cutout replaces original', () => {
+  const SRC = 'assets/aaaa1111.jpg';
+  const MATTE = 'assets/bbbb2222.png';
+  test('unedited → original source', () => {
+    expect(resolveSourceUrl(null, SRC)).toBe(SRC);
+    expect(resolveSourceUrl({}, SRC)).toBe(SRC);
+  });
+  test('bg-removed enabled with a matte → the matte', () => {
+    expect(resolveSourceUrl({ backgroundRemoved: { enabled: true, maskAsset: MATTE } }, SRC)).toBe(
+      MATTE
+    );
+  });
+  test('bg-removed disabled OR no matte → original (non-destructive toggle)', () => {
+    expect(resolveSourceUrl({ backgroundRemoved: { enabled: false, maskAsset: MATTE } }, SRC)).toBe(
+      SRC
+    );
+    expect(resolveSourceUrl({ backgroundRemoved: { enabled: true } }, SRC)).toBe(SRC);
+  });
+});
+
+describe('needsCompositor — lazy-bundle gate', () => {
+  test('mirrors isDefaultEdit inverse', () => {
+    expect(needsCompositor(null)).toBe(false);
+    expect(needsCompositor({})).toBe(false);
+    expect(needsCompositor({ adjustments: { contrast: 0.4 } })).toBe(true);
+    expect(
+      needsCompositor({ backgroundRemoved: { enabled: true, maskAsset: 'assets/cc33.png' } })
+    ).toBe(true);
+  });
+});

package/apps/studio/test/photo-taxonomy.test.ts

@@ -0,0 +1,96 @@
+// photo-taxonomy.test.ts — regression guard for the DDR-115 "three lists must
+// agree" invariant, extended to the new `assets/<sha8>.photo.json` PhotoEdit
+// sidecar (feature-photo-editor, Task 3).
+//
+// The invariant: a VERSIONED path must be classified VERSIONED by ALL THREE
+// lists that encode the taxonomy —
+//   (1) apps/studio/git/service.ts  → `isMaudeRuntimeState` (panel backstop),
+//   (2) cli/lib/gitignore-block.mjs → `buildBlock` (the `maude init` template),
+//   (3) the repo root `.gitignore`  → tested via `git check-ignore` ground truth.
+// `assets/**` (binaries AND `.photo.json` sidecars) is VERSIONED, so none of the
+// three may hide it. This is the automated form of DDR-115 §3's manual claim.
+
+import { describe, expect, test } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+
+import { buildBlock } from '../../../cli/lib/gitignore-block.mjs';
+import { __testing } from '../git/service.ts';
+
+const { isMaudeRuntimeState } = __testing;
+
+// Representative content-addressed paths under `assets/`.
+const PHOTO_SIDECAR_REL = 'assets/ab12cd34.photo.json';
+const PHOTO_SIDECAR_DESIGN = '.design/assets/ab12cd34.photo.json';
+const ASSET_BINARY_DESIGN = '.design/assets/ab12cd34.png';
+const MATTE_ASSET_DESIGN = '.design/assets/ff00aa99.png';
+
+describe('DDR-115 taxonomy — assets/<sha8>.photo.json is VERSIONED', () => {
+  test('isMaudeRuntimeState does NOT classify photo sidecars/assets as runtime', () => {
+    expect(isMaudeRuntimeState(PHOTO_SIDECAR_REL)).toBe(false);
+    expect(isMaudeRuntimeState(PHOTO_SIDECAR_DESIGN)).toBe(false);
+    expect(isMaudeRuntimeState(ASSET_BINARY_DESIGN)).toBe(false);
+    expect(isMaudeRuntimeState(MATTE_ASSET_DESIGN)).toBe(false);
+  });
+
+  // Positive control — proves the classifier's mechanism actually fires, so the
+  // negatives above aren't passing for a trivial reason (e.g. a broken regex).
+  test('isMaudeRuntimeState still classifies real runtime state as IGNORED', () => {
+    expect(isMaudeRuntimeState('.design/_server.json')).toBe(true);
+    expect(isMaudeRuntimeState('.design/_history/foo/bar.png')).toBe(true);
+    expect(isMaudeRuntimeState('.design/_canvas-state/x.view.json')).toBe(true);
+  });
+
+  // `_photo/` (Task 18/20's headless bg-remove proof canvases, mirroring
+  // `_draw/`'s draw-proof canvases) must agree as IGNORED across all three lists.
+  test('_photo/ (headless bg-remove proof canvases) is IGNORED across all three lists', () => {
+    expect(isMaudeRuntimeState('.design/_photo/smoke-tsx.bgremove.tsx')).toBe(true);
+
+    const block = buildBlock('.design');
+    expect(block).toContain('.design/_photo/');
+
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+    if (top.status !== 0) {
+      console.warn('git rev-parse failed; skipping root .gitignore ground-truth check');
+      return;
+    }
+    const root = top.stdout.trim();
+    const r = spawnSync('git', ['check-ignore', '-q', '--', '.design/_photo/x.bgremove.tsx'], {
+      cwd: root,
+    });
+    expect(r.status).toBe(0);
+  });
+
+  test('the gitignore-block template ignores no assets/ path', () => {
+    for (const root of ['.design', 'design', 'mock']) {
+      const block = buildBlock(root);
+      // buildBlock only lists `${root}/_*` runtime prefixes — VERSIONED content
+      // (assets, canvases, meta) is deliberately absent. A future editor adding
+      // an `assets`/`.photo.json` ignore line trips this.
+      expect(block).not.toContain('assets');
+      expect(block).not.toContain('.photo.json');
+    }
+  });
+
+  test('root .gitignore (git check-ignore ground truth) does not ignore photo assets', () => {
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+    if (top.status !== 0) {
+      // Not in a git checkout (unexpected in CI/dev) — skip rather than false-fail.
+      console.warn('git rev-parse failed; skipping root .gitignore ground-truth check');
+      return;
+    }
+    const root = top.stdout.trim();
+
+    const isIgnored = (relPath: string): boolean => {
+      const r = spawnSync('git', ['check-ignore', '-q', '--', relPath], { cwd: root });
+      // exit 0 = ignored, 1 = not ignored, other = error.
+      return r.status === 0;
+    };
+
+    // VERSIONED assets must NOT be ignored by the repo's own .gitignore.
+    expect(isIgnored(PHOTO_SIDECAR_DESIGN)).toBe(false);
+    expect(isIgnored(ASSET_BINARY_DESIGN)).toBe(false);
+
+    // Positive control — a known runtime path IS ignored, proving check-ignore works here.
+    expect(isIgnored('.design/_server.json')).toBe(true);
+  });
+});

package/apps/studio/test/read-annotations.test.ts

@@ -18,9 +18,11 @@ import { fileURLToPath } from 'node:url';
 import {
   type ArrowStroke,
   type EllipseStroke,
+  type ImageStroke,
   type PenStroke,
   type PolygonStroke,
   type RectStroke,
+  type SectionStroke,
   type StickyStroke,
   type Stroke,
   strokesToSvg,
@@ -50,6 +52,18 @@ interface Annotation {
     text: string;
   } | null;
   target?: { source: string; selector: { type: string; value: string }; geometry: unknown };
+  href?: string;
+  authorName?: string;
+  members?: Array<{
+    id: string;
+    tool: string;
+    order: number;
+    x: number | null;
+    y: number | null;
+    w: number | null;
+    h: number | null;
+    href?: string;
+  }>;
 }
 
 // Mirror api.ts fileSlug for the common (design-root-relative .tsx) case so the
@@ -171,6 +185,20 @@ describe('read-annotations / sticky', () => {
     const { annotations } = read(REL, strokesToSvg([multi]));
     expect(annotations[0]?.text).toBe('line one\nline two');
   });
+
+  test('authorName containing `>` round-trips intact and does not corrupt sibling geometry (DDR-155/escAttr regression)', () => {
+    const authored: StickyStroke = { ...sticky, authorName: 'Bob> data-x="evil' };
+    const { annotations } = read(REL, strokesToSvg([authored]));
+    const [a] = annotations;
+    expect(a?.authorName).toBe('Bob> data-x="evil');
+    // The injected `>`/`"` must not have shifted the element scan and eaten
+    // the sibling geometry/text attributes.
+    expect(a?.x).toBe(40);
+    expect(a?.y).toBe(50);
+    expect(a?.w).toBe(200);
+    expect(a?.h).toBe(160);
+    expect(a?.text).toBe('Step 1: email + password');
+  });
 });
 
 describe('read-annotations / position-only strokes carry text:null + a bbox', () => {
@@ -561,3 +589,139 @@ describe('read-annotations / --rects element-level context', () => {
     expect(a && 'element' in a).toBe(false);
   });
 });
+
+describe('read-annotations / section membership + reading order', () => {
+  test('members are ordered spatially (top-to-bottom, left-to-right), not by z/paint order', () => {
+    // Drawn out of visual order: B (top-right) first, A (top-left) second,
+    // C (bottom-left) third — so z = [B, A, C] but reading order must be
+    // [A, B, C].
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 400,
+      label: 'Board',
+      color: '#8884',
+    };
+    const stickyB: StickyStroke = {
+      id: 'stickyB',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 200,
+      y: 20,
+      w: 120,
+      h: 120,
+      text: 'B',
+      fontSize: 14,
+    };
+    const stickyA: StickyStroke = {
+      id: 'stickyA',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 20,
+      y: 20,
+      w: 120,
+      h: 120,
+      text: 'A',
+      fontSize: 14,
+    };
+    const stickyC: StickyStroke = {
+      id: 'stickyC',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 20,
+      y: 220,
+      w: 120,
+      h: 120,
+      text: 'C',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([section, stickyB, stickyA, stickyC]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members?.map((m) => m.id)).toEqual(['stickyA', 'stickyB', 'stickyC']);
+    expect(sec?.members?.map((m) => m.order)).toEqual([0, 1, 2]);
+  });
+
+  test('image members carry their resolvable asset href', () => {
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 400,
+      label: 'Board',
+      color: '#8884',
+    };
+    const img: ImageStroke = {
+      id: 'img1',
+      tool: 'image',
+      x: 20,
+      y: 20,
+      w: 120,
+      h: 120,
+      href: 'assets/deadbeef.png',
+    };
+    const { annotations } = read(REL, strokesToSvg([section, img]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members).toEqual([
+      {
+        id: 'img1',
+        tool: 'image',
+        order: 0,
+        x: 20,
+        y: 20,
+        w: 120,
+        h: 120,
+        href: 'assets/deadbeef.png',
+      },
+    ]);
+  });
+
+  test('a stroke outside the section rect is not a member; a section with nothing inside gets an empty array', () => {
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 100,
+      h: 100,
+      label: 'Board',
+      color: '#8884',
+    };
+    const outside: StickyStroke = {
+      id: 'outside',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 500,
+      y: 500,
+      w: 60,
+      h: 60,
+      text: 'far away',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([section, outside]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members).toEqual([]);
+    const other = annotations.find((a) => a.id === 'outside');
+    expect(other?.members).toBeUndefined();
+  });
+
+  test('a non-section stroke never gets a members field', () => {
+    const sticky: StickyStroke = {
+      id: 'lone',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 0,
+      y: 0,
+      w: 60,
+      h: 60,
+      text: 'no section here',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([sticky]));
+    expect(annotations[0] && 'members' in annotations[0]).toBe(false);
+  });
+});

package/apps/studio/test/readiness.test.ts

@@ -107,33 +107,35 @@ describe('readiness — plugin registry scan (web / manual path)', () => {
   });
 });
 
-// DDR-143 — on the native/desktop path the ACP session auto-loads the bundled
-// plugins, so the row is satisfied even against a pristine registry. This suite
-// runs in the dev tree, so the bundled plugin dirs resolve → native context is
-// on by default (no opt-out).
-describe('readiness — plugin auto-bootstrap (native, DDR-143)', () => {
-  test('pristine registry → present + "Auto-loaded" detail, no manual remediation', async () => {
+// DDR-143 / DDR-168 — on the native/desktop path the ACP session ALWAYS loads
+// the bundled plugins, so the row is satisfied even against a pristine
+// registry, AND even when a marketplace copy is also installed at the user
+// level (DDR-168 removed the old scan-gated no-op — the bundled copy wins
+// regardless of disk state). This suite runs in the dev tree, so the bundled
+// plugin dirs resolve → native context is on by default (no opt-out).
+describe('readiness — plugin auto-bootstrap (native, DDR-143/DDR-168)', () => {
+  test('pristine registry → present + "Bundled with this app" detail, no manual remediation', async () => {
     const item = await pluginsItem(fixtureClaudeDir({}));
     expect(item.status).toBe('present');
-    expect(item.detail).toContain('Auto-loaded');
+    expect(item.detail).toContain('Bundled with this app');
     expect(item.remediation).toBeUndefined();
   });
 
-  test('design NOT installed (flow-only registry) → still present (design is auto-loaded, no red wall)', async () => {
+  test('design NOT installed (flow-only registry) → still present (design is bundled, no red wall)', async () => {
     const item = await pluginsItem(
       fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_FLOW_ONLY })
     );
     expect(item.status).toBe('present');
-    expect(item.detail).toContain('Auto-loaded');
+    expect(item.detail).toContain('Bundled with this app');
     expect(item.remediation).toBeUndefined();
   });
 
-  test('design already installed → present, keeps the "is installed" detail (no auto-load framing)', async () => {
+  test('design ALSO installed on disk → present, STILL reads as bundled (DDR-168 — no more "is installed" framing)', async () => {
     const item = await pluginsItem(
       fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_DESIGN_ONLY })
     );
     expect(item.status).toBe('present');
-    expect(item.detail).toContain('installed');
+    expect(item.detail).toContain('Bundled with this app');
   });
 });