@1agh/maude 1.0.11 → 1.3.0

package/apps/studio/sync/writer-registry.ts

@@ -0,0 +1,236 @@
+// The executable half of the persistent-writer registry — DDR-241, plan T6.
+//
+// `docs/architecture/project-writer-registry.md` explains every writer; this
+// module is the part a test can hold the code to. Every `/_api/*` route the
+// studio serves is classified here by HOW its persistent effect reaches the
+// project in accepted-revisions mode. A route that is not listed fails
+// `test/sync-writer-registry.test.ts` — a new mutating route cannot ship
+// without someone deciding which lane carries it.
+//
+// Classes:
+//   read        — no persistent project effect.
+//   lane        — rewrites canvas source/meta/annotations/comments; reaches the
+//                 project as a `lane.replace` proposal (watcher import with the
+//                 base announced by `activity:suppress`, or an API hook that
+//                 hands the runtime its base).
+//   structural  — canvas/folder create, move, delete: one manifest action.
+//   file-plane  — assets, media sidecars, support files: the file plane's own
+//                 CAS journal (DDR-226), not the canvas kernel (DDR-241 §8).
+//   git         — operates on the checkout's Git graph; never a project action.
+//   local       — this machine only: credentials, caches, jobs, activity, UI.
+
+export type WriterClass = 'read' | 'lane' | 'structural' | 'file-plane' | 'git' | 'local';
+
+export interface WriterEntry {
+  class: WriterClass;
+  /** Registry row(s) in project-writer-registry.md. */
+  rows?: string;
+  /** How the effect travels in accepted mode (lane / structural only). */
+  via?: string;
+  /** The test that proves it (lane / structural only). */
+  test?: string;
+}
+
+const LANE_SOURCE = {
+  class: 'lane',
+  via: 'source write announced by activity:suppress → watcher import → html lane.replace with the announced base',
+  test: 'test/sync-accepted-projection.test.ts',
+} as const;
+
+export const WRITER_REGISTRY: Record<string, WriterEntry> = {
+  // --- canvas source edits (S01–S18, V01–V10)
+  '/_api/edit-text': { ...LANE_SOURCE, rows: 'S01' },
+  '/_api/edit-css': { ...LANE_SOURCE, rows: 'S02' },
+  '/_api/edit-attr': { ...LANE_SOURCE, rows: 'S03' },
+  '/_api/reorder': { ...LANE_SOURCE, rows: 'S04' },
+  '/_api/delete-element': { ...LANE_SOURCE, rows: 'S05' },
+  '/_api/insert-element': { ...LANE_SOURCE, rows: 'S06' },
+  '/_api/duplicate-element': { ...LANE_SOURCE, rows: 'S07' },
+  '/_api/convert-to-absolute': { ...LANE_SOURCE, rows: 'S08' },
+  '/_api/detach-component': { ...LANE_SOURCE, rows: 'S09' },
+  '/_api/insert-artboard': { ...LANE_SOURCE, rows: 'S10' },
+  '/_api/duplicate-artboard': { ...LANE_SOURCE, rows: 'S11' },
+  '/_api/delete-artboard': { ...LANE_SOURCE, rows: 'S12' },
+  '/_api/resize-artboard': { ...LANE_SOURCE, rows: 'S13' },
+  '/_api/set-artboard-hug': { ...LANE_SOURCE, rows: 'S14' },
+  '/_api/set-artboard-style': { ...LANE_SOURCE, rows: 'S15' },
+  '/_api/set-artboard-kind': { ...LANE_SOURCE, rows: 'S16' },
+  '/_api/set-artboard-label': { ...LANE_SOURCE, rows: 'S16' },
+  '/_api/set-artboard-guides': { ...LANE_SOURCE, rows: 'S17' },
+  '/_api/set-artboard-print': { ...LANE_SOURCE, rows: 'S17' },
+  '/_api/reorder-revert': { ...LANE_SOURCE, rows: 'S18' },
+  '/_api/retime-sequence': { ...LANE_SOURCE, rows: 'V01' },
+  '/_api/remove-sequence': { ...LANE_SOURCE, rows: 'V02' },
+  '/_api/insert-sequence': { ...LANE_SOURCE, rows: 'V03' },
+  '/_api/reorder-sequence': { ...LANE_SOURCE, rows: 'V04' },
+  '/_api/toggle-hide': { ...LANE_SOURCE, rows: 'V05' },
+  '/_api/edit-array-src': { ...LANE_SOURCE, rows: 'V06' },
+  '/_api/clip-edit': { ...LANE_SOURCE, rows: 'V07–V10' },
+  // --- shared meta, annotations, comments (S19, S23, S24)
+  '/_api/canvas-meta': {
+    class: 'lane',
+    rows: 'S19',
+    via: 'onMetaChanged hook → meta lane.replace with the replaced file as base; camera/overlays/locked stay local',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/annotations': {
+    class: 'lane',
+    rows: 'S23',
+    via: 'onAnnotationsChanged hook → annotations lane.replace with the base the layer sent',
+    test: 'test/sync-accepted-projection.test.ts',
+  },
+  // --- accepted history (T27/T28)
+  '/_api/project/history': { class: 'read' },
+  '/_api/project/restore': {
+    class: 'lane',
+    rows: 'X15',
+    via: 'history.restore — a NEW action restoring the canvas lanes (not comments) to a revision',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/conflict': {
+    class: 'lane',
+    rows: 'X15',
+    via: 'mine: html lane.replace on top of the accepted version (a new action); theirs: accepted body back to disk',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/ai-action': {
+    class: 'lane',
+    rows: 'I02',
+    via: 'publish: the held AI stage as ONE history action (lane.replace ops); discard: accepted value back to disk',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/undo': {
+    class: 'lane',
+    rows: 'S18',
+    via: 'history.undo/redo — effect-aware compensation of one of this actor’s actions',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  // --- manifest (S20–S22)
+  '/_api/canvas': {
+    class: 'structural',
+    rows: 'S20',
+    via: 'create: cold start doc.create; delete: canvas-deleted → doc.delete; folders: dir.delete',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/fs-move': {
+    class: 'structural',
+    rows: 'S21',
+    via: 'retireForMove → doc.move; folders: proposeFolder dir.move',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/fs-mkdir': {
+    class: 'structural',
+    rows: 'S22',
+    via: 'proposeFolder dir.create before mkdir',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/design/init': {
+    class: 'structural',
+    rows: 'I12',
+    via: 'scaffolded canvases join by cold start doc.create',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  // --- file plane (S25–S30, I04–I11)
+  '/_api/photo-edit': { class: 'file-plane', rows: 'S25' },
+  '/_api/footage': { class: 'file-plane', rows: 'S26' },
+  '/_api/asset': { class: 'file-plane', rows: 'S27' },
+  '/_api/assets': { class: 'file-plane', rows: 'S27' },
+  '/_api/import-asset': { class: 'file-plane', rows: 'S28/I08' },
+  '/_api/import-brand': { class: 'file-plane', rows: 'S28/I07' },
+  '/_api/figma/import': { class: 'file-plane', rows: 'I04/I05 (canvases join by cold start)' },
+  '/_api/figma/explode': { class: 'file-plane', rows: 'I04/I05 (canvases join by cold start)' },
+  '/_api/generate-jobs': { class: 'file-plane', rows: 'S29' },
+  '/_api/generate/audio-reuse': { class: 'file-plane', rows: 'S30' },
+  '/_api/stickers': { class: 'file-plane', rows: 'S27' },
+  '/_api/generate/prefs': { class: 'local', rows: 'S31 (config.assign schema gap)' },
+  // --- git (H09/H10)
+  '/_api/git/branch': { class: 'git', rows: 'H10' },
+  '/_api/git/branches': { class: 'read' },
+  '/_api/git/checkout': { class: 'git', rows: 'H09' },
+  '/_api/git/commit': { class: 'git', rows: 'H10' },
+  '/_api/git/diff': { class: 'read' },
+  '/_api/git/discard': { class: 'git', rows: 'H09' },
+  '/_api/git/fetch': { class: 'git', rows: 'H10' },
+  '/_api/git/fold': { class: 'git', rows: 'H09' },
+  '/_api/git/log': { class: 'read' },
+  '/_api/git/pull': { class: 'git', rows: 'H09' },
+  '/_api/git/push': { class: 'git', rows: 'H10' },
+  '/_api/git/resolve': { class: 'git', rows: 'H09' },
+  '/_api/git/status': { class: 'read' },
+  '/_api/github/clone': { class: 'git', rows: 'H10' },
+  '/_api/github/create-project': { class: 'local', rows: 'I12' },
+  '/_api/github/create-repo': { class: 'local' },
+  '/_api/github/identity': { class: 'local' },
+  '/_api/github/invite': { class: 'local' },
+  '/_api/github/repos': { class: 'read' },
+  '/_api/project/create-local': { class: 'local', rows: 'I12' },
+  '/_api/projects/prepare': {
+    class: 'local',
+    rows: 'H13 (credential + project description for a managed copy)',
+  },
+  // --- reads
+  '/_api/canvas-source': { class: 'read' },
+  '/_api/comp-clips': { class: 'read' },
+  '/_api/component-map': { class: 'read' },
+  '/_api/edit-scope': { class: 'read' },
+  '/_api/git-committers': { class: 'read' },
+  '/_api/git-user': { class: 'read' },
+  '/_api/preflight': { class: 'read' },
+  '/_api/setup-readiness': { class: 'read' },
+  '/_api/whats-new': { class: 'read' },
+  '/_api/figma/probe': { class: 'read' },
+  '/_api/figma/status': { class: 'read' },
+  '/_api/generate/providers': { class: 'read' },
+  '/_api/generate/audio-search': { class: 'read' },
+  '/_api/export-history': { class: 'read' },
+  // --- this machine only
+  '/_api/acp/activity': { class: 'local' },
+  '/_api/acp/attachment': { class: 'local' },
+  '/_api/acp/chat': { class: 'local' },
+  '/_api/acp/chats': { class: 'local' },
+  '/_api/acp/focus': { class: 'local' },
+  '/_api/acp/running': { class: 'local' },
+  '/_api/acp/status': { class: 'local' },
+  '/_api/ai': { class: 'local', rows: 'I02' },
+  '/_api/ai/end': { class: 'local', rows: 'I02' },
+  '/_api/ai/heartbeat': { class: 'local', rows: 'I02' },
+  '/_api/ai/start': { class: 'local', rows: 'I02' },
+  '/_api/claude/install': { class: 'local' },
+  '/_api/claude/install-status': { class: 'local' },
+  '/_api/claude/signin': { class: 'local' },
+  '/_api/claude/signin-cancel': { class: 'local' },
+  '/_api/claude/signin-status': { class: 'local' },
+  '/_api/cloud/attach': { class: 'local' },
+  '/_api/cloud/attach/code': { class: 'local' },
+  '/_api/cloud/detach': { class: 'local' },
+  '/_api/cloud/history': { class: 'read' },
+  '/_api/cloud/projects': { class: 'read' },
+  '/_api/cloud/signin/poll': { class: 'local' },
+  '/_api/cloud/signin/start': { class: 'local' },
+  '/_api/cloud/signout': { class: 'local' },
+  '/_api/cloud/status': { class: 'read' },
+  '/_api/debug-bundle': { class: 'local' },
+  '/_api/export': { class: 'local' },
+  '/_api/export-assemble': { class: 'local' },
+  '/_api/export-jobs': { class: 'local' },
+  '/_api/export-jobs/download': { class: 'local' },
+  '/_api/export-warmup': { class: 'local' },
+  '/_api/figma/connect': { class: 'local' },
+  '/_api/generate/keyframe-model': { class: 'local' },
+  '/_api/generate/keys': { class: 'local' },
+  '/_api/generate/whisper-model': { class: 'local' },
+  '/_api/hub/link': { class: 'local' },
+  '/_api/report': { class: 'local' },
+  '/_api/report-fallback': { class: 'local' },
+  '/_api/shell-shot': { class: 'local' },
+  '/_api/sync/cancel-assets': { class: 'local' },
+  '/_api/sync/ownership': { class: 'local' },
+  '/_api/sync/resync': { class: 'local', rows: 'X16' },
+  '/_api/sync/offline': { class: 'local', rows: 'T19 (pull the whole file plane now)' },
+  '/_api/sync/settings': { class: 'local' },
+  '/_api/sync/trash': { class: 'local', rows: 'X15 (restore re-enters through cold start)' },
+  '/_api/timeline-media': { class: 'local' },
+  '/_api/ui-prefs': { class: 'local' },
+  '/_api/workspace/disclosure': { class: 'local' },
+  '/_api/workspace/sign-in': { class: 'local' },
+};

package/apps/studio/text-caret.ts

@@ -76,6 +76,41 @@ export function placeCaretAt(
   }
 }
 
+/**
+ * Collapse an ENTRY select-all to the end of the content, if that is what the
+ * selection still is. issue-106: keyboard entry into a text surface (select the
+ * stroke, press Enter) leaves `placeCaretAt`'s select-all fallback in place, so
+ * the first keystroke replaces the whole body — which is exactly what the
+ * retype/rename convention wants for a typed CHARACTER, but never for
+ * Shift+Enter, whose entire documented meaning is "add a new line". Without
+ * this, Shift+Enter deleted the note and left a blank line in its place.
+ *
+ * Deliberately narrow: only a selection whose boundaries are still BOTH ends of
+ * the editable is collapsed. A user's own drag-selection or a partial range is
+ * left alone, so ordinary "replace the selected words" editing keeps native
+ * semantics. Returns true when it collapsed something.
+ */
+export function collapseEntrySelectAll(editable: HTMLElement, win: Window): boolean {
+  try {
+    const sel = win.getSelection();
+    if (!sel || sel.rangeCount === 0 || sel.isCollapsed) return false;
+    const cur = sel.getRangeAt(0);
+    const all = editable.ownerDocument.createRange();
+    all.selectNodeContents(editable);
+    // Range.START_TO_START / END_TO_END via the instance so no global lookup is
+    // needed (the editable may live in another document/realm).
+    if (cur.compareBoundaryPoints(cur.START_TO_START, all) !== 0) return false;
+    if (cur.compareBoundaryPoints(cur.END_TO_END, all) !== 0) return false;
+    all.collapse(false); // to the end
+    sel.removeAllRanges();
+    sel.addRange(all);
+    return true;
+  } catch {
+    /* selection API unavailable */
+    return false;
+  }
+}
+
 const STYLE_ID = 'maude-caret-css';
 
 const CARET_CSS = `

package/apps/studio/undo-hud.tsx

@@ -1,94 +1,16 @@
-/**
- * @file       undo-hud.tsx — top-right toast announcing the last undo edit
- * @scope      apps/studio/undo-hud.tsx
- * @purpose    Subscribes to `useUndoStack().lastLabel` + `.lastTick` and
- *             surfaces a 1.2 s aria-live toast so the user (and a screen
- *             reader) knows which edit just got pushed / undone / redone.
- *
- * a11y. The toast renders into `aria-live="polite"` so a screen reader
- * announces "Undo: move 3 artboards" without interrupting in-flight speech.
- * Pointer events are disabled — the HUD is informational only and must
- * never absorb clicks meant for the canvas behind it.
- */
-
-import { useEffect, useState } from 'react';
-
+/** Announces canvas edit/undo/redo operations through the shared toast stack. */
+import { useEffect, useRef } from 'react';
+import { showCanvasToast } from './canvas-notifications.tsx';
 import { useUndoStackOptional } from './use-undo-stack.tsx';
 
-const HUD_CSS = `
-.dc-undo-hud {
-  position: fixed;
-  top: 16px;
-  right: 16px;
-  z-index: 7;
-  pointer-events: none;
-  padding: 6px 10px;
-  background: var(--maude-chrome-bg-2, rgba(20, 20, 20, 0.85));
-  color: var(--maude-chrome-fg-1, rgba(255, 255, 255, 0.85));
-  border: 1px solid var(--maude-chrome-border, rgba(255, 255, 255, 0.08));
-  border-radius: 6px;
-  font: 11px var(--maude-chrome-font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
-  letter-spacing: 0.02em;
-  user-select: none;
-  opacity: 0;
-  transform: translateY(-4px);
-  transition: opacity 200ms linear, transform 200ms ease-out;
-}
-.dc-undo-hud[data-visible="true"] {
-  opacity: 1;
-  transform: translateY(0);
-  transition-duration: 120ms;
-}
-@media (prefers-reduced-motion: reduce) {
-  .dc-undo-hud {
-    transition-duration: 1ms !important;
-  }
-}
-`.trim();
-
-function ensureStyles(): void {
-  if (typeof document === 'undefined') return;
-  if (document.getElementById('dc-undo-hud-css')) return;
-  const s = document.createElement('style');
-  s.id = 'dc-undo-hud-css';
-  s.textContent = HUD_CSS;
-  document.head.appendChild(s);
-}
-
-/** Auto-dismiss timeout — matches the post-Wave-3 toast cadence. */
-const DISMISS_MS = 1200;
-
 export function UndoHud() {
-  ensureStyles();
   const undo = useUndoStackOptional();
-  const [visible, setVisible] = useState(false);
-
-  // Bump visibility every time `lastTick` increments — same tick value means
-  // the underlying state did NOT change (provider's no-op fallback returns
-  // `lastTick: 0` constantly, so the HUD stays hidden when no provider).
-  const tick = undo.lastTick;
-  const label = undo.lastLabel;
-
+  const lastTick = useRef(0);
   useEffect(() => {
-    if (tick === 0 || !label) {
-      setVisible(false);
-      return;
-    }
-    setVisible(true);
-    const id = window.setTimeout(() => setVisible(false), DISMISS_MS);
-    return () => window.clearTimeout(id);
-  }, [tick, label]);
-
-  return (
-    <div
-      className="dc-undo-hud"
-      data-visible={visible ? 'true' : 'false'}
-      role="status"
-      aria-live="polite"
-      aria-atomic="true"
-    >
-      {label ?? ''}
-    </div>
-  );
+    if (!undo.lastTick || !undo.lastLabel || lastTick.current === undo.lastTick) return;
+    lastTick.current = undo.lastTick;
+    showCanvasToast(undo.lastLabel, 'undo');
+  }, [undo.lastTick, undo.lastLabel]);
+  return null;
 }
 UndoHud.displayName = 'UndoHud';

package/apps/studio/use-canvas-media-drop.tsx

@@ -22,6 +22,9 @@
  */
 
 import { useEffect } from 'react';
+import { showCanvasToast } from './canvas-notifications.tsx';
+
+export { showCanvasToast } from './canvas-notifications.tsx';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Pure helpers (exported for unit tests)
@@ -194,25 +197,6 @@ export async function uploadAsset(file: Blob): Promise<{ path: string } | { erro
 // Transient toast (no React state — self-contained DOM, mirrors ensure*Styles)
 
 const TOAST_CSS = `
-.dc-media-toast {
-  position: fixed;
-  left: 50%;
-  bottom: 108px;
-  transform: translateX(-50%);
-  z-index: 9;
-  max-width: 360px;
-  padding: 8px 14px;
-  border-radius: 8px;
-  background: #26262b;
-  color: #fff;
-  font-family: var(--maude-chrome-font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
-  font-size: 12px;
-  box-shadow: 0 8px 28px rgba(0,0,0,0.34);
-  opacity: 0;
-  transition: opacity 140ms ease;
-  pointer-events: none;
-}
-.dc-media-toast[data-show="1"] { opacity: 1; }
 /* Drop affordance — a focus-accent inset frame while a media drag is over the
    canvas, so the surface reads as a drop target. */
 .dc-media-dragover::after {
@@ -224,9 +208,6 @@ const TOAST_CSS = `
   border-radius: 12px;
   pointer-events: none;
 }
-@media (prefers-reduced-motion: reduce) {
-  .dc-media-toast { transition: none; }
-}
 /* feature-4 (2026-07-19) — sandbox-safe confirm dialog (window.confirm is
    silently blocked in the allow-modals-less canvas iframe). HUD-token styled. */
 .dc-confirm-backdrop {
@@ -364,22 +345,6 @@ export function canvasConfirm(
   });
 }
 
-/** Show a brief auto-dismissing toast in the canvas (e.g. an upload failure). */
-export function showCanvasToast(message: string): void {
-  if (typeof document === 'undefined') return;
-  ensureMediaStyles();
-  const el = document.createElement('div');
-  el.className = 'dc-media-toast';
-  el.setAttribute('role', 'status');
-  el.textContent = message;
-  document.body.appendChild(el);
-  requestAnimationFrame(() => el.setAttribute('data-show', '1'));
-  setTimeout(() => {
-    el.setAttribute('data-show', '0');
-    setTimeout(() => el.remove(), 200);
-  }, 2600);
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Hook
 
@@ -414,7 +379,7 @@ export async function uploadAndAnnounceMedia(
   const sizeMb = file.size / (1024 * 1024);
   const res = await uploadAsset(file);
   if ('error' in res) {
-    showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`);
+    showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`, 'error');
     return;
   }
   const snippet = mediaSnippet(mediaKind, res.path);

package/apps/studio/whats-new.json

@@ -1,6 +1,179 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "artboard-rename-and-files",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Rename artboards on the canvas; manage notes and images in the tree",
+      "summary": "Double-click an artboard’s name to rename it — everyone on the project sees the new name. Notes, styles, images and videos beside your canvases now have their own ⋯ menu: Rename…, Move to… and Delete. A file a canvas still uses is not moved or deleted from under it; Maude names the canvas that uses it instead.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "cloud-connect-starts-syncing",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "fix",
+      "title": "Connecting a project to Maude Cloud starts syncing right away again",
+      "summary": "Connect used to link the project and then ask you to restart Maude before anything synced. It syncs immediately now, a project that is not linked no longer greets you with a stale “Working offline” note, and a large video upload survives a dropped connection instead of failing.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "file-tree-rename-duplicate",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Rename and duplicate canvases and folders from the file tree",
+      "summary": "The ⋯ menu on a canvas now offers Rename… and Duplicate, and folders can be renamed in place. Teammates see the new name immediately — a canvas they have open follows the rename. Menus near the bottom of a long tree now open upward instead of off-screen, and after ⌘D the copy is what stays selected.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "open-team-project-no-folder",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Open your team’s project in one step",
+      "summary": "Invited to a project? Choose “Open a project you were invited to”, sign in to Maude Cloud or your team’s server with your email, pick the project and start designing — no folder to choose, no token, no Git. Maude keeps the project’s copy for you and lists it under “Open a team project…”.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "reliable-project-saving",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Every change saved, shared and undoable",
+      "summary": "In projects that save through accepted revisions, the status says “Saving…” until your team’s project has your change, History lists each action with its author, Undo takes back only your own action, two people changing the same thing end with the later change instead of a conflict, an unfinished AI edit waits for your decision, and large videos upload and download resumably.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "share-link-deeplink",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Share a link to any canvas",
+      "summary": "Copy a link that opens a canvas or file in the browser or Maude. After signing in, return to the shared file; links to another local project ask before switching.",
+      "learnMore": "https://maude.sh/docs/share-links",
+      "surface": "design-ui",
+      "tour": [
+        {
+          "target": "[data-testid=\"share-btn\"]",
+          "title": "Share this file",
+          "body": "Copy a web link, an app link, or a link for this Mac. You can also share another file from its row menu.",
+          "placement": "bottom",
+          "canvas": true
+        }
+      ]
+    },
+    {
+      "id": "native-codex-shared-workflows",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "feature",
+      "title": "Use Maude workflows in Codex",
+      "summary": "Install Maude’s design and flow plugins natively in Codex and use the shared workflows alongside Claude Code. The new guide covers setup, dependencies and the browser requirements for working with Design Studio.",
+      "learnMore": "https://maude.sh/docs/codex",
+      "surface": "design-ui"
+    },
+    {
+      "id": "shared-toast-stack-export-errors",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "improvement",
+      "title": "Notifications stack and clear themselves",
+      "summary": "Export updates, canvas messages and Undo now share a stack that expands when you hover or use the keyboard. Notifications dismiss automatically; long export errors stay short, with the complete message available on demand in export history.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "source-sync-preserves-valid-canvases",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "fix",
+      "title": "Safer canvas source syncing",
+      "summary": "Sync now holds incoming canvas code with syntax errors or duplicate declarations and warns you in the Sync panel. Concurrent edits preserve more unchanged code, and recovery copies help you recover local work when a conflicting update is held.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "sticky-notes-take-a-second-line",
+      "version": "1.3.0",
+      "date": "2026-09-15",
+      "kind": "fix",
+      "title": "Sticky notes take a second line",
+      "summary": "Shift+Enter in a sticky note could look like it did nothing. A note never grew, and its text is clipped at the card's edge, so on a full note the new line was inserted and then hidden — notes now grow as you type and keep that height. Opening a note from the keyboard selects all of its text so you can retype it, and Shift+Enter used to replace the lot; it now adds a line instead, while typing still replaces. And on a project synced to a workspace, what you have typed into an open note is no longer overwritten mid-keystroke when a collaborator edits the same note.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "pdf-export-print-safe-text",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "feature",
+      "title": "PDF exports a print shop will actually accept",
+      "summary": "A colour font or a faux-italic could come out of a PDF export in a form printers reject — the file looked perfect on screen, and you only found out when the print shop refused it. Maude now checks the fonts on every PDF export and warns you, by name, when one of them would fail preflight. Under Text you can also ask it to verify the fonts are properly embedded, or convert all text to curves so there is nothing left to break — bleed, crop marks and photo resolution all come through untouched.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "seed-progress-you-can-watch",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "improvement",
+      "title": "You can watch a large project sync",
+      "summary": "Linking a big project used to be a black box: the Sync panel counted files it had moved but never how many there were, so \"1 412\" looked the same whether it was a quarter done or finished — and `maude design status` reported only canvases, so a project with hundreds of files still on their way could read as fully synced. Now every surface shows the same thing: how many of how many have arrived, what is waiting, and what is stuck and why. The panel has a progress bar, `maude design status` has a files line (and a `--watch` mode), and the desktop app puts the count in the window title and tells you once when it finishes. Files the workspace will never take — something over its size limit, or an hourly upload allowance that is used up — now say so by name instead of retrying forever.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "images-arrive-again",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "fix",
+      "title": "Images arrive again on linked projects",
+      "summary": "On a project synced with a workspace, images and other project files could quietly never arrive — broken placeholders on the canvas while the Sync panel still said everything was synced. When a workspace asks Maude to slow down, it now waits as long as it was asked instead of retrying straight into the same wall, and the Sync panel says so in plain words: syncing is paused for a moment, nothing is lost, the rest arrives when the pause lifts.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "comments-stop-disappearing",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "fix",
+      "title": "Comments stop disappearing",
+      "summary": "On a project linked to a hub, a comment you had just added could vanish a few seconds later, leaving only the first one on the canvas — with nothing to undo and no sign anything had gone wrong. A new comment now reaches the shared project before it is written to disk, and Maude will not overwrite a comment it has not seen yet, so what you write stays put.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "comments-stop-duplicating",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "fix",
+      "title": "Comments stop duplicating, and resolve works",
+      "summary": "On a project linked to a hub, a comment could come back two, four, then eight times, and clicking resolve appeared to do nothing — every copy had to be dealt with separately, and new ones kept arriving. Maude now recognises the copies as one comment, so they collapse back to a single pin, and resolving or deleting one clears all of it. A project that already filled up with duplicates repairs itself the next time you open it.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "synced-canvases-stop-duplicating",
+      "version": "1.2.0",
+      "date": "2026-09-04",
+      "kind": "fix",
+      "title": "Synced canvases stop duplicating themselves",
+      "summary": "On a project linked to a hub, a canvas could come back with its whole contents pasted onto itself — twice, sometimes more — which broke the build and left the canvas unopenable. It happened when two people (or your machine and the hub) first picked up the same canvas at the same moment. Maude now recognises that exact shape and collapses it back to one copy, on the styles as well as the body. Moving a canvas into another folder also fixes up its imports instead of breaking them.",
+      "surface": "design-ui"
+    },
+    {
+      "date": "2026-09-04",
+      "id": "sync-recovers-after-the-workspace-sleeps",
+      "kind": "fix",
+      "summary": "If you left Maude alone for a while, your cloud workspace went to sleep and syncing quietly stopped — the indicator still said it was connected, and only pressing Resync got it moving again. Maude now notices when the connection has gone quiet, brings it back on its own, and only reports canvases as synced once they really are.",
+      "surface": "design-ui",
+      "title": "Sync comes back on its own",
+      "version": "1.2.0"
+    },
+    {
+      "date": "2026-09-04",
+      "id": "long-chats-no-longer-freeze",
+      "kind": "fix",
+      "summary": "In a project with a long chat history, Maude could slow to a crawl and stop responding for many minutes while using enormous amounts of memory — often needing a force-quit. Screenshots the agent took were being stored inside the chat history at full size, and every chat you opened re-read all of it. Chats now stay small and are read in fixed-size pieces, so a long history costs the same as a short one.",
+      "surface": "design-ui",
+      "title": "Long chats no longer freeze Maude",
+      "version": "1.2.0"
+    },
     {
       "id": "canvas-media-plays-on-linux",
       "version": "1.0.10",

package/cli/bin/maude.mjs

@@ -14,6 +14,7 @@ const COMMANDS = {
   init: () => import('../commands/init.mjs'),
   config: () => import('../commands/config.mjs'),
   cache: () => import('../commands/cache.mjs'),
+  codex: () => import('../commands/codex.mjs'),
   preflight: () => import('../commands/preflight.mjs'),
   design: () => import('../commands/design.mjs'),
   'scenario-report': () => import('../commands/scenario-report.mjs'),
@@ -21,6 +22,7 @@ const COMMANDS = {
   kg: () => import('../commands/kg.mjs'),
   help: () => import('../commands/help.mjs'),
   hub: () => import('../commands/hub.mjs'),
+  harness: () => import('../commands/harness.mjs'),
   version: () => import('../commands/version.mjs'),
 };