@1agh/maude 0.17.2 → 0.18.1

package/plugins/design/dev-server/dist/runtime/react_jsx-runtime.js

@@ -0,0 +1,103 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../../node_modules/.pnpm/react@19.2.6/node_modules/react/cjs/react-jsx-runtime.production.js
+var exports_react_jsx_runtime_production = {};
+__export(exports_react_jsx_runtime_production, {
+  jsxs: () => $jsxs,
+  jsx: () => $jsx,
+  Fragment: () => $Fragment
+});
+function jsxProd(type, config, maybeKey) {
+  var key = null;
+  maybeKey !== undefined && (key = "" + maybeKey);
+  config.key !== undefined && (key = "" + config.key);
+  if ("key" in config) {
+    maybeKey = {};
+    for (var propName in config)
+      propName !== "key" && (maybeKey[propName] = config[propName]);
+  } else
+    maybeKey = config;
+  config = maybeKey.ref;
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type,
+    key,
+    ref: config !== undefined ? config : null,
+    props: maybeKey
+  };
+}
+var REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, $Fragment, $jsx, $jsxs;
+var init_react_jsx_runtime_production = __esm(() => {
+  REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  $Fragment = REACT_FRAGMENT_TYPE;
+  $jsx = jsxProd;
+  $jsxs = jsxProd;
+});
+
+// ../../../node_modules/.pnpm/react@19.2.6/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS((exports, module) => {
+  init_react_jsx_runtime_production();
+  if (true) {
+    module.exports = exports_react_jsx_runtime_production;
+  }
+});
+
+// synth:/home/runner/work/maude/maude/plugins/design/dev-server/.runtime-bundle-react_jsx-runtime-entry.tsx
+var __mod__ = __toESM(require_jsx_runtime(), 1);
+var {
+  Fragment,
+  jsx,
+  jsxs
+} = __mod__;
+var __runtime_bundle_react_jsx_runtime_entry_default = __mod__;
+export {
+  jsxs,
+  jsx,
+  __runtime_bundle_react_jsx_runtime_entry_default as default,
+  Fragment
+};

package/plugins/design/dev-server/http.ts

@@ -5,8 +5,7 @@
 // top-level fall-through for paths Bun's `routes` field doesn't cover.
 
 import { watch } from 'node:fs';
-import { dirname, join, posix } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join, posix } from 'node:path';
 
 import type { Api } from './api.ts';
 import { buildCanvasModule } from './canvas-build.ts';
@@ -17,9 +16,12 @@ import { isFormat, isScope, runExport } from './exporters/index.ts';
 import type { ActiveJsonShape } from './exporters/scope.ts';
 import type { Inspect } from './inspect.ts';
 import { canvasSlug, writeLocator } from './locator.ts';
+import { DEV_SERVER_ROOT } from './paths.ts';
 import { RUNTIME_PACKAGES, getRuntimeBundle, packageForSlug, slugFor } from './runtime-bundle.ts';
 
-const HERE = dirname(fileURLToPath(import.meta.url));
+// Real disk install root — never the virtual `/$bunfs/root` of compiled bins.
+// See paths.ts for the resolution logic + Phase 19.1 / v0.18.1 rationale.
+const HERE = DEV_SERVER_ROOT;
 
 export const MIME: Record<string, string> = {
   '.html': 'text/html; charset=utf-8',

package/plugins/design/dev-server/paths.ts

@@ -0,0 +1,115 @@
+// Path resolution for the dev-server, robust across THREE runtime modes:
+//
+//   1. Dev (`bun server.ts`):      import.meta.url is a real file:// path,
+//                                  use dirname of it.
+//   2. Compiled binary, npm:       maude installed via `npm i -g @1agh/maude`;
+//                                  binary lives in a sub-package dir, deps in
+//                                  the parent @1agh/maude/ dir. import.meta.url
+//                                  is the virtual `/$bunfs/root` (bun --compile
+//                                  embedded fs) — NOT a real disk path.
+//                                  Walk up from process.execPath until we find
+//                                  the real plugins/design/dev-server/ dir.
+//   3. Compiled binary, marketplace cache: similar to (2) but lives at
+//                                  ~/.claude/plugins/cache/maude/design/<v>/
+//                                  dev-server/. Same walk-up logic finds it.
+//
+// Why this matters: Phase 19 v0.18.0 used `dirname(fileURLToPath(import.meta.url))`
+// universally. In the compiled binary that's `/$bunfs/root` — a virtual path —
+// so `existsSync('/$bunfs/root/dist/client.bundle.js')` always returned false
+// even when the file was sitting on disk at the real install path. Self-heal
+// false-triggered, http.ts /_client/* fell through to /$bunfs/root/client/*.jsx
+// (raw source), runtime-bundle.ts synthetic entrypoint anchored in virtual fs
+// so Bun.build couldn't walk node_modules. Every observed symptom traces to
+// this one bug. Phase 19.1 / v0.18.1.
+
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Real disk path to the dev-server install dir
+ * (`plugins/design/dev-server/` inside whatever package layout we're in).
+ *
+ * Always a directory that contains `http.ts` + `dist/` + (optionally)
+ * `node_modules/` and `client/`. Never a virtual `/$bunfs/*` path.
+ */
+export const DEV_SERVER_ROOT: string = resolveDevServerRoot();
+
+/** `<DEV_SERVER_ROOT>/dist/` — committed artifacts + runtime bundles + binary. */
+export const DIST_DIR: string = join(DEV_SERVER_ROOT, 'dist');
+
+/** `<DEV_SERVER_ROOT>/client/` — raw source HTML + JSX + CSS for dev fallback. */
+export const CLIENT_DIR: string = join(DEV_SERVER_ROOT, 'client');
+
+/** `<DEV_SERVER_ROOT>/dist/runtime/` — pre-built /_canvas-runtime/*.js bundles. */
+export const RUNTIME_BUNDLES_DIR: string = join(DIST_DIR, 'runtime');
+
+/**
+ * Whether we are running inside a `bun --compile` standalone binary
+ * (true when `import.meta.url` resolves to bun's virtual filesystem).
+ *
+ * Useful for code that needs to know whether disk-relative fallback paths
+ * (e.g. `<DEV_SERVER_ROOT>/client/app.jsx`) are even reachable — in compiled
+ * mode the answer is "only if shipped via the install layout".
+ */
+export const IS_COMPILED_BINARY: boolean = isVirtualBunfsPath(getImportMetaDir());
+
+function getImportMetaDir(): string | null {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return null;
+  }
+}
+
+function isVirtualBunfsPath(p: string | null): boolean {
+  return p !== null && (p.startsWith('/$bunfs') || p.startsWith('B:/~BUN'));
+}
+
+function isDevServerDir(dir: string): boolean {
+  // Two anchors that the dev-server source tree always has and an arbitrary
+  // sibling directory wouldn't: http.ts (canonical entry route table) AND
+  // package.json with name "@maude/dev-server" (catches the case where some
+  // unrelated tree happens to have an http.ts).
+  if (!existsSync(join(dir, 'http.ts'))) return false;
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return false;
+  try {
+    const text = require('node:fs').readFileSync(pkgPath, 'utf8') as string;
+    return /"@maude\/dev-server"/.test(text);
+  } catch {
+    return false;
+  }
+}
+
+function resolveDevServerRoot(): string {
+  // (1) Dev mode: import.meta.url is a real file:// path AND lands in the
+  // dev-server dir. Common case for `bun run server.ts`, tests, etc.
+  const importDir = getImportMetaDir();
+  if (importDir && !isVirtualBunfsPath(importDir) && isDevServerDir(importDir)) {
+    return importDir;
+  }
+
+  // (2 + 3) Compiled binary: walk up from process.execPath until we find a dir
+  // that *contains* `plugins/design/dev-server/<canonical files>`. Match both
+  // npm install layout (binary at @1agh/maude-<plat>/maude → walk up 4 levels
+  // to @1agh/maude/) AND marketplace cache layout (binary somewhere under
+  // ~/.claude/plugins/cache/maude/design/<v>/dev-server/dist/).
+  let cur = dirname(process.execPath);
+  for (let i = 0; i < 10; i++) {
+    // Check if cur itself is the dev-server root.
+    if (isDevServerDir(cur)) return cur;
+    // Check if cur contains plugins/design/dev-server/.
+    const nested = join(cur, 'plugins', 'design', 'dev-server');
+    if (isDevServerDir(nested)) return nested;
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+
+  // Final fallback for unanchored test contexts (e.g. tests spawning compiled
+  // binary in a tmp dir without our layout). Return the import dir even if
+  // it's virtual — callers should expect existsSync to fail and surface a
+  // clear error.
+  return importDir ?? dirname(process.execPath);
+}

package/plugins/design/dev-server/runtime-bundle.ts

@@ -18,10 +18,28 @@
 //   - In dev we externalise *nothing* — the four bundles together are
 //     self-contained. The importmap wires them together at runtime.
 
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 
-const HERE = dirname(fileURLToPath(import.meta.url));
+import { DEV_SERVER_ROOT, RUNTIME_BUNDLES_DIR } from './paths.ts';
+
+// Real disk install root — synthetic entry points must anchor here so
+// Bun.build's resolver walks UP and finds node_modules/react on disk.
+// In compiled binaries, import.meta.url is the virtual `/$bunfs/root`
+// where no node_modules exists (Phase 19.1 / v0.18.1).
+const HERE = DEV_SERVER_ROOT;
+
+/**
+ * Read a pre-built runtime bundle from `dist/runtime/<slug>.js`. Returns
+ * null when missing → caller falls back to dynamic Bun.build (dev mode).
+ */
+async function loadPrebuiltRuntimeBundle(pkg: RuntimePackage): Promise<BundleCacheEntry | null> {
+  const path = join(RUNTIME_BUNDLES_DIR, `${slugFor(pkg)}.js`);
+  const file = Bun.file(path);
+  if (!(await file.exists())) return null;
+  const js = await file.text();
+  if (!js) return null;
+  return { js, etag: Bun.hash(js).toString(16) };
+}
 
 export const RUNTIME_PACKAGES = [
   'react',
@@ -99,10 +117,37 @@ const cache = new Map<RuntimePackage, BundleCacheEntry>();
  * each entry includes everything it needs; the four bundles only share state
  * at the browser level (via React's module-singleton convention — multiple
  * imports of "react" resolve to the same module thanks to the importmap).
+ *
+ * Two paths:
+ *   1. **Pre-built on disk** (Phase 19.1 / v0.18.1). Every release ships
+ *      `dist/runtime/<slug>.js` so npm-installed users + marketplace cache
+ *      users never need disk node_modules/react or Bun.build at request time.
+ *      Read from disk → return.
+ *   2. **Dynamic Bun.build** — only fires for dev (cd dev-server; bun
+ *      server.ts) where `dist/runtime/` may be empty/stale.
  */
-export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCacheEntry> {
+export interface GetRuntimeBundleOptions {
+  /** Skip the disk cache lookup — used by build.ts to force a fresh dynamic build. */
+  skipPrebuilt?: boolean;
+  /** Minify the dynamic build output — used by build.ts in release mode. */
+  minify?: boolean;
+}
+
+export async function getRuntimeBundle(
+  pkg: RuntimePackage,
+  opts: GetRuntimeBundleOptions = {}
+): Promise<BundleCacheEntry> {
   const hit = cache.get(pkg);
-  if (hit) return hit;
+  if (hit && !opts.skipPrebuilt) return hit;
+
+  // (1) Pre-built bundle path — try disk first (unless caller opts out).
+  if (!opts.skipPrebuilt) {
+    const prebuilt = await loadPrebuiltRuntimeBundle(pkg);
+    if (prebuilt) {
+      cache.set(pkg, prebuilt);
+      return prebuilt;
+    }
+  }
 
   // A throwaway entrypoint that re-exports every member of the target package.
   // We use named re-exports (default + an enumerated namespace) so the bundle
@@ -144,7 +189,7 @@ export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCache
     entrypoints: [entryName],
     target: 'browser',
     format: 'esm',
-    minify: false,
+    minify: opts.minify ?? false,
     splitting: false,
     define: {
       // Force React's production module (smaller, no dev-only `let React`
@@ -194,7 +239,12 @@ export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCache
         return `[${lvl}] ${l.message}`;
       })
       .join('\n');
-    throw new Error(`Failed to build runtime bundle for "${pkg}":\n${msg || '(no log messages)'}`);
+    const remediation = bunCacheRemediation(pkg, msg);
+    throw new Error(
+      `Failed to build runtime bundle for "${pkg}":\n${msg || '(no log messages)'}${
+        remediation ? `\n\n${remediation}` : ''
+      }`
+    );
   }
 
   const out = built.outputs[0];
@@ -206,6 +256,29 @@ export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCache
   return entry;
 }
 
+/**
+ * Detect the "Bun's global install cache is in a bad state" failure mode and
+ * return a one-paragraph remediation message. Returns null when the build
+ * failure has a different shape (real syntax error, missing package, etc.) —
+ * the original log is enough then.
+ *
+ * Symptoms: log messages like `EISDIR reading '/Users/foo/.bun/install/cache/
+ * react@19.2.6@@@1 @@1/index.js'` or `ENOENT … .bun/install/cache/<pkg>@…`.
+ * Surfacing the cache path + the exact `bun pm cache rm <pkg>` command saves
+ * the user from grepping the error to figure out what to do. Phase 19 / DDR-044.
+ */
+export function bunCacheRemediation(pkg: string, log: string): string | null {
+  const cacheHit = /(EISDIR|ENOENT).*\.bun\/install\/cache\/([\w@/.-]+?)(?:@@@|\/)/i.test(log);
+  if (!cacheHit) return null;
+  const basePkg = pkg.split('/')[0] ?? pkg;
+  return [
+    `  ⚠ Bun's global package cache for "${basePkg}" appears to be in a bad state`,
+    '    (truncated install, EISDIR/ENOENT on an index file).',
+    '',
+    `    Fix: run \`bun pm cache rm ${basePkg}\` then reload the page.`,
+  ].join('\n');
+}
+
 function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/plugins/design/dev-server/server.ts

@@ -17,6 +17,7 @@
 import { spawn } from 'node:child_process';
 
 import { createApi } from './api.ts';
+import { bootSelfHeal } from './boot-self-heal.ts';
 import { createContext } from './context.ts';
 import { createFsWatch } from './fs-watch.ts';
 import { createHttp } from './http.ts';
@@ -24,6 +25,11 @@ import { createInspect } from './inspect.ts';
 import { startHeapWatch } from './mem.ts';
 import { createWs } from './ws.ts';
 
+// Phase 19 / DDR-044 — covers the marketplace-cache-install gap where
+// node_modules/ ships empty (git clone honors .gitignore). Auto-installs +
+// builds on first boot; opt out with MAUDE_NO_AUTOBUILD=1.
+await bootSelfHeal();
+
 const ctx = createContext();
 
 const api = createApi(ctx, async (file) => {

package/plugins/design/dev-server/test/boot-self-heal.test.ts

@@ -0,0 +1,87 @@
+// Boot artifact check — Phase 19 / DDR-044, simplified in v0.18.1.
+// v0.18.0 tried to `bun install` + `bun run build.ts` when node_modules/react
+// was missing; that misfired in every install scenario (see boot-self-heal.ts
+// header). v0.18.1 ships pre-built runtime bundles + just verifies they're
+// reachable. Missing artifact == broken install, not first-boot gap.
+
+import { afterEach, beforeEach, 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 { type SelfHealOptions, bootSelfHeal } from '../boot-self-heal.ts';
+
+let TMP: string;
+
+beforeEach(() => {
+  TMP = mkdtempSync(join(tmpdir(), 'maude-self-heal-'));
+  mkdirSync(join(TMP, 'dist', 'runtime'), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(TMP, { recursive: true, force: true });
+});
+
+function harness(extra: Partial<SelfHealOptions> = {}) {
+  const logs: string[] = [];
+  let exited: number | null = null;
+  const opts: SelfHealOptions = {
+    here: TMP,
+    log: (m) => logs.push(m),
+    exit: ((code: number) => {
+      exited = code;
+      throw new Error(`__exit:${code}`);
+    }) as never,
+    ...extra,
+  };
+  return { opts, logs, getExited: () => exited };
+}
+
+function seedAll() {
+  writeFileSync(join(TMP, 'dist', 'client.bundle.js'), '/* stub */');
+  writeFileSync(join(TMP, 'dist', 'runtime', 'react.js'), '/* stub */');
+}
+
+describe('bootSelfHeal', () => {
+  test('passes when both required artifacts present', async () => {
+    seedAll();
+    const { opts, logs } = harness();
+    const result = await bootSelfHeal(opts);
+    expect(result.verified).toEqual(['client.bundle.js', 'runtime/react.js']);
+    expect(logs).toEqual([]);
+  });
+
+  test('exits 1 with remediation when dist/client.bundle.js missing', async () => {
+    writeFileSync(join(TMP, 'dist', 'runtime', 'react.js'), '/* stub */');
+    const { opts, logs, getExited } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
+    expect(getExited()).toBe(1);
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/client\.bundle\.js/);
+    expect(msg).toMatch(/npm uninstall -g @1agh\/maude/);
+  });
+
+  test('exits 1 with remediation when dist/runtime/react.js missing', async () => {
+    writeFileSync(join(TMP, 'dist', 'client.bundle.js'), '/* stub */');
+    const { opts, logs, getExited } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
+    expect(getExited()).toBe(1);
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/runtime\/react\.js/);
+  });
+
+  test('lists ALL missing artifacts in one message (not first-fail-only)', async () => {
+    // Nothing seeded — both missing.
+    const { opts, logs } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/client\.bundle\.js/);
+    expect(msg).toMatch(/dist\/runtime\/react\.js/);
+  });
+
+  test('remediation surfaces the looked-under path so user can verify', async () => {
+    const { opts, logs } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow();
+    expect(logs.join('\n')).toContain(TMP);
+  });
+});

package/plugins/design/dev-server/test/paths.test.ts

@@ -0,0 +1,31 @@
+// paths.ts — resolves real disk install root across dev mode, compiled npm
+// install, and compiled marketplace install. Phase 19.1 / v0.18.1.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  CLIENT_DIR,
+  DEV_SERVER_ROOT,
+  DIST_DIR,
+  IS_COMPILED_BINARY,
+  RUNTIME_BUNDLES_DIR,
+} from '../paths.ts';
+
+describe('paths.ts', () => {
+  test('DEV_SERVER_ROOT contains http.ts + package.json (canonical anchor)', () => {
+    expect(DEV_SERVER_ROOT).not.toMatch(/\$bunfs|~BUN/);
+    expect(Bun.file(`${DEV_SERVER_ROOT}/http.ts`).size).toBeGreaterThan(0);
+    expect(Bun.file(`${DEV_SERVER_ROOT}/package.json`).size).toBeGreaterThan(0);
+  });
+
+  test('DIST_DIR + CLIENT_DIR + RUNTIME_BUNDLES_DIR are descendants of DEV_SERVER_ROOT', () => {
+    expect(DIST_DIR).toBe(`${DEV_SERVER_ROOT}/dist`);
+    expect(CLIENT_DIR).toBe(`${DEV_SERVER_ROOT}/client`);
+    expect(RUNTIME_BUNDLES_DIR).toBe(`${DEV_SERVER_ROOT}/dist/runtime`);
+  });
+
+  test('IS_COMPILED_BINARY is false when running under bun directly (this test)', () => {
+    // bun:test invokes via `bun`, so import.meta.url is a real file:// path.
+    expect(IS_COMPILED_BINARY).toBe(false);
+  });
+});

package/plugins/design/dev-server/test/runtime-bundle-error-mapping.test.ts

@@ -0,0 +1,43 @@
+// Phase 19 / DDR-044 — runtime-bundle error-message remediation.
+// When Bun.build fails because the global install cache is corrupted
+// (EISDIR/ENOENT on a cached package's entry file), surface an actionable
+// `bun pm cache rm <pkg>` hint instead of just relaying the raw log.
+
+import { describe, expect, test } from 'bun:test';
+
+import { bunCacheRemediation } from '../runtime-bundle.ts';
+
+describe('bunCacheRemediation', () => {
+  test('returns null on unrelated build failures (real syntax errors etc.)', () => {
+    expect(bunCacheRemediation('react', '[error] Unexpected token <')).toBeNull();
+    expect(bunCacheRemediation('react-dom', '[error] Could not resolve "missing-pkg"')).toBeNull();
+  });
+
+  test('matches EISDIR on .bun/install/cache + names the base package', () => {
+    const log =
+      "[error] EISDIR reading '/Users/iagh/.bun/install/cache/react@19.2.6@@@1 @@1/index.js'";
+    const out = bunCacheRemediation('react', log);
+    expect(out).not.toBeNull();
+    expect(out).toMatch(/bun pm cache rm react/);
+    expect(out).toMatch(/bad state/);
+  });
+
+  test('matches ENOENT on .bun/install/cache too', () => {
+    const log = "[error] ENOENT: '/Users/x/.bun/install/cache/react-dom@19.0.0/index.js'";
+    const out = bunCacheRemediation('react-dom', log);
+    expect(out).toMatch(/bun pm cache rm react-dom/);
+  });
+
+  test('subpath specifiers strip to the base package for the cache rm command', () => {
+    // bun pm cache works on base package names — "react/jsx-runtime" → "react".
+    const log = "[error] EISDIR '/Users/x/.bun/install/cache/react@19.2.6/jsx-runtime.js'";
+    const out = bunCacheRemediation('react/jsx-runtime', log);
+    expect(out).toMatch(/bun pm cache rm react\b/);
+    expect(out).not.toMatch(/bun pm cache rm react\//);
+  });
+
+  test('case-insensitive match (Bun has bounced casing across versions)', () => {
+    const log = '[error] eisdir reading /Users/x/.bun/install/cache/react@19/index.js';
+    expect(bunCacheRemediation('react', log)).not.toBeNull();
+  });
+});

package/plugins/design/templates/canvas.tsx.template

@@ -11,11 +11,11 @@
  *
  * Authored under {{DS_NAME}}. Tokens + shared component classes load via the
  * dev-server's _shell.html harness — link tags arrive automatically from the
- * iframe's ?tokens= / ?components= query. Class names match the DS's
- * `_components.css` (`.btn`, `.tile`, `.sku`, `.seg`, ...). Bespoke classes go
- * into a sibling .module.css iff `css_mode === "modules"`; for `inline` (the
- * MDCC-DSN/01 default) prefer existing classes + `style={{}}` for arbitrary
- * one-off values.
+ * iframe's ?tokens= / ?components= query. Class names come from the DS's
+ * own `_components.css` — see `system/{{DS_NAME}}/preview/` for the available
+ * class shapes. Bespoke classes go into a sibling .module.css iff
+ * `css_mode === "modules"`; for `inline` prefer existing classes + `style={{}}`
+ * for arbitrary one-off values.
  *
  * The envelope primitives (`DesignCanvas`, `DCSection`, `DCArtboard`) and any
  * specimen helpers come from the dev-server-bundled canvas library via the
@@ -40,11 +40,11 @@ export default function {{COMPONENT_NAME}}() {
     <DesignCanvas>
       <DCSection id="overview" title="{{SUBTITLE}}">
         <DCArtboard id="primary" label="A · primary" width={1280} height={800}>
-          <div className="mdcc" data-theme="{{THEME_DEFAULT}}">
+          <div className="{{ROOT_CLASS}}" data-theme="{{THEME_DEFAULT}}">
             {/* Replace this scaffold with the actual canvas content. The
                 envelope this template was rendered against is in
                 {{HISTORY_DIR}}/000-envelope.md. */}
-            <h1 className="sku">{{NAME}}</h1>
+            <h1>{{NAME}}</h1>
             <p>{{BRIEF}}</p>
           </div>
         </DCArtboard>

package/plugins/design/templates/design-system-inspiration/audience-pro/colors-presence.html

@@ -4,7 +4,7 @@ DEMONSTRATES: --presence-online, --presence-away, --presence-offline; presence d
 COMPOSITION: 4 avatars with presence dots (online / away / offline / idle) + a "live cursors" mockup with 3 simultaneous users
 COPY VOICE: real names, real timestamps
 WHEN SCAFFOLDED: presence family (IF "presence" ∈ activeFamilies — typically pro tools with multiplayer)
-NOTES: Presence dot is 8px circle bottom-right of 32-40px avatars (anchor on the visual bottom-right, not on a math grid). Cursor labels are subtle (pill at 11px, low opacity bg). Don't blink presence — too noisy in a busy view.
+NOTES: Presence dot is 8px circle bottom-right of 32-40px avatars (anchor on the visual bottom-right, not on a math grid). Per-user cursor colors below are illustrative only — the inline `oklch(...)` values are NOT part of the project's design system. A real implementation should source these from a `--presence-user-*` family or derive from `--accent` deterministically. Cursor labels are subtle (pill at 11px, low opacity bg). Don't blink presence — too noisy in a busy view.
 -->
 <!doctype html>
 <html lang="en">

package/plugins/design/templates/design-system-inspiration/core/README.philosophy.md.tpl

@@ -19,13 +19,15 @@
 
 ## Foundations
 
-### One-accent rule
+### Token contract
 
-Exactly one accent family lives in `colors_and_type.css`: `--accent`, `--accent-hover`, `--accent-active`, `--accent-fg`. **No `--accent2`.** Calls-to-attention compete with each other; one accent forces hierarchy decisions at design time, not runtime.
+All visuals reference `var(--*)` tokens declared in `colors_and_type.css`. Adding a new visual concept means **extending the tokens CSS first**, never inventing values inline in a canvas.
 
-### Token contract
+{{color_space_block}}
+
+### Accent strategy
 
-All visuals reference `var(--*)` tokens declared in `colors_and_type.css`. No hardcoded hex / px / rem in canvases or production code. Adding a new visual concept means **extending the tokens CSS first**, never inventing values inline.
+{{accent_rules_block}}
 
 ### Active token families
 
@@ -33,8 +35,9 @@ All visuals reference `var(--*)` tokens declared in `colors_and_type.css`. No ha
 
 ## Hard rules (non-negotiable)
 
-- **Accessibility:** WCAG 2.1 AA contrast at every theme. Focus-visible always rendered. Touch targets ≥ 44×44. `prefers-reduced-motion: reduce` respected.
-- **No off-token colors / radii / spacings** in canvases. Extend tokens; don't inline.
+- **Accessibility:** WCAG 2.1 AA contrast at every theme. Focus-visible always rendered. `prefers-reduced-motion: reduce` respected.
+- **Touch targets:** {{touch_target_rule}}
+- **No off-token values** in canvases. Extend tokens; don't inline.
 - **No placeholder copy.** Real product strings only — no "Lorem Solutions Inc.", no "Click here".
 - **Type ladder:** {{type_scale_summary}}
 - **Motion:** every animation uses a `var(--dur-*)` and `var(--ease-*)` token. No magic numbers.
@@ -52,7 +55,8 @@ All visuals reference `var(--*)` tokens declared in `colors_and_type.css`. No ha
 ## Hard-stops the completeness-critic enforces
 
 - Core tokens present (`--accent`, `--bg-0..4`, `--fg-0..3`, `--dur-flip`)
-- Exactly one accent family
+- Accent family count matches the declared strategy ({{accent_strategy_summary}})
+- Color space matches the declared choice ({{color_space_summary}})
 - `system/{{ds_dirname}}/preview/` populated with at least 8 specimens
 - `colors_and_type.css` linked from every specimen
 - `prefers-reduced-motion: reduce` guard present in tokens CSS

package/plugins/design/templates/design-system-inspiration/core/SKILL.md.tpl

@@ -24,8 +24,9 @@ It is **not** auto-invoked by `/design:edit` or `/design:new` on a project with
 
 ## What the agent should remember
 
-- **One accent.** No `--accent2`. Calls-to-attention compete; one accent forces hierarchy decisions.
-- **All visuals reference `var(--*)` tokens.** No hardcoded hex / px / rem in canvases.
+- **Accent strategy:** {{accent_strategy_summary}}. {{accent_rules_summary}}
+- **All visuals reference `var(--*)` tokens.** No off-token values in canvases.
+- **Color space:** {{color_space_summary}}.
 - **Voice:** {{voice_tone_summary}}
 - **Iconography:** {{iconography_summary}}
 - **Theme default:** `{{theme_default}}`. {{theme_extra}}
@@ -47,4 +48,4 @@ It is **not** auto-invoked by `/design:edit` or `/design:new` on a project with
 
 ## How to extend
 
-If a canvas iteration needs a value not currently in the system, **extend `colors_and_type.css` first**. Adding a new variant of an existing token (e.g. `--accent-tertiary`) is fine; adding a parallel accent family (e.g. `--accent2`) violates the one-accent rule and the completeness-critic will block.
+If a canvas iteration needs a value not currently in the system, **extend `colors_and_type.css` first**. Adding a new variant of an existing token (e.g. `--accent-tertiary`) is fine. Adding a parallel accent family (e.g. `--accent2`) is only allowed if the project's declared `accentStrategy` in `config.json` permits it (e.g. `paired` or `chromatic-N`) — the completeness-critic enforces the declared strategy.