@1agh/maude 0.37.0 → 0.38.0

package/apps/studio/test/ensure-browser.test.ts

@@ -0,0 +1,92 @@
+// Screenshot-browser resolver (bundled-screenshots feature). Covers the pure
+// resolution priority; the actual download (priority 5) is exercised only when no
+// browser exists on the host — untestable in CI where system Chrome / a Playwright
+// headless-shell are usually present, so we assert `download:false` never fetches.
+
+import { describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { CFT_VERSION_RE, isTrustedDownloadUrl, resolveBrowser } from '../bin/_ensure-browser.mjs';
+
+function withEnv<T>(patch: Record<string, string | undefined>, fn: () => T): T {
+  const saved: Record<string, string | undefined> = {};
+  for (const k of Object.keys(patch)) {
+    saved[k] = process.env[k];
+    if (patch[k] === undefined) delete process.env[k];
+    else process.env[k] = patch[k];
+  }
+  try {
+    return fn();
+  } finally {
+    for (const k of Object.keys(patch)) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  }
+}
+
+describe('resolveBrowser — resolution priority', () => {
+  test('AGENT_BROWSER_EXECUTABLE_PATH override wins', async () => {
+    const r = await withEnv({ AGENT_BROWSER_EXECUTABLE_PATH: import.meta.path }, () =>
+      resolveBrowser({ download: false })
+    );
+    expect(r.source).toBe('override');
+    expect(r.path).toBe(import.meta.path);
+  });
+
+  test('a cached chrome-headless-shell in MAUDE_BROWSERS_DIR resolves before system Chrome', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'maude-browsers-'));
+    const sub = join(dir, 'chrome-headless-shell-1.2.3-mac-arm64');
+    mkdirSync(sub, { recursive: true });
+    const exeName =
+      process.platform === 'win32' ? 'chrome-headless-shell.exe' : 'chrome-headless-shell';
+    const exe = join(sub, exeName);
+    writeFileSync(exe, '#!/bin/sh\n');
+    try {
+      const r = await withEnv(
+        {
+          MAUDE_BROWSERS_DIR: dir,
+          AGENT_BROWSER_EXECUTABLE_PATH: undefined,
+          MAUDE_BROWSER_EXECUTABLE: undefined,
+        },
+        () => resolveBrowser({ download: false })
+      );
+      expect(r.source).toBe('cache');
+      expect(r.path).toBe(exe);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('download:false never fetches (source is never "downloaded")', async () => {
+    const r = await resolveBrowser({ download: false });
+    expect(r.source).not.toBe('downloaded');
+  });
+});
+
+describe('download hardening (DDR-144 security fixes)', () => {
+  test('isTrustedDownloadUrl accepts only https on the allowlisted CDN hosts (F2)', () => {
+    expect(
+      isTrustedDownloadUrl('https://storage.googleapis.com/chrome-for-testing-public/x.zip')
+    ).toBe(true);
+    expect(isTrustedDownloadUrl('https://googlechromelabs.github.io/x.json')).toBe(true);
+    // plaintext scheme (MITM-able) rejected
+    expect(isTrustedDownloadUrl('http://storage.googleapis.com/x.zip')).toBe(false);
+    // foreign host (manifest tampering / redirect) rejected
+    expect(isTrustedDownloadUrl('https://evil.example.com/x.zip')).toBe(false);
+    // garbage rejected, no throw
+    expect(isTrustedDownloadUrl('not a url')).toBe(false);
+    expect(isTrustedDownloadUrl('')).toBe(false);
+  });
+
+  test('CFT_VERSION_RE accepts real versions, rejects shell-injection payloads (F3)', () => {
+    expect(CFT_VERSION_RE.test('150.0.7871.46')).toBe(true);
+    expect(CFT_VERSION_RE.test('120')).toBe(true);
+    // the PowerShell -Command break-out attempt
+    expect(CFT_VERSION_RE.test("1.0'; Remove-Item C:\\ -Recurse #")).toBe(false);
+    expect(CFT_VERSION_RE.test('$(rm -rf /)')).toBe(false);
+    expect(CFT_VERSION_RE.test('../../etc')).toBe(false);
+  });
+});

package/apps/studio/test/fixtures/mock-acp-agent-commands.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+// Mock ACP agent variant that publishes an `available_commands_update` the moment
+// a session is created (before the prompt) — stands in for Claude Code's command
+// catalogue so acp-commands.test.ts can exercise the warm-up + broadcast path
+// WITHOUT a real `claude`. Also answers a prompt so prompt-based paths still work.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-commands' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', async (ctx) => {
+    const sessionId = `mock-session-${++n}`;
+    // Publish the command catalogue on session creation — the warm-up path relies
+    // on this arriving without a prompt.
+    await ctx.client.notify('session/update', {
+      sessionId,
+      update: {
+        sessionUpdate: 'available_commands_update',
+        availableCommands: [
+          { name: 'design:edit', description: 'Iterate on the active canvas' },
+          { name: 'flow:plan', description: 'Create a plan' },
+        ],
+      },
+    });
+    return { sessionId };
+  })
+  .onRequest('session/prompt', async (ctx) => {
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'ok' } },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/hmr-broadcast.test.ts

@@ -95,6 +95,50 @@ describe('hmr-broadcast / debouncing', () => {
   });
 });
 
+describe('hmr-broadcast / multi-file bursts (RC4)', () => {
+  test('a burst touching two canvases broadcasts one message PER file', async () => {
+    // The old single-slot pendingMsg kept only the LAST file of a <50ms burst —
+    // the other open canvas never got its module reload and sat stale until a
+    // manual hard refresh (rca/issue-canvas-hmr-optimistic-update-consistency).
+    const ctx = mkCtx();
+    const got: HmrMessage[] = [];
+    const h = createHmrBroadcaster(ctx, (m) => got.push(m));
+    ctx.bus.emit('fs:any', 'ui/A.tsx');
+    ctx.bus.emit('fs:any', 'ui/B.tsx');
+    await awaitNextFlush();
+    expect(got).toHaveLength(2);
+    expect(new Set(got.map((m) => m.file))).toEqual(new Set(['ui/A.tsx', 'ui/B.tsx']));
+    for (const m of got) expect(m.mode).toBe('module');
+    h.stop();
+  });
+
+  test('a pending hard supersedes the whole per-file queue', async () => {
+    const ctx = mkCtx();
+    const got: HmrMessage[] = [];
+    const h = createHmrBroadcaster(ctx, (m) => got.push(m));
+    ctx.bus.emit('fs:any', 'ui/A.tsx');
+    ctx.bus.emit('fs:any', 'ui/B.tsx');
+    ctx.bus.emit('fs:any', '_lib/canvas-lib.tsx');
+    await awaitNextFlush();
+    expect(got).toHaveLength(1);
+    expect(got[0]?.mode).toBe('hard');
+    h.stop();
+  });
+
+  test('same-file meta echo never downgrades a queued module reload', async () => {
+    const ctx = mkCtx();
+    const got: HmrMessage[] = [];
+    const h = createHmrBroadcaster(ctx, (m) => got.push(m));
+    ctx.bus.emit('fs:any', 'ui/A.tsx');
+    ctx.bus.emit('fs:any', 'ui/A.meta.json');
+    await awaitNextFlush();
+    const forA = got.filter((m) => m.file === 'ui/A.tsx');
+    expect(forA).toHaveLength(1);
+    expect(forA[0]?.mode).toBe('module');
+    h.stop();
+  });
+});
+
 describe('hmr-broadcast / stop', () => {
   test('stop() prevents further broadcasts', async () => {
     const ctx = mkCtx();

package/apps/studio/test/inspect-selections.test.ts

@@ -0,0 +1,219 @@
+// feature-acp-context-hardening — per-canvas selection memory (`selections`
+// map) with the `selected` mirror invariant, restore-on-switch, the mtime
+// drift gate, html size cap on parked entries, and open_tabs GC.
+
+import { describe, expect, test } from 'bun:test';
+import { join } from 'node:path';
+
+import { type Context, createBus } from '../context.ts';
+import { createInspect, type SelectedElement } from '../inspect.ts';
+import { makeSandbox } from './_helpers.ts';
+
+function mkCtx(root: string, designRoot: string): Context {
+  return {
+    cfg: {} as Context['cfg'],
+    projectLabel: 'test',
+    bus: createBus(),
+    paths: {
+      repoRoot: root,
+      designRel: '.design',
+      designRoot,
+      serverInfoFile: join(designRoot, '_server.json'),
+      activeFile: join(designRoot, '_active.json'),
+      commentsDir: join(designRoot, '_comments'),
+      canvasStateDir: join(designRoot, '_canvas-state'),
+      historyDir: join(designRoot, '_history'),
+      tokensUrlRel: '',
+      systemDirRel: 'system',
+    },
+  };
+}
+
+const A = '.design/ui/fixture.html'; // exists via makeSandbox
+const B = '.design/ui/second.tsx';
+
+function selFor(file: string, text = 'hello') {
+  return {
+    file,
+    selector: 'h1',
+    tag: 'h1',
+    classes: '',
+    text,
+    dom_path: ['html', 'body', 'h1'],
+    bounds: { x: 0, y: 0, w: 100, h: 24 },
+    html: `<h1>${text}</h1>`,
+  };
+}
+
+async function mkRig() {
+  const { root, designRoot } = makeSandbox();
+  await Bun.write(join(root, B), 'export default function Second() { return <h1>B</h1>; }');
+  const ctx = mkCtx(root, designRoot);
+  const inspect = createInspect(ctx, async () => []);
+  return { root, designRoot, ctx, inspect };
+}
+
+const asOne = (v: unknown): SelectedElement => v as SelectedElement;
+
+describe('per-canvas selections — restore on switch', () => {
+  test('selection survives a canvas switch and comes back on return', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    expect(asOne(inspect.state.selected).selector).toBe('h1');
+
+    inspect.setActive(B);
+    expect(inspect.state.selected).toBeNull(); // B has no memory
+
+    inspect.setActive(A);
+    const restored = asOne(inspect.state.selected);
+    expect(restored).not.toBeNull();
+    expect(restored.selector).toBe('h1');
+    expect(restored.file).toBe(A); // SEL_VALID (`selected.file === active`) holds
+  });
+
+  test('parked (non-active) entries carry html: "" — size cap', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    // Active canvas's write-through keeps the rich copy…
+    expect(asOne(inspect.state.selections['ui/fixture']).html).toContain('<h1>');
+    inspect.setActive(B);
+    // …but parking on switch-away strips it.
+    expect(asOne(inspect.state.selections['ui/fixture']).html).toBe('');
+    inspect.setActive(A);
+    expect(asOne(inspect.state.selected).html).toBe('');
+  });
+
+  test('mirror invariant: selected === selections[activeSlug] after select', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    expect(inspect.state.selections['ui/fixture']).toBe(inspect.state.selected);
+  });
+
+  test('a cross-canvas plant (selection.file != active) is NOT stored (attacker F2 residual)', async () => {
+    // An active untrusted canvas posts a selection claiming a DIFFERENT canvas's
+    // file — it must not land in that canvas's slot for later agent delivery.
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(B, 'planted')); // A is active, payload claims B
+    expect(inspect.state.selections['ui/second']).toBeUndefined();
+    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
+    // Later opening B must not resurrect the plant.
+    inspect.setActive(B);
+    expect(inspect.state.selected).toBeNull();
+  });
+
+  test('single-entry array still collapses to a bare object (Phase 4.1 contract)', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected([selFor(A)]);
+    expect(Array.isArray(inspect.state.selected)).toBe(false);
+    expect(asOne(inspect.state.selected).tag).toBe('h1');
+  });
+});
+
+describe('per-canvas selections — drift gate', () => {
+  test('canvas edited while parked → restored selection is stale', async () => {
+    const { root, inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    const stamped = asOne(inspect.state.selected).canvas_mtime;
+    expect(stamped).toBeGreaterThan(0);
+
+    inspect.setActive(B);
+    // Another writer edits canvas A while it's parked (ensure mtime moves).
+    await Bun.sleep(5);
+    await Bun.write(join(root, A), '<!doctype html><html><body><h1>changed</h1></body></html>');
+
+    inspect.setActive(A);
+    expect(asOne(inspect.state.selected).stale).toBe(true);
+  });
+
+  test('untouched canvas restores without the stale flag', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    inspect.setActive(B);
+    inspect.setActive(A);
+    expect(asOne(inspect.state.selected).stale).toBeUndefined();
+  });
+});
+
+describe('per-canvas selections — lifecycle', () => {
+  test('explicit deselect clears the active canvas memory', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    inspect.setSelected(null);
+    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
+    inspect.setActive(B);
+    inspect.setActive(A);
+    expect(inspect.state.selected).toBeNull();
+  });
+
+  test('single-canvas shell ordering (tabs BEFORE active) never GCs the outgoing canvas', async () => {
+    // The shell replaces the tab and sends `tabs` with ONLY the incoming canvas
+    // before `active` parks the outgoing one — the exact wire order of app.jsx
+    // openTab effects. The outgoing canvas's memory must survive the round trip.
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setOpenTabs([A]);
+    inspect.setSelected(selFor(A));
+
+    inspect.setOpenTabs([B]); // switch A→B: tabs first…
+    inspect.setActive(B); //    …then active (parks A)
+    expect(inspect.state.selections['ui/fixture']).toBeDefined();
+
+    inspect.setOpenTabs([A]); // switch back B→A: tabs first…
+    inspect.setActive(A); //    …then active (restores A)
+    expect(asOne(inspect.state.selected).selector).toBe('h1');
+    expect(asOne(inspect.state.selected).file).toBe(A);
+  });
+
+  test('closing a tab GCs its parked selection', async () => {
+    const { inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    inspect.setActive(B); // parks A
+    inspect.setOpenTabs([B]); // A closed
+    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
+    expect(Object.keys(inspect.state.selections)).toHaveLength(0);
+  });
+
+  test('save/load round-trips selections; legacy file without them loads as {}', async () => {
+    const { designRoot, ctx, inspect } = await mkRig();
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    await inspect.save();
+
+    const reloaded = createInspect(ctx, async () => []);
+    await reloaded.load();
+    expect(asOne(reloaded.state.selections['ui/fixture']).selector).toBe('h1');
+
+    // Legacy shape (pre-selections) → invariant restored on load.
+    await Bun.write(
+      join(designRoot, '_active.json'),
+      JSON.stringify({ active: A, open_tabs: [A], selected: null, last_change: null })
+    );
+    const legacy = createInspect(ctx, async () => []);
+    await legacy.load();
+    expect(legacy.state.selections).toEqual({});
+  });
+
+  test('switch emits the restored selection on the bus (clients stay in sync)', async () => {
+    const { ctx, inspect } = await mkRig();
+    const emitted: unknown[] = [];
+    ctx.bus.on('selected', (s: unknown) => emitted.push(s));
+    inspect.setActive(A);
+    inspect.setSelected(selFor(A));
+    inspect.setActive(B);
+    inspect.setActive(A);
+    // emits: initial activate (null), select(A), switch→B (null), switch→A (restored)
+    expect(emitted).toHaveLength(4);
+    expect(emitted[0]).toBeNull();
+    expect(emitted[2]).toBeNull();
+    expect(asOne(emitted[3]).selector).toBe('h1');
+  });
+});

package/apps/studio/test/paths.test.ts

@@ -2,12 +2,18 @@
 // install, and compiled marketplace install. Phase 19.1 / v0.18.1.
 
 import { describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 import {
   CLIENT_DIR,
+  DESIGN_PLUGIN_DIR,
   DEV_SERVER_ROOT,
   DIST_DIR,
+  FLOW_PLUGIN_DIR,
   IS_COMPILED_BINARY,
+  pluginDirFrom,
   RUNTIME_BUNDLES_DIR,
 } from '../paths.ts';
 
@@ -29,3 +35,54 @@ describe('paths.ts', () => {
     expect(IS_COMPILED_BINARY).toBe(false);
   });
 });
+
+describe('pluginDirFrom — session-scoped plugin auto-bootstrap resolution (DDR-143)', () => {
+  // Both simulated layouts keep `plugins/` a sibling of `apps/studio/`, matching
+  // the dev tree and the desktop Resources bundle (stage-resources.mjs).
+  function makeLayout(shape: 'desktop-bundle' | 'npm'): { root: string; devServerRoot: string } {
+    const root = mkdtempSync(join(tmpdir(), 'maude-paths-'));
+    const devServerRoot = join(root, 'apps', 'studio');
+    mkdirSync(devServerRoot, { recursive: true });
+    for (const plugin of ['design', 'flow'] as const) {
+      const pluginRoot = join(root, 'plugins', plugin);
+      // Both layouts ship templates (DDR-044).
+      mkdirSync(join(pluginRoot, 'templates'), { recursive: true });
+      if (shape === 'desktop-bundle') {
+        // The desktop bundle stages the full loadable tree incl. the manifest.
+        mkdirSync(join(pluginRoot, '.claude-plugin'), { recursive: true });
+        mkdirSync(join(pluginRoot, 'commands'), { recursive: true });
+        writeFileSync(join(pluginRoot, '.claude-plugin', 'plugin.json'), '{"name":"x"}');
+      }
+      // npm layout: NO .claude-plugin/plugin.json (DDR-044 minimal surface).
+    }
+    return { root, devServerRoot };
+  }
+
+  test('desktop Resources layout → resolves both plugin dirs (manifest present)', () => {
+    const { root, devServerRoot } = makeLayout('desktop-bundle');
+    try {
+      expect(pluginDirFrom(devServerRoot, 'design')).toBe(join(root, 'plugins', 'design'));
+      expect(pluginDirFrom(devServerRoot, 'flow')).toBe(join(root, 'plugins', 'flow'));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('npm/web layout → null (templates ship, but no plugin manifest)', () => {
+    const { root, devServerRoot } = makeLayout('npm');
+    try {
+      expect(pluginDirFrom(devServerRoot, 'design')).toBeNull();
+      expect(pluginDirFrom(devServerRoot, 'flow')).toBeNull();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('exported constants resolve under the running dev tree (manifest present here)', () => {
+    // This suite runs from the repo dev tree, where plugins/{design,flow}/ carry
+    // their manifests — so the module-load-time constants are non-null and point
+    // at the real plugin roots.
+    expect(DESIGN_PLUGIN_DIR).toBe(join(DEV_SERVER_ROOT, '..', '..', 'plugins', 'design'));
+    expect(FLOW_PLUGIN_DIR).toBe(join(DEV_SERVER_ROOT, '..', '..', 'plugins', 'flow'));
+  });
+});

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

@@ -22,6 +22,9 @@ const INSTALLED_BOTH = {
   },
 };
 const INSTALLED_DESIGN_ONLY = { version: 2, plugins: { 'design@maude': [{ scope: 'user' }] } };
+// `/flow` is no longer part of the chat (2026-07-03) — the gate tracks `design`
+// alone, so a registry with flow-but-not-design is the "design missing" case.
+const INSTALLED_FLOW_ONLY = { version: 2, plugins: { 'flow@maude': [{ scope: 'user' }] } };
 
 function fixtureClaudeDir(opts: { markets?: unknown; installed?: unknown }): string {
   const dir = mkdtempSync(join(tmpdir(), 'maude-readiness-'));
@@ -45,43 +48,95 @@ async function withClaudeDir<T>(dir: string, fn: () => Promise<T> | T): Promise<
   }
 }
 
-const pluginsItem = async (dir: string) =>
-  (await withClaudeDir(dir, () => probeReadiness())).items.find((i) => i.id === 'plugins')!;
+/** Plugins row under the given ~/.claude fixture. `nativeBootstrap:false` sets
+ *  MAUDE_NO_PLUGIN_BOOTSTRAP to force the web / manual (DDR-128) path — needed to
+ *  isolate the registry scan, since this suite runs in the dev tree where the
+ *  bundled plugin dirs resolve and DDR-143 auto-load would otherwise mask it. */
+const pluginsItem = async (dir: string, opts: { nativeBootstrap?: boolean } = {}) => {
+  const savedOptOut = process.env.MAUDE_NO_PLUGIN_BOOTSTRAP;
+  if (opts.nativeBootstrap === false) process.env.MAUDE_NO_PLUGIN_BOOTSTRAP = '1';
+  try {
+    return (await withClaudeDir(dir, () => probeReadiness())).items.find(
+      (i) => i.id === 'plugins'
+    )!;
+  } finally {
+    if (savedOptOut === undefined) delete process.env.MAUDE_NO_PLUGIN_BOOTSTRAP;
+    else process.env.MAUDE_NO_PLUGIN_BOOTSTRAP = savedOptOut;
+  }
+};
 
-describe('readiness — plugin registry scan', () => {
-  test('both plugins + marketplace present → plugins item is present, no remediation', async () => {
+// Registry-scan branches under the WEB / manual path (auto-bootstrap opted out) —
+// the pure DDR-128 detect-and-guide behavior, still what a `maude design serve`
+// user sees.
+describe('readiness — plugin registry scan (web / manual path)', () => {
+  test('design@maude + marketplace present → plugins item is present, no remediation', async () => {
     const item = await pluginsItem(
-      fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_BOTH })
+      fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_DESIGN_ONLY }),
+      { nativeBootstrap: false }
     );
     expect(item.status).toBe('present');
     expect(item.remediation).toBeUndefined();
   });
 
-  test('only design@maude installed → missing, names the absent flow@maude + offers the fix', async () => {
+  test('design@maude NOT installed → missing, names the absent design@maude + offers the fix', async () => {
+    // flow-only registry: `/flow` is irrelevant to the chat now, so this reads as
+    // "design missing" — the gate tracks design alone.
     const item = await pluginsItem(
-      fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_DESIGN_ONLY })
+      fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_FLOW_ONLY }),
+      { nativeBootstrap: false }
     );
     expect(item.status).toBe('missing');
-    expect(item.detail).toContain('flow@maude');
+    expect(item.detail).toContain('design@maude');
     expect(item.remediation).toContain('/plugin install');
   });
 
   test('registry absent → unknown (Claude Code internal contract; never throws)', async () => {
-    const item = await pluginsItem(fixtureClaudeDir({}));
+    const item = await pluginsItem(fixtureClaudeDir({}), { nativeBootstrap: false });
     expect(item.status).toBe('unknown');
   });
 
-  test('plugin presence is the gate — a foreign-repo marketplace does not change a both-installed verdict', async () => {
+  test('plugin presence is the gate — a foreign-repo marketplace does not change a design-installed verdict', async () => {
     const item = await pluginsItem(
       fixtureClaudeDir({
         markets: { other: { source: { repo: 'someone/else' } } },
         installed: INSTALLED_BOTH,
-      })
+      }),
+      { nativeBootstrap: false }
     );
     expect(item.status).toBe('present');
   });
 });
 
+// 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 () => {
+    const item = await pluginsItem(fixtureClaudeDir({}));
+    expect(item.status).toBe('present');
+    expect(item.detail).toContain('Auto-loaded');
+    expect(item.remediation).toBeUndefined();
+  });
+
+  test('design NOT installed (flow-only registry) → still present (design is auto-loaded, 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.remediation).toBeUndefined();
+  });
+
+  test('design already installed → present, keeps the "is installed" detail (no auto-load framing)', async () => {
+    const item = await pluginsItem(
+      fixtureClaudeDir({ markets: MARKET_OK, installed: INSTALLED_DESIGN_ONLY })
+    );
+    expect(item.status).toBe('present');
+    expect(item.detail).toContain('installed');
+  });
+});
+
 describe('readiness — resolveOnPath', () => {
   test('finds a binary that is on PATH', async () => {
     const hit = await resolveOnPath('sh');
@@ -126,9 +181,24 @@ describe('readiness — report shape', () => {
     expect(typeof report.ready).toBe('boolean');
   });
 
-  test('agent-browser is optional and never gates ready', async () => {
+  test('screenshot engine: required + present (bundled) on native → never blocks ready', async () => {
+    // Native (this dev tree): agent-browser is bundled, so the row is first-class
+    // (required) but PRESENT — it can't turn `ready` false.
     const ab = (await probeReadiness()).items.find((i) => i.id === 'agent-browser')!;
-    expect(ab.required).toBe(false);
+    expect(ab.required).toBe(true);
+    expect(ab.status).toBe('present');
+  });
+
+  test('screenshot engine: optional on the web/opt-out path', async () => {
+    const saved = process.env.MAUDE_NO_PLUGIN_BOOTSTRAP;
+    process.env.MAUDE_NO_PLUGIN_BOOTSTRAP = '1'; // force native=false
+    try {
+      const ab = (await probeReadiness()).items.find((i) => i.id === 'agent-browser')!;
+      expect(ab.required).toBe(false);
+    } finally {
+      if (saved === undefined) delete process.env.MAUDE_NO_PLUGIN_BOOTSTRAP;
+      else process.env.MAUDE_NO_PLUGIN_BOOTSTRAP = saved;
+    }
   });
 
   test('adapter row tracks the real chat gate (resolveAdapterEntry) and is required', async () => {