@1agh/maude 0.30.0 → 0.32.0

package/apps/studio/whats-new.json

@@ -1,6 +1,88 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "ai-editing-readiness-check",
+      "version": "0.32.0",
+      "date": "2026-06-24",
+      "kind": "feature",
+      "title": "See what AI editing needs",
+      "summary": "The welcome screen and the Assistant panel now show whether AI editing is ready — and if Claude Code, the maude CLI, or the Maude plugins are missing, they hand you the exact step to fix it. Check it any time under Help → Check AI editing readiness.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "native-desktop-app",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Maude is now a desktop app",
+      "summary": "Install Maude for macOS or Windows — download, open, sign in with GitHub, and start designing, with no terminal at any step. It keeps itself up to date in the background: when a new version is ready you'll see “Maude updated · restart to apply,” and one click puts you on the latest. No npm, no command line.",
+      "learnMore": "https://maude.sh/desktop",
+      "surface": "design-ui"
+    },
+    {
+      "id": "native-acp-chat-sidepanel",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Chat with Claude inside Maude",
+      "summary": "Open the Assistant panel (the ✦ in the menubar, or ⌘⇧A) and ask Claude for an edit, a critique, or a new screen — it changes the canvas while you watch, no terminal needed. It runs on your own installed Claude on your Pro/Max subscription: no login inside Maude, never metered API billing. Open several chats and work on different things at once — each runs in the background, so switching never interrupts a running one, and a switcher shows which chats are running, open, or saved (start a new one or delete an old one). Chats are saved per project and reopen with their history. Pick the model and effort, watch what Claude is doing live, and get a notification when a turn finishes while you're looking elsewhere. Native app only.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "branch-scoped-live-multiplayer",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Work together, live, in the same version",
+      "summary": "When you and a teammate are in the same shared version, you now collaborate live — you see each other's cursors, annotations, comments, and each other's canvas changes as they happen, like Figma. Your canvas list shows only the version you're in, so there's no clutter; switch to a teammate's draft to join them. When someone — or the AI agent — is editing a canvas, a soft badge in their colour gives you a heads-up so you don't step on each other (it's never a lock, and you can always keep working). The AI's \"is editing\" cue now reaches everyone on the team, new canvases show up instantly in a second tab and via Get latest for teammates, and live updates now slot in seamlessly without the presence avatars blinking.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "native-onboarding-switcher-collab-tour",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Get started & switch projects — no terminal",
+      "summary": "Open Maude for the first time and a friendly setup walks you in: sign in with GitHub to open or create a shared project, pick a local folder, or connect to a team hub — no terminal, ever. A new switcher at the bottom of the sidebar lets you jump between projects and between the Shared version and your own drafts, all in plain words. Happy with a draft? \"Add this draft to the Shared version\" folds it in, publishes, and tidies up in one click. And a re-openable \"How sharing works\" tour teaches the simple Save changes locally → Publish for everyone → Pull changes cycle — with a picture showing that being in a canvas together just happens, automatically.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "present-mode-and-chrome-toggles",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Presentation Mode — just your artboards",
+      "summary": "View ▸ Presentation Mode now clears everything but your work: the menubar, sidebar, and panels disappear along with the mini-map, zoom controls, tool palette, annotations, and comment pins — leaving a clean canvas perfect for a screenshot or a demo. Press Esc or the floating Exit button to bring it all back. The presentation button in the canvas toolbar enters it too. Prefer to hide just the floating extras? Two new View toggles — Minimap and Zoom controls — switch those off on their own. Nothing is lost: leaving Presentation Mode restores exactly what you had.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "sign-in-with-github",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "Sign in with GitHub — projects without the terminal",
+      "summary": "Sign in with GitHub right from the account bar (just enter a short code — your access stays in your computer's keychain). Start a New project and Maude creates a private GitHub project and opens it; Pull a local copy brings down one of your projects to a folder you choose; Share invites a teammate by username. Publish and Get latest now use your sign-in directly, and you'll get a nudge when a teammate has shared new work. If you both changed the same canvas, Get latest opens a visual resolver — Keep mine, theirs, or both (both saves your version as a copy, so nothing is ever lost) — and finishes the merge for you.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "changes-panel-canvas-grouping",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "improvement",
+      "title": "A cleaner Changes panel, grouped by canvas",
+      "summary": "Panning or zooming a canvas no longer counts as a change to save — the Changes panel now reflects your actual work, not your mouse. And changes are grouped by canvas: each one lists its supporting files (Layout & settings, Annotations) tucked underneath, so a single checkbox saves a canvas and everything that travels with it as one unit.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "in-ui-git-layer",
+      "version": "0.31.0",
+      "date": "2026-06-23",
+      "kind": "feature",
+      "title": "See, save & publish — no terminal",
+      "summary": "A new Changes panel (View ▸ Changes, or ⌘⇧G) shows exactly what you've changed, with live colour-coded badges right in the file tree. Save a version with a message, Publish it to share with your team, or Get the latest they published — all in plain language, never a command line. And when a canvas changed, compare a real rendered before & after: both sides live with locked zoom & pan, an overlay wipe, and a simple Keep mine / theirs / both picker so nothing is ever lost. Open History to browse every saved version of a canvas and preview any one of them — and pick which past version to compare against, right in the diff.",
+      "surface": "design-ui"
+    },
     {
       "id": "in-canvas-token-editor",
       "version": "0.30.0",

package/apps/studio/ws.ts

@@ -3,6 +3,7 @@
 
 import type { ServerWebSocket, WebSocketHandler } from 'bun';
 
+import type { Acp } from './acp/index.ts';
 import type { Activity } from './activity.ts';
 import type { Api } from './api.ts';
 import type { Collab, RoomConn } from './collab/index.ts';
@@ -36,6 +37,15 @@ export type WsData =
       id: string;
       remote: string;
       kind: 'canvas-hmr';
+    }
+  | {
+      // Phase 31 (DDR-123) — ACP chat bridge socket. Main origin ONLY,
+      // loopback-guarded at upgrade (server.ts); NEVER opened from the canvas
+      // origin. Carries the JSON chat protocol (prompt / cancel ↔ update /
+      // turn-end), bridged to the user's own `claude` via createAcp.
+      id: string;
+      remote: string;
+      kind: 'acp';
     };
 
 /**
@@ -82,7 +92,8 @@ export function createWs(
   api: Api,
   inspect: Inspect,
   collab: Collab,
-  activity: Activity
+  activity: Activity,
+  acp: Acp
 ): Ws {
   const clients = new Set<ServerWebSocket<WsData>>();
 
@@ -143,6 +154,26 @@ export function createWs(
   // emits, so this is a no-op for unlinked projects.
   ctx.bus.on('sync:status', (payload: unknown) => broadcast({ type: 'sync:status', payload }));
 
+  // Phase 27 Task 5 (E2) — live dirty-state. git/watch.ts recomputes gitStatus on
+  // a versionable file change (trailing-debounced) and emits 'git-status'. Only
+  // the same-origin inspector clients (the shell) get it — it carries the changed-
+  // file list, so it stays off the untrusted canvas-origin feed like the other
+  // privileged broadcasts. Drives the Changes-panel count + tree M/A/D badges.
+  ctx.bus.on('git-status', (payload: unknown) => broadcast({ type: 'git-status', payload }));
+
+  // Phase 30 — live canvas-list refresh. api.createCanvas / deleteCanvas emit
+  // this; inspector clients (the shell) re-read the branch-scoped tree via
+  // /_index-data. Loopback-only (same dev-server) — cross-machine peers get a
+  // new canvas through git "Get latest", not this event.
+  ctx.bus.on('canvas-list-update', (payload: unknown) =>
+    broadcast({ type: 'canvas-list-update', payload })
+  );
+
+  // Phase 31 (DDR-123) — `/design:chat` → `maude design chat-open` → POST
+  // /_api/acp/focus emits this; the shell (app.jsx, native-only) opens the
+  // Assistant panel. Inspector clients only — same-origin shell, like the rest.
+  ctx.bus.on('acp-focus', () => broadcast({ type: 'acp-focus' }));
+
   // HMR broadcaster — turns fs:any change events into `canvas-hmr` messages.
   // The iframe-side client (in _shell.html) decides reload strategy from `mode`.
   // Uses broadcastHmr so the segregated canvas origin's HMR-only sockets get it.
@@ -189,6 +220,10 @@ export function createWs(
         clients.add(ws);
         return;
       }
+      if (ws.data.kind === 'acp') {
+        acp.onOpen(ws);
+        return;
+      }
       clients.add(ws);
       // Snapshot carries the inspector state AND the activity map so a client
       // opening mid-edit seeds its overlay state (Phase 13). Inspector-origin
@@ -197,6 +232,10 @@ export function createWs(
       send(ws, { type: 'snapshot', state: inspect.state, activity: activity.state });
     },
     async close(ws) {
+      if (ws.data.kind === 'acp') {
+        acp.onClose(ws);
+        return;
+      }
       if (ws.data.kind === 'collab') {
         const binding = collabConns.get(ws.data.id);
         if (binding) {
@@ -217,6 +256,10 @@ export function createWs(
       // HMR-only canvas-origin socket: never accepts inbound messages (the
       // canvas iframe only listens for canvas-hmr; it never sends).
       if (ws.data.kind === 'canvas-hmr') return;
+      if (ws.data.kind === 'acp') {
+        acp.onMessage(ws, raw);
+        return;
+      }
       if (ws.data.kind === 'collab') {
         const binding = collabConns.get(ws.data.id);
         if (!binding) return;

package/cli/commands/design.mjs

@@ -43,6 +43,7 @@ const BIN_VERBS = new Set([
   'to-lottie',
   'read-annotations',
   'annotate',
+  'chat-open',
 ]);
 
 // Bin verbs that boot the dev-server (directly, or by shelling into server-up.sh).

package/cli/lib/gitignore-block.mjs

@@ -22,19 +22,32 @@ export const END_MARKER = '# maude:end';
  */
 export function buildBlock(designRel = '.design') {
   const root = designRel.replace(/\/+$/, '');
+  // The canonical IGNORED set is the DDR-115 runtime-state taxonomy — kept in
+  // lockstep with `apps/studio/git/service.ts` (isMaudeRuntimeState backstop)
+  // and the repo's own `.gitignore`. VERSIONED content (canvases, `.meta.json`,
+  // `*.annotations.svg`, `system/**`, `config.json`) is deliberately absent.
   const lines = [
     BEGIN_MARKER,
-    '# Maude design plugin runtime — gitignored even in linked mode (DDR-056).',
-    `${root}/_state/`, // binary CRDT logs (regenerable from hub)
+    '# Maude design plugin runtime — gitignored even in linked mode (DDR-056/DDR-115).',
+    // Per-machine runtime JSON.
     `${root}/_server.json`,
     `${root}/_server.log`,
+    `${root}/_server.lock`,
     `${root}/_active.json`,
     `${root}/_sync.json`, // linked-mode offline/sync status (Task 8)
+    `${root}/_preflight.json`,
+    `${root}/_locator.json`, // regenerable slug→path index
+    `${root}/_export-history.json`,
+    // Per-machine / per-user dirs.
+    `${root}/_state/`, // binary CRDT logs (regenerable from hub)
     `${root}/_history/`,
     `${root}/_trash/`, // soft-deleted canvases (recoverable locally — Phase 22 delete)
     `${root}/_draw/`, // draw-agent proof canvases (regenerable — Phase 25)
-    `${root}/_canvas-state/`, // per-machine canvas undo/redo + scratch state
+    `${root}/_smoke/`, // batch-screenshot output (regenerable — DDR-021)
+    `${root}/_canvas-state/`, // per-machine canvas scratch + camera (`*.view.json`, DDR-115)
     `${root}/_chat/`, // ACP transcripts (per-machine)
+    `${root}/_untrusted/`, // hub-synced untrusted file mirror (DDR-054)
+    `${root}/_comments/`, // hub-sync-only collab comments (DDR-102/DDR-115 — never git)
     END_MARKER,
   ];
   return `${lines.join('\n')}\n`;

package/cli/lib/gitignore-block.test.mjs

@@ -31,17 +31,29 @@ test('buildBlock includes the runtime paths and is marker-wrapped', () => {
   for (const p of [
     '.design/_state/',
     '.design/_server.json',
+    '.design/_server.log',
+    '.design/_server.lock',
     '.design/_active.json',
     '.design/_sync.json',
+    '.design/_preflight.json',
+    '.design/_locator.json',
+    '.design/_export-history.json',
     '.design/_history/',
+    '.design/_trash/',
     '.design/_draw/',
+    '.design/_smoke/',
+    '.design/_canvas-state/', // covers the DDR-115 `<slug>.view.json` camera
     '.design/_chat/',
+    '.design/_untrusted/',
+    '.design/_comments/', // hub-sync-only (DDR-115)
   ]) {
     assert.ok(block.includes(p), `missing ${p}`);
   }
-  // Committed artifacts must NOT be ignored.
+  // VERSIONED content must NOT be ignored (DDR-115 taxonomy).
   assert.ok(!block.includes('.design/config.json'));
   assert.ok(!/\.design\/\*\.html/.test(block));
+  // Annotations are versioned — never in the ignore block.
+  assert.ok(!/annotations\.svg/.test(block), 'annotations must stay versioned');
 });
 
 test('buildBlock honors a custom design root', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -20,7 +20,9 @@
     "start": "bun run apps/studio/server.ts",
     "dev": "bun run apps/studio/server.ts --port 4555",
     "dev:site": "pnpm --filter @maude/site dev --port 4398",
-    "build": "pnpm -r --if-present run build",
+    "dev:desktop": "PATH=\"$HOME/.cargo/bin:$PATH\" pnpm --filter @maude/desktop tauri dev",
+    "build:desktop": "PATH=\"$HOME/.cargo/bin:$PATH\" pnpm --filter @maude/desktop tauri build",
+    "build": "pnpm -r --if-present --filter '!@maude/desktop' run build",
     "build:binary": "bun run apps/studio/build.ts --release",
     "test": "node --test --test-reporter=spec cli/**/*.test.mjs",
     "test:dev-server": "cd apps/studio && bun test",
@@ -41,13 +43,13 @@
     "prepublishOnly": "bash scripts/check-version-parity.sh && bash apps/studio/bin/check-runtime-bundles.sh"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.30.0",
-    "@1agh/maude-darwin-x64": "0.30.0",
-    "@1agh/maude-linux-arm64": "0.30.0",
-    "@1agh/maude-linux-arm64-musl": "0.30.0",
-    "@1agh/maude-linux-x64": "0.30.0",
-    "@1agh/maude-linux-x64-musl": "0.30.0",
-    "@1agh/maude-win32-x64": "0.30.0"
+    "@1agh/maude-darwin-arm64": "0.32.0",
+    "@1agh/maude-darwin-x64": "0.32.0",
+    "@1agh/maude-linux-arm64": "0.32.0",
+    "@1agh/maude-linux-arm64-musl": "0.32.0",
+    "@1agh/maude-linux-x64": "0.32.0",
+    "@1agh/maude-linux-x64-musl": "0.32.0",
+    "@1agh/maude-win32-x64": "0.32.0"
   },
   "files": [
     "cli",

package/plugins/design/dependencies.json

@@ -170,6 +170,23 @@
       "fallbackBehavior": "Discovery + critic-panel rounds fall back to numbered-prose chat. Slower, fewer options per round, no preview side-pane.",
       "usedBy": ["skills/design-system/SKILL.md", "commands/setup-ds.md", "commands/new.md"],
       "docsUrl": "https://docs.claude.com/en/docs/claude-code"
+    },
+    {
+      "id": "claude",
+      "type": "cli",
+      "hardness": "soft",
+      "check": {
+        "command": "claude --version",
+        "expectExit": 0
+      },
+      "install": {
+        "preferred": "npm i -g @anthropic-ai/claude-code",
+        "darwin": "brew install --cask claude-code"
+      },
+      "autoInstall": false,
+      "fallbackBehavior": "Phase 31 (DDR-123) — the native ACP chat sidepanel drives the user's OWN installed `claude` CLI on their Pro/Max subscription (never API billing). Without it the panel shows the not-connected explainer ('run `claude` in a terminal and `/login`'); every other design surface is unaffected.",
+      "usedBy": ["dev-server/acp/probe.ts", "dev-server/acp/bridge.ts"],
+      "docsUrl": "https://docs.claude.com/en/docs/claude-code"
     }
   ]
 }

package/plugins/design/templates/_shell.html

@@ -170,7 +170,13 @@
       // Phase 13.1 / DDR-077 — error-resilient HMR while an agent edits. Hoisted
       // here so the HMR client (below) can soft-reload the canvas module instead
       // of location.reload()-ing into a half-saved (broken) build.
-      const canvasUrl = canvasRel ? ('/' + designRel + '/' + canvasRel) : null;
+      // Phase 27 (E2) — DiffView "before" pane. `?sha=<ref>` renders the canvas
+      // AT a past version (the dev-server's serveHistoricalCanvas builds from
+      // `git show <sha>:<path>`). Baked into the module URL so both the initial
+      // import and the HMR soft-reload carry it.
+      const shaParam = params.get('sha');
+      const canvasQuery = shaParam ? ('?sha=' + encodeURIComponent(shaParam)) : '';
+      const canvasUrl = canvasRel ? ('/' + designRel + '/' + canvasRel + canvasQuery) : null;
       const myFileKey = canvasRel ? (designRel + '/' + canvasRel) : null;
       // True while an `ai-activity` entry is live for THIS canvas (an agent is
       // running /design:edit|new on it). Mirrors ai-banner's gate: parent relays
@@ -202,13 +208,15 @@
 
       // Soft reload — re-import the canvas module (cache-busted) and swap it in
       // via the runtime, holding the last good render on a build/import error
-      // (no white flash). Only used when an agent is editing; manual edits keep
-      // the plain location.reload() below.
+      // (no white flash). Phase 30 (F4): used for EVERY canvas-body change while
+      // the runtime is mounted — agent edits, manual edits, AND cross-peer synced
+      // writes — so presence + in-canvas state survive. Falls back to the plain
+      // location.reload() below only when no runtime is present.
       function softReload(version) {
         if (!canvasUrl) { location.reload(); return; }
         const rt = window.__maudeCanvasRuntime;
         if (!rt || !rt.remount) { location.reload(); return; }
-        import(canvasUrl + '?v=' + (version || Date.now()))
+        import(canvasUrl + (canvasUrl.includes('?') ? '&' : '?') + 'v=' + (version || Date.now()))
           .then((mod) => {
             if (mod && typeof mod.default === 'function') {
               rt.remount(mod.default);
@@ -344,10 +352,24 @@
                   // read the parent-verified local (NOT a canvas-writable global)
                   if (Date.now() - lastCssOptimisticAt < 1500) return;
                 }
-                // Phase 13.1 / DDR-077 — when an agent is live-editing, soft-
-                // reload (hold last good on a broken intermediate). Manual edits
-                // (or no runtime yet) keep the plain, immediate hard reload.
-                if (agentEditing && window.__maudeCanvasRuntime && window.__maudeCanvasRuntime.remount) {
+                // Phase 30 (F4) — prefer an in-place hot-swap for ANY canvas-body
+                // (`module`) change whenever the canvas runtime is mounted: the
+                // soft-reload re-imports the module and remounts only the canvas
+                // content, KEEPING the iframe — and thus the live CollabProvider
+                // + presence cursors/avatars — mounted (the collab session is a
+                // module-level singleton that survives the remount, use-collab.tsx).
+                // This covers cross-peer SYNCED writes, which arrive as a `module`
+                // change with NO `ai-activity` entry: a teammate's edit must update
+                // seamlessly, never blink everyone's presence (and scroll / tool
+                // mode / undo survive too). It also keeps the Phase 13.1 / DDR-077
+                // hold-last-good behaviour for agent edits. (`agentEditing` is still
+                // tracked from ai-activity above but no longer gates the swap — any
+                // module change to the live canvas hot-swaps.) `hard` (_lib rebuild)
+                // is global and ALWAYS full-reloads. With no runtime (gallery
+                // thumbnails / ?comments=0) we full-reload; softReload itself also
+                // falls back to location.reload() when the re-import yields no usable
+                // default export.
+                if (msg.mode === 'module' && window.__maudeCanvasRuntime && window.__maudeCanvasRuntime.remount) {
                   softReload(msg.version);
                 } else {
                   location.reload();