@1agh/maude 0.56.0 → 0.58.0

package/apps/studio/test/sync-presentation.test.ts

@@ -0,0 +1,185 @@
+// The one rule both sync surfaces read — see sync/presentation.ts.
+//
+// Pins the two SURFACE defects that the monitor-level falsifier
+// (`sync-connect-honesty.test.ts`) deliberately leaves alone:
+//   - a link with refusals reading green, because the old status bar keyed off
+//     `state` and never looked at `docs` at all;
+//   - the status bar and the connect note being able to disagree, because they
+//     were two rules over one payload.
+//
+// Every row of the plan's states/copy table gets a case, and each asserts the
+// state names a NEXT ACTION where one exists — the user's explicit ask.
+
+import { describe, expect, test } from 'bun:test';
+
+import { type SyncStatusLike, syncPresentation } from '../sync/presentation.ts';
+
+const base: SyncStatusLike = {
+  state: 'online',
+  queuedOps: 0,
+  lastSyncAt: null,
+  offlineSince: null,
+  flash: null,
+  updatedAt: 0,
+};
+
+const at = (over: SyncStatusLike) =>
+  syncPresentation({ ...base, ...over }, { project: 'alligators' });
+
+describe('nothing to say', () => {
+  test('an unlinked project has no hub status', () => {
+    expect(syncPresentation({ linked: false })).toBeNull();
+    expect(syncPresentation(null)).toBeNull();
+  });
+});
+
+describe('the states a person passes through', () => {
+  test('connecting — no document has settled yet', () => {
+    const p = at({ state: 'connecting', docs: { synced: 0, pending: 3, rejected: 0 } });
+    expect(p?.phase).toBe('connecting');
+    expect(p?.online).toBe(false);
+    expect(p?.title).toContain('Connecting to alligators');
+  });
+
+  test('syncing — visible progress, with a real count', () => {
+    const p = at({ docs: { synced: 40, pending: 35, rejected: 0 } });
+    expect(p?.phase).toBe('syncing');
+    expect(p?.online).toBe(false);
+    expect(p?.label).toBe('40/75');
+    expect(p?.title).toContain('40 of 75');
+  });
+
+  test('synced — and names what arrived, without telling you to open it', () => {
+    const p = at({
+      docs: { synced: 75, pending: 0, rejected: 0 },
+      pulled: { names: ['ui-welcome', 'ui-how-to'], count: 2 },
+    });
+    expect(p?.phase).toBe('synced');
+    expect(p?.online).toBe(true);
+    expect(p?.title).toContain('2 came down');
+    // Names the fact; the decision to open hub-authored TSX stays the person's.
+    expect(p?.next).toContain('new to this machine');
+    expect(p?.next).not.toContain('Open one');
+    expect(p?.names).toEqual(['ui-welcome', 'ui-how-to']);
+  });
+
+  test('synced with nothing pulled has no next action — because there is none', () => {
+    const p = at({ docs: { synced: 5, pending: 0, rejected: 0 } });
+    expect(p?.phase).toBe('synced');
+    expect(p?.next).toBeNull();
+  });
+});
+
+describe('the states that used to read green', () => {
+  test('a hub that refuses everything is not synced', () => {
+    // THE surface defect: `state` is 'online' (a socket exists, the hub is
+    // reachable) while every document's edits go nowhere. The old status bar
+    // showed a green dot and the word "synced" here.
+    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 75 } });
+    expect(p?.phase).toBe('refused');
+    expect(p?.online).toBe(false);
+    expect(p?.label).toBe('75 refused');
+    expect(p?.next).toContain('Reconnect');
+  });
+
+  test('a partial refusal is reported, not averaged away', () => {
+    const p = at({ state: 'online', docs: { synced: 72, pending: 0, rejected: 3 } });
+    expect(p?.phase).toBe('refused');
+    expect(p?.title).toContain('3 of 75');
+  });
+
+  test('an unreachable hub outranks a stale count', () => {
+    const p = at({ state: 'offline', queuedOps: 4, docs: { synced: 75, pending: 0, rejected: 0 } });
+    expect(p?.phase).toBe('offline');
+    expect(p?.online).toBe(false);
+    expect(p?.label).toBe('offline · 4 ↑');
+    expect(p?.next).toContain('resumes by itself');
+  });
+});
+
+describe('payloads that predate the counts', () => {
+  test('an old payload falls back to state without inventing document facts', () => {
+    const p = at({ state: 'online', docs: undefined });
+    expect(p?.phase).toBe('synced');
+    expect(p?.title).not.toContain('canvas');
+  });
+
+  test('a linked project with zero known documents reads as connecting, not synced', () => {
+    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 0 } });
+    expect(p?.phase).toBe('connecting');
+    expect(p?.online).toBe(false);
+  });
+
+  test('nothing syncable keeps its own honest copy and names the move', () => {
+    const p = syncPresentation({ notSyncable: true, tsxCount: 4, reason: 'No canvases yet.' });
+    expect(p?.phase).toBe('nothing-syncable');
+    expect(p?.label).toBe('0 syncable · 4 tsx');
+    expect(p?.next).toContain('Create a canvas');
+  });
+});
+
+describe('a payload it cannot read is not a payload that says everything is fine', () => {
+  // `/_sync-status` returns JSON.parse of `_sync.json` with NO schema, so the
+  // input here is whatever is on disk — a partial write, an older producer, a
+  // newer one. `synced` used to be the fall-through, which made the reassuring
+  // answer the only reachable one for every shape not recognised.
+  test('an empty docs object does not render as "all NaN canvases", green', () => {
+    const p = at({ state: 'online', docs: {} as never });
+    expect(p?.phase).not.toBe('synced');
+    expect(p?.online).toBe(false);
+    expect(p?.title).not.toContain('NaN');
+  });
+
+  test('negative, fractional and non-numeric counts all fail closed', () => {
+    for (const docs of [
+      { synced: 5, pending: -5, rejected: 0 },
+      { synced: 1, pending: null, rejected: 0 },
+      { synced: 1.5, pending: 0, rejected: 0 },
+      { synced: '75', pending: 0, rejected: 0 },
+    ] as never[]) {
+      const p = at({ state: 'online', docs });
+      expect(p?.online).toBe(false);
+      expect(p?.phase).not.toBe('synced');
+    }
+  });
+
+  test('an absent docs field is still the old-payload path, not "unreadable"', () => {
+    // Absent and malformed are different facts and must not collapse.
+    const p = at({ state: 'online', docs: undefined });
+    expect(p?.phase).toBe('synced');
+  });
+
+  test('a wild pulled count cannot reach the sentence', () => {
+    const p = at({
+      docs: { synced: 1, pending: 0, rejected: 0 },
+      pulled: { names: [], count: 1e9 } as never,
+    });
+    expect(p?.title).not.toContain('1000000000');
+  });
+});
+
+describe('hub-supplied text is untrusted (DDR-054)', () => {
+  test('counts come first and names are capped in number', () => {
+    const p = at({
+      state: 'online',
+      docs: { synced: 0, pending: 0, rejected: 9 },
+      rejectedSlugs: ['a', 'b', 'c', 'd', 'e'],
+    });
+    expect(p?.names).toHaveLength(3);
+    // The label a hostile name could otherwise dominate carries no name at all.
+    expect(p?.label).toBe('9 refused');
+  });
+
+  test('a long project name cannot run away with the sentence', () => {
+    const p = syncPresentation(
+      { ...base, docs: { synced: 1, pending: 0, rejected: 0 } },
+      { project: 'x'.repeat(500) }
+    );
+    expect(p?.title.length).toBeLessThan(200);
+  });
+
+  test('names survive being absent or empty', () => {
+    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 2 } });
+    expect(p?.names).toEqual([]);
+  });
+});

package/apps/studio/test/sync-remote-docs.test.ts

@@ -0,0 +1,171 @@
+// The gap between what a project HOLDS and what this machine carries.
+//
+// Regression cover for the reported "Open in Maude does nothing": the desktop
+// synced 72/72 and was accurate about the wrong set — three canvases lived only
+// on the hub and no local counter could ever show it.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  describeRemoteDiff,
+  diffRemoteDocs,
+  fetchRemoteDocs,
+  pullTargets,
+  slugFromDocName,
+} from '../sync/remote-docs.ts';
+
+const okFetch = (documents: unknown) =>
+  (async () =>
+    new Response(JSON.stringify({ documents }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })) as unknown as typeof fetch;
+
+describe('fetchRemoteDocs', () => {
+  test('reads the hub listing', async () => {
+    const docs = await fetchRemoteDocs(
+      'https://hub.example',
+      't',
+      okFetch([{ name: 'ui-welcome', bytes: 2931 }])
+    );
+    expect(docs).toEqual([{ name: 'ui-welcome', bytes: 2931 }]);
+  });
+
+  test('carries the token as a bearer, and strips a trailing slash', async () => {
+    let seenUrl = '';
+    let seenAuth = '';
+    const spy = (async (url: string, init: RequestInit) => {
+      seenUrl = String(url);
+      seenAuth = String((init.headers as Record<string, string>).authorization);
+      return new Response(JSON.stringify({ documents: [] }), { status: 200 });
+    }) as unknown as typeof fetch;
+    await fetchRemoteDocs('https://hub.example/', 'tok123', spy);
+    expect(seenUrl).toBe('https://hub.example/api/documents');
+    expect(seenAuth).toBe('Bearer tok123');
+  });
+
+  test('an unreachable or old hub yields null, never a throw', async () => {
+    // Load-bearing: sync must proceed when the listing cannot be had. A hub
+    // without the route (404) must not degrade into a failed sync.
+    const boom = (async () => {
+      throw new Error('offline');
+    }) as unknown as typeof fetch;
+    expect(await fetchRemoteDocs('https://h', 't', boom)).toBeNull();
+
+    const notFound = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
+    expect(await fetchRemoteDocs('https://h', 't', notFound)).toBeNull();
+
+    const junk = (async () =>
+      new Response(JSON.stringify({ documents: 'not-an-array' }), {
+        status: 200,
+      })) as unknown as typeof fetch;
+    expect(await fetchRemoteDocs('https://h', 't', junk)).toBeNull();
+  });
+});
+
+describe('diffRemoteDocs', () => {
+  test('names the canvases this machine can never receive', () => {
+    // The reported case, in miniature.
+    const diff = diffRemoteDocs(
+      ['ui-home', 'ui-about'],
+      [
+        { name: 'ui-home', bytes: 1 },
+        { name: 'ui-about', bytes: 1 },
+        { name: 'ui-welcome', bytes: 2931 },
+      ]
+    );
+    expect(diff.shared).toEqual(['ui-about', 'ui-home']);
+    expect(diff.hubOnly.map((d) => d.name)).toEqual(['ui-welcome']);
+    expect(diff.localOnly).toEqual([]);
+    expect(diff.reachable).toBe(true);
+  });
+
+  test('a canvas created here but not yet pushed is localOnly, not a gap', () => {
+    const diff = diffRemoteDocs(['ui-new'], []);
+    expect(diff.localOnly).toEqual(['ui-new']);
+    expect(diff.hubOnly).toEqual([]);
+  });
+
+  test('an unreachable hub reports NOT reachable rather than a false gap', () => {
+    // Reporting every local canvas as "hub-only missing" would be worse than
+    // saying nothing — it would invent an alarm out of a network blip.
+    const diff = diffRemoteDocs(['ui-home'], null);
+    expect(diff.reachable).toBe(false);
+    expect(diff.hubOnly).toEqual([]);
+  });
+
+  test('compares WIRE names — a namespaced hub vs flat local is a real mismatch', () => {
+    // If a caller passed raw slugs against a namespaced hub, everything would
+    // look missing on both sides. The diff reports exactly that rather than
+    // papering over it, because it IS the doc-identity bug (DDR-192 §5).
+    const diff = diffRemoteDocs(['ui-home'], [{ name: 'ws/acme/main/ui-home', bytes: 1 }]);
+    expect(diff.shared).toEqual([]);
+    expect(diff.hubOnly.map((d) => d.name)).toEqual(['ws/acme/main/ui-home']);
+    expect(diff.localOnly).toEqual(['ui-home']);
+  });
+});
+
+describe('describeRemoteDiff', () => {
+  test('says what is missing, with names', () => {
+    const msg = describeRemoteDiff(
+      diffRemoteDocs(
+        [],
+        [
+          { name: 'ui-welcome', bytes: 1 },
+          { name: 'ui-how_to_use_maude', bytes: 1 },
+        ]
+      )
+    );
+    expect(msg).toContain('2 canvases');
+    expect(msg).toContain('ui-welcome');
+  });
+
+  test('stays quiet when there is nothing to report', () => {
+    expect(describeRemoteDiff(diffRemoteDocs(['a'], [{ name: 'a', bytes: 1 }]))).toBeNull();
+    expect(describeRemoteDiff(diffRemoteDocs(['a'], null))).toBeNull();
+  });
+});
+
+describe('pulling hub-only documents down', () => {
+  const join = (...p: string[]) => p.join('/');
+  const resolve = (p: string) => p.replace(/\/\.\//g, '/');
+
+  test('maps a flat and a namespaced doc name to the same slug', () => {
+    expect(slugFromDocName('ui-welcome')).toBe('ui-welcome');
+    expect(slugFromDocName('ws/acme/main/ui-welcome')).toBe('ui-welcome');
+  });
+
+  test('lands hub-only canvases flat under the design root', () => {
+    const targets = pullTargets(
+      [
+        { name: 'ui-welcome', bytes: 1 },
+        { name: 'ws/acme/main/ui-home', bytes: 1 },
+      ],
+      '/p/.design',
+      join,
+      resolve,
+      '/'
+    );
+    expect(targets.map((t) => t.bodyAbs)).toEqual([
+      '/p/.design/ui-welcome.tsx',
+      '/p/.design/ui-home.tsx',
+    ]);
+    // The wire name is kept — the provider must open the document the HUB has,
+    // not a name re-derived from the local path.
+    expect(targets[1].docName).toBe('ws/acme/main/ui-home');
+  });
+
+  test('a document NAME can never write outside the design root', () => {
+    // Hub-controlled input, last point before a create. Dots are refused
+    // outright, so traversal cannot even form a candidate path.
+    const evil = [
+      { name: '../../etc/passwd', bytes: 1 },
+      { name: '..', bytes: 1 },
+      { name: 'ui/../../escape', bytes: 1 },
+      { name: 'a b', bytes: 1 },
+      { name: '', bytes: 1 },
+      { name: 'x'.repeat(500), bytes: 1 },
+    ];
+    expect(pullTargets(evil, '/p/.design', join, resolve, '/')).toEqual([]);
+  });
+});

package/apps/studio/test/whats-new.test.ts

@@ -23,8 +23,20 @@ describe('whats-new feed loader', () => {
     }
   });
 
-  test('resolveMaudeVersion reads the design plugin manifest', () => {
+  test('resolveMaudeVersion resolves a real release version', () => {
     expect(resolveMaudeVersion()).toMatch(/^\d+\.\d+\.\d+/);
+    // The studio's own manifest is preferred over the design plugin's (it is
+    // the one staged into the cell image), and `0.0.0` — the placeholder both
+    // carried before joining the release line — is never an answer.
+    expect(resolveMaudeVersion()).not.toBe('0.0.0');
+  });
+
+  test('an unversioned root falls through rather than reporting the placeholder', () => {
+    const root = mkdtempSync(join(tmpdir(), 'maude-ver-'));
+    writeFileSync(join(root, 'package.json'), JSON.stringify({ version: '0.0.0' }));
+    // No plugin manifest above a tmpdir either, so this lands on `dev` — a
+    // value obviously not a release, rather than a plausible wrong number.
+    expect(resolveMaudeVersion(root)).toBe('dev');
   });
 
   test('a missing feed dir yields empty entries and never throws', () => {

package/apps/studio/whats-new.json

@@ -1,6 +1,33 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "release-version-visible",
+      "version": "0.58.0",
+      "date": "2026-08-07",
+      "kind": "improvement",
+      "title": "See which version of Maude you are running",
+      "summary": "The Studio status bar now shows the running version, and the hub admin header shows it beside the bundle hash — so you can tell what you are on without digging. In the cloud it is the same chip, because the cloud serves the same Studio.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "cloud-connect-tells-you-what-happened",
+      "version": "0.57.0",
+      "date": "2026-08-07",
+      "kind": "fix",
+      "title": "Connecting a cloud project tells you what happened",
+      "summary": "The line you see after Connect is now live and true: it moves from Connecting, through Syncing 40 of 75, to Synced — and names any canvases that came down from the project. Every outcome says what to do next, so a refused connection tells you to reconnect instead of sitting on “syncing” forever.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "acp-turn-notifications",
+      "version": "0.57.0",
+      "date": "2026-08-07",
+      "kind": "feature",
+      "title": "Get notified when a background chat finishes",
+      "summary": "Maude now sends a real notification when a chat finishes or needs your input — even in a project you're not currently viewing. The notification never shows what was said, only which project needs you.",
+      "surface": "design-ui"
+    },
     {
       "id": "cloud-projects-save-themselves",
       "version": "0.56.0",

package/apps/studio/whats-new.ts

@@ -43,18 +43,42 @@ export interface WhatsNewFeed {
 let cache: WhatsNewFeed | null = null;
 
 /**
- * Read the installed maude version from the design plugin manifest.
- * `apps/studio/` → `plugins/design/.claude-plugin/plugin.json`.
- * That manifest ships in BOTH npm installs and marketplace-cache clones
- * (same rationale as build.ts `readPluginVersion`). Falls back to `dev`.
+ * Read the installed maude version.
+ *
+ * THE ONE resolution path (DDR-045: disk paths come from `paths.ts`). Everything
+ * that wants to name the running version — the What's New feed, `/_config`, the
+ * status-bar chip — calls this rather than growing a second answer that can
+ * disagree with the first.
+ *
+ * Two sources, in order:
+ *
+ *   1. the studio's OWN `package.json`. It rides the release line since the
+ *      fleet-verification change, and it is the only one of the two that is
+ *      staged into the cell image — a cloud tab asking "which version am I on"
+ *      gets an answer rather than `dev`.
+ *   2. `plugins/design/.claude-plugin/plugin.json`, which ships in BOTH npm
+ *      installs and marketplace-cache clones (same rationale as build.ts
+ *      `readPluginVersion`). Kept as the fallback so an older layout that lacks
+ *      a version-stamped studio manifest still resolves.
+ *
+ * Falls back to `dev` — a placeholder that is obviously not a release, never a
+ * plausible-looking wrong number.
  */
 export function resolveMaudeVersion(root: string = DEV_SERVER_ROOT): string {
-  const manifest = join(root, '..', '..', 'plugins', 'design', '.claude-plugin', 'plugin.json');
-  try {
-    const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { version?: unknown };
-    if (typeof parsed.version === 'string') return parsed.version;
-  } catch {
-    /* fall through */
+  const candidates = [
+    join(root, 'package.json'),
+    join(root, '..', '..', 'plugins', 'design', '.claude-plugin', 'plugin.json'),
+  ];
+  for (const manifest of candidates) {
+    try {
+      const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { version?: unknown };
+      // `0.0.0` is the private-workspace placeholder these manifests carried
+      // before they joined the release line. Treating it as an answer is how
+      // `/health` came to report `0.0.0` for months.
+      if (typeof parsed.version === 'string' && parsed.version !== '0.0.0') return parsed.version;
+    } catch {
+      /* try the next one */
+    }
   }
   return 'dev';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.56.0",
+  "version": "0.58.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": {
@@ -54,13 +54,13 @@
     "test:e2e:desktop:parity:cloud": "pnpm --filter @maude/desktop-e2e e2e:parity:cloud"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.56.0",
-    "@1agh/maude-darwin-x64": "0.56.0",
-    "@1agh/maude-linux-arm64": "0.56.0",
-    "@1agh/maude-linux-arm64-musl": "0.56.0",
-    "@1agh/maude-linux-x64": "0.56.0",
-    "@1agh/maude-linux-x64-musl": "0.56.0",
-    "@1agh/maude-win32-x64": "0.56.0"
+    "@1agh/maude-darwin-arm64": "0.58.0",
+    "@1agh/maude-darwin-x64": "0.58.0",
+    "@1agh/maude-linux-arm64": "0.58.0",
+    "@1agh/maude-linux-arm64-musl": "0.58.0",
+    "@1agh/maude-linux-x64": "0.58.0",
+    "@1agh/maude-linux-x64-musl": "0.58.0",
+    "@1agh/maude-win32-x64": "0.58.0"
   },
   "files": [
     "cli",